edytor 1.0.0-rc.3 → 2.0.0

package/dist/edytor.svelte.d.ts

@@ -1,4 +1,3 @@
-import { type Snippet } from 'svelte';
 import { Suggestions } from './session/suggestions.svelte.js';
 import { type JSONDoc } from './utils/json.js';
 import { EdytorSelection } from './selection/selection.svelte.js';
@@ -6,23 +5,28 @@ import { type Cells } from './surface/cells.js';
 import { Overlay } from './surface/overlay.js';
 import { Popups } from './surface/popups.svelte.js';
 import { Announcer as AnnouncerState } from './session/announcer.svelte.js';
-import { type EditorLabels, type PartialLabels } from './labels.js';
+import type { PartialLabels } from './labels.js';
 import type { Block } from './block/block.svelte.js';
-import type { Text } from './text/text.svelte.js';
 import { Handles } from './session/handles.js';
 import { type Awareness, type DocChange, type DocumentActor, type EdytorDocument, type OrderPolicy, type YDoc } from './crdt/index.js';
 import { PresenceWriter, type PresenceOptions } from './collaboration/awarenessSelection.js';
 import { type BlockMoveRequest } from './session/moves.js';
-import type { Plugin, BlockSnippetPayload, MarkSnippetPayload, BlockDefinition, MarkDefinition, InlineBlockDefinition, InlineBlockSnippetPayload, EditorCommand, Placeholder } from './plugins.js';
+import { type DocumentWrites } from './crdt/operations.js';
+import type { Plugin, BlockDefinition, MarkDefinition, InlineBlockDefinition, EditorCommand, Placeholder } from './plugins.js';
 import { type HotKey, type HotKeyCombination } from './session/keymap.js';
 import { Dispatcher } from './session/commands.js';
 import { type KindRow } from './kinds.js';
