@lpdfio/lpdf 0.21.0 → 0.23.0

package/dist/attrs.d.ts

@@ -0,0 +1,493 @@
+/**
+ * Places children top to bottom, each at the full width, with gap between them. Can split across
+ * pages between children.
+ */
+export interface StackAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    align?: string;
+    justify?: string;
+    width?: string;
+}
+/**
+ * One row where the children keep their own width except one, which fills the rest. By default the
+ * last child fills; set end to true and the first fills. Never splits across pages.
+ */
+export interface FlankAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    align?: string;
+    /**
+     * false (the default): every child but the last keeps its own width at the left, and the last
+     * fills the rest. true: the first child fills, and the others keep their own width at the right.
+     */
+    end?: string;
+    width?: string;
+}
+/**
+ * Two children side by side; any further children are ignored. By default each keeps its own width,
+ * the first at the left edge and the second at the right. With equal set to true they take half the
+ * width each. Never splits across pages.
+ */
+export interface SplitAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    align?: string;
+    /**
+     * false (the default): each child keeps its own width, the first at the left edge and the second
+     * at the right edge. true: the two children share the width in equal halves.
+     */
+    equal?: string;
+    width?: string;
+}
+/**
+ * A row that wraps: children sit side by side, and continue on the next line when they run out of
+ * width. Splits across pages between lines.
+ */
+export interface ClusterAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    align?: string;
+    justify?: string;
+    width?: string;
+}
+/**
+ * Fills a fixed number of equal columns from left to right, then starts a new row. A row never
+ * splits across pages. For data with a header row, use table.
+ */
+export interface GridAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    width?: string;
+    colWidth?: string;
+    cols?: string;
+}
+/**
+ * A box around a single child, which it centres. Never splits across pages: if it does not fit, the
+ * whole box moves to the next page.
+ */
+export interface FrameAttr {
+    font?: string;
+    fontSize?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    width?: string;
+}
+/**
+ * Attributes of the `link` element.
+ */
+export interface LinkAttr {
+    href: string;
+    gap?: string;
+    width?: string;
+    height?: string;
+    debug?: string;
+}
+/**
+ * Attributes of the `divider` element.
+ */
+export interface DividerAttr {
+    direction?: string;
+    color?: string;
+    thickness?: string;
+    debug?: string;
+}
+/**
+ * Attributes of the `span` element.
+ */
+export interface SpanAttr {
+    font?: string;
+    bold?: string;
+    color?: string;
+    href?: string;
+    underline?: string;
+    strike?: string;
+}
+/**
+ * Attributes of the `img` element.
+ */
+export interface ImgAttr {
+    name: string;
+    height?: string;
+    width?: string;
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    padding?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+}
+/**
+ * Attributes of the `barcode` element.
+ */
+export interface BarcodeAttr {
+    type: string;
+    data: string;
+    size?: string;
+    width?: string;
+    height?: string;
+    ec?: string;
+    hrt?: string;
+    color?: string;
+    background?: string;
+    debug?: string;
+}
+/**
+ * A block of wrapping text. Use span children to style parts of it. Splits across pages between
+ * lines.
+ */
+export interface TextAttr {
+    fontSize?: string;
+    font?: string;
+    /**
+     * Use the bold face of the font. It applies to the 14 built-in fonts: Helvetica becomes
+     * Helvetica-Bold, Times-Roman becomes Times-Bold, Courier becomes Courier-Bold, and the oblique
+     * and italic faces their bold forms. A custom font has no bold face to pick, so name one in font.
+     */
+    bold?: string;
+    color?: string;
+    align?: string;
+    width?: string;
+    debug?: string;
+}
+/**
+ * Attributes of the `td` element.
+ */
+export interface TdAttr {
+    font?: string;
+    fontSize?: string;
+    gap?: string;
+    /**
+     * Space between the edge of the box and its content, written like CSS: one value for all sides,
+     * two for top-bottom and left-right, three for top, left-right and bottom, four for top, right,
+     * bottom and left.
+     */
+    padding?: string;
+    /**
+     * Height of the box. Leave it out to size to the content. A length fixes it; fill takes what is
+     * left after its siblings (shared equally if several use fill); full takes all the height
+     * available. Any of these stops the box splitting across pages.
+     */
+    height?: string;
+    background?: string;
+    border?: string;
+    radius?: string;
+    debug?: string;
+    align?: string;
+    valign?: string;
+}
+/**
+ * Attributes of the `thead` element.
+ */
+export interface TheadAttr {
+    background?: string;
+}
+/**
+ * Attributes of the `tr` element.
+ */
+export interface TrAttr {
+    background?: string;
+}
+/**
+ * Rows and cells in columns whose widths are set by cols. The thead row repeats at the top of every
+ * page, and rows move between pages whole.
+ */
+export interface TableAttr {
+    /**
+     * Column widths, separated by spaces, in fr, pt or % units: for example 2fr 1fr 120pt 20%.
+     */
+    cols: string;
+    border?: string;
+    stripe?: string;
+    gap?: string;
+    padding?: string;
+    background?: string;
+    width?: string;
+    height?: string;
+    debug?: string;
+}
+/**
+ * Attributes of the `field` element.
+ */
+export interface FieldAttr {
+    type: string;
+    name: string;
+    value?: string;
+    label?: string;
+    options?: string;
+    group?: string;
+    checked?: string;
+    required?: string;
+    readonly?: string;
+    maxLen?: string;
+    actionUrl?: string;
+    width?: string;
+    height?: string;
+    background?: string;
+    border?: string;
+    debug?: string;
+}
+/**
+ * Pins content to the top or bottom edge of pages, outside the normal flow, for headers and
+ * footers. It reserves that space on every page it appears on. Only allowed directly inside layout,
+ * and one per pin on a page.
+ */
+export interface RegionAttr {
+    /**
+     * Which edge the region sticks to. top and bottom work. left and right pass validation but are
+     * not implemented yet.
+     */
+    pin: string;
+    /**
+     * Which pages show the region: each, first, last, odd, even, or a range such as 2-last. Defaults
+     * to each.
+     */
+    page?: string;
+    w?: string;
+    debug?: string;
+}
+/**
+ * Groups canvas shapes and sets what applies to all of them: which pages they appear on, opacity,
+ * transform and clip. Layers cannot be nested.
+ */
+export interface LayerAttr {
+    page?: string;
+    opacity?: string;
+    transform?: string;
+    clip?: string;
+}
+/**
+ * Attributes of the `rect` element on the canvas.
+ */
+export interface RectAttr {
+    w: string;
+    h: string;
+    x?: string;
+    y?: string;
+    anchor?: string;
+    radius?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: string;
+    strokeDash?: string;
+    opacity?: string;
+}
+/**
+ * Attributes of the `circle` element on the canvas.
+ */
+export interface CircleAttr {
+    r: string;
+    cx?: string;
+    cy?: string;
+    anchor?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: string;
+    strokeDash?: string;
+    opacity?: string;
+}
+/**
+ * Attributes of the `ellipse` element on the canvas.
+ */
+export interface EllipseAttr {
+    rx: string;
+    ry: string;
+    cx?: string;
+    cy?: string;
+    anchor?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: string;
+    strokeDash?: string;
+    opacity?: string;
+}
+/**
+ * Attributes of the `line` element on the canvas.
+ */
+export interface LineAttr {
+    x1: string;
+    y1: string;
+    x2: string;
+    y2: string;
+    stroke?: string;
+    strokeWidth?: string;
+    strokeDash?: string;
+    lineCap?: string;
+}
+/**
+ * Attributes of the `path` element on the canvas.
+ */
+export interface PathAttr {
+    d: string;
+    fill?: string;
+    stroke?: string;
+    fillRule?: string;
+    strokeWidth?: string;
+    strokeDash?: string;
+    lineCap?: string;
+    opacity?: string;
+}
+/**
+ * Text at an exact position on the page: either x and y, or an anchor with optional offsets.
+ */
+export interface CanvasTextAttr {
+    x?: string;
+    y?: string;
+    anchor?: string;
+    font?: string;
+    fontSize?: string;
+    color?: string;
+    align?: string;
+    w?: string;
+    lineHeight?: string;
+    opacity?: string;
+}
+/**
+ * Attributes of the `img` element on the canvas.
+ */
+export interface CanvasImgAttr {
+    name: string;
+    w: string;
+    h: string;
+    x?: string;
+    y?: string;
+    anchor?: string;
+}
+/**
+ * Declares a font that text can be set in by name, with the font attribute. A built-in PDF font is
+ * named by core; any other font is a file the SDK reads from src, or one loaded on the engine under
+ * ref or, with no ref, under the font's own name.
+ */
+export interface FontAttr {
+    /**
+     * The name that the font attribute of a text uses to pick this font: lowercase letters, digits
+     * and -, starting with a letter.
+     */
+    name: string;
+    /** A built-in PDF font, which needs no file. */
+    core?: string;
+    /** The key the font was loaded under on the engine, when that is not its name. */
+    ref?: string;
+    /**
+     * A path the SDK reads the font file from, when the font was not loaded on the engine.
+     */
+    src?: string;
+}
+/**
+ * Declares an image that an img refers to by name. The SDK reads the file from src, or the image
+ * was loaded on the engine under ref or, with no ref, under its own name.
+ */
+export interface ImageAttr {
+    /**
+     * The name that the name attribute of an img uses to pick this image: lowercase letters, digits
+     * and -, starting with a letter.
+     */
+    name: string;
+    /** The key the image was loaded under on the engine, when that is not its name. */
+    ref?: string;
+    /**
+     * A path the SDK reads the image file from, when the image was not loaded on the engine.
+     */
+    src?: string;
+}

