ctrl-fx 0.0.1 → 0.1.0

package/dist/internal/testinginterpreter.d.ts

@@ -0,0 +1,10 @@
+import { type TestConfig, type TestData } from '../testing';
+import type { Interpreter } from './interpreter';
+import type { RealWindow } from './realdom';
+export declare function makeTestingInterpreter<Custom = {}>(initialData: TestData<Custom>, window: RealWindow, config?: TestConfig): {
+    interpreter: Interpreter;
+    getData: () => TestData<Custom>;
+    advanceTime: (ms: number) => void;
+    fireBroadcast: (channel: string, message: unknown) => void;
+};
+//# sourceMappingURL=testinginterpreter.d.ts.map

package/dist/internal/testinginterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testinginterpreter.d.ts","sourceRoot":"","sources":["../../src/internal/testinginterpreter.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAA;AAK3D,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAwO3C,wBAAgB,sBAAsB,CAAC,MAAM,GAAG,EAAE,EAChD,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,UAAU,EAClB,MAAM,CAAC,EAAE,UAAU,GAClB;IACD,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAA;IAC/B,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACjC,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3D,CAyEA"}

package/dist/internal/testinginterpreter.js

@@ -0,0 +1,646 @@
+// Deterministic hash-based PRNG for test fallback — never uses Math.random().
+// Uses the 32-bit finalizer from MurmurHash3; distributes evenly over [0, 1).
+function seededRandom(callIndex) {
+    let h = (callIndex + 1) | 0;
+    h = Math.imul(h ^ (h >>> 16), 0x45d9f3b);
+    h = Math.imul(h ^ (h >>> 16), 0x45d9f3b);
+    h ^= h >>> 16;
+    return (h >>> 0) / 0x100000000;
+}
+import { generateUuid } from '.';
+import { permission, uuidFromString } from '..';
+import { dbVersion } from '../db';
+import { serializeIdbKey, TestDatabaseData, } from '../db/testdb';
+import { taskId, } from '../effects';
+import { scrollElementError } from '../scroll';
+import { emptyLocation } from '../net/location';
+import {} from '../testing';
+import { exhaustivenessCheck } from '../utils';
+import { run as runDbEffect } from '../db/effects';
+import { run as runDbSetupEffect } from '../db/setup';
+import { failure, success } from '../utils/result';
+import { TaskRegistry } from './taskreg';
+/* eslint-enable @typescript-eslint/no-explicit-any */
+function snapshotTestData(acc) {
+    return {
+        window: {
+            alerts: [...acc.window.alerts],
+            confirms: [...acc.window.confirms],
+            confirmResponses: [...acc.window.confirmResponses],
+            prompts: [...acc.window.prompts],
+            promptResponses: [...acc.window.promptResponses],
+        },
+        navigator: { appBadgeOperations: [...acc.navigator.appBadgeOperations] },
+        clipboard: {
+            content: acc.clipboard.content,
+            writes: [...acc.clipboard.writes],
+        },
+        document: { title: acc.document.title },
+        http: { interactions: [...acc.http.interactions] },
+        clock: { calls: [...acc.clock.calls] },
+        random: { calls: [...acc.random.calls] },
+        console: { logs: [...acc.console.logs] },
+        db: new TestDatabaseData(new Map([...acc.db.databases.entries()].map(([dbName, db]) => [
+            dbName,
+            new Map([...db.stores.entries()].map(([storeName, store]) => [
+                storeName,
+                {
+                    keyPath: store.keyPath,
+                    records: new Map(store.records),
+                    autoIncrementCounter: store.autoIncrementCounter,
+                },
+            ])),
+        ]))),
+        storage: {
+            local: new Map(acc.storage.local),
+            session: new Map(acc.storage.session),
+        },
+        navigation: {
+            locationHistory: [...acc.navigation.locationHistory],
+        },
+        scroll: {
+            windowScrolls: [...acc.scroll.windowScrolls],
+            elementScrolls: [...acc.scroll.elementScrolls],
+        },
+        downloads: [...acc.downloads],
+        broadcasts: {
+            sent: [...acc.broadcasts.sent],
+        },
+        custom: acc.custom,
+    };
+}
+class TestScheduler {
+    constructor() {
+        Object.defineProperty(this, "virtualNow", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    schedule(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    task, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    taskCallbacks, tskId, initialDelayInMillis, repeatIntervalInMillis) {
+        this.pending.push({
+            task,
+            taskCallbacks,
+            taskId: tskId,
+            nextFireAtMillis: this.virtualNow + initialDelayInMillis,
+            repeatIntervalInMillis,
+        });
+    }
+    cancel(tskId) {
+        this.pending = this.pending.filter(t => t.taskId !== tskId);
+    }
+    advance(ms, acc, broadcastReg, window) {
+        const targetTime = this.virtualNow + ms;
+        while (true) {
+            const next = this.pending
+                .filter(t => t.nextFireAtMillis <= targetTime)
+                .sort((a, b) => a.nextFireAtMillis - b.nextFireAtMillis)[0];
+            if (!next)
+                break;
+            this.virtualNow = next.nextFireAtMillis;
+            if (next.repeatIntervalInMillis !== undefined) {
+                next.nextFireAtMillis = this.virtualNow + next.repeatIntervalInMillis;
+            }
+            else {
+                this.pending = this.pending.filter(t => t !== next);
+            }
+            testingInterpreter(next.task, next.taskCallbacks, new TaskRegistry(), acc, broadcastReg, this, window);
+        }
+        this.virtualNow = targetTime;
+    }
+}
+class BroadcastChannelRegistry {
+    constructor() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "channels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    subscribe(channel, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler, tskId) {
+        if (!this.channels.has(channel))
+            this.channels.set(channel, []);
+        this.channels.get(channel).push({ handler, taskId: tskId });
+    }
+    unsubscribe(tskId) {
+        for (const [ch, subs] of this.channels) {
+            this.channels.set(ch, subs.filter(s => s.taskId !== tskId));
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    deliver(channel, message, acc, broadcastReg, scheduler, window) {
+        const subs = this.channels.get(channel) ?? [];
+        for (const sub of subs) {
+            testingInterpreter(sub.handler(message), {
+                onComplete() { },
+                onFireEvent() { },
+                getState() { return undefined; },
+                setState() { },
+            }, new TaskRegistry(), acc, broadcastReg, scheduler, window);
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export function makeTestingInterpreter(initialData, window, config) {
+    const acc = {
+        window: {
+            alerts: [...initialData.window.alerts],
+            confirms: [...initialData.window.confirms],
+            confirmResponses: [...initialData.window.confirmResponses],
+            prompts: [...initialData.window.prompts],
+            promptResponses: [...initialData.window.promptResponses],
+        },
+        navigator: {
+            appBadgeOperations: [...initialData.navigator.appBadgeOperations],
+        },
+        clipboard: {
+            content: initialData.clipboard.content,
+            writes: [...initialData.clipboard.writes],
+        },
+        document: { title: initialData.document.title },
+        http: { interactions: [...initialData.http.interactions] },
+        clock: { calls: [...initialData.clock.calls] },
+        random: { calls: [...initialData.random.calls] },
+        console: { logs: [...initialData.console.logs] },
+        storage: {
+            local: new Map(initialData.storage.local),
+            session: new Map(initialData.storage.session),
+        },
+        navigation: {
+            locationHistory: [...initialData.navigation.locationHistory],
+        },
+        scroll: {
+            windowScrolls: [...initialData.scroll.windowScrolls],
+            elementScrolls: [...initialData.scroll.elementScrolls],
+        },
+        downloads: [...initialData.downloads],
+        broadcasts: {
+            sent: [...initialData.broadcasts.sent],
+        },
+        db: {
+            databases: new Map([...initialData.db._databases.entries()].map(([dbName, dbSnap]) => [
+                dbName,
+                {
+                    stores: new Map([...dbSnap.entries()].map(([storeName, storeSnap]) => [
+                        storeName,
+                        {
+                            keyPath: storeSnap.keyPath,
+                            records: new Map(storeSnap.records),
+                            autoIncrementCounter: storeSnap.autoIncrementCounter,
+                        },
+                    ])),
+                },
+            ])),
+        },
+        uuidSequence: [],
+        custom: initialData.custom,
+    };
+    const scheduler = new TestScheduler();
+    const broadcastReg = new BroadcastChannelRegistry();
+    const interpreter = (effect, callbacks, taskRegistry) => {
+        testingInterpreter(effect, callbacks, taskRegistry, acc, broadcastReg, scheduler, window, config);
+    };
+    return {
+        interpreter,
+        getData: () => snapshotTestData(acc),
+        advanceTime: (ms) => scheduler.advance(ms, acc, broadcastReg, window),
+        fireBroadcast: (channel, message) => broadcastReg.deliver(channel, message, acc, broadcastReg, scheduler, window),
+    };
+}
+function testingInterpreter(effect, callbacks, taskRegistry, acc, broadcastReg, scheduler, window, config) {
+    switch (effect._type) {
+        case 'Return': {
+            callbacks.onComplete(effect.value);
+            return;
+        }
+        case 'FlatMap': {
+            testingInterpreter(effect.effect, {
+                ...callbacks,
+                onComplete(result) {
+                    testingInterpreter(effect.next(result), callbacks, taskRegistry, acc, broadcastReg, scheduler, window, config);
+                },
+            }, taskRegistry, acc, broadcastReg, scheduler, window, config);
+            return;
+        }
+        case 'Suspend': {
+            switch (effect.operation._type) {
+                case 'Alert': {
+                    acc.window.alerts.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Confirm': {
+                    const response = acc.window.confirmResponses.shift() ?? false;
+                    acc.window.confirms.push({
+                        message: effect.operation.input,
+                        response,
+                    });
+                    callbacks.onComplete(response);
+                    return;
+                }
+                case 'Prompt': {
+                    const response = acc.window.promptResponses.shift() ?? null;
+                    acc.window.prompts.push({
+                        message: effect.operation.input.message,
+                        default: effect.operation.input.default,
+                        response,
+                    });
+                    callbacks.onComplete(response);
+                    return;
+                }
+                case 'GetNotificationPermission': {
+                    callbacks.onComplete(permission('default'));
+                    return;
+                }
+                case 'RequestNotificationPermission': {
+                    callbacks.onComplete(permission('granted'));
+                    return;
+                }
+                case 'GetLocation': {
+                    const history = acc.navigation.locationHistory;
+                    callbacks.onComplete((history.length > 0
+                        ? history[history.length - 1]
+                        : emptyLocation));
+                    return;
+                }
+                case 'Async': {
+                    // run the inner effect synchronously, ignoring the delay
+                    testingInterpreter(effect.operation.input.effect, {
+                        ...callbacks,
+                        onComplete() {
+                            callbacks.onComplete(undefined);
+                        },
+                    }, taskRegistry, acc, broadcastReg, scheduler, window, config);
+                    return;
+                }
+                case 'CancelTask': {
+                    scheduler.cancel(effect.operation.input);
+                    broadcastReg.unsubscribe(effect.operation.input);
+                    taskRegistry.remove(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ClearAppBadge': {
+                    acc.navigator.appBadgeOperations.push({ _type: 'ClearAppBadge' });
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SetAppBadge': {
+                    acc.navigator.appBadgeOperations.push({
+                        _type: 'SetAppBadge',
+                        count: effect.operation.input,
+                    });
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SetDocumentTitle': {
+                    acc.document.title = effect.operation.input;
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ReadClipboard': {
+                    callbacks.onComplete(success(acc.clipboard.content));
+                    return;
+                }
+                case 'WriteClipboard': {
+                    acc.clipboard.content = effect.operation.input;
+                    acc.clipboard.writes.push(effect.operation.input);
+                    callbacks.onComplete(success(undefined));
+                    return;
+                }
+                case 'Download': {
+                    acc.downloads.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'PostBroadcastMessage': {
+                    acc.broadcasts.sent.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SubscribeToBroadcastChannel': {
+                    const { channel, handler, taskId: tskIdInput } = effect.operation.input;
+                    const tskId = tskIdInput ?? taskId(generateUuid());
+                    if (tskIdInput) {
+                        broadcastReg.unsubscribe(tskIdInput);
+                    }
+                    broadcastReg.subscribe(channel, handler, tskId);
+                    callbacks.onComplete(tskId);
+                    return;
+                }
+                case 'ScrollWindow': {
+                    acc.scroll.windowScrolls.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ScrollElement': {
+                    const { selector, options } = effect.operation.input;
+                    const el = window.document.querySelector(selector);
+                    if (el === null) {
+                        callbacks.onComplete(failure(scrollElementError(selector)));
+                    }
+                    else {
+                        el.scrollTo(options);
+                        acc.scroll.elementScrolls.push({ selector, options });
+                        callbacks.onComplete(success(undefined));
+                    }
+                    return;
+                }
+                case 'FireEvent': {
+                    callbacks.onFireEvent(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'GetState': {
+                    callbacks.onComplete(callbacks.getState());
+                    return;
+                }
+                case 'GetTime': {
+                    const callIndex = acc.clock.calls.length;
+                    const scripted = config?.clock.values ?? [];
+                    const value = callIndex < scripted.length ? scripted[callIndex] : new Date(0);
+                    acc.clock.calls.push(value);
+                    callbacks.onComplete(value);
+                    return;
+                }
+                case 'GetRandom': {
+                    const callIndex = acc.random.calls.length;
+                    const scripted = config?.random.values ?? [];
+                    const value = callIndex < scripted.length
+                        ? scripted[callIndex]
+                        : seededRandom(callIndex);
+                    acc.random.calls.push(value);
+                    callbacks.onComplete(value);
+                    return;
+                }
+                case 'Log': {
+                    acc.console.logs.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'MakeHttpRequest': {
+                    // TODO: add HTTP mock support for testing
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Product': {
+                    let resultA = '__ctrl_fx_unset_result';
+                    let resultB = '__ctrl_fx_unset_result';
+                    testingInterpreter(effect.operation.input[0], {
+                        ...callbacks,
+                        onComplete(a) {
+                            resultA = a;
+                            if (resultB !== '__ctrl_fx_unset_result') {
+                                callbacks.onComplete([resultA, resultB]);
+                            }
+                        },
+                    }, taskRegistry, acc, broadcastReg, scheduler, window, config);
+                    testingInterpreter(effect.operation.input[1], {
+                        ...callbacks,
+                        onComplete(b) {
+                            resultB = b;
+                            if (resultA !== '__ctrl_fx_unset_result') {
+                                callbacks.onComplete([resultA, resultB]);
+                            }
+                        },
+                    }, taskRegistry, acc, broadcastReg, scheduler, window, config);
+                    return;
+                }
+                case 'ScheduleTask': {
+                    const tskId = effect.operation.input.taskId ?? taskId(generateUuid());
+                    // rescheduling: cancel any existing task with this id
+                    if (effect.operation.input.taskId) {
+                        scheduler.cancel(effect.operation.input.taskId);
+                    }
+                    scheduler.schedule(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    effect.operation.input.task, 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    { ...callbacks, onComplete() { } }, tskId, effect.operation.input.initialDelayInMillis, effect.operation.input.repeatIntervalInMillis);
+                    callbacks.onComplete(tskId);
+                    return;
+                }
+                case 'SetTimeout': {
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'PushState': {
+                    acc.navigation.locationHistory.push(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ReplaceState': {
+                    if (acc.navigation.locationHistory.length > 0) {
+                        acc.navigation.locationHistory[acc.navigation.locationHistory.length - 1] = effect.operation.input;
+                    }
+                    else {
+                        acc.navigation.locationHistory.push(effect.operation.input);
+                    }
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Go': {
+                    const delta = effect.operation.input;
+                    const newLen = acc.navigation.locationHistory.length + delta;
+                    if (newLen > 0) {
+                        acc.navigation.locationHistory.length = newLen;
+                    }
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'GenerateUuid': {
+                    const uuidLen = acc.uuidSequence.length;
+                    const nextUuid = uuidFromString(`${uuidLen}`);
+                    acc.uuidSequence.push(nextUuid);
+                    callbacks.onComplete(nextUuid);
+                    return;
+                }
+                case 'GetStorageItem': {
+                    const store = acc.storage[effect.operation.input.storage];
+                    callbacks.onComplete((store.get(effect.operation.input.key) ?? null));
+                    return;
+                }
+                case 'SetStorageItem': {
+                    acc.storage[effect.operation.input.storage].set(effect.operation.input.key, effect.operation.input.value);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'RemoveStorageItem': {
+                    acc.storage[effect.operation.input.storage].delete(effect.operation.input.key);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ClearStorage': {
+                    acc.storage[effect.operation.input.storage].clear();
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'OpenDatabase': {
+                    const { db, setup } = effect.operation.input;
+                    if (!acc.db.databases.has(db)) {
+                        const mutableDb = { stores: new Map() };
+                        acc.db.databases.set(db, mutableDb);
+                        runDbSetupEffect(setup(dbVersion(0)), makeSetupInterpreter(mutableDb), _r => {
+                            callbacks.onComplete(success(undefined));
+                        });
+                    }
+                    else {
+                        callbacks.onComplete(success(undefined));
+                    }
+                    return;
+                }
+                case 'RunDbTransaction': {
+                    const { db, effect: dbEffect } = effect.operation.input;
+                    const mutableDb = acc.db.databases.get(db);
+                    if (!mutableDb) {
+                        callbacks.onComplete(failure({
+                            _type: 'UnexpectedError',
+                            message: `Database '${db}' is not open`,
+                        }));
+                        return;
+                    }
+                    runDbEffect(dbEffect, makeDbInterpreter(mutableDb), _r => {
+                        callbacks.onComplete(success(undefined));
+                    });
+                    return;
+                }
+                case 'UpdateState': {
+                    callbacks.setState(effect.operation.input(callbacks.getState()));
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'CustomEffect': {
+                    const { args, test } = effect.operation.input;
+                    const result = test(args, acc.custom);
+                    acc.custom = result.data;
+                    callbacks.onComplete(result.out);
+                    return;
+                }
+                default: {
+                    exhaustivenessCheck(effect.operation);
+                }
+            }
+            break;
+        }
+        default: {
+            exhaustivenessCheck(effect);
+        }
+    }
+}
+function makeSetupInterpreter(mutableDb) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (op, onComplete) => {
+        switch (op._type) {
+            case 'CreateObjectStore': {
+                mutableDb.stores.set(op.objectStore, {
+                    keyPath: op.keyPath,
+                    records: new Map(),
+                    autoIncrementCounter: 1,
+                });
+                onComplete(undefined);
+                return;
+            }
+            case 'CreateIndex': {
+                onComplete(undefined);
+                return;
+            }
+            case 'DeleteObjectStore': {
+                mutableDb.stores.delete(op.objectStore);
+                onComplete(undefined);
+                return;
+            }
+            case 'DeleteIndex': {
+                onComplete(undefined);
+                return;
+            }
+            case 'GetObjectStoreNames': {
+                onComplete([...mutableDb.stores.keys()]);
+                return;
+            }
+            case 'GetIndexNames': {
+                onComplete([]);
+                return;
+            }
+            case 'RunDbEffect': {
+                runDbEffect(op.effect, makeDbInterpreter(mutableDb), _r => onComplete(undefined));
+                return;
+            }
+        }
+    };
+}
+function makeDbInterpreter(mutableDb) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (op, onComplete) => {
+        switch (op._type) {
+            case 'Add':
+            case 'Put': {
+                const store = requireStore(mutableDb, op.objectStore);
+                store.records.set(extractKey(op.value, store), op.value);
+                onComplete(undefined);
+                return;
+            }
+            case 'Get': {
+                const store = requireStore(mutableDb, op.objectStore);
+                onComplete(store.records.get(serializeIdbKey(op.key)));
+                return;
+            }
+            case 'GetAll': {
+                const store = requireStore(mutableDb, op.objectStore);
+                onComplete([...store.records.values()]);
+                return;
+            }
+            case 'Delete': {
+                const store = requireStore(mutableDb, op.objectStore);
+                store.records.delete(serializeIdbKey(op.key));
+                onComplete(undefined);
+                return;
+            }
+            case 'Count': {
+                const store = requireStore(mutableDb, op.objectStore);
+                onComplete(store.records.size);
+                return;
+            }
+        }
+    };
+}
+function requireStore(mutableDb, storeName) {
+    const store = mutableDb.stores.get(storeName);
+    if (!store)
+        throw new Error(`Object store '${storeName}' not found`);
+    return store;
+}
+function extractKey(value, store) {
+    const { keyPath } = store;
+    switch (keyPath._type) {
+        case 'AutoIncrement':
+            return String(store.autoIncrementCounter++);
+        case 'Manual': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error(`Cannot extract key '${keyPath.value}' from non-object`);
+            }
+            return JSON.stringify(value[keyPath.value]);
+        }
+        case 'Multi': {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                throw new Error('Cannot extract compound key from non-object');
+            }
+            const obj = value;
+            return JSON.stringify([keyPath.first, keyPath.second, ...keyPath.rest].map(f => obj[f]));
+        }
+    }
+}