@betteroffice/docx 0.0.1 → 0.0.3

package/dist/types-dYdjUZMo.d.mts

@@ -1,311 +0,0 @@
-import { Document } from './types/document.mjs';
-import { Position, Range, AgentCommand } from './types/agentApi.mjs';
-
-/**
- * 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/units-O5Y02RKQ.d.mts

@@ -1,34 +0,0 @@
-/**
- * Pixels per inch at standard DPI
- *
- * @public
- */
-declare const PIXELS_PER_INCH = 96;
-/**
- * Convert EMUs to pixels (at 96 DPI)
- *
- * 1 inch = 914400 EMUs = 96 pixels
- * Returns 0 for null/undefined/NaN inputs.
- *
- * @public
- */
-declare function emuToPixels(emu: number | undefined | null): number;
-/**
- * Convert pixels to EMUs.
- * EMU coordinates in OOXML are integer-typed (xs:long); rounding here keeps
- * floating-point drift (e.g. 52 px → 495299.99999999994) out of the document.
- *
- * @public
- */
-declare function pixelsToEmu(px: number): number;
-/**
- * Convert points to pixels (at 96 DPI)
- *
- * 1 inch = 72 points = 96 pixels
- * → 1 point = 96/72 pixels = 4/3 pixels
- *
- * @public
- */
-declare function pointsToPixels(points: number): number;
-
-export { PIXELS_PER_INCH as P, pointsToPixels as a, emuToPixels as e, pixelsToEmu as p };

package/dist/utils/headingCollector.d.mts

@@ -1,28 +0,0 @@
-import { E as EditorTreeNode } from '../editorTree-DO5PyDK8.mjs';
-
-/**
- * @packageDocumentation
- * @public
- */
-
-/**
- * Information about a heading found in the document.
- */
-interface HeadingInfo {
-    /** The text content of the heading */
-    text: string;
-    /** Outline level (0 = Heading 1, 1 = Heading 2, etc.) */
-    level: number;
-    /** ProseMirror document position of the paragraph node */
-    pmPos: number;
-}
-/**
- * Collect all headings from a ProseMirror document.
- *
- * Detection logic:
- * 1. Check `outlineLevel` attr (set by OOXML parsing or style resolution)
- * 2. Fallback to `styleId` matching /^[Hh]eading(\d)$/
- */
-declare function collectHeadings(doc: EditorTreeNode): HeadingInfo[];
-
-export { type HeadingInfo, collectHeadings };

package/dist/utils/headingCollector.mjs

@@ -1 +0,0 @@
-export{a as collectHeadings}from'../chunk-TYHI7RAD.mjs';import'../chunk-TTRUPDAB.mjs';

package/dist/utils/highlightColors.d.mts

@@ -1,14 +0,0 @@
-/**
- * OOXML highlight color name <-> hex mapping. Used by both adapter
- * toolbars when serialising highlight selections to the
- * `w:highlight` attribute (which only accepts named colors).
- *
- * Lifted from packages/docx-react/src/components/toolbarUtils.ts so both
- * sides share the same canonical table.
- * @packageDocumentation
- * @public
- */
-declare const HIGHLIGHT_HEX_TO_NAME: Record<string, string>;
-declare function mapHexToHighlightName(hex: string): string | null;
-
-export { HIGHLIGHT_HEX_TO_NAME, mapHexToHighlightName };

package/dist/utils/highlightColors.mjs

@@ -1 +0,0 @@
-export{a as HIGHLIGHT_HEX_TO_NAME,b as mapHexToHighlightName}from'../chunk-YCIH2Q3E.mjs';import'../chunk-TTRUPDAB.mjs';

package/dist/utils/textSelection.d.mts

