@domternal/core 0.3.0 → 0.4.1

package/dist/EventEmitter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Callback type for event handlers
+ * - Events with payload: (data: T) => void
+ * - Events without payload (undefined): () => void
+ */
+type EventCallback<T> = T extends undefined ? () => void : (data: T) => void;
+/**
+ * Generic, type-safe event emitter
+ *
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   update: { value: number };
+ *   destroy: undefined;
+ * }
+ *
+ * const emitter = new EventEmitter<MyEvents>();
+ * emitter.on('update', ({ value }) => console.log(value));
+ * emitter.on('destroy', () => console.log('destroyed'));
+ * ```
+ */
+export declare class EventEmitter<Events extends {
+    [K in keyof Events]: unknown;
+} = Record<string, never>> {
+    protected callbacks: Map<keyof Events, Set<(data: unknown) => void>>;
+    /**
+     * Register an event listener
+     */
+    on<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
+    /**
+     * Remove an event listener, or all listeners for an event if no callback specified
+     */
+    off<E extends keyof Events>(event: E, callback?: EventCallback<Events[E]>): this;
+    /**
+     * Emit an event to all registered listeners
+     * Uses .call(this) to preserve context for callbacks
+     */
+    emit<E extends keyof Events>(event: E, ...args: Events[E] extends undefined ? [] : [Events[E]]): this;
+    /**
+     * Register an event listener that fires only once
+     */
+    once<E extends keyof Events>(event: E, callback: EventCallback<Events[E]>): this;
+    /**
+     * Remove all listeners for a specific event, or all events if no event specified
+     */
+    removeAllListeners(event?: keyof Events): this;
+    /**
+     * Get the number of listeners for a specific event
+     */
+    listenerCount(event: keyof Events): number;
+    /**
+     * Get all event names that have listeners
+     */
+    eventNames(): (keyof Events)[];
+}
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../src/EventEmitter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AAE7E;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAY,CAAC,MAAM,SAAS;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,OAAO;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAE/F,SAAS,CAAC,SAAS,2CAnBmD,IAAI,GAmBC;IAE3E;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAY9E;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAqBhF;;;OAGG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EACzB,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtD,IAAI;IAgBP;;OAEG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAchF;;OAEG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI;IAU9C;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,MAAM;IAI1C;;OAEG;IACH,UAAU,IAAI,CAAC,MAAM,MAAM,CAAC,EAAE;CAG/B"}

package/dist/EventEmitter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EventEmitter.test.d.ts.map

package/dist/EventEmitter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.test.d.ts","sourceRoot":"","sources":["../src/EventEmitter.test.ts"],"names":[],"mappings":""}

