@campxdev/pdfme 1.1.0 → 1.2.0

package/dist/types/_vendors/schemas/dynamicTable/engine/stores/structure.store.d.ts

@@ -0,0 +1,39 @@
+import { IStructureStore } from "../interfaces";
+import { Region } from "../types";
+export declare class StructureStore implements IStructureStore {
+    private headerRoots;
+    private childrenMap;
+    private parentMap;
+    private body;
+    private footer;
+    constructor();
+    private setRegionStructure;
+    isLeafCell(cellId: string): boolean;
+    getLeafCells(cellId: string): string[];
+    getBodyIndexForHeaderLeafCell(region: Region, cellId: string): number;
+    private getTotalLeafCount;
+    getHeightOfCell(cellId: string): number;
+    getLeafCount(region: Region): number;
+    addRootCell(cellId: string, region: Region): void;
+    removeRootCell(cellId: string, region: Region): void;
+    getRoots(region: Region): readonly string[] | undefined;
+    addChildCell(parentId: string, region: Region, childId: string, index?: number): void;
+    getChildren(parentId: string): readonly string[] | undefined;
+    insertBodyRow(rowIndex: number, cellIds: string[]): void;
+    removeBodyRow(rowIndex: number): string[];
+    insertBodyCol(colIndex: number, cellIds: string[]): void;
+    removeBodyCol(colIndex: number): string[];
+    removeChildCell(parentId: string, childId: string, region: Region): void;
+    getBodyCell(rowIndex: number, colIndex: number): string | undefined;
+    getBody(): readonly (readonly string[])[];
+    countTotalCols(): number;
+    countTotalRows(): number;
+    reorderHeaderCell(region: Region, fromIndex: number, toIndex: number, withChildren?: boolean): void;
+    needsBodySliceForRegion(region: Region): boolean;
+    addFooterCell(rowIndex: number, cellId: string): void;
+    removeFooterCell(rowIndex: number, colIndex: number): string;
+    addFooterRow(cellId: string): void;
+    removeFooterRow(rowIndex: number): string[];
+    getFooter(): readonly (readonly string[])[];
+    getFooterCell(rowIndex: number, colIndex: number): string | undefined;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/styles/defaults.d.ts

@@ -0,0 +1,7 @@
+import type { CellStyle, TableStyle, RegionStyleMap } from '../types';
+/** Hardcoded baseline — every CellStyle property has a value */
+export declare const defaultCellStyle: CellStyle;
+/** Default table-level visual frame */
+export declare const defaultTableStyle: TableStyle;
+/** Default region styles (empty — all regions fall through to defaultCellStyle) */
+export declare const defaultRegionStyles: RegionStyleMap;

package/dist/types/_vendors/schemas/dynamicTable/engine/styles/index.d.ts

@@ -0,0 +1,2 @@
+export { defaultCellStyle, defaultTableStyle, defaultRegionStyles } from './defaults';
+export { resolveStyle } from './resolve';

package/dist/types/_vendors/schemas/dynamicTable/engine/styles/resolve.d.ts

@@ -0,0 +1,12 @@
+import type { CellStyle, RegionStyle } from '../types';
+/**
+ * Resolve a cell's final CellStyle through the three-level cascade:
+ *
+ *   1. defaultCellStyle        (hardcoded baseline)
+ *   2. regionStyle             (partial override from region)
+ *   3. cellOverrides           (partial override from cell)
+ *   4. rulePatches             (partial overrides from rules, applied in order)
+ *
+ * Returns a complete CellStyle with every property defined.
+ */
+export declare function resolveStyle(regionStyle?: RegionStyle, cellOverrides?: Partial<CellStyle>, ...rulePatches: (Partial<CellStyle> | undefined)[]): CellStyle;

package/dist/types/_vendors/schemas/dynamicTable/engine/types/common.d.ts

@@ -0,0 +1,138 @@
+export interface CellAddress {
+    rowNumber: number;
+    colNumber: number;
+}
+export interface CellLayout {
+    readonly row: number;
+    readonly col: number;
+    readonly rowSpan: number;
+    readonly colSpan: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface TablePosition {
+    x: number;
+    y: number;
+}
+export type Region = 'theader' | 'lheader' | 'rheader' | 'footer' | 'body';
+export type Spacing = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type Alignment = 'left' | 'center' | 'right' | 'justify';
+export type VerticalAlignment = 'top' | 'middle' | 'bottom';
+export interface CellStyle {
+    fontName?: string;
+    bold: boolean;
+    italic: boolean;
+    alignment: Alignment;
+    verticalAlignment: VerticalAlignment;
+    fontSize: number;
+    lineHeight: number;
+    characterSpacing: number;
+    fontColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: Spacing;
+    padding: Spacing;
+}
+/** @deprecated Use CellStyle instead */
+export type Style = CellStyle;
+/** Visual frame of the table (outer border, outline, corner radius) */
+export interface TableStyle {
+    borderColor?: string;
+    borderWidth?: Spacing;
+    outline?: {
+        color?: string;
+        width?: number;
+        style?: 'solid' | 'dashed' | 'dotted';
+    };
+    cornerRadius?: {
+        topLeft?: number;
+        topRight?: number;
+        bottomLeft?: number;
+        bottomRight?: number;
+    };
+}
+/** Per-region style defaults — same shape as CellStyle but fully optional */
+export type RegionStyle = Partial<CellStyle>;
+/** Body region gets an extra alternating row color property */
+export interface BodyRegionStyle extends RegionStyle {
+    alternateBackgroundColor?: string;
+}
+/** Map of region → style overrides */
+export type RegionStyleMap = {
+    theader?: RegionStyle;
+    lheader?: RegionStyle;
+    rheader?: RegionStyle;
+    footer?: RegionStyle;
+    body?: BodyRegionStyle;
+};
+/** @deprecated Use TableStyle instead */
+export interface TableStyles {
+    borderColor: string;
+    borderWidth: number;
+}
+/** @deprecated Use BodyRegionStyle instead */
+export interface BodyStyles extends CellStyle {
+    alternateBackgroundColor: string;
+}
+/** @deprecated No longer used — column alignment handled via region styles */
+export interface ColumnStyleOverrides {
+    alignment?: Record<number, Alignment>;
+}
+export type Rect = {
+    cellId: string;
+    startRow: number;
+    startCol: number;
+    endRow: number;
+    endCol: number;
+    primaryRegion?: Region;
+};
+export type CellPayload = {
+    inRegion?: Region;
+    rawValue?: string | number;
+    style?: Partial<CellStyle>;
+    overflow?: OverflowMode;
+    computedValue?: string | number;
+};
+export type OverflowMode = 'wrap' | 'increase-height' | 'increase-width';
+export type FooterPlacement = {
+    mode: 'every-page';
+} | {
+    mode: 'last-page';
+} | {
+    mode: 'first-page';
+};
+export interface HeaderVisibility {
+    theader?: boolean;
+    lheader?: boolean;
+    rheader?: boolean;
+}
+export interface TableSettings {
+    minRows?: number;
+    maxRows?: number;
+    minCols?: number;
+    maxCols?: number;
+    overflow?: OverflowMode;
+    footer?: FooterPlacement;
+    headerVisibility?: HeaderVisibility;
+    showGridLines?: boolean;
+    defaultCellWidth?: number;
+    defaultCellHeight?: number;
+}
+export type MergeMode = 'none' | 'selecting' | 'unmerging' | 'styling';
+export interface UIState {
+    editingCellId: string | null;
+    selectedCells: ReadonlySet<string>;
+    selectionAnchor: {
+        row: number;
+        col: number;
+        region: string;
+    } | null;
+    mergeMode: MergeMode;
+}

package/dist/types/_vendors/schemas/dynamicTable/engine/types/index.d.ts

@@ -0,0 +1 @@
+export type { CellAddress, CellLayout, TablePosition, Region, Style, CellStyle, Spacing, Alignment, VerticalAlignment, TableStyle, RegionStyle, BodyRegionStyle, RegionStyleMap, TableStyles, BodyStyles, ColumnStyleOverrides, CellPayload, OverflowMode, FooterPlacement, HeaderVisibility, TableSettings, Rect, UIState } from "./common";

package/dist/types/_vendors/schemas/dynamicTable/engine/types/rule-target.types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Rule target/selector types — identifies which cells a rule applies to.
+ * Discriminated union by scope type.
+ */
+export type RuleScope = 'table' | 'region' | 'column' | 'row' | 'cell' | 'selection';
+/**
+ * TableTarget — rule applies to every cell in every region.
+ * No additional selector needed.
+ */
+export interface TableTarget {
+    scope: 'table';
+}
+/**
+ * RegionTarget — rule applies to all cells in a named region.
+ * Region: 'theader' | 'lheader' | 'rheader' | 'footer' | 'body'
+ */
+export interface RegionTarget {
+    scope: 'region';
+    region: 'theader' | 'lheader' | 'rheader' | 'footer' | 'body';
+}
+/**
+ * ColumnTarget — rule applies to all body cells in one column.
+ * Identified by headerName (preferred, semantic) or colIndex (raw, fragile).
+ *
+ * headerName: the theader leaf cell's rawValue (user-friendly for canvas)
+ *   → engine resolves to colIndex via StructureStore.getBodyIndexForHeaderLeafCell()
+ *
+ * colIndex: 0-based absolute column index (fallback, used by programmatic rules)
+ *
+ * includeHeader: if true, also apply to the theader leaf cell itself (default false)
+ */
+export type ColumnTarget = {
+    scope: 'column';
+    headerName: string;
+    includeHeader?: boolean;
+} | {
+    scope: 'column';
+    colIndex: number;
+    includeHeader?: boolean;
+};
+/**
+ * RowTarget — rule applies to all cells in one body row (or header depth).
+ *
+ * region: default 'body'; for 'theader', rowIndex means tree depth level (0 = root)
+ *
+ * rowIndex: 0-based within that region
+ */
+export interface RowTarget {
+    scope: 'row';
+    rowIndex: number;
+    region?: 'theader' | 'body';
+}
+/**
+ * CellTarget — rule applies to exactly one cell.
+ *
+ * cellId (preferred): stable reference (UUID), works for header + body cells
+ *   → canvas click → engine returns cellId → rule stores cellId
+ *
+ * address: [rowIndex, colIndex] for body cells only; used by programmatic rules
+ */
+export type CellTarget = {
+    scope: 'cell';
+    cellId: string;
+} | {
+    scope: 'cell';
+    address: {
+        rowIndex: number;
+        colIndex: number;
+    };
+};
+/**
+ * SelectionTarget — rule applies to a rectangular selection of body cells.
+ *
+ * All bounds are 0-based body indices; endRow/endCol are inclusive.
+ */
+export interface SelectionTarget {
+    scope: 'selection';
+    rect: {
+        rowStart: number;
+        colStart: number;
+        rowEnd: number;
+        colEnd: number;
+    };
+}
+/**
+ * RuleTarget — discriminated union of all rule scope types.
+ * Identifies which cells a rule applies to.
+ */
+export type RuleTarget = TableTarget | RegionTarget | ColumnTarget | RowTarget | CellTarget | SelectionTarget;

package/dist/types/_vendors/schemas/dynamicTable/helpers/cellSchemaMapper.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Maps RenderableCell (our type) → PdfmeCellSchema (pdfme-compatible type).
+ *
+ * This is the bridge between our style system and pdfme's rendering system.
+ * Our CellStyle maps ~1:1 to pdfme's CellStyle / CellSchema.
+ */
+import type { RenderableCell } from '../engine/index.js';
+import type { PdfmeCellSchema } from '../types.js';
+/**
+ * Convert a RenderableCell to a PdfmeCellSchema for delegation to pdfme renderers.
+ *
+ * @param cell — The RenderableCell with fully resolved style and layout
+ * @param tableOffsetX — The table's X offset on the page/canvas (schema.position.x)
+ * @param tableOffsetY — The table's Y offset on the page/canvas (schema.position.y)
+ */
+export declare function toPdfmeCellSchema(cell: RenderableCell, tableOffsetX: number, tableOffsetY: number): PdfmeCellSchema;
+/**
+ * Get the display value for a RenderableCell.
+ * Uses computedValue for dynamic cells, rawValue otherwise.
+ */
+export declare function getCellDisplayValue(cell: RenderableCell): string;

package/dist/types/_vendors/schemas/dynamicTable/helpers/cellStyleControls.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Renders per-cell style controls for selected cells.
+ * Used when "Cell" is selected in the region style dropdown.
+ */
+import type { PropPanelWidgetProps } from '../../../common/index.js';
+export declare function renderCellStyleControls(props: PropPanelWidgetProps, container: HTMLElement): void;

package/dist/types/_vendors/schemas/dynamicTable/helpers/domUtils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared DOM utilities and table helpers for dynamicTable propPanel widgets.
+ */
+import type { PropPanelWidgetProps, SchemaForUI } from '../../../common/index.js';
+import type { DynamicTableSchema } from '../types.js';
+import type { TableExportData } from '../engine/index.js';
+export type WidgetSchema = SchemaForUI & DynamicTableSchema;
+export declare function parseContent(schema: WidgetSchema): TableExportData;
+/** Get the cached Table for the active schema and return a commit function */
+export declare function getTableAndCommit(props: PropPanelWidgetProps): {
+    table: import("../engine/index.js").Table;
+    commit: () => void;
+    schema: WidgetSchema;
+};
+export declare function createLabel(text: string): HTMLLabelElement;
+export declare function createRow(): HTMLDivElement;
+export declare function createNumberInput(value: number, min: number, step: number, onChange: (v: number) => void): HTMLInputElement;
+export declare function createColorInput(value: string, onChange: (v: string) => void): HTMLInputElement;
+export declare function createCheckbox(label: string, checked: boolean, onChange: (v: boolean) => void): HTMLDivElement;
+export declare function createSelect(options: {
+    label: string;
+    value: string;
+}[], currentValue: string, onChange: (v: string) => void): HTMLSelectElement;
+export declare function createSmallButton(text: string, title: string, onClick: () => void): HTMLButtonElement;

package/dist/types/_vendors/schemas/dynamicTable/helpers/propPanelWidgets.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Re-exports for backward compatibility.
+ * The implementations have been split into focused files:
+ *   - helpers/domUtils.ts           — shared DOM helpers + getTableAndCommit
+ *   - helpers/regionStyleControls.ts — renderRegionStyleControls
+ *   - helpers/cellStyleControls.ts  — renderCellStyleControls
+ *   - helpers/widgets/settingsWidgets.ts — headerVisibilityWidget, constraintsWidget, overflowWidget
+ *   - helpers/widgets/styleWidgets.ts   — tableStyleWidget, regionStyleSelectWidget, cellStyleWidget
+ *   - helpers/widgets/structureWidget.ts — structureWidget
+ */
+export { headerVisibilityWidget, constraintsWidget, overflowWidget } from './widgets/settingsWidgets.js';
+export { tableStyleWidget, regionStyleSelectWidget, cellStyleWidget } from './widgets/styleWidgets.js';
+export { structureWidget } from './widgets/structureWidget.js';

package/dist/types/_vendors/schemas/dynamicTable/helpers/regionStyleControls.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Renders region style controls (font, color, border, padding) for a given region.
+ */
+import type { PropPanelWidgetProps } from '../../../common/index.js';
+export declare function renderRegionStyleControls(props: PropPanelWidgetProps, region: string, container: HTMLElement): void;

package/dist/types/_vendors/schemas/dynamicTable/helpers/toast.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Lightweight DOM toast for dynamic table constraint notifications.
+ * Appends a temporary floating message that auto-dismisses.
+ */
+export declare function showToast(message: string, durationMs?: number): void;

package/dist/types/_vendors/schemas/dynamicTable/helpers/widgets/settingsWidgets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Settings widgets: headerVisibilityWidget, constraintsWidget, overflowWidget.
+ */
+import type { PropPanelWidgetProps } from '../../../../common/index.js';
+/**
+ * Header visibility: 3 checkboxes for theader, lheader, rheader.
+ */
+export declare function headerVisibilityWidget(props: PropPanelWidgetProps): void;
+/**
+ * Constraints: minRows, maxRows, minCols, maxCols.
+ */
+export declare function constraintsWidget(props: PropPanelWidgetProps): void;
+/**
+ * Overflow mode selector.
+ */
+export declare function overflowWidget(props: PropPanelWidgetProps): void;

package/dist/types/_vendors/schemas/dynamicTable/helpers/widgets/structureWidget.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Structure widget — tree view of all table regions with add/remove/merge controls.
+ */
+import type { PropPanelWidgetProps } from '../../../../common/index.js';
+/**
+ * Shows a tree structure for the table:
+ * - Top Header (theader) with sub-headers
+ * - Left Header / Right Header (toggle + add/remove)
+ * - Body row/col count with +/-
+ * - Footer (toggle)
+ * - Merge / Unmerge controls
+ */
+export declare function structureWidget(props: PropPanelWidgetProps): void;

package/dist/types/_vendors/schemas/dynamicTable/helpers/widgets/styleWidgets.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Style widgets: tableStyleWidget, regionStyleSelectWidget, cellStyleWidget.
+ */
+import type { PropPanelWidgetProps } from '../../../../common/index.js';
+/**
+ * Table style: border color, border width.
+ */
+export declare function tableStyleWidget(props: PropPanelWidgetProps): void;
+/**
+ * Unified region style widget with a region selector dropdown.
+ * Shows region style controls normally, or cell style controls when "Cell" is selected.
+ * Selecting "Cell" activates styling mode (purple highlights, click-to-select).
+ */
+export declare function regionStyleSelectWidget(props: PropPanelWidgetProps): void;
+/**
+ * Standalone cell style widget — delegates to renderCellStyleControls.
+ * Kept for potential standalone use; the primary entry point is now
+ * the "Cell" option in regionStyleSelectWidget.
+ */
+export declare function cellStyleWidget(props: PropPanelWidgetProps): void;

package/dist/types/_vendors/schemas/dynamicTable/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '../../common/index.js';
+import type { DynamicTableSchema } from './types.js';
+declare const dynamicTableSchema: Plugin<DynamicTableSchema>;
+export default dynamicTableSchema;

package/dist/types/_vendors/schemas/dynamicTable/instanceManager.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Thin Table cache — avoids reconstructing from JSON on every pdfme render call.
+ *
+ * pdfme may call pdf() or ui() many times in rapid succession (e.g., during
+ * drag/resize in the designer). This cache ensures we only reconstruct when
+ * the value actually changes. Table instance is preserved across renders so
+ * transient UI state (editing, selection) survives re-renders.
+ */
+import { Table } from './engine/index.js';
+/**
+ * Get a cached Table for the given schema key, or create one from JSON.
+ * Returns the same Table instance as long as the value string hasn't changed.
+ */
+export declare function getTable(key: string, json: string): Table;
+/**
+ * After mutating a Table, call this to update the cache and get the new JSON.
+ */
+export declare function commitTable(key: string, table: Table): string;

package/dist/types/_vendors/schemas/dynamicTable/pdfRender.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PDF Renderer for the Dynamic Table pdfme plugin.
+ *
+ * Pure read-only rendering from Table.getRenderSnapshot().
+ */
+import type { PDFRenderProps } from '../../common/index.js';
+import type { DynamicTableSchema } from './types.js';
+export declare function pdfRender(arg: PDFRenderProps<DynamicTableSchema>): Promise<void>;

package/dist/types/_vendors/schemas/dynamicTable/propPanel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * PropPanel for the Dynamic Table pdfme plugin.
+ *
+ * Uses function-based schema to dynamically show/hide sections based on
+ * current table state. Custom widgets handle style/settings editing by
+ * reading from and writing to the serialized table content.
+ */
+import type { PropPanel } from '../../common/index.js';
+import type { DynamicTableSchema } from './types.js';
+/**
+ * Create a default TableExportData JSON string for a minimal 3-column, 3-row table.
+ * Used as the initial value when a new dynamic table schema is added.
+ */
+export declare function createDefaultTableValue(): string;
+export declare const propPanel: PropPanel<DynamicTableSchema>;

package/dist/types/_vendors/schemas/dynamicTable/types.d.ts

@@ -0,0 +1,39 @@
+import type { Schema } from '../../common/index.js';
+export declare const SCHEMA_TYPE: "dynamicTable";
+/**
+ * Schema for the dynamic table plugin.
+ * Extends pdfme's base Schema with table-specific display options.
+ * The actual table data lives in the `value` field (JSON-encoded TableExportData).
+ */
+export interface DynamicTableSchema extends Schema {
+    type: typeof SCHEMA_TYPE;
+}
+/**
+ * Maps our CellStyle to pdfme's cell schema shape.
+ * Used when delegating rendering to pdfme's cell/text/rectangle/line renderers.
+ */
+export interface PdfmeCellSchema extends Schema {
+    fontName?: string;
+    bold?: boolean;
+    italic?: boolean;
+    alignment: string;
+    verticalAlignment: string;
+    fontSize: number;
+    lineHeight: number;
+    characterSpacing: number;
+    fontColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    padding: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+}

package/dist/types/_vendors/schemas/dynamicTable/uiComponents/addRemoveButtons.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Add/remove row buttons for the dynamic table UI (form mode).
+ */
+import type { RenderableTableInstance, Table } from '../engine/index.js';
+export declare function appendAddRowButton(root: HTMLElement, snapshot: RenderableTableInstance, table: Table, commit: () => void): void;
+export declare function appendRemoveRowButtons(root: HTMLElement, snapshot: RenderableTableInstance, table: Table, commit: () => void): void;

package/dist/types/_vendors/schemas/dynamicTable/uiComponents/cellResizeInteractions.d.ts

@@ -0,0 +1,17 @@
+import type { RenderableTableInstance, Table } from '../engine/index.js';
+/**
+ * Attaches scroll + right-click resize interactions to all table cells in designer mode.
+ * Uses event delegation on the root element to bypass child elements created by cellUiRender.
+ *
+ * - Shift + Scroll: resize column width (shared for non-footer; per-cell for footer)
+ * - Alt + Scroll: resize row height
+ * - Right-click: context menu with numeric Width/Height inputs
+ *
+ * Scroll direction: UP = increase, DOWN = decrease (fixed 1mm step)
+ */
+/** Key for storing AbortController on root element to clean up previous listeners */
+declare const ABORT_KEY: unique symbol;
+export declare function attachCellResizeInteractions(root: HTMLElement & {
+    [ABORT_KEY]?: AbortController;
+}, snapshot: RenderableTableInstance, table: Table, commit: () => void): void;
+export {};

package/dist/types/_vendors/schemas/dynamicTable/uiComponents/cellSelection.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cell selection tracking for the dynamic table designer mode.
+ * Uses Table's UI state instead of module-level singletons.
+ */
+import type { RenderableTableInstance, Table, Rect } from '../engine/index.js';
+/**
+ * Handle a cell click for selection purposes.
+ * Without shift: single selection (clears previous).
+ * With shift: rectangular range from anchor to clicked cell.
+ */
+export declare function handleCellClick(table: Table, cellId: string, row: number, col: number, region: string, shiftKey: boolean, snapshot: RenderableTableInstance): void;
+/**
+ * Build a merge Rect from the currently selected cells.
+ * Returns null if selection is invalid for merge.
+ */
+export declare function buildMergeRect(table: Table, snapshot: RenderableTableInstance): Rect | null;

package/dist/types/_vendors/schemas/dynamicTable/uiComponents/createButton.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reusable button factory for the dynamic table UI.
+ * Extracted from the tables plugin pattern (tables/uiRender.ts).
+ */
+export interface ButtonOptions {
+    width: number;
+    height: number;
+    top: string;
+    left?: string;
+    right?: string;
+    text: string;
+    onClick: (e: MouseEvent) => void;
+}
+export declare function createButton(options: ButtonOptions): HTMLButtonElement;

package/dist/types/_vendors/schemas/dynamicTable/uiComponents/index.d.ts

@@ -0,0 +1,4 @@
+export { createButton } from './createButton.js';
+export { appendAddRowButton, appendRemoveRowButtons, } from './addRemoveButtons.js';
+export { attachCellResizeInteractions } from './cellResizeInteractions.js';
+export { handleCellClick, buildMergeRect } from './cellSelection.js';

package/dist/types/_vendors/schemas/dynamicTable/uiRender.d.ts

@@ -0,0 +1,26 @@
+/**
+ * UI Renderer for the Dynamic Table pdfme plugin.
+ *
+ * Architecture:
+ * - Plugin uses `uninterruptedEditMode: true` so React (Renderer.tsx) only
+ *   calls this function on mode transitions (viewer <-> designer), NOT on
+ *   every schema/value change. This prevents the flash caused by synchronous
+ *   innerHTML clearing followed by async re-rendering.
+ *
+ * - Internal re-renders (cell clicks, propPanel triggers, structural mutations)
+ *   go through the inner `render()` function which:
+ *   1. Builds all cell DOM into a DocumentFragment (parallel cell rendering)
+ *   2. Swaps atomically via `rootElement.replaceChildren(fragment)` — no empty frame
+ *
+ * - The `requestRender` callback lets propPanel widgets trigger canvas updates
+ *   without going through React's change cycle.
+ */
+import type { UIRenderProps } from '../../common/index.js';
+import type { DynamicTableSchema } from './types.js';
+/**
+ * pdfme ui() entry point.
+ *
+ * Called by React's Renderer on mode transitions. Sets up the table instance,
+ * commit helpers, and the inner render loop.
+ */
+export declare function uiRender(arg: UIRenderProps<DynamicTableSchema>): Promise<void>;

package/dist/types/_vendors/schemas/graphics/image.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '../../common/index.js';
+import type { Schema } from '../../common/index.js';
+type ImageSchema = Schema;
+declare const imageSchema: Plugin<ImageSchema>;
+export default imageSchema;

package/dist/types/_vendors/schemas/graphics/imagehelper.d.ts

@@ -0,0 +1,4 @@
+export declare const getImageDimension: (value: string) => {
+    height: number;
+    width: number;
+};

package/dist/types/_vendors/schemas/graphics/signature.d.ts

@@ -0,0 +1,5 @@
+import { Plugin, Schema } from '../../common/index.js';
+interface Signature extends Schema {
+}
+export declare const signature: Plugin<Signature>;
+export default signature;

package/dist/types/_vendors/schemas/graphics/svg.d.ts

@@ -0,0 +1,4 @@
+import { Plugin, Schema } from '../../common/index.js';
+export type SVGSchema = Schema;
+declare const svgSchema: Plugin<SVGSchema>;
+export default svgSchema;