package/dist/attrs.js

@@ -0,0 +1,4 @@
+"use strict";
+// Generated from lpdf.xsd by scripts/gen-sdk-api.mjs.
+// Do not edit: change the schema and run `make gen-sdk-api`.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser.js

@@ -392,6 +392,48 @@ async function __wbg_init(module_or_path) {
   return __wbg_finalize_init(instance, module);
 }
 
+// src/constants.ts
+var FieldType = {
+  Text: "text",
+  Checkbox: "checkbox",
+  Dropdown: "dropdown",
+  Radio: "radio",
+  Button: "button"
+};
+var Pin = {
+  Top: "top",
+  Bottom: "bottom",
+  Left: "left",
+  Right: "right"
+};
+var Orientation = {
+  Portrait: "portrait",
+  Landscape: "landscape"
+};
+var BuiltinFont = {
+  Courier: "Courier",
+  CourierBold: "Courier-Bold",
+  CourierOblique: "Courier-Oblique",
+  CourierBoldOblique: "Courier-BoldOblique",
+  Helvetica: "Helvetica",
+  HelveticaBold: "Helvetica-Bold",
+  HelveticaOblique: "Helvetica-Oblique",
+  HelveticaBoldOblique: "Helvetica-BoldOblique",
+  TimesRoman: "Times-Roman",
+  TimesBold: "Times-Bold",
+  TimesItalic: "Times-Italic",
+  TimesBoldItalic: "Times-BoldItalic",
+  Symbol: "Symbol",
+  ZapfDingbats: "ZapfDingbats"
+};
+var PageScope = {
+  Each: "each",
+  First: "first",
+  Last: "last",
+  Odd: "odd",
+  Even: "even"
+};
+
 // src/browser.ts
 var NoAttr = null;
 function nowUnix() {
@@ -443,6 +485,11 @@ async function initLpdf(wasmSource, licenseKey = "") {
   };
 }
 export {
+  BuiltinFont,
+  FieldType,
   NoAttr,
+  Orientation,
+  PageScope,
+  Pin,
   initLpdf
 };

package/dist/canvas.d.ts

@@ -1,57 +1,9 @@
-import type { PageScope } from './_shared';
-export type TextAlign = 'left' | 'center' | 'right' | 'justify';
-export type LineCap = 'butt' | 'round' | 'square';
-export type LineJoin = 'miter' | 'round' | 'bevel';
-export interface CanvasRectStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    borderRadius?: number;
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasLineStyle {
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    lineCap?: LineCap;
-    lineJoin?: LineJoin;
-}
-export interface CanvasEllipseStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasPathStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    fillRuleEvenodd?: boolean;
-    lineCap?: LineCap;
-    lineJoin?: LineJoin;
-    opacity?: number;
-}
-export interface CanvasTextStyle {
-    font?: string;
-    size?: number;
-    color?: string;
-    align?: TextAlign;
-    lineHeight?: number;
-    width?: number;
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasRun {
-    text: string;
-    font?: string;
-    size?: number;
-    color?: string;
-}
+import type { RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, CanvasTextAttr, CanvasImgAttr, LayerAttr } from './attrs';
+import type { LpdfSpanNode } from './layout';
+/**
+ * Builds the `transform` string of a layer. `String(CanvasTransform.rotate(45))` is
+ * `matrix(...)`, which a layer's `transform` attribute accepts like `rotate(45)`.
+ */
 export declare class CanvasTransform {
     readonly matrix: number[];
     constructor(matrix: number[]);
@@ -66,67 +18,52 @@ export declare class CanvasTransform {
      * Equivalent to matrix multiplication: this × other.
      */
     then(other: CanvasTransform): CanvasTransform;
-    /** Serialise to the `"matrix(a,b,c,d,e,f)"` string form that Rust `jattr()` reads. */
+    /** The `"matrix(a,b,c,d,e,f)"` form of the transform. */
     toString(): string;
 }
 export interface LpdfCanvasRectNode {
-    type: 'canvas-rect';
+    type: 'rect';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasLineNode {
-    type: 'canvas-line';
+    type: 'line';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasEllipseNode {
-    type: 'canvas-ellipse';
+    type: 'ellipse';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasCircleNode {
-    type: 'canvas-circle';
+    type: 'circle';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasPathNode {
-    type: 'canvas-path';
+    type: 'path';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasTextNode {
-    type: 'canvas-text';
-    text: string;
+    type: 'text';
     attrs: Record<string, string>;
-    runs?: {
-        text: string;
-        attrs: {
-            font?: string;
-            'font-size'?: string;
-            color?: string;
-        };
-    }[];
+    nodes: (string | LpdfSpanNode)[];
 }
 export interface LpdfCanvasImgNode {
-    type: 'canvas-img';
+    type: 'img';
     attrs: Record<string, string>;
 }
 export type LpdfCanvasPrimitiveNode = LpdfCanvasRectNode | LpdfCanvasLineNode | LpdfCanvasEllipseNode | LpdfCanvasCircleNode | LpdfCanvasPathNode | LpdfCanvasTextNode | LpdfCanvasImgNode;
-/** @deprecated Use {@link LayerAttr} */
-export type CanvasLayerOptions = LayerAttr;
-export interface LayerAttr {
-    page?: PageScope | string;
-    opacity?: number;
-    transform?: CanvasTransform;
-}
 export interface LpdfCanvasLayerNode {
-    type: 'canvas-layer';
+    type: 'layer';
     attrs: Record<string, string>;
     nodes: LpdfCanvasPrimitiveNode[];
 }
-declare function rect(x: number, y: number, w: number, h: number, style?: CanvasRectStyle): LpdfCanvasRectNode;
-declare function line(x1: number, y1: number, x2: number, y2: number, style?: CanvasLineStyle): LpdfCanvasLineNode;
-declare function ellipse(cx: number, cy: number, rx: number, ry: number, style?: CanvasEllipseStyle): LpdfCanvasEllipseNode;
-declare function circle(cx: number, cy: number, r: number, style?: CanvasEllipseStyle): LpdfCanvasCircleNode;
-declare function path(d: string, style?: CanvasPathStyle): LpdfCanvasPathNode;
-declare function textAt(x: number, y: number, content: string, style?: CanvasTextStyle, runs?: CanvasRun[]): LpdfCanvasTextNode;
-declare function imgAt(x: number, y: number, w: number, h: number, name: string, anchor?: string): LpdfCanvasImgNode;
-declare function layer(attrs: LayerAttr | null, nodes: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;
+declare function rect(attrs: RectAttr): LpdfCanvasRectNode;
+declare function line(attrs: LineAttr): LpdfCanvasLineNode;
+declare function ellipse(attrs: EllipseAttr): LpdfCanvasEllipseNode;
+declare function circle(attrs: CircleAttr): LpdfCanvasCircleNode;
+declare function path(attrs: PathAttr): LpdfCanvasPathNode;
+declare function textAt(attrs: CanvasTextAttr, nodes?: (string | LpdfSpanNode)[]): LpdfCanvasTextNode;
+declare function imgAt(attrs: CanvasImgAttr): LpdfCanvasImgNode;
+declare function layer(attrs: LayerAttr | null, nodes?: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;
 export declare const LpdfCanvas: Readonly<{
     rect: typeof rect;
     line: typeof line;