@zeke-02/docx-editor-core 0.1.0

package/dist/types/document.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Comprehensive TypeScript types for full DOCX document representation
+ *
+ * This barrel file re-exports all types from the split modules.
+ * Existing imports from './types/document' continue to work unchanged.
+ *
+ * Module structure:
+ * - colors.ts      — Color primitives, borders, shading
+ * - formatting.ts  — Text, paragraph, and table formatting properties
+ * - lists.ts       — Numbering and list definitions
+ * - content.ts     — Content model (runs, images, shapes, tables, paragraphs, sections)
+ * - styles.ts      — Styles, theme, fonts, relationships, media
+ * @packageDocumentation
+ * @public
+ */
+export { B as BorderSpec, C as ColorValue, S as ShadingProperties, T as ThemeColorSlot } from '../colors-C3vA7HUU.js';
+export { C as CellMargins, g as ConditionalFormatStyle, E as EmphasisMark, F as FloatingTableProperties, L as LineSpacingRule, d as ParagraphAlignment, P as ParagraphFormatting, h as TabLeader, e as TabStop, i as TabStopAlignment, j as TableBorders, c as TableCellFormatting, a as TableFormatting, f as TableLook, k as TableMeasurement, b as TableRowFormatting, l as TableWidthType, m as TextEffect, T as TextFormatting, U as UnderlineStyle } from '../formatting-_OXU8gLB.js';
+import { c as DocumentBody, N as NumberingDefinitions, F as Footnote, E as Endnote, u as HeaderFooter } from '../content-CmqAwdFL.js';
+export { A as AbstractNumbering, B as BlockContent, v as BlockSdt, w as BookmarkEnd, x as BookmarkStart, t as BreakContent, y as Column, C as Comment, a as CommentRangeEnd, b as CommentRangeStart, z as ComplexField, D as Deletion, G as DrawingContent, J as EndnotePosition, K as EndnoteProperties, O as Field, Q as FieldCharContent, U as FieldType, V as FooterReference, W as FootnotePosition, X as FootnoteProperties, Y as HeaderFooterType, Z as HeaderReference, H as Hyperlink, I as Image, _ as ImageCrop, $ as ImagePadding, a0 as ImagePosition, a1 as ImageSize, a2 as ImageTransform, a3 as ImageWrap, a4 as InlineSdt, d as Insertion, a5 as InstrTextContent, a6 as LevelSuffix, a7 as LineNumberRestart, L as ListLevel, a8 as ListRendering, a9 as MathEquation, M as MoveFrom, aa as MoveFromRangeEnd, ab as MoveFromRangeStart, e as MoveTo, ac as MoveToRangeEnd, ad as MoveToRangeStart, ae as NoBreakHyphenContent, af as NoteNumberRestart, ag as NoteReferenceContent, o as NumberFormat, ah as NumberingInstance, ai as PageOrientation, P as Paragraph, f as ParagraphContent, p as ParagraphPropertyChange, aj as PropertyChangeInfo, R as Run, g as RunContent, ak as RunPropertyChange, al as SdtProperties, am as SdtType, an as Section, S as SectionProperties, ao as SectionStart, ap as Shape, aq as ShapeContent, ar as ShapeFill, as as ShapeOutline, at as ShapeTextBody, au as ShapeType, av as SimpleField, aw as SoftHyphenContent, ax as SymbolContent, ay as TabContent, T as Table, h as TableCell, r as TableCellPropertyChange, q as TablePropertyChange, i as TableRow, s as TableRowPropertyChange, az as TableStructuralChangeInfo, aA as TextBox, j as TextContent, k as TrackedChangeInfo, l as TrackedRunChange, aB as VerticalAlign } from '../content-CmqAwdFL.js';
+import { a as StyleDefinitions, T as Theme, F as FontTable, b as RelationshipMap, M as MediaFile } from '../styles-BBv7doYK.js';
+export { D as DocDefaults, c as FontInfo, R as Relationship, d as RelationshipType, S as Style, e as StyleType, f as ThemeColorScheme, g as ThemeFont, h as ThemeFontScheme } from '../styles-BBv7doYK.js';
+import '../docx/wrapTypes.js';
+
+/**
+ * settings.xml parser
+ *
+ * Extracts document-wide settings the layout pipeline needs at render time.
+ * We only read what's currently consumed; most of settings.xml (compatibility
+ * flags, view state, autoformat) is irrelevant to layout.
+ */
+/** Document-wide settings parsed from `word/settings.xml`. */
+interface DocumentSettings {
+    /**
+     * `w:defaultTabStop` (§17.6.13) — interval in twips between default tab
+     * stops applied when a paragraph has no custom `w:tabs`. Word's default
+     * if unspecified is 720 twips (0.5 inch).
+     */
+    defaultTabStop: number;
+}
+
+/**
+ * Comprehensive TypeScript types for full DOCX document representation
+ *
+ * This barrel file re-exports all types from the split modules.
+ * Existing imports from './types/document' continue to work unchanged.
+ *
+ * Module structure:
+ * - colors.ts      — Color primitives, borders, shading
+ * - formatting.ts  — Text, paragraph, and table formatting properties
+ * - lists.ts       — Numbering and list definitions
+ * - content.ts     — Content model (runs, images, shapes, tables, paragraphs, sections)
+ * - styles.ts      — Styles, theme, fonts, relationships, media
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * Complete DOCX package structure
+ */
+interface DocxPackage {
+    /** Document body */
+    document: DocumentBody;
+    /** Style definitions */
+    styles?: StyleDefinitions;
+    /** Theme */
+    theme?: Theme;
+    /** Numbering definitions */
+    numbering?: NumberingDefinitions;
+    /** Document-wide settings from `word/settings.xml` */
+    settings?: DocumentSettings;
+    /** Font table */
+    fontTable?: FontTable;
+    /** Footnotes */
+    footnotes?: Footnote[];
+    /** Endnotes */
+    endnotes?: Endnote[];
+    /** Headers by relationship ID */
+    headers?: Map<string, HeaderFooter>;
+    /** Footers by relationship ID */
+    footers?: Map<string, HeaderFooter>;
+    /** Document relationships */
+    relationships?: RelationshipMap;
+    /** Media files */
+    media?: Map<string, MediaFile>;
+    /** Document properties */
+    properties?: {
+        title?: string;
+        subject?: string;
+        creator?: string;
+        keywords?: string;
+        description?: string;
+        lastModifiedBy?: string;
+        revision?: number;
+        created?: Date;
+        modified?: Date;
+    };
+}
+/**
+ * Top-level parsed DOCX document — the result of `parseDocx(buffer)`.
+ *
+ * Wraps the unzipped DOCX package (`document.xml`, `styles.xml`, etc.),
+ * the original buffer for round-trip saves, and any template variables /
+ * parse warnings detected during ingestion.
+ *
+ * @example
+ * ```ts
+ * import { parseDocx } from '@zeke-02/docx-editor-core/headless';
+ * const doc = await parseDocx(buffer);
+ * console.log(doc.package.document.content.length);
+ * ```
+ */
+interface Document {
+    /** Parsed DOCX package — body, styles, numbering, theme, media, headers/footers. */
+    package: DocxPackage;
+    /** Original DOCX buffer. Kept for round-trip saves that preserve untouched parts. */
+    originalBuffer?: ArrayBuffer;
+    /** Detected docxtemplater variables (e.g. `{name}`, `{address}`). Populated when the document is recognized as a template. */
+    templateVariables?: string[];
+    /** Non-fatal parser diagnostics — malformed parts, unsupported features, fallbacks. */
+    warnings?: string[];
+}
+
+export { type Document, DocumentBody, type DocumentSettings, type DocxPackage, Endnote, FontTable, Footnote, HeaderFooter, MediaFile, NumberingDefinitions, RelationshipMap, StyleDefinitions, Theme };

