@betteroffice/docx 0.0.1

package/dist/rustPagination-Bj2hq013.d.mts

@@ -0,0 +1,106 @@
+import { L as LayoutOptions, a as Layout } from './types-DNrYr6yQ.mjs';
+import { M as MeasuredBlock } from './measuredBlock-DZwz8zhD.mjs';
+
+/**
+ * The mandatory Rust pagination source — the seam through which EVERY
+ * pagination pass (full, incremental-trigger, footnote pass 1, and each
+ * footnote-stabilization iteration in `layout/regions/footnoteLayout.ts`)
+ * runs the wasm `docx-layout` engine. There is no TypeScript pagination
+ * kernel anymore; this seam is the only way a `Layout` is produced.
+ *
+ * Contract (pinned by the golden corpus — `__golden__/rustParity.test.ts`
+ * proves the engine reproduces every golden byte-for-byte, and
+ * `__golden__/rustPaginationSeam.test.ts` proves this seam adds zero drift
+ * on top):
+ *  - Input marshaling is exactly the golden convention:
+ *    `JSON.stringify({ measured, options }, mapReplacer)` where the replacer
+ *    turns `Map`s (`options.footnoteReservedHeights`) into plain objects
+ *    keyed by decimal page number — the shape the Rust `LayoutOptions`
+ *    deserializer expects.
+ *  - `layout_document_json` in, `Layout` JSON out. Engine failures THROW —
+ *    the layout pipeline surfaces the error (`onError` / console) and keeps
+ *    the previous committed layout; nothing falls back to a hidden kernel.
+ *  - The wasm engine is synchronous once loaded. Adapters gate layout passes
+ *    on {@link RustPaginationSource.isReady} / `whenReady()` (the same
+ *    defer-and-rerun pattern as the Rust measurement readiness gate), so
+ *    `paginate` never runs against an unloaded engine. The wasm module is
+ *    shared with the measurement engine, so in practice it is already
+ *    resolved by the time the first measured pass reaches pagination.
+ *
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * The narrow seam `editor/computeLayout.ts` consumes: a synchronous
+ * pagination call over the measured blocks + options, plus the readiness
+ * surface adapters use to defer layout passes until the wasm engine has
+ * loaded. `paginate` throws if called before readiness or when the engine
+ * rejects the input — there is no fallback engine.
+ *
+ * @public
+ */
+interface LayoutPaginationSource {
+    /** Paginate through the loaded Rust engine. Throws when not ready or on engine failure. */
+    paginate(measured: MeasuredBlock[], options: LayoutOptions): Layout;
+    /** Whether the wasm engine has finished its lazy load. */
+    isReady(): boolean;
+    /** Resolves when the engine is loaded; rejects if the load failed. */
+    whenReady(): Promise<void>;
+}
+/**
+ * Thin sync facade over the wasm pagination export (`layout_document_json`).
+ * Injectable so unit tests can script responses without loading wasm — the
+ * same pattern as the measurement seam's `RustTextEngine`.
+ *
+ * @public
+ */
+interface RustLayoutEngine {
+    /** `{ measured, options }` JSON in, `Layout` JSON out. Throws on any input the engine rejects. */
+    layoutDocumentJson(input: string): string;
+}
+/**
+ * Lazily load the embedded wasm module and expose its pagination surface as
+ * a {@link RustLayoutEngine}. The dynamic `import()` keeps the ~800KB base64
+ * module out of the synchronous require graph; the module — and therefore
+ * the wasm instantiation — is shared with the measurement seam
+ * (`getRustTextEngine`), so only one load happens per session.
+ *
+ * @public
+ */
+declare function getRustLayoutEngine(): Promise<RustLayoutEngine>;
+/** Counters for observability (passes paginated / engine errors). @public */
+interface RustPaginationStats {
+    /** Layout passes paginated by the Rust engine. */
+    rustPaginated: number;
+    /** Passes where the engine threw (the pass produced no layout). */
+    engineErrors: number;
+}
+/** Options for {@link createRustPaginationSource}. @public */
+interface RustPaginationSourceOptions {
+    /** Pre-loaded engine (tests). When set, the source is ready immediately. */
+    engine?: RustLayoutEngine;
+    /** Engine loader override (tests). Defaults to {@link getRustLayoutEngine}. */
+    loadEngine?: () => Promise<RustLayoutEngine>;
+}
+/**
+ * The mandatory pagination source. Create with
+ * {@link createRustPaginationSource}; see the module doc for the contract.
+ *
+ * @public
+ */
+interface RustPaginationSource extends LayoutPaginationSource {
+    /** Snapshot of the pagination counters (never reset implicitly). */
+    getStats(): RustPaginationStats;
+}
+/**
+ * Build a {@link RustPaginationSource}. The wasm load starts immediately at
+ * construction; adapters defer layout passes until `isReady()` and re-run
+ * the pipeline off `whenReady()` — mirroring the Rust measurement readiness
+ * gate, and sharing the same underlying wasm module load.
+ *
+ * @public
+ */
+declare function createRustPaginationSource(opts?: RustPaginationSourceOptions): RustPaginationSource;
+
+export { type LayoutPaginationSource as L, type RustLayoutEngine as R, type RustPaginationSource as a, type RustPaginationSourceOptions as b, type RustPaginationStats as c, createRustPaginationSource as d, getRustLayoutEngine as g };

