@openpresentation/opf 0.12.2 → 0.14.0

package/dist/markdown.d.ts

@@ -1,8 +1,10 @@
-import { LintDiagnostic, LintLocation, LintSeverity } from './lint.js';
-import { P as Presentation } from './presentation-DcF-MZcz.js';
-import './catalogs-BnI7JKcn.js';
-import './schemas-BSjlG8-R.js';
-import './validator-DfG9yxba.js';
+import { P as Presentation } from './presentation-C5eHkevA.js';
+import { F as Finding, d as FindingLocation, e as FindingReport } from './finding-C_por275.js';
+import { V as ValidateOptions } from './validation-types-zh03LeZy.js';
+import './catalogs-D-yyQWCQ.js';
+import './schemas-DDpqAgyS.js';
+import './composition-_WEwBe2a.js';
+import './chart-data-B_3z9VTb.js';
 
 interface EmbeddedPart {
     /** JSON Pointer into the OPF document. */
@@ -10,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>;
@@ -26,24 +24,29 @@ interface ParseOptions {
     split?: "rules" | "headings";
 }
 
-interface MarkdownToOpfOptions extends ParseOptions {
+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;
 }
-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
@@ -51,7 +54,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. */
@@ -66,9 +69,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 };