edytor 4.0.0 → 6.0.0

package/dist/crdt/edytor-doc.js

@@ -23,18 +23,16 @@
  *   `doc/types.ts` — the public types; `doc/plan.ts` — op results, a plan's
  *   effect, ingress normalization.
  * - `doc/reads.ts` (`DocBase`: the doc, its engine, its index and
- *   roles) — the reads, roles and document order; `doc/capability.ts` —
- *   structural capability (`canPlace`, `fits`, `canMerge`, the island and
- *   void rules).
+ *   roles) — the reads, roles and document order.
  * - `doc/funnel.ts` — the write funnel (`write`, `apply`, attribution);
  *   `doc/events.ts` — `onChange`; `doc/history.ts` —
  *   `createUndoManager`; `doc/anchors.ts` — caret anchors.
- * - `doc/steps.ts` — the step writers every op composes (ranks, settle,
- *   emptying, dissolving); the prepared op families over them
- *   (`OpsContext`): `doc/moves.ts`, `doc/layout.ts`, `doc/split-merge.ts`,
- *   `doc/delete.ts`, `doc/meta.ts` (type and data), `doc/content.ts`
- *   (text, atoms, marks); range deletion and flow placement are
- *   `rangeDelete.ts` and `flow.ts`.
+ * - `doc/ops.ts` — one closure over the reads: the structural capability
+ *   (`canPlace`, `fits`, `canMerge`, the island and void rules), the step
+ *   writers every op composes (ranks, settle, emptying, dissolving) and the
+ *   prepared op families (placement, layout, split and merge, delete, type
+ *   and data, text, atoms and marks), then range deletion and flow placement
+ *   over them (their types in `rangeDelete.ts` and `flow.ts`).
  *
  * ── Identity discipline ────────────────────────────────────────────────
  *
@@ -56,24 +54,15 @@ import { bindPurge, readHorizon } from './purge.js';
 import { restoreDocument } from './restore.js';
 import { bindRuns, indexOf } from './text/runs.js';
 import { bindBlockAttribution, blockAttributionOf } from './attribution/block.js';
-import { rangeDeleteOps } from './rangeDelete.js';
-import { flowOps } from './flow.js';
 import { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion } from './doc/gate.js';
 import { bindSeed, restore } from './doc/seed.js';
 import { applied, ref } from './doc/plan.js';
 import { docReads } from './doc/reads.js';
-import { docCapability } from './doc/capability.js';
 import { writeFunnel } from './doc/funnel.js';
 import { docEvents } from './doc/events.js';
 import { docHistory } from './doc/history.js';
 import { docAnchors } from './doc/anchors.js';
-import { planSteps } from './doc/steps.js';
-import { moveOps } from './doc/moves.js';
-import { layoutOps } from './doc/layout.js';
-import { splitMergeOps } from './doc/split-merge.js';
-import { deleteOps } from './doc/delete.js';
-import { metaOps } from './doc/meta.js';
-import { contentOps } from './doc/content.js';
+import { docOps } from './doc/ops.js';
 // ── schema manifest and gate (`doc/gate.ts`) ────────────────────────────
 export { SCHEMA };
 export { assertSchema, checkSchema, isInitialized, META_KEY, registryEmpty, SCHEMA_NAME, SCHEMA_VERSION, SchemaMismatchError, schemaVersion };
@@ -105,7 +94,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,30 +112,52 @@ 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);
         // The facade's parts, each over the ones before it (`doc/*`).
         const base = { Y, doc, runsView, roles, roleOf, rendersContentOf };
         const reads = { ...base, ...docReads(base) };
-        const shape = { ...reads, ...docCapability(reads) };
+        // The capability, the step writers and the prepared op families (`doc/ops.ts`).
+        const ops = { ...reads, ...docOps(reads) };
         const { blockJSON, view, blockTypeOf, blockDataOf, docData, dataItemIds, dataPreview, childrenIds, positionOf, pathOf, ancestorsOf, slotOf, isVoid, isIsland, isLines, islandOf, insideIsland, isLayout, isLayoutItem, order, compare, next, previous, displayLength, contentItems, hasBlock, live } = reads;
-        const { canPlace, fits, nestParent, canMerge, defaultChild } = shape;
+        const { canPlace, fits, nestParent, canMerge, defaultChild, plan, landingOf, besideAt } = ops;
         const funnel = writeFunnel({ ...reads, BA, config });
         const { write, apply } = funnel;
         const events = docEvents({ runsView });
@@ -157,53 +168,34 @@ export const docFacade = (Y, layers) => {
         };
         const { createUndoManager } = docHistory({ ...base, ...funnel, init });
         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);
