@openpresentation/opf 0.11.4 → 0.12.1

package/dist/lint.d.ts

@@ -1,7 +1,7 @@
-import { C as CatalogKind } from './catalogs-CUClB3nl.js';
-import { ValidationIssue } from './validator.js';
-import { J as JsonPrimitive } from './schemas-X_NniU4A.js';
-import './presentation-j5PVrqfV.js';
+import { C as CatalogKind } from './catalogs-BnI7JKcn.js';
+import { V as ValidationIssue } from './validator-DfG9yxba.js';
+import { J as JsonPrimitive } from './schemas-BSjlG8-R.js';
+import './presentation-DcF-MZcz.js';
 
 type LintSeverity = 'error' | 'warning' | 'info';
 interface LintLocation {

package/dist/lint.js

@@ -1,5 +1,6 @@
-export { lintPresentation, lintSource } from './chunk-3OJN7QAW.js';
-import './chunk-FDCWQHWO.js';
-import './chunk-3H2U7FDR.js';
-import './chunk-KJKASEPE.js';
-import './chunk-AEUSVEUY.js';
+export { lintPresentation, lintSource } from './chunk-MWPMJE6P.js';
+import './chunk-JKVKYVWL.js';
+import './chunk-HOBSL7AJ.js';
+import './chunk-S5W34SIJ.js';
+import './chunk-E34DJ5LL.js';
+import './chunk-4LAM3N6S.js';

package/dist/markdown.d.ts

@@ -0,0 +1,74 @@
+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';
+
+interface EmbeddedPart {
+    /** JSON Pointer into the OPF document. */
+    path: string;
+    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). */
+declare class OPFMarkdownError extends Error {
+    readonly code: "invalid-document" | "not-representable";
+    readonly details: Record<string, unknown>;
+    constructor(code: "invalid-document" | "not-representable", message: string, details?: Record<string, unknown>);
+}
+
+interface ParseOptions {
+    /** `rules` (default): slides are separated by `---` lines. `headings`: a `# ` heading also starts a new slide (outline input). */
+    split?: "rules" | "headings";
+}
+
+interface MarkdownToOpfOptions 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;
+}
+interface MarkdownToOpfResult {
+    /** The converted deck. Always an object; when `valid` is false it is a best effort that does not validate. */
+    document: 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>;
+}
+/** 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 {
+    /**
+     * 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
+     * and reports it in `loss`, for Markdown meant to be read rather than converted back.
+     */
+    unsupported?: "embed" | "drop";
+}
+interface OpfToMarkdownResult {
+    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. */
+        lossless: boolean;
+        /** True when nothing needed embedding or dropping: the Markdown is plain dialect syntax throughout. */
+        native: boolean;
+        /** Parts written as YAML because the dialect has no syntax for them (`embed` mode), with a JSON Pointer and the reason. */
+        embedded: EmbeddedPart[];
+        /** Parts left out (`drop` mode), as `<JSON Pointer>: <reason>`. Empty when lossless. */
+        loss: string[];
+    };
+}
+/**
+ * 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
+ * itself byte for byte. Throws `OPFMarkdownError` (`invalid-document`) when the input is not valid OPF.
+ */
+declare function opfToMarkdown(document: unknown, options?: OpfToMarkdownOptions): OpfToMarkdownResult;
+
+export { type EmbeddedPart, type MarkdownDiagnostic, type MarkdownToOpfOptions, type MarkdownToOpfResult, OPFMarkdownError, type OpfToMarkdownOptions, type OpfToMarkdownResult, markdownToOpf, opfToMarkdown };