6835892098

Committed 11 Nov 2023 06:26PM UTC coverage: 97.394% (-2.6%) from 100.0%

Build # 6835892098

Build Type

push

github

Committed by

unadlib

Commit Message

test(test): update immer test cases

Run Details

649 of 671 branches covered (0.0%)

Branch coverage included in aggregate %.

94 of 111 new or added lines in 2 files covered. (84.68%)

4 existing lines in 2 files now uncovered.

958 of 979 relevant lines covered (97.85%)

1416.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.83

/test/immer/src/immer.ts

import { rawReturn, create, isDraft, isDraftable, apply } from '../../../src';
import { getType as getArchtype, forEach as each } from '../../../src/utils';

export { forEach as each } from '../../../src/utils';

let enableAutoFreeze = true;

let strict = false;

export const setUseStrictShallowCopy = (value: boolean) => {
  strict = value;
};

export const assert = () => {};

export const produce = (base: any, recipe: any, patchListener: any) => {
  if (patchListener) {
    const [state, patches, inversePatches] = create(base, recipe, {
      enableAutoFreeze,
      enablePatches: true,
      mark: (target) => {
        if (
          target &&
          (target[immerable] ||
            Object.getPrototypeOf(target)?.constructor[immerable])
        ) {
          return 'immutable';
        }
        if (strict) {
          return 'immutable';
        }
      },
    });
    patchListener(patches, inversePatches);
    return state;
  }
  return create(base, recipe, {
    enableAutoFreeze,
    mark: (target) => {
      if (
        target &&
        (target[immerable] ||
          Object.getPrototypeOf(target)?.constructor[immerable])
      ) {
        return 'immutable';
      }
      if (strict) {
        return 'immutable';
      }
    },
  });
};

export class Immer {
  constructor(config: any) {
    setAutoFreeze(config?.autoFreeze ?? true);
  }

  produce(base: any, recipe: any, patchListener: any) {
    return produce(base, recipe, patchListener);
  }

  produceWithPatches(base: any, recipe: any) {
    return produceWithPatches(base, recipe);
  }
}

export const immerable = Symbol.for('immerable');

export const nothing = rawReturn(undefined);

export {
  original,
  isDraft,
  type Draft,
  isDraftable,
  type Immutable,
  castImmutable,
  current,
  castDraft,
} from '../../../src';

export const applyPatches = (base: any, patches: any) =>
  apply(base, patches);

export const enablePatches = () => {};

export const enableMapSet = () => {};

export const setAutoFreeze = (value: boolean) => {
  enableAutoFreeze = value;
};

export const produceWithPatches = (base: any, recipe: any) => {
  if (recipe === undefined) {
    return create(base, {
      enablePatches: true,
      enableAutoFreeze,
      mark: (target) => {
        if (
          target &&
          (target[immerable] ||
            Object.getPrototypeOf(target)?.constructor[immerable])
        ) {
          return 'immutable';
        }
        if (strict) {
          return 'immutable';
        }
      },
    });
  }
  return create(base, recipe, {
    enablePatches: true,
    enableAutoFreeze,
    mark: (target) => {
      if (
        target &&
        (target[immerable] ||
          Object.getPrototypeOf(target)?.constructor[immerable])
      ) {
        return 'immutable';
      }
      if (strict) {
        return 'immutable';
      }
    },
  });
};

export function freeze<T>(obj: any, deep: boolean = false): T {
  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
  if (getArchtype(obj) > 1 /* Map or Set */) {
    obj.set =
      obj.add =
      obj.clear =
      obj.delete =
        dontMutateFrozenCollections as any;
  }
  Object.freeze(obj);
  if (deep) each(obj, (_key, value) => freeze(value, true));
  return obj;
}

function dontMutateFrozenCollections() {
  throw new Error('This object has been frozen and should not be mutated');
}

function isFrozen(obj: any): boolean {
  return Object.isFrozen(obj);
}

export const DRAFT_STATE = Symbol.for('immer-state');

export function isMap(target: any) {
  return target instanceof Map;
}

export function isSet(target: any) {
  return target instanceof Set;
}

const objectCtorString = Object.prototype.constructor.toString();

export function isPlainObject(value: any): boolean {
  if (!value || typeof value !== 'object') return false;
  const proto = Object.getPrototypeOf(value);
  if (proto === null) {
    return true;
  }
  const Ctor =
    Object.hasOwnProperty.call(proto, 'constructor') && proto.constructor;

  if (Ctor === Object) return true;

  return (
    typeof Ctor === 'function' &&
    Function.toString.call(Ctor) === objectCtorString
  );
}