package/dist/sectionConfigs-DW3J8q0X.d.mts

@@ -0,0 +1,55 @@
+import { P as PageMargins, C as ColumnLayout, b as PageHeaderFooterRefs, c as PageNumberingContract, d as PageBorderContract, S as SectionBreakBlock, N as NoteSettingsContract, e as LayoutBlock, L as LayoutOptions } from './types-DNrYr6yQ.mjs';
+
+/**
+ * Per-section geometry collection.
+ *
+ * Walks a block list once and resolves the effective page geometry of every
+ * section (size, margins, columns, header/footer refs, numbering, borders,
+ * …), inheriting from the previous section where a break leaves a property
+ * unset and applying any upstream section contracts. The live consumer is
+ * `layout/regions/sectionGeometry.ts` (per-section measurement widths); the
+ * Rust engine mirrors the same resolution natively.
+ */
+
+/**
+ * Page-flow geometry resolved from a single section's properties.
+ * Exported so the React paged editor can reuse the same shape when
+ * measuring blocks per section width — keeping pagination and
+ * measurement consistent.
+ */
+type SectionLayoutConfig = {
+    pageSize: {
+        w: number;
+        h: number;
+    };
+    margins: PageMargins;
+    /** Optional. Sections without explicit columns inherit `{ count: 1 }`. */
+    columns?: ColumnLayout;
+    /** Stable section/page state copied onto every page created in this section. */
+    sectionIndex?: number;
+    sectionId?: string;
+    orientation?: 'portrait' | 'landscape';
+    headerFooterRefs?: PageHeaderFooterRefs;
+    pageNumbering?: PageNumberingContract;
+    pageBorders?: PageBorderContract;
+    watermark?: SectionBreakBlock['watermark'];
+    verticalAlign?: SectionBreakBlock['verticalAlign'];
+    noteSettings?: NoteSettingsContract;
+    /** Versioned page metadata is emitted only when an upstream contract opts in. */
+    emitPageMetadata?: boolean;
+};
+/**
+ * Walk `blocks` once and collect per-section geometry. `configs` has one
+ * entry per section break plus a trailing `finalConfig`. `breakIndices` is
+ * 1-to-1 with the inner break entries (same length as `configs.length - 1`).
+ * Callers that need the break `type` can read it from
+ * `(blocks[breakIndices[i]] as SectionBreakBlock).type`.
+ *
+ * @internal
+ */
+declare function collectSectionConfigs(blocks: LayoutBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig, sectionContracts?: LayoutOptions['sections']): {
+    configs: SectionLayoutConfig[];
+    breakIndices: number[];
+};
+
+export { type SectionLayoutConfig as S, collectSectionConfigs as c };