package/dist/types/document.js

@@ -0,0 +1 @@
+'use strict';

package/dist/types-DXG7vqe9.d.ts

@@ -0,0 +1,311 @@
+import { Document } from './types/document.js';
+import { Position, Range, AgentCommand } from './types/agentApi.js';
+
+/**
+ * Core Plugin System Types
+ *
+ * Defines the interfaces for headless plugins that work in Node.js
+ * without React/DOM dependencies. These plugins extend DocumentAgent
+ * with additional commands and expose MCP tools for AI integration.
+ */
+
+/**
+ * Core plugin interface - headless, works in Node.js
+ *
+ * Plugins can:
+ * - Register command handlers that DocumentAgent dispatches to
+ * - Declare MCP tools that the MCP server exposes to AI clients
+ * - Have optional initialization logic
+ * - Declare dependencies on other plugins
+ */
+interface CorePlugin {
+    /** Unique plugin identifier */
+    id: string;
+    /** Human-readable plugin name */
+    name: string;
+    /** Plugin version (semver) */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /**
+     * Command handlers this plugin provides.
+     * DocumentAgent dispatches commands to these handlers.
+     *
+     * @example
+     * ```ts
+     * commandHandlers: {
+     *   'insertTemplateVariable': (doc, cmd) => {
+     *     // Transform document
+     *     return modifiedDoc;
+     *   },
+     * }
+     * ```
+     */
+    commandHandlers?: Record<string, CommandHandler>;
+    /**
+     * MCP tools this plugin exposes.
+     * MCP server collects these from all plugins.
+     */
+    mcpTools?: McpToolDefinition[];
+    /**
+     * Optional setup when plugin is registered.
+     * Called once during plugin registration.
+     */
+    initialize?: () => void | Promise<void>;
+    /**
+     * Optional cleanup when plugin is unregistered.
+     */
+    destroy?: () => void | Promise<void>;
+    /**
+     * Dependencies on other plugins (by ID).
+     * The registry ensures dependencies are loaded first.
+     */
+    dependencies?: string[];
+}
+/**
+ * Command handler function type
+ *
+ * Receives a document and a command, returns a modified document.
+ * Must be pure/immutable - always return a new document.
+ */
+type CommandHandler = (doc: Document, command: PluginCommand) => Document;
+/**
+ * Extended command type for plugins
+ *
+ * Plugins can define custom command types beyond the built-in AgentCommand types.
+ */
+interface PluginCommand {
+    /** Command type identifier */
+    type: string;
+    /** Unique command ID (for undo tracking) */
+    id?: string;
+    /** Position for positional commands */
+    position?: Position;
+    /** Range for range-based commands */
+    range?: Range;
+    /** Additional command-specific data */
+    [key: string]: unknown;
+}
+/**
+ * Result of command execution
+ */
+interface CommandResult {
+    /** The modified document */
+    document: Document;
+    /** Whether the command succeeded */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Metadata about the operation */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * MCP tool definition
+ *
+ * Describes a tool that can be called by AI clients through the MCP server.
+ */
+interface McpToolDefinition {
+    /** Tool name (used in MCP protocol) */
+    name: string;
+    /** Human-readable description for AI */
+    description: string;
+    /**
+     * JSON Schema for tool input validation.
+     * Can be a Zod schema or plain JSON Schema object.
+     */
+    inputSchema: JsonSchema | ZodSchemaLike;
+    /**
+     * Handler function for the tool.
+     * Receives validated input and returns a result.
+     */
+    handler: McpToolHandler;
+    /**
+     * Optional annotations for the tool
+     */
+    annotations?: McpToolAnnotations;
+}
+/**
+ * MCP tool handler function
+ */
+type McpToolHandler = (input: unknown, context: McpToolContext) => Promise<McpToolResult> | McpToolResult;
+/**
+ * Context passed to MCP tool handlers
+ */
+interface McpToolContext {
+    /** Current document (if loaded) */
+    document?: Document;
+    /** Document buffer (if loaded) */
+    documentBuffer?: ArrayBuffer;
+    /** Session state */
+    session: McpSession;
+    /** Logger for debugging */
+    log: (message: string, data?: unknown) => void;
+}
+/**
+ * MCP session state
+ *
+ * Maintains state across tool calls within a session.
+ */
+interface McpSession {
+    /** Session ID */
+    id: string;
+    /** Loaded documents by ID */
+    documents: Map<string, LoadedDocument>;
+    /** Custom session data */
+    data: Map<string, unknown>;
+}
+/**
+ * A loaded document in the session
+ */
+interface LoadedDocument {
+    /** Document ID */
+    id: string;
+    /** Parsed document */
+    document: Document;
+    /** Original buffer (for repacking) */
+    buffer?: ArrayBuffer;
+    /** Source filename or path */
+    source?: string;
+    /** Last modified timestamp */
+    lastModified: number;
+}
+/**
+ * MCP tool result
+ */
+interface McpToolResult {
+    /** Result content */
+    content: McpToolContent[];
+    /** Whether this is an error result */
+    isError?: boolean;
+}
+/**
+ * MCP tool content types
+ */
+type McpToolContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    uri: string;
+    mimeType?: string;
+    text?: string;
+};
+/**
+ * MCP tool annotations
+ */
+interface McpToolAnnotations {
+    /** Tool category for organization */
+    category?: string;
+    /** Whether this tool modifies the document */
+    readOnly?: boolean;
+    /** Estimated cost/complexity */
+    complexity?: 'low' | 'medium' | 'high';
+    /** Example usage */
+    examples?: McpToolExample[];
+}
+/**
+ * MCP tool example
+ */
+interface McpToolExample {
+    /** Example description */
+    description: string;
+    /** Example input */
+    input: unknown;
+    /** Expected output description */
+    output?: string;
+}
+/**
+ * JSON Schema definition (subset)
+ */
+interface JsonSchema {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: string[];
+    description?: string;
+    enum?: unknown[];
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    additionalProperties?: boolean | JsonSchema;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    $ref?: string;
+}
+/**
+ * Zod-like schema interface for compatibility
+ */
+interface ZodSchemaLike {
+    _def?: unknown;
+    parse?: (data: unknown) => unknown;
+    safeParse?: (data: unknown) => {
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    };
+}
+/**
+ * Check if a schema is Zod-like
+ */
+declare function isZodSchema(schema: unknown): schema is ZodSchemaLike;
+/**
+ * Plugin lifecycle events
+ */
+type PluginEvent = {
+    type: 'registered';
+    plugin: CorePlugin;
+} | {
+    type: 'unregistered';
+    pluginId: string;
+} | {
+    type: 'error';
+    pluginId: string;
+    error: Error;
+};
+/**
+ * Plugin event listener
+ */
+type PluginEventListener = (event: PluginEvent) => void;
+/**
+ * Extract command type from a union
+ */
+type ExtractCommand<T extends AgentCommand, Type extends string> = T extends {
+    type: Type;
+} ? T : never;
+/**
+ * Create a typed command handler
+ */
+type TypedCommandHandler<T extends PluginCommand> = (doc: Document, command: T) => Document;
+/**
+ * Plugin configuration options
+ */
+interface PluginOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom configuration */
+    config?: Record<string, unknown>;
+}
+/**
+ * Result of plugin registration
+ */
+interface PluginRegistrationResult {
+    /** Whether registration succeeded */
+    success: boolean;
+    /** Registered plugin (if successful) */
+    plugin?: CorePlugin;
+    /** Error message (if failed) */
+    error?: string;
+    /** Warning messages */
+    warnings?: string[];
+}
+
+export { type CommandHandler as C, type ExtractCommand as E, type JsonSchema as J, type LoadedDocument as L, type McpSession as M, type PluginCommand as P, type TypedCommandHandler as T, type ZodSchemaLike as Z, type CommandResult as a, type CorePlugin as b, type McpToolAnnotations as c, type McpToolContent as d, type McpToolContext as e, type McpToolDefinition as f, type McpToolHandler as g, type McpToolResult as h, type PluginEvent as i, type PluginEventListener as j, type PluginOptions as k, type PluginRegistrationResult as l, isZodSchema as m, type McpToolExample as n };