export function shallowCopy(base: any, strict: boolean) {
  if (isMap(base)) {
    return new Map(base);
  }
  if (isSet(base)) {
    return new Set(base);
  }
  if (Array.isArray(base)) return Array.prototype.slice.call(base);

  if (!strict && isPlainObject(base)) {
    if (!Object.getPrototypeOf(base)) {
      const obj = Object.create(null);
      return Object.assign(obj, base);
    }
    return { ...base };
  }

  const descriptors = Object.getOwnPropertyDescriptors(base);
  delete descriptors[DRAFT_STATE as any];
  let keys = Reflect.ownKeys(descriptors);
  for (let i = 0; i < keys.length; i++) {
    const key: any = keys[i];
    const desc = descriptors[key];
    if (desc.writable === false) {
      desc.writable = true;
      desc.configurable = true;
    }
    // like object.assign, we will read any _own_, get/set accessors. This helps in dealing
    // with libraries that trap values, like mobx or vue
    // unlike object.assign, non-enumerables will be copied as well
    if (desc.get || desc.set)
      descriptors[key] = {
        configurable: true,
        writable: true, // could live with !!desc.set as well here...
        enumerable: desc.enumerable,
        value: base[key],
      };
  }
  return Object.create(Object.getPrototypeOf(base), descriptors);
}

export const createDraft = (state: any) => {
  const [draft, finishDraft] = create(state, {
    enablePatches: true,
    enableAutoFreeze,
    mark: (target) => {
      if (
        target &&
        (target[immerable] ||
          Object.getPrototypeOf(target)?.constructor[immerable])
      ) {
        return 'immutable';
      }
      if (strict) {
        return 'immutable';
      }
    },
  });
  return [
    draft,
    (a: any, b: any) => {
      const state = finishDraft();
      if (b) {
        b(state[1], state[2]);
      }
      return state[0];
    },
  ];
};

