edytor 1.0.0-rc.3 → 2.0.0

package/dist/session/attempt.d.ts

@@ -18,8 +18,7 @@
  */
 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';
+import type { BlockMovePosition } from './moves.js';
 type Kind = 'text' | 'composition' | 'payload' | 'break' | 'delete' | 'history';
 export type IntentRow = {
     kind: Kind;
@@ -27,10 +26,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 +56,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.js").SelectionProjection;
+    isCollapsed: boolean;
+    /** The admitted mark-edge side of a caret. */
+    edge: import("./editing/text.js").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.js").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;
@@ -102,9 +108,16 @@ export type Occurrence = {
     dataTransfer?: DataTransfer | null;
     /** The range the browser declared (`getTargetRanges()`, a drop point). */
     declared?: StaticRange | null;
+    /** Where a file drop lands, the indicator's placement (`plugins/fileDrop.ts`). */
+    placement?: DropAt | null;
     cancelable: boolean;
     event?: InputEvent;
 };
+/** A drop's placement in block terms: beside, before, after or inside `block`. */
+export type DropAt = {
+    block: string;
+    position: BlockMovePosition;
+};
 export type Attempt = ReturnType<typeof facts> & {
     id: number;
     /** The intent, fixed at admission. */
@@ -116,10 +129,9 @@ export type Attempt = ReturnType<typeof facts> & {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | 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 +144,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.js").SelectionProjection;
+    isCollapsed: boolean;
+    /** The admitted mark-edge side of a caret. */
+    edge: import("./editing/text.js").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.js").SelectionValue;
 } & {
     id: number;
     /** The intent, fixed at admission. */
@@ -162,10 +167,9 @@ export declare const reproject: (edytor: Edytor, attempt: Attempt) => {
     dataTransfer: DataTransfer | null;
     hasDataTransferTextPayload: boolean;
     declared: StaticRange | null;
+    placement: DropAt | 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,32 +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;
-    // Its block's place by id: no handle for every sibling (the root's on a long page).
-    const at = startText && edytor.facade.positionOf(startText.parent.id);
+    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: Boolean(at && at.parent === null && at.index === 0),
-        isNested: Boolean(startText && startText.parent.parent !== edytor.root),
-        isLastChild: Boolean(at && at.index === edytor.facade.childrenIds(at.parent).length - 1)
+        edge: selection.edge,
+        isVoidEditableElement: selection.voidField
     };
 };
 /** A text intent with no `data` carries its text in the data transfer. */
@@ -112,8 +119,8 @@ export const attemptOf = (edytor, occurrence, keyIntent) => {
         dataTransfer: occurrence.dataTransfer ?? null,
         hasDataTransferTextPayload: payload !== null,
         declared: occurrence.declared ?? null,
+        placement: occurrence.placement ?? null,
         isStructuralKeyFallback: Boolean(keyIntent),
-        target: edytor.selection.value,
         owner: 'model',
         expect: null,
         phase: 'open'
@@ -126,7 +133,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));