@asterdoc/render 0.0.0-stage → 0.9.0

package/dist/chunk-U7LF3GN4.js

@@ -0,0 +1,34 @@
+// src/render-data.ts
+var SPREAD_ROOTS = {
+  parties: true,
+  signatories: true,
+  annexes: true,
+  defs: true
+};
+var RENDER_DATA_ROOTS = /* @__PURE__ */ new Set([
+  ...Object.keys(SPREAD_ROOTS),
+  "_signers",
+  "_captures"
+]);
+function flattenRenderData(data) {
+  const { fields, signers, captures, ...rest } = data;
+  return {
+    fields,
+    ...rest,
+    ...signers ? { _signers: signers } : {},
+    ...captures ? { _captures: captures } : {}
+  };
+}
+function requestRenderData(request) {
+  if (request.kind !== "form") return { data: {} };
+  const fields = request.data?.fields;
+  if (fields === null || typeof fields !== "object" || Array.isArray(fields)) {
+    throw new TypeError("A form render request needs FormData: its data must hold a `fields` record.");
+  }
+  return { data: flattenRenderData(request.data), form: request.artifact };
+}
+
+export {
+  RENDER_DATA_ROOTS,
+  requestRenderData
+};

package/dist/context-BmjDcc_j.d.ts

@@ -0,0 +1,32 @@
+import { EvaluationContext, HostFunction, FnSignature } from '@asterdoc/expr';
+
+/**
+ * The expression context a template reads, and where its paths sit in the
+ * render data.
+ *
+ * Roots are those of every other artifact expression: `fields`, computed
+ * values by name, `parties`, and `items` for a checklist. An artifact runtime
+ * hands over its own context; a direct render builds one from the data. A
+ * printed path may also name an attachment as `annexes.<slot>`.
+ */
+
+/**
+ * How a renderer is told what template expressions can read and call.
+ *
+ * Its `context` is the one a render request carries in `ctx.expressions`
+ * (`RendererExpressions` from `@asterdoc/types`); the functions and their
+ * signatures come from the renderer's own options.
+ */
+interface TemplateExpressionOptions {
+    /**
+     * The artifact's expression context. `@asterdoc/core` supplies it, so a
+     * template sees exactly what field logic sees.
+     */
+    context?: EvaluationContext;
+    /** Host-configured functions, used when no context is supplied. */
+    functions?: Readonly<Record<string, HostFunction>>;
+    /** Signatures of the configured functions. A template cannot call a function it has no signature for. */
+    signatures?: readonly FnSignature[];
+}
+
+export type { TemplateExpressionOptions as T };

package/dist/docx.d.ts

@@ -0,0 +1,37 @@
+import { Form, Formatter, AsterdocRenderer, RendererLayer } from '@asterdoc/types';
+import { T as TemplateExpressionOptions } from './context-BmjDcc_j.js';
+import { D as DocxSignatureOptions } from './signatures-DPaL4gay.js';
+export { D as DocxCheckOptions, T as TemplateDiagnostic, a as TemplateError, b as TemplatePosition, c as checkDocxTemplate } from './check-BA5xdYgi.js';
+import '@asterdoc/expr';
+
+interface DocxRenderOptions {
+    cmdDelimiter?: [string, string];
+    processLineBreaks?: boolean;
+}
+interface RenderDocxOptions {
+    template: Uint8Array;
+    data: Record<string, unknown>;
+    form?: Form;
+    formatter?: Formatter;
+    signatureOptions?: DocxSignatureOptions;
+    options?: DocxRenderOptions;
+    /** The expression context and configured functions templates read. */
+    expressions?: TemplateExpressionOptions;
+    /** The layer key, named in template errors. */
+    layer?: string;
+}
+declare function renderDocx({ template, data, form, formatter, signatureOptions, options, expressions, layer, }: RenderDocxOptions): Promise<Uint8Array>;
+
+interface DocxRendererOptions {
+    formatter?: Formatter;
+    signatureOptions?: DocxSignatureOptions;
+    /** Configured functions templates can call when no artifact context is supplied. */
+    expressions?: Pick<TemplateExpressionOptions, 'functions' | 'signatures'>;
+}
+type DocxLayer = RendererLayer & {
+    type: 'docx';
+    content: Uint8Array;
+};
+declare function docxRenderer(options?: DocxRendererOptions): AsterdocRenderer<DocxLayer, Uint8Array>;
+
+export { type DocxRenderOptions, type DocxRendererOptions, DocxSignatureOptions, type RenderDocxOptions, docxRenderer, renderDocx };

package/dist/docx.js