@@ -1,92 +0,0 @@
-/**
- * Text Selection Utilities
- *
- * Utilities for word-level and paragraph-level text selection.
- * Used for double-click (word) and triple-click (paragraph) selection.
- * @packageDocumentation
- * @public
- */
-/**
- * Check if a character is a word character
- */
-declare function isWordCharacter(char: string): boolean;
-/**
- * Check if a character is whitespace
- */
-declare function isWhitespace(char: string): boolean;
-/**
- * Find word boundaries around a position in text
- * Returns [startIndex, endIndex] inclusive start, exclusive end
- */
-declare function findWordBoundaries(text: string, position: number): [number, number];
-/**
- * Get the word at a position in text
- */
-declare function getWordAt(text: string, position: number): string;
-/**
- * Word selection result
- */
-interface WordSelectionResult {
-    /** The selected word */
-    word: string;
-    /** Start index in the text (inclusive) */
-    startIndex: number;
-    /** End index in the text (exclusive) */
-    endIndex: number;
-}
-/**
- * Find the word at a position and return detailed info
- */
-declare function findWordAt(text: string, position: number): WordSelectionResult;
-/**
- * Select a word at the current cursor position using the browser's native APIs.
- * This works reliably across different browsers and handles contentEditable well.
- */
-declare function selectWordAtCursor(): boolean;
-/**
- * Select a word in a specific text node at the given offset
- */
-declare function selectWordInTextNode(textNode: Text, offset: number): boolean;
-/**
- * Expand the current selection to word boundaries.
- * If there's a collapsed selection (cursor), selects the word at cursor.
- * If there's an existing selection, expands to include complete words.
- */
-declare function expandSelectionToWordBoundaries(): boolean;
-/**
- * Select the entire paragraph containing the current selection.
- * Looks for the nearest element with [data-paragraph-index] attribute.
- */
-declare function selectParagraphAtCursor(): boolean;
-/**
- * Handle click event for multi-click detection.
- * Call this in your click handler.
- * Returns the click count (1 = single, 2 = double, 3 = triple).
- */
-declare function handleClickForMultiClick(event: MouseEvent): number;
-/**
- * Create a double-click handler that selects words.
- * Returns a function that should be called on dblclick events.
- */
-declare function createDoubleClickWordSelector(): (event: MouseEvent) => void;
-/**
- * Create a triple-click handler that selects paragraphs.
- * This uses our custom click counting since browsers have inconsistent triple-click.
- */
-declare function createTripleClickParagraphSelector(): (event: MouseEvent) => void;
-declare const _default: {
-    isWordCharacter: typeof isWordCharacter;
-    isWhitespace: typeof isWhitespace;
-    findWordBoundaries: typeof findWordBoundaries;
-    getWordAt: typeof getWordAt;
-    findWordAt: typeof findWordAt;
-    selectWordAtCursor: typeof selectWordAtCursor;
-    selectWordInTextNode: typeof selectWordInTextNode;
-    expandSelectionToWordBoundaries: typeof expandSelectionToWordBoundaries;
-    selectParagraphAtCursor: typeof selectParagraphAtCursor;
-    handleClickForMultiClick: typeof handleClickForMultiClick;
-    createDoubleClickWordSelector: typeof createDoubleClickWordSelector;
-    createTripleClickParagraphSelector: typeof createTripleClickParagraphSelector;
-};
-
-export { type WordSelectionResult, createDoubleClickWordSelector, createTripleClickParagraphSelector, _default as default, expandSelectionToWordBoundaries, findWordAt, findWordBoundaries, getWordAt, handleClickForMultiClick, isWhitespace, isWordCharacter, selectParagraphAtCursor, selectWordAtCursor, selectWordInTextNode };

package/dist/utils/textSelection.mjs

@@ -1 +0,0 @@
-export{k as createDoubleClickWordSelector,l as createTripleClickParagraphSelector,m as default,h as expandSelectionToWordBoundaries,e as findWordAt,c as findWordBoundaries,d as getWordAt,j as handleClickForMultiClick,b as isWhitespace,a as isWordCharacter,i as selectParagraphAtCursor,f as selectWordAtCursor,g as selectWordInTextNode}from'../chunk-4RCISPPE.mjs';import'../chunk-TTRUPDAB.mjs';

package/dist/variableDetector-Borj29SF.d.mts

