edytor 5.0.0 → 7.0.0

package/dist/components/Edytor.svelte

@@ -193,6 +193,8 @@
 		params,
 		onSyncExpired,
 		onSyncRefused,
+		rebuild,
+		adopt,
 		requireHydration,
 		snapshot,
 		actor,
@@ -208,7 +210,15 @@
 		autocapitalize = 'none',
 		inputmode,
 		enterkeyhint
-	}: EdytorProps = $props();
+	}: EdytorProps & {
+		/** The view's own rebuild (`EdytorRoot`): a new view on a new document. */
+		rebuild?: () => void;
+		/**
+		 * Hands the view to `EdytorRoot`, which a binding cannot: on the server a
+		 * bound prop renders the tree twice, and the discarded view never ends.
+		 */
+		adopt?: (view: EdytorClass) => void;
+	} = $props();
 
 	const initialEdytorOptions = untrack(() => ({
 		readonly,
@@ -227,6 +237,7 @@
 	}));
 
 	edytor = new EdytorClass(initialEdytorOptions);
+	untrack(() => adopt)?.(edytor);
 
 	// ONE attach path for owned and injected documents: `attachSync`
 	// tracks the provider on the DOCUMENT's lifetime (one provider per
@@ -276,7 +287,11 @@
 		}
 		// Subscribe first, then replay the standing refusal isolated like the
 		// later ones: a throwing callback still hears the next refusal.
