npm - superdoc-macros - Versions diffs - 0.1.0 - Mend

superdoc-macros 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/LICENSE +21 -0
package/README.md +154 -0
package/dist/host/superdoc-host.d.ts +130 -0
package/dist/host/superdoc-host.js +257 -0
package/dist/index.d.ts +12 -0
package/dist/index.js +10 -0
package/dist/manager.d.ts +102 -0
package/dist/manager.js +249 -0
package/dist/recorder/recorder.d.ts +57 -0
package/dist/recorder/recorder.js +141 -0
package/dist/scripting/eval-runner.d.ts +16 -0
package/dist/scripting/eval-runner.js +69 -0
package/dist/scripting/iframe-runner.d.ts +41 -0
package/dist/scripting/iframe-runner.js +150 -0
package/dist/scripting/macro-api.d.ts +69 -0
package/dist/scripting/macro-api.js +102 -0
package/dist/scripting/runner.d.ts +21 -0
package/dist/scripting/runner.js +2 -0
package/dist/shortcuts.d.ts +39 -0
package/dist/shortcuts.js +79 -0
package/dist/snippets/autotext.d.ts +43 -0
package/dist/snippets/autotext.js +106 -0
package/dist/snippets/snippets.d.ts +26 -0
package/dist/snippets/snippets.js +38 -0
package/dist/storage.d.ts +24 -0
package/dist/storage.js +65 -0
package/dist/types.d.ts +119 -0
package/dist/types.js +9 -0
package/package.json +44 -0

package/dist/scripting/iframe-runner.js ADDED Viewed

