@openpresentation/opf 0.13.0 → 0.15.1

package/dist/pagination-wedbe7eq.d.ts

@@ -0,0 +1,119 @@
+import { C as ComposeSlideOptions, F as Fonts, L as LayoutDiagnostic } from './composition-D2tghM82.js';
+import { U as UnresolvedReferenceDiagnostic, R as RecordProvenance, b as CatalogOptions } from './catalog-refs-BSfGELpt.js';
+
+/**
+ * One slide's composition context: the layout, canvas, theme and font families that `composeSlide` needs,
+ * resolved the one way every engine must resolve them (slide design, then deck design, then theme, then the
+ * engine default, per field). Core pagination, the layout checks, the renderer, the exporter and the editor
+ * all call this, with the same `catalogs` option, so preview and export resolve the same records.
+ */
+type Rec = Record<string, any>;
+/** A reference that resolves nowhere, so the slide composes with the automatic layout or the engine default. */
+type SlideContextDiagnostic = UnresolvedReferenceDiagnostic;
+interface SlideContextOptions extends CatalogOptions {
+    /** The fonts handle; core reads its `textMeasurement`. Without it composition uses core's portable estimate. */
+    fonts?: Fonts;
+    /** One-based displayed slide number. Default: index + 1. */
+    slideNumber?: number;
+    /** Displayed slide count for `{total}`. Default: the deck's slide count. */
+    slideCount?: number;
+    /** Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` header/footer fields. */
+    date?: string;
+    /** Throw OPFUnresolvedReferenceError for a reference that resolves nowhere, instead of falling back (strict export). */
+    strictReferences?: boolean;
+}
+interface SlideContext {
+    /** Ready for `composeSlide(slide, options)`. */
+    options: ComposeSlideOptions;
+    diagnostics: SlideContextDiagnostic[];
+    /** The records `options` was resolved from, for hosts that also need the theme's or colour scheme's own fields. */
+    resolved: {
+        theme: Rec;
+        colorScheme: Rec;
+        fontScheme: Rec;
+        /** Where the font scheme reference is written, dotted. */
+        fontSchemePath: string;
+        /** The layout record, when the slide names one that resolves. */
+        layout?: Rec;
+        /**
+         * Where each resolved record came from: `{ kind, reference, id, group, source?, origin }` (origin `document` for an
+         * embedded record, `host` for a registered catalog's). A kind is absent when nothing resolved for it (the engine
+         * default, or automatic composition for a layout), so engines record provenance without resolving again.
+         */
+        provenance: {
+            layout?: RecordProvenance;
+            theme?: RecordProvenance;
+            colorScheme?: RecordProvenance;
+            fontScheme?: RecordProvenance;
+        };
+    };
+}
+/**
+ * Resolve slide `index` of `presentation` into the options `composeSlide` takes. Never throws for an unresolved
+ * reference unless `strictReferences` is set: the engine default (or automatic composition, for a layout) applies and
+ * `diagnostics` holds one `unresolved-reference` per reference. Throws a RangeError for an index outside the deck or
+ * non-positive canvas dimensions, which a schema-valid deck cannot have.
+ */
+declare function resolveSlideContext(presentation: unknown, index: number, options?: SlideContextOptions): SlideContext;
+
+interface PaginationOptions extends Omit<ComposeSlideOptions, 'textMeasurement'> {
+    /** The fonts handle: page breaks are chosen with its `textMeasurement`. Without it core uses its portable estimate. */
+    fonts?: Fonts;
+    /** Readability floor used while choosing page breaks. Default 24 reference pixels. */
+    minFontSize?: number;
+    /** All-or-nothing resource limit. Defaults to 100 output slides. */
+    maxSlides?: number;
+    /** Existing slide and content payload IDs to avoid when generating continuation IDs. */
+    reservedIds?: string[];
+}
+interface PaginationMapping {
+    sourcePath: string;
+    outputPath: string;
+    /** Half-open offsets into the original leaf; text offsets use UTF-16. */
+    range?: {
+        unit: 'utf16' | 'items';
+        start: number;
+        end: number;
+    };
+}
+interface PaginatedPage {
+    slideIndex: number;
+    mappings: PaginationMapping[];
+    /** Repeated headings/furniture and their metadata sources; separate from body slices. */
+    repeatedMappings?: PaginationMapping[];
+}
+interface PaginationResult {
+    slides: Record<string, any>[];
+    pages: PaginatedPage[];
+}
+declare class OPFPaginationError extends Error {
+    readonly diagnostics: LayoutDiagnostic[];
+    readonly code = "pagination-unresolved";
+    constructor(message: string, diagnostics?: LayoutDiagnostic[]);
+}
+/** Explicit, lossless authoring transform. It never changes slide count during rendering. */
+declare function paginateSlide(input: unknown, options?: PaginationOptions): PaginationResult;
+interface PresentationPaginationOptions extends CatalogOptions {
+    /** The fonts handle: page breaks are chosen with its `textMeasurement`. Without it core uses its portable estimate. */
+    fonts?: Fonts;
+    /** Unscaled reference-pixel clearance for supplied vector text outlines. */
+    textRasterPadding?: number;
+    minFontSize?: number;
+    maxSlides?: number;
+    /** Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` header/footer fields. */
+    date?: string;
+    /** Throw OPFUnresolvedReferenceError for a reference that resolves nowhere, instead of falling back (strict export). */
+    strictReferences?: boolean;
+    /** Receives each `unresolved-reference` diagnostic once per reference path; pagination continues with the fallback. */
+    onDiagnostic?: (diagnostic: SlideContextDiagnostic) => void;
+}
+interface PresentationPaginationResult {
+    presentation: Record<string, any>;
+    pages: (PaginatedPage & {
+        sourceSlideIndex: number;
+    })[];
+}
+/** Resolve the slides' references (the document's catalogs groups, then the registered catalogs) and paginate a complete presentation without mutating it. */
+declare function paginate(input: unknown, options?: PresentationPaginationOptions): PresentationPaginationResult;
+
+export { OPFPaginationError as O, type PaginatedPage as P, type SlideContext as S, type PaginationMapping as a, type PaginationOptions as b, type PaginationResult as c, type PresentationPaginationOptions as d, type PresentationPaginationResult as e, type SlideContextDiagnostic as f, type SlideContextOptions as g, paginateSlide as h, paginate as p, resolveSlideContext as r };