1	import { rawReturn, create, isDraft, isDraftable, apply } from '../../../src';	19✔
2	import { getType as getArchtype, forEach as each } from '../../../src/utils';	19✔
3
4	export { forEach as each } from '../../../src/utils';	35✔
5
6	let enableAutoFreeze = true;	19✔
7
8	let strict = false;	19✔
9
10	export const setUseStrictShallowCopy = (value: boolean) => {	19✔
11	strict = value;	2✔
12	};
13
14	export const assert = () => {};	19✔
15
16	export const produce = (base: any, recipe: any, patchListener: any) => {	19✔
17	if (patchListener) {	2,276✔
18	const [state, patches, inversePatches] = create(base, recipe, {	1,033✔
19	enableAutoFreeze,
20	enablePatches: true,
21	mark: (target) => {
22	if (	4,566✔
23	target &&	12,688✔
24	(target[immerable] \|\|
25	Object.getPrototypeOf(target)?.constructor[immerable])	11,811!
26	) {
27	return 'immutable';	264✔
28	}
29	if (strict) {	4,302!
NEW 30	return 'immutable';	×
31	}
32	},
33	});
34	patchListener(patches, inversePatches);	983✔
35	return state;	982✔
36	}
37	return create(base, recipe, {	1,243✔
38	enableAutoFreeze,
39	mark: (target) => {
40	if (	4,765✔
41	target &&	13,173✔
42	(target[immerable] \|\|
43	Object.getPrototypeOf(target)?.constructor[immerable])	12,171!
44	) {
45	return 'immutable';	318✔
46	}
47	if (strict) {	4,447✔
48	return 'immutable';	2✔
49	}
50	},
51	});
52	};
53
54	export class Immer {	19✔
55	constructor(config: any) {
56	setAutoFreeze(config?.autoFreeze ?? true);	16✔
57	}
58
59	produce(base: any, recipe: any, patchListener: any) {
60	return produce(base, recipe, patchListener);	2,059✔
61	}
62
63	produceWithPatches(base: any, recipe: any) {
64	return produceWithPatches(base, recipe);	36✔
65	}
66	}
67
68	export const immerable = Symbol.for('immerable');	19✔
69
70	export const nothing = rawReturn(undefined);	19✔
71
72	export {	19✔
73	original,	55✔
74	isDraft,	134✔
75	type Draft,
76	isDraftable,	20✔
77	type Immutable,
78	castImmutable,	21✔
79	current,	39✔
80	castDraft,	20✔
81	} from '../../../src';
82
83	export const applyPatches = (base: any, patches: any) =>	19✔
84	apply(base, patches);	157✔
85
86	export const enablePatches = () => {};	19✔
87
88	export const enableMapSet = () => {};	19✔
89
90	export const setAutoFreeze = (value: boolean) => {	19✔
91	enableAutoFreeze = value;	35✔
92	};
93
94	export const produceWithPatches = (base: any, recipe: any) => {	19✔
95	if (recipe === undefined) {	57✔
96	return create(base, {	1✔
97	enablePatches: true,
98	enableAutoFreeze,
99	mark: (target) => {
100	if (	3!
101	target &&	9✔
102	(target[immerable] \|\|
103	Object.getPrototypeOf(target)?.constructor[immerable])	9!
104	) {
NEW 105	return 'immutable';	×
106	}
107	if (strict) {	3!
NEW 108	return 'immutable';	×
109	}
110	},
111	});
112	}
113	return create(base, recipe, {	56✔
114	enablePatches: true,
115	enableAutoFreeze,
116	mark: (target) => {
117	if (	521!
118	target &&	1,425✔
119	(target[immerable] \|\|
120	Object.getPrototypeOf(target)?.constructor[immerable])	1,356!
121	) {
NEW 122	return 'immutable';	×
123	}
124	if (strict) {	521!
NEW 125	return 'immutable';	×
126	}
127	},
128	});
129	};
130
131	export function freeze<T>(obj: any, deep: boolean = false): T {	19✔
132	if (isFrozen(obj) \|\| isDraft(obj) \|\| !isDraftable(obj)) return obj;	5✔
133	if (getArchtype(obj) > 1 /* Map or Set */) {	4!
NEW 134	obj.set =	×
135	obj.add =
136	obj.clear =
137	obj.delete =
138	dontMutateFrozenCollections as any;
139	}
140	Object.freeze(obj);	4✔
141	if (deep) each(obj, (_key, value) => freeze(value, true));	4✔
142	return obj;	4✔
143	}
144
145	function dontMutateFrozenCollections() {
NEW 146	throw new Error('This object has been frozen and should not be mutated');	×
147	}
148
149	function isFrozen(obj: any): boolean {
150	return Object.isFrozen(obj);	5✔
151	}
152
153	export const DRAFT_STATE = Symbol.for('immer-state');	19✔
154
155	export function isMap(target: any) {	19✔
156	return target instanceof Map;	120✔
157	}
158
159	export function isSet(target: any) {	19✔
160	return target instanceof Set;	120✔
161	}
162
163	const objectCtorString = Object.prototype.constructor.toString();	19✔
164
165	export function isPlainObject(value: any): boolean {	19✔
166	if (!value \|\| typeof value !== 'object') return false;	24!
167	const proto = Object.getPrototypeOf(value);	24✔
168	if (proto === null) {	24!
NEW 169	return true;	×
170	}
171	const Ctor =
172	Object.hasOwnProperty.call(proto, 'constructor') && proto.constructor;	24✔
173
174	if (Ctor === Object) return true;	24✔
175
176	return (	8✔
177	typeof Ctor === 'function' &&	16✔
178	Function.toString.call(Ctor) === objectCtorString
179	);
180	}
181
182	export function shallowCopy(base: any, strict: boolean) {	19✔
183	if (isMap(base)) {	120!
NEW 184	return new Map(base);	×
185	}
186	if (isSet(base)) {	120!
NEW 187	return new Set(base);	×
188	}
189	if (Array.isArray(base)) return Array.prototype.slice.call(base);	120✔
190
191	if (!strict && isPlainObject(base)) {	72✔
192	if (!Object.getPrototypeOf(base)) {	16!
NEW 193	const obj = Object.create(null);	×
NEW 194	return Object.assign(obj, base);	×
195	}
196	return { ...base };	16✔
197	}
198
199	const descriptors = Object.getOwnPropertyDescriptors(base);	56✔
200	delete descriptors[DRAFT_STATE as any];	56✔
201	let keys = Reflect.ownKeys(descriptors);	56✔
202	for (let i = 0; i < keys.length; i++) {	56✔
203	const key: any = keys[i];	80✔
204	const desc = descriptors[key];	80✔
205	if (desc.writable === false) {	80!
NEW 206	desc.writable = true;	×
NEW 207	desc.configurable = true;	×
208	}
209	// like object.assign, we will read any _own_, get/set accessors. This helps in dealing
210	// with libraries that trap values, like mobx or vue
211	// unlike object.assign, non-enumerables will be copied as well
212	if (desc.get \|\| desc.set)	80!
NEW 213	descriptors[key] = {	×
214	configurable: true,
215	writable: true, // could live with !!desc.set as well here...
216	enumerable: desc.enumerable,
217	value: base[key],
218	};
219	}
220	return Object.create(Object.getPrototypeOf(base), descriptors);	56✔
221	}
222
223	export const createDraft = (state: any) => {	19✔
224	const [draft, finishDraft] = create(state, {	11✔
225	enablePatches: true,
226	enableAutoFreeze,
227	mark: (target) => {
228	if (	31!
229	target &&	91✔
230	(target[immerable] \|\|
231	Object.getPrototypeOf(target)?.constructor[immerable])	90!
232	) {
NEW 233	return 'immutable';	×
234	}
235	if (strict) {	31!
NEW 236	return 'immutable';	×
237	}
238	},
239	});
240	return [	9✔
241	draft,
242	(a: any, b: any) => {
243	const state = finishDraft();	11✔
244	if (b) {	9✔
245	b(state[1], state[2]);	1✔
246	}
247	return state[0];	9✔
248	},
249	];
250	};

unadlib / mutative / 6835892098

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous