@rtif-sdk/web 1.0.0

package/dist/plugins/alignment-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alignment-plugin.js","sourceRoot":"","sources":["../../src/plugins/alignment-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,aAAa;IACpB,OAAO,EAAE,eAAe;CAChB,CAAC;AAeX;;;;;;GAMG;AACH,SAAS,mBAAmB,CAAC,MAAqB;IAChD,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC;IACjC,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,EAAE,EAAE,gBAAgB;QACpB,IAAI,CAAC,GAAG;YACN,MAAM,UAAU,GAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;YAEvE,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACnC,GAAG,CAAC,eAAe,CAAC,SAAS,SAAS,EAAE,EAAE;oBACxC,OAAO,CAAC,MAAqB;wBAC3B,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;wBAEvC,gEAAgE;wBAChE,MAAM,KAAK,GAAkB,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;wBAErE,MAAM,CAAC,QAAQ,CAAC;4BACd,IAAI,EAAE,iBAAiB;4BACvB,OAAO,EAAE,KAAK,CAAC,EAAE;4BACjB,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;yBACxB,CAAC,CAAC;oBACL,CAAC;oBAED,UAAU,CAAC,OAAsB;wBAC/B,OAAO,IAAI,CAAC;oBACd,CAAC;oBAED,QAAQ,CAAC,MAAqB;wBAC5B,OAAO,mBAAmB,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC;oBACnD,CAAC;iBACF,CAAC,CAAC;YACL,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/block-utils.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared utilities for block type plugins.
+ *
+ * Provides `getBlockStartOffset()` for computing a block's absolute offset,
+ * `getBlockAtCursor()` for resolving the block at the cursor,
+ * `isBlockType()` for checking the cursor block's type and attrs,
+ * `createToggleBlockTypeCommand()` for building block type toggle commands,
+ * and `setBlockType()` for dispatching type + attrs changes in a single batch.
+ *
+ * @module
+ */
+import type { IEditorEngine, CommandDescriptor } from '@rtif-sdk/engine';
+import type { Document, Block } from '@rtif-sdk/core';
+/**
+ * Compute the absolute document offset where a block's text starts.
+ *
+ * Walks all blocks summing text lengths and virtual `\n` separators
+ * until the target block is found.
+ *
+ * @param doc - The document to search
+ * @param blockId - The ID of the target block
+ * @returns The absolute offset of the first character in the block
+ * @throws {RtifError} BLOCK_NOT_FOUND if no block with the given ID exists
+ *
+ * @example
+ * ```ts
+ * // doc has blocks: "hello" (b1), "world" (b2)
+ * getBlockStartOffset(doc, 'b2'); // => 6 (5 chars + 1 virtual \n)
+ * ```
+ */
+export declare function getBlockStartOffset(doc: Document, blockId: string): number;
+/**
+ * Get the block at the current cursor position.
+ *
+ * Uses the engine's `getBlockAtOffset()` method with the focus offset
+ * from the current selection.
+ *
+ * @param engine - The editor engine instance
+ * @returns The block containing the cursor
+ *
+ * @example
+ * ```ts
+ * const block = getBlockAtCursor(engine);
+ * console.log(block.type); // "text"
+ * ```
+ */
+export declare function getBlockAtCursor(engine: IEditorEngine): Block;
+/**
+ * Check whether the block at the cursor position matches a given type
+ * and optionally specific attributes.
+ *
+ * Gets the block at the cursor via `getBlockAtCursor()`, checks that
+ * `block.type === blockType`, and if `attrs` is provided, verifies
+ * that each key/value pair matches the block's attrs.
+ *
+ * @param engine - The editor engine instance
+ * @param blockType - The block type string to check (e.g., "heading")
+ * @param attrs - Optional attributes to match against the block's attrs
+ * @returns `true` if the block matches the given type and attrs
+ *
+ * @example
+ * ```ts
+ * // Check if cursor is in a heading
+ * isBlockType(engine, 'heading');
+ *
+ * // Check if cursor is in a level-2 heading
+ * isBlockType(engine, 'heading', { level: 2 });
+ * ```
+ */
+export declare function isBlockType(engine: IEditorEngine, blockType: string, attrs?: Record<string, unknown>): boolean;
+/**
+ * Create a `CommandDescriptor` that toggles a block between a specific
+ * type (with optional attrs) and plain `"text"`.
+ *
+ * When the block already matches the target type and attrs, it reverts
+ * to `"text"` with the relevant attr keys cleared. Otherwise it sets
+ * the block to the target type with the provided attrs.
+ *
+ * @param blockType - The block type to toggle to (e.g., "heading")
+ * @param attrs - Optional attributes to set when toggling on
+ * @returns A `CommandDescriptor` with execute, canExecute, and isActive
+ *
+ * @example
+ * ```ts
+ * const h1Command = createToggleBlockTypeCommand('heading', { level: 1 });
+ * registries.registerCommand('toggleHeading1', h1Command);
+ * ```
+ */
+export declare function createToggleBlockTypeCommand(blockType: string, attrs?: Record<string, unknown>): CommandDescriptor;
+/**
+ * Dispatch `set_block_type` and optionally `set_block_attrs` in a single
+ * batch to change a block's type and attributes atomically.
+ *
+ * When `attrs` is provided and non-empty, both operations are dispatched
+ * together so they form a single undo group. When `attrs` is omitted,
+ * only `set_block_type` is dispatched.
+ *
+ * @param engine - The editor engine instance
+ * @param blockId - The ID of the block to change
+ * @param blockType - The new block type string
+ * @param attrs - Optional attributes to set on the block
+ *
+ * @example
+ * ```ts
+ * // Change block to heading level 2
+ * setBlockType(engine, 'b1', 'heading', { level: 2 });
+ *
+ * // Change block type without setting attrs
+ * setBlockType(engine, 'b1', 'code');
+ * ```
+ */
+export declare function setBlockType(engine: IEditorEngine, blockId: string, blockType: string, attrs?: Record<string, unknown>): void;
+//# sourceMappingURL=block-utils.d.ts.map