@@ -0,0 +1,150 @@
+import { limitCalls } from './eval-runner.js';
+import { DEFAULT_MAX_API_CALLS, DEFAULT_TIMEOUT_MS, } from './runner.js';
+/** סימון ההודעות של הפרוטוקול, כדי לא להתנגש בהודעות אחרות בדף. */
+export const PROTOCOL_MARK = '__otzariaMacro';
+/** האם הודעה שייכת לפרוטוקול. חשופה לבדיקות. */
+export function isProtocolMessage(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        data[PROTOCOL_MARK] === true &&
+        typeof data.kind === 'string');
+}
+/**
+ * הקוד שרץ בתוך ה-iframe. מחרוזת ולא פונקציה מוסרלת — כדי שה-build לא ישנה
+ * אותו (minify של שמות היה שובר את הפרוטוקול).
+ */
+export const SANDBOX_BOOTSTRAP = `
+'use strict';
+(function () {
+  var MARK = '${PROTOCOL_MARK}';
+  var pending = new Map();
+  var seq = 0;
+  function post(message) {
+    message[MARK] = true;
+    parent.postMessage(message, '*');
+  }
+  var api = new Proxy({}, {
+    get: function (_target, method) {
+      if (typeof method !== 'string') return undefined;
+      if (method === 'then') return undefined; // ש-await api לא יתפרש כ-thenable
+      return function () {
+        var args = Array.prototype.slice.call(arguments);
+        return new Promise(function (resolve, reject) {
+          seq += 1;
+          pending.set(seq, { resolve: resolve, reject: reject });
+          post({ kind: 'call', id: seq, method: method, args: args });
+        });
+      };
+    }
+  });
+  addEventListener('message', function (event) {
+    var m = event.data;
+    if (!m || m[MARK] !== true) return;
+    if (m.kind === 'run') {
+      var AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+      Promise.resolve()
+        .then(function () {
+          var fn = new AsyncFunction('api', '"use strict";' + m.source);
+          return fn(api);
+        })
+        .then(function (value) {
+          var safe;
+          try { safe = value === undefined ? undefined : JSON.parse(JSON.stringify(value)); }
+          catch (_e) { safe = String(value); }
+          post({ kind: 'done', value: safe });
+        })
+        .catch(function (error) {
+          post({ kind: 'error', message: error && error.message ? String(error.message) : String(error) });
+        });
+      return;
+    }
+    if (m.kind === 'result') {
+      var entry = pending.get(m.id);
+      if (!entry) return;
+      pending.delete(m.id);
+      if (m.ok) entry.resolve(m.value);
+      else entry.reject(new Error(m.message || 'macro call failed'));
+    }
+  });
+  post({ kind: 'ready' });
+})();
+`;
+/** ערך בטוח למסירה חזרה ל-iframe (structured clone עלול להיכשל על אובייקטי מנוע). */
+function toCloneSafe(value) {
+    if (value === undefined || value === null)
+        return value;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+export function createIframeRunner(doc = document) {
+    return {
+        run(source, bridge, options = {}) {
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const limited = limitCalls(bridge, options.maxApiCalls ?? DEFAULT_MAX_API_CALLS);
+            return new Promise((resolve) => {
+                const iframe = doc.createElement('iframe');
+                iframe.setAttribute('sandbox', 'allow-scripts');
+                iframe.style.display = 'none';
+                iframe.srcdoc = `<!doctype html><meta charset="utf-8"><script>${SANDBOX_BOOTSTRAP}</script>`;
+                let settled = false;
+                let timer;
+                const finish = (result) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    removeEventListener('message', onMessage);
+                    iframe.remove();
+                    resolve(result);
+                };
+                const onMessage = (event) => {
+                    // רק הודעות מה-iframe הזה: דף יכול להריץ כמה מאקרו במקביל.
+                    if (event.source !== iframe.contentWindow)
+                        return;
+                    const data = event.data;
+                    if (!isProtocolMessage(data))
+                        return;
+                    if (data.kind === 'ready') {
+                        iframe.contentWindow?.postMessage({ [PROTOCOL_MARK]: true, kind: 'run', source }, '*');
+                        return;
+                    }
+                    if (data.kind === 'call') {
+                        const { id, method, args } = data;
+                        limited
+                            .call(method, args)
+                            .then((value) => {
+                            iframe.contentWindow?.postMessage({ [PROTOCOL_MARK]: true, kind: 'result', id, ok: true, value: toCloneSafe(value) }, '*');
+                        })
+                            .catch((error) => {
+                            iframe.contentWindow?.postMessage({
+                                [PROTOCOL_MARK]: true,
+                                kind: 'result',
+                                id,
+                                ok: false,
+                                message: error instanceof Error ? error.message : String(error),
+                            }, '*');
+                        });
+                        return;
+                    }
+                    if (data.kind === 'done')
+                        finish({ ok: true, value: data.value });
+                    else if (data.kind === 'error')
+                        finish({ ok: false, reason: 'error', message: data.message });
+                };
+                addEventListener('message', onMessage);
+                timer = setTimeout(() => finish({ ok: false, reason: 'timeout', message: `המאקרו לא הסתיים תוך ${timeoutMs / 1000} שניות ונעצר` }), timeoutMs);
+                doc.body.appendChild(iframe);
+            });
+        },
+    };
+}

package/dist/scripting/macro-api.d.ts ADDED Viewed

@@ -0,0 +1,69 @@
+/**
+ * ה-API שסקריפט מאקרו מקבל.
+ *
+ * שני צרכנים לאותו מימוש: מריץ ה-eval מקבל את האובייקט `api` ישירות, ומריץ
+ * ה-iframe מדבר איתו דרך `call(method, args)` — RPC על postMessage. לכן כל
+ * מתודה רשומה במילון אחד, וה-proxy בתוך ה-iframe פונה לאותם שמות בדיוק.
+ *
+ * כללי כשל: פעולות כתיבה זורקות `MacroError` כשהן נכשלות, כדי שסקריפט ייעצר
+ * במקום להמשיך על מסמך במצב לא צפוי. `command()` הגולמית מחזירה את התוצאה
+ * ואינה זורקת — למי שרוצה לבדוק בעצמו.
+ */
+import type { MacroHost, MacroOutcome } from '../types.js';
+/** כשל של פעולת מאקרו. השם מאפשר לסקריפט להבחין בינו ובין TypeError שלו. */
+export declare class MacroError extends Error {
+    readonly reason?: string;
+    constructor(message: string, reason?: string);
+}
+/** תצלום בחירה בטוח למסירה ל-iframe (בלי היעד האטום של המנוע). */
+export interface ScriptSelection {
+    text: string;
+    hasRange: boolean;
+    blockId: string | null;
+    empty: boolean;
+}
+/** מה שסקריפט מקבל בתור `api`. כל המתודות א-סינכרוניות. */
+export interface MacroApi {
+    /** מריצה פקודה מקטלוג המנוע. מחזירה תוצאה ואינה זורקת. */
+    command(id: string, payload?: unknown): Promise<MacroOutcome>;
+    /** האם המנוע מכיר את הפקודה. */
+    hasCommand(id: string): Promise<boolean>;
+    /** מזהי הפקודות המוכרות. */
+    commandIds(): Promise<readonly string[]>;
+    insertText(text: string): Promise<void>;
+    insertParagraph(): Promise<void>;
+    deleteBackward(count?: number): Promise<void>;
+    getSelection(): Promise<ScriptSelection>;
+    getSelectionText(): Promise<string>;
+    getDocumentText(): Promise<string>;
+    /** מחליפה את כל המופעים. מחזירה כמה הוחלפו. */
+    replaceAll(query: string, replacement: string): Promise<number>;
+    bold(): Promise<void>;
+    italic(): Promise<void>;
+    underline(): Promise<void>;
+    strikethrough(): Promise<void>;
+    clearFormatting(): Promise<void>;
+    bulletList(): Promise<void>;
+    numberedList(): Promise<void>;
+    indentIncrease(): Promise<void>;
+    indentDecrease(): Promise<void>;
+    directionRtl(): Promise<void>;
+    directionLtr(): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    /** כותבת שורה ליומן הריצה (מוצג למשתמש, לא ל-console). */
+    log(...parts: unknown[]): Promise<void>;
+}
+export interface MacroApiOptions {
+    /** מקבלת כל שורת `api.log`. ברירת המחדל: console.info. */
+    onLog?: (line: string) => void;
+}
+export interface MacroBridge {
+    api: MacroApi;
+    /** מסלול ה-RPC: מפעילה מתודה לפי שם. זורקת על מתודה שאינה קיימת. */
+    call(method: string, args: readonly unknown[]): Promise<unknown>;
+    /** מספר הקריאות שבוצעו עד כה. משמש לתקרת קריאות במריצים. */
+    callCount(): number;
+}
+/** בונה את ה-API מעל מארח. */
+export declare function createMacroApi(host: MacroHost, options?: MacroApiOptions): MacroBridge;

package/dist/scripting/macro-api.js ADDED Viewed

