edytor 1.0.0-rc.2 → 1.0.0

package/dist/session/announcer.svelte.d.ts

@@ -1,7 +1,7 @@
 /**
  * What a view tells assistive technology about a change a screen does not
  * say by itself: a block move or a block delete this view made, in the
- * view's labels (`edytor.labels`).
+ * view's `editor` labels (`labelsOf`).
  * DOM-free: the surface renders `message` in a polite live region beside
  * the host (`components/Announcer.svelte`), a new node per announcement
  * (`serial`), so the same words twice are read twice. Only this view's own
@@ -11,6 +11,7 @@ import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';
 import type { BlockMoveRequest } from './moves.js';
 export declare class Announcer {
+    #private;
     private edytor;
     /** The last announcement. */
     message: string;

package/dist/session/announcer.svelte.js

@@ -1,4 +1,5 @@
 import { kindLabel } from '../kinds.js';
+import { editorEnglish, labelsOf } from '../labels.js';
 /** The label saying a move, by direction (`to`: a placement, a drop). */
 const MOVED = {
     up: 'movedUp',
@@ -16,6 +17,9 @@ export class Announcer {
     constructor(edytor) {
         this.edytor = edytor;
     }
+    get #labels() {
+        return labelsOf(this.edytor, 'editor', editorEnglish);
+    }
     /** Announce `message` (politely: after what the screen reader is saying). */
     say = (message) => {
         this.message = message;
@@ -23,7 +27,7 @@ export class Announcer {
     };
     /** `blocks` (one or several) as words: a kind's label for one, a count for several. */
     what = (blocks) => {
-        const { labels } = this.edytor;
+        const labels = this.#labels;
         return blocks.length === 1
             ? labels.block(kindLabel(this.edytor, blocks[0]))
             : labels.blocks(blocks.length);
@@ -33,8 +37,8 @@ export class Announcer {
         if (!moved.length)
             return;
         const said = MOVED['direction' in request ? request.direction : 'to'];
-        this.say(this.edytor.labels[said](this.what(moved)));
+        this.say(this.#labels[said](this.what(moved)));
     };
     /** Blocks were deleted: `what` names them, read before they went. */
-    deleted = (what) => this.say(this.edytor.labels.deleted(what));
+    deleted = (what) => this.say(this.#labels.deleted(what));
 }

package/dist/session/attempt.d.ts

@@ -18,8 +18,6 @@
  */
 import type { Edytor } from '../edytor.svelte.js';
 import type { Text } from '../text/text.svelte.js';
-import type { EdgeSide } from './editing/text.js';
-import type { SelectionValue } from './selection.js';
 type Kind = 'text' | 'composition' | 'payload' | 'break' | 'delete' | 'history';
 export type IntentRow = {
     kind: Kind;
@@ -27,10 +25,14 @@ export type IntentRow = {
     key?: string;
     /** A delete whose extent the model computes; a declared range only locates the caret edge. */
     dir?: 'back' | 'fwd';
+    /** A delete's unit at a collapsed caret (none: a cut, drag or composition fragment, which deletes nothing there). */
+    unit?: 'char' | 'word' | 'soft' | 'hard' | 'line';
 };
 /** The one inputType → intent table; everything downstream switches on its rows. */
 export declare const INTENTS: Record<string, IntentRow | undefined>;
 export declare const kindOf: (inputType: string) => Kind | undefined;
+/** The intent a key stands for (Enter, Shift+Enter, Backspace, Delete): the table's `key`, read back. */
+export declare const keyIntentOf: (key: string, shift: boolean) => string | null;
 /**
  * The intent of a reported inputType (misreport overrides): a text insertion
  * of `\n`/`\r` is a line break/paragraph, and a line break the engine reports
@@ -53,30 +55,33 @@ export declare const intentOf: (reported: string, data: string | null, keyIntent
 export declare const targetless: (edytor: Edytor, intent: string) => boolean;
 /** Nowhere to act: the selection value is `none` and no gesture placed the host's DOM caret. */
 export declare const untargeted: (edytor: Edytor) => boolean;
-/** The target's facts a command reads, projected when the attempt runs. */
+/**
+ * The target as a command reads it when the attempt runs: the anchored
+ * value, its projection (edges, spans, island and void roots) and its
+ * endpoints lowered to text segments (`selection.textRange`), with the
+ * mark-edge side the DOM showed a caret with and whether focus is in a
+ * void's own field.
+ */
 declare const facts: (edytor: Edytor) => {
+    projection: import("./selection").SelectionProjection;
+    isCollapsed: boolean;
+    /** The admitted mark-edge side of a caret. */
+    edge: import("./editing/text").EdgeSide | undefined;
+    isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
-    texts: Text[];
     yStart: number;
     yEnd: number;
-    /** The admitted mark-edge side of a caret. */
-    edge: EdgeSide | undefined;
-    isCollapsed: boolean;
-    isTextSpanning: boolean;
-    isBlockSpanning: boolean;
-    isAtStartOfBlock: boolean;
-    isAtEndOfBlock: boolean;
-    isAtStartOfText: boolean;
-    isAtEndOfText: boolean;
-    islandRoot: import("../index.js").Block | null;
-    isVoidEditableElement: boolean;
-    isFirstChildOfDocument: boolean;
-    isNested: boolean;
-    isLastChild: boolean;
+    texts: Text[];
+    /** The anchored target, fixed at admission. */
+    target: import("./selection").SelectionValue;
 };
-/** How DOM drift around a model-owned attempt is handled: re-render, restore the caret, or also discard structure. */
-export type Drift = 'refresh' | 'restore' | 'discard';
+/**
+ * How DOM drift around a model-owned attempt is repaired: the observer
+ * inverts it (`refresh`), and its `input` also shows the caret again and
+ * re-renders the text it landed in (`restore`).
+ */
+export type Drift = 'refresh' | 'restore';
 export type TextPoint = {
     text: Text;
     offset: number;
@@ -118,8 +123,6 @@ export type Attempt = ReturnType<typeof facts> & {
     declared: StaticRange | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
-    /** The anchored target, fixed at admission. */
-    target: SelectionValue;
     owner: 'model' | 'browser';
     expect: Expect | null;
     phase: 'open' | 'applied' | 'failed' | 'closed';
@@ -132,25 +135,18 @@ export declare const intentSnapshot: (edytor: Edytor, inputType: string) => Atte
 export declare const caretAt: (edytor: Edytor, text: Text | null | undefined, offset: number) => void;
 /** Re-project an attempt's anchored target when it runs later than its admission. */
 export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
+    projection: import("./selection").SelectionProjection;
+    isCollapsed: boolean;
+    /** The admitted mark-edge side of a caret. */
+    edge: import("./editing/text").EdgeSide | undefined;
+    isVoidEditableElement: boolean;
     startText: Text | null;
     endText: Text | null;
-    texts: Text[];
     yStart: number;
     yEnd: number;
-    /** The admitted mark-edge side of a caret. */
-    edge: EdgeSide | undefined;
-    isCollapsed: boolean;
-    isTextSpanning: boolean;
-    isBlockSpanning: boolean;
-    isAtStartOfBlock: boolean;
-    isAtEndOfBlock: boolean;
-    isAtStartOfText: boolean;
-    isAtEndOfText: boolean;
-    islandRoot: import("../index.js").Block | null;
-    isVoidEditableElement: boolean;
-    isFirstChildOfDocument: boolean;
-    isNested: boolean;
-    isLastChild: boolean;
+    texts: Text[];
+    /** The anchored target, fixed at admission. */
+    target: import("./selection").SelectionValue;
 } & {
     id: number;
     /** The intent, fixed at admission. */
@@ -164,8 +160,6 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     declared: StaticRange | null;
     /** Admitted from a keydown (the key's intent wins; the browser may never announce it). */
     isStructuralKeyFallback: boolean;
-    /** The anchored target, fixed at admission. */
-    target: SelectionValue;
     owner: "model" | "browser";
     expect: Expect | null;
     phase: "open" | "applied" | "failed" | "closed";

package/dist/session/attempt.js

@@ -1,35 +1,49 @@
-const row = (kind, key, dir) => ({ kind, key, dir });
-/** The one inputType → intent table; everything downstream switches on its rows. */
-export const INTENTS = {
-    insertText: row('text'),
-    insertReplacementText: row('text'),
-    insertFromYank: row('text'),
-    insertTranspose: row('text'),
-    insertCompositionText: row('composition'),
-    insertFromComposition: row('composition'),
-    deleteCompositionText: row('composition'),
-    insertFromPaste: row('payload'),
-    insertFromPasteAsQuotation: row('payload'),
-    insertFromDrop: row('payload'),
-    insertParagraph: row('break', 'enter'),
-    insertLineBreak: row('break', 'shift+enter'),
-    deleteContentBackward: row('delete', 'backspace', 'back'),
-    deleteContentForward: row('delete', 'delete', 'fwd'),
-    deleteWordBackward: row('delete', undefined, 'back'),
-    deleteSoftLineBackward: row('delete', undefined, 'back'),
-    deleteHardLineBackward: row('delete', undefined, 'back'),
-    deleteWordForward: row('delete', undefined, 'fwd'),
-    deleteSoftLineForward: row('delete', undefined, 'fwd'),
-    deleteHardLineForward: row('delete', undefined, 'fwd'),
-    deleteByCut: row('delete'),
-    deleteByDrag: row('delete'),
-    deleteByComposition: row('delete'),
-    deleteContent: row('delete'),
-    deleteEntireSoftLine: row('delete'),
-    historyUndo: row('history'),
-    historyRedo: row('history')
+/** The inputTypes of each kind (the directional deletes are generated below). */
+const KINDS = {
+    text: 'insertText insertReplacementText insertFromYank insertTranspose',
+    composition: 'insertCompositionText insertFromComposition deleteCompositionText',
+    payload: 'insertFromPaste insertFromPasteAsQuotation insertFromDrop',
+    break: 'insertParagraph insertLineBreak',
+    delete: 'deleteByCut deleteByDrag deleteByComposition deleteContent deleteEntireSoftLine',
+    history: 'historyUndo historyRedo'
+};
+const KEYS = {
+    insertParagraph: 'enter',
+    insertLineBreak: 'shift+enter',
+    deleteContentBackward: 'backspace',
+    deleteContentForward: 'delete'
 };
+/** The one inputType → intent table; everything downstream switches on its rows. */
+export const INTENTS = {};
+for (const [kind, types] of Object.entries(KINDS))
+    for (const type of types.split(' '))
+        INTENTS[type] = { kind, key: KEYS[type] };
+INTENTS.deleteContent.unit = 'char';
+INTENTS.deleteEntireSoftLine.unit = 'line';
+// `delete<Unit><Backward|Forward>`: the name says the unit and the direction.
+for (const [part, unit] of [
+    ['Content', 'char'],
+    ['Word', 'word'],
+    ['SoftLine', 'soft'],
+    ['HardLine', 'hard']
+])
+    for (const [side, dir] of [
+        ['Backward', 'back'],
+        ['Forward', 'fwd']
+    ]) {
+        const type = `delete${part}${side}`;
+        INTENTS[type] = { kind: 'delete', key: KEYS[type], dir, unit };
+    }
 export const kindOf = (inputType) => INTENTS[inputType]?.kind;
+/** The intent a key stands for (Enter, Shift+Enter, Backspace, Delete): the table's `key`, read back. */
+export const keyIntentOf = (key, shift) => {
+    const name = key.toLowerCase();
+    const hotkey = shift && name === 'enter' ? 'shift+enter' : name;
+    for (const type in KEYS)
+        if (KEYS[type] === hotkey)
+            return type;
+    return null;
+};
 /**
  * The intent of a reported inputType (misreport overrides): a text insertion
  * of `\n`/`\r` is a line break/paragraph, and a line break the engine reports
@@ -64,30 +78,25 @@ export const targetless = (edytor, intent) => {
 };
 /** Nowhere to act: the selection value is `none` and no gesture placed the host's DOM caret. */
 export const untargeted = (edytor) => edytor.selection.value.kind === 'none' && !edytor.ports.surface.placed();
-/** The target's facts a command reads, projected when the attempt runs. */
+/**
+ * The target as a command reads it when the attempt runs: the anchored
+ * value, its projection (edges, spans, island and void roots) and its
+ * endpoints lowered to text segments (`selection.textRange`), with the
+ * mark-edge side the DOM showed a caret with and whether focus is in a
+ * void's own field.
+ */
 const facts = (edytor) => {
-    const { state, projection } = edytor.selection;
-    const { startText } = state;
+    const { selection } = edytor;
+    const projection = selection.projection;
     return {
-        startText,
-        endText: state.endText,
-        texts: state.texts,
-        yStart: state.yStart,
-        yEnd: state.yEnd,
+        /** The anchored target, fixed at admission. */
+        target: selection.value,
+        ...selection.textRange(projection),
+        projection,
+        isCollapsed: projection.isCollapsed,
         /** The admitted mark-edge side of a caret. */
-        edge: state.edge,
-        isCollapsed: state.isCollapsed,
-        isTextSpanning: projection.isTextSpanning,
-        isBlockSpanning: projection.isBlockSpanning,
-        isAtStartOfBlock: projection.isAtStartOfBlock,
-        isAtEndOfBlock: projection.isAtEndOfBlock,
-        isAtStartOfText: projection.isAtStartOfText,
-        isAtEndOfText: projection.isAtEndOfText,
-        islandRoot: edytor.idToBlock.get(projection.islandRoot ?? '') ?? null,
-        isVoidEditableElement: state.isVoidEditableElement,
-        isFirstChildOfDocument: startText?.parent === edytor.root?.children.at(0),
-        isNested: Boolean(startText && startText.parent.parent !== edytor.root),
-        isLastChild: startText?.parent.parent?.children.at(-1) === startText?.parent
+        edge: selection.edge,
+        isVoidEditableElement: selection.voidField
     };
 };
 /** A text intent with no `data` carries its text in the data transfer. */
@@ -111,7 +120,6 @@ export const attemptOf = (edytor, occurrence, keyIntent) => {
         hasDataTransferTextPayload: payload !== null,
         declared: occurrence.declared ?? null,
         isStructuralKeyFallback: Boolean(keyIntent),
-        target: edytor.selection.value,
         owner: 'model',
         expect: null,
         phase: 'open'
@@ -124,7 +132,7 @@ export const caretAt = (edytor, text, offset) => {
     if (!text)
         return;
     edytor.attempts.caret(text, offset);
-    edytor.selection.setAtTextOffset(text, offset);
+    edytor.selection.selectText(text, offset);
 };
 /** Re-project an attempt's anchored target when it runs later than its admission. */
 export const reproject = (edytor, attempt) => Object.assign(attempt, facts(edytor));