@pixerate/editor 0.23.0 → 0.25.0

package/dist/{registry-D5-R90p0.d.ts → registry-DnzpgY27.d.cts}

@@ -1,42 +1,4 @@
-/**
- * JSON-Schema-lite: the subset of JSON Schema used by MCP tool `inputSchema`s,
- * plus a small validator for tool-call arguments. Unknown keywords are ignored.
- */
-type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
-interface JsonSchema {
-    type?: JsonSchemaType | readonly JsonSchemaType[];
-    description?: string;
-    title?: string;
-    enum?: readonly unknown[];
-    const?: unknown;
-    default?: unknown;
-    properties?: {
-        readonly [key: string]: JsonSchema;
-    };
-    required?: readonly string[];
-    additionalProperties?: boolean | JsonSchema;
-    items?: JsonSchema;
-    minItems?: number;
-    maxItems?: number;
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    [keyword: string]: unknown;
-}
-interface SchemaValidationError {
-    /** JSON-pointer-like path to the offending value, e.g. `/node/id` (`""` is the root). */
-    path: string;
-    message: string;
-}
-/**
- * Validates `value` against `schema` and returns every error found (an empty
- * array means valid). Supports `type` (incl. arrays of types), `enum`, `const`,
- * `properties`, `required`, `additionalProperties`, `items`, `minItems`,
- * `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength` and `pattern`.
- */
-declare function validateJsonSchema(value: unknown, schema: JsonSchema | undefined, path?: string): SchemaValidationError[];
+import { J as JsonSchema, S as SchemaValidationError } from './schema-DYDGdYL9.cjs';
 
 /**
  * MCP-shaped tool definition, as returned by `tools/list`.
@@ -206,4 +168,4 @@ declare class ToolRegistry {
 }
 declare function createToolRegistry(options?: ToolRegistryOptions): ToolRegistry;
 
-export { type AgentToolProvider as A, type JsonSchema as J, type McpListToolsResult as M, type SchemaValidationError as S, TOOL_NAMESPACE_SEPARATOR as T, type AgentTool as a, type AgentToolHandler as b, type JsonSchemaType as c, type McpToolContent as d, type McpToolDefinition as e, type McpToolResult as f, type ToolCallContext as g, type ToolCallError as h, type ToolErrorCode as i, ToolRegistry as j, ToolRegistryError as k, type ToolRegistryOptions as l, createToolRegistry as m, toToolResult as t, validateJsonSchema as v };
+export { type AgentToolProvider as A, type McpListToolsResult as M, TOOL_NAMESPACE_SEPARATOR as T, type AgentTool as a, type AgentToolHandler as b, type McpToolContent as c, type McpToolDefinition as d, type McpToolResult as e, type ToolCallContext as f, type ToolCallError as g, type ToolErrorCode as h, ToolRegistry as i, ToolRegistryError as j, type ToolRegistryOptions as k, createToolRegistry as l, toToolResult as t };

package/dist/registry-evKTP4ls.d.ts

@@ -0,0 +1,354 @@
+import { J as JsonSchema, S as SchemaValidationError } from './schema-DYDGdYL9.js';
+
+/**
+ * Keyboard chords in a platform-neutral notation.
+ *
+ * | token | macOS | Windows / Linux |
+ * |---|---|---|
+ * | `Mod` | ⌘ Command | Ctrl |
+ * | `Ctrl` | ⌃ Control | Ctrl (same key as `Mod`: conflicts are reported) |
+ * | `Meta` / `Cmd` | ⌘ Command | Win / Super |
+ * | `Alt` / `Option` | ⌥ Option | Alt |
+ * | `Shift` | ⇧ Shift | Shift |
+ *
+ * Keys are stored as `KeyboardEvent.code` values (`KeyZ`, `Digit1`, `BracketRight`,
+ * `PageDown`), so Option/Alt chords work on macOS (where Option changes `event.key`).
+ */
+type Platform = 'mac' | 'windows' | 'linux';
+declare const PLATFORMS: readonly Platform[];
+/** A parsed chord. `mod` is the platform's primary modifier. */
+interface Chord {
+    /** `KeyboardEvent.code` of the key, e.g. `KeyZ`. */
+    key: string;
+    mod?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+}
+/** The modifiers a chord needs on one platform (`mod` resolved to `meta` or `ctrl`). */
+interface EffectiveChord {
+    key: string;
+    ctrl: boolean;
+    meta: boolean;
+    alt: boolean;
+    shift: boolean;
+}
+/** The current platform from `navigator` (`linux` when unknown, e.g. in Node). */
+declare function detectPlatform(): Platform;
+/** `KeyboardEvent.code` for a key token (`Z`, `1`, `]`, `PageDown`, `F5`, `KeyZ`), or `null`. */
+declare function keyToCode(token: string): string | null;
+/** Neutral text for a code: `KeyZ` → `Z`, `BracketRight` → `]`, `ArrowUp` → `Up`. */
+declare function codeToKeyText(code: string): string;
+/**
+ * Parses chord text (`Mod+Shift+Z`, `Alt+]`, `⌥⇧⌘K`, `CmdOrCtrl+K`). Throws on unknown
+ * modifiers or keys. The last `+`-separated token is the key (`+` itself is `Plus`).
+ */
+declare function parseChord(text: string): Chord;
+/** Canonical platform-neutral text: `Mod+Ctrl+Meta+Alt+Shift+<key>`. */
+declare function chordToString(chord: Chord): string;
+/** Canonical spelling of chord text (`shift+cmdorctrl+z` → `Mod+Shift+Z`). Throws when invalid. */
+declare function normalizeChord(text: string): string;
+/** The modifiers a chord needs on `platform`: `Mod` is ⌘ (meta) on macOS and Ctrl elsewhere. */
+declare function effectiveChord(chord: string | Chord, platform: Platform): EffectiveChord;
+/** Identity of an effective chord, for conflict detection (`Ctrl+Shift+KeyZ`). */
+declare function effectiveChordKey(chord: string | Chord, platform: Platform): string;
+/**
+ * Display text: `⌥⇧⌘K` on macOS, `Ctrl+Alt+Shift+K` on Windows / Linux (`Meta` shows as
+ * `Win` / `Super`). Invalid text is returned unchanged.
+ */
+declare function formatShortcut(chord: string | Chord, platform?: Platform): string;
+/** Minimal keyboard event surface (DOM `KeyboardEvent` satisfies it). */
+interface KeyboardEventLike {
+    key?: string;
+    code?: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    target?: EventTarget | null | unknown;
+    defaultPrevented?: boolean;
+    preventDefault?: () => void;
+}
+/** `event.code`, or one derived from `event.key` for synthetic events without a code. */
+declare function eventCode(event: KeyboardEventLike): string;
+/**
+ * The key code a shortcut event is matched by: `event.code` (layout-independent, so
+ * Option/Alt chords work on macOS and punctuation chords follow the physical key),
+ * except that a letter key producing a different Latin letter without Alt (AZERTY,
+ * QWERTZ, Dvorak) uses the produced letter, as browsers and operating systems do.
+ */
+declare function shortcutCode(event: KeyboardEventLike): string;
+/** The code a printable `event.key` names on a US layout (`z` → `KeyZ`, `]` → `BracketRight`). */
+declare function codeFromKey(key: string): string | null;
+/**
+ * Whether a keyboard event comes from a text-entry element: `<input>`, `<textarea>`,
+ * `<select>`, a `contenteditable` element (or a descendant) or a ProseMirror editor.
+ * Falls back to `document.activeElement` when the event has no element target.
+ */
+declare function isEditableEventTarget(event: {
+    target?: unknown;
+}): boolean;
+
+/** One key binding: a chord that runs `command`, optionally only in one scope / on some platforms. */
+interface ShortcutBinding {
+    command: string;
+    /** Chord text (`Mod+Shift+Z`) or a parsed chord. */
+    chord: string | Chord;
+    /** Scope (e.g. `canvas`, `spreadsheet`); scoped bindings win over global ones. Omit for global. */
+    scope?: string;
+    /** Platforms the binding exists on (default: all). E.g. `Mod+Y` redo only off macOS. */
+    platforms?: readonly Platform[];
+    /** Also fire while focus is in an input, textarea or contenteditable (default `false`). */
+    allowInEditable?: boolean;
+}
+/** Shortcut declaration on a command: chord text, or an object for platform / scope specifics. */
+type ShortcutInput = string | Omit<ShortcutBinding, 'command'> | ReadonlyArray<string | Omit<ShortcutBinding, 'command'>>;
+/** Expands a command's `shortcut` declaration into bindings. */
+declare function toShortcutBindings(command: string, input: ShortcutInput | undefined, scope?: string): ShortcutBinding[];
+interface ShortcutConflict {
+    /** Scope shared by the bindings (`undefined` = global). */
+    scope?: string;
+    /** Effective chord, e.g. `Ctrl+KeyZ`. */
+    chord: string;
+    /** Commands bound to it (two or more). */
+    commands: string[];
+}
+interface ShortcutMatch {
+    command: string;
+    binding: ShortcutBinding;
+}
+interface ShortcutResolveOptions {
+    /** Active scopes, most specific first. Bindings in these scopes win over global ones. */
+    scopes?: string | readonly string[];
+    /** Resolve even when the event comes from a text input (default: per binding). */
+    allowInEditable?: boolean;
+    /** Override the map's platform. */
+    platform?: Platform;
+}
+interface ShortcutMapOptions {
+    /** Platform used to resolve `Mod` (default: detected from `navigator` on every resolve). */
+    platform?: Platform;
+    /**
+     * `platform` (default): `Mod` means ⌘ on macOS and Ctrl elsewhere, exactly.
+     * `either`: `Mod` (and `Ctrl` / `Meta`) match ⌘ or Ctrl on every platform.
+     */
+    modifierMode?: 'platform' | 'either';
+}
+/**
+ * Keyboard shortcuts as data: default bindings plus user overrides, resolved from
+ * `KeyboardEvent`s by `event.code` (so Option/Alt chords work on macOS), with scopes
+ * (scoped bindings win), conflict detection per platform and display formatting.
+ */
+declare class ShortcutMap {
+    private defaults;
+    private overrides;
+    private readonly listeners;
+    private readonly options;
+    constructor(bindings?: readonly ShortcutBinding[], options?: ShortcutMapOptions);
+    get platform(): Platform;
+    private entry;
+    private changed;
+    /** Subscribes to binding changes. Returns an unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Adds default bindings (throws on invalid chord text). Returns a function removing them. */
+    bind(bindings: ShortcutBinding | readonly ShortcutBinding[]): () => void;
+    /**
+     * User override for a command: replaces all of its default bindings with `chords`
+     * (an empty list unbinds it). Throws on invalid chord text.
+     */
+    setOverride(command: string, chords: string | Chord | ReadonlyArray<string | Chord | Omit<ShortcutBinding, 'command'>>): void;
+    /** Removes a user override (the defaults apply again). */
+    clearOverride(command: string): void;
+    /** User overrides as plain data (`{ command: ['Mod+K'] }`), e.g. to persist them. */
+    getOverrides(): Record<string, string[]>;
+    /** Restores overrides saved with `getOverrides` (replacing the current ones). */
+    setOverrides(overrides: Record<string, readonly string[]>): void;
+    private active;
+    /** Effective bindings on `platform` (defaults without overridden commands, plus overrides). */
+    bindings(platform?: Platform): ShortcutBinding[];
+    /** Canonical chord text bound to `command` on `platform` (first = primary). */
+    forCommand(command: string, platform?: Platform): string[];
+    /**
+     * The command a keydown event runs, or `null`. Events from text inputs are ignored
+     * unless the binding (or `options`) allows them. Bindings in the active scopes
+     * (in order) win over global bindings; bindings in other scopes never match.
+     * Keys are matched by `event.code`, except that a letter key producing another Latin
+     * letter (AZERTY, QWERTZ, Dvorak) matches that letter when Alt is not held, so
+     * `Mod+Z` follows the Z label (see `shortcutCode`).
+     */
+    resolve(event: KeyboardEventLike, options?: ShortcutResolveOptions): ShortcutMatch | null;
+    private matches;
+    /**
+     * Groups of bindings that share an effective chord in one scope on `platform`
+     * (e.g. `Mod+Y` and `Ctrl+Y` collide off macOS). A scoped binding shadowing a
+     * global one is not a conflict.
+     */
+    findConflicts(platform?: Platform): ShortcutConflict[];
+    /** Conflicts on every platform, keyed by platform (only platforms with conflicts). */
+    findAllConflicts(): Partial<Record<Platform, ShortcutConflict[]>>;
+}
+
+/** Object JSON Schema describing a command's parameters. */
+type CommandParamsSchema = JsonSchema & {
+    type: 'object';
+};
+/**
+ * Metadata and implementation of one command. Menus, shortcuts, the palette and agent
+ * tools all run commands by id, so every entry point shares enablement and validation.
+ */
+interface CommandSpec<TContext = any, TParams = any, TResult = unknown> {
+    /** Unique id, e.g. `history.undo` or `canvas.alignLeft`. */
+    id: string;
+    label: string;
+    /** Group / menu name shown next to the label, e.g. `Edit` or `Arrange`. */
+    group?: string;
+    /** Extra search terms for the palette. */
+    keywords?: readonly string[];
+    description?: string;
+    /** Object JSON Schema for `params`. Unknown keys are rejected unless `additionalProperties` allows them. */
+    params?: CommandParamsSchema;
+    /** Default shortcut(s): platform-neutral chord text such as `Mod+Shift+Z`. */
+    shortcut?: ShortcutInput;
+    /** Scope the command (and its shortcuts) belong to, e.g. `canvas`. Omit for global commands. */
+    scope?: string;
+    /**
+     * Whether the command can run: `true` (or `undefined`), `false`, or a reason string
+     * ("Nothing to undo"). Receives the params a caller named, so a command acting on the
+     * selection can still run on targets passed explicitly (`params` is `undefined` for menus).
+     */
+    enabled?: (context: TContext, params: TParams | undefined) => boolean | string | undefined;
+    run: (context: TContext, params: TParams) => TResult;
+    /**
+     * Runs inside the registry's `history.batch(label, …)`, so all history entries the
+     * command records become one undo step and a throw rolls back its partial changes.
+     */
+    undoable?: boolean;
+    /** The command only reads state (agent tools mark it read-only). */
+    readOnly?: boolean;
+    /** Hide from the palette and `list()` unless `includeHidden` (still runnable by id). */
+    hidden?: boolean;
+}
+type CommandErrorCode = 'unknown_command' | 'disabled' | 'invalid_params' | 'failed';
+type CommandResult<T = unknown> = {
+    ok: true;
+    id: string;
+    result: T;
+} | {
+    ok: false;
+    id: string;
+    code: CommandErrorCode;
+    message: string;
+    details?: SchemaValidationError[];
+};
+/** A command as listed for menus, palettes and agents. */
+interface CommandEntry {
+    id: string;
+    label: string;
+    group?: string;
+    keywords?: readonly string[];
+    description?: string;
+    params?: CommandParamsSchema;
+    scope?: string;
+    /** Canonical chord text bound on the registry's platform (first = primary). */
+    shortcuts: string[];
+    enabled: boolean;
+    /** Why the command is disabled (only when `enabled` is false). */
+    disabledReason?: string;
+    undoable: boolean;
+    readOnly: boolean;
+}
+interface CommandListOptions<TContext = any> {
+    /** Only global commands plus commands of these scopes. */
+    scope?: string | readonly string[];
+    enabledOnly?: boolean;
+    includeHidden?: boolean;
+    /** Context for the enablement check (default: the registry's context). */
+    context?: TContext;
+}
+/** Minimal history surface (`HistoryManager` satisfies it). */
+interface CommandHistoryTarget {
+    batch(name: string, fn: () => void): void;
+}
+interface CommandRegistryOptions<TContext = any> {
+    /** Default context passed to `enabled` / `run` (a value or a getter). */
+    context?: TContext | (() => TContext);
+    /** Wraps `undoable` commands in one history step (see `CommandSpec.undoable`). */
+    history?: CommandHistoryTarget;
+    /** Options for the registry's `ShortcutMap`. */
+    shortcuts?: ShortcutMapOptions;
+}
+declare class CommandRegistryError extends Error {
+    readonly code: 'duplicate_command' | 'invalid_command';
+    constructor(code: CommandRegistryError['code'], message: string);
+}
+/**
+ * Registry of commands: one id per action, shared by shortcuts (`shortcuts`), the
+ * command palette (`list` + `rankCommands`) and agent tools (`createCommandToolProvider`).
+ */
+declare class CommandRegistry<TContext = any> {
+    /** Shortcut bindings of the registered commands (plus any user overrides). */
+    readonly shortcuts: ShortcutMap;
+    private readonly commands;
+    private readonly listeners;
+    private readonly options;
+    private version;
+    private muted;
+    constructor(options?: CommandRegistryOptions<TContext>);
+    /** Monotonic counter bumped on every change (useful as a snapshot key). */
+    getVersion(): number;
+    /** The default context. */
+    get context(): TContext;
+    /**
+     * Registers a command (or several) and returns a function that unregisters it.
+     * Throws a `CommandRegistryError` for a duplicate or invalid id, or invalid chord text.
+     */
+    register(spec: CommandSpec<TContext> | readonly CommandSpec<TContext>[]): () => void;
+    /** Removes a command by id. Returns whether it was registered. */
+    unregister(id: string): boolean;
+    private unbindQuietly;
+    has(id: string): boolean;
+    get(id: string): CommandSpec<TContext> | undefined;
+    /** Registered ids in registration order. */
+    ids(): string[];
+    /** Whether `id` can run now (`{ enabled, reason }`); `params` are the targets a caller named. */
+    isEnabled(id: string, params?: unknown, context?: TContext): {
+        enabled: boolean;
+        reason?: string;
+    };
+    /** Commands for menus, palettes and agents, with their current enablement. */
+    list(options?: CommandListOptions<TContext>): CommandEntry[];
+    private check;
+    private invoke;
+    /**
+     * Runs a command synchronously and returns a structured result; never throws.
+     * A command whose `run` returns a promise yields `{ ok: true, result: promise }`
+     * (use `executeAsync` to await it and catch its rejection).
+     */
+    execute<T = unknown>(id: string, params?: unknown, context?: TContext): CommandResult<T>;
+    /** Like `execute`, but awaits async commands (rejections become `failed` results). */
+    executeAsync<T = unknown>(id: string, params?: unknown, context?: TContext): Promise<CommandResult<T>>;
+    /**
+     * Resolves a keydown event to a command (see `ShortcutMap.resolve`) and runs it when
+     * enabled, calling `preventDefault()`. Disabled commands leave the event alone, so the
+     * browser or a focused editor can still handle it. Returns the result, or `null`.
+     */
+    handleKeyDown(event: KeyboardEventLike, options?: ShortcutResolveOptions & {
+        context?: TContext;
+    }): CommandResult | null;
+    /** Display-ready primary shortcut of a command (`⇧⌘Z` / `Ctrl+Shift+Z`), or `undefined`. */
+    shortcutFor(id: string, platform?: Platform): string | undefined;
+    /**
+     * Subscribes to changes: commands registered or removed, shortcut overrides, executed
+     * commands and `invalidate()` calls (e.g. when enablement inputs change).
+     */
+    subscribe(listener: () => void): () => void;
+    /** Tells subscribers that enablement may have changed (e.g. the selection changed). */
+    invalidate(): void;
+    private notify;
+}
+declare function createCommandRegistry<TContext = any>(options?: CommandRegistryOptions<TContext>): CommandRegistry<TContext>;
+/** Identity helper that types a command spec. */
+declare function defineCommand<TContext = any, TParams = any, TResult = unknown>(spec: CommandSpec<TContext, TParams, TResult>): CommandSpec<TContext, TParams, TResult>;
+
+export { formatShortcut as A, isEditableEventTarget as B, CommandRegistry as C, keyToCode as D, type EffectiveChord as E, normalizeChord as F, parseChord as G, shortcutCode as H, toShortcutBindings as I, type KeyboardEventLike as K, type Platform as P, type ShortcutBinding as S, type CommandResult as a, type CommandEntry as b, type CommandSpec as c, type Chord as d, type CommandErrorCode as e, type CommandHistoryTarget as f, type CommandListOptions as g, type CommandParamsSchema as h, CommandRegistryError as i, type CommandRegistryOptions as j, PLATFORMS as k, type ShortcutConflict as l, type ShortcutInput as m, ShortcutMap as n, type ShortcutMapOptions as o, type ShortcutMatch as p, type ShortcutResolveOptions as q, chordToString as r, codeFromKey as s, codeToKeyText as t, createCommandRegistry as u, defineCommand as v, detectPlatform as w, effectiveChord as x, effectiveChordKey as y, eventCode as z };