@@ -0,0 +1,102 @@
+/** כשל של פעולת מאקרו. השם מאפשר לסקריפט להבחין בינו ובין TypeError שלו. */
+export class MacroError extends Error {
+    reason;
+    constructor(message, reason) {
+        super(message);
+        this.name = 'MacroError';
+        this.reason = reason;
+    }
+}
+function requireOk(outcome, action) {
+    if (!outcome.ok) {
+        throw new MacroError(`${action}: ${outcome.message}`, outcome.reason);
+    }
+}
+function asText(value, name) {
+    if (typeof value !== 'string')
+        throw new MacroError(`${name} חייב להיות מחרוזת`);
+    return value;
+}
+function formatLogPart(part) {
+    if (typeof part === 'string')
+        return part;
+    try {
+        return JSON.stringify(part);
+    }
+    catch {
+        return String(part);
+    }
+}
+/** בונה את ה-API מעל מארח. */
+export function createMacroApi(host, options = {}) {
+    const onLog = options.onLog ?? ((line) => console.info('[superdoc-macros]', line));
+    const commandSugar = async (id) => {
+        requireOk(await host.commands.execute(id), `הפקודה ${id} נכשלה`);
+    };
+    const api = {
+        command: (id, payload) => host.commands.execute(asText(id, 'id'), payload),
+        hasCommand: async (id) => host.commands.has(asText(id, 'id')),
+        commandIds: async () => host.commands.ids(),
+        async insertText(text) {
+            requireOk(await host.insertText(asText(text, 'text')), 'הכנסת הטקסט נכשלה');
+        },
+        async insertParagraph() {
+            requireOk(await host.insertText('\n'), 'הכנסת הפסקה נכשלה');
+        },
+        async deleteBackward(count = 1) {
+            const n = Math.max(0, Math.trunc(Number(count)));
+            if (n === 0)
+                return;
+            requireOk(await host.deleteBackward(n), 'המחיקה נכשלה');
+        },
+        async getSelection() {
+            const snapshot = await host.getSelection({ includeText: true });
+            return {
+                text: snapshot.text,
+                hasRange: snapshot.hasRange,
+                blockId: snapshot.blockId,
+                empty: snapshot.empty,
+            };
+        },
+        async getSelectionText() {
+            return (await host.getSelection({ includeText: true })).text;
+        },
+        getDocumentText: () => host.getDocumentText(),
+        async replaceAll(query, replacement) {
+            const result = await host.replaceAll(asText(query, 'query'), asText(replacement, 'replacement'));
+            if (!result.ok)
+                throw new MacroError(result.message ?? 'ההחלפה נכשלה');
+            return result.replaced;
+        },
+        bold: () => commandSugar('bold'),
+        italic: () => commandSugar('italic'),
+        underline: () => commandSugar('underline'),
+        strikethrough: () => commandSugar('strikethrough'),
+        clearFormatting: () => commandSugar('clear-formatting'),
+        bulletList: () => commandSugar('bullet-list'),
+        numberedList: () => commandSugar('numbered-list'),
+        indentIncrease: () => commandSugar('indent-increase'),
+        indentDecrease: () => commandSugar('indent-decrease'),
+        directionRtl: () => commandSugar('direction-rtl'),
+        directionLtr: () => commandSugar('direction-ltr'),
+        undo: () => commandSugar('undo'),
+        redo: () => commandSugar('redo'),
+        async log(...parts) {
+            onLog(parts.map(formatLogPart).join(' '));
+        },
+    };
+    let calls = 0;
+    const methods = api;
+    return {
+        api,
+        async call(method, args) {
+            const fn = methods[method];
+            if (typeof fn !== 'function' || !Object.prototype.hasOwnProperty.call(api, method)) {
+                throw new MacroError(`מתודה לא מוכרת: ${String(method)}`);
+            }
+            calls += 1;
+            return fn.apply(api, args);
+        },
+        callCount: () => calls,
+    };
+}

package/dist/scripting/runner.d.ts ADDED Viewed

@@ -0,0 +1,21 @@
+/** חוזה משותף לשני המריצים (eval ו-iframe). */
+import type { MacroBridge } from './macro-api.js';
+export type MacroRunResult = {
+    ok: true;
+    value?: unknown;
+} | {
+    ok: false;
+    message: string;
+    reason?: 'timeout' | 'error' | 'call-limit';
+};
+export interface MacroRunOptions {
+    /** תקרת זמן לריצה כולה. ברירת מחדל: 30 שניות. */
+    timeoutMs?: number;
+    /** תקרת קריאות API, נגד לולאה בורחת. ברירת מחדל: 10,000. */
+    maxApiCalls?: number;
+}
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_MAX_API_CALLS = 10000;
+export interface MacroRunner {
+    run(source: string, bridge: MacroBridge, options?: MacroRunOptions): Promise<MacroRunResult>;
+}

package/dist/scripting/runner.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export const DEFAULT_TIMEOUT_MS = 30_000;
2	+ export const DEFAULT_MAX_API_CALLS = 10_000;

package/dist/shortcuts.d.ts ADDED Viewed

