edytor 1.0.0-rc.3 → 2.0.0

package/dist/session/keymap.d.ts

@@ -23,6 +23,7 @@ export type Modifiers = {
 /** A chord: a key, after up to three modifiers in any order (matched case-insensitively). */
 export type HotKeyCombination = Key | `${Modifiers}+${Key}`;
 export declare class Keymap {
+    #private;
     private edytor;
     /** chord → bindings in precedence order. */
     private table;
@@ -30,12 +31,6 @@ export declare class Keymap {
     offered: string | null;
     get isMac(): boolean;
     constructor(edytor: Edytor, consumer?: EdytorOptions['hotkeys'], plugins?: InitializedPlugin[]);
-    /**
-     * A keyboard event's chord: `mod` is Cmd on Apple and Ctrl elsewhere; on
-     * Apple bare Ctrl stays `ctrl` (the Emacs rows); a reverse tab is Shift+Tab;
-     * the space bar is `space`.
-     */
-    chordOf: (event: KeyboardEvent, key?: string) => string;
     /** Offer a keydown to its bindings (the produced key first, then the layout key). */
     handle: (event: KeyboardEvent) => boolean;
     /** Run `chord`'s bindings in precedence order until one claims it. */

package/dist/session/keymap.js

@@ -19,32 +19,33 @@ const CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789`~!@#$%^&*()-_=+[]{}\\|;:\'",
 // prettier-ignore
 const NAMED = ['arrowup', 'arrowdown', 'arrowleft', 'arrowright', 'tab', 'enter', 'backspace', 'delete', 'space', 'escape', 'home', 'end', 'pageup', 'pagedown', 'insert', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12'];
 const MODIFIERS = ['mod', 'alt', 'ctrl', 'shift'];
-/** Every token a keydown's chord can carry (`chordOf`). */
-const TOKENS = new Set([...MODIFIERS, ...CHARS, ...NAMED]);
 /** The canonical chord: lower case, modifiers in one order, then the key. */
 const chord = (parts) => {
     const lower = parts.map((part) => part.toLowerCase());
     const key = lower.filter((part) => part && !MODIFIERS.includes(part));
     return [...MODIFIERS.filter((modifier) => lower.includes(modifier)), ...key].join('+');
 };
-/** US-layout keys and what Shift makes of them: a keydown reports the character typed. */
-const [BASE, SHIFT] = ["`1234567890-=[]\\;',./", '~!@#$%^&*()_+{}|:"<>?'];
-const SHIFTED = new Map([...BASE].map((base, index) => [base, SHIFT[index]]));
-/** Characters only Shift types (the numeric keypad types `+` and `*` unshifted). */
-const TYPED_WITH_SHIFT = new Set([...SHIFTED.values()].filter((key) => !'+*'.includes(key)));
 /**
- * Why a well-formed chord still never fires (a development hint), or null:
- * a character Shift types needs `shift` (`mod+shift+?`), Shift turns a key
- * into another character (`shift+/` arrives as `?`), and on macOS Option
- * with a character types text (`alt+b` is `∫`) unless `mod` or `ctrl` holds.
+ * Why a chord never fires (a development hint), or null: a part that is no
+ * token a keydown's chord can carry (`#chordOf`); a character Shift types
+ * needs `shift` (`mod+shift+?`), Shift turns a key into another character
+ * (`shift+/` arrives as `?`: US-layout keys, a keydown reports the
+ * character typed; the numeric keypad types `+` and `*` unshifted), and on
+ * macOS Option with a character types text (`alt+b` is `∫`) unless `mod` or
+ * `ctrl` holds.
  */
 const silent = (parts) => {
     const lower = parts.map((part) => part.toLowerCase());
+    const tokens = new Set([...MODIFIERS, ...CHARS, ...NAMED]);
+    const dead = lower.find((part) => !tokens.has(part));
+    if (dead !== undefined)
+        return `"${parts[lower.indexOf(dead)]}" is neither a modifier (mod, alt, ctrl, shift) nor a key name`;
     const key = lower.find((part) => !MODIFIERS.includes(part)) ?? '';
     const has = (modifier) => lower.includes(modifier);
-    if (!has('shift') && TYPED_WITH_SHIFT.has(key))
+    const [base, shift] = ["`1234567890-=[]\\;',./", '~!@#$%^&*()_+{}|:"<>?'];
+    if (!has('shift') && key && shift.includes(key) && !'+*'.includes(key))
         return `"${key}" is typed with Shift: bind "${chord([...lower, 'shift'])}"`;
-    const shifted = SHIFTED.get(key);
+    const shifted = key && shift[base.indexOf(key)];
     if (has('shift') && shifted)
         return `Shift turns "${key}" into "${shifted}": bind "${chord([...lower.filter((part) => part !== key), shifted])}"`;
     if (has('alt') && !has('mod') && !has('ctrl') && key.length === 1)
@@ -90,11 +91,7 @@ export class Keymap {
                     continue;
                 }
                 const parts = keys.split(/\+(?!$)/);
-                const dead = parts.find((part) => !TOKENS.has(part.toLowerCase()));
-                if (DEV && dead !== undefined)
-                    console.warn(`[edytor] hotkey "${keys}" never fires: "${dead}" is neither a modifier ` +
-                        '(mod, alt, ctrl, shift) nor a key name.');
-                const hint = DEV && dead === undefined && silent(parts);
+                const hint = DEV && silent(parts);
                 if (hint)
                     console.warn(`[edytor] hotkey "${keys}" never fires: ${hint}.`);
                 const at = chord(parts);
@@ -106,7 +103,7 @@ export class Keymap {
      * Apple bare Ctrl stays `ctrl` (the Emacs rows); a reverse tab is Shift+Tab;
      * the space bar is `space`.
      */
-    chordOf = (event, key = event.key === ' ' ? 'space' : event.key.toLowerCase()) => {
+    #chordOf = (event, key = event.key === ' ' ? 'space' : event.key.toLowerCase()) => {
         const back = key === 'iso_left_tab' || key === 'backtab';
         const mac = this.isMac;
         return chord([
@@ -122,7 +119,7 @@ export class Keymap {
         if (composesText(event))
             return false;
         const fallback = layoutKey(event);
-        const chords = [this.chordOf(event), ...(fallback ? [this.chordOf(event, fallback)] : [])];
+        const chords = [this.#chordOf(event), ...(fallback ? [this.#chordOf(event, fallback)] : [])];
         this.offered = chords[0];
         const claimed = chords.some((at) => this.run(at, event));
         if (claimed)

package/dist/session/moves.d.ts

@@ -25,16 +25,49 @@ export type BlockMoveRequest = {
 } | {
     direction: BlockMoveDirection;
 });
+/**
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export declare const nestsInto: (edytor: Edytor, parent: Block, blocks?: readonly Block[]) => boolean;
 /** Whether the move is allowed: for runs (`parts`), whether one of them may move. */
-export declare const canMoveBlocks: (edytor: Edytor, request: BlockMoveRequest) => boolean;
+export declare const canMove: (edytor: Edytor, request: BlockMoveRequest) => boolean;
+/**
+ * One move: the document's `moveBlocks`, an `out` step's outdent
+ * (`unNestBlocks`) or a beside placement (`placeBeside`), dispatched as the
+ * view's write — identity kept, one undo step, a closed toggle the blocks
+ * land in or that adopts blocks opening (every caller — keys, drops, menus,
+ * the public command — shows the moved blocks); `[]` when refused or
+ * vetoed. Runs (`parts`) move one by one, a run that cannot move staying, as
+ * Tab does (`dispatcher.each`). The view announces what moved
+ * (`announcer.moved`).
+ */
+export declare const move: (edytor: Edytor, request: BlockMoveRequest) => Block[];
+/** A new block a drop places (`placeNew`): its kind, and its id when the caller names it. */
+export type NewBlock = {
+    type: string;
+    id?: string;
+};
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export declare const canPlaceNew: (edytor: Edytor, kinds: readonly string[], target: Block, position: BlockMovePosition) => boolean;
 /**
- * One move command (`moveBlock` for one block, `moveBlocks` for a group; an
- * `out` step plans the outdent, `unNestBlocks`): identity kept, one undo
- * step (the dispatcher cuts before it); `[]` when refused or vetoed.
- * Runs (`parts`) move one by one, a run that cannot move staying, as Tab
- * does (`dispatcher.each`). A closed toggle the blocks land in, or that
- * adopts blocks, opens (`revealing`): every caller — keys, drops, menus,
- * the public command — shows the moved blocks. The view announces what
- * moved (`announcer.moved`).
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
  */
-export declare const moveBlocks: (edytor: Edytor, request: BlockMoveRequest) => Block[];
+export declare const placeNew: (edytor: Edytor, blocks: readonly NewBlock[], target: Block, position: BlockMovePosition) => string[];

package/dist/session/moves.js

@@ -1,5 +1,3 @@
-import { dispatchPlan } from '../block/block.utils.js';
-import { revealing } from '../selection/replaceSelection.js';
 /** The positions that place the blocks beside the target, in a layout. */
 const BESIDE = ['left', 'right'];
 const isBeside = (position) => BESIDE.includes(position);
@@ -27,12 +25,28 @@ const placement = (edytor, request) => {
 };
 const POSITIONS = ['before', 'after', 'inside', ...BESIDE];
 /**
- * The move op's payload, or `null` when refused: a well-formed request, then
- * the document's one structural answer (`canPlace` — the predicate the
- * move op applies at execution; an `out` step asks the outdent plan, which
- * places the blocks as the kind they take there: a paragraph outdented into
- * a list is its item; `left`/`right` ask the beside plan,
- * `placeBeside`). Extensions may still veto the command.
+ * The view's nesting rule (`allowNesting`, off by default): whether a user
+ * gesture may place `blocks` under `parent`. With nesting off, blocks land
+ * only at the root or in a block made to hold children — a container (a
+ * list, a column, a toggle's or a callout's body: `isContainer`, the kind's
+ * `container`), an island (a code block's lines) — or stay under the parent
+ * they already have (a document holding nested blocks still edits them).
+ * Every move (`destination`: keys, drops, menus, `edytor.move`) and every
+ * new block a drop places (`canPlaceNew`) reads it.
+ */
+export const nestsInto = (edytor, parent, blocks = []) => edytor.allowNesting ||
+    parent.isRoot ||
+    parent.isContainer ||
+    !!parent.definition.container ||
+    edytor.facade.isIsland(parent.id) ||
+    (blocks.length > 0 && blocks.every((block) => block.parent === parent));
+/**
+ * The document write a move request is, or `null` when refused: a
+ * well-formed request, then the document's one structural answer
+ * (`canPlace` — the predicate the move applies at execution; an `out` step
+ * asks the outdent plan, which places the blocks as the kind they take
+ * there: a paragraph outdented into a list is its item; `left`/`right` ask
+ * the beside plan, `placeBeside`). Extensions may still veto it.
  */
 const destination = (edytor, request) => {
     const move = placement(edytor, request);
@@ -49,21 +63,24 @@ const destination = (edytor, request) => {
     // root or a column) and owns every refusal (fits, its own subtree).
     if (isBeside(position)) {
         return 'writes' in edytor.facade.prepare.placeBeside(ids, target.id, position)
-            ? { blocks, path: target.path, beside: { target, side: position } }
+            ? { blocks, write: () => edytor.placeBeside(ids, target.id, position) }
             : null;
     }
     // Inside a container they are no items of: under its last item (Tab after a list).
     const nest = () => edytor.idToBlock.get(edytor.facade.nestParent(ids, target.id));
     const parent = position === 'inside' ? (nest() ?? target) : target.parent;
-    const placeable = (to) => 'direction' in request && request.direction === 'out'
-        ? 'writes' in edytor.facade.prepare.unNestBlocks(ids)
-        : edytor.facade.canPlace(ids, to.isRoot ? null : to.id);
-    if (!parent || !placeable(parent))
+    // The outdent plan: the siblings after the last block follow it.
+    if ('direction' in request && request.direction === 'out')
+        return 'writes' in edytor.facade.prepare.unNestBlocks(ids)
+            ? { blocks, write: () => edytor.unNestBlocks(ids) }
+            : null;
+    const to = parent?.isRoot ? null : parent?.id;
+    if (!parent || !nestsInto(edytor, parent, blocks) || !edytor.facade.canPlace(ids, to))
         return null;
     const at = position === 'inside' ? parent.children.length : target.index + (position === 'after' ? 1 : 0);
     // The document counts the destination's children without the moved blocks.
     const index = at - blocks.filter((block) => block.parent === parent && block.index < at).length;
-    return { blocks, path: [...(parent.isRoot ? [] : parent.path), index] };
+    return { blocks, write: () => edytor.moveBlocks(ids, { parent: to, index }) };
 };
 /**
  * An `in` or `out` step over siblings as its runs of adjacent ones:
@@ -88,24 +105,24 @@ const parts = (edytor, request) => {
     return runs.map((run) => ({ blocks: run, direction }));
 };
 /** Whether the move is allowed: for runs (`parts`), whether one of them may move. */
-export const canMoveBlocks = (edytor, request) => parts(edytor, request).some((part) => destination(edytor, part) !== null);
+export const canMove = (edytor, request) => parts(edytor, request).some((part) => destination(edytor, part) !== null);
 /**
- * One move command (`moveBlock` for one block, `moveBlocks` for a group; an
- * `out` step plans the outdent, `unNestBlocks`): identity kept, one undo
- * step (the dispatcher cuts before it); `[]` when refused or vetoed.
- * Runs (`parts`) move one by one, a run that cannot move staying, as Tab
- * does (`dispatcher.each`). A closed toggle the blocks land in, or that
- * adopts blocks, opens (`revealing`): every caller — keys, drops, menus,
- * the public command — shows the moved blocks. The view announces what
- * moved (`announcer.moved`).
+ * One move: the document's `moveBlocks`, an `out` step's outdent
+ * (`unNestBlocks`) or a beside placement (`placeBeside`), dispatched as the
+ * view's write — identity kept, one undo step, a closed toggle the blocks
+ * land in or that adopts blocks opening (every caller — keys, drops, menus,
+ * the public command — shows the moved blocks); `[]` when refused or
+ * vetoed. Runs (`parts`) move one by one, a run that cannot move staying, as
+ * Tab does (`dispatcher.each`). The view announces what moved
+ * (`announcer.moved`).
  */
-export const moveBlocks = (edytor, request) => {
+export const move = (edytor, request) => {
     const runs = parts(edytor, request);
-    const moved = revealing(request.blocks, () => runs.length > 1
+    const moved = runs.length > 1
         ? edytor.dispatcher
             .each('moveBlocks', runs, (run) => place(edytor, run))
             .flatMap((moved) => moved ?? [])
-        : place(edytor, runs[0] ?? request));
+        : place(edytor, runs[0] ?? request);
     // Said to assistive technology: what moved, and where (`session/announcer`).
     edytor.announcer.moved(request, moved);
     return moved;
@@ -114,39 +131,64 @@ const place = (edytor, request) => {
     const move = destination(edytor, request);
     if (!move) {
         // Refused before any command ran: `last` still reports it (commands#results).
-        const operation = request.blocks.length > 1 ? 'moveBlocks' : 'moveBlock';
-        edytor.dispatcher.record({ operation, status: request.blocks.length ? 'refused' : 'noop' });
+        const status = request.blocks.length ? 'refused' : 'noop';
+        edytor.dispatcher.record({ operation: 'moveBlocks', status });
         return [];
     }
-    const [first, ...rest] = move.blocks;
-    if (move.beside) {
-        const { beside } = move;
-        // The beside plan, from the payload hooks leave: a new column, or a new
-        // layout wrapping the target; the sources cleaned in the same plan.
-        const ids = move.blocks.map((block) => block.id);
-        const besides = (payload) => payload.beside
-            ? edytor.facade.prepare.placeBeside(ids, payload.beside.target.id, payload.beside.side)
-            : { status: 'refused', ids: [] };
-        const touched = [
-            ...new Set([...move.blocks.map((block) => block.parent), beside.target.parent])
-        ];
-        const applied = rest.length
-            ? dispatchPlan(first, 'moveBlocks', move, besides, touched)
-            : dispatchPlan(first, 'moveBlock', { path: move.path, beside }, besides, touched);
-        return applied ? move.blocks : [];
-    }
-    if ('direction' in request && request.direction === 'out') {
-        // The outdent plan: the siblings after the last block follow it.
-        const ids = move.blocks.map((block) => block.id);
-        const outdent = () => edytor.facade.prepare.unNestBlocks(ids);
-        const touched = [first.parent, first.parent?.parent, move.blocks.at(-1)];
-        const applied = rest.length
-            ? dispatchPlan(first, 'moveBlocks', move, outdent, touched)
-            : dispatchPlan(first, 'moveBlock', { path: move.path }, outdent, touched);
-        return applied ? move.blocks : [];
-    }
-    if (rest.length)
-        return first.moveBlocks(move) ?? [];
-    const moved = first.moveBlock(move);
-    return moved ? [moved] : [];
+    const result = move.write();
+    return result.status === 'applied' ? move.blocks : [];
+};
+/**
+ * Whether new blocks of `kinds` may land at `target`'s `position` (a file
+ * dropped there, `placeNew`): the move's places (`destination`) asked of
+ * blocks not yet in the document — the container rule (`fits`) of the
+ * parent they land in, never inside a void or an island; beside, a layout
+ * kind and a target outside any island (`placeBeside` takes any block a
+ * column holds).
+ */
+export const canPlaceNew = (edytor, kinds, target, position) => {
+    const { facade } = edytor;
+    if (edytor.readonly || !kinds.length || !target.isInTree || target.isRoot)
+        return false;
+    if (!POSITIONS.includes(position) || facade.insideIsland(target.id))
+        return false;
+    if (isBeside(position))
+        return ([...edytor.blocks.values()].some((definition) => definition.layout) &&
+            !facade.isIsland(target.id));
+    const parent = position === 'inside' ? target : target.parent;
+    if (!parent || !nestsInto(edytor, parent))
+        return false;
+    const to = parent.isRoot ? null : parent.id;
+    if (to !== null && (facade.isVoid(to) || facade.isIsland(to)))
+        return false;
+    return kinds.every((kind) => facade.fits(to, kind));
+};
+/**
+ * Insert new blocks at `target`'s `position` (a file drop's placement):
+ * before or after it, inside it (its last children), or beside it — inserted
+ * after the block it stands beside (`besideAt`) and moved there by the one
+ * move path (`layout.place-beside`) — in one transaction. The caller's
+ * command makes it one undo step. Answers the ids placed (none: refused).
+ */
+export const placeNew = (edytor, blocks, target, position) => {
+    const kinds = blocks.map((block) => block.type);
+    if (!canPlaceNew(edytor, kinds, target, position))
+        return [];
+    const beside = isBeside(position);
+    const at = beside ? (edytor.idToBlock.get(edytor.facade.besideAt(target.id)) ?? target) : target;
+    const parent = position === 'inside' ? target : at.parent;
+    const destination = position === 'inside'
+        ? { parent: target.id, index: target.children.length }
+        : {
+            parent: !parent || parent.isRoot ? null : parent.id,
+            index: at.index + (position === 'before' ? 0 : 1)
+        };
+    return edytor.transact(() => {
+        const { ids } = edytor.insertBlocks(destination, blocks.map((block) => ({ ...block })));
+        if (!beside || !ids.length)
+            return [...ids];
+        const placed = ids.flatMap((id) => edytor.idToBlock.get(id) ?? []);
+        move(edytor, { blocks: placed, target, position });
+        return [...ids];
+    });
 };

package/dist/session/navigation.d.ts

@@ -4,8 +4,9 @@
  *
  * The stream is the document order of the displayable blocks (a
  * Surface fact: a collapsed toggle's body or a phantom content slot holds no
- * stop), each block's content parts in order: offsets inside its texts at
- * grapheme (or word) boundaries, with the inline atoms between them. A key
+ * stop), each block's stops in block offsets (an inline atom counts 1, as
+ * the projection's points): grapheme (or word) boundaries inside its texts,
+ * the inline atoms between them. A key
  * names a unit (grapheme, word, block edge, document edge) and a direction;
  * the arrow and word keys are visual, resolved once from the focus text's
  * computed direction (RTL).
@@ -22,6 +23,7 @@
  * lands it on no caret stop (`landed`).
  */
 import type { Edytor } from '../edytor.svelte.js';
+import type { Block } from '../block/block.svelte.js';
 import type { HotKey } from './keymap.js';
 /**
  * With no target (`untargeted`: the value is `none`, no gesture placed the
@@ -47,6 +49,12 @@ export declare const move: (edytor: Edytor, unit: Unit, key: Dir | "left" | "rig
  * moves keep the goal column. Answers whether a text selection moved.
  */
 export declare const extendVertically: (edytor: Edytor, dir: Dir) => boolean;
+/**
+ * The block a collapsed text caret sits on the last line of (a line box
+ * where the view lays one out, else a line break), if it does: where
+ * ArrowDown leaves the block (`nav.trailing.exit`, `body.down`).
+ */
+export declare const onLastLine: (edytor: Edytor) => Block | undefined;
 /**
  * The trailing paragraph (`nav.trailing`, Notion): the caret goes to an
  * empty top-level block of the root's default kind after the document's