package/dist/schema-DYDGdYL9.d.cts

@@ -0,0 +1,41 @@
+/**
+ * JSON-Schema-lite: the subset of JSON Schema used by MCP tool `inputSchema`s,
+ * plus a small validator for tool-call arguments. Unknown keywords are ignored.
+ */
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    type?: JsonSchemaType | readonly JsonSchemaType[];
+    description?: string;
+    title?: string;
+    enum?: readonly unknown[];
+    const?: unknown;
+    default?: unknown;
+    properties?: {
+        readonly [key: string]: JsonSchema;
+    };
+    required?: readonly string[];
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    [keyword: string]: unknown;
+}
+interface SchemaValidationError {
+    /** JSON-pointer-like path to the offending value, e.g. `/node/id` (`""` is the root). */
+    path: string;
+    message: string;
+}
+/**
+ * Validates `value` against `schema` and returns every error found (an empty
+ * array means valid). Supports `type` (incl. arrays of types), `enum`, `const`,
+ * `properties`, `required`, `additionalProperties`, `items`, `minItems`,
+ * `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength` and `pattern`.
+ */
+declare function validateJsonSchema(value: unknown, schema: JsonSchema | undefined, path?: string): SchemaValidationError[];
+
+export { type JsonSchema as J, type SchemaValidationError as S, type JsonSchemaType as a, validateJsonSchema as v };