@@ -0,0 +1,39 @@
+/**
+ * קיצורי מקלדת למאקרו ולקטעים: ניתוח מחרוזת `Ctrl+Alt+M` והתאמה לאירוע.
+ *
+ * ההתאמה לפי `event.key` באותיות קטנות. `Mod` פירושו Ctrl (או ⌘ במק).
+ */
+export interface ParsedShortcut {
+    key: string;
+    ctrl: boolean;
+    alt: boolean;
+    shift: boolean;
+    meta: boolean;
+    /** Ctrl או Meta — לקיצורים שנכתבו עם `Mod`. */
+    mod: boolean;
+}
+/** תת-הצורה של KeyboardEvent שההתאמה צריכה. מאפשר בדיקות בלי DOM. */
+export interface KeyEventLike {
+    key: string;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    preventDefault?(): void;
+    stopPropagation?(): void;
+}
+export declare function parseShortcut(shortcut: string): ParsedShortcut | null;
+export declare function eventMatches(parsed: ParsedShortcut, event: KeyEventLike): boolean;
+export interface ShortcutBinding {
+    shortcut: string;
+    run(): void | Promise<unknown>;
+}
+export interface ShortcutTarget {
+    addEventListener(type: 'keydown', listener: (event: KeyboardEvent) => void, options?: boolean): void;
+    removeEventListener(type: 'keydown', listener: (event: KeyboardEvent) => void, options?: boolean): void;
+}
+/**
+ * קושרת קיצורים ליעד. `getBindings` נקראת בכל הקשה — כך רשימת המאקרו יכולה
+ * להשתנות בלי לקשור מחדש. מחזירה פונקציית ניתוק.
+ */
+export declare function bindShortcuts(target: ShortcutTarget, getBindings: () => readonly ShortcutBinding[]): () => void;

package/dist/shortcuts.js ADDED Viewed

@@ -0,0 +1,79 @@
+export function parseShortcut(shortcut) {
+    const parts = shortcut
+        .split('+')
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    if (parts.length === 0)
+        return null;
+    const parsed = { key: '', ctrl: false, alt: false, shift: false, meta: false, mod: false };
+    for (const part of parts) {
+        switch (part.toLowerCase()) {
+            case 'ctrl':
+            case 'control':
+                parsed.ctrl = true;
+                break;
+            case 'alt':
+            case 'option':
+                parsed.alt = true;
+                break;
+            case 'shift':
+                parsed.shift = true;
+                break;
+            case 'meta':
+            case 'cmd':
+            case 'win':
+                parsed.meta = true;
+                break;
+            case 'mod':
+                parsed.mod = true;
+                break;
+            default: {
+                if (parsed.key)
+                    return null; // שני מקשים שאינם modifiers — קיצור פסול.
+                parsed.key = normalizeKey(part);
+            }
+        }
+    }
+    return parsed.key ? parsed : null;
+}
+function normalizeKey(key) {
+    const lower = key.toLowerCase();
+    if (lower === 'space')
+        return ' ';
+    if (lower === 'esc')
+        return 'escape';
+    return lower;
+}
+export function eventMatches(parsed, event) {
+    if (normalizeKey(event.key) !== parsed.key)
+        return false;
+    if (parsed.mod) {
+        if (!event.ctrlKey && !event.metaKey)
+            return false;
+        // עם Mod לא בודקים ctrl/meta בנפרד — אבל alt/shift חייבים להתאים בדיוק.
+        return event.altKey === parsed.alt && event.shiftKey === parsed.shift;
+    }
+    return (event.ctrlKey === parsed.ctrl &&
+        event.altKey === parsed.alt &&
+        event.shiftKey === parsed.shift &&
+        event.metaKey === parsed.meta);
+}
+/**
+ * קושרת קיצורים ליעד. `getBindings` נקראת בכל הקשה — כך רשימת המאקרו יכולה
+ * להשתנות בלי לקשור מחדש. מחזירה פונקציית ניתוק.
+ */
+export function bindShortcuts(target, getBindings) {
+    const listener = (event) => {
+        for (const binding of getBindings()) {
+            const parsed = parseShortcut(binding.shortcut);
+            if (!parsed || !eventMatches(parsed, event))
+                continue;
+            event.preventDefault?.();
+            event.stopPropagation?.();
+            void binding.run();
+            return;
+        }
+    };
+    target.addEventListener('keydown', listener, true);
+    return () => target.removeEventListener('keydown', listener, true);
+}

