@encorejs/saaz 1.0.0

package/dist/rogue.js

@@ -0,0 +1,548 @@
+import deepEqual from '@encorejs/utils/deepEqual';
+import * as immer from 'immer';
+import setDeep from 'lodash-es/set';
+import memoizeFn from '@encorejs/utils/memoizeFn';
+const NOT_DEFINED = {};
+function isCell(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const $type = v.$type;
+    if (!Array.isArray($type))
+        return false;
+    if ($type.length !== 2 && $type.length !== 1)
+        return false;
+    if (typeof $type[0] !== 'string')
+        return false;
+    const [type, branchName] = $type;
+    if (type === 'map' || type === 'boxed' || type === 'deleted')
+        return true;
+    return false;
+}
+export function makeDraft(base) {
+    if (!isPlainObject(base)) {
+        throw Error(`Base must be a plain object`);
+    }
+    base = isCell(base)
+        ? base
+        : {
+            $type: ['map', 'base'],
+            $branches: { base: { $mapProps: base } },
+        };
+    const immerDraft = immer.createDraft(base);
+    const state = {
+        imo: immerDraft,
+    };
+    const draft = new Proxy(state, traps);
+    const finish = () => {
+        const cell = immer.finishDraft(immerDraft);
+        const forwardOps = compare(base, cell);
+        const backwardOps = compare(cell, base);
+        return [cell, forwardOps, backwardOps];
+    };
+    return [draft, finish];
+}
+export function change(base, fn) {
+    const [draft, finish] = makeDraft(base);
+    fn(draft);
+    return finish();
+}
+export function fromOps(base, ops) {
+    if (!isPlainObject(base)) {
+        throw Error(`Base must be a plain object`);
+    }
+    base = isCell(base)
+        ? base
+        : {
+            $type: ['map', 'base'],
+            $branches: { base: { $mapProps: base } },
+        };
+    const immerDraft = immer.createDraft(base);
+    const state = {
+        imo: immerDraft,
+    };
+    for (const op of ops) {
+        const flatPath = op.path
+            .map(([branchName, mapProp]) => [
+            '$branches',
+            branchName,
+            '$mapProps',
+            mapProp,
+        ])
+            .flat();
+        if (op.type === 'ChangeType') {
+            const [type, branchName] = op.value;
+            setDeep(immerDraft, [...flatPath, '$type'], [type, branchName]);
+        }
+        else if (op.type === 'SetBoxedValue') {
+            setDeep(immerDraft, [...flatPath, '$branches', op.branchName, '$boxedValue'], op.value);
+        }
+        else {
+            throw Error(`Unrecognized op type: ${op.type}`);
+        }
+    }
+    return [immer.finishDraft(immerDraft)];
+}
+function compare(before, after) {
+    const ops = [];
+    compareCell(before, after, [], ops);
+    return ops;
+}
+function compareCell(before, after, path, ops) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (before === after)
+        return;
+    if (!deepEqual(before === null || before === void 0 ? void 0 : before.$type, after.$type)) {
+        const beforeType = before
+            ? [before.$type[0], (_a = before.$type[1]) !== null && _a !== void 0 ? _a : 'base']
+            : null;
+        const afterType = [after.$type[0], (_b = after.$type[1]) !== null && _b !== void 0 ? _b : 'base'];
+        if (!deepEqual(beforeType, afterType)) {
+            ops.push({
+                type: 'ChangeType',
+                path,
+                value: after.$type,
+            });
+        }
+    }
+    const [type, branchName] = [after.$type[0], (_c = after.$type[1]) !== null && _c !== void 0 ? _c : 'base'];
+    const afterBranch = (_d = after.$branches) === null || _d === void 0 ? void 0 : _d[branchName];
+    const beforeBranch = (_e = before === null || before === void 0 ? void 0 : before.$branches) === null || _e === void 0 ? void 0 : _e[branchName];
+    if (afterBranch === beforeBranch)
+        return;
+    if (!afterBranch)
+        return;
+    if (type === 'deleted')
+        return;
+    if (type === 'boxed') {
+        if (afterBranch.$boxedValue !== (beforeBranch === null || beforeBranch === void 0 ? void 0 : beforeBranch.$boxedValue)) {
+            ops.push({
+                type: 'SetBoxedValue',
+                path,
+                branchName,
+                value: afterBranch.$boxedValue,
+            });
+        }
+        return;
+    }
+    if (type === 'map') {
+        const beforeMapProps = (_f = beforeBranch === null || beforeBranch === void 0 ? void 0 : beforeBranch.$mapProps) !== null && _f !== void 0 ? _f : {};
+        const afterMapProps = (_g = afterBranch.$mapProps) !== null && _g !== void 0 ? _g : {};
+        const afterKeys = Object.keys(afterMapProps);
+        for (const prop of afterKeys) {
+            compareCell(Object.hasOwn(beforeMapProps, prop) ? beforeMapProps[prop] : undefined, afterMapProps[prop], [...path, [branchName, prop]], ops);
+        }
+        const beforeKeys = Object.keys(beforeMapProps);
+        for (const prop of beforeKeys) {
+            if (!Object.hasOwn(afterMapProps, prop)) {
+                ops.push({
+                    type: 'ChangeType',
+                    path: [...path, [branchName, prop]],
+                    value: ['deleted', generateBranchName()],
+                });
+            }
+        }
+        return;
+    }
+    throw Error(`Unrecognized type: ${type}`);
+}
+let _lastBranchName = 0;
+const generateBranchName = () => {
+    _lastBranchName++;
+    return _lastBranchName.toString();
+};
+const traps = {
+    get(state, prop) {
+        var _a, _b, _c, _d, _e, _f;
+        if (prop === DRAFT_STATE)
+            return state;
+        if (typeof prop !== 'string')
+            return undefined;
+        const imo = state.imo;
+        const type = imo.$type[0];
+        const branchName = (_a = imo.$type[1]) !== null && _a !== void 0 ? _a : 'base';
+        if (type === 'deleted')
+            throw new Error(`This value is marked as deleted and cannot be accessed`);
+        if (type === 'boxed')
+            throw new Error(`Implement getting inside a boxed value`);
+        if (type === 'map') {
+            const mapProps = (_c = (_b = imo.$branches) === null || _b === void 0 ? void 0 : _b[branchName]) === null || _c === void 0 ? void 0 : _c.$mapProps;
+            if (!mapProps)
+                return undefined;
+            if (Object.hasOwn(mapProps, prop)) {
+                const value = mapProps[prop];
+                if (!isCell(value)) {
+                    throw Error(`mapProps[${prop}] is not an ahistoric cell. this is a bug.`);
+                }
+                if (value.$type[0] === 'deleted')
+                    return undefined;
+                if (value.$type[0] === 'boxed') {
+                    const boxedValue = (_f = (_d = value.$branches) === null || _d === void 0 ? void 0 : _d[(_e = value.$type[1]) !== null && _e !== void 0 ? _e : 'base']) === null || _f === void 0 ? void 0 : _f.$boxedValue;
+                    if (isPlainObject(boxedValue)) {
+                        throw Error(`Implement getting a mapProp that is a boxed object`);
+                    }
+                    else {
+                        return boxedValue;
+                    }
+                }
+                else if (value.$type[0] === 'map') {
+                    const subState = {
+                        imo: value,
+                        parent: state,
+                    };
+                    return new Proxy(subState, traps);
+                }
+            }
+            else {
+                return undefined;
+            }
+        }
+        throw new Error(`Unrecognized type: ${type}`);
+    },
+    set(state, prop, _value) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _m, _o;
+        if (prop === DRAFT_STATE)
+            throw Error(`Unallowed`);
+        if (typeof prop !== 'string')
+            throw Error(`Non-string props are not allowed`);
+        const value = valueType(_value);
+        const imo = state.imo;
+        const cellType = imo.$type[0];
+        const branchName = (_a = imo.$type[1]) !== null && _a !== void 0 ? _a : 'base';
+        // setting self.a=value, when self is deleted
+        if (cellType === 'deleted')
+            throw new Error(`This value is marked as deleted and cannot be changed`);
+        // setting self.a=value, when self is a boxed value
+        if (cellType === 'boxed')
+            throw new Error(`Implement setting inside a boxed value`);
+        // setting self.a=value when self is a map
+        if (cellType === 'map') {
+            let branches = imo.$branches;
+            if (!branches) {
+                branches = {};
+                imo.$branches = branches;
+            }
+            let branch = branches[branchName];
+            if (!branch) {
+                branch = {};
+                branches[branchName] = branch;
+            }
+            let mapProps = branch.$mapProps;
+            if (!mapProps) {
+                mapProps = {};
+                branch.$mapProps = mapProps;
+            }
+            // setting self.a=value when self.a is defined
+            if (Object.hasOwn(mapProps, prop)) {
+                if (!isCell(mapProps[prop]))
+                    throw Error(`mapProps[${prop}] is not an ahistoric cell. this is a bug.`);
+                const currentPropCell = mapProps[prop];
+                // setting self.a={}
+                if (value.type === 'map') {
+                    let currentBranch;
+                    // setting self.a={} when self.a is not a map
+                    if (currentPropCell.$type[0] !== 'map') {
+                        // we're switching from a non-map to a map, which means if a map was previously set, it was
+                        // already deleted/overridden to be a boxed value, and the current user hasn't _seen_ the previous
+                        // map yet. So we should generate a new branchName for the new map.
+                        const newBranchName = generateBranchName();
+                        currentPropCell.$type = ['map', newBranchName];
+                        (_b = currentPropCell.$branches) !== null && _b !== void 0 ? _b : (currentPropCell.$branches = {});
+                        const newBranch = { $mapProps: {} };
+                        currentPropCell.$branches[newBranchName] = newBranch;
+                        currentBranch = newBranch;
+                    }
+                    else {
+                        (_c = currentPropCell.$branches) !== null && _c !== void 0 ? _c : (currentPropCell.$branches = {});
+                        (_e = (_m = currentPropCell.$branches)[_o = (_d = currentPropCell.$type[1]) !== null && _d !== void 0 ? _d : 'base']) !== null && _e !== void 0 ? _e : (_m[_o] = {});
+                        currentBranch =
+                            currentPropCell.$branches[(_f = currentPropCell.$type[1]) !== null && _f !== void 0 ? _f : 'base'];
+                    }
+                    const subState = {
+                        imo: currentPropCell,
+                        parent: state,
+                    };
+                    const proxy = new Proxy(subState, traps);
+                    const existingProps = Object.keys(proxy);
+                    // let's delete existing props that are not in the new value
+                    for (const key of existingProps) {
+                        if (!Object.hasOwn(value.value, key)) {
+                            delete proxy[key];
+                        }
+                    }
+                    for (const key of Object.keys(value.value)) {
+                        ;
+                        proxy[key] = value.value[key];
+                    }
+                    return true;
+                }
+                else if (value.type === 'boxed') {
+                    if (currentPropCell.$type[0] === 'boxed') {
+                        (_g = currentPropCell.$branches) !== null && _g !== void 0 ? _g : (currentPropCell.$branches = {});
+                        const branches = currentPropCell.$branches;
+                        const branchName = (_h = currentPropCell.$type[1]) !== null && _h !== void 0 ? _h : 'base';
+                        (_j = branches[branchName]) !== null && _j !== void 0 ? _j : (branches[branchName] = {});
+                        const branch = branches[branchName];
+                        branch.$boxedValue = value.value;
+                        return true;
+                    }
+                    else {
+                        const branchName = generateBranchName();
+                        currentPropCell.$type = ['boxed', branchName];
+                        (_k = currentPropCell.$branches) !== null && _k !== void 0 ? _k : (currentPropCell.$branches = {});
+                        const branches = currentPropCell.$branches;
+                        (_l = branches[branchName]) !== null && _l !== void 0 ? _l : (branches[branchName] = {});
+                        const branch = branches[branchName];
+                        branch.$boxedValue = value.value;
+                        return true;
+                    }
+                }
+                throw new Error(`Unrecognized type: ${currentPropCell.$type[0]}`);
+            }
+            else {
+                if (value.type === 'boxed') {
+                    mapProps[prop] = {
+                        $type: ['boxed', 'base'],
+                        $branches: {
+                            base: {
+                                $boxedValue: value.value,
+                            },
+                        },
+                    };
+                    return true;
+                }
+                else if (value.type === 'map') {
+                    mapProps[prop] = {
+                        $type: ['map', 'base'],
+                    };
+                    const subState = {
+                        imo: mapProps[prop],
+                        parent: state,
+                    };
+                    const proxy = new Proxy(subState, traps);
+                    for (const [k, v] of Object.entries(value.value)) {
+                        ;
+                        proxy[k] = v;
+                    }
+                    return true;
+                }
+                throw Error(`Unrecognized type: ${value.type}`);
+            }
+        }
+        throw new Error(`Unrecognized type: ${cellType}`);
+    },
+    has(state, prop) {
+        throw Error(`Implement has()`);
+    },
+    ownKeys(state) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const type = state.imo.$type[0];
+        if (type === 'boxed') {
+            const value = (_c = (_a = state.imo.$branches) === null || _a === void 0 ? void 0 : _a[(_b = state.imo.$type[1]) !== null && _b !== void 0 ? _b : 'base']) === null || _c === void 0 ? void 0 : _c.$boxedValue;
+            if (isPlainObject(value)) {
+                return Reflect.ownKeys(value);
+            }
+            else {
+                return [];
+            }
+        }
+        else if (type === 'deleted') {
+            return [];
+        }
+        else if (type === 'map') {
+            const props = (_g = (_f = (_d = state.imo.$branches) === null || _d === void 0 ? void 0 : _d[(_e = state.imo.$type[1]) !== null && _e !== void 0 ? _e : 'base']) === null || _f === void 0 ? void 0 : _f.$mapProps) !== null && _g !== void 0 ? _g : {};
+            return Reflect.ownKeys(props).filter((key) => props[key].$type[0] !== 'deleted');
+        }
+        else {
+            throw Error(`Unrecognized type: ${type}`);
+        }
+    },
+    deleteProperty(state, prop) {
+        var _a, _b, _c;
+        if (prop === DRAFT_STATE)
+            throw Error(`Unallowed`);
+        if (typeof prop !== 'string')
+            throw Error(`Non-string props are not allowed`);
+        const imo = state.imo;
+        const type = imo.$type[0];
+        const branchName = (_a = imo.$type[1]) !== null && _a !== void 0 ? _a : 'base';
+        if (type === 'deleted')
+            throw new Error(`This value is marked as deleted and cannot be changed`);
+        if (type === 'boxed')
+            throw new Error(`Implement deleting inside a boxed value`);
+        if (type === 'map') {
+            const mapProps = (_c = (_b = imo.$branches) === null || _b === void 0 ? void 0 : _b[branchName]) === null || _c === void 0 ? void 0 : _c.$mapProps;
+            if (!mapProps)
+                return false;
+            if (!Object.hasOwn(mapProps, prop))
+                return false;
+            if (!isCell(mapProps[prop]))
+                return false;
+            const currentPropCell = mapProps[prop];
+            if (currentPropCell.$type[0] === 'deleted')
+                return false;
+            currentPropCell.$type = ['deleted', generateBranchName()];
+            return true;
+        }
+        throw new Error(`Unrecognized type: ${type}`);
+    },
+    getOwnPropertyDescriptor(state, prop) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const type = state.imo.$type[0];
+        if (type === 'boxed') {
+            const $boxedValue = (_c = (_a = state.imo.$branches) === null || _a === void 0 ? void 0 : _a[(_b = state.imo.$type[1]) !== null && _b !== void 0 ? _b : 'base']) === null || _c === void 0 ? void 0 : _c.$boxedValue;
+            if (isPlainObject($boxedValue)) {
+                return Reflect.getOwnPropertyDescriptor($boxedValue, prop);
+            }
+            else {
+                return undefined;
+            }
+        }
+        else if (type === 'deleted') {
+            return undefined;
+        }
+        else if (type === 'map') {
+            const props = (_g = (_f = (_d = state.imo.$branches) === null || _d === void 0 ? void 0 : _d[(_e = state.imo.$type[1]) !== null && _e !== void 0 ? _e : 'base']) === null || _f === void 0 ? void 0 : _f.$mapProps) !== null && _g !== void 0 ? _g : {};
+            if (Object.hasOwn(props, prop)) {
+                return {
+                    writable: true,
+                    configurable: true,
+                    enumerable: true,
+                    value: traps.get(state, prop, {}),
+                };
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            throw Error(`Unrecognized type: ${type}`);
+        }
+    },
+    defineProperty(state, prop, descriptor) {
+        throw Error(`Implement defineProperty()`);
+    },
+    getPrototypeOf(state) {
+        var _a, _b, _c;
+        const type = state.imo.$type[0];
+        if (type === 'boxed') {
+            return Object.getPrototypeOf((_c = (_a = state.imo.$branches) === null || _a === void 0 ? void 0 : _a[(_b = state.imo.$type[1]) !== null && _b !== void 0 ? _b : 'base']) === null || _c === void 0 ? void 0 : _c.$boxedValue);
+        }
+        else if (type === 'deleted') {
+            return undefined;
+        }
+        else if (type === 'map') {
+            return Object.getPrototypeOf({});
+        }
+        else {
+            throw Error(`Unrecognized type: ${type}`);
+        }
+    },
+    setPrototypeOf(state, prototype) {
+        throw Error(`Implement setPrototypeOf()`);
+    },
+};
+export const current = (draft) => {
+    if (typeof draft !== 'object' || draft === null) {
+        return draft;
+    }
+    const state = draft[DRAFT_STATE];
+    if (!state)
+        return draft;
+    const currentImo = immer.current(state.imo);
+    return jsonFromCell(currentImo);
+};
+function valueType(v) {
+    if (typeof v === 'object' && v) {
+        if (Array.isArray(v)) {
+            return { type: 'boxed', value: v };
+        }
+        return { type: 'map', value: v };
+    }
+    if (typeof v === 'string' ||
+        typeof v === 'number' ||
+        typeof v === 'boolean' ||
+        typeof v === 'undefined' ||
+        v === null) {
+        return { type: 'boxed', value: v };
+    }
+    throw Error(`Unrecognized value type: ${typeof v}`);
+}
+const DRAFT_STATE = Symbol.for('draft-state');
+const objectCtorString = Object.prototype.constructor.toString();
+export function isPlainObject(value) {
+    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);
+}
+const BOXED = Symbol.for('boxed');
+export function boxed(value) {
+    return { [BOXED]: true, value };
+}
+function isBoxed(value) {
+    return typeof value === 'object' &&
+        value &&
+        value[BOXED] === true
+        ? true
+        : false;
+}
+const RESET = Symbol.for('reset');
+export function reset(value) {
+    return { [RESET]: true, value };
+}
+function isReset(value) {
+    return typeof value === 'object' &&
+        value &&
+        value[RESET] === true
+        ? true
+        : false;
+}
+function is(x, y) {
+    // Copied from https://github.com/immerjs/immer/blob/f6736a4beef727c6e5b41c312ce1b202ad3afb23/src/utils/common.ts#L115
+    // Originally from: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js
+    if (x === y) {
+        return x !== 0 || 1 / x === 1 / y;
+    }
+    else {
+        return x !== x && y !== y;
+    }
+}
+export function jsonFromCell(v) {
+    if (typeof v !== 'object' || v === null) {
+        return NOT_DEFINED;
+    }
+    return _jsonFromCell(v);
+}
+const _jsonFromCell = memoizeFn((v) => {
+    var _a, _b, _c, _d;
+    const type = (_a = v.$type) === null || _a === void 0 ? void 0 : _a[0];
+    const branchName = (_b = v.$branches) === null || _b === void 0 ? void 0 : _b[(_d = (_c = v.$type) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : 'base'];
+    if (typeof type !== 'string') {
+        return NOT_DEFINED;
+    }
+    if (type === 'deleted') {
+        return NOT_DEFINED;
+    }
+    if (type === 'boxed') {
+        return branchName === null || branchName === void 0 ? void 0 : branchName.$boxedValue;
+    }
+    if (v.$type[0] === 'map') {
+        const props = {};
+        for (const [k, _value] of Object.entries((branchName === null || branchName === void 0 ? void 0 : branchName.$mapProps) || {})) {
+            const value = jsonFromCell(_value);
+            if (value !== NOT_DEFINED) {
+                props[k] = value;
+            }
+        }
+        return props;
+    }
+    return NOT_DEFINED;
+});

package/dist/rogue.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rogue.test.d.ts.map

package/dist/rogue.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rogue.test.d.ts","sourceRoot":"","sources":["../src/rogue.test.ts"],"names":[],"mappings":""}