@@ -0,0 +1,38 @@
+import {
+  TemplateError,
+  checkDocxTemplate,
+  renderDocx,
+  requestExpressions
+} from "./chunk-PNYKTSIT.js";
+import {
+  requestRenderData
+} from "./chunk-U7LF3GN4.js";
+import "./chunk-ICQLU4FL.js";
+import "./chunk-4QVR6LUY.js";
+
+// src/docx/renderer.ts
+import { defaultFormatter } from "@asterdoc/format";
+function docxRenderer(options = {}) {
+  const formatter = options.formatter ?? defaultFormatter;
+  return {
+    id: "docx",
+    render(request) {
+      const { data, form } = requestRenderData(request);
+      return renderDocx({
+        template: request.template.content,
+        data,
+        form,
+        formatter: request.ctx?.formatter ?? formatter,
+        signatureOptions: options.signatureOptions,
+        expressions: requestExpressions(options.expressions, request.ctx?.expressions),
+        layer: request.template.key
+      });
+    }
+  };
+}
+export {
+  TemplateError,
+  checkDocxTemplate,
+  docxRenderer,
+  renderDocx
+};

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { Formatter, FormatterProgressivePolicy, AsterdocRenderer, RendererLayer } from '@asterdoc/types';
+import { D as DocxSignatureOptions } from './signatures-DPaL4gay.js';
+import { P as PdfFont } from './layer-bindings-CFXyN7SM.js';
+export { L as LayerBindingsSpec, a as PdfBindingKeyError, b as PdfBindingPart, c as PdfBindingSyntaxError, p as parseBinding, r as resolveLayerBindings } from './layer-bindings-CFXyN7SM.js';
+import { T as TextSignatureOptions } from './signatures-cS3V0yR3.js';
+import { T as TemplateExpressionOptions } from './context-BmjDcc_j.js';
+import '@asterdoc/expr';
+
+/** Parse Asterdoc paths with object dots and zero-based list brackets. */
+declare function pathSegments(path: string): string[];
+declare function getPath(value: unknown, path: string): unknown;
+
+/** Options shared by the MIME-selected rendering engines. */
+interface CreateLayerRendererOptions {
+    formatter?: Formatter;
+    progressive?: FormatterProgressivePolicy;
+    textSignatureOptions?: TextSignatureOptions;
+    /** A font the PDF engine tries first, before the font a PDF layer declares. */
+    pdfFont?: PdfFont;
+    docxSignatureOptions?: DocxSignatureOptions;
+    /** Host-configured functions text and DOCX templates can call, with their signatures. */
+    expressions?: Pick<TemplateExpressionOptions, 'functions' | 'signatures'>;
+}
+/**
+ * Render a document layer with the engine selected from `template.mimeType`.
+ *
+ * The selected renderer is imported only when it is needed. Import a format
+ * subpath directly when an application needs format-specific operations.
+ */
+declare function createLayerRenderer(options?: CreateLayerRendererOptions): AsterdocRenderer<RendererLayer, string | Uint8Array>;
+
+export { type CreateLayerRendererOptions, PdfFont, createLayerRenderer, getPath, pathSegments };

package/dist/index.js

@@ -0,0 +1,69 @@
+import {
+  PdfBindingKeyError,
+  PdfBindingSyntaxError,
+  getPath,
+  parseBinding,
+  pathSegments,
+  resolveLayerBindings
+} from "./chunk-4QVR6LUY.js";
+
+// src/index.ts
+var DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+function unsupportedMimeType(template) {
+  const mimeType = template.mimeType ?? "(missing)";
+  throw new Error(
+    `Unsupported render layer MIME type: ${mimeType}. Use @asterdoc/render/text, @asterdoc/render/pdf, or @asterdoc/render/docx for an explicit renderer.`
+  );
+}
+function requireContent(template) {
+  if (template.content !== void 0) return;
+  const mimeType = template.mimeType ?? "(missing)";
+  throw new Error(
+    `Render layer of MIME type ${mimeType} carries no content. Layers that name their content instead of carrying it render through a renderer registered for their MIME type; pass one in the \`renderers\` option.`
+  );
+}
+function createLayerRenderer(options = {}) {
+  return {
+    id: "render-layer",
+    async render(request) {
+      const mimeType = request.template.mimeType?.toLowerCase();
+      if (mimeType === "text/plain" || mimeType === "text/markdown" || mimeType === "text/html") {
+        requireContent(request.template);
+        const { textRenderer } = await import("./text.js");
+        return textRenderer({
+          formatter: options.formatter,
+          progressive: options.progressive,
+          signatureOptions: options.textSignatureOptions,
+          expressions: options.expressions
+        }).render(request);
+      }
+      if (mimeType === "application/pdf") {
+        requireContent(request.template);
+        const { pdfRenderer } = await import("./pdf.js");
+        return pdfRenderer({
+          formatter: options.formatter,
+          font: options.pdfFont
+        }).render(request);
+      }
+      if (mimeType === DOCX_MIME_TYPE) {
+        requireContent(request.template);
+        const { docxRenderer } = await import("./docx.js");
+        return docxRenderer({
+          formatter: options.formatter,
+          signatureOptions: options.docxSignatureOptions,
+          expressions: options.expressions
+        }).render(request);
+      }
+      return unsupportedMimeType(request.template);
+    }
+  };
+}
+export {
+  PdfBindingKeyError,
+  PdfBindingSyntaxError,
+  createLayerRenderer,
+  getPath,
+  parseBinding,
+  pathSegments,
+  resolveLayerBindings
+};