package/dist/snippets/autotext.d.ts ADDED Viewed

@@ -0,0 +1,43 @@
+/**
+ * השלמה אוטומטית (AutoText): הקלדת מילת ההפעלה של קטע ואחריה רווח מחליפה את
+ * המילה בתוכן הקטע.
+ *
+ * איך זה עובד: נשמר חוצץ קטן של התווים שהוקלדו ברצף הנוכחי (מתוך אירועי
+ * `TextInputEvent` של המארח). כשמוקלד תו הרחבה (רווח כברירת מחדל) והמילה
+ * שלפניו היא trigger של קטע — המילה ותו ההרחבה נמחקים לאחור, והתוכן המורחב
+ * מוכנס במקומם עם תו ההרחבה בסופו.
+ *
+ * החוצץ מתאפס על פסקה חדשה, על מחיקה קדימה ועל פקודה שרצה באמצע — כל דבר
+ * שמנתק את הרצף בין מה שהוקלד ובין מה שנמצא בפועל לפני הסמן. עדיף פספוס
+ * הרחבה על הרחבה שמוחקת טקסט לא נכון.
+ */
+import type { MacroHost, Snippet } from '../types.js';
+export interface AutoTextOptions {
+    /** תווי ההרחבה. ברירת מחדל: רווח בלבד. */
+    expandOn?: readonly string[];
+    /** גודל החוצץ. מילת הפעלה ארוכה מזה לא תזוהה. */
+    bufferSize?: number;
+    /** נקראת אחרי הרחבה מוצלחת. */
+    onExpand?: (snippet: Snippet) => void;
+    /** נקראת כשהרחבה נכשלה (למשל מסמך לקריאה בלבד). */
+    onError?: (message: string) => void;
+}
+export declare class AutoText {
+    private readonly host;
+    private readonly getSnippets;
+    private readonly expandOn;
+    private readonly bufferSize;
+    private readonly onExpand?;
+    private readonly onError?;
+    private buffer;
+    private busy;
+    private disposeCommand;
+    private disposeInput;
+    constructor(host: MacroHost, getSnippets: () => readonly Snippet[], options?: AutoTextOptions);
+    get attached(): boolean;
+    attach(): () => void;
+    detach(): void;
+    private handleInput;
+    private findByTrigger;
+    private expand;
+}

package/dist/snippets/autotext.js ADDED Viewed