@@ -1,115 +0,0 @@
-import { Document } from './types/document.mjs';
-import { c as DocumentBody, P as Paragraph } from './content-sSHuWw49.mjs';
-
-/**
- * Variable Detector Utility
- *
- * Scans a DOCX document for template variables in the format {variable_name}
- * (standard docxtemplater syntax).
- * Returns a unique, sorted list of variable names found in the document.
- */
-
-/**
- * Result of variable detection
- */
-interface VariableDetectionResult {
-    /** Unique variable names sorted alphabetically */
-    variables: string[];
-    /** Total count of variable occurrences */
-    totalOccurrences: number;
-    /** Variables by location */
-    byLocation: {
-        body: string[];
-        headers: string[];
-        footers: string[];
-        footnotes: string[];
-        endnotes: string[];
-        textBoxes: string[];
-    };
-    /** Variable occurrences with positions */
-    occurrences: VariableOccurrence[];
-}
-/**
- * A single variable occurrence with location info
- */
-interface VariableOccurrence {
-    /** Variable name (without braces) */
-    name: string;
-    /** Location type */
-    location: 'body' | 'header' | 'footer' | 'footnote' | 'endnote' | 'textBox';
-    /** Paragraph index within location */
-    paragraphIndex?: number;
-    /** Section index (for headers/footers) */
-    sectionIndex?: number;
-}
-/**
- * Detect all template variables in a document
- *
- * @param doc - The parsed document
- * @returns Array of unique variable names sorted alphabetically
- */
-declare function detectVariables(doc: Document): string[];
-/**
- * Detect variables with detailed information
- *
- * @param doc - The parsed document
- * @returns Detailed detection result
- */
-declare function detectVariablesDetailed(doc: Document): VariableDetectionResult;
-/**
- * Detect variables in document body
- */
-declare function detectVariablesInBody(body: DocumentBody): string[];
-/**
- * Detect variables in a paragraph
- */
-declare function detectVariablesInParagraph(paragraph: Paragraph): string[];
-/**
- * Extract variable names from text
- *
- * @param text - The text to search
- * @returns Array of variable names (without braces)
- */
-declare function extractVariablesFromText(text: string): string[];
-/**
- * Check if text contains template variables
- */
-declare function hasTemplateVariables(text: string): boolean;
-/**
- * Check if a variable name is valid
- */
-declare function isValidVariableName(name: string): boolean;
-/**
- * Sanitize a variable name
- */
-declare function sanitizeVariableName(name: string): string;
-/**
- * Format a variable name with braces (standard docxtemplater syntax)
- */
-declare function formatVariable(name: string): string;
-/**
- * Parse a variable string to get the name
- */
-declare function parseVariable(variable: string): string | null;
-/**
- * Replace variables in text with values
- *
- * @param text - The text containing variables
- * @param values - Map of variable name to replacement value
- * @returns Text with variables replaced
- */
-declare function replaceVariables(text: string, values: Record<string, string>): string;
-/**
- * Replace all variables in text with a placeholder
- *
- * @param text - The text containing variables
- * @param placeholder - Placeholder to use (default: empty string)
- * @returns Text with variables replaced
- */
-declare function removeVariables(text: string, placeholder?: string): string;
-/**
- * Check if document has any template variables
- */
-declare function documentHasVariables(doc: Document): boolean;
-
-export { type VariableDetectionResult as V, type VariableOccurrence as a, detectVariablesDetailed as b, detectVariablesInBody as c, detectVariables as d, detectVariablesInParagraph as e, documentHasVariables as f, extractVariablesFromText as g, formatVariable as h, hasTemplateVariables as i, isValidVariableName as j, replaceVariables as k, parseVariable as p, removeVariables as r, sanitizeVariableName as s };

package/dist/wasm-FZQ5XB2Y.mjs

@@ -1 +0,0 @@
-import'./chunk-EUUIJVM6.mjs';export{b as createEditSession,a as preloadEditWasm}from'./chunk-NEWOMDTX.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/wasm-SA237OSP.mjs

@@ -1 +0,0 @@
-export{l as buildDisplayListJson,o as clearMeasureFonts,g as closeDisplayList,d as hasDisplayListSession,e as hasRangeRectsRegion,h as hitTestRegionsByHandle,b as hitTestRegionsJson,m as layoutDocumentJson,p as measureParagraphJson,f as openDisplayList,q as outlineGlyphJson,a as preloadLayoutWasm,i as rangeRectsByHandle,c as rangeRectsJson,k as rangeRectsRegionByHandle,j as rangeRectsRegionJson,n as registerMeasureFont}from'./chunk-CIRN3LZA.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/watermarkApi-DCxjutkg.d.mts

@@ -1,38 +0,0 @@
-import { Document } from './types/document.mjs';
-import { W as Watermark } from './content-sSHuWw49.mjs';
-
-/**
- * Watermark document API
- *
- * Platform-agnostic helpers for reading and applying a document watermark.
- * Shared by the React and Vue adapters (and the imperative ref API) so the
- * "Design → Watermark" behavior stays identical across frameworks.
- *
- * A watermark lives on `HeaderFooter.watermark`. MS Word repeats the same
- * watermark across the default, first-page, and even-page headers of every
- * section, so `setDocumentWatermark`:
- *
- * 1. Applies the watermark (a per-header copy) to every existing header, and
- * 2. Creates the header parts a section needs but lacks, so the watermark
- *    still shows on title pages (`w:titlePg`) and even pages
- *    (`w:evenAndOddHeaders`) and on documents that had no header at all.
- *
- * To avoid breaking header inheritance (a section that omits a header
- * reference inherits the previous section's header — Word's "link to
- * previous"), a missing `first`/`even` header part is only created when **no**
- * header of that type exists anywhere in the document, i.e. there is nothing to
- * inherit. All updates are immutable — a new `Document` is returned so the
- * change lands in the host's undo/redo history.
- */
-
-/** Read the document's watermark (the first header that carries one). */
-declare function getDocumentWatermark(doc: Document | null | undefined): Watermark | undefined;
-/**
- * Return a new `Document` with the watermark applied to all headers, or removed
- * when `watermark` is null. Creates the header parts a section needs but lacks
- * (default for a headerless doc; first/even for title/even pages) so the
- * watermark shows on every page MS Word would show it.
- */
-declare function setDocumentWatermark(doc: Document, watermark: Watermark | null): Document;
-
-export { getDocumentWatermark as g, setDocumentWatermark as s };