@lpdfio/lpdf 0.25.0 → 0.26.0

package/README.md

@@ -22,16 +22,16 @@ const engine = L.engine()
 const doc = L.document({ size: 'letter', margin: '48pt' }, [
     L.section(NoAttr, [
         L.layout(NoAttr, [
-            L.stack({ gap: '24pt' }, [
-                L.split(NoAttr, [
+            L.column({ gap: '24pt' }, [
+                L.row({ justify: 'between' }, [
                     L.text({ fontSize: '8pt', color: '#888888' }, ['ACME CORP']),
                     L.text({ fontSize: '22pt', bold: 'true' }, ['Project Proposal']),
                 ]),
                 L.divider({ thickness: 'xs' }),
                 L.text({ fontSize: '13pt', bold: 'true' }, ['Scope of Work']),
-                L.flank({ gap: '12pt', align: 'start' }, [
+                L.row({ gap: '12pt', align: 'start' }, [
                     L.text({ color: '#888888', width: '24pt' }, ['01']),
-                    L.text(NoAttr, ['Discovery & Research']),
+                    L.text({ width: 'fill' }, ['Discovery & Research']),
                 ]),
             ]),
         ]),

package/dist/L.d.ts

@@ -35,10 +35,8 @@ export declare const L: Readonly<{
     canvas: (_attrs: null, layers?: import("./canvas").LpdfCanvasLayerNode[]) => import("./kit").LpdfCanvasBlock;
     assets: (attrs: DocumentAssets) => DocumentAssets;
     tokens: (attrs: DocumentTokens) => DocumentTokens;
-    stack: (attrs: import("./attrs").StackAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
-    flank: (attrs: import("./attrs").FlankAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
-    split: (attrs: import("./attrs").SplitAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
-    cluster: (attrs: import("./attrs").ClusterAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    column: (attrs: import("./attrs").ColumnAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    row: (attrs: import("./attrs").RowAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
     grid: (attrs: import("./attrs").GridAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
     frame: (attrs: import("./attrs").FrameAttr | null, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
     link: (attrs: import("./attrs").LinkAttr, nodes?: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;

package/dist/L.js

@@ -43,10 +43,8 @@ exports.L = Object.freeze({
     assets: (attrs) => attrs,
     tokens: (attrs) => attrs,
     // ── Layout ────────────────────────────────────────────────────────────────
-    stack: layout_1.LpdfLayout.stack,
-    flank: layout_1.LpdfLayout.flank,
-    split: layout_1.LpdfLayout.split,
-    cluster: layout_1.LpdfLayout.cluster,
+    column: layout_1.LpdfLayout.column,
+    row: layout_1.LpdfLayout.row,
     grid: layout_1.LpdfLayout.grid,
     frame: layout_1.LpdfLayout.frame,
     link: layout_1.LpdfLayout.link,

package/dist/attrs.d.ts

@@ -2,7 +2,7 @@
  * Places children top to bottom, each at the full width, with gap between them. Can split across
  * pages between children.
  */
-export interface StackAttr {
+export interface ColumnAttr {
     font?: string;
     fontSize?: string;
     gap?: string;
@@ -33,55 +33,20 @@ export interface StackAttr {
     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;
     /**
-     * Where the box falls in the page flow. no: never split the box, and move it whole to the next
-     * page when it does not fit. break-before: start it on a new page. break-after: start the next
-     * sibling on a new page. keep-next: keep it on one page with the sibling that follows, moving
-     * both to the next page if that sibling would not fit. break-before, break-after and keep-next
-     * take effect on the children of layout; on a box inside another box they are not applied. no
-     * applies at any depth.
-     */
-    paginate?: 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.
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
      */
-    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.
+ * Children side by side, continuing on the next line when they run out of width. A child with width
+ * set to fill takes what its line leaves; justify set to between puts a line's first child at the
+ * left edge, its last at the right and the others evenly between. Splits across pages between
+ * lines.
  */
-export interface SplitAttr {
+export interface RowAttr {
     font?: string;
     fontSize?: string;
     gap?: string;
@@ -111,48 +76,12 @@ export interface SplitAttr {
     paginate?: string;
     debug?: string;
     align?: string;
+    justify?: 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;
-    /**
-     * Where the box falls in the page flow. no: never split the box, and move it whole to the next
-     * page when it does not fit. break-before: start it on a new page. break-after: start the next
-     * sibling on a new page. keep-next: keep it on one page with the sibling that follows, moving
-     * both to the next page if that sibling would not fit. break-before, break-after and keep-next
-     * take effect on the children of layout; on a box inside another box they are not applied. no
-     * applies at any depth.
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
      */
-    paginate?: string;
-    debug?: string;
-    align?: string;
-    justify?: string;
     width?: string;
 }
 /**
@@ -188,6 +117,11 @@ export interface GridAttr {
      */
     paginate?: string;
     debug?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     colWidth?: string;
     cols?: string;
@@ -224,6 +158,11 @@ export interface FrameAttr {
      */
     paginate?: string;
     debug?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
 }
 /**
@@ -236,6 +175,11 @@ export interface LinkAttr {
      */
     href: string;
     gap?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     height?: string;
     debug?: string;
@@ -247,6 +191,12 @@ export interface DividerAttr {
     direction?: string;
     color?: string;
     thickness?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
+    width?: string;
     debug?: string;
 }
 /**
@@ -270,6 +220,11 @@ export interface SpanAttr {
 export interface ImgAttr {
     name: string;
     height?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     font?: string;
     fontSize?: string;
@@ -288,6 +243,11 @@ export interface BarcodeAttr {
     type: string;
     data: string;
     size?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     height?: string;
     ec?: string;
@@ -312,6 +272,11 @@ export interface TextAttr {
     bold?: string;
     color?: string;
     align?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     /**
      * The fewest lines of the text that may stand alone at the top of the next page when it splits.
@@ -390,6 +355,11 @@ export interface TableAttr {
     gap?: string;
     padding?: string;
     background?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     height?: string;
     paginate?: string;
@@ -410,6 +380,11 @@ export interface FieldAttr {
     readonly?: string;
     maxLen?: string;
     actionUrl?: string;
+    /**
+     * Width of the element. A length fixes it. fill, in a row, takes the width its line leaves after
+     * the other children, shared equally if several on the line use fill, and never moves to the next
+     * line; in a column it takes the full width.
+     */
     width?: string;
     height?: string;
     background?: string;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export type { EncryptPermissions, EncryptOptions } from './engine';
 export type { RenderOptions, EngineOptions } from './_shared';
 export { FieldType, Pin, Orientation, SectionType, BuiltinFont, PageScope } from './constants';
 export type { PdfDocument, LpdfSectionNode, LpdfLayoutBlock, LpdfCanvasBlock, DocumentTokens, DocumentAssets, DocumentMeta, SectionAttr, DocumentAttr, } from './kit';
-export type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, FieldAttr, BookmarkAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, CanvasTextAttr, CanvasImgAttr, FontAttr, ImageAttr, } from './attrs';
+export type { ColumnAttr, RowAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, FieldAttr, BookmarkAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, CanvasTextAttr, CanvasImgAttr, FontAttr, ImageAttr, } from './attrs';
 export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, LpdfBookmarkNode, } from './layout';
 export { CanvasTransform } from './canvas';
 export type { LpdfCanvasLayerNode, LpdfCanvasPrimitiveNode, LpdfCanvasRectNode, LpdfCanvasLineNode, LpdfCanvasEllipseNode, LpdfCanvasCircleNode, LpdfCanvasPathNode, LpdfCanvasTextNode, LpdfCanvasImgNode, } from './canvas';

package/dist/layout.d.ts

@@ -1,11 +1,11 @@
-import type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, FieldAttr, RegionAttr, BookmarkAttr } from './attrs';
+import type { ColumnAttr, RowAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, FieldAttr, RegionAttr, BookmarkAttr } from './attrs';
 export interface LpdfSpanNode {
     type: 'span';
     attrs: Record<string, string>;
     nodes: string[];
 }
 export interface LpdfContainerNode {
-    type: 'stack' | 'flank' | 'split' | 'cluster' | 'grid' | 'frame' | 'link';
+    type: 'column' | 'row' | 'grid' | 'frame' | 'link';
     attrs: Record<string, string>;
     nodes: LpdfNode[];
 }
@@ -61,10 +61,8 @@ export interface LpdfBookmarkNode {
     attrs: Record<string, string>;
 }
 export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode | LpdfFieldNode | LpdfBookmarkNode;
-declare function stack(attrs: StackAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
-declare function flank(attrs: FlankAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
-declare function split(attrs: SplitAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
-declare function cluster(attrs: ClusterAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
+declare function column(attrs: ColumnAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
+declare function row(attrs: RowAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
 declare function grid(attrs: GridAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
 declare function frame(attrs: FrameAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
 declare function link(attrs: LinkAttr, nodes?: LpdfNode[]): LpdfContainerNode;
@@ -85,10 +83,8 @@ declare function field(attrs: FieldAttr): LpdfFieldNode;
  */
 declare function bookmark(attrs: BookmarkAttr): LpdfBookmarkNode;
 export declare const LpdfLayout: Readonly<{
-    stack: typeof stack;
-    flank: typeof flank;
-    split: typeof split;
-    cluster: typeof cluster;
+    column: typeof column;
+    row: typeof row;
     grid: typeof grid;
     frame: typeof frame;
     link: typeof link;

package/dist/layout.js

@@ -7,17 +7,11 @@ function makeContainer(type, attrs, nodes) {
     return { type, attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
 // ── LpdfLayout factory ────────────────────────────────────────────────────────
-function stack(attrs, nodes = []) {
-    return makeContainer('stack', attrs, nodes);
+function column(attrs, nodes = []) {
+    return makeContainer('column', attrs, nodes);
 }
-function flank(attrs, nodes = []) {
-    return makeContainer('flank', attrs, nodes);
-}
-function split(attrs, nodes = []) {
-    return makeContainer('split', attrs, nodes);
-}
-function cluster(attrs, nodes = []) {
-    return makeContainer('cluster', attrs, nodes);
+function row(attrs, nodes = []) {
+    return makeContainer('row', attrs, nodes);
 }
 function grid(attrs, nodes = []) {
     return makeContainer('grid', attrs, nodes);
@@ -69,10 +63,8 @@ function bookmark(attrs) {
     return { type: 'bookmark', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
 exports.LpdfLayout = Object.freeze({
-    stack,
-    flank,
-    split,
-    cluster,
+    column,
+    row,
     grid,
     frame,
     link,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Node.js SDK for Lpdf — PDF as Code on every platform. You describe a document as code or XML. Lpdf renders a compact, pixel-perfect PDF — identical across platforms.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",