package/dist/pagination.d.ts

@@ -1,61 +1,4 @@
-import { T as TextMeasurement, C as ComposeSlideOptions, F as FontSchemeDiagnostic, L as LayoutDiagnostic } from './composition-D7we69Tr.js';
-import './chart-data-Cdr6rRVV.js';
-
-interface PaginationOptions extends ComposeSlideOptions {
-    /** Readability floor used while choosing page breaks. Default 24 reference pixels. */
-    minFontSize?: number;
-    /** All-or-nothing resource limit. Defaults to 100 output slides. */
-    maxSlides?: number;
-    /** Existing slide and content payload IDs to avoid when generating continuation IDs. */
-    reservedIds?: string[];
-}
-interface PaginationMapping {
-    sourcePath: string;
-    outputPath: string;
-    /** Half-open offsets into the original leaf; text offsets use UTF-16. */
-    range?: {
-        unit: 'utf16' | 'items';
-        start: number;
-        end: number;
-    };
-}
-interface PaginatedPage {
-    slideIndex: number;
-    mappings: PaginationMapping[];
-    /** Repeated headings/furniture and their metadata sources; separate from body slices. */
-    repeatedMappings?: PaginationMapping[];
-}
-interface PaginationResult {
-    slides: Record<string, any>[];
-    pages: PaginatedPage[];
-}
-declare class OPFPaginationError extends Error {
-    readonly diagnostics: LayoutDiagnostic[];
-    readonly code = "pagination-unresolved";
-    constructor(message: string, diagnostics?: LayoutDiagnostic[]);
-}
-/** Explicit, lossless authoring transform. It never changes slide count during rendering. */
-declare function paginateSlide(input: unknown, options?: PaginationOptions): PaginationResult;
-interface PresentationPaginationOptions {
-    textMeasurement?: TextMeasurement;
-    /** Unscaled reference-pixel clearance for supplied vector text outlines. */
-    textRasterPadding?: number;
-    minFontSize?: number;
-    maxSlides?: number;
-    /** Host-supplied current calendar date (ISO YYYY-MM-DD) for `date: true` header/footer fields. */
-    date?: string;
-    /** Optional host-resolved layout/canvas overrides for each source slide. */
-    slideOptions?: (slide: Record<string, any>, index: number) => ComposeSlideOptions;
-    /** Receives `unresolved-font-scheme` once per reference path when a font-scheme id matches no record. */
-    onDiagnostic?: (diagnostic: FontSchemeDiagnostic) => void;
-}
-interface PresentationPaginationResult {
-    presentation: Record<string, any>;
-    pages: (PaginatedPage & {
-        sourceSlideIndex: number;
-    })[];
-}
-/** Resolve local catalogs and paginate a complete presentation without mutating it. */
-declare function paginatePresentation(input: unknown, options?: PresentationPaginationOptions): PresentationPaginationResult;
-
-export { OPFPaginationError, type PaginatedPage, type PaginationMapping, type PaginationOptions, type PaginationResult, type PresentationPaginationOptions, type PresentationPaginationResult, paginatePresentation, paginateSlide };
+import './composition-D2tghM82.js';
+import './catalog-refs-BSfGELpt.js';
+export { O as OPFPaginationError, P as PaginatedPage, a as PaginationMapping, b as PaginationOptions, c as PaginationResult, d as PresentationPaginationOptions, e as PresentationPaginationResult, p as paginate, h as paginateSlide } from './pagination-wedbe7eq.js';
+import './chart-data-BnNqgnC-.js';

