@mog-sdk/spreadsheet-contracts 0.1.12

package/dist/document/document.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Document Lifecycle Types
+ *
+ * Types for the DocumentFactory API that manages document creation and lifecycle.
+ * This enables clean separation between the spreadsheet engine and host applications.
+ *
+ * Architecture:
+ * - DocumentFactory creates DocumentHandles (stateless, doesn't track open docs)
+ * - DocumentHandle bundles document identity + ready state
+ * - Host app owns document metadata (name, owner, permissions)
+ * - Engine owns document content (cells, formulas, charts)
+ *
+ * Note: The actual YjsDocument and SpreadsheetStore types are internal to the engine.
+ * This file defines the PUBLIC contract types that consuming apps use.
+ *
+ * @see plans/parity/Issue-9-XLSX-IMPORT-BUTTON.md
+ */
+/**
+ * Describes where a document's data comes from.
+ *
+ * The pipeline preserves this context through every layer so each
+ * platform bridge can dispatch optimally:
+ * - Desktop (Tauri): 'path' → native Rust I/O (one IPC call)
+ * - Web: 'bytes' → WASM parsing
+ * - Recovery: 'bytes' → autosave data from IndexedDB/Rust
+ */
+export type DocumentSource = {
+    readonly type: 'path';
+    readonly path: string;
+} | {
+    readonly type: 'bytes';
+    readonly data: Uint8Array;
+};
+/**
+ * IndexedDB provider configuration for offline-first persistence.
+ */
+export interface IndexedDBProviderConfig {
+    type: 'indexeddb';
+}
+/**
+ * WebSocket provider configuration for real-time collaboration.
+ */
+export interface WebSocketProviderConfig {
+    type: 'websocket';
+    /** WebSocket server URL (e.g., 'wss://collab.example.com') */
+    url: string;
+    /** Optional URL parameters (e.g., auth tokens) */
+    params?: Record<string, string>;
+}
+/**
+ * Provider configuration union type.
+ * Extensible for future providers (WebRTC, custom, etc.)
+ */
+export type ProviderConfig = IndexedDBProviderConfig | WebSocketProviderConfig;
+/**
+ * Options for creating a new document.
+ */
+export interface CreateDocumentOptions {
+    /**
+     * Custom document ID.
+     * If not provided, a UUID v7 is generated automatically.
+     * Use this when you need a deterministic ID (e.g., from database).
+     */
+    documentId?: string;
+    /**
+     * Yjs providers for sync/persistence.
+     * Default: [{ type: 'indexeddb' }] for offline-first persistence.
+     *
+     * Common configurations:
+     * - IndexedDB only: [{ type: 'indexeddb' }]
+     * - IndexedDB + WebSocket: [{ type: 'indexeddb' }, { type: 'websocket', url: '...' }]
+     */
+    providers?: ProviderConfig[];
+    /**
+     * Skip creating the default "Sheet1" on document creation.
+     * Default: false (creates default sheet)
+     *
+     * Use this when importing from external sources (e.g., XLSX) that will
+     * create their own sheets. This prevents an empty "Sheet1" from remaining
+     * after import.
+     *
+     * @internal Used by DocumentFactory.createFromXlsx()
+     */
+    skipDefaultSheet?: boolean;
+    /**
+     * Pre-built WorkbookSnapshot to initialize the engine from (for collaboration).
+     * When provided, the engine is created with this snapshot instead of an empty one.
+     * This ensures the engine shares the same CellIds as the source/authoritative engine.
+     */
+    initialSnapshot?: Record<string, unknown>;
+}
+/**
+ * Options for importing an XLSX file into a new document.
+ * Extends CreateDocumentOptions with import-specific settings.
+ */
+export interface DocumentImportOptions extends CreateDocumentOptions {
+    /**
+     * Maximum number of cells to import.
+     * Default: 1,000,000
+     * Files exceeding this limit will fail the pre-flight check.
+     */
+    maxCells?: number;
+    /**
+     * Import values only, skip formulas.
+     * Default: false
+     */
+    valuesOnly?: boolean;
+    /**
+     * Skip cell formatting (faster import).
+     * Default: false
+     */
+    skipFormatting?: boolean;
+    /**
+     * AbortSignal for cancellation support.
+     * Use with AbortController to cancel long-running imports.
+     */
+    signal?: AbortSignal;
+    /**
+     * Progress callback for UI feedback.
+     * Called periodically during import with progress information.
+     */
+    onProgress?: (progress: ImportProgressInfo) => void;
+}
+/**
+ * Progress information during XLSX import.
+ */
+export interface ImportProgressInfo {
+    /** Current phase of import */
+    phase: 'parsing' | 'processing' | 'complete';
+    /** Name of the sheet currently being processed */
+    currentSheet?: string;
+    /** Number of sheets processed so far */
+    sheetsProcessed: number;
+    /** Total number of sheets to process */
+    totalSheets: number;
+    /** Number of cells processed so far */
+    cellsProcessed: number;
+    /** Total number of cells to process */
+    totalCells: number;
+    /** Percentage complete (0-100) */
+    percentage: number;
+}
+/**
+ * Result of an XLSX import operation.
+ * Note: The handle is not included here - it's part of the engine's return type.
+ */
+export interface DocumentImportResult {
+    /** Whether the import succeeded */
+    success: boolean;
+    /** Number of cells imported */
+    cellCount: number;
+    /** Sheet IDs created during import */
+    sheetIds: string[];
+    /** Error that occurred (if success is false) */
+    error?: Error;
+    /** Warnings generated during import (e.g., unsupported features) */
+    warnings: DocumentImportWarning[];
+    /** Import metrics for performance monitoring */
+    metrics?: {
+        /** Time spent parsing the XLSX file (ms) */
+        parseTimeMs: number;
+        /** Time spent processing cells (ms) */
+        processTimeMs: number;
+        /** Total import time (ms) */
+        totalTimeMs: number;
+    };
+}
+/**
+ * Warning generated during import.
+ */
+export interface DocumentImportWarning {
+    /** Type of warning */
+    type: 'cell_limit' | 'format_loss' | 'formula_error' | 'unsupported_feature';
+    /** Human-readable warning message */
+    message: string;
+    /** Location where the warning occurred */
+    location?: {
+        sheet?: string;
+        cell?: string;
+    };
+}
+//# sourceMappingURL=document.d.ts.map

package/dist/document/document.d.ts.map

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

package/dist/document/index.d.ts

@@ -0,0 +1,5 @@
+export * from './comments';
+export * from './document';
+export * from './protection';
+export * from './search';
+//# sourceMappingURL=index.d.ts.map

package/dist/document/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/document/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}