package/dist/layer-bindings-CFXyN7SM.d.ts

@@ -0,0 +1,94 @@
+/**
+ * A minimal reader for TrueType-outline font programs: enough to map
+ * characters to glyphs, measure them, decide whether a glyph really draws
+ * something, and describe the font to a PDF reader. Nothing is shaped.
+ */
+/** Why a font program could not be used. */
+type FontProgramProblem = 'unreadable' | 'unsupported-format' | 'not-embeddable';
+
+/** A font program supplied to the PDF renderer, and the name its errors use for it. */
+interface PdfFont {
+    /** A TrueType-outline font program (.ttf, or .otf with TrueType outlines). */
+    bytes: Uint8Array;
+    /** Where the font came from, such as its path. Errors name the font by this. */
+    source: string;
+}
+/** Thrown when a supplied font cannot be used, naming its source. */
+declare class PdfFontError extends Error {
+    readonly source: string;
+    readonly problem: FontProgramProblem;
+    constructor(source: string, problem: FontProgramProblem, detail: string);
+}
+/** Measures text in a supplied font, the way filling and overlays draw it. */
+interface PdfFontMetrics {
+    /**
+     * True when filling or an overlay can draw every character of `text` in
+     * this font: each has a glyph that paints, and none is in a script that
+     * needs shaping.
+     */
+    canDraw(text: string): boolean;
+    /** The width of `text` in points at `size`, ignoring line breaks. */
+    width(text: string, size: number): number;
+}
+/**
+ * Metrics for a supplied font, so a caller can wrap or fall back before it
+ * draws overlay text with that font.
+ *
+ * @throws {PdfFontError} when the font cannot be used, naming its source.
+ */
+declare function pdfFontMetrics(font: PdfFont): PdfFontMetrics;
+
+/** The part of a layer that decides which bindings it fills with. */
+interface LayerBindingsSpec {
+    mimeType?: string;
+    bindings?: Record<string, string>;
+    bindingsFrom?: string;
+}
+/**
+ * The bindings a layer fills with: its own, or else those of the sibling layer
+ * its `bindingsFrom` names. The reference is one hop: the sibling's own
+ * `bindings`, never its `bindingsFrom`. Only bindings carry over; a layer's
+ * `format` is always its own.
+ *
+ * Only PDF layers have bindings, which map AcroForm field names to Asterdoc
+ * paths; any other layer, or a source that is not a PDF layer, gives none.
+ *
+ * Throws when `bindingsFrom` names a layer that does not exist.
+ */
+declare function resolveLayerBindings(layers: Record<string, LayerBindingsSpec>, layer: LayerBindingsSpec): Record<string, string> | undefined;
+/** One path a PDF binding value reads. */
+interface PdfBindingPart {
+    /** The path as the binding writes it, trimmed: `fields.name`, `ssn`. */
+    source: string;
+    /** Where the path sits in fill data, historically without the `fields` root. */
+    path: string;
+    /** The text after `:`, trimmed: the option a checkbox tests, or the one-based part a split binding fills. */
+    qualifier?: string;
+}
+/** A PDF binding value whose syntax no fill, extraction, or check can read. */
+declare class PdfBindingSyntaxError extends Error {
+    readonly binding: string;
+    constructor(binding: string, problem: string);
+}
+/**
+ * Parse a PDF binding value into the paths it reads. Fill, extraction, the fit
+ * check, and validation all read bindings through this one parser.
+ *
+ * - `name` or `fields.name` reads one path.
+ * - `status:married` tests an option; `ssn:2` fills the second hyphen-separated
+ *   part. Space around the `:` is ignored.
+ * - `city, state, zip` joins several whole values with `, `. A part of a joined
+ *   binding takes no qualifier.
+ *
+ * @throws {PdfBindingSyntaxError} for an empty part or qualifier, or a
+ * qualifier inside a joined binding.
+ */
+declare function parseBinding(binding: string): PdfBindingPart[];
+/** A PDF binding key that names no form field of the template. */
+declare class PdfBindingKeyError extends Error {
+    /** The binding keys the template has no field for. */
+    readonly keys: string[];
+    constructor(keys: string[], templateFields: string[]);
+}
+
+export { type FontProgramProblem as F, type LayerBindingsSpec as L, type PdfFont as P, PdfBindingKeyError as a, type PdfBindingPart as b, PdfBindingSyntaxError as c, PdfFontError as d, type PdfFontMetrics as e, pdfFontMetrics as f, parseBinding as p, resolveLayerBindings as r };