package/dist/schema-DYDGdYL9.d.ts

@@ -0,0 +1,41 @@
+/**
+ * JSON-Schema-lite: the subset of JSON Schema used by MCP tool `inputSchema`s,
+ * plus a small validator for tool-call arguments. Unknown keywords are ignored.
+ */
+type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+interface JsonSchema {
+    type?: JsonSchemaType | readonly JsonSchemaType[];
+    description?: string;
+    title?: string;
+    enum?: readonly unknown[];
+    const?: unknown;
+    default?: unknown;
+    properties?: {
+        readonly [key: string]: JsonSchema;
+    };
+    required?: readonly string[];
+    additionalProperties?: boolean | JsonSchema;
+    items?: JsonSchema;
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    [keyword: string]: unknown;
+}
+interface SchemaValidationError {
+    /** JSON-pointer-like path to the offending value, e.g. `/node/id` (`""` is the root). */
+    path: string;
+    message: string;
+}
+/**
+ * Validates `value` against `schema` and returns every error found (an empty
+ * array means valid). Supports `type` (incl. arrays of types), `enum`, `const`,
+ * `properties`, `required`, `additionalProperties`, `items`, `minItems`,
+ * `maxItems`, `minimum`, `maximum`, `minLength`, `maxLength` and `pattern`.
+ */
+declare function validateJsonSchema(value: unknown, schema: JsonSchema | undefined, path?: string): SchemaValidationError[];
+
+export { type JsonSchema as J, type SchemaValidationError as S, type JsonSchemaType as a, validateJsonSchema as v };

