@twip/web 0.1.0-alpha.1 → 0.1.0-pre.2

package/dist/services/ruler.d.ts

@@ -0,0 +1,95 @@
+import type { Session } from '../editor.js';
+import type { Points } from '../types.js';
+/** The ruler model, on every editor. */
+export interface RulerModelSource {
+    /** The ruler model for the selection, in points: the same value as `getState().ruler`. */
+    model(): RulerModel;
+}
+/** The rulers of a mounted editor: the built-in rulers, and the model mapped to the viewport. */
+export interface Ruler extends RulerModelSource {
+    /** Shows or hides the built-in rulers. */
+    setVisible(rulers: {
+        horizontal?: boolean;
+        vertical?: boolean;
+    }): Promise<void>;
+    /** The unit the rulers show. */
+    setUnit(unit: RulerUnit): Promise<void>;
+    /** What a click on the ruler adds; the corner box cycles it. */
+    setTabSelector(kind: TabSelector): Promise<void>;
+    /** The model with its mapping to the viewport, for an application drawing its own ruler. */
+    view(): RulerView;
+}
+/** A ruler unit. */
+export type RulerUnit = 'inches' | 'centimeters' | 'millimeters' | 'points' | 'picas';
+/** What a click on the ruler adds. */
+export type TabSelector = TabAlignment | 'firstLineIndent' | 'hangingIndent';
+/** A tab stop's alignment. */
+export type TabAlignment = 'left' | 'center' | 'right' | 'decimal' | 'bar';
+/** A tab stop's leader. */
+export type TabLeader = 'none' | 'dots' | 'dashes' | 'underline' | 'heavy' | 'middleDot';
+/** The ruler model for the selection, in points. */
+export interface RulerModel {
+    /** The selected paragraphs differ: the first one's values are shown. */
+    mixed: boolean;
+    /** The horizontal ruler. */
+    horizontal: {
+        pageWidth: Points;
+        /** The margins, or the cell or text column around the caret. */
+        text: {
+            start: Points;
+            end: Points;
+        };
+        /** `firstLine` is relative to `left`; negative is hanging. */
+        indents: {
+            left: Points;
+            right: Points;
+            firstLine: Points;
+        };
+        tabs: {
+            position: Points;
+            alignment: TabAlignment;
+            leader: TabLeader;
+            inherited: boolean;
+        }[];
+        defaultTabStop: Points;
+        /** The section's text columns. */
+        columns: {
+            start: Points;
+            end: Points;
+        }[];
+        /** The cell boundaries of the caret's row. */
+        tableColumns: Points[];
+    };
+    /** The vertical ruler. */
+    vertical: {
+        pageHeight: Points;
+        /** The top and bottom margins. */
+        text: {
+            start: Points;
+            end: Points;
+        };
+        /** The row boundaries of the caret's table on this page. */
+        tableRows: Points[];
+    };
+}
+/** The ruler model mapped to the viewport. */
+export interface RulerView {
+    /** The model. */
+    model: RulerModel;
+    /** The page the rulers follow (the caret's). */
+    page: number;
+    /** The client x of the page's left edge, and CSS px per point. */
+    horizontal: {
+        origin: number;
+        scale: number;
+    };
+    /** The client y of the page's top edge, and CSS px per point. */
+    vertical: {
+        origin: number;
+        scale: number;
+    };
+    /** The unit shown. */
+    unit: RulerUnit;
+}
+/** The mounted rulers over a session; `view` starts as `initial` and follows `rulerChanged`. */
+export declare function createRuler(s: Session, initial: RulerView): Ruler;

package/dist/services/ruler.js

@@ -0,0 +1,16 @@
+import { Method } from '../transport/protocol.js';
+/** The mounted rulers over a session; `view` starts as `initial` and follows `rulerChanged`. */
+export function createRuler(s, initial) {
+    let view = initial;
+    s.on('rulerChanged', (v) => (view = v));
+    return {
+        model: () => s.state.ruler,
+        setVisible: ({ horizontal, vertical }) => {
+            const now = s.state.view.rulers;
+            return s.call(Method.HostSetRulers, { horizontal: horizontal ?? now.horizontal, vertical: vertical ?? now.vertical });
+        },
+        setUnit: (unit) => s.call(Method.HostSetRulerUnit, unit),
+        setTabSelector: (kind) => s.call(Method.HostSetTabSelector, kind),
+        view: () => view,
+    };
+}

package/dist/services/spelling.d.ts

@@ -0,0 +1,34 @@
+import type { Session } from '../editor.js';
+/** Hunspell dictionaries for one language. */
+export interface Dictionary {
+    /** The BCP 47 language tag. */
+    language: string;
+    /** The `.aff` file. */
+    aff: Uint8Array;
+    /** The `.dic` file. */
+    dic: Uint8Array;
+}
+/** Spell checking. */
+export interface Spelling {
+    /** Adds a language's dictionaries. */
+    addDictionary(dictionary: Dictionary): Promise<void>;
+    /** Turns checking on or off. */
+    setEnabled(on: boolean): Promise<void>;
+    /** The default language for text with no language. */
+    setLanguage(language: string): Promise<void>;
+    /** Ignores a word for this session. */
+    ignore(word: string): Promise<void>;
+    /** Adds a word to the user's dictionary: emits `wordAdded`, for the application to persist. */
+    add(word: string): Promise<void>;
+    /** Loads the user's words for a language; kept until that language's dictionary arrives. */
+    loadUserWords(language: string, words: string[]): Promise<void>;
+    /** Suggestions for a word. */
+    suggestions(word: string, language?: string): Promise<string[]>;
+    /** Selects the next misspelling (F7), or resolves `null` when there is none. */
+    next(): Promise<{
+        word: string;
+        suggestions: string[];
+    } | null>;
+}
+/** Spell checking over a session. */
+export declare function createSpelling(s: Session): Spelling;

