edytor 4.0.0 → 6.0.0

package/dist/crdt/structs.d.ts

@@ -212,6 +212,8 @@ export declare const engineOps: (Y: EngineApi) => {
     merge: (sets: IdSetLike[]) => IdSetOf;
     /** Whether a store struct is an item (not a GC or a Skip). */
     isItem: (struct: unknown) => struct is StoreStruct;
+    /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+    unhide: (tr: unknown) => void;
     /** Whether `item` sits in `node`'s subtree. */
     inside: (node: EngineNode, item: StoreStruct) => boolean;
     /** Keep `item` (and its parents) from collection (`keepItem`). */

package/dist/crdt/structs.js

@@ -238,6 +238,8 @@ export const engineOps = (Y) => {
         merge: (sets) => Y.mergeIdSets(sets),
         /** Whether a store struct is an item (not a GC or a Skip). */
         isItem: (struct) => struct instanceof Y.Item,
+        /** Show again what a suggestion's deletes in `tr` proposed (fork patch YP32). */
+        unhide: (tr) => Y.unhide(tr),
         /** Whether `item` sits in `node`'s subtree. */
         inside: (node, item) => Y.isParentOf(asYNode(node), item),
         /** Keep `item` (and its parents) from collection (`keepItem`). */

package/dist/crdt/text/index/build.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The per-document index (`indexOf`) as ONE closure: its state, then its
+ * parts — the claim graph, the stream table and each block's claims, the
+ * layout and table rules, placements and the children index (with THE
+ * shown-kind rule, `typeOf`), block records, the run cache, the fold and the
+ * change report — each reading the state and the parts before it as closure
+ * variables, then the view (`RunView`) over them. `../runs.ts` declares the
+ * index's types and contracts. The self-checks (`indexChecks`) read the
+ * maintained facts through {@link IndexFacts} and rebuild their own.
+ */
+import type { EngineDoc, EngineNode, EngineTransaction } from '../../engine-api.js';
+import { type BlockId, type BlockRec, type ChildSlot, type DisplayOwnership, type ResolvedPlacement } from '../../placement/model.js';
+import { type IdSetLike } from '../../structs.js';
+import { type LiveRow, type RowItem } from '../rows.js';
+import type { ContentRun, RunView } from '../runs.js';
+import { type Cached } from './shared.js';
+import { type Claim, type Owner, type Stream } from '../model.js';
+import { type Edge, type SlotRef } from '../../placement/resolve.js';
+export type TextEdit = {
+    item: RowItem;
+    len: number;
+    del: boolean;
+};
+export type TextEdits = {
+    edits: TextEdit[];
+    scan: boolean;
+    opaque: boolean;
+};
+/** One fold's effects: invalidated blocks, rescanned texts, rebuilt facets. */
+export type FoldCtx = {
+    invalidated: Set<BlockId>;
+    /** Per home block: its text's edits, whether it rescans, whether every reader re-reads. */
+    texts: Map<BlockId, {
+        edits: TextEdit[];
+        scan: boolean;
+        opaque: boolean;
+        seen: Set<TextEdits>;
+    }>;
+    /** The blocks whose entry or nonce changed: their delimiters are re-decided. */
+    named: Set<BlockId>;
+    table: boolean;
+    /** The winning parents, before and after, of the blocks the fold touched. */
+    parents: Set<BlockId>;
+};
+/** A slot in a children index: its display parent, rank and the island it displays out of. */
+export type Slot = {
+    parent: BlockId | null;
+    rank: string;
+    reset?: BlockId;
+};
+/** Each row's segments at its last placement: segment 0's block, then each cut's key and block. */
+export type Placed = {
+    head: BlockId | null;
+    keys: string[];
+    blocks: (BlockId | null)[];
+};
+/** The tree the change report last published. */
+export type Published = {
+    nodes: Map<BlockId, {
+        parent: BlockId | null;
+        index: number;
+        type: string;
+        data: unknown;
+        runs: readonly ContentRun[];
+        key?: string;
+    }>;
+    order: Map<BlockId | null, readonly BlockId[]>;
+    /** The children index version it was taken at. */
+    kids: number;
+};
+/** A transaction as the fold reads it. */
+export type Tx = {
+    insertSet?: IdSetLike;
+    deleteSet?: IdSetLike;
+    changed?: EngineTransaction['changed'];
+    /** The visibility changes hold records made, in order (fork patch YP20). */
+    holds?: number[];
+    /** The units whose mover changed, in order (fork patch YP22). */
+    moves?: number[];
+};
+/** The index's self-checks (`indexChecks`), run after each fold and each report. */
+export type SelfChecks = {
+    check: () => void;
+    checkPublished: (pub: Published) => void;
+};
+/**
+ * What the self-checks read of one index: the facts it maintains
+ * incrementally (compared with their rebuild from the replicated state) and
+ * the reads they compare through.
+ */
+export type IndexFacts = {
+    doc: EngineDoc;
+    registry: EngineNode;
+    blocks: ReadonlyMap<BlockId, BlockRec>;
+    displaysMap: ReadonlyMap<BlockId, ReadonlySet<BlockId>>;
+    rows: ReadonlyMap<BlockId, LiveRow>;
+    streamIx: ReadonlyMap<BlockId, unknown>;
+    delim: ReadonlyMap<BlockId, string>;
+    placementsMap: ReadonlyMap<BlockId, ResolvedPlacement>;
+    slotsByBlock: ReadonlyMap<BlockId, SlotRef[]>;
+    edges: ReadonlyMap<BlockId, Edge | null>;
+    rejected: ReadonlySet<BlockId>;
+    kids0: Map<BlockId | null, ChildSlot[]>;
+    kidsMap: Map<BlockId | null, ChildSlot[]>;
+    slots: ReadonlyMap<BlockId, Slot>;
+    dissolved: ReadonlySet<BlockId>;
+    following: ReadonlySet<BlockId>;
+    cache: ReadonlyMap<BlockId, Cached>;
+    dirty: ReadonlySet<BlockId>;
+    ownShim: DisplayOwnership;
+    own0: DisplayOwnership;
+    ownerOf: (b: BlockId) => Owner;
+    streamOf: (b: BlockId) => Stream | undefined;
+    sameClaims: (x: readonly Claim[], y: readonly Claim[]) => boolean;
+    dissolve: (kids: Map<BlockId | null, ChildSlot[]>) => Set<BlockId>;
+    noteFollowing: (id: BlockId) => void;
+    ensurePlacements: () => void;
+    computeFresh: (b: BlockId) => {
+        fresh: readonly ContentRun[];
+    };
+    unfolded: () => boolean;
+    reachable: (prev?: Published['nodes']) => Published;
+};
+/** The doc's index — built on first use, torn down when the doc is destroyed. */
+export declare const indexOf: (doc: EngineDoc) => RunView;