package/dist/serializers/index.cjs

@@ -9,7 +9,7 @@
 
 
 
-var _chunkCL37JGFWcjs = require('../chunk-CL37JGFW.cjs');
+var _chunkV3CHHWOEcjs = require('../chunk-V3CHHWOE.cjs');
 
 
 
@@ -26,12 +26,14 @@ var _chunkCL37JGFWcjs = require('../chunk-CL37JGFW.cjs');
 
 
 
+var _chunk7WISYZFOcjs = require('../chunk-7WISYZFO.cjs');
 
-var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
 
 
 
 
+var _chunkBVP3TSLHcjs = require('../chunk-BVP3TSLH.cjs');
+require('../chunk-X4N4WUKB.cjs');
 
 
 
@@ -54,5 +56,12 @@ var _chunkAA4ZEVCCcjs = require('../chunk-AA4ZEVCC.cjs');
 
 
 
-exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunkAA4ZEVCCcjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkAA4ZEVCCcjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkCL37JGFWcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunkAA4ZEVCCcjs.escapeHtml; exports.extractMentions = _chunkAA4ZEVCCcjs.extractMentions; exports.extractMentionsFromDoc = _chunkAA4ZEVCCcjs.extractMentionsFromDoc; exports.getClipboardData = _chunkCL37JGFWcjs.getClipboardData; exports.getEditorMarkdown = _chunkAA4ZEVCCcjs.getEditorMarkdown; exports.getEditorText = _chunkAA4ZEVCCcjs.getEditorText; exports.getSchemaSignature = _chunkCL37JGFWcjs.getSchemaSignature; exports.htmlToPlainText = _chunkAA4ZEVCCcjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunkAA4ZEVCCcjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunkAA4ZEVCCcjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkCL37JGFWcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkCL37JGFWcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunkAA4ZEVCCcjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunkAA4ZEVCCcjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunkAA4ZEVCCcjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunkAA4ZEVCCcjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkCL37JGFWcjs.readRichClipboard; exports.rtfToPlainText = _chunkCL37JGFWcjs.rtfToPlainText; exports.sanitizeHtml = _chunkAA4ZEVCCcjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkCL37JGFWcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkCL37JGFWcjs.serializeRichClipboardPayload; exports.stripMarkdownCode = _chunkAA4ZEVCCcjs.stripMarkdownCode;
+
+
+
+
+
+
+
+exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunk7WISYZFOcjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkBVP3TSLHcjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkV3CHHWOEcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunk7WISYZFOcjs.escapeHtml; exports.extractMentions = _chunk7WISYZFOcjs.extractMentions; exports.extractMentionsFromDoc = _chunk7WISYZFOcjs.extractMentionsFromDoc; exports.findTextMentions = _chunkBVP3TSLHcjs.findTextMentions; exports.formatMentionText = _chunkBVP3TSLHcjs.formatMentionText; exports.getClipboardData = _chunkV3CHHWOEcjs.getClipboardData; exports.getEditorMarkdown = _chunk7WISYZFOcjs.getEditorMarkdown; exports.getEditorText = _chunk7WISYZFOcjs.getEditorText; exports.getSchemaSignature = _chunkV3CHHWOEcjs.getSchemaSignature; exports.htmlToPlainText = _chunk7WISYZFOcjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunk7WISYZFOcjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunk7WISYZFOcjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkV3CHHWOEcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkV3CHHWOEcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunk7WISYZFOcjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunk7WISYZFOcjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunk7WISYZFOcjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunk7WISYZFOcjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkV3CHHWOEcjs.readRichClipboard; exports.rtfToPlainText = _chunkV3CHHWOEcjs.rtfToPlainText; exports.sanitizeHtml = _chunk7WISYZFOcjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkV3CHHWOEcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkV3CHHWOEcjs.serializeRichClipboardPayload; exports.setMentionRoleInText = _chunkBVP3TSLHcjs.setMentionRoleInText; exports.stripMarkdownCode = _chunk7WISYZFOcjs.stripMarkdownCode;
 //# sourceMappingURL=index.cjs.map