package/dist/Extension.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Extension - Base class for all extensions
+ *
+ * Extensions provide functionality without contributing to the schema.
+ * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const History = Extension.create({
+ *   name: 'history',
+ *   addOptions() {
+ *     return { depth: 100 };
+ *   },
+ *   addKeyboardShortcuts() {
+ *     return {
+ *       'Mod-z': () => this.editor.commands.undo(),
+ *       'Mod-Shift-z': () => this.editor.commands.redo(),
+ *     };
+ *   },
+ * });
+ */
+import type { ExtensionConfig, ExtensionConfigBase, ExtensionContext } from './types/ExtensionConfig.js';
+import type { SingleCommands } from './types/Commands.js';
+import type { EditorState } from '@domternal/pm/state';
+import type { EditorView } from '@domternal/pm/view';
+/**
+ * Merges extension config with parent binding support.
+ *
+ * For each function in `extendedConfig` that overrides a function in `parentConfig`,
+ * wraps the override so that `this.parent` temporarily points to the parent's version.
+ * This enables the `this.parent?.()` pattern in extend():
+ *
+ * ```typescript
+ * Paragraph.extend({
+ *   addAttributes() {
+ *     return { ...this.parent?.(), align: { default: 'left' } };
+ *   },
+ * });
+ * ```
+ */
+export declare function mergeConfigWithParentBinding(parentConfig: object, extendedConfig: object): object;
+/**
+ * Editor interface for Extension
+ * Forward declaration to avoid circular dependency
+ */
+export interface ExtensionEditorInterface {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
+}
+/**
+ * Base class for all extensions
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+export declare class Extension<Options = unknown, Storage = unknown> {
+    /**
+     * Extension type identifier
+     * Used to distinguish between Extension, Node, and Mark
+     * Subclasses override this to 'node' or 'mark'
+     */
+    readonly type: 'extension' | 'node' | 'mark';
+    /**
+     * Unique extension name
+     */
+    readonly name: string;
+    /**
+     * Extension options (immutable after creation)
+     */
+    readonly options: Options;
+    /**
+     * Extension storage (mutable state)
+     * Accessible via editor.storage[extensionName]
+     */
+    storage: Storage;
+    /**
+     * The original configuration object
+     */
+    readonly config: ExtensionConfig<Options, Storage>;
+    /**
+     * Editor instance (set by ExtensionManager after creation)
+     * null until ExtensionManager binds it
+     */
+    editor: ExtensionEditorInterface | null;
+    /**
+     * Reference to the parent config method when using extend().
+     * Set temporarily during config method execution so overridden
+     * methods can call `this.parent?.()` to invoke the original.
+     */
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Protected constructor - use Extension.create() instead
+     */
+    protected constructor(config: ExtensionConfig<Options, Storage>);
+    /**
+     * Creates a new extension instance
+     *
+     * @param config - Extension configuration
+     * @returns New extension instance
+     *
+     * @example
+     * const MyExtension = Extension.create({
+     *   name: 'myExtension',
+     *   addOptions() {
+     *     return { enabled: true };
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    /**
+     * Creates a new extension with merged options
+     * Original extension is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New extension instance with merged options
+     *
+     * @example
+     * const configured = MyExtension.configure({ enabled: false });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { nested: { a: 1, b: 2 } }
+     * // configure({ nested: { b: 3 } })
+     * // Result: { nested: { b: 3 } } — 'a' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ nested: { ...original.options.nested, b: 3 } })
+     */
+    configure(options: Partial<Options>): Extension<Options, Storage>;
+    /**
+     * Creates a new extension with extended configuration
+     * Original extension is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+     * replaced entirely, not combined with the base extension's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New extension instance with extended config
+     *
+     * @example
+     * const Extended = MyExtension.extend({
+     *   name: 'extendedExtension',
+     *   addCommands() {
+     *     return { customCommand: () => ({ tr }) => true };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base extension's commands while adding new ones:
+     * const Extended = BaseExtension.extend({
+     *   addCommands() {
+     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+     *     return {
+     *       ...baseCommands,
+     *       newCommand: () => ({ tr }) => true,
+     *     };
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}
+//# sourceMappingURL=Extension.d.ts.map

package/dist/Extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extension.d.ts","sourceRoot":"","sources":["../src/Extension.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,MAAM,EACpB,cAAc,EAAE,MAAM,GACrB,MAAM,CAsBR;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED;;;;;GAKG;AACH,qBAAa,SAAS,CAAC,OAAO,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO;IACzD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,CAAe;IAE3D;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEnD;;;OAGG;IACH,MAAM,EAAE,wBAAwB,GAAG,IAAI,CAAQ;IAE/C;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,CAAC;IAEvD;;OAEG;IACH,SAAS,aAAa,MAAM,EAAE,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC;IAuB/D;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACpC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC;IAIlB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAcjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,eAAe,GAAG,OAAO,EAAE,eAAe,GAAG,OAAO,EACzD,cAAc,EAAE,OAAO,CAAC,mBAAmB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GAC5E,QAAQ,CAAC,gBAAgB,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC,GAC7D,SAAS,CAAC,eAAe,EAAE,eAAe,CAAC;CAK/C"}

package/dist/Extension.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Extension.test.d.ts.map

package/dist/Extension.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Extension.test.d.ts","sourceRoot":"","sources":["../src/Extension.test.ts"],"names":[],"mappings":""}

package/dist/ExtensionManager.d.ts

@@ -0,0 +1,283 @@
+/**
+ * ExtensionManager - Manages extensions and schema
+ *
+ * Handles:
+ * - Extension lifecycle (flatten, resolve, bind)
+ * - Schema building from Node/Mark extensions
+ * - Plugin collection from all extensions
+ * - Extension storage management
+ * - Conflict detection (AD-7)
+ */
+import { Schema } from '@domternal/pm/model';
+import type { Plugin, Transaction } from '@domternal/pm/state';
+import type { NodeViewConstructor } from '@domternal/pm/view';
+import type { AnyExtension } from './types/EditorOptions.js';
+import type { CommandMap } from './types/Commands.js';
+import type { ToolbarItem } from './types/Toolbar.js';
+/**
+ * Error event props for safeCall
+ */
+interface ErrorEventProps {
+    error: Error;
+    context: string;
+}
+/**
+ * Editor interface for ExtensionManager
+ * Forward declaration to avoid circular dependency
+ */
+export interface ExtensionManagerEditor {
+    readonly schema: Schema;
+    emit?(event: 'error', props: ErrorEventProps): void;
+}
+/**
+ * Context attached to node view constructors for framework wrappers.
+ * Accessible via `(constructor as any).__domternalContext`.
+ */
+export interface NodeViewContext {
+    editor: ExtensionManagerEditor;
+    extension: {
+        name: string;
+        options: Record<string, unknown>;
+    };
+}
+/**
+ * Options for ExtensionManager constructor
+ */
+export interface ExtensionManagerOptions {
+    /**
+     * Extensions to process
+     * If provided, schema is built from extensions
+     */
+    extensions?: AnyExtension[] | undefined;
+    /**
+     * Direct schema (backward compatibility with Step 1.3)
+     * If provided, extensions are ignored for schema building
+     */
+    schema?: Schema | undefined;
+}
+export declare class ExtensionManager {
+    /**
+     * Processed extensions (flattened, sorted by priority)
+     */
+    private readonly _extensions;
+    /**
+     * ProseMirror schema (built from extensions or passed directly)
+     */
+    private readonly _schema;
+    /**
+     * Reference to the editor instance
+     */
+    readonly editor: ExtensionManagerEditor;
+    /**
+     * Extension storage (keyed by extension name)
+     */
+    private readonly _storage;
+    /**
+     * Whether the manager has been destroyed
+     */
+    private isDestroyed;
+    /**
+     * Cached plugins (built lazily)
+     */
+    private _plugins;
+    /**
+     * Cached commands (collected lazily)
+     */
+    private _commands;
+    /**
+     * Cached toolbar items (collected lazily)
+     */
+    private _toolbarItems;
+    /**
+     * Cached node views (collected lazily)
+     */
+    private _nodeViews;
+    /**
+     * Creates a new ExtensionManager
+     *
+     * @param options - Extensions or direct schema
+     * @param editor - Editor instance
+     */
+    constructor(options: ExtensionManagerOptions, editor: ExtensionManagerEditor);
+    /**
+     * Gets the processed extensions array
+     */
+    get extensions(): readonly AnyExtension[];
+    /**
+     * Gets the ProseMirror schema
+     */
+    get schema(): Schema;
+    /**
+     * Gets extension storage (accessed via editor.storage)
+     */
+    get storage(): Record<string, unknown>;
+    /**
+     * Gets plugins from all extensions
+     * Cached after first call
+     */
+    get plugins(): Plugin[];
+    /**
+     * Gets commands from all extensions
+     */
+    get commands(): CommandMap;
+    /**
+     * Gets toolbar items from all extensions
+     * Cached after first call
+     */
+    get toolbarItems(): ToolbarItem[];
+    /**
+     * Gets node views from all Node extensions that define addNodeView
+     */
+    get nodeViews(): Record<string, NodeViewConstructor>;
+    /**
+     * Clears all caches (plugins, commands)
+     * Call when extensions change dynamically
+     */
+    clearAllCaches(): void;
+    /**
+     * Recursively flattens extensions by expanding addExtensions()
+     * This allows extension bundles like StarterKit to work
+     */
+    private flattenExtensions;
+    /**
+     * Removes duplicate extensions by name, keeping the last occurrence.
+     * This allows parent extensions to auto-include children via addExtensions()
+     * while letting users override with explicitly configured versions.
+     */
+    private deduplicateExtensions;
+    /**
+     * Sorts extensions by priority (higher priority first)
+     * Default priority is 100
+     */
+    private resolveExtensions;
+    /**
+     * Detects duplicate extension names (AD-7: Schema Conflict Detection)
+     * @throws Error if duplicate names found
+     */
+    private detectConflicts;
+    /**
+     * Validates that all extension dependencies are present
+     * @throws Error if required dependency is missing
+     */
+    private checkDependencies;
+    /**
+     * Sets editor reference on all extensions
+     */
+    private bindEditorToExtensions;
+    /**
+     * Collects global attributes from all extensions.
+     * Returns a map of type name -> attribute specs to merge.
+     */
+    private collectGlobalAttributes;
+    /**
+     * Applies global attributes to a node or mark spec.
+     * Merges extra attrs into spec.attrs, wraps parseDOM getAttrs to parse
+     * global attributes from DOM elements, and wraps toDOM to inject rendered
+     * global HTML attributes into the output.
+     */
+    private applyGlobalAttributes;
+    /**
+     * Builds ProseMirror Schema from Node and Mark extensions
+     */
+    private buildSchema;
+    /**
+     * Initializes storage for all extensions
+     */
+    private initializeStorage;
+    /**
+     * Builds all ProseMirror plugins from extensions
+     */
+    private buildPlugins;
+    /**
+     * Collects keyboard shortcuts from all extensions
+     * Returns ProseMirror-compatible commands for keymap plugin
+     *
+     * Note: Extensions should return PM-compatible commands from addKeyboardShortcuts()
+     */
+    private collectKeyboardShortcuts;
+    /**
+     * Collects input rules from all extensions
+     */
+    private collectInputRules;
+    /**
+     * Collects commands from all extensions
+     *
+     * Note: Commands with the same name will be overwritten by later extensions
+     * (lower priority extensions override higher priority). This is intentional
+     * to allow customization of built-in commands.
+     */
+    private collectCommands;
+    /**
+     * Collects toolbar items from all extensions
+     */
+    private collectToolbarItems;
+    /**
+     * Collects node views from all Node extensions.
+     * Returns a map of node name to NodeViewConstructor for EditorView.
+     *
+     * Each constructor is annotated with `__domternalContext` containing
+     * the editor and extension metadata so framework wrappers (React, Vue)
+     * can access them without changing the ProseMirror calling convention.
+     */
+    private collectNodeViews;
+    /**
+     * Validates that the schema has required nodes
+     * @throws Error if schema is missing 'doc' or 'text' nodes
+     */
+    validateSchema(): void;
+    /**
+     * Cleans up the extension manager
+     * Calls onDestroy on all extensions and clears all caches
+     */
+    destroy(): void;
+    /**
+     * Safely executes a function, catching and reporting errors
+     * Prevents a single extension error from crashing the entire editor
+     *
+     * Handles both synchronous errors and async promise rejections.
+     *
+     * @param fn - Function to execute
+     * @param context - Context for error reporting (e.g., 'Bold.onUpdate')
+     * @returns The function result, or undefined if an error occurred
+     */
+    safeCall<T>(fn: () => T, context: string): T | undefined;
+    /**
+     * Calls onBeforeCreate on all extensions
+     */
+    callOnBeforeCreate(): void;
+    /**
+     * Calls onCreate on all extensions
+     */
+    callOnCreate(): void;
+    /**
+     * Calls onUpdate on all extensions
+     */
+    callOnUpdate(): void;
+    /**
+     * Calls onSelectionUpdate on all extensions
+     */
+    callOnSelectionUpdate(): void;
+    /**
+     * Calls onTransaction on all extensions
+     * @param props - Transaction props
+     */
+    callOnTransaction(props: {
+        transaction: Transaction;
+    }): void;
+    /**
+     * Calls onFocus on all extensions
+     * @param props - Focus event props
+     */
+    callOnFocus(props: {
+        event: FocusEvent;
+    }): void;
+    /**
+     * Calls onBlur on all extensions
+     * @param props - Blur event props
+     */
+    callOnBlur(props: {
+        event: FocusEvent;
+    }): void;
+}
+export {};
+//# sourceMappingURL=ExtensionManager.d.ts.map

package/dist/ExtensionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.d.ts","sourceRoot":"","sources":["../src/ExtensionManager.ts"],"names":[],"mappings":"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"}

package/dist/ExtensionManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExtensionManager.test.d.ts.map

package/dist/ExtensionManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionManager.test.d.ts","sourceRoot":"","sources":["../src/ExtensionManager.test.ts"],"names":[],"mappings":""}