@lpdfio/lpdf 0.6.0 → 0.8.0

package/dist/layout.d.ts

@@ -1,5 +1,5 @@
 import type { PageScope } from './_shared';
-export interface StackOptions {
+export interface StackAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -11,7 +11,7 @@ export interface StackOptions {
     radius?: string;
     debug?: string;
 }
-export interface FlankOptions {
+export interface FlankAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -24,7 +24,7 @@ export interface FlankOptions {
     radius?: string;
     debug?: string;
 }
-export interface SplitOptions {
+export interface SplitAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -36,7 +36,7 @@ export interface SplitOptions {
     radius?: string;
     debug?: string;
 }
-export interface ClusterOptions {
+export interface ClusterAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -48,7 +48,7 @@ export interface ClusterOptions {
     radius?: string;
     debug?: string;
 }
-export interface GridOptions {
+export interface GridAttr {
     cols?: string;
     colWidth?: string;
     gap?: string;
@@ -61,7 +61,7 @@ export interface GridOptions {
     radius?: string;
     debug?: string;
 }
-export interface FrameOptions {
+export interface FrameAttr {
     width?: string;
     height?: string;
     padding?: string;
@@ -71,13 +71,14 @@ export interface FrameOptions {
     align?: string;
     debug?: string;
 }
-export interface LinkOptions {
+export interface LinkAttr {
     url?: string;
+    gap?: string;
     width?: string;
     height?: string;
     debug?: string;
 }
-export interface TableOptions {
+export interface TableAttr {
     cols: string;
     border?: string;
     stripe?: string;
@@ -89,13 +90,13 @@ export interface TableOptions {
     repeat?: string;
     debug?: string;
 }
-export interface TheadOptions {
+export interface TheadAttr {
     background?: string;
 }
-export interface TrOptions {
+export interface TrAttr {
     background?: string;
 }
-export interface TdOptions {
+export interface TdAttr {
     padding?: string;
     background?: string;
     align?: string;
@@ -105,7 +106,7 @@ export interface TdOptions {
     gap?: string;
     debug?: string;
 }
-export interface TextOptions {
+export interface TextAttr {
     font?: string;
     fontSize?: string;
     textAlign?: string;
@@ -121,7 +122,7 @@ export interface TextOptions {
     repeat?: string;
     debug?: string;
 }
-export interface SpanOptions {
+export interface SpanAttr {
     font?: string;
     fontSize?: string;
     color?: string;
@@ -130,13 +131,13 @@ export interface SpanOptions {
     underline?: string;
     strike?: string;
 }
-export interface DividerOptions {
+export interface DividerAttr {
     color?: string;
     thickness?: string;
     direction?: string;
     debug?: string;
 }
-export interface ImgOptions {
+export interface ImgAttr {
     name: string;
     height?: string;
     width?: string;
@@ -150,7 +151,7 @@ export interface ImgOptions {
     repeat?: string;
     debug?: string;
 }
-export interface BarcodeOptions {
+export interface BarcodeAttr {
     type: string;
     data: string;
     size?: string;
@@ -163,7 +164,22 @@ export interface BarcodeOptions {
     repeat?: string;
     debug?: string;
 }
-export interface RegionOptions {
+export interface FieldAttr {
+    label?: string;
+    value?: string;
+    options?: string;
+    group?: string;
+    checked?: string;
+    required?: string;
+    readonly?: string;
+    maxLen?: string;
+    actionUrl?: string;
+    width?: string;
+    height?: string;
+    debug?: string;
+}
+export interface RegionAttr {
+    pin: string;
     page?: PageScope | string;
     w?: string;
     debug?: string;
@@ -220,24 +236,29 @@ export interface LpdfRegionNode {
     attrs: Record<string, string>;
     nodes: LpdfNode[];
 }
-export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode;
-declare function stack(nodes?: LpdfNode[], options?: StackOptions): LpdfContainerNode;
-declare function flank(nodes?: LpdfNode[], options?: FlankOptions): LpdfContainerNode;
-declare function split(nodes?: LpdfNode[], options?: SplitOptions): LpdfContainerNode;
-declare function cluster(nodes?: LpdfNode[], options?: ClusterOptions): LpdfContainerNode;
-declare function grid(nodes?: LpdfNode[], options?: GridOptions): LpdfContainerNode;
-declare function frame(nodes?: LpdfNode[], options?: FrameOptions): LpdfContainerNode;
-declare function link(nodes?: LpdfNode[], options?: LinkOptions): LpdfContainerNode;
-declare function table(options: TableOptions, nodes?: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
-declare function thead(nodes?: LpdfTdNode[], options?: TheadOptions): LpdfTheadNode;
-declare function tr(nodes?: LpdfTdNode[], options?: TrOptions): LpdfTrNode;
-declare function td(nodes?: LpdfNode[], options?: TdOptions): LpdfTdNode;
-declare function text(nodes?: (string | LpdfSpanNode)[], options?: TextOptions): LpdfTextNode;
-declare function span(nodes?: string[], options?: SpanOptions): LpdfSpanNode;
-declare function divider(options?: DividerOptions): LpdfDividerNode;
-declare function img(options: ImgOptions): LpdfImgNode;
-declare function barcode(options: BarcodeOptions): LpdfBarcodeNode;
-declare function region(pin: string, nodes?: LpdfNode[], options?: RegionOptions): LpdfRegionNode;
+export interface LpdfFieldNode {
+    type: 'field';
+    attrs: Record<string, string>;
+}
+export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode | LpdfFieldNode;
+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 grid(attrs: GridAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function frame(attrs: FrameAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function link(attrs: LinkAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function table(attrs: TableAttr, nodes: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
+declare function thead(attrs: TheadAttr | null, nodes: LpdfTdNode[]): LpdfTheadNode;
+declare function tr(attrs: TrAttr | null, nodes: LpdfTdNode[]): LpdfTrNode;
+declare function td(attrs: TdAttr | null, nodes: LpdfNode[]): LpdfTdNode;
+declare function text(attrs: TextAttr | null, nodes: (string | LpdfSpanNode)[]): LpdfTextNode;
+declare function span(attrs: SpanAttr | null, nodes: string[]): LpdfSpanNode;
+declare function divider(attrs: DividerAttr | null): LpdfDividerNode;
+declare function img(attrs: ImgAttr): LpdfImgNode;
+declare function barcode(attrs: BarcodeAttr): LpdfBarcodeNode;
+declare function region(attrs: RegionAttr, nodes: LpdfNode[]): LpdfRegionNode;
+declare function field(type: string, name: string, attrs?: FieldAttr | null): LpdfFieldNode;
 export declare const LpdfLayout: Readonly<{
     stack: typeof stack;
     flank: typeof flank;
@@ -256,5 +277,6 @@ export declare const LpdfLayout: Readonly<{
     tr: typeof tr;
     td: typeof td;
     region: typeof region;
+    field: typeof field;
 }>;
 export {};

package/dist/layout.js

@@ -15,100 +15,106 @@ function buildAttrs(options) {
     return result;
 }
 // ── Helper ────────────────────────────────────────────────────────────────────
-function makeContainer(type, nodes, options) {
-    return { type, attrs: buildAttrs(options ?? {}), nodes };
+function makeContainer(type, attrs, nodes) {
+    return { type, attrs: buildAttrs(attrs ?? {}), nodes };
 }
 // ── LpdfLayout factory ────────────────────────────────────────────────────────
-function stack(nodes = [], options) {
-    return makeContainer('stack', nodes, options);
+function stack(attrs, nodes) {
+    return makeContainer('stack', attrs, nodes);
 }
-function flank(nodes = [], options) {
-    return makeContainer('flank', nodes, options);
+function flank(attrs, nodes) {
+    return makeContainer('flank', attrs, nodes);
 }
-function split(nodes = [], options) {
-    return makeContainer('split', nodes, options);
+function split(attrs, nodes) {
+    return makeContainer('split', attrs, nodes);
 }
-function cluster(nodes = [], options) {
-    return makeContainer('cluster', nodes, options);
+function cluster(attrs, nodes) {
+    return makeContainer('cluster', attrs, nodes);
 }
-function grid(nodes = [], options) {
-    return makeContainer('grid', nodes, options);
+function grid(attrs, nodes) {
+    return makeContainer('grid', attrs, nodes);
 }
-function frame(nodes = [], options) {
-    return makeContainer('frame', nodes, options);
+function frame(attrs, nodes) {
+    return makeContainer('frame', attrs, nodes);
 }
-function link(nodes = [], options) {
-    return makeContainer('link', nodes, options);
+function link(attrs, nodes) {
+    return makeContainer('link', attrs, nodes);
 }
-function table(options, nodes = []) {
+function table(attrs, nodes) {
     return {
         type: 'table',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
         nodes,
     };
 }
-function thead(nodes = [], options) {
+function thead(attrs, nodes) {
     return {
         type: 'thead',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function tr(nodes = [], options) {
+function tr(attrs, nodes) {
     return {
         type: 'tr',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function td(nodes = [], options) {
+function td(attrs, nodes) {
     return {
         type: 'td',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function text(nodes = [], options) {
+function text(attrs, nodes) {
     return {
         type: 'text',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function span(nodes = [], options) {
+function span(attrs, nodes) {
     return {
         type: 'span',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function divider(options) {
+function divider(attrs) {
     return {
         type: 'divider',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
     };
 }
-function img(options) {
+function img(attrs) {
     return {
         type: 'img',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function barcode(options) {
+function barcode(attrs) {
     return {
         type: 'barcode',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function region(pin, nodes = [], options) {
-    const attrs = { pin };
-    if (options?.page !== undefined)
-        attrs['page'] = options.page;
-    if (options?.w !== undefined)
-        attrs['w'] = options.w;
-    if (options?.debug !== undefined)
-        attrs['debug'] = options.debug;
-    return { type: 'layout-region', attrs, nodes };
+function region(attrs, nodes) {
+    const a = { pin: attrs.pin };
+    if (attrs.page !== undefined)
+        a['page'] = attrs.page;
+    if (attrs.w !== undefined)
+        a['w'] = attrs.w;
+    if (attrs.debug !== undefined)
+        a['debug'] = attrs.debug;
+    return { type: 'layout-region', attrs: a, nodes };
+}
+function field(type, name, attrs) {
+    const a = { type, name };
+    if (attrs)
+        Object.assign(a, buildAttrs(attrs));
+    return { type: 'field', attrs: a };
 }
 exports.LpdfLayout = Object.freeze({
     stack,
@@ -128,4 +134,5 @@ exports.LpdfLayout = Object.freeze({
     tr,
     td,
     region,
+    field,
 });

package/dist/wasm/lpdf-web.js

@@ -205,6 +205,79 @@ export class LpdfEngine {
 }
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 
+/**
+ * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
+ *
+ * Unlike `codegen_wasm`, this accepts a snippet without the `<lpdf>` wrapper and
+ * returns just the node expression(s) — no imports, no engine setup, no boilerplate.
+ * Ideal for documentation code examples where the same XML snippet should be shown
+ * in multiple target languages.
+ *
+ * `options_json` accepts the same shape as `codegen_wasm`:
+ * - `target`: `"js"`, `"dotnet"`, `"php"`, or `"python"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function codegen_fragment_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_fragment_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Generate SDK source code from an Lpdf XML string.
+ *
+ * `options_json` is a JSON object with:
+ * - `target`: `"js"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ *
+ * Returns the generated source code as a string.
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function codegen_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Convert a JSON kit-tree (produced by `LpdfKit` in any adapter) to an lpdf
  * XML string.

package/dist/wasm/lpdf.js

@@ -206,6 +206,81 @@ class LpdfEngine {
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 exports.LpdfEngine = LpdfEngine;
 
+/**
+ * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
+ *
+ * Unlike `codegen_wasm`, this accepts a snippet without the `<lpdf>` wrapper and
+ * returns just the node expression(s) — no imports, no engine setup, no boilerplate.
+ * Ideal for documentation code examples where the same XML snippet should be shown
+ * in multiple target languages.
+ *
+ * `options_json` accepts the same shape as `codegen_wasm`:
+ * - `target`: `"js"`, `"dotnet"`, `"php"`, or `"python"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+function codegen_fragment_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_fragment_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.codegen_fragment_wasm = codegen_fragment_wasm;
+
+/**
+ * Generate SDK source code from an Lpdf XML string.
+ *
+ * `options_json` is a JSON object with:
+ * - `target`: `"js"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ *
+ * Returns the generated source code as a string.
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+function codegen_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.codegen_wasm = codegen_wasm;
+
 /**
  * Convert a JSON kit-tree (produced by `LpdfKit` in any adapter) to an lpdf
  * XML string.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.6.0",
-  "description": "Node.js adapter for Lpdf — PDF as Code, on every platform. Describe your document structure in code using the programming Kit, or XML. Every PDF is compact, pixel-perfect, and identical across platforms.",
+  "version": "0.8.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",
   "exports": {