package/dist/serializers/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,gsDAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,u4DAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}

package/dist/serializers/index.d.cts

@@ -1,9 +1,12 @@
 import { Schema, Slice } from '@tiptap/pm/model';
-import { t as TrackedChangesView, h as MentionEntity } from '../track-changes-BSF58RK0.cjs';
+import { r as TrackedChangesView, d as MentionEntity } from '../track-changes-D_VAPELi.cjs';
+import { a as MentionRoleSyntax } from '../mention-text-CDnCFd3c.cjs';
+export { M as MENTION_REGEX, T as TextMention, f as findTextMentions, b as formatMentionText, s as setMentionRoleInText } from '../mention-text-CDnCFd3c.cjs';
 import '@tiptap/core';
 import '@tiptap/extension-mention';
 import '@tiptap/suggestion';
 import '@tiptap/pm/state';
+import '../comment-store-BEMgVlAA.cjs';
 
 interface PlainTextOptions {
     /**
@@ -44,6 +47,8 @@ interface ExtractedMention {
     id: string;
     label: string;
     type?: string;
+    /** Asset role (`data-role`), when set. */
+    role?: string;
     avatarUrl?: string;
     color?: string;
     [key: string]: any;
@@ -54,14 +59,6 @@ interface ExtractedMention {
  */
 declare function extractMentionsFromDoc(docOrEditor: any): ExtractedMention[];
 
-/**
- * Canonical regex pattern for matching @mentions in plain text or markdown.
- * Supports:
- * - Standard unquoted handles: @username, @user.name, @team_alpha, @sa-1
- * - Quoted handles: @"John Doe", "Jane Doe"
- * Unquoted handles exclude trailing punctuation (e.g. @violet. matches "violet" without the dot).
- */
-declare const MENTION_REGEX: RegExp;
 /**
  * Split regex identifying markdown code blocks, inline code, URLs, and existing HTML tags.
  * Used by preprocessMarkdownMentions to ensure non-mention regions remain completely untouched.
@@ -71,6 +68,19 @@ interface MentionSegment {
     type: "text" | "mention";
     value: string;
     handle?: string;
+    /** Role written after the handle (`@fox:style`), when role syntax is enabled. */
+    role?: string;
+}
+/** A mention with its role (asset mentions: `@fox:style`, or `data-role` on a mention node). */
+interface MentionDetail {
+    handle: string;
+    role?: string;
+}
+interface ExtractMentionsOptions {
+    /** Return `{ handle, role }` objects instead of handles. */
+    details?: boolean;
+    /** Read `@handle:role` suffixes in text (see {@link MentionRoleSyntax}). Mention nodes' `data-role` is always read in `details` mode. */
+    roles?: MentionRoleSyntax;
 }
 interface PreprocessMarkdownMentionsOptions {
     /**
@@ -86,6 +96,11 @@ interface PreprocessMarkdownMentionsOptions {
      * Custom resolver callback to derive entity metadata for unmatched handles.
      */
     resolveMention?: (handle: string) => Partial<MentionEntity> | null | undefined;
+    /**
+     * Read `@handle:role` and emit the role as `data-role` (the `:role` text is
+     * consumed). Off by default. See {@link MentionRoleSyntax}.
+     */
+    roles?: MentionRoleSyntax;
 }
 /**
  * Strips code blocks and inline code from markdown or HTML content:
@@ -98,13 +113,26 @@ declare function stripMarkdownCode(content: string): string;
 /**
  * Extracts unique mention handles from a text, markdown, or HTML string,
  * ignoring trailing punctuation, code blocks, URLs, and pre-existing HTML mention attributes.
+ *
+ * With `{ details: true }` it returns `{ handle, role }` objects, unique per
+ * handle and role: roles come from mention nodes' `data-role` and, when
+ * `roles` is set, from `@handle:role` text. Without options the result is
+ * unchanged.
  */
-declare function extractMentions(content: string): string[];
+declare function extractMentions(content: string, options?: ExtractMentionsOptions & {
+    details?: false;
+}): string[];
+declare function extractMentions(content: string, options: ExtractMentionsOptions & {
+    details: true;
+}): MentionDetail[];
+declare function extractMentions(content: string, options?: ExtractMentionsOptions): string[] | MentionDetail[];
 /**
  * Segments a text string into plain text parts and mention tokens.
  * Correctly leaves trailing punctuation (like ".") as part of the following text segment.
  */
-declare function parseMentionSegments(content: string): MentionSegment[];
+declare function parseMentionSegments(content: string, options?: {
+    roles?: MentionRoleSyntax;
+}): MentionSegment[];
 /**
  * Preprocesses markdown text by turning raw @mention handles into TipTap-compatible
  * mention HTML spans (<span class="pixerate-mention-node" data-type="mention" ...>),
@@ -257,4 +285,4 @@ declare function getClipboardData(event: unknown): ClipboardDataLike | null;
  */
 declare function readRichClipboard(event: unknown, schema: Schema, mimeType?: string): Slice | null;
 
-export { type ClipboardDataLike, type ExtractedMention, MARKDOWN_MENTION_SPLIT_REGEX, MENTION_REGEX, type MarkdownToHtmlOptions, type MentionSegment, PIXERATE_DOCUMENT_MIME, type PlainTextOptions, type PreprocessMarkdownMentionsOptions, type RichClipboardPayload, type SanitizeHtmlOptions, escapeHtml, extractMentions, extractMentionsFromDoc, getClipboardData, getEditorMarkdown, getEditorText, getSchemaSignature, htmlToPlainText, markdownToTipTapHtml, parseMentionSegments, parseRichClipboardPayload, plainTextToParagraphHtml, plainTextToSlice, plainTextToTipTapHtml, preprocessMarkdownFileLinks, preprocessMarkdownMentions, readRichClipboard, rtfToPlainText, sanitizeHtml, sanitizeImportedHtml, serializeRichClipboardPayload, stripMarkdownCode };
+export { type ClipboardDataLike, type ExtractMentionsOptions, type ExtractedMention, MARKDOWN_MENTION_SPLIT_REGEX, type MarkdownToHtmlOptions, type MentionDetail, MentionRoleSyntax, type MentionSegment, PIXERATE_DOCUMENT_MIME, type PlainTextOptions, type PreprocessMarkdownMentionsOptions, type RichClipboardPayload, type SanitizeHtmlOptions, escapeHtml, extractMentions, extractMentionsFromDoc, getClipboardData, getEditorMarkdown, getEditorText, getSchemaSignature, htmlToPlainText, markdownToTipTapHtml, parseMentionSegments, parseRichClipboardPayload, plainTextToParagraphHtml, plainTextToSlice, plainTextToTipTapHtml, preprocessMarkdownFileLinks, preprocessMarkdownMentions, readRichClipboard, rtfToPlainText, sanitizeHtml, sanitizeImportedHtml, serializeRichClipboardPayload, stripMarkdownCode };