package/dist/types-RchZmPFN.d.mts

@@ -0,0 +1,137 @@
+import { Schema, NodeSpec, MarkSpec } from 'prosemirror-model';
+import { Plugin, Command } from 'prosemirror-state';
+
+/**
+ * Extension Manager
+ *
+ * Two-phase initialization:
+ * 1. buildSchema() — collects NodeSpecs/MarkSpecs from extensions → new Schema
+ * 2. initializeRuntime() — calls onSchemaReady() on each extension, collects plugins/commands/keymaps
+ */
+
+declare class ExtensionManager {
+    private extensions;
+    private schema;
+    private plugins;
+    private commands;
+    constructor(extensions: AnyExtension[]);
+    /**
+     * Phase 1: Build schema from node/mark extensions
+     */
+    buildSchema(): void;
+    /**
+     * Phase 2: Initialize runtime (plugins, commands, keymaps)
+     * Must be called after buildSchema()
+     */
+    initializeRuntime(): void;
+    /**
+     * Get the built schema
+     */
+    getSchema(): Schema;
+    /**
+     * Get all plugins (raw + keymap merged)
+     */
+    getPlugins(): Plugin[];
+    /**
+     * Get the flat command registry
+     */
+    getCommands(): CommandMap;
+    /**
+     * Get a specific command by name
+     */
+    getCommand(name: string): ((...args: any[]) => Command) | undefined;
+    /**
+     * Lifecycle: destroy
+     */
+    destroy(): void;
+}
+
+/**
+ * Extension System Type Definitions
+ *
+ * Tiptap-style extension architecture for ProseMirror.
+ * Three extension types:
+ * - Extension: plugins, commands, keymaps (no schema)
+ * - NodeExtension: adds a node spec to the schema
+ * - MarkExtension: adds a mark spec to the schema
+ */
+
+type ExtensionPriority = number;
+declare const Priority: {
+    readonly Highest: 0;
+    readonly High: 50;
+    readonly Default: 100;
+    readonly Low: 150;
+    readonly Lowest: 200;
+};
+interface ExtensionContext {
+    schema: Schema;
+    /**
+     * The manager that owns this extension. Use this in runtime callbacks
+     * (e.g. `handleKeyDown`) that need to dispatch commands, instead of
+     * reaching back to the `singletonManager` export — the latter forms a
+     * circular import that breaks when the package is consumed as a built
+     * bundle.
+     */
+    manager: ExtensionManager;
+}
+type CommandMap = Record<string, (...args: any[]) => Command>;
+type KeyboardShortcutMap = Record<string, Command>;
+interface ExtensionRuntime {
+    commands?: CommandMap;
+    keyboardShortcuts?: KeyboardShortcutMap;
+    plugins?: Plugin[];
+}
+interface ExtensionConfig {
+    name: string;
+    priority: ExtensionPriority;
+    options: Record<string, unknown>;
+}
+interface NodeExtensionConfig extends ExtensionConfig {
+    schemaNodeName: string;
+    nodeSpec: NodeSpec;
+}
+interface MarkExtensionConfig extends ExtensionConfig {
+    schemaMarkName: string;
+    markSpec: MarkSpec;
+}
+interface Extension {
+    type: 'extension';
+    config: ExtensionConfig;
+    onSchemaReady(ctx: ExtensionContext): ExtensionRuntime;
+}
+interface NodeExtension {
+    type: 'node';
+    config: NodeExtensionConfig;
+    onSchemaReady(ctx: ExtensionContext): ExtensionRuntime;
+}
+interface MarkExtension {
+    type: 'mark';
+    config: MarkExtensionConfig;
+    onSchemaReady(ctx: ExtensionContext): ExtensionRuntime;
+}
+type AnyExtension = Extension | NodeExtension | MarkExtension;
+interface ExtensionDefinition<TOptions = Record<string, unknown>> {
+    name: string;
+    priority?: ExtensionPriority;
+    defaultOptions?: TOptions;
+    onSchemaReady(ctx: ExtensionContext, options: TOptions): ExtensionRuntime;
+}
+interface NodeExtensionDefinition<TOptions = Record<string, unknown>> {
+    name: string;
+    priority?: ExtensionPriority;
+    defaultOptions?: TOptions;
+    schemaNodeName: string;
+    nodeSpec: NodeSpec | ((options: TOptions) => NodeSpec);
+    onSchemaReady?(ctx: ExtensionContext, options: TOptions): ExtensionRuntime;
+}
+interface MarkExtensionDefinition<TOptions = Record<string, unknown>> {
+    name: string;
+    priority?: ExtensionPriority;
+    defaultOptions?: TOptions;
+    schemaMarkName: string;
+    markSpec: MarkSpec | ((options: TOptions) => MarkSpec);
+    onSchemaReady?(ctx: ExtensionContext, options: TOptions): ExtensionRuntime;
+}
+
+export { type AnyExtension as A, type CommandMap as C, type Extension as E, type KeyboardShortcutMap as K, type MarkExtensionDefinition as M, type NodeExtension as N, Priority as P, ExtensionManager as a, type ExtensionDefinition as b, type MarkExtension as c, type NodeExtensionDefinition as d, type ExtensionConfig as e, type ExtensionContext as f, type ExtensionPriority as g, type ExtensionRuntime as h, type MarkExtensionConfig as i, type NodeExtensionConfig as j };