package/dist/services/spelling.js

@@ -0,0 +1,14 @@
+import { Method } from '../transport/protocol.js';
+/** Spell checking over a session. */
+export function createSpelling(s) {
+    return {
+        addDictionary: (dictionary) => s.call(Method.SpellingAddDictionary, dictionary),
+        setEnabled: (on) => s.call(Method.SpellingSetEnabled, on),
+        setLanguage: (language) => s.call(Method.SpellingSetLanguage, language),
+        ignore: (word) => s.call(Method.SpellingIgnore, word),
+        add: (word) => s.call(Method.SpellingAdd, word),
+        loadUserWords: (language, words) => s.call(Method.SpellingLoadUserWords, { language, words }),
+        suggestions: (word, language) => s.call(Method.SpellingSuggestions, { word, language }),
+        next: () => s.call(Method.SpellingNext),
+    };
+}

package/dist/services/view.d.ts

@@ -0,0 +1,70 @@
+import type { Op } from '../commands.js';
+import type { Session } from '../editor.js';
+import type { ClientPoint, ClientRect, Color, FrameStats, OverlayColors } from '../types.js';
+import type { MenuTarget } from './menus.js';
+/** The view of a mounted editor. Zoom and the other view settings are the view commands. */
+export interface View {
+    /** Scrolls the selection into view. */
+    revealSelection(): Promise<void>;
+    /**
+     * The background around the pages (dark mode). The paper stays white. The page shadow, the markup pane and the
+     * rulers' colours follow it: a dark background gives dark rulers.
+     */
+    setBackground(color: Color): Promise<void>;
+    /** The pages on screen, for a page navigator or a thumbnails strip. */
+    visiblePages(): {
+        page: number;
+        rect: ClientRect;
+    }[];
+    /** What the frames have cost so far: for benchmarks and tests. */
+    frameStats(): Promise<FrameStats>;
+    /**
+     * How the caret blinks: `ms` per phase (0 for a steady caret), and stop blinking, the caret left visible, after
+     * `stopAfterMs` without input. The editor stops following the platform's reduced-motion setting.
+     */
+    setCaretBlink(ms: number, stopAfterMs?: number): Promise<void>;
+    /**
+     * The colours of what the editor draws over the document; the ones not given keep theirs. The editor stops following
+     * the platform's forced-colours mode.
+     */
+    setOverlayColors(colors: Partial<OverlayColors>): Promise<void>;
+}
+/** What the engine's pointer gestures do, on a mounted editor. */
+export interface Gestures {
+    /** Every gesture's binding. */
+    bindings(): GestureBinding[];
+    /** Rebinds a gesture. */
+    set(gesture: GestureId, action: GestureAction): Promise<void>;
+    /** Back to the default (all of them when no id is given). */
+    reset(gesture?: GestureId): Promise<void>;
+}
+/** A pointer gesture the engine recognises. */
+export type GestureId = 'headerAreaDoubleClick' | 'footerAreaDoubleClick' | 'bodyDoubleClickInHeaderFooter' | 'textDoubleClick' | 'textTripleClick' | 'textCtrlClick' | 'linkActivate' | 'marginClick' | 'marginDoubleClick' | 'tableBorderDoubleClick' | 'tableBorderDrag' | 'objectDrag' | 'textDrag' | 'elementDoubleClick' | 'placeholderClick' | 'rulerClick' | 'rulerDrag' | 'rulerDragOff' | 'rulerDoubleClick' | 'contextClick';
+/** What a gesture does: its default, an event, nothing, or an op. */
+export type GestureAction = 'default' | 'emit' | 'none' | {
+    op: Op;
+};
+/** A gesture's binding. */
+export interface GestureBinding {
+    /** The gesture. */
+    gesture: GestureId;
+    /** What it does. */
+    action: GestureAction;
+    /** For example `'Double-click the header area'`. */
+    label: string;
+}
+/** The `gesture` event: a gesture bound to `'emit'` happened. */
+export interface GestureEvent {
+    /** The gesture. */
+    gesture: GestureId;
+    /** Where. */
+    at: ClientPoint;
+    /** The page. */
+    page: number;
+    /** What is under the point. */
+    target: MenuTarget | {
+        kind: 'headerArea' | 'footerArea' | 'margin' | 'ruler' | 'tableBorder';
+    };
+}
+/** The gestures over a session; `bindings` starts as `initial` and is read again after each change. */
+export declare function createGestures(s: Session, initial: GestureBinding[]): Gestures;

package/dist/services/view.js

@@ -0,0 +1,19 @@
+import { Method } from '../transport/protocol.js';
+/** The gestures over a session; `bindings` starts as `initial` and is read again after each change. */
+export function createGestures(s, initial) {
+    let bindings = initial;
+    const refresh = async () => {
+        bindings = await s.call(Method.GesturesBindings);
+    };
+    return {
+        bindings: () => bindings,
+        set: async (gesture, action) => {
+            await s.call(Method.GesturesSet, { gesture, action });
+            await refresh();
+        },
+        reset: async (gesture) => {
+            await s.call(Method.GesturesReset, gesture ?? null);
+            await refresh();
+        },
+    };
+}