package/dist/document/protection.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Sheet Protection Contracts
+ *
+ * Defines types for sheet protection, cell locking, and protected operations.
+ * These types enable Excel-compatible protection enforcement.
+ *
+ * @see STREAM-H-EDITOR-PROTECTION.md
+ */
+/**
+ * Sheet protection options - matches Excel/SpreadJS behavior.
+ * All flags default to false (operation NOT allowed when protected).
+ * The two exceptions are selection flags which default to true.
+ *
+ * When a sheet is protected:
+ * - Operations not explicitly allowed are blocked
+ * - Cells with locked: false can still be edited (unless formatCells is also blocked)
+ *
+ * These options are stored in sheet metadata and preserved in XLSX round-trips.
+ */
+export interface SheetProtectionOptions {
+    /** Can select locked cells (default: true) */
+    selectLockedCells: boolean;
+    /** Can select unlocked cells (default: true) */
+    selectUnlockedCells: boolean;
+    /** Can insert new rows */
+    insertRows: boolean;
+    /** Can insert new columns */
+    insertColumns: boolean;
+    /** Can delete rows */
+    deleteRows: boolean;
+    /** Can delete columns */
+    deleteColumns: boolean;
+    /** Can format cells */
+    formatCells: boolean;
+    /** Can format columns (width, hide/show) */
+    formatColumns: boolean;
+    /** Can format rows (height, hide/show) */
+    formatRows: boolean;
+    /** Can sort ranges */
+    sort: boolean;
+    /** Can use AutoFilter */
+    useAutoFilter: boolean;
+    /** Can use PivotTable reports */
+    usePivotTableReports: boolean;
+    /** Can edit objects (charts, shapes, images) */
+    editObjects: boolean;
+    /** Can edit scenarios */
+    editScenarios: boolean;
+}
+/**
+ * Default protection options.
+ * All operations blocked except selection.
+ */
+export declare const DEFAULT_PROTECTION_OPTIONS: SheetProtectionOptions;
+/**
+ * Types of operations that can be protected.
+ * Used by protection check functions to determine if an operation is allowed.
+ */
+export type ProtectedOperation = 'editCell' | 'insertRows' | 'insertColumns' | 'deleteRows' | 'deleteColumns' | 'formatCells' | 'formatRows' | 'formatColumns' | 'sort' | 'filter' | 'editObject';
+/**
+ * Result of a protection check.
+ */
+export interface ProtectionCheckResult {
+    /** Whether the operation is allowed */
+    allowed: boolean;
+    /** Reason why operation was blocked (only set when allowed is false) */
+    reason?: 'sheetProtected' | 'cellLocked' | 'operationNotAllowed';
+}
+/**
+ * Result of a mutation operation.
+ * Used by Mutations layer to return success/failure with context.
+ *
+ * Named MutationResult to avoid collision with OperationResult<T> in api.ts.
+ * OperationResult is a generic API type with `data` field, while this is
+ * a simpler internal type for the coordinator layer.
+ */
+export interface MutationResult {
+    /** Whether the mutation succeeded */
+    success: boolean;
+    /** Error type if mutation failed */
+    error?: 'PROTECTED' | 'INVALID_RANGE' | 'SHEET_NOT_FOUND' | 'VALIDATION_FAILED';
+    /** Human-readable error reason */
+    reason?: string;
+    /** Number of cells/items affected (for success cases) */
+    affected?: number;
+}
+/**
+ * Workbook protection options - matches Excel behavior.
+ * Workbook protection prevents structural changes to sheets.
+ *
+ * When a workbook is protected:
+ * - Users cannot add, delete, rename, hide, unhide, or move sheets
+ * - Sheet content can still be edited (unless sheet is also protected)
+ *
+ * Plan 08: Dialogs - Task 4 (Protect Workbook Dialog)
+ */
+export interface WorkbookProtectionOptions {
+    /**
+     * Protect workbook structure (prevents sheet add/delete/move/rename/hide/unhide).
+     * Default: true when protection is enabled.
+     */
+    structure: boolean;
+}
+/**
+ * Default workbook protection options.
+ * Structure protection enabled by default.
+ */
+export declare const DEFAULT_WORKBOOK_PROTECTION_OPTIONS: WorkbookProtectionOptions;
+/**
+ * Types of workbook-level operations that can be protected.
+ * Used by protection check functions to determine if an operation is allowed.
+ */
+export type ProtectedWorkbookOperation = 'addSheet' | 'deleteSheet' | 'renameSheet' | 'moveSheet' | 'hideSheet' | 'unhideSheet' | 'copySheet';
+//# sourceMappingURL=protection.d.ts.map