-export type Snippets = {
-    [K in `${string}InlineBlock` | `${string}Block` | `${string}Mark`]: K extends `${string}InlineBlock` ? Snippet<[InlineBlockSnippetPayload]> : K extends `${string}Block` ? Snippet<[BlockSnippetPayload]> | Snippet<[InlineBlockSnippetPayload]> : Snippet<[MarkSnippetPayload]>;
-};
 export type EdytorOptions = {
     readonly?: boolean;
-    snippets?: Snippets;
+    /**
+     * Let users nest blocks under other blocks (default `false`): Tab and
+     * Shift+Tab nest and unnest, a drop or a handle's Alt+→ may place a block
+     * inside another. Off, those gestures nest nothing and Tab is left to the
+     * browser (the focus moves on); containers (lists, toggles, callouts,
+     * columns) keep their bodies, and nested blocks already in the document
+     * still render and edit.
+     */
+    allowNesting?: boolean;
     /** Chords (`mod+s`, `shift+alt+enter`) the view binds before plugins and built-ins. */
     hotkeys?: Partial<Record<HotKeyCombination, HotKey>>;
     plugins?: Plugin[];
@@ -56,9 +60,12 @@ export type EdytorOptions = {
      */
     onDocChange?: (change: DocChange) => void;
     onSelectionChange?: (selection: EdytorSelection) => void;
-    placeholder?: Placeholder;
-    /** The words this view says itself (its announcements, a suggestion's name); English by default. */
-    labels?: PartialLabels<'editor'>;
+    /**
+     * The words the package shows and says in this view, over the English
+     * ones: any entry of any section (`richText`, `table`, `editor`…), and
+     * the commands' slash `keywords` by id.
+     */
+    labels?: PartialLabels;
 };
 /**
  * The document's properties (`edytor.data`). Augment it to type yours:
@@ -71,6 +78,18 @@ export type RootBlock = Block & {
     readonly id: 'root';
     readonly depth: 0;
 };
+/**
+ * The view writes with the document's operations (`DocumentWrites`), under
+ * the same names and arguments as a bare `EdytorDocument`, dispatched:
+ * readonly and `document.writable` admit them, every extension hook sees
+ * them and their planned steps first, each is one transaction and the undo
+ * policy's step, the blocks it touched are normalized, and the caret it
+ * decides (a range deletion, a placed flow) is selected. Each answers its
+ * `OpResult` (`refused` when the view, a hook or the document refused it);
+ * `dispatcher.last` records it.
+ */
+export interface Edytor extends DocumentWrites {
+}
 export declare class Edytor {
     #private;
     node?: HTMLElement;
@@ -86,18 +105,15 @@ export declare class Edytor {
     root: Block | undefined;
     /** The view is bound to its decided document (its root is built). */
     get synced(): boolean;
-    /** `batch` binds operations onto blocks and the view alike: both answer `.edytor`. */
-    readonly edytor: this;
     selection: EdytorSelection;
     /** What the components render: one cell per visible block, patched from change reports. */
     cells: Cells | undefined;
-    /** Bumped by each commit that changed the document's data: what `docData()` readers track. */
-    private dataRevision;
     /**
-     * The document's properties as a live proxy (`session/props.ts`): read
-     * and write them like a plain object (`edytor.data.title = 'Notes'`,
-     * `bind:value={edytor.data.title}`); each write is a `patchData` command
-     * on the root. Type it by augmenting {@link EdytorDocData}.
+     * The document's properties, as plain state: reactive at any depth, and
+     * writable (`edytor.data.title = 'Notes'`, `edytor.data.tags.push('x')`,
+     * `delete edytor.data.draft`). Each write is the `patchData` operation,
+     * dispatched; the writes of one task are one undo step. Type them by
+     * augmenting {@link EdytorDocData}.
      */
     get data(): EdytorDocData;
     /** The chrome layer outside the host: handles, menus, remote carets. */
@@ -106,8 +122,10 @@ export declare class Edytor {
     readonly popups: Popups;
     /** What this view announces to assistive technology (`session/announcer`): its block moves and deletes. */
     readonly announcer: AnnouncerState;
-    /** The words this view says itself (`<Edytor labels>`): its announcements, a suggestion's name. */
-    readonly labels: EditorLabels;
+    /** The words the view was given (`<Edytor labels>`); its plugins read their section through `labelsOf`. */
+    readonly labels: PartialLabels;
+    /** Whether users may nest blocks (`allowNesting`, read once; the rule is `session/moves.ts` `nestsInto`). */
+    readonly allowNesting: boolean;
     private off;
     private onChange?;
     private onDocChange?;
@@ -126,8 +144,6 @@ export declare class Edytor {
     get awareness(): Awareness;
     /** The view's command dispatcher: every mutation this view makes goes through it. */
     readonly dispatcher: Dispatcher;
-    /** An outermost `transact` of this view is running. */
-    private transacting;
     /**
      * One transaction of this view. The outermost call runs the normalization
      * its operations requested at its end, inside the same transaction (one transaction, normalization once per touched parent): normalizers read
@@ -139,9 +155,13 @@ export declare class Edytor {
      */
     transact: <T>(cb: () => T) => T;
     /** Whether a block move (relative step or beside/inside a target) is structurally allowed. */
-    canMoveBlocks: (request: BlockMoveRequest) => boolean;
-    /** Move blocks one relative step, or before, after or inside a live target block. */
-    moveBlocks: (request: BlockMoveRequest) => Block[];
+    canMove: (request: BlockMoveRequest) => boolean;
+    /**
+     * Move blocks one relative step, or before, after, inside or beside a live
+     * target block: resolved to the document's move (`moveBlocks`, an outdent's
+     * `unNestBlocks`, `placeBeside`) and announced. Answers the moved blocks.
+     */
+    move: (request: BlockMoveRequest) => Block[];
     /**
      * Undo/redo through THIS view: the only history entry points that restore
      * a view's selection (its recorded `before`/`after`); sibling views and a
@@ -153,8 +173,6 @@ export declare class Edytor {
     historyUndo: () => void;
     historyRedo: () => void;
     constructor(options: EdytorOptions);
-    /** Kinds already reported missing (DEV, once each). */
-    private unknownKinds;
     /**
      * The definition of block kind `type` — the one lookup (render, surface,
      * handles). A kind no plugin of this view registers (a rolling deploy, a
@@ -181,41 +199,6 @@ export declare class Edytor {
     runCommand: (id: string) => Promise<boolean>;
     /** The adopted default type for a new child of `parent` — its actual parent. */
     defaultChild: (parent: Block) => string;
-    /** Releases the readiness wait of a view bound before its document decided. */
-    private _readinessRelease;
-    /** The commit subscription: editor-lifetime (a remount's `off` drain never releases it). */
-    private offCommit?;
-    /**
-     * One commit (local, remote, undo/redo): prune the handles of the removed
-     * blocks, then the selection's seam and the value consumers.
-     */
-    private onCommit;
-    /**
-     * Mark the synchronous extent of a real user-input event — see
-     * `isHandlingUserInput`. Deferred (rAF/timeout) work intentionally
-     * runs with the flag cleared so async restores can't trigger typing
-     * affordances long after the gesture ended.
-     */
-    private userInputHandlingDepth;
-    private withUserInput;
-    /**
-     * The next `focusin` was caused by the editor's own `.focus()` call —
-     * a selection write refocusing its text host is programmatic
-     * housekeeping, not a user gesture. Armed immediately before the
-     * call; `focusin` dispatches synchronously inside it, so the flag is
-     * consumed there; the microtask reset covers a focus that never
-     * fires (element already focused).
-     */
-    private expectInternalFocusArmed;
-    /** An event of this view's own composition (not a native control's, not a nested island's). */
-    private ownComposition;
-    deleteContentWithinSelection: (payload: {
-        replace?: boolean;
-        selection?: import("./edytor.utils.js").RangeEndpoints;
-    }) => readonly [Text | null, number] | undefined;
-    deleteBlocks: (payload: {
-        blocks: Block[];
-    }) => boolean;
     /**
      * Focus the editor, as a click in it would, without scrolling: the
      * selection it has stays, and with none the caret goes to the start of