-        /** What range deletion and flow placement compose: the step writers and the ops. */
-        const ops = { ...steps, insertBlocks, deleteBlocks, dataSteps, replaceData };
         /** Every document op, prepared — `apply(prepare.op(…))` is the op. */
         const prepare = {
-            insertBlocks,
-            moveBlocks,
+            ...ops.prepare,
             /**
              * 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 ops.prepare.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),
-            ...rangeDeleteOps(ops),
-            ...flowOps(ops)
+            deleteBlocks: (ids) => ops.prepare.deleteBlocks(ids)
+        };
+        /**
+         * 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;
@@ -226,7 +218,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 +232,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 +260,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 +271,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 +306,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 +320,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 +328,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

@@ -1,47 +1,9 @@
 /**
- * Placement of an admitted flow — one prepared document operation for
- * paste, drop and fragment insertion. The rules are the `flow.*` rows of
- * `docs/editor-delete-contract.md`:
- *
- * - a flow is lines with fresh ids: a kinded block, or an inline run (no
- *   `type`); an empty flow changes nothing (`flow.shape`);
- * - one line joins the text at the position; an empty block takes a kinded
- *   line's kind (`flow.inline`);
- * - several lines split the block: the first joins the head, the last is the
- *   tail's block and takes the text after the position and the block's
- *   children, the rest go between (`flow.split`) — children the view
- *   hides (a closed toggle's body) stay with the head, as Enter keeps them;
- * - a line that joins no text (a list, a code block, a divider: it renders
- *   none of its own, or is a void or an island) is placed as a block, never
- *   joined; the text after the position stays in a shown line of the
- *   block's kind (`flow.apart`), and the caret ends the last pasted
- *   shown line;
- * - in a code line (a `lines` island) the lines, nested ones included, are
- *   placed as plain lines (`flow.lines`);
- * - a `whole` flow (a block-selection copy) goes after the block, replacing
- *   it when empty (`flow.whole`); over selected blocks the lines take their
- *   slot (`flow.slot`), and at a slot they are placed with nothing replaced
- *   (`flow.place`: an accepted suggestion), as plain inserts (`insertBlocks`: their order
- *   against a peer's split beside them is not claimed); a void
- *   takes one run (`flow.void`);
- * - a table's cell is never split: it takes the lines a flow shows, nested
- *   ones and a pasted table's cells included, as one text joined by line
- *   breaks; a cell outside a row (cells copied out of a table) is a line of
- *   text, and a row outside a table its cells (`table.paste`);
- * - a plain line that lands directly in a container takes its item kind
- *   (the document's `fitted`: a pasted paragraph in a list is its item),
- *   and so does a line of the list's flat item kind (the view's
- *   `itemKind`: a pasted numbered item in an `ordered-list`); any
- *   other kind keeps its kind and data (a pasted image stays an image, a
- *   bulleted item in an `ordered-list` a bulleted item).
+ * The types flow placement (`insertFlow`: the `flow.*` rows, prepared in
+ * `doc/ops.ts`) reads, and where the caret ends a placed block.
  */
 import type { BlockId, BlockSpec, Destination } from './placement/model.js';
-import type { Prepared } from './edytor-doc.js';
 import type { DocPosition, RangeView } from './rangeDelete.js';
-import type { OpsContext } from './doc/steps.js';
-import type { MoveOps } from './doc/moves.js';
-import type { DeleteOps } from './doc/delete.js';
-import type { MetaOps } from './doc/meta.js';
 /** One line of a flow: a kinded block, or an inline run when it has no `type`. */
 export type FlowLine = Omit<BlockSpec, 'type'> & {
     type?: string;
@@ -72,8 +34,8 @@ export type FlowTarget = DocPosition | {
 } | {
     slot: Destination;
 };
-/** What flow placement composes: the step writers and the ops it places and deletes with. */
-export type FlowContext = OpsContext & Pick<MoveOps, 'insertBlocks'> & Pick<DeleteOps, 'deleteBlocks'> & Pick<MetaOps, 'dataSteps' | 'replaceData'>;
+/** The units of a line's content (an atom counts 1). */
+export declare const lengthOf: (l: FlowLine) => number;
 /**
  * Where the caret ends a placed block: its own content's end when it shows a
  * line (renders its content, no void; a toggle's header, never its body),
@@ -82,10 +44,6 @@ 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. */
-export declare const flowOps: (c: FlowContext) => {
-    insertFlow: (target: FlowTarget, flow: Flow, view?: FlowView) => Prepared;
-};