package/dist/document/protection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protection.d.ts","sourceRoot":"","sources":["../../src/document/protection.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,sBAAsB;IAErC,8CAA8C;IAC9C,iBAAiB,EAAE,OAAO,CAAC;IAC3B,gDAAgD;IAChD,mBAAmB,EAAE,OAAO,CAAC;IAG7B,0BAA0B;IAC1B,UAAU,EAAE,OAAO,CAAC;IACpB,6BAA6B;IAC7B,aAAa,EAAE,OAAO,CAAC;IACvB,sBAAsB;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,yBAAyB;IACzB,aAAa,EAAE,OAAO,CAAC;IAGvB,uBAAuB;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,4CAA4C;IAC5C,aAAa,EAAE,OAAO,CAAC;IACvB,0CAA0C;IAC1C,UAAU,EAAE,OAAO,CAAC;IAGpB,sBAAsB;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,yBAAyB;IACzB,aAAa,EAAE,OAAO,CAAC;IACvB,iCAAiC;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAG9B,gDAAgD;IAChD,WAAW,EAAE,OAAO,CAAC;IACrB,yBAAyB;IACzB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,sBAiBxC,CAAC;AAMF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,eAAe,GACf,aAAa,GACb,YAAY,GACZ,eAAe,GACf,MAAM,GACN,QAAQ,GACR,YAAY,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,MAAM,CAAC,EAAE,gBAAgB,GAAG,YAAY,GAAG,qBAAqB,CAAC;CAClE;AAMD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,qCAAqC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,KAAK,CAAC,EAAE,WAAW,GAAG,eAAe,GAAG,iBAAiB,GAAG,mBAAmB,CAAC;IAChF,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAUD;;;;;;;;;GASG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CAEpB;AAED;;;GAGG;AACH,eAAO,MAAM,mCAAmC,EAAE,yBAEjD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAClC,UAAU,GACV,aAAa,GACb,aAAa,GACb,WAAW,GACX,WAAW,GACX,aAAa,GACb,WAAW,CAAC"}