package/dist/pagination.js

@@ -1,6 +1,6 @@
-export { OPFPaginationError, paginatePresentation, paginateSlide } from './chunk-RAYB46AB.js';
-import './chunk-IYCJUKWD.js';
-import './chunk-MPM7NRG7.js';
-import './chunk-S5W34SIJ.js';
-import './chunk-E34DJ5LL.js';
-import './chunk-7QBCWNWL.js';
+export { OPFPaginationError, paginate, paginateSlide } from './chunk-UBFJ2QHH.js';
+import './chunk-QDI75P2M.js';
+import './chunk-O744SXXA.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-2CJPC4HI.js';

package/dist/patch.d.ts

@@ -1,18 +1,8 @@
+import { F as FindingReport, a as Finding, J as JsonPatchOperation } from './finding-CT_f_vbD.js';
+
 type JsonPointer = string;
-type JsonPatchOperation = {
-    op: "add" | "replace" | "test";
-    path: JsonPointer;
-    value: unknown;
-} | {
-    op: "remove";
-    path: JsonPointer;
-} | {
-    op: "move" | "copy";
-    from: JsonPointer;
-    path: JsonPointer;
-};
 type PatchErrorCode = "invalid-patch" | "invalid-patch-operation" | "unsupported-patch-operation" | "invalid-json-pointer" | "patch-path-missing" | "patch-parent-missing" | "invalid-array-index" | "patch-test-failed" | "patch-invalid-move" | "patch-root-remove" | "patch-invalid-document";
-declare class PatchError extends Error {
+declare class OPFPatchError extends Error {
     readonly code: PatchErrorCode;
     /** The JSON Pointer the failing operation addressed, when known. */
     path?: string;
@@ -27,20 +17,18 @@ declare class PatchError extends Error {
     });
 }
 /** Thrown when `validate` is requested and the patched document is not a valid OPF presentation. */
-declare class PatchValidationError extends PatchError {
+declare class OPFPatchValidationError extends OPFPatchError {
     readonly validation: PatchValidationResult;
     constructor(validation: PatchValidationResult);
 }
-interface PatchValidationResult {
-    valid: boolean;
-    errors?: unknown[];
-    warnings?: unknown[];
-    [key: string]: unknown;
+/** What a validator hook returns: a `validate` report, or anything with `valid` (and `findings` for `strict` to read). */
+interface PatchValidationResult extends Pick<FindingReport, "valid"> {
+    findings?: Finding[];
 }
 interface ApplyPatchOptions {
     /**
      * Validate the whole patched document against the OPF schema (`true`) or a
-     * custom validator. An invalid result throws `PatchValidationError`; the
+     * custom validator. An invalid result throws `OPFPatchValidationError`; the
      * input is never changed. Intermediate states are not validated.
      */
     validate?: boolean | ((document: unknown) => PatchValidationResult);
@@ -48,8 +36,9 @@ interface ApplyPatchOptions {
     strict?: boolean;
 }
 interface PatchResult {
-    document: unknown;
-    /** The patch that restores the input from `document`. Applying it to `document` yields the input. */
+    /** The patched presentation (a clone; the input is never changed). */
+    presentation: unknown;
+    /** The patch that restores the input from `presentation`. Applying it to `presentation` yields the input. */
     inverse: JsonPatchOperation[];
     /** The normalised operations that were applied (values cloned, unknown members dropped). */
     patch: JsonPatchOperation[];
@@ -96,4 +85,4 @@ declare function applyPatch(document: unknown, patch: unknown, options?: ApplyPa
 /** The patch that undoes `patch` when applied to the result of `applyPatch(document, patch)`. */
 declare function invertPatch(document: unknown, patch: unknown): JsonPatchOperation[];
 
-export { type ApplyPatchOptions, type JsonPatchOperation, type JsonPointer, PatchError, type PatchErrorCode, type PatchResult, PatchValidationError, type PatchValidationResult, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };
+export { type ApplyPatchOptions, JsonPatchOperation, type JsonPointer, OPFPatchError, OPFPatchValidationError, type PatchErrorCode, type PatchResult, type PatchValidationResult, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };

package/dist/patch.js

@@ -1,6 +1,6 @@
-export { PatchError, PatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-IS2CPNVJ.js';
-import './chunk-IYCJUKWD.js';
-import './chunk-MPM7NRG7.js';
-import './chunk-S5W34SIJ.js';
-import './chunk-E34DJ5LL.js';
-import './chunk-7QBCWNWL.js';
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken } from './chunk-5FTUIDUH.js';
+import './chunk-QDI75P2M.js';
+import './chunk-O744SXXA.js';
+import './chunk-TRDXRRQK.js';
+import './chunk-SPFV27O5.js';
+import './chunk-2CJPC4HI.js';