edytor 4.0.0 → 5.0.0

package/dist/crdt/edytor-doc.js

@@ -105,7 +105,7 @@ export const docFacade = (Y, layers) => {
     // per-doc (WeakMap-keyed), so facades on the same doc share it.
     const BA = bindBlockAttribution(Y);
     const { init, seed } = bindSeed(Y, BA);
-    return (doc, config = {}) => {
+    const create = (doc, config = {}) => {
         adoptRules(doc);
         setMarkEdges(doc, config.markEdge ?? (() => undefined));
         const roleOf = config.roleOf ?? (() => undefined);
@@ -123,21 +123,42 @@ export const docFacade = (Y, layers) => {
         // A layout displays only its items — its
         // `defaultChild` kind — and only two or more (`layout.*`). A table
         // displays only its rows and a row only its cells (`table.*`).
+        let kinds = new Map();
+        let declared;
         const roles = {
-            childless: (type) => roleOf(type)?.void === true,
-            island: (type) => roleOf(type)?.island === true,
-            container: (type) => !rendersContentOf(type) && roleOf(type)?.void !== true && roleOf(type)?.island !== true,
-            rendersContent: (type) => rendersContentOf(type),
-            defaultChild: (type) => (type !== null ? defaultChildOf(type) : undefined) ?? defaultType,
-            line: (type) => {
-                const role = roleOf(type);
-                return role?.island === true && role.lines === true ? defaultChildOf(type) : undefined;
+            of: (type) => {
+                let k = kinds.get(type);
+                if (k === undefined) {
+                    const role = type === null ? undefined : roleOf(type);
+                    const own = type === null ? undefined : defaultChildOf(type);
+                    const renders = type === null || rendersContentOf(type);
+                    kinds.set(type, (k = {
+                        childless: role?.void === true,
+                        island: role?.island === true,
+                        container: !renders && role?.void !== true && role?.island !== true,
+                        rendersContent: renders,
+                        child: own ?? defaultType,
+                        line: role?.island === true && role.lines === true ? own : undefined,
+                        layout: role?.layout === true ? own : undefined,
+                        table: role?.table === true ? own : undefined
+                    }));
+                }
+                return k;
             },
-            lineKinds: () => [...(config.kinds?.() ?? [])].flatMap((type) => roles.line(type) ?? []),
-            layout: (type) => (roleOf(type)?.layout === true ? defaultChildOf(type) : undefined),
-            layoutKinds: () => [...(config.kinds?.() ?? [])].filter((type) => roles.layout(type) !== undefined),
-            table: (type) => (roleOf(type)?.table === true ? defaultChildOf(type) : undefined),
-            tableKinds: () => [...(config.kinds?.() ?? [])].filter((type) => roles.table(type) !== undefined)
+            declared: () => {
+                if (declared === undefined) {
+                    const all = [...(config.kinds?.() ?? [])].map(roles.of);
+                    const rows = new Map(all.flatMap((k) => (k.table ? [[k.table, roles.of(k.table).child]] : [])));
+                    declared = {
+                        lines: new Set(all.flatMap((k) => k.line ?? [])),
+                        layouts: [...(config.kinds?.() ?? [])].filter((t) => roles.of(t).layout !== undefined),
+                        items: new Set(all.flatMap((k) => k.layout ?? [])),
+                        rows,
+                        cells: new Set(rows.values())
+                    };
+                }
+                return declared;
+            }
         };
         if (config.roleOf)
             runsView.roles(roles);
@@ -159,52 +180,51 @@ export const docFacade = (Y, layers) => {
         const { anchorAt, followUndo, resolveAnchor } = docAnchors(reads);
         const steps = { ...shape, ...planSteps(shape) };
         const { plan } = steps;
-        // The prepared op families (`OpsContext`: the reads, capability and step writers).
-        const { insertBlocks, moveBlocks, unNestBlocks, unNestBlock, landingOf, liftOut, duplicateBlock } = moveOps(steps);
-        const { besideAt, placeBeside, wrapInLayout } = layoutOps(steps);
-        const { splitBlock, mergeBlocks, mergeBackward, mergeForward } = splitMergeOps(steps);
-        const { deleteBlocks, deleteBlock } = deleteOps(steps);
-        const { dataSteps, replaceData, setBlockType, patchData, setBlock } = metaOps(steps);
-        const { insertText, deleteText, formatRange, clearMarks, insertInline, removeInline } = contentOps(steps);
+        // The prepared op families (`OpsContext`: the reads, capability and step
+        // writers): every op they answer is a document write, but for the reads
+        // and step writers taken out here.
+        const { landingOf, ...moves } = moveOps(steps);
+        const { besideAt, ...layouts } = layoutOps(steps);
+        const { dataSteps, replaceData, ...metas } = metaOps(steps);
+        const deletes = deleteOps(steps);
         /** What range deletion and flow placement compose: the step writers and the ops. */
-        const ops = { ...steps, insertBlocks, deleteBlocks, dataSteps, replaceData };
+        const ops = { ...steps, ...moves, ...deletes, dataSteps, replaceData };
         /** Every document op, prepared — `apply(prepare.op(…))` is the op. */
         const prepare = {
-            insertBlocks,
-            moveBlocks,
+            ...moves,
+            ...layouts,
+            ...splitMergeOps(steps),
+            ...deletes,
+            ...metas,
+            ...contentOps(steps),
             /**
              * Move `id` to the last position under `parent` — under a container
              * it is no item of, under its last item (`nestParent`: Tab after a list).
              */
             nestBlock: (id, parent) => {
                 const at = nestParent([ref(id)], ref(parent));
-                return moveBlocks([id], { parent: at, index: childrenIds(at).length });
+                return moves.moveBlocks([id], { parent: at, index: childrenIds(at).length });
             },
-            unNestBlock,
-            unNestBlocks,
-            liftOut,
-            placeBeside,
-            wrapInLayout,
-            splitBlock,
-            mergeBlocks,
-            mergeBackward,
-            mergeForward,
-            deleteBlock,
-            setBlock,
-            setBlockType,
-            patchData,
-            duplicateBlock,
-            insertText,
-            deleteText,
-            formatRange,
-            clearMarks,
-            insertInline,
-            removeInline,
             /** Delete a block selection — one plan; only the members leave (`deleteBlocks` above). */
-            deleteBlocks: (ids) => deleteBlocks(ids),
+            deleteBlocks: (ids) => deletes.deleteBlocks(ids),
             ...rangeDeleteOps(ops),
             ...flowOps(ops)
         };
+        /**
+         * What a part built over this document reads beyond the facade (the
+         * shared suggestions, `doc/suggest.ts`): the reads, a facade over
+         * another doc (`create`, with this `config`);
+         * `v` counts its changes no index fact shows (in `version`), and
+         * `base`, when set, is the export `toJSON()` gives unless asked for
+         * the suggestions.
+         */
+        const part = {
+            ...reads,
+            config,
+            create: create,
+            v: 0,
+            base: undefined
+        };
         /**
          * Plans prepared at one version, as one plan (refused if any part is;
          * stamped with the oldest part's version, so `apply` refuses a stale
@@ -226,7 +246,11 @@ export const docFacade = (Y, layers) => {
          * omitted when empty): the one serializer, {@link blockJSON}, over the
          * root's visible children.
          */
-        const toJSON = () => {
+        const toJSON = (options) => {
+            // A part's export first (the shared suggestions': without the pending ones, `sugg.json.base`).
+            const base = !options?.suggestions && part.base?.();
+            if (base)
+                return base;
             const data = docData();
             const children = childrenIds(null).map(blockJSON);
             return Object.keys(data).length > 0
@@ -236,32 +260,17 @@ export const docFacade = (Y, layers) => {
         // ── facade object ─────────────────────────────────────────────────
         /** A read taking an id first: the id normalizes at ingress. */
         const byRef = (f) => (id, ...rest) => f(ref(id), ...rest);
-        const facade = {
-            // lifecycle
-            init: (opts) => write(() => init(doc, opts)),
-            /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
-            seed: (value, data) => write(() => seed(doc, value, defaultType, data)),
-            isInitialized: () => isInitialized(doc),
-            /** Replicated `meta.v` schema version (the module-level read, bound). */
-            schemaVersion: () => schemaVersion(doc),
-            /**
-             * The schema gate for this doc — throws {@link SchemaMismatchError}
-             * on unversioned-content or unsupported-version state. Consumers
-             * (`Edytor.sync()`, packed consumers) call it before trusting
-             * a synced doc.
-             */
-            checkSchema: () => checkSchema(doc),
-            assertSchema: () => assertSchema(doc),
-            dispose,
-            createUndoManager,
+        /**
+         * The public operations (`DocumentOperations`), each name once: what
+         * an `EdytorDocument` forwards. The facade has them and the internal
+         * members below.
+         */
+        const api = {
             // reads — every id argument normalizes at ingress
             project: () => project(doc),
             toJSON,
             blockJSON: byRef(blockJSON),
             childrenIds: byRef(childrenIds),
-            /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
-            childSlots: (parent) => view().kids.get(parent) ?? [],
-            slotOf: byRef(slotOf),
             positionOf: byRef(positionOf),
             pathOf: byRef(pathOf),
             parentOf: byRef((id) => positionOf(id)?.parent ?? null),
@@ -279,8 +288,6 @@ export const docFacade = (Y, layers) => {
              * O(1) per call; live-replicated (remote values read the same).
              */
             blockAttribution: byRef((id) => blockAttributionOf(doc, id)),
-            crdtId: byRef((id) => crdtId(doc, id)),
-            resolveBlock: byRef((id) => resolveBlock(doc, id)),
             displayLength: byRef(displayLength),
             contentItems: byRef(contentItems),
             hasBlock: byRef(hasBlock),
@@ -292,10 +299,6 @@ export const docFacade = (Y, layers) => {
             // caret anchors — backing-text-bound selection endpoints
             anchorAt: byRef(anchorAt),
             resolveAnchor,
-            followUndo,
-            // roles
-            /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
-            rolesChanged: () => runsView.roles(roles),
             isVoid: byRef(isVoid),
             isIsland: byRef(isIsland),
             isLines: byRef(isLines),
@@ -331,10 +334,8 @@ export const docFacade = (Y, layers) => {
             nestParent: (ids, parent) => nestParent(ids.map(ref), ref(parent)),
             /** Where a block of `kind` at `id`'s place lands, and the containers it leaves (`liftOut`). */
             landingOf: (id, kind, after) => landingOf(ref(id), ref(kind), after),
-            defaultChild: byRef(defaultChild),
             // maintained runs (bound to this doc)
             runs: byRef(runsView.runs),
-            contentJSON: byRef(runsView.contentJSON),
             // events
             onChange,
             // every op — each returns an {@link OpResult}; `apply(prepare.op(…))`
@@ -347,10 +348,6 @@ export const docFacade = (Y, layers) => {
             // transactions (composed ops already run in one; expose for callers
             // that batch several ops into one undo step / one event)
             transact: (fn, origin) => write(() => doc.transact(fn, origin)),
-            // escape hatch for the history and debugging — the bound engine layers.
-            model: layers.model,
-            text: layers.text,
-            runsView,
             // ── model-state version ─────────────────────────────
             /**
              * The index version — bumps on every fold that changed derived
@@ -359,11 +356,57 @@ export const docFacade = (Y, layers) => {
              * post-write state — this is the read-your-writes contract.
              */
             get version() {
-                return runsView.version();
+                // A part's change may show in no index fact (a suggestion's decision).
+                return runsView.version() + part.v;
             }
         };
-        return facade;
+        const internal = {
+            // lifecycle
+            init: (opts) => write(() => init(doc, opts)),
+            /** Apply the deterministic seed of `value` and the document's `data` — the document's seed decision. */
+            seed: (value, data) => write(() => seed(doc, value, defaultType, data)),
+            isInitialized: () => isInitialized(doc),
+            /** Replicated `meta.v` schema version (the module-level read, bound). */
+            schemaVersion: () => schemaVersion(doc),
+            /**
+             * The schema gate for this doc — throws {@link SchemaMismatchError}
+             * on unversioned-content or unsupported-version state. Consumers
+             * (`Edytor.sync()`, packed consumers) call it before trusting
+             * a synced doc.
+             */
+            checkSchema: () => checkSchema(doc),
+            assertSchema: () => assertSchema(doc),
+            dispose,
+            createUndoManager,
+            /** @internal What a part built over the document reads and writes (`doc/suggest.ts`). */
+            part,
+            /** Visible children of `parent` with their ranks, in `(rank, id)` order. */
+            childSlots: (parent) => view().kids.get(parent) ?? [],
+            slotOf: byRef(slotOf),
+            crdtId: byRef((id) => crdtId(doc, id)),
+            resolveBlock: byRef((id) => resolveBlock(doc, id)),
+            followUndo,
+            // roles
+            /** Re-read the roles after `roleOf` answers differently (roles adopted later). */
+            rolesChanged: (place = true) => {
+                kinds = new Map();
+                declared = undefined;
+                if (place)
+                    runsView.roles(roles);
+            },
+            defaultChild: byRef(defaultChild),
+            contentJSON: byRef(runsView.contentJSON),
+            // escape hatch for the history and debugging — the bound engine layers.
+            model: layers.model,
+            text: layers.text,
+            runsView,
+            /** The public members' names (`EdytorDocument` forwards them). */
+            api: api
+        };
+        // The public members joined as they are (the `version` getter stays one).
+        return Object.defineProperties(internal, Object.getOwnPropertyDescriptors(api));
     };
+    return create;
 };
 /**
  * Bind the assembled model to a concrete engine surface. `Y` must be the

package/dist/crdt/engine-api.d.ts

@@ -78,9 +78,15 @@ export interface EngineNode {
      * Delete `length` live units at `index`. With `into` (the document's
      * records list), they are held by one record appended there instead (a
      * delete its writer can take back), except those `fresh` names, which are
-     * removed.
+     * removed. With `propose` (a suggestion's delete), each
+     * unit is sorted: `1` held as above (its author's own), `2` proposed (an
+     * id list appended to `propose.into`) or `3` stepped over; proposed and
+     * stepped-over units read gone until the engine's `unhide`.
      */
-    delete(index: number, length?: number, into?: EngineNode | null, fresh?: unknown): void;
+    delete(index: number, length?: number, into?: EngineNode | null, fresh?: unknown, propose?: {
+        into: EngineNode;
+        sort: (client: number, clock: number) => number;
+    } | null): void;
     /** Append one hold record of `ids` (`client, clock, len` triples) to this records list: they read as deleted while it lives. */
     hold(ids: number[]): void;
     /**

package/dist/crdt/engine.d.ts

@@ -30,6 +30,7 @@ export type EngineSymbol =
 	| 'followRedone'
 	| 'isParentOf'
 	| 'mergeIdSets'
-	| 'createID';
+	| 'createID'
+	| 'unhide';
 
 export declare const Y: Pick<typeof V, EngineSymbol>;

package/dist/crdt/engine.js

@@ -45,5 +45,7 @@ export const Y = {
 	followRedone: V.followRedone,
 	isParentOf: V.isParentOf,
 	mergeIdSets: V.mergeIdSets,
-	createID: V.createID
+	createID: V.createID,
+	// a suggestion's proposed deletion reads gone until its plan ends (fork patch YP32)
+	unhide: V.unhide
 };

package/dist/crdt/flow.d.ts

@@ -82,7 +82,7 @@ export type FlowContext = OpsContext & Pick<MoveOps, 'insertBlocks'> & Pick<Dele
  * paragraph (`doc.empty.virtual`) place the caret by it.
  */
 export declare const placedEnd: (roleOf: (kind: string) => {
-    void: boolean;
+    childless: boolean;
     rendersContent: boolean;
 }) => (s: BlockSpec) => DocPosition | undefined;
 /** `insertFlow`, prepared. */

package/dist/crdt/flow.js

@@ -14,7 +14,7 @@ const lengthOf = (l) => (l.content ?? []).reduce((n, i) => n + (i.kind === 'text
 export const placedEnd = (roleOf) => {
     const endOf = (s) => {
         const role = roleOf(s.type);
-        if (role.rendersContent && !role.void)
+        if (role.rendersContent && !role.childless)
             return { block: s.id, offset: lengthOf(s) };
         for (const kid of [...(s.children ?? [])].reverse()) {
             const at = endOf(kid);
@@ -27,15 +27,9 @@ export const placedEnd = (roleOf) => {
 };
 /** `insertFlow`, prepared. */
 export const flowOps = (c) => {
-    /** A kind's roles, as placement reads them. */
-    const roleOf = (kind) => ({
-        void: c.roles.childless(kind),
-        island: c.roles.island(kind),
-        rendersContent: c.roles.rendersContent(kind),
-        layout: c.roles.layout(kind)
-    });
+    const roleOf = c.roles.of;
     /** What a kind is in a table: the table, its row or its cell. */
-    const tableKind = (kind) => c.roles.table(kind) !== undefined
+    const tableKind = (kind) => roleOf(kind).table !== undefined
         ? 'table'
         : c.isRowKind(kind)
             ? 'row'
@@ -150,7 +144,7 @@ export const flowOps = (c) => {
             const apart = (l, under) => {
                 const kind = l.type && fit(under, l.type);
                 const role = kind ? roleOf(kind) : undefined;
-                return !!role && (!role.rendersContent || role.void || role.island);
+                return !!role && (!role.rendersContent || role.childless || role.island);
             };
             // At the end of a container's header whose body shows, what follows the caret
             // leads its children and the body stays, as Enter opens a first child