package/dist/document/search.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Search Types for Find/Replace
+ *
+ * Defines types for the Find/Replace system following the Cell Identity Architecture.
+ * Search results store stable CellIds, not positions - positions are resolved at
+ * navigation/render time.
+ *
+ * Key architectural decisions:
+ * - CellId-based results survive row/col insert/delete operations
+ * - Position is resolved from CellId at navigation time via GridIndex
+ * - Search is a read-only query - NOT persistent state (not a domain module)
+ * - XState machine manages search state (not Zustand) due to complex transitions
+ *
+ * @see plans/active/detailed-parity-implementation/STREAM-C2-FIND-REPLACE.md
+ * @see docs/architecture/cell-identity.md
+ */
+import type { CellId } from '../cells/cell-identity';
+import type { SheetId } from '../core/core';
+/**
+ * Options for Find/Replace operations.
+ */
+export interface SearchOptions {
+    /**
+     * Where to search: displayed values, formula text, or both.
+     *
+     * - 'values': Search in displayed/computed values (default)
+     * - 'formulas': Search in formula text (=SUM(A1:B10))
+     * - 'both': Search in both values and formulas
+     */
+    searchIn: 'values' | 'formulas' | 'both';
+    /**
+     * Case-sensitive matching.
+     * @default false
+     */
+    caseSensitive: boolean;
+    /**
+     * Match entire cell contents only.
+     * If true, "test" won't match a cell containing "testing".
+     * @default false
+     */
+    matchEntireCell: boolean;
+    /**
+     * Enable regular expression matching.
+     * When true, the query is treated as a regex pattern.
+     * @default false
+     */
+    useRegex: boolean;
+    /**
+     * Search scope: current sheet or entire workbook.
+     * @default 'sheet'
+     */
+    scope: 'sheet' | 'workbook';
+    /**
+     * Search direction for result ordering.
+     * - 'byRow': Left-to-right, top-to-bottom (row-major)
+     * - 'byColumn': Top-to-bottom, left-to-right (column-major)
+     * @default 'byRow'
+     */
+    direction: 'byRow' | 'byColumn';
+}
+/**
+ * Default search options.
+ */
+export declare const DEFAULT_SEARCH_OPTIONS: SearchOptions;
+/**
+ * A single search result.
+ *
+ * ARCHITECTURE (Cell Identity):
+ * - Uses CellId for stable identity per Cell Identity Architecture
+ * - Position is NOT stored - resolved at navigation/render time via GridIndex.getPosition()
+ * - This ensures results survive row/column insert/delete operations
+ * - Deleted cells are gracefully skipped during navigation
+ *
+ * @example
+ * // When navigating to a result:
+ * const position = GridIndex.getPosition(ctx, result.cellId);
+ * if (position) {
+ *   selectionActor.send({ type: 'SELECT_CELL', row: position.row, col: position.col });
+ * }
+ * // If position is null, cell was deleted - skip to next result
+ */
+export interface SearchResult {
+    /**
+     * Sheet containing the match.
+     * Used for cross-sheet navigation in workbook-wide search.
+     */
+    sheetId: SheetId;
+    /**
+     * Stable cell identity - survives row/col insert/delete.
+     * Use GridIndex.getPosition(ctx, cellId) to get current position.
+     */
+    cellId: CellId;
+    /**
+     * The matched text substring.
+     */
+    matchedText: string;
+    /**
+     * Start position of match within cell text (0-indexed).
+     */
+    matchStart: number;
+    /**
+     * Length of matched text.
+     */
+    matchLength: number;
+    /**
+     * Whether match is in formula text (vs displayed value).
+     * Affects Replace behavior:
+     * - true: Replace modifies formula text
+     * - false: Replace modifies cell value (only for non-formula cells)
+     */
+    isInFormula: boolean;
+}
+/**
+ * Information about a match within cell text.
+ * Used internally by search functions.
+ */
+export interface SearchMatchInfo {
+    /** Matched text */
+    text: string;
+    /** Start position in original text */
+    start: number;
+    /** Length of match */
+    length: number;
+    /** Whether match is in formula */
+    isInFormula: boolean;
+}
+/**
+ * Options for Replace operations.
+ * Extends SearchOptions with replacement-specific settings.
+ */
+export interface ReplaceOptions extends SearchOptions {
+    /**
+     * Text to replace matches with.
+     */
+    replacement: string;
+}
+/**
+ * Result of a replace operation.
+ */
+export interface ReplaceResult {
+    /** Whether replacement was successful */
+    success: boolean;
+    /** Number of replacements made */
+    replacedCount: number;
+    /**
+     * Number of matches skipped.
+     * Reasons for skipping:
+     * - Formula cell when searching in 'values' (Excel behavior)
+     * - Cell was deleted since search
+     */
+    skippedCount: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Search highlight for rendering.
+ * Position is resolved at render time from CellId.
+ *
+ * ARCHITECTURE:
+ * - Canvas layer receives row/col (doesn't know about CellId)
+ * - CellId → position resolution happens in React (SpreadsheetGrid.tsx)
+ * - This keeps canvas layer pure and testable
+ */
+export interface SearchHighlight {
+    /** Current row position (resolved from CellId at render time) */
+    row: number;
+    /** Current column position (resolved from CellId at render time) */
+    col: number;
+    /** Whether this is the current/active result */
+    isCurrent: boolean;
+}
+/**
+ * Search state for XState machine context.
+ * This is NOT stored in Zustand - it's in the XState machine.
+ */
+export interface FindReplaceState {
+    /** Current search query */
+    query: string;
+    /** Replacement text (for replace operations) */
+    replacement: string;
+    /** Search options */
+    options: SearchOptions;
+    /**
+     * Search results (computed on search).
+     * Stores CellIds, not positions - per Cell Identity Architecture.
+     */
+    results: SearchResult[];
+    /** Current result index for navigation (0-based, -1 if no results) */
+    currentIndex: number;
+    /**
+     * Whether results are stale (cell VALUES changed since last search).
+     *
+     * IMPORTANT: Structure changes (insert/delete row/col) do NOT cause staleness
+     * because we store CellId, not position. Only value changes cause staleness.
+     */
+    resultsStale: boolean;
+    /** Whether showing replace UI (false = find-only mode) */
+    showReplace: boolean;
+    /** Error message if search/replace failed */
+    errorMessage: string | null;
+}
+//# sourceMappingURL=search.d.ts.map

package/dist/document/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/document/search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAM5C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,MAAM,CAAC;IAEzC;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,KAAK,EAAE,OAAO,GAAG,UAAU,CAAC;IAE5B;;;;;OAKG;IACH,SAAS,EAAE,OAAO,GAAG,UAAU,CAAC;CACjC;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAOpC,CAAC;AAMF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAC;CACtB;AAMD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,WAAW,EAAE,OAAO,CAAC;CACtB;AAMD;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IAEjB,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAMD;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,SAAS,EAAE,OAAO,CAAC;CACpB;AAMD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IAEd,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;IAEpB,qBAAqB;IACrB,OAAO,EAAE,aAAa,CAAC;IAEvB;;;OAGG;IACH,OAAO,EAAE,YAAY,EAAE,CAAC;IAExB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB,0DAA0D;IAC1D,WAAW,EAAE,OAAO,CAAC;IAErB,6CAA6C;IAC7C,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B"}

package/dist/drawing/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Drawing Module — Shared types for shape rendering (3D effects, etc.)
+ *
+ * These types are shared across SmartArt, WordArt, and general
+ * DrawingML shape rendering.
+ */
+export type { Bevel, BevelPresetType, Camera, ColorRef, LightRig, LightRigDirection, LightRigType, PresetCameraType, PresetMaterialType, Rotation3D, Scene3D, Shape3D, } from './three-d';
+//# sourceMappingURL=index.d.ts.map

package/dist/drawing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/drawing/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,YAAY,EACV,KAAK,EACL,eAAe,EACf,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,OAAO,EACP,OAAO,GACR,MAAM,WAAW,CAAC"}