@slimlib/smart-mock 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.cjs +319 -324
  2. package/dist/index.d.ts +16 -0
  3. package/dist/index.mjs +319 -324
  4. package/package.json +1 -1
package/dist/index.cjs CHANGED
@@ -1,329 +1,324 @@
1
1
  'use strict';
2
2
 
3
- const mock = Symbol();
4
- const unwrap = Symbol();
5
- const unwrapValue = (value) => (value != null && value[unwrap]) || value;
6
- const getMockData = (value) => (value != null && value[mock]) || undefined;
7
- function createRecordingMockFactory() {
8
- const mockDatas = [];
9
- let counter = 0;
10
- return {
11
- createMock,
12
- generateGlobals,
13
- generate
14
- };
15
- function createMock(object, name) {
16
- return createInternalMock(object, {
17
- name,
18
- source: 0 /* MockDataSource.root */,
19
- useCount: 0,
20
- generated: false
21
- });
22
- }
23
- function generateGlobals() {
24
- const strings = [];
25
- for (const mockData of mockDatas) {
26
- if (mockData.generated)
27
- continue;
28
- if (!mockData.instanceName && mockData.source !== 0 /* MockDataSource.root */) {
29
- mockData.instanceName = getNextInstanceName();
30
- }
31
- const identifier = (mockData?.instanceName ?? mockData?.name);
32
- if (mockData.source !== 0 /* MockDataSource.root */) {
33
- strings.push('const ' + identifier + ' = ' + getAccessor(mockData, mockData.parent));
34
- }
35
- for (const effect of (mockData.sideEffects || [])) {
36
- switch (effect.source) {
37
- case 3 /* MockDataSource.set */:
38
- strings.push(identifier + '.' + effect.name + ' = ' + stringify(effect.options, replacer));
39
- break;
40
- // case MockDataSource.defineProperty:
41
- // strings.push('Object.defineProperty(' + identifier + ', "' + (effect.name as string) + '", ' + stringify(effect.options, replacer as ReplacerFunction) + ')');
42
- // break;
43
- case 5 /* MockDataSource.deleteProperty */:
44
- strings.push('delete ' + identifier + '["' + effect.name + '"]');
45
- break;
46
- case 6 /* MockDataSource.setPrototypeOf */:
47
- strings.push('Object.setPrototypeOf(' + identifier + ', ' + stringify(effect.options, replacer) + ')');
48
- break;
49
- case 7 /* MockDataSource.preventExtensions */:
50
- strings.push('Object.preventExtensions(' + identifier + ')');
51
- break;
52
- case 2 /* MockDataSource.call */:
53
- strings.push(identifier + getParameters(effect.options, replacer));
54
- break;
55
- }
56
- }
57
- }
58
- return strings.join('\n');
59
- function getAccessor(mockData, parent) {
60
- const parentName = (parent?.instanceName ?? parent?.name);
61
- switch (mockData.source) {
62
- case 2 /* MockDataSource.call */:
63
- return parentName + getParameters(mockData.options, replacer);
64
- case 1 /* MockDataSource.get */:
65
- return parentName + '.' + mockData.name;
66
- case 8 /* MockDataSource.construct */:
67
- {
68
- const newTarget = stringify(mockData.target, replacer);
69
- return parentName !== newTarget
70
- ? 'Reflect.construct(' + parentName + ',' + stringify(mockData.options, replacer) + ',' + newTarget + ')'
71
- : 'new ' + parentName + getParameters(mockData.options, replacer);
72
- }
73
- }
74
- }
75
- }
76
- function generate(object) {
77
- stringify(object, bumpReplacer);
78
- return stringify(object, replacer);
79
- }
80
- function bumpReplacer(value) {
81
- const mockData = getMockData(value);
82
- if (mockData) {
83
- ++mockData.useCount;
84
- return getCode(mockData, bumpReplacer, true);
85
- }
86
- return value;
87
- }
88
- function replacer(value) {
89
- const mockData = getMockData(value);
90
- if (mockData) {
91
- return getCode(mockData, replacer, true);
92
- }
93
- return value;
94
- }
95
- function getCode(value, replacer, bumpCount) {
96
- if (bumpCount && value.useCount > 1) {
97
- if (value.source === 0 /* MockDataSource.root */) {
98
- return value.name;
99
- }
100
- if (!value.instanceName) {
101
- value.instanceName = getNextInstanceName();
102
- }
103
- return value.instanceName;
104
- }
105
- value.generated = true;
106
- switch (value.source) {
107
- case 2 /* MockDataSource.call */:
108
- return getCallCode(value.parent, value);
109
- case 1 /* MockDataSource.get */:
110
- return getPrevCode(value) + '.' + value.name;
111
- case 0 /* MockDataSource.root */:
112
- return value.name;
113
- case 8 /* MockDataSource.construct */:
114
- {
115
- const prevCode = getPrevCode(value);
116
- const newTarget = stringify(value.target, replacer);
117
- return prevCode !== newTarget
118
- ? 'Reflect.construct(' + prevCode + ',' + stringify(value.options, replacer) + ',' + newTarget + ')'
119
- : 'new ' + prevCode + getParameters(value.options, replacer);
120
- }
121
- }
122
- function getCallCode(parent, value) {
123
- parent.generated = true;
124
- const prevCode = getPrevCode(parent);
125
- return prevCode + (prevCode ? '.' : '') + parent.name + getParameters(value.options, replacer);
126
- }
127
- function getPrevCode(mockData) {
128
- return mockData.parent ? getCode(mockData.parent, replacer, bumpCount) : '';
129
- }
130
- }
131
- function createInternalMock(target, mockData) {
132
- mockDatas.push(mockData);
133
- target[mock] = mockData;
134
- return new Proxy(target, {
135
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
136
- set(target, p, value, receiver) {
137
- const realValue = unwrapValue(value);
138
- if (!mockData.sideEffects) {
139
- mockData.sideEffects = [];
140
- }
141
- mockData.sideEffects.push({
142
- useCount: 0,
143
- name: p,
144
- options: realValue,
145
- parent: mockData,
146
- source: 3 /* MockDataSource.set */,
147
- generated: false
148
- });
149
- ++mockData.useCount;
150
- Reflect.set(target, p, realValue, receiver);
151
- return true;
152
- },
153
- get(target, p) {
154
- if (p === unwrap)
155
- return target;
156
- if (p === mock)
157
- return mockData;
158
- const value = Reflect.get(target, p);
159
- if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
160
- return value;
161
- }
162
- if (!mockData.mocks) {
163
- mockData.mocks = Object.create(null);
164
- }
165
- if (!mockData.mocks[p]) {
166
- mockData.mocks[p] = createInternalMock(value, {
167
- useCount: 0,
168
- name: p,
169
- parent: mockData,
170
- source: 1 /* MockDataSource.get */,
171
- generated: false
172
- });
173
- }
174
- const result = mockData.mocks[p];
175
- ++mockData.useCount;
176
- return result;
177
- },
178
- // eslint-disable-next-line @typescript-eslint/ban-types
179
- construct(target, argArray, newTarget) {
180
- const realTarget = unwrapValue(newTarget);
181
- const realArguments = unwrapValue(argArray);
182
- ++mockData.useCount;
183
- const result = Reflect.construct(target, realArguments, realTarget);
184
- return createInternalMock(result, {
185
- useCount: 0,
186
- name: '',
187
- options: realArguments,
188
- target: realTarget,
189
- parent: mockData,
190
- source: 8 /* MockDataSource.construct */,
191
- generated: false
192
- });
193
- },
194
- defineProperty(target, property, attributes) {
195
- const realValue = unwrapValue(attributes);
196
- // if (!mockData.sideEffects) {
197
- // mockData.sideEffects = [];
198
- // }
199
- // mockData.sideEffects.push({
200
- // useCount: 0,
201
- // name: property,
202
- // options: realValue,
203
- // parent: mockData,
204
- // source: MockDataSource.defineProperty,
205
- // generated: false
206
- // });
207
- // ++mockData.useCount;
208
- return Reflect.defineProperty(target, property, realValue);
209
- },
210
- deleteProperty(target, p) {
211
- if (!mockData.sideEffects) {
212
- mockData.sideEffects = [];
213
- }
214
- mockData.sideEffects.push({
215
- useCount: 0,
216
- name: p,
217
- options: undefined,
218
- parent: mockData,
219
- source: 5 /* MockDataSource.deleteProperty */,
220
- generated: false
221
- });
222
- ++mockData.useCount;
223
- const result = Reflect.deleteProperty(target, p);
224
- return result;
225
- },
226
- setPrototypeOf(target, v) {
227
- const realValue = unwrapValue(v);
228
- if (!mockData.sideEffects) {
229
- mockData.sideEffects = [];
230
- }
231
- mockData.sideEffects.push({
232
- useCount: 0,
233
- name: '',
234
- options: realValue,
235
- parent: mockData,
236
- source: 6 /* MockDataSource.setPrototypeOf */,
237
- generated: false
238
- });
239
- ++mockData.useCount;
240
- return Reflect.setPrototypeOf(target, realValue);
241
- },
242
- preventExtensions(target) {
243
- if (!mockData.sideEffects) {
244
- mockData.sideEffects = [];
245
- }
246
- mockData.sideEffects.push({
247
- useCount: 0,
248
- name: '',
249
- options: undefined,
250
- parent: mockData,
251
- source: 7 /* MockDataSource.preventExtensions */,
252
- generated: false
253
- });
254
- ++mockData.useCount;
255
- return Reflect.preventExtensions(target);
256
- },
257
- apply(target, thisArg, argumentsList) {
258
- const realThis = unwrapValue(thisArg);
259
- const realArguments = unwrapValue(argumentsList);
260
- ++mockData.useCount;
261
- const result = Reflect.apply(target, realThis, realArguments);
262
- if (result === null || (typeof result !== 'object' && typeof result !== 'function')) {
263
- if (!mockData.sideEffects) {
264
- mockData.sideEffects = [];
265
- }
266
- mockData.sideEffects.push({
267
- useCount: 0,
268
- name: '',
269
- parent: mockData,
270
- source: 2 /* MockDataSource.call */,
271
- options: realArguments,
272
- generated: false
273
- });
274
- ++mockData.useCount;
275
- return result;
276
- }
277
- return createInternalMock(result, {
278
- useCount: 0,
279
- name: '',
280
- parent: mockData,
281
- source: 2 /* MockDataSource.call */,
282
- options: realArguments,
283
- generated: false
284
- });
285
- }
286
- });
287
- }
288
- function getNextInstanceName() {
289
- return `tmp_${counter++}`;
290
- }
291
- }
292
- function getParameters(options, replacer) {
293
- return `(${options.length ? options.map(value => stringify(value, replacer)).join(',') : ''})`;
294
- }
295
- // stringify like functionality, recursively walks through objects and converts them to strings but leaved some basic values intact
296
- function stringify(value, replacer) {
297
- const original = value;
298
- value = replacer(value);
299
- if (original !== value && typeof value === 'string') {
300
- return value;
301
- }
302
- if (value === null) {
303
- return null;
304
- }
305
- if (value === undefined) {
306
- return undefined;
307
- }
308
- if (typeof value === 'number') {
309
- return `${value}`;
310
- }
311
- if (Array.isArray(value)) {
312
- return `[${value.map((v) => stringify(v, replacer)).join(',')}]`;
313
- }
314
- if (typeof value === 'boolean') {
315
- return value;
316
- }
317
- if (typeof value === 'function') {
318
- return value.toString();
319
- }
320
- if (value instanceof RegExp) {
321
- return value;
322
- }
323
- if (typeof value === 'object') {
324
- return `{${Object.entries(value).map(([k, v]) => k + ':' + stringify(v, replacer)).join(',')}}`;
325
- }
326
- return '"' + String(value) + '"';
3
+ const mock = Symbol();
4
+ const unwrap = Symbol();
5
+ const unwrapValue = (value) => (value != null && value[unwrap]) || value;
6
+ const getMockData = (value) => (value != null && value[mock]) || undefined;
7
+ function createRecordingMockFactory() {
8
+ const mockDatas = [];
9
+ let counter = 0;
10
+ return {
11
+ createMock,
12
+ generateGlobals,
13
+ generate
14
+ };
15
+ function createMock(object, name) {
16
+ return createInternalMock(object, {
17
+ name,
18
+ source: 0 /* MockDataSource.root */,
19
+ useCount: 0,
20
+ generated: false
21
+ });
22
+ }
23
+ function generateGlobals() {
24
+ const strings = [];
25
+ for (const mockData of mockDatas) {
26
+ if (mockData.generated)
27
+ continue;
28
+ if (!mockData.instanceName && mockData.source !== 0 /* MockDataSource.root */) {
29
+ mockData.instanceName = getNextInstanceName();
30
+ }
31
+ const identifier = (mockData?.instanceName ?? mockData?.name);
32
+ if (mockData.source !== 0 /* MockDataSource.root */) {
33
+ strings.push('const ' + identifier + ' = ' + getAccessor(mockData, mockData.parent));
34
+ }
35
+ for (const effect of (mockData.sideEffects || [])) {
36
+ switch (effect.source) {
37
+ case 3 /* MockDataSource.set */:
38
+ strings.push(identifier + '.' + effect.name + ' = ' + stringify(effect.options, replacer));
39
+ break;
40
+ // case MockDataSource.defineProperty:
41
+ // strings.push('Object.defineProperty(' + identifier + ', "' + (effect.name as string) + '", ' + stringify(effect.options, replacer as ReplacerFunction) + ')');
42
+ // break;
43
+ case 5 /* MockDataSource.deleteProperty */:
44
+ strings.push('delete ' + identifier + '["' + effect.name + '"]');
45
+ break;
46
+ case 6 /* MockDataSource.setPrototypeOf */:
47
+ strings.push('Object.setPrototypeOf(' + identifier + ', ' + stringify(effect.options, replacer) + ')');
48
+ break;
49
+ case 7 /* MockDataSource.preventExtensions */:
50
+ strings.push('Object.preventExtensions(' + identifier + ')');
51
+ break;
52
+ case 2 /* MockDataSource.call */:
53
+ strings.push(identifier + getParameters(effect.options, replacer));
54
+ break;
55
+ }
56
+ }
57
+ }
58
+ return strings.join('\n');
59
+ function getAccessor(mockData, parent) {
60
+ const parentName = (parent?.instanceName ?? parent?.name);
61
+ switch (mockData.source) {
62
+ case 2 /* MockDataSource.call */:
63
+ return parentName + getParameters(mockData.options, replacer);
64
+ case 1 /* MockDataSource.get */:
65
+ return parentName + '.' + mockData.name;
66
+ case 8 /* MockDataSource.construct */:
67
+ {
68
+ const newTarget = stringify(mockData.target, replacer);
69
+ return parentName !== newTarget
70
+ ? 'Reflect.construct(' + parentName + ',' + stringify(mockData.options, replacer) + ',' + newTarget + ')'
71
+ : 'new ' + parentName + getParameters(mockData.options, replacer);
72
+ }
73
+ }
74
+ }
75
+ }
76
+ function generate(object) {
77
+ stringify(object, bumpReplacer);
78
+ return stringify(object, replacer);
79
+ }
80
+ function bumpReplacer(value) {
81
+ const mockData = getMockData(value);
82
+ if (mockData) {
83
+ ++mockData.useCount;
84
+ return getCode(mockData, bumpReplacer, true);
85
+ }
86
+ return value;
87
+ }
88
+ function replacer(value) {
89
+ const mockData = getMockData(value);
90
+ if (mockData) {
91
+ return getCode(mockData, replacer, true);
92
+ }
93
+ return value;
94
+ }
95
+ function getCode(value, replacer, bumpCount) {
96
+ if (bumpCount && value.useCount > 1) {
97
+ if (value.source === 0 /* MockDataSource.root */) {
98
+ return value.name;
99
+ }
100
+ if (!value.instanceName) {
101
+ value.instanceName = getNextInstanceName();
102
+ }
103
+ return value.instanceName;
104
+ }
105
+ value.generated = true;
106
+ switch (value.source) {
107
+ case 2 /* MockDataSource.call */:
108
+ return getPrevCode(value) + getParameters(value.options, replacer);
109
+ case 1 /* MockDataSource.get */:
110
+ return getPrevCode(value) + '.' + value.name;
111
+ case 0 /* MockDataSource.root */:
112
+ return value.name;
113
+ case 8 /* MockDataSource.construct */:
114
+ {
115
+ const prevCode = getPrevCode(value);
116
+ const newTarget = stringify(value.target, replacer);
117
+ return prevCode !== newTarget
118
+ ? 'Reflect.construct(' + prevCode + ',' + stringify(value.options, replacer) + ',' + newTarget + ')'
119
+ : 'new ' + prevCode + getParameters(value.options, replacer);
120
+ }
121
+ }
122
+ function getPrevCode(mockData) {
123
+ return mockData.parent ? getCode(mockData.parent, replacer, bumpCount) : '';
124
+ }
125
+ }
126
+ function createInternalMock(target, mockData) {
127
+ mockDatas.push(mockData);
128
+ target[mock] = mockData;
129
+ return new Proxy(target, {
130
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
131
+ set(target, p, value, receiver) {
132
+ const realValue = unwrapValue(value);
133
+ if (!mockData.sideEffects) {
134
+ mockData.sideEffects = [];
135
+ }
136
+ mockData.sideEffects.push({
137
+ useCount: 0,
138
+ name: p,
139
+ options: realValue,
140
+ parent: mockData,
141
+ source: 3 /* MockDataSource.set */,
142
+ generated: false
143
+ });
144
+ ++mockData.useCount;
145
+ Reflect.set(target, p, realValue, receiver);
146
+ return true;
147
+ },
148
+ get(target, p) {
149
+ if (p === unwrap)
150
+ return target;
151
+ if (p === mock)
152
+ return mockData;
153
+ const value = Reflect.get(target, p);
154
+ if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
155
+ return value;
156
+ }
157
+ if (!mockData.mocks) {
158
+ mockData.mocks = Object.create(null);
159
+ }
160
+ if (!mockData.mocks[p]) {
161
+ mockData.mocks[p] = createInternalMock(value, {
162
+ useCount: 0,
163
+ name: p,
164
+ parent: mockData,
165
+ source: 1 /* MockDataSource.get */,
166
+ generated: false
167
+ });
168
+ }
169
+ const result = mockData.mocks[p];
170
+ ++mockData.useCount;
171
+ return result;
172
+ },
173
+ // eslint-disable-next-line @typescript-eslint/ban-types
174
+ construct(target, argArray, newTarget) {
175
+ const realTarget = unwrapValue(newTarget);
176
+ const realArguments = unwrapValue(argArray);
177
+ ++mockData.useCount;
178
+ const result = Reflect.construct(target, realArguments, realTarget);
179
+ return createInternalMock(result, {
180
+ useCount: 0,
181
+ name: '',
182
+ options: realArguments,
183
+ target: realTarget,
184
+ parent: mockData,
185
+ source: 8 /* MockDataSource.construct */,
186
+ generated: false
187
+ });
188
+ },
189
+ defineProperty(target, property, attributes) {
190
+ const realValue = unwrapValue(attributes);
191
+ // if (!mockData.sideEffects) {
192
+ // mockData.sideEffects = [];
193
+ // }
194
+ // mockData.sideEffects.push({
195
+ // useCount: 0,
196
+ // name: property,
197
+ // options: realValue,
198
+ // parent: mockData,
199
+ // source: MockDataSource.defineProperty,
200
+ // generated: false
201
+ // });
202
+ // ++mockData.useCount;
203
+ return Reflect.defineProperty(target, property, realValue);
204
+ },
205
+ deleteProperty(target, p) {
206
+ if (!mockData.sideEffects) {
207
+ mockData.sideEffects = [];
208
+ }
209
+ mockData.sideEffects.push({
210
+ useCount: 0,
211
+ name: p,
212
+ options: undefined,
213
+ parent: mockData,
214
+ source: 5 /* MockDataSource.deleteProperty */,
215
+ generated: false
216
+ });
217
+ ++mockData.useCount;
218
+ const result = Reflect.deleteProperty(target, p);
219
+ return result;
220
+ },
221
+ setPrototypeOf(target, v) {
222
+ const realValue = unwrapValue(v);
223
+ if (!mockData.sideEffects) {
224
+ mockData.sideEffects = [];
225
+ }
226
+ mockData.sideEffects.push({
227
+ useCount: 0,
228
+ name: '',
229
+ options: realValue,
230
+ parent: mockData,
231
+ source: 6 /* MockDataSource.setPrototypeOf */,
232
+ generated: false
233
+ });
234
+ ++mockData.useCount;
235
+ return Reflect.setPrototypeOf(target, realValue);
236
+ },
237
+ preventExtensions(target) {
238
+ if (!mockData.sideEffects) {
239
+ mockData.sideEffects = [];
240
+ }
241
+ mockData.sideEffects.push({
242
+ useCount: 0,
243
+ name: '',
244
+ options: undefined,
245
+ parent: mockData,
246
+ source: 7 /* MockDataSource.preventExtensions */,
247
+ generated: false
248
+ });
249
+ ++mockData.useCount;
250
+ return Reflect.preventExtensions(target);
251
+ },
252
+ apply(target, thisArg, argumentsList) {
253
+ const realThis = unwrapValue(thisArg);
254
+ const realArguments = unwrapValue(argumentsList);
255
+ ++mockData.useCount;
256
+ const result = Reflect.apply(target, realThis, realArguments);
257
+ if (result === null || (typeof result !== 'object' && typeof result !== 'function')) {
258
+ if (!mockData.sideEffects) {
259
+ mockData.sideEffects = [];
260
+ }
261
+ mockData.sideEffects.push({
262
+ useCount: 0,
263
+ name: '',
264
+ parent: mockData,
265
+ source: 2 /* MockDataSource.call */,
266
+ options: realArguments,
267
+ generated: false
268
+ });
269
+ ++mockData.useCount;
270
+ return result;
271
+ }
272
+ return createInternalMock(result, {
273
+ useCount: 0,
274
+ name: '',
275
+ parent: mockData,
276
+ source: 2 /* MockDataSource.call */,
277
+ options: realArguments,
278
+ generated: false
279
+ });
280
+ }
281
+ });
282
+ }
283
+ function getNextInstanceName() {
284
+ return `tmp_${counter++}`;
285
+ }
286
+ }
287
+ function getParameters(options, replacer) {
288
+ return `(${options.length ? options.map(value => stringify(value, replacer)).join(',') : ''})`;
289
+ }
290
+ // stringify like functionality, recursively walks through objects and converts them to strings but leaved some basic values intact
291
+ function stringify(value, replacer) {
292
+ const original = value;
293
+ value = replacer(value);
294
+ if (original !== value && typeof value === 'string') {
295
+ return value;
296
+ }
297
+ if (value === null) {
298
+ return null;
299
+ }
300
+ if (value === undefined) {
301
+ return undefined;
302
+ }
303
+ if (typeof value === 'number') {
304
+ return `${value}`;
305
+ }
306
+ if (Array.isArray(value)) {
307
+ return `[${value.map((v) => stringify(v, replacer)).join(',')}]`;
308
+ }
309
+ if (typeof value === 'boolean') {
310
+ return value;
311
+ }
312
+ if (typeof value === 'function') {
313
+ return value.toString();
314
+ }
315
+ if (value instanceof RegExp) {
316
+ return value;
317
+ }
318
+ if (typeof value === 'object') {
319
+ return `{${Object.entries(value).map(([k, v]) => k + ':' + stringify(v, replacer)).join(',')}}`;
320
+ }
321
+ return '"' + String(value) + '"';
327
322
  }
328
323
 
329
324
  module.exports = createRecordingMockFactory;