@openpresentation/opf 0.13.0 → 0.15.1

package/dist/json-BFSdESOE.d.ts

@@ -0,0 +1,19 @@
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+/**
+ * Structural shape of a bundled JSON Schema document (the schema itself, not
+ * data validated against it). Kept intentionally loose — `$id`/`$schema` are
+ * typed precisely because callers rely on them (see `src/validator.ts`), and
+ * everything else falls through the index signature. This avoids inferring a
+ * deeply-nested literal type for every property/subschema, which is what
+ * previously made `dist/schemas.d.ts` balloon to hundreds of KB.
+ */
+interface JsonSchemaDocument extends JsonObject {
+    readonly $id: string;
+    readonly $schema: string;
+}
+
+export type { JsonPrimitive as J, JsonSchemaDocument as a, JsonObject as b };

package/dist/markdown.d.ts

@@ -1,10 +1,10 @@
-import { L as LintDiagnostic, i as LintLocation, j as LintSeverity } from './lint-B7azdiuE.js';
-import { P as Presentation } from './presentation-mG-IYErQ.js';
-import './catalogs-ywCamd8C.js';
-import './schemas-BbPonsTz.js';
-import './validator-CIylxoIm.js';
-import './composition-D7we69Tr.js';
-import './chart-data-Cdr6rRVV.js';
+import { a as Catalog } from './catalog-refs-BSfGELpt.js';
+import { P as Presentation } from './presentation-CDKQVkyI.js';
+import { a as Finding, b as FindingLocation, F as FindingReport } from './finding-CT_f_vbD.js';
+import { V as ValidateOptions } from './validation-types-BOcY9GTs.js';
+import './composition-D2tghM82.js';
+import './chart-data-BnNqgnC-.js';
+import './json-BFSdESOE.js';
 
 interface EmbeddedPart {
     /** JSON Pointer into the OPF document. */
@@ -12,11 +12,7 @@ interface EmbeddedPart {
     reason: string;
 }
 
-/** A diagnostic in the shape of `@openpresentation/opf/lint`, with the source range always present. */
-type MarkdownDiagnostic = LintDiagnostic & {
-    location: LintLocation;
-};
-/** Raised by `opfToMarkdown` for a document it cannot convert: `invalid-document` (does not validate as OPF) or `not-representable` (a value that no Markdown or YAML form can carry exactly). */
+/** Raised by `toMarkdown` for a document it cannot convert: `invalid-document` (does not validate as OPF) or `not-representable` (a value that no Markdown or YAML form can carry exactly). */
 declare class OPFMarkdownError extends Error {
     readonly code: "invalid-document" | "not-representable";
     readonly details: Record<string, unknown>;
@@ -28,24 +24,41 @@ interface ParseOptions {
     split?: "rules" | "headings";
 }
 
-interface MarkdownToOpfOptions extends ParseOptions {
+/**
+ * Deterministic Markdown to OPF and OPF to Markdown conversion for the OPF Markdown dialect (RR-30): YAML front
+ * matter for deck metadata, `---` between slides, `#` title, `##` subtitle, paragraphs, lists, block quotes with
+ * a dash attribution, fenced code, pipe tables, images, `chart`, `metric` and `timeline` fences, `Note:` speaker
+ * notes and HTML comments for slide and block options. Anything the dialect has no syntax for is embedded as YAML
+ * (`opf-slide`, `opf-block`) so a round trip loses nothing, or dropped and reported on request.
+ *
+ * No renderer, fonts, DOM, network or model calls. The same input always gives the same output.
+ */
+
+interface FromMarkdownOptions extends ParseOptions {
     /** Deck properties used when the front matter does not set them (for example `{ name: "Title" }`). The front matter wins. */
     defaults?: Record<string, unknown>;
-    /** Run the OPF lint over the result and map its findings to Markdown line and column (default true). */
-    validate?: boolean;
+    /**
+     * Check the result with `validate` and map its findings to Markdown line and column: `true` (the default) checks
+     * `format` and `references`; options pick other rules or categories; `false` skips the check.
+     */
+    validate?: boolean | ValidateOptions;
+    /** Catalogs the host registered, for the references check of `validate: true` (the default). Nothing is fetched. */
+    catalogs?: readonly Catalog[];
 }
-interface MarkdownToOpfResult {
+interface FromMarkdownResult {
     /** The converted deck. Always an object; when `valid` is false it is a best effort that does not validate. */
-    document: Presentation;
+    presentation: Presentation;
     /** True when there are no errors (Markdown syntax errors and OPF validation errors both count). */
     valid: boolean;
-    /** Lint-shaped diagnostics, in source order, each with `location` (UTF-16 offset and length, one-based line and column). */
-    diagnostics: MarkdownDiagnostic[];
-    counts: Record<LintSeverity, number>;
+    /** Findings (the shared Finding format), in source order, each with `location` (UTF-16 offset and length, one-based line and column). */
+    findings: (Finding & {
+        location: FindingLocation;
+    })[];
+    counts: FindingReport["counts"];
 }
-/** Convert Markdown in the OPF dialect to an OPF document. Never throws for malformed content; read `valid` and `diagnostics`. */
-declare function markdownToOpf(markdown: string, options?: MarkdownToOpfOptions): MarkdownToOpfResult;
-interface OpfToMarkdownOptions {
+/** Convert Markdown in the OPF dialect to an OPF document. Never throws for malformed content; read `valid` and `findings`. */
+declare function fromMarkdown(markdown: string, options?: FromMarkdownOptions): FromMarkdownResult;
+interface ToMarkdownOptions {
     /**
      * What to do with a part that has no Markdown syntax (a design, region keys, a styled table cell, a nested group).
      * `embed` (default) writes it as YAML in an `opf-slide` or `opf-block` fence so nothing is lost; `drop` leaves it out
@@ -53,7 +66,7 @@ interface OpfToMarkdownOptions {
      */
     unsupported?: "embed" | "drop";
 }
-interface OpfToMarkdownResult {
+interface ToMarkdownResult {
     markdown: string;
     report: {
         /** True when everything in the document is in the Markdown (natively or embedded). False only in `drop` mode, when `loss` is not empty. */
@@ -68,9 +81,9 @@ interface OpfToMarkdownResult {
 }
 /**
  * Convert an OPF document to Markdown in the dialect. For a document the dialect fully expresses,
- * `markdownToOpf(opfToMarkdown(doc).markdown).document` is the same deck; the Markdown it writes converts back to
+ * `fromMarkdown(toMarkdown(presentation).markdown).presentation` is the same deck; the Markdown it writes converts back to
  * itself byte for byte. Throws `OPFMarkdownError` (`invalid-document`) when the input is not valid OPF.
  */
-declare function opfToMarkdown(document: unknown, options?: OpfToMarkdownOptions): OpfToMarkdownResult;
+declare function toMarkdown(document: unknown, options?: ToMarkdownOptions): ToMarkdownResult;
 
-export { type EmbeddedPart, type MarkdownDiagnostic, type MarkdownToOpfOptions, type MarkdownToOpfResult, OPFMarkdownError, type OpfToMarkdownOptions, type OpfToMarkdownResult, markdownToOpf, opfToMarkdown };
+export { type EmbeddedPart, type FromMarkdownOptions, type FromMarkdownResult, OPFMarkdownError, type ToMarkdownOptions, type ToMarkdownResult, fromMarkdown, toMarkdown };