package/dist/plugins/block-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-utils.d.ts","sourceRoot":"","sources":["../../src/plugins/block-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAa,MAAM,gBAAgB,CAAC;AAGjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAc1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK,CAE7D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAcT;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,iBAAiB,CAqCnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,IAAI,CAYN"}

package/dist/plugins/block-utils.js

@@ -0,0 +1,191 @@
+/**
+ * Shared utilities for block type plugins.
+ *
+ * Provides `getBlockStartOffset()` for computing a block's absolute offset,
+ * `getBlockAtCursor()` for resolving the block at the cursor,
+ * `isBlockType()` for checking the cursor block's type and attrs,
+ * `createToggleBlockTypeCommand()` for building block type toggle commands,
+ * and `setBlockType()` for dispatching type + attrs changes in a single batch.
+ *
+ * @module
+ */
+import { blockTextLength, RtifError } from '@rtif-sdk/core';
+/**
+ * Compute the absolute document offset where a block's text starts.
+ *
+ * Walks all blocks summing text lengths and virtual `\n` separators
+ * until the target block is found.
+ *
+ * @param doc - The document to search
+ * @param blockId - The ID of the target block
+ * @returns The absolute offset of the first character in the block
+ * @throws {RtifError} BLOCK_NOT_FOUND if no block with the given ID exists
+ *
+ * @example
+ * ```ts
+ * // doc has blocks: "hello" (b1), "world" (b2)
+ * getBlockStartOffset(doc, 'b2'); // => 6 (5 chars + 1 virtual \n)
+ * ```
+ */
+export function getBlockStartOffset(doc, blockId) {
+    let offset = 0;
+    for (let i = 0; i < doc.blocks.length; i++) {
+        const block = doc.blocks[i];
+        if (block.id === blockId) {
+            return offset;
+        }
+        offset += blockTextLength(block);
+        // Add virtual \n separator between blocks (not after the last block)
+        if (i < doc.blocks.length - 1) {
+            offset += 1;
+        }
+    }
+    throw new RtifError('BLOCK_NOT_FOUND', `Block not found: ${blockId}`);
+}
+/**
+ * Get the block at the current cursor position.
+ *
+ * Uses the engine's `getBlockAtOffset()` method with the focus offset
+ * from the current selection.
+ *
+ * @param engine - The editor engine instance
+ * @returns The block containing the cursor
+ *
+ * @example
+ * ```ts
+ * const block = getBlockAtCursor(engine);
+ * console.log(block.type); // "text"
+ * ```
+ */
+export function getBlockAtCursor(engine) {
+    return engine.getBlockAtOffset(engine.state.selection.focus.offset);
+}
+/**
+ * Check whether the block at the cursor position matches a given type
+ * and optionally specific attributes.
+ *
+ * Gets the block at the cursor via `getBlockAtCursor()`, checks that
+ * `block.type === blockType`, and if `attrs` is provided, verifies
+ * that each key/value pair matches the block's attrs.
+ *
+ * @param engine - The editor engine instance
+ * @param blockType - The block type string to check (e.g., "heading")
+ * @param attrs - Optional attributes to match against the block's attrs
+ * @returns `true` if the block matches the given type and attrs
+ *
+ * @example
+ * ```ts
+ * // Check if cursor is in a heading
+ * isBlockType(engine, 'heading');
+ *
+ * // Check if cursor is in a level-2 heading
+ * isBlockType(engine, 'heading', { level: 2 });
+ * ```
+ */
+export function isBlockType(engine, blockType, attrs) {
+    const block = getBlockAtCursor(engine);
+    if (block.type !== blockType) {
+        return false;
+    }
+    if (attrs === undefined) {
+        return true;
+    }
+    for (const key of Object.keys(attrs)) {
+        if (block.attrs?.[key] !== attrs[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Create a `CommandDescriptor` that toggles a block between a specific
+ * type (with optional attrs) and plain `"text"`.
+ *
+ * When the block already matches the target type and attrs, it reverts
+ * to `"text"` with the relevant attr keys cleared. Otherwise it sets
+ * the block to the target type with the provided attrs.
+ *
+ * @param blockType - The block type to toggle to (e.g., "heading")
+ * @param attrs - Optional attributes to set when toggling on
+ * @returns A `CommandDescriptor` with execute, canExecute, and isActive
+ *
+ * @example
+ * ```ts
+ * const h1Command = createToggleBlockTypeCommand('heading', { level: 1 });
+ * registries.registerCommand('toggleHeading1', h1Command);
+ * ```
+ */
+export function createToggleBlockTypeCommand(blockType, attrs) {
+    return {
+        execute(engine) {
+            const block = getBlockAtCursor(engine);
+            const isActive = isBlockType(engine, blockType, attrs);
+            if (isActive) {
+                // Revert to plain "text" and clear the relevant attr keys
+                const clearAttrs = {};
+                if (attrs !== undefined) {
+                    for (const key of Object.keys(attrs)) {
+                        clearAttrs[key] = null;
+                    }
+                }
+                const ops = [
+                    { type: 'set_block_type', blockId: block.id, blockType: 'text' },
+                ];
+                if (Object.keys(clearAttrs).length > 0) {
+                    ops.push({
+                        type: 'set_block_attrs',
+                        blockId: block.id,
+                        attrs: clearAttrs,
+                    });
+                }
+                engine.dispatch(ops);
+            }
+            else {
+                // Set to the target block type with optional attrs
+                setBlockType(engine, block.id, blockType, attrs);
+            }
+        },
+        canExecute(_engine) {
+            return true;
+        },
+        isActive(engine) {
+            return isBlockType(engine, blockType, attrs);
+        },
+    };
+}
+/**
+ * Dispatch `set_block_type` and optionally `set_block_attrs` in a single
+ * batch to change a block's type and attributes atomically.
+ *
+ * When `attrs` is provided and non-empty, both operations are dispatched
+ * together so they form a single undo group. When `attrs` is omitted,
+ * only `set_block_type` is dispatched.
+ *
+ * @param engine - The editor engine instance
+ * @param blockId - The ID of the block to change
+ * @param blockType - The new block type string
+ * @param attrs - Optional attributes to set on the block
+ *
+ * @example
+ * ```ts
+ * // Change block to heading level 2
+ * setBlockType(engine, 'b1', 'heading', { level: 2 });
+ *
+ * // Change block type without setting attrs
+ * setBlockType(engine, 'b1', 'code');
+ * ```
+ */
+export function setBlockType(engine, blockId, blockType, attrs) {
+    const ops = [
+        { type: 'set_block_type', blockId, blockType },
+    ];
+    if (attrs !== undefined && Object.keys(attrs).length > 0) {
+        ops.push({
+            type: 'set_block_attrs',
+            blockId,
+            attrs,
+        });
+    }
+    engine.dispatch(ops);
+}
+//# sourceMappingURL=block-utils.js.map

package/dist/plugins/block-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-utils.js","sourceRoot":"","sources":["../../src/plugins/block-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAa,EAAE,OAAe;IAChE,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAE,CAAC;QAC7B,IAAI,KAAK,CAAC,EAAE,KAAK,OAAO,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC;QACjC,qEAAqE;QACrE,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,CAAC;QACd,CAAC;IACH,CAAC;IACD,MAAM,IAAI,SAAS,CAAC,iBAAiB,EAAE,oBAAoB,OAAO,EAAE,CAAC,CAAC;AACxE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAqB;IACpD,OAAO,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,WAAW,CACzB,MAAqB,EACrB,SAAiB,EACjB,KAA+B;IAE/B,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACvC,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACtC,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,4BAA4B,CAC1C,SAAiB,EACjB,KAA+B;IAE/B,OAAO;QACL,OAAO,CAAC,MAAqB;YAC3B,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACvC,MAAM,QAAQ,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YAEvD,IAAI,QAAQ,EAAE,CAAC;gBACb,0DAA0D;gBAC1D,MAAM,UAAU,GAA4B,EAAE,CAAC;gBAC/C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;wBACrC,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;oBACzB,CAAC;gBACH,CAAC;gBACD,MAAM,GAAG,GAAgB;oBACvB,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;iBACjE,CAAC;gBACF,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACvC,GAAG,CAAC,IAAI,CAAC;wBACP,IAAI,EAAE,iBAAiB;wBACvB,OAAO,EAAE,KAAK,CAAC,EAAE;wBACjB,KAAK,EAAE,UAAU;qBAClB,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,mDAAmD;gBACnD,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;QACD,UAAU,CAAC,OAAsB;YAC/B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,QAAQ,CAAC,MAAqB;YAC5B,OAAO,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAqB,EACrB,OAAe,EACf,SAAiB,EACjB,KAA+B;IAE/B,MAAM,GAAG,GAAgB;QACvB,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,SAAS,EAAE;KAC/C,CAAC;IACF,IAAI,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzD,GAAG,CAAC,IAAI,CAAC;YACP,IAAI,EAAE,iBAAiB;YACvB,OAAO;YACP,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IACD,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AACvB,CAAC"}

package/dist/plugins/blockquote-plugin.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Blockquote block type plugin — registers the `blockquote` block type,
+ * `toggleBlockquote` command, and an input rule for `> ` at block start.
+ *
+ * @module
+ */
+import type { Plugin } from '@rtif-sdk/engine';
+/**
+ * Command name constants for the blockquote plugin.
+ *
+ * @example
+ * ```ts
+ * engine.exec(BlockquoteCommands.TOGGLE);
+ * ```
+ */
+export declare const BlockquoteCommands: {
+    readonly TOGGLE: "toggleBlockquote";
+};
+/**
+ * Create the blockquote block type plugin.
+ *
+ * Registers:
+ * - Block type: `blockquote` (no default attrs, no validator)
+ * - Command: `toggleBlockquote` — toggle between blockquote and plain text
+ * - Input rule: `> ` at block start converts to blockquote
+ *
+ * @returns A plugin instance ready for `engine.use()`
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine(initialDoc);
+ * engine.use(blockquotePlugin());
+ *
+ * // Toggle blockquote on the block at cursor
+ * engine.exec(BlockquoteCommands.TOGGLE);
+ * ```
+ */
+export declare function blockquotePlugin(): Plugin;
+//# sourceMappingURL=blockquote-plugin.d.ts.map

package/dist/plugins/blockquote-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockquote-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/blockquote-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,kBAAkB,CAAC;AAG9D;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB;;CAErB,CAAC;AAEX;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAyDzC"}

package/dist/plugins/blockquote-plugin.js

@@ -0,0 +1,88 @@
+/**
+ * Blockquote block type plugin — registers the `blockquote` block type,
+ * `toggleBlockquote` command, and an input rule for `> ` at block start.
+ *
+ * @module
+ */
+import { getBlockStartOffset, getBlockAtCursor, isBlockType, setBlockType } from './block-utils.js';
+/**
+ * Command name constants for the blockquote plugin.
+ *
+ * @example
+ * ```ts
+ * engine.exec(BlockquoteCommands.TOGGLE);
+ * ```
+ */
+export const BlockquoteCommands = {
+    TOGGLE: 'toggleBlockquote',
+};
+/**
+ * Create the blockquote block type plugin.
+ *
+ * Registers:
+ * - Block type: `blockquote` (no default attrs, no validator)
+ * - Command: `toggleBlockquote` — toggle between blockquote and plain text
+ * - Input rule: `> ` at block start converts to blockquote
+ *
+ * @returns A plugin instance ready for `engine.use()`
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine(initialDoc);
+ * engine.use(blockquotePlugin());
+ *
+ * // Toggle blockquote on the block at cursor
+ * engine.exec(BlockquoteCommands.TOGGLE);
+ * ```
+ */
+export function blockquotePlugin() {
+    return {
+        id: 'block-blockquote',
+        init(ctx) {
+            // ---------------------------------------------------------------
+            // Block type registration
+            // ---------------------------------------------------------------
+            ctx.registerBlockType('blockquote', {});
+            // ---------------------------------------------------------------
+            // toggleBlockquote command
+            // ---------------------------------------------------------------
+            ctx.registerCommand(BlockquoteCommands.TOGGLE, {
+                execute(engine) {
+                    const block = getBlockAtCursor(engine);
+                    if (isBlockType(engine, 'blockquote')) {
+                        // Already a blockquote — revert to plain text
+                        engine.dispatch([
+                            { type: 'set_block_type', blockId: block.id, blockType: 'text' },
+                        ]);
+                    }
+                    else {
+                        // Set to blockquote
+                        setBlockType(engine, block.id, 'blockquote');
+                    }
+                },
+                canExecute(_engine) {
+                    return true;
+                },
+                isActive(engine) {
+                    return isBlockType(engine, 'blockquote');
+                },
+            });
+            // ---------------------------------------------------------------
+            // Input rule: > followed by space at block start
+            // ---------------------------------------------------------------
+            ctx.registerInputRule({
+                pattern: /^> $/,
+                exclusive: true,
+                handler(engine, match, blockId) {
+                    const blockStart = getBlockStartOffset(engine.state.doc, blockId);
+                    const prefixLength = match[0].length;
+                    engine.dispatch([
+                        { type: 'delete_text', offset: blockStart, count: prefixLength },
+                        { type: 'set_block_type', blockId, blockType: 'blockquote' },
+                    ]);
+                },
+            });
+        },
+    };
+}
+//# sourceMappingURL=blockquote-plugin.js.map

package/dist/plugins/blockquote-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockquote-plugin.js","sourceRoot":"","sources":["../../src/plugins/blockquote-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEpG;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,MAAM,EAAE,kBAAkB;CAClB,CAAC;AAEX;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,EAAE,EAAE,kBAAkB;QACtB,IAAI,CAAC,GAAG;YACN,kEAAkE;YAClE,0BAA0B;YAC1B,kEAAkE;YAElE,GAAG,CAAC,iBAAiB,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;YAExC,kEAAkE;YAClE,2BAA2B;YAC3B,kEAAkE;YAElE,GAAG,CAAC,eAAe,CAAC,kBAAkB,CAAC,MAAM,EAAE;gBAC7C,OAAO,CAAC,MAAqB;oBAC3B,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;oBAEvC,IAAI,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC;wBACtC,8CAA8C;wBAC9C,MAAM,CAAC,QAAQ,CAAC;4BACd,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE;yBACjE,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,oBAAoB;wBACpB,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;oBAC/C,CAAC;gBACH,CAAC;gBAED,UAAU,CAAC,OAAsB;oBAC/B,OAAO,IAAI,CAAC;gBACd,CAAC;gBAED,QAAQ,CAAC,MAAqB;oBAC5B,OAAO,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBAC3C,CAAC;aACF,CAAC,CAAC;YAEH,kEAAkE;YAClE,iDAAiD;YACjD,kEAAkE;YAElE,GAAG,CAAC,iBAAiB,CAAC;gBACpB,OAAO,EAAE,MAAM;gBACf,SAAS,EAAE,IAAI;gBACf,OAAO,CAAC,MAAqB,EAAE,KAAuB,EAAE,OAAe;oBACrE,MAAM,UAAU,GAAG,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;oBAClE,MAAM,YAAY,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC,MAAM,CAAC;oBAEtC,MAAM,CAAC,QAAQ,CAAC;wBACd,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE;wBAChE,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE;qBAC7D,CAAC,CAAC;gBACL,CAAC;aACF,CAAC,CAAC;QACL,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/bold-plugin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bold mark plugin — registers the `bold` mark type, `toggleMark:bold` command,
+ * and Cmd/Ctrl+B keyboard shortcut.
+ *
+ * @module
+ */
+import type { Plugin } from '@rtif-sdk/engine';
+/**
+ * Command name constants for the bold plugin.
+ *
+ * @example
+ * ```ts
+ * engine.exec(BoldCommands.TOGGLE);
+ * ```
+ */
+export declare const BoldCommands: {
+    readonly TOGGLE: "toggleMark:bold";
+};
+/**
+ * Create the bold mark plugin.
+ *
+ * Registers:
+ * - Mark type: `bold` (value must be `true`)
+ * - Command: `toggleMark:bold`
+ * - Shortcut: Cmd/Ctrl+B
+ *
+ * @returns A plugin instance ready for `engine.use()`
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine(initialDoc);
+ * engine.use(boldPlugin());
+ * engine.exec(BoldCommands.TOGGLE);
+ * ```
+ */
+export declare function boldPlugin(): Plugin;
+//# sourceMappingURL=bold-plugin.d.ts.map

package/dist/plugins/bold-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bold-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/bold-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG/C;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;CAEf,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,IAAI,MAAM,CAanC"}

package/dist/plugins/bold-plugin.js

@@ -0,0 +1,48 @@
+/**
+ * Bold mark plugin — registers the `bold` mark type, `toggleMark:bold` command,
+ * and Cmd/Ctrl+B keyboard shortcut.
+ *
+ * @module
+ */
+import { createToggleMarkCommand } from './mark-utils.js';
+/**
+ * Command name constants for the bold plugin.
+ *
+ * @example
+ * ```ts
+ * engine.exec(BoldCommands.TOGGLE);
+ * ```
+ */
+export const BoldCommands = {
+    TOGGLE: 'toggleMark:bold',
+};
+/**
+ * Create the bold mark plugin.
+ *
+ * Registers:
+ * - Mark type: `bold` (value must be `true`)
+ * - Command: `toggleMark:bold`
+ * - Shortcut: Cmd/Ctrl+B
+ *
+ * @returns A plugin instance ready for `engine.use()`
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine(initialDoc);
+ * engine.use(boldPlugin());
+ * engine.exec(BoldCommands.TOGGLE);
+ * ```
+ */
+export function boldPlugin() {
+    return {
+        id: 'mark-bold',
+        init(ctx) {
+            ctx.registerMarkType('bold', {
+                validate: (value) => value === true,
+            });
+            ctx.registerCommand(BoldCommands.TOGGLE, createToggleMarkCommand('bold'));
+            ctx.registerShortcut({ key: 'b', mod: true }, BoldCommands.TOGGLE);
+        },
+    };
+}
+//# sourceMappingURL=bold-plugin.js.map

package/dist/plugins/bold-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bold-plugin.js","sourceRoot":"","sources":["../../src/plugins/bold-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,MAAM,EAAE,iBAAiB;CACjB,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO;QACL,EAAE,EAAE,WAAW;QACf,IAAI,CAAC,GAAG;YACN,GAAG,CAAC,gBAAgB,CAAC,MAAM,EAAE;gBAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI;aACpC,CAAC,CAAC;YAEH,GAAG,CAAC,eAAe,CAAC,YAAY,CAAC,MAAM,EAAE,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC;YAE1E,GAAG,CAAC,gBAAgB,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;QACrE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/plugins/callout-plugin.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Callout block type plugin — registers the `callout` block type with 5 variants
+ * (info, warning, error, success, note), three commands (`insertCallout`,
+ * `setCalloutVariant`, `toggleCallout`), and an input rule for `> !` at block start.
+ *
+ * Callouts are blocks with a colored border, icon, and editable content area.
+ * The variant determines the visual treatment (color, icon) applied by the
+ * block renderer in the web layer.
+ *
+ * @module
+ */
+import type { Plugin } from '@rtif-sdk/engine';
+/**
+ * Command name constants for the callout plugin.
+ *
+ * @example
+ * ```ts
+ * engine.exec(CalloutCommands.INSERT, { variant: 'warning' });
+ * engine.exec(CalloutCommands.SET_VARIANT, { variant: 'error' });
+ * engine.exec(CalloutCommands.TOGGLE);
+ * ```
+ */
+export declare const CalloutCommands: {
+    readonly INSERT: "insertCallout";
+    readonly SET_VARIANT: "setCalloutVariant";
+    readonly TOGGLE: "toggleCallout";
+};
+/**
+ * The five supported callout visual variants.
+ *
+ * Each variant maps to a distinct border color and icon in the block renderer:
+ * - `info` — blue, informational
+ * - `warning` — yellow/amber, caution
+ * - `error` — red, danger or critical
+ * - `success` — green, positive confirmation
+ * - `note` — gray/purple, neutral annotation
+ *
+ * @example
+ * ```ts
+ * const variant: CalloutVariant = 'warning';
+ * ```
+ */
+export type CalloutVariant = 'info' | 'warning' | 'error' | 'success' | 'note';
+/**
+ * Payload for the `insertCallout` command.
+ *
+ * @example
+ * ```ts
+ * engine.exec('insertCallout', { variant: 'warning' });
+ * ```
+ */
+export interface InsertCalloutPayload {
+    /** Callout variant. Defaults to `'info'` when omitted. */
+    readonly variant?: CalloutVariant;
+}
+/**
+ * Payload for the `setCalloutVariant` command.
+ *
+ * @example
+ * ```ts
+ * engine.exec('setCalloutVariant', { variant: 'error' });
+ * ```
+ */
+export interface SetCalloutVariantPayload {
+    /** The variant to apply to the current callout block. */
+    readonly variant: CalloutVariant;
+}
+/**
+ * Create the callout block type plugin.
+ *
+ * Registers:
+ * - Block type: `callout` (attrs must have `variant` as one of 5 valid values)
+ * - Command: `insertCallout` — convert the block at cursor to a callout with
+ *   an optional variant payload (defaults to `'info'`)
+ * - Command: `setCalloutVariant` — change the variant attr on the current
+ *   callout block (only executable when cursor is in a callout)
+ * - Command: `toggleCallout` — toggle between callout (info variant) and
+ *   plain text
+ * - Input rule: `> !` at the start of a block converts to a callout with
+ *   `'info'` variant
+ *
+ * @returns A plugin instance ready for `engine.use()`
+ *
+ * @example
+ * ```ts
+ * const engine = createEngine(initialDoc);
+ * engine.use(calloutPlugin());
+ *
+ * // Convert block at cursor to a warning callout
+ * engine.exec(CalloutCommands.INSERT, { variant: 'warning' });
+ *
+ * // Change variant of the current callout
+ * engine.exec(CalloutCommands.SET_VARIANT, { variant: 'error' });
+ *
+ * // Toggle callout on/off (uses 'info' variant when toggling on)
+ * engine.exec(CalloutCommands.TOGGLE);
+ * ```
+ */
+export declare function calloutPlugin(): Plugin;
+//# sourceMappingURL=callout-plugin.d.ts.map

package/dist/plugins/callout-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callout-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/callout-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,kBAAkB,CAAC;AAG9D;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;CACnC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AA2BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAsItC"}