@@ -0,0 +1,106 @@
+import { renderSnippet, usesSelection } from './snippets.js';
+const DEFAULT_BUFFER = 64;
+export class AutoText {
+    host;
+    getSnippets;
+    expandOn;
+    bufferSize;
+    onExpand;
+    onError;
+    buffer = '';
+    busy = false;
+    disposeCommand = null;
+    disposeInput = null;
+    constructor(host, getSnippets, options = {}) {
+        this.host = host;
+        this.getSnippets = getSnippets;
+        this.expandOn = new Set(options.expandOn ?? [' ']);
+        this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER;
+        this.onExpand = options.onExpand;
+        this.onError = options.onError;
+    }
+    get attached() {
+        return this.disposeInput !== null;
+    }
+    attach() {
+        if (this.disposeInput)
+            return () => this.detach();
+        this.buffer = '';
+        this.disposeInput = this.host.onTextInput((event) => void this.handleInput(event));
+        // פקודה באמצע הקלדה (עיצוב, הדבקה) מנתקת את הקשר בין החוצץ למסמך.
+        this.disposeCommand = this.host.onCommand(() => {
+            if (!this.busy)
+                this.buffer = '';
+        });
+        return () => this.detach();
+    }
+    detach() {
+        this.disposeInput?.();
+        this.disposeCommand?.();
+        this.disposeInput = null;
+        this.disposeCommand = null;
+        this.buffer = '';
+    }
+    async handleInput(event) {
+        // קלט שנוצר בזמן שההרחבה עצמה כותבת — לא חלק מההקלדה של המשתמש.
+        if (this.busy)
+            return;
+        switch (event.kind) {
+            case 'insert-paragraph':
+            case 'delete-forward':
+                this.buffer = '';
+                return;
+            case 'delete-backward':
+                this.buffer = this.buffer.slice(0, -1);
+                return;
+            case 'insert-text':
+                break;
+        }
+        for (const char of event.text) {
+            if (this.expandOn.has(char)) {
+                const trigger = trailingWord(this.buffer);
+                const snippet = trigger ? this.findByTrigger(trigger) : undefined;
+                this.buffer = '';
+                if (snippet && trigger)
+                    await this.expand(snippet, trigger, char);
+                continue;
+            }
+            this.buffer = (this.buffer + char).slice(-this.bufferSize);
+        }
+    }
+    findByTrigger(word) {
+        return this.getSnippets().find((snippet) => snippet.trigger === word);
+    }
+    async expand(snippet, trigger, expandChar) {
+        this.busy = true;
+        try {
+            // אירוע הקלט (beforeinput) נורה לפני שהתו נכתב למסמך. הדחייה לתור
+            // המשימות מבטיחה שתו ההרחבה כבר בפנים לפני שמוחקים אותו יחד עם ה-trigger.
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            const selectionText = usesSelection(snippet.text)
+                ? (await this.host.getSelection({ includeText: true })).text
+                : undefined;
+            const rendered = renderSnippet(snippet.text, { selectionText });
+            // תו ההרחבה כבר נכתב למסמך כשמגיעים לכאן, ולכן הוא נכלל במחיקה ומוחזר בסוף.
+            const deleted = await this.host.deleteBackward(trigger.length + 1);
+            if (!deleted.ok) {
+                this.onError?.(deleted.message);
+                return;
+            }
+            const inserted = await this.host.insertText(rendered + expandChar);
+            if (!inserted.ok) {
+                this.onError?.(inserted.message);
+                return;
+            }
+            this.onExpand?.(snippet);
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+}
+/** המילה שבסוף החוצץ — רצף שאינו רווח לבן. */
+function trailingWord(buffer) {
+    const match = /(\S+)$/u.exec(buffer);
+    return match?.[1] ?? null;
+}

package/dist/snippets/snippets.d.ts ADDED Viewed

@@ -0,0 +1,26 @@
+/**
+ * קטעי טקסט (Snippets): תבניות שמוכנסות במיקום הסמן, עם משתני `{{...}}`.
+ *
+ * משתנים מובנים: `{{date}}`, `{{time}}`, `{{datetime}}` (בעברית, לפי שעון
+ * המערכת), `{{selection}}` (הטקסט המסומן ברגע ההרחבה). כל שם אחר נפתר מתוך
+ * `variables` שנמסרו בקריאה; משתנה שאין לו ערך נשאר כמו שהוא בטקסט — כדי
+ * שטעות כתיב תיראה במסמך ולא תיעלם בשקט.
+ */
+import type { MacroHost, MacroOutcome, Snippet } from '../types.js';
+export interface RenderContext {
+    /** ערכים למשתנים מותאמים. */
+    variables?: Readonly<Record<string, string>>;
+    /** הטקסט שיוצב ב-`{{selection}}`. */
+    selectionText?: string;
+    /** הזמן ל-`{{date}}`/`{{time}}`. ברירת מחדל: עכשיו. קיים בשביל בדיקות. */
+    now?: Date;
+}
+export declare function renderSnippet(text: string, context?: RenderContext): string;
+/** האם הקטע משתמש ב-`{{selection}}` — ואז ההרחבה צריכה לקרוא את הבחירה. */
+export declare function usesSelection(text: string): boolean;
+export interface ExpandOptions {
+    variables?: Readonly<Record<string, string>>;
+    now?: Date;
+}
+/** מרחיבה קטע במיקום הסמן. */
+export declare function expandSnippet(host: MacroHost, snippet: Pick<Snippet, 'text'>, options?: ExpandOptions): Promise<MacroOutcome>;