@slimlib/smart-mock 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Konstantin Shutkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# Smart Mock
+
+One more proxy based mock
+
+# License
+
+[MIT](https://github.com/kshutkin/slimlib/blob/main/LICENSE)

package/dist/index.cjs

@@ -0,0 +1,307 @@
+'use strict';
+
+const mock = Symbol();
+const unwrap = Symbol();
+const unwrapValue = (value) => (value != null && value[unwrap]) || value;
+const getMockData = (value) => (value != null && value[mock]) || undefined;
+function createRecordingMockFactory() {
+    const mockDatas = [];
+    let counter = 0;
+    return {
+        createMock,
+        generateGlobals,
+        generate
+    };
+    function createMock(object, name) {
+        return createInternalMock(object, {
+            name,
+            source: 0 /* MockDataSource.root */,
+            useCount: 0,
+            generated: true
+        });
+    }
+    function generateGlobals() {
+        const strings = [];
+        for (const mockData of mockDatas) {
+            if (mockData.generated)
+                continue;
+            if (!mockData.instanceName) {
+                mockData.instanceName = getNextInstanceName();
+            }
+            strings.push('const ' + mockData.instanceName + ' = ' + getAccessor(mockData, mockData.parent));
+            for (const effect of (mockData.sideEffects || [])) {
+                switch (effect.source) {
+                    case 3 /* MockDataSource.set */:
+                        strings.push(mockData.instanceName + '.' + effect.name + ' = ' + stringify(effect.options, replacer));
+                        break;
+                    // case MockDataSource.defineProperty:
+                    //     strings.push('Object.defineProperty(' + mockData.instanceName + ', "' + (effect.name as string) + '", ' + stringify(effect.options, replacer as ReplacerFunction) + ')');
+                    //     break;
+                    case 5 /* MockDataSource.deleteProperty */:
+                        strings.push('delete ' + mockData.instanceName + '["' + effect.name + '"]');
+                        break;
+                    case 6 /* MockDataSource.setPrototypeOf */:
+                        strings.push('Object.setPrototypeOf(' + mockData.instanceName + ', ' + stringify(effect.options, replacer) + ')');
+                        break;
+                    case 7 /* MockDataSource.preventExtensions */:
+                        strings.push('Object.preventExtensions(' + mockData.instanceName + ')');
+                        break;
+                }
+            }
+        }
+        return strings.join('\n');
+        function getAccessor(mockData, parent) {
+            var _a;
+            const parentName = ((_a = parent.instanceName) !== null && _a !== void 0 ? _a : parent.name);
+            switch (mockData.source) {
+                case 2 /* MockDataSource.call */:
+                    return parentName + getParameters(mockData.options, replacer);
+                case 1 /* MockDataSource.get */:
+                    return parentName + '.' + mockData.name;
+                case 8 /* MockDataSource.construct */:
+                    {
+                        const newTarget = stringify(mockData.target, replacer);
+                        return parentName !== newTarget
+                            ? 'Reflect.construct(' + parentName + ',' + stringify(mockData.options, replacer) + ',' + newTarget + ')'
+                            : 'new ' + parentName + getParameters(mockData.options, replacer);
+                    }
+            }
+        }
+    }
+    function generate(object) {
+        stringify(object, bumpReplacer);
+        return stringify(object, replacer);
+    }
+    function bumpReplacer(value) {
+        const mockData = getMockData(value);
+        if (mockData) {
+            ++mockData.useCount;
+            return getCode(mockData, bumpReplacer, true);
+        }
+        return value;
+    }
+    function replacer(value) {
+        const mockData = getMockData(value);
+        if (mockData) {
+            return getCode(mockData, replacer, true);
+        }
+        return value;
+    }
+    function getCode(value, replacer, bumpCount) {
+        if (bumpCount && value.useCount > 1) {
+            if (value.source === 0 /* MockDataSource.root */) {
+                return value.name;
+            }
+            if (!value.instanceName) {
+                value.instanceName = getNextInstanceName();
+            }
+            return value.instanceName;
+        }
+        value.generated = true;
+        switch (value.source) {
+            case 2 /* MockDataSource.call */:
+                return getCallCode(value.parent, value);
+            case 1 /* MockDataSource.get */:
+                return getPrevCode(value) + '.' + value.name;
+            case 0 /* MockDataSource.root */:
+                return value.name;
+            case 8 /* MockDataSource.construct */:
+                {
+                    const prevCode = getPrevCode(value);
+                    const newTarget = stringify(value.target, replacer);
+                    return prevCode !== newTarget
+                        ? 'Reflect.construct(' + prevCode + ',' + stringify(value.options, replacer) + ',' + newTarget + ')'
+                        : 'new ' + prevCode + getParameters(value.options, replacer);
+                }
+        }
+        function getCallCode(parent, value) {
+            parent.generated = true;
+            const prevCode = getPrevCode(parent);
+            return prevCode + (prevCode ? '.' : '') + parent.name + getParameters(value.options, replacer);
+        }
+        function getPrevCode(mockData) {
+            return mockData.parent ? getCode(mockData.parent, replacer, bumpCount) : '';
+        }
+    }
+    function createInternalMock(target, mockData) {
+        mockDatas.push(mockData);
+        target[mock] = mockData;
+        return new Proxy(target, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            set(target, p, value, receiver) {
+                const realValue = unwrapValue(value);
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: p,
+                    options: realValue,
+                    parent: mockData,
+                    source: 3 /* MockDataSource.set */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                Reflect.set(target, p, realValue, receiver);
+                return true;
+            },
+            get(target, p) {
+                if (p === unwrap)
+                    return target;
+                if (p === mock)
+                    return mockData;
+                const value = Reflect.get(target, p);
+                if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+                    return value;
+                }
+                if (!mockData.mocks) {
+                    mockData.mocks = Object.create(null);
+                }
+                if (!mockData.mocks[p]) {
+                    mockData.mocks[p] = createInternalMock(value, {
+                        useCount: 0,
+                        name: p,
+                        parent: mockData,
+                        source: 1 /* MockDataSource.get */,
+                        generated: false
+                    });
+                }
+                const result = mockData.mocks[p];
+                ++mockData.useCount;
+                return result;
+            },
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            construct(target, argArray, newTarget) {
+                const realTarget = unwrapValue(newTarget);
+                const realArguments = unwrapValue(argArray);
+                ++mockData.useCount;
+                const result = Reflect.construct(target, realArguments, realTarget);
+                return createInternalMock(result, {
+                    useCount: 0,
+                    name: '',
+                    options: realArguments,
+                    target: realTarget,
+                    parent: mockData,
+                    source: 8 /* MockDataSource.construct */,
+                    generated: false
+                });
+            },
+            defineProperty(target, property, attributes) {
+                const realValue = unwrapValue(attributes);
+                // if (!mockData.sideEffects) {
+                //     mockData.sideEffects = [];
+                // }
+                // mockData.sideEffects.push({
+                //     useCount: 0,
+                //     name: property,
+                //     options: realValue,
+                //     parent: mockData,
+                //     source: MockDataSource.defineProperty,
+                //     generated: false
+                // });
+                // ++mockData.useCount;
+                return Reflect.defineProperty(target, property, realValue);
+            },
+            deleteProperty(target, p) {
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: p,
+                    options: undefined,
+                    parent: mockData,
+                    source: 5 /* MockDataSource.deleteProperty */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                const result = Reflect.deleteProperty(target, p);
+                return result;
+            },
+            setPrototypeOf(target, v) {
+                const realValue = unwrapValue(v);
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: '',
+                    options: realValue,
+                    parent: mockData,
+                    source: 6 /* MockDataSource.setPrototypeOf */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                return Reflect.setPrototypeOf(target, realValue);
+            },
+            preventExtensions(target) {
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: '',
+                    options: undefined,
+                    parent: mockData,
+                    source: 7 /* MockDataSource.preventExtensions */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                return Reflect.preventExtensions(target);
+            },
+            apply(target, thisArg, argumentsList) {
+                const realThis = unwrapValue(thisArg);
+                const realArguments = unwrapValue(argumentsList);
+                ++mockData.useCount;
+                return createInternalMock(Reflect.apply(target, realThis, realArguments), {
+                    useCount: 0,
+                    name: '',
+                    parent: mockData,
+                    source: 2 /* MockDataSource.call */,
+                    options: realArguments,
+                    generated: false
+                });
+            }
+        });
+    }
+    function getNextInstanceName() {
+        return `tmp_${counter++}`;
+    }
+}
+function getParameters(options, replacer) {
+    return `(${options.length ? options.map(value => stringify(value, replacer)).join(',') : ''})`;
+}
+function stringify(value, replacer) {
+    const original = value;
+    value = replacer(value);
+    if (original !== value && typeof value === 'string') {
+        return value;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'number') {
+        return `${value}`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => stringify(v, replacer)).join(',')}]`;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'function') {
+        return value.toString();
+    }
+    if (value instanceof RegExp) {
+        return value;
+    }
+    if (typeof value === 'object') {
+        return `{${Object.entries(value).map(([k, v]) => k + ':' + stringify(v, replacer)).join(',')}}`;
+    }
+    return '"' + String(value) + '"';
+}
+
+module.exports = createRecordingMockFactory;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export declare const enum MockDataSource {
+    root = 0,
+    get = 1,
+    call = 2,
+    set = 3,
+    defineProperty = 4,
+    deleteProperty = 5,
+    setPrototypeOf = 6,
+    preventExtensions = 7,
+    construct = 8
+}
+export default function createRecordingMockFactory(): {
+    createMock: <T extends object>(object: T, name: string) => T;
+    generateGlobals: () => string;
+    generate: <T_1 extends object>(object: T_1) => string | boolean | RegExp | null | undefined;
+};

package/dist/index.mjs

@@ -0,0 +1,305 @@
+const mock = Symbol();
+const unwrap = Symbol();
+const unwrapValue = (value) => (value != null && value[unwrap]) || value;
+const getMockData = (value) => (value != null && value[mock]) || undefined;
+function createRecordingMockFactory() {
+    const mockDatas = [];
+    let counter = 0;
+    return {
+        createMock,
+        generateGlobals,
+        generate
+    };
+    function createMock(object, name) {
+        return createInternalMock(object, {
+            name,
+            source: 0 /* MockDataSource.root */,
+            useCount: 0,
+            generated: true
+        });
+    }
+    function generateGlobals() {
+        const strings = [];
+        for (const mockData of mockDatas) {
+            if (mockData.generated)
+                continue;
+            if (!mockData.instanceName) {
+                mockData.instanceName = getNextInstanceName();
+            }
+            strings.push('const ' + mockData.instanceName + ' = ' + getAccessor(mockData, mockData.parent));
+            for (const effect of (mockData.sideEffects || [])) {
+                switch (effect.source) {
+                    case 3 /* MockDataSource.set */:
+                        strings.push(mockData.instanceName + '.' + effect.name + ' = ' + stringify(effect.options, replacer));
+                        break;
+                    // case MockDataSource.defineProperty:
+                    //     strings.push('Object.defineProperty(' + mockData.instanceName + ', "' + (effect.name as string) + '", ' + stringify(effect.options, replacer as ReplacerFunction) + ')');
+                    //     break;
+                    case 5 /* MockDataSource.deleteProperty */:
+                        strings.push('delete ' + mockData.instanceName + '["' + effect.name + '"]');
+                        break;
+                    case 6 /* MockDataSource.setPrototypeOf */:
+                        strings.push('Object.setPrototypeOf(' + mockData.instanceName + ', ' + stringify(effect.options, replacer) + ')');
+                        break;
+                    case 7 /* MockDataSource.preventExtensions */:
+                        strings.push('Object.preventExtensions(' + mockData.instanceName + ')');
+                        break;
+                }
+            }
+        }
+        return strings.join('\n');
+        function getAccessor(mockData, parent) {
+            var _a;
+            const parentName = ((_a = parent.instanceName) !== null && _a !== void 0 ? _a : parent.name);
+            switch (mockData.source) {
+                case 2 /* MockDataSource.call */:
+                    return parentName + getParameters(mockData.options, replacer);
+                case 1 /* MockDataSource.get */:
+                    return parentName + '.' + mockData.name;
+                case 8 /* MockDataSource.construct */:
+                    {
+                        const newTarget = stringify(mockData.target, replacer);
+                        return parentName !== newTarget
+                            ? 'Reflect.construct(' + parentName + ',' + stringify(mockData.options, replacer) + ',' + newTarget + ')'
+                            : 'new ' + parentName + getParameters(mockData.options, replacer);
+                    }
+            }
+        }
+    }
+    function generate(object) {
+        stringify(object, bumpReplacer);
+        return stringify(object, replacer);
+    }
+    function bumpReplacer(value) {
+        const mockData = getMockData(value);
+        if (mockData) {
+            ++mockData.useCount;
+            return getCode(mockData, bumpReplacer, true);
+        }
+        return value;
+    }
+    function replacer(value) {
+        const mockData = getMockData(value);
+        if (mockData) {
+            return getCode(mockData, replacer, true);
+        }
+        return value;
+    }
+    function getCode(value, replacer, bumpCount) {
+        if (bumpCount && value.useCount > 1) {
+            if (value.source === 0 /* MockDataSource.root */) {
+                return value.name;
+            }
+            if (!value.instanceName) {
+                value.instanceName = getNextInstanceName();
+            }
+            return value.instanceName;
+        }
+        value.generated = true;
+        switch (value.source) {
+            case 2 /* MockDataSource.call */:
+                return getCallCode(value.parent, value);
+            case 1 /* MockDataSource.get */:
+                return getPrevCode(value) + '.' + value.name;
+            case 0 /* MockDataSource.root */:
+                return value.name;
+            case 8 /* MockDataSource.construct */:
+                {
+                    const prevCode = getPrevCode(value);
+                    const newTarget = stringify(value.target, replacer);
+                    return prevCode !== newTarget
+                        ? 'Reflect.construct(' + prevCode + ',' + stringify(value.options, replacer) + ',' + newTarget + ')'
+                        : 'new ' + prevCode + getParameters(value.options, replacer);
+                }
+        }
+        function getCallCode(parent, value) {
+            parent.generated = true;
+            const prevCode = getPrevCode(parent);
+            return prevCode + (prevCode ? '.' : '') + parent.name + getParameters(value.options, replacer);
+        }
+        function getPrevCode(mockData) {
+            return mockData.parent ? getCode(mockData.parent, replacer, bumpCount) : '';
+        }
+    }
+    function createInternalMock(target, mockData) {
+        mockDatas.push(mockData);
+        target[mock] = mockData;
+        return new Proxy(target, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            set(target, p, value, receiver) {
+                const realValue = unwrapValue(value);
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: p,
+                    options: realValue,
+                    parent: mockData,
+                    source: 3 /* MockDataSource.set */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                Reflect.set(target, p, realValue, receiver);
+                return true;
+            },
+            get(target, p) {
+                if (p === unwrap)
+                    return target;
+                if (p === mock)
+                    return mockData;
+                const value = Reflect.get(target, p);
+                if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
+                    return value;
+                }
+                if (!mockData.mocks) {
+                    mockData.mocks = Object.create(null);
+                }
+                if (!mockData.mocks[p]) {
+                    mockData.mocks[p] = createInternalMock(value, {
+                        useCount: 0,
+                        name: p,
+                        parent: mockData,
+                        source: 1 /* MockDataSource.get */,
+                        generated: false
+                    });
+                }
+                const result = mockData.mocks[p];
+                ++mockData.useCount;
+                return result;
+            },
+            // eslint-disable-next-line @typescript-eslint/ban-types
+            construct(target, argArray, newTarget) {
+                const realTarget = unwrapValue(newTarget);
+                const realArguments = unwrapValue(argArray);
+                ++mockData.useCount;
+                const result = Reflect.construct(target, realArguments, realTarget);
+                return createInternalMock(result, {
+                    useCount: 0,
+                    name: '',
+                    options: realArguments,
+                    target: realTarget,
+                    parent: mockData,
+                    source: 8 /* MockDataSource.construct */,
+                    generated: false
+                });
+            },
+            defineProperty(target, property, attributes) {
+                const realValue = unwrapValue(attributes);
+                // if (!mockData.sideEffects) {
+                //     mockData.sideEffects = [];
+                // }
+                // mockData.sideEffects.push({
+                //     useCount: 0,
+                //     name: property,
+                //     options: realValue,
+                //     parent: mockData,
+                //     source: MockDataSource.defineProperty,
+                //     generated: false
+                // });
+                // ++mockData.useCount;
+                return Reflect.defineProperty(target, property, realValue);
+            },
+            deleteProperty(target, p) {
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: p,
+                    options: undefined,
+                    parent: mockData,
+                    source: 5 /* MockDataSource.deleteProperty */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                const result = Reflect.deleteProperty(target, p);
+                return result;
+            },
+            setPrototypeOf(target, v) {
+                const realValue = unwrapValue(v);
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: '',
+                    options: realValue,
+                    parent: mockData,
+                    source: 6 /* MockDataSource.setPrototypeOf */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                return Reflect.setPrototypeOf(target, realValue);
+            },
+            preventExtensions(target) {
+                if (!mockData.sideEffects) {
+                    mockData.sideEffects = [];
+                }
+                mockData.sideEffects.push({
+                    useCount: 0,
+                    name: '',
+                    options: undefined,
+                    parent: mockData,
+                    source: 7 /* MockDataSource.preventExtensions */,
+                    generated: false
+                });
+                ++mockData.useCount;
+                return Reflect.preventExtensions(target);
+            },
+            apply(target, thisArg, argumentsList) {
+                const realThis = unwrapValue(thisArg);
+                const realArguments = unwrapValue(argumentsList);
+                ++mockData.useCount;
+                return createInternalMock(Reflect.apply(target, realThis, realArguments), {
+                    useCount: 0,
+                    name: '',
+                    parent: mockData,
+                    source: 2 /* MockDataSource.call */,
+                    options: realArguments,
+                    generated: false
+                });
+            }
+        });
+    }
+    function getNextInstanceName() {
+        return `tmp_${counter++}`;
+    }
+}
+function getParameters(options, replacer) {
+    return `(${options.length ? options.map(value => stringify(value, replacer)).join(',') : ''})`;
+}
+function stringify(value, replacer) {
+    const original = value;
+    value = replacer(value);
+    if (original !== value && typeof value === 'string') {
+        return value;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'number') {
+        return `${value}`;
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => stringify(v, replacer)).join(',')}]`;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'function') {
+        return value.toString();
+    }
+    if (value instanceof RegExp) {
+        return value;
+    }
+    if (typeof value === 'object') {
+        return `{${Object.entries(value).map(([k, v]) => k + ':' + stringify(v, replacer)).join(',')}}`;
+    }
+    return '"' + String(value) + '"';
+}
+
+export { createRecordingMockFactory as default };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "version": "0.1.0",
+  "license": "MIT",
+  "name": "@slimlib/smart-mock",
+  "author": "Konstantin Shutkin",
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "typings": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshutkin/slimlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kshutkin/slimlib/issues"
+  },
+  "homepage": "https://github.com/kshutkin/slimlib/blob/main/smart-mock/README.md",
+  "readme": "README.md",
+  "description": "One more proxy based mock",
+  "keywords": [
+    "@slimlib",
+    "mock",
+    "smart-mock"
+  ],
+  "scripts": {
+    "build": "pkgbld-internal",
+    "test": "jest --collectCoverage",
+    "lint": "eslint ./src"
+  }
+}