-		offRefused = document.onSyncRefused((next) => onSyncRefused?.(next));
+		offRefused = document.onSyncRefused((next) => {
+			onSyncRefused?.(next);
+			// A re-seed (`4410`): a view that owns its document builds itself again on a new one.
+			if (next.code === CLOSE.reseeded && !edytorDocument) rebuild?.();
+		});
 		if (refusal) {
 			try {
 				onSyncRefused?.(refusal);
@@ -379,7 +394,7 @@
 			contenteditable="false"
 			aria-hidden="true"
 			style="display: none"
-			use:edytor.surface.anchor
+			use:edytor.surface.own
 		></span>
 	</div>
 {:else if snapshot}

package/dist/components/Edytor.svelte.d.ts

@@ -113,6 +113,15 @@ export type EdytorProps = {
 import type { JSONDoc } from '../utils/json.js';
 import type { HotKey, HotKeyCombination } from '../session/keymap.js';
 import type { EdytorSelection } from '../selection/selection.svelte.js';
-declare const Edytor: import("svelte").Component<EdytorProps, {}, "edytor">;
+type $$ComponentProps = EdytorProps & {
+    /** The view's own rebuild (`EdytorRoot`): a new view on a new document. */
+    rebuild?: () => void;
+    /**
+     * Hands the view to `EdytorRoot`, which a binding cannot: on the server a
+     * bound prop renders the tree twice, and the discarded view never ends.
+     */
+    adopt?: (view: EdytorClass) => void;
+};
+declare const Edytor: import("svelte").Component<$$ComponentProps, {}, "edytor">;
 type Edytor = ReturnType<typeof Edytor>;
 export default Edytor;

package/dist/components/EdytorRoot.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+	// The public `<Edytor>`: the view, built again on a new document when the
+	// room re-seeds the one it owns (`room.reseed.protocol`).
+	import Edytor, { type EdytorProps } from './Edytor.svelte';
+
+	// eslint-disable-next-line no-useless-assignment -- bindable: `adopt` assigns it
+	let { edytor = $bindable(), ...props }: EdytorProps = $props();
+	let epoch = $state(0);
+</script>
+
+<!-- A view built again loads the room's document: it never seeds its value over it. -->
+{#key epoch}<Edytor
+		{...props}
+		requireHydration={epoch > 0 || props.requireHydration}
+		adopt={(view) => (edytor = view)}
+		rebuild={() => epoch++}
+	/>{/key}

package/dist/components/EdytorRoot.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type EdytorProps } from './Edytor.svelte';
+declare const EdytorRoot: import("svelte").Component<EdytorProps, {}, "edytor">;
+type EdytorRoot = ReturnType<typeof EdytorRoot>;
+export default EdytorRoot;

package/dist/components/Suggestion.svelte

@@ -31,7 +31,7 @@
 	contenteditable="false"
 	aria-label={suggestion.label ?? labelsOf(edytor, 'editor', editorEnglish).suggestion}
 	role="group"
-	use:edytor.surface.preview={suggestion.id}
+	use:edytor.surface.own={suggestion.id}
 	onmousedown={cancel}
 >
 	{#each cells as cell (cell.id)}<Block kid={cell} />{/each}

package/dist/crdt/attribution/block.d.ts

@@ -78,6 +78,9 @@ export type BlockAttribution = {
     lastChangedBy?: ActorId;
 };
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
+/** A record's `createdBy` key, and the prefix of its contributors' (a re-seed copies them: `crdt/reseed.ts`). */
+export declare const CREATED_KEY = "c";
+export declare const CONTRIBUTOR_PREFIX = "k/";
 /** The `k/` member set on a `b/` record node. */
 export declare const contributorsOfRecord: (rec: EngineNode | null) => Set<ActorId>;
 /**

package/dist/crdt/attribution/block.js

@@ -5,8 +5,9 @@ import { attrItems, newNode as makeNode } from '../structs.js';
 // `../schema.js` leaf — re-exported so existing import sites stay.
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
 const REC_NODE = 'brec';
-const CREATED_KEY = 'c';
-const CONTRIBUTOR_PREFIX = 'k/';
+/** A record's `createdBy` key, and the prefix of its contributors' (a re-seed copies them: `crdt/reseed.ts`). */
+export const CREATED_KEY = 'c';
+export const CONTRIBUTOR_PREFIX = 'k/';
 /** Incarnation stamp on a record: the nonce `n` of the node it belongs to. */
 const INCARNATION_KEY = 'i';
 const recordOf = (doc, id) => {

package/dist/crdt/doc/history.js

@@ -20,6 +20,7 @@ import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, eng
 import { isInitialized } from './gate.js';
 import { DocumentDestroyedError } from './funnel.js';
 import { registryOf, withdrawOnUndo } from '../placement/model.js';
+import { getOr } from '../../utils.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export const DEFAULT_HISTORY_LIMIT = 200;
 /** The origin of the transaction that releases a dropped history step's content. */
@@ -465,9 +466,7 @@ export const historyRules = (Y, doc) => {
             if (step.inserts.has(s.id.client, s.id.clock))
                 return;
             const values = s.content;
-            let attrs = lost.get(node);
-            if (attrs === undefined)
-                lost.set(node, (attrs = new Map()));
+            const attrs = getOr(lost, node, () => new Map());
             attrs.set(key, values.getContent().at(-1));
         });
         for (const [node, attrs] of lost) {

package/dist/crdt/doc/ops.d.ts

@@ -0,0 +1,81 @@
+import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
+import { type DataPatch } from '../data.js';
+import { type BlockId, type BlockSpec, type ContentItem, type Destination, type InlineSpec, type SplitTail } from '../placement/model.js';
+import type { DataTarget, Plan, PlanStep, Prepared } from './types.js';
+import type { DocBase, DocReads } from './reads.js';
+import type { DocPosition, RangeView } from '../rangeDelete.js';
+import { type Flow, type FlowTarget, type FlowView } from '../flow.js';
+/**
+ * A record's order among the records standing at one block, for the
+ * engine's sort of two records at one origin (fork patch YP22): what a split
+ * of a list around a block writes there — a new head list holding the items
+ * before it (`head`), new blocks placed after the items before it, which
+ * stay (`kept`), a head holding those items and the block (`with`), the
+ * block itself leaving (`self`), new blocks after it (`after`) — in the
+ * order every serial run of the gestures gives (`del.merge.container`).
+ */
+export declare const PART: {
+    readonly head: 0;
+    readonly kept: 1;
+    readonly with: 2;
+    readonly self: 3;
+    readonly after: 4;
+};
+/** An inline atom to insert: its id is minted when it names none. */
+export type NewInline = Omit<InlineSpec, 'id'> & {
+    id?: string;
+};
+/** The prepared ops of one facade over its reads. */
+export declare const docOps: (c: DocBase & DocReads) => {
+    plan: (ids: readonly BlockId[], writes: PlanStep[], at?: DocPosition) => Plan;
+    canPlace: (ids: readonly BlockId[], parent?: BlockId | null, kindOf?: (id: BlockId) => string | undefined) => boolean;
+    fits: (parent: BlockId | null, kind: string | undefined) => boolean;
+    nestParent: (ids: readonly BlockId[], parent: BlockId) => BlockId;
+    canMerge: (fromId: BlockId, intoId: BlockId) => boolean;
+    defaultChild: (parent: BlockId | null) => string;
+    landingOf: (id: BlockId, kind: string, after?: boolean) => {
+        parent: string | null;
+        levels: string[];
+    };
+    besideAt: (target: BlockId, kind?: string) => BlockId;
+    /** Every op of the families, prepared. */
+    prepare: {
+        insertBlocks: (dest: Destination, specs: readonly (BlockSpec | JSONBlock)[]) => Prepared;
+        moveBlocks: (ids: readonly BlockId[], dest: Destination) => Prepared;
+        unNestBlocks: (ids: readonly BlockId[]) => Prepared;
+        unNestBlock: (id: BlockId) => Prepared;
+        liftOut: (id: BlockId, kind: string, { keep, after }?: {
+            keep?: boolean;
+            after?: readonly BlockSpec[];
+        }) => Prepared;
+        duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+        placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
+        wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
+        splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
+        mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
+        mergeBackward: (id: BlockId) => Prepared;
+        mergeForward: (id: BlockId) => Prepared;
+        deleteBlocks: (ids: readonly BlockId[], subtree?: boolean, filled?: BlockId | null) => Prepared;
+        deleteBlock: (id: BlockId, opts?: {
+            keepChildren?: boolean;
+        }) => Prepared;
+        setBlockType: (id: BlockId, type: string) => Prepared;
+        patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
+        setBlock: (id: BlockId, value: {
+            type?: string;
+            data?: Record<string, unknown>;
+            content?: (ContentItem | JSONText | JSONInlineBlock)[];
+            children?: (BlockSpec | JSONBlock)[];
+        }) => Prepared;
+        insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
+        deleteText: (id: BlockId, offset: number, length: number) => Prepared;
+        formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
+        clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
+        insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
+        removeInline: (id: BlockId, inlineId: string) => Prepared;
+        insertFlow: (target: FlowTarget, flow: Flow, view?: FlowView) => Prepared;
+        deleteRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
+        replaceRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
+    };
+};
+export type DocOps = ReturnType<typeof docOps>;