@encorejs/saaz 1.0.0

package/dist/rogue.test.js

@@ -0,0 +1,248 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BackMemoryAdapter } from './back/BackMemoryAdapter';
+import SaazBack from './back/SaazBack';
+import { FrontMemoryAdapter } from './front/FrontMemoryAdapter';
+import { SaazFront } from './front/SaazFront';
+import { change, fromOps, jsonFromCell } from './rogue';
+const ahistoricSnapshot = {
+    $type: ['map', 'base'],
+    $branches: {
+        base: {
+            $mapProps: {
+                foo: {
+                    $type: ['map', 'base'],
+                    $branches: {
+                        base: {
+                            $boxedValue: 'some value here, but this will be ignored, because this is an obj register.',
+                            $mapProps: {
+                                bar: {
+                                    $type: ['boxed', 'base'],
+                                    $branches: {
+                                        base: {
+                                            $boxedValue: 'some value here. this is an lww register, and it can contain any json value.',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+describe(`Rogue`, () => {
+    test('setting a non-existing prop', () => {
+        const [rep, ops] = change({}, (draft) => {
+            expect(draft.a).toBe(undefined);
+            draft.a = 1;
+            expect(draft.a).toBe(1);
+        });
+        expect(jsonFromCell(rep)).toEqual({ a: 1 });
+        expect([rep, ops]).toMatchSnapshot();
+        const [rep2] = fromOps({}, ops);
+        expect(rep2).toEqual(rep);
+    });
+    test('overriding an existing prop with the same value', () => {
+        const [rep1] = change({}, (draft) => {
+            draft.a = 1;
+        });
+        const [rep2, ops] = change(rep1, (draft) => {
+            expect(draft.a).toBe(1);
+            draft.a = 1;
+            expect(draft.a).toBe(1);
+        });
+        expect(rep1).toBe(rep2);
+        expect(ops).toEqual([]);
+    });
+    test('overriding an existing prop', () => {
+        const [rep1] = change({}, (draft) => {
+            draft.a = 1;
+        });
+        const [rep2, ops] = change(rep1, (draft) => {
+            expect(draft.a).toBe(1);
+            draft.a = 2;
+            expect(draft.a).toBe(2);
+        });
+        expect(jsonFromCell(rep2)).toEqual({ a: 2 });
+        expect(ops).toHaveLength(1);
+        expect(ops).toMatchSnapshot();
+        const [rep3] = fromOps(rep1, ops);
+        expect(rep3).toEqual(rep2);
+    });
+    test('setting a non-existing prop to an object', () => {
+        const [rep, ops] = change({}, (draft) => {
+            expect(draft.a).toBe(undefined);
+            draft.a = { b: 1 };
+            expect(draft.a).toEqual(draft.a);
+            expect(draft.a).toEqual({ b: 1 });
+        });
+        expect(jsonFromCell(rep)).toEqual({ a: { b: 1 } });
+        expect([rep, ops]).toMatchSnapshot();
+        const [rep2] = fromOps({}, ops);
+        expect(rep2).toEqual(rep);
+    });
+    test('setting an existing prop to an object', () => {
+        const [rep] = change({}, (draft) => {
+            draft.a = { b: 1 };
+        });
+        expect(jsonFromCell(rep)).toEqual({ a: { b: 1 } });
+        const [rep2, ops2] = change(rep, (draft) => {
+            expect(draft.a).toEqual({ b: 1 });
+            draft.a = { b: 2 };
+            expect(draft.a).toEqual({ b: 2 });
+        });
+        expect(jsonFromCell(rep2)).toEqual({ a: { b: 2 } });
+        const [rep3] = fromOps(rep, ops2);
+        expect(rep3).toEqual(rep2);
+    });
+    test('setting an existing prop from an object', () => {
+        const [rep] = change({}, (draft) => {
+            draft.a = { b: 1 };
+        });
+        expect(jsonFromCell(rep)).toEqual({ a: { b: 1 } });
+        const [rep2, ops2] = change(rep, (draft) => {
+            expect(draft.a).toEqual({ b: 1 });
+            draft.a = { c: 1 };
+            expect(draft.a).toEqual({ c: 1 });
+        });
+        expect(jsonFromCell(rep2)).toEqual({ a: { c: 1 } });
+        const [rep3] = fromOps(rep, ops2);
+        expect(rep3).toEqual(rep2);
+    });
+    test(`merging defaults`, () => {
+        const [, ops1_1] = change({}, (draft) => {
+            draft.a = { aStep: 1, foo: 'setBy1', obj: { objA: 'true' } };
+        });
+        const [, ops2_1] = change({}, (draft) => {
+            draft.a = { bStep: 1, foo: 'setBy2', obj: { objB: 'true' } };
+        });
+        const merge1 = fromOps({}, [...ops2_1, ...ops1_1])[0];
+        const _11 = jsonFromCell(merge1);
+        expect(_11).toMatchSnapshot();
+        // console.log(_11)
+    });
+    function scenario(name, steps) {
+        describe(name, () => {
+            let last = {
+                json: {},
+                backwardOps: [],
+                ops: [],
+                rep: {},
+            };
+            const byStep = {};
+            for (const [stepName, fn] of Object.entries(steps)) {
+                test(stepName, () => {
+                    const prev = Object.assign({}, last);
+                    const [rep, ops, backwardOps] = change(prev.rep, (draft) => {
+                        fn(draft, prev.json, prev.ops);
+                    });
+                    const stepResult = {
+                        rep,
+                        ops,
+                        backwardOps,
+                        json: jsonFromCell(rep),
+                        prev,
+                    };
+                    last.next = stepResult;
+                    last = stepResult;
+                    byStep[stepName] = stepResult;
+                });
+            }
+            // i = 0 so that we skip the first step, which is the initial state
+            for (let i = 1; i < Object.keys(steps).length; i++) {
+                const prevStepName = Object.keys(steps)[i - 1];
+                const stepName = Object.keys(steps)[i];
+                test(`${prevStepName} => ${stepName}`, () => {
+                    const stepResult = byStep[stepName];
+                    const [rep] = fromOps(stepResult.prev.rep, stepResult.ops);
+                    expect(rep).toEqual(stepResult.rep);
+                });
+                test(`${prevStepName} <= ${stepName}`, () => {
+                    const stepResult = byStep[stepName];
+                    const [rep] = fromOps(stepResult.rep, stepResult.backwardOps);
+                    const s = jsonFromCell(rep);
+                    // note that as opposed to the previous test, we're not comparing cells, we're
+                    // comparing snapshots. This is because the cells are not guaranteed to be the
+                    // same when undoing a change, but the snapshots are.
+                    expect(s).toEqual(stepResult.prev.json);
+                });
+            }
+        });
+    }
+    scenario('scenario 1', {
+        step1: (draft) => {
+            expect(draft.a).toBe(undefined);
+            draft.a = 1;
+            expect(draft.a).toBe(1);
+        },
+        step2: (_, snapshot, ops) => {
+            expect(snapshot).toEqual({ a: 1 });
+        },
+    });
+    scenario('scenario 2', {
+        step1: (draft) => {
+            draft.a = { a1: { a11: 1 } };
+            expect(draft.a.a1).toEqual({ a11: 1 });
+            draft.a.a1.a11 = 2;
+            expect(draft.a).toEqual({ a1: { a11: 2 } });
+        },
+        step2: (_, snapshot, ops) => {
+            expect(snapshot).toEqual({ a: { a1: { a11: 2 } } });
+        },
+    });
+    scenario('scenario 3', {
+        step1: (draft) => {
+            draft.a = { a1: { a11: 1 } };
+            expect(draft.a.a1).toEqual({ a11: 1 });
+            draft.a = { b: 1 };
+            expect(draft.a).toEqual({ b: 1 });
+        },
+        step2: (draft, snapshot, ops) => {
+            expect(draft.a).toEqual({ b: 1 });
+            draft.a = 1;
+        },
+        step3: (draft, snapshot) => {
+            expect(snapshot).toEqual({ a: 1 });
+        },
+    });
+    describe(`saaz integration`, () => {
+        test(`test`, () => __awaiter(void 0, void 0, void 0, function* () {
+            const schema = {
+                version: 1,
+                // migrateOp(state: $IntentionalAny) {},
+                // migrateCell(s) {},
+                generators: {},
+                editors: {
+                    increaseBy(state, generators, opts) {
+                        state.count += opts.by;
+                    },
+                },
+                opShape: null,
+                cellShape: null,
+            };
+            const backend = new SaazBack({
+                schema,
+                dbName: 'test',
+                storageAdapter: new BackMemoryAdapter(),
+            });
+            const saaz = new SaazFront({
+                schema,
+                dbName: 'test',
+                peerId: '1',
+                storageAdapter: new FrontMemoryAdapter(),
+                backend,
+            });
+            saaz.tx((editors) => { });
+            saaz.teardown();
+        }));
+    });
+});

package/dist/shared/GeneratorSpy.d.ts

@@ -0,0 +1,4 @@
+import type { GeneratorRecordings } from '../types';
+import type { ValidGenerators } from '../types';
+export declare function createGeneratorsSpy<Generators extends ValidGenerators>(generators: ValidGenerators, prevREcordings?: GeneratorRecordings, playbackOnly?: boolean): [spy: Generators, recordings: GeneratorRecordings];
+//# sourceMappingURL=GeneratorSpy.d.ts.map

package/dist/shared/GeneratorSpy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorSpy.d.ts","sourceRoot":"","sources":["../../src/shared/GeneratorSpy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,mBAAmB,EAAC,MAAM,UAAU,CAAA;AAGlE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,UAAU,CAAA;AAG7C,wBAAgB,mBAAmB,CAAC,UAAU,SAAS,eAAe,EACpE,UAAU,EAAE,eAAe,EAC3B,cAAc,GAAE,mBAAwB,EACxC,YAAY,GAAE,OAAe,GAC5B,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,mBAAmB,CAAC,CAmDpD"}

package/dist/shared/GeneratorSpy.js

@@ -0,0 +1,41 @@
+import { cloneDeep } from 'lodash-es';
+import { stableValueHash } from '@encorejs/utils/stableJsonStringify';
+export function createGeneratorsSpy(generators, prevREcordings = {}, playbackOnly = false) {
+    const recordings = cloneDeep(prevREcordings);
+    const calls = {};
+    const spy = Object.fromEntries(Object.entries(generators).map(([fnName, fn]) => {
+        if (typeof fn !== 'function') {
+            throw new Error(`Generator method "${fnName}" is not a function`);
+        }
+        if (typeof fnName !== 'string') {
+            throw new Error('key is not a string');
+        }
+        const spyFn = (...args) => {
+            var _a;
+            const key = stableValueHash([fnName, args]);
+            // Monotonic per-(fnName,args) call counter: 0 on first call, then 1, 2…
+            // (the previous `if (!calls[key])` test was stuck at 0 because 0 is
+            // falsy, so every same-args call collided on recording slot 0).
+            const callIndex = (_a = calls[key]) !== null && _a !== void 0 ? _a : 0;
+            calls[key] = callIndex + 1;
+            if (playbackOnly &&
+                (!Array.isArray(recordings[key]) ||
+                    recordings[key].length < callIndex)) {
+                throw new Error(`Generator method "${fnName}" was called with arguments that were not recorded: ${JSON.stringify(args)}`);
+            }
+            if (!recordings[key]) {
+                recordings[key] = [];
+            }
+            if (recordings[key].length > callIndex) {
+                return recordings[key][callIndex];
+            }
+            else {
+                const ret = fn(args[0]);
+                recordings[key][callIndex] = ret;
+                return ret;
+            }
+        };
+        return [fnName, spyFn];
+    }));
+    return [spy, recordings];
+}

package/dist/shared/transactions.d.ts

@@ -0,0 +1,4 @@
+import type { EditorDefinitionToEditorInvocable, Invokations, Transaction, Schema, ValidOpSnapshot as ValidOpSnapshot, GeneratorRecordings, FullSnapshot } from '../types';
+export declare function applyOptimisticUpdateToState<OpSnapshot extends ValidOpSnapshot>({ invokations, generatorRecordings, draftOps, }: Pick<Transaction, 'invokations' | 'generatorRecordings' | 'draftOps'>, before: FullSnapshot<OpSnapshot>, schema: Schema<OpSnapshot>, playbackOnly?: boolean, testDeterminism?: boolean): [after: FullSnapshot<OpSnapshot>, generatorRecordings: GeneratorRecordings];
+export declare function recordInvokations<Editors extends {}>(editors: Editors, fn: (editors: EditorDefinitionToEditorInvocable<Editors>) => void): Invokations;
+//# sourceMappingURL=transactions.d.ts.map

package/dist/shared/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../src/shared/transactions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,iCAAiC,EACjC,WAAW,EACX,WAAW,EAIX,MAAM,EACN,eAAe,IAAI,eAAe,EAElC,mBAAmB,EACnB,YAAY,EACb,MAAM,UAAU,CAAA;AAGjB,wBAAgB,4BAA4B,CAC1C,UAAU,SAAS,eAAe,EAElC,EACE,WAAW,EACX,mBAAmB,EACnB,QAAQ,GACT,EAAE,IAAI,CAAC,WAAW,EAAE,aAAa,GAAG,qBAAqB,GAAG,UAAU,CAAC,EACxE,MAAM,EAAE,YAAY,CAAC,UAAU,CAAC,EAChC,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAC1B,YAAY,GAAE,OAAe,EAC7B,eAAe,GAAE,OAAc,GAC9B,CAAC,KAAK,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,mBAAmB,EAAE,mBAAmB,CAAC,CAY7E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,EAAE,EAClD,OAAO,EAAE,OAAO,EAChB,EAAE,EAAE,CAAC,OAAO,EAAE,iCAAiC,CAAC,OAAO,CAAC,KAAK,IAAI,GAChE,WAAW,CAgBb"}

package/dist/shared/transactions.js

@@ -0,0 +1,131 @@
+import * as GeneratorSpy from './GeneratorSpy';
+import { createDraft, finishDraft } from 'immer';
+import { get } from 'lodash-es';
+import { fromOps } from '../rogue';
+export function applyOptimisticUpdateToState({ invokations, generatorRecordings, draftOps, }, before, schema, playbackOnly = false, testDeterminism = true) {
+    const draft = createDraft(before.op);
+    const [generatorSpy, newRecordings] = GeneratorSpy.createGeneratorsSpy(schema.generators, generatorRecordings, playbackOnly);
+    runInvokations(schema, draft, invokations, generatorSpy);
+    const opSnapshotAfter = finishDraft(draft);
+    const [cellAfter] = fromOps(before.cell, draftOps);
+    return [{ op: opSnapshotAfter, cell: cellAfter }, newRecordings];
+}
+export function recordInvokations(editors, fn) {
+    const { invokableEditors, release, invokations } = invokables.getInvokables(editors);
+    let released = false;
+    try {
+        fn(invokableEditors);
+        release();
+        released = true;
+    }
+    catch (error) {
+        throw error;
+    }
+    finally {
+        if (!released) {
+            release();
+        }
+    }
+    return invokations;
+}
+function runInvokations(schema, prevState, invokations, generatorSpy) {
+    for (const [fnPath, opts] of invokations) {
+        const fn = get(schema.editors, fnPath.split('.'));
+        if (typeof fn !== 'function') {
+            throw new Error(`editor ${fnPath} not found. Transaction may be corrupt, or the editor names may have changed`);
+        }
+        fn(prevState, generatorSpy, opts);
+    }
+}
+var invokables;
+(function (invokables) {
+    class Pool {
+        constructor(_factory) {
+            this._factory = _factory;
+            this._items = [];
+        }
+        /**
+         * Get an item from the pool. If the pool is empty, a new item is created. Also starts a timer to ensure that the item is released back into the pool.
+         *
+         * @returns A tuple of the item and a function to release the item back into the pool.
+         *
+         */
+        get(releaseTimeoutms = 0) {
+            const item = this._items.length === 0 ? this._factory() : this._items.pop();
+            let released = false;
+            // if the invokables are not released within 0ms, it's probably a bug + memory leak.
+            const releaseTimeout = setTimeout(() => {
+                if (!released) {
+                    throw new Error('Release timeout exceeded.');
+                }
+            }, releaseTimeoutms);
+            const release = () => {
+                released = true;
+                clearTimeout(releaseTimeout);
+                this._items.push(item);
+            };
+            return [item, release];
+        }
+    }
+    const pools = new WeakMap();
+    function getPool(editorDefinition) {
+        if (!pools.has(editorDefinition)) {
+            function createPoolItem(editors) {
+                const context = {
+                    snapshot: {},
+                    invokations: [],
+                };
+                const invokableEditors = createInvokables(editors, context);
+                return { context, invokableEditors };
+            }
+            const pool = new Pool(() => createPoolItem(editorDefinition));
+            pools.set(editorDefinition, pool);
+            return pool;
+        }
+        else {
+            return pools.get(editorDefinition);
+        }
+    }
+    function createInvokables(editors, context, pathSoFar = []) {
+        const cache = {};
+        const proxy = new Proxy(new Function(), {
+            get(_, prop) {
+                if (prop in cache) {
+                    return cache[prop];
+                }
+                else if (!(prop in editors)) {
+                    const path = [...pathSoFar, prop];
+                    throw new Error(`editor "${path.join('.')}" not found`);
+                }
+                else {
+                    const path = [...pathSoFar, prop];
+                    const sub = createInvokables(editors[prop], context, path);
+                    cache[prop] = sub;
+                    return sub;
+                }
+            },
+            apply(_, __, args) {
+                const opts = args[0];
+                if (typeof editors !== 'function') {
+                    throw new Error(`editor "${pathSoFar.join('.')}" is not a function`);
+                }
+                else {
+                    context.invokations.push([pathSoFar.join('.'), opts]);
+                }
+            },
+        });
+        return proxy;
+    }
+    function getInvokables(editorDefinitions) {
+        const pool = getPool(editorDefinitions);
+        const [poolItem, release] = pool.get();
+        const { context, invokableEditors } = poolItem;
+        context.invokations = [];
+        return {
+            invokableEditors: invokableEditors,
+            release,
+            invokations: context.invokations,
+        };
+    }
+    invokables.getInvokables = getInvokables;
+})(invokables || (invokables = {}));

package/dist/shared/utils.d.ts

@@ -0,0 +1,5 @@
+import type { FullSnapshot, Schema } from '../types';
+export declare function ensureStateIsUptodate<S extends {
+    $schemaVersion: number;
+}>(original: FullSnapshot<S> | null, schema: Schema<S>): FullSnapshot<S>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/shared/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/shared/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,EAAC,MAAM,UAAU,CAAA;AAInE,wBAAgB,qBAAqB,CAAC,CAAC,SAAS;IAAC,cAAc,EAAE,MAAM,CAAA;CAAC,EACtE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,EAChC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,YAAY,CAAC,CAAC,CAAC,CAoBjB"}

package/dist/shared/utils.js

@@ -0,0 +1,21 @@
+const empty = { op: {}, cell: {} };
+export function ensureStateIsUptodate(original, schema) {
+    if (original === null) {
+        return empty;
+    }
+    return original;
+    // if (
+    //   !original ||
+    //   typeof original.op.$schemaVersion !== 'number' ||
+    //   original.op.$schemaVersion < schema.version
+    // ) {
+    //   return {
+    //     op: produce((original?.op ?? {}) as {}, (originalDraft) => {
+    //       schema.migrateOp(originalDraft)
+    //     }) as S,
+    //     cell: original?.cell ?? {},
+    //   }
+    // } else {
+    //   return original
+    // }
+}

package/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.36.4"
+    }
+  ]
+}