@pdfme/schemas 0.0.0

package/dist/types/src/tables/cell.d.ts

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

package/dist/types/src/tables/classes.d.ts

@@ -0,0 +1,69 @@
+import { Font } from '@pdfme/common';
+import type { Font as FontKitFont } from 'fontkit';
+import type { Styles, TableInput, Settings, Section, StylesProps } from './types.js';
+type ContentSettings = {
+    body: Row[];
+    head: Row[];
+    columns: Column[];
+};
+export declare class Cell {
+    raw: string;
+    text: string[];
+    styles: Styles;
+    section: Section;
+    contentHeight: number;
+    contentWidth: number;
+    wrappedWidth: number;
+    minReadableWidth: number;
+    minWidth: number;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    constructor(raw: string, styles: Styles, section: Section);
+    getContentHeight(): number;
+    padding(name: 'top' | 'bottom' | 'left' | 'right'): number;
+}
+export declare class Column {
+    index: number;
+    wrappedWidth: number;
+    minReadableWidth: number;
+    minWidth: number;
+    width: number;
+    constructor(index: number);
+    getMaxCustomCellWidth(table: Table): number;
+}
+export declare class Row {
+    readonly raw: string[];
+    readonly index: number;
+    readonly section: Section;
+    readonly cells: {
+        [key: string]: Cell;
+    };
+    height: number;
+    constructor(raw: string[], index: number, section: Section, cells: {
+        [key: string]: Cell;
+    });
+    getMaxCellHeight(columns: Column[]): number;
+    getMinimumRowHeight(columns: Column[]): number;
+}
+export declare class Table {
+    readonly settings: Settings;
+    readonly styles: StylesProps;
+    readonly columns: Column[];
+    readonly head: Row[];
+    readonly body: Row[];
+    constructor(input: TableInput, content: ContentSettings);
+    static create(arg: {
+        input: TableInput;
+        content: ContentSettings;
+        font: Font;
+        _cache: Map<string | number, FontKitFont>;
+    }): Promise<Table>;
+    getHeadHeight(): number;
+    getBodyHeight(): number;
+    allRows(): Row[];
+    getWidth(): number;
+    getHeight(): number;
+}
+export {};

package/dist/types/src/tables/dynamicTemplate.d.ts

@@ -0,0 +1,7 @@
+import { Schema, BasePdf, CommonOptions } from '@pdfme/common';
+export declare const getDynamicHeightsForTable: (value: string, args: {
+    schema: Schema;
+    basePdf: BasePdf;
+    options: CommonOptions;
+    _cache: Map<string | number, unknown>;
+}) => Promise<number[]>;

package/dist/types/src/tables/helper.d.ts

@@ -0,0 +1,265 @@
+export declare const getDefaultCellStyles: () => {
+    fontName: undefined;
+    alignment: import("../text/types.js").ALIGNMENT;
+    verticalAlignment: import("../text/types.js").VERTICAL_ALIGNMENT;
+    fontSize: number;
+    lineHeight: number;
+    characterSpacing: number;
+    fontColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    padding: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+};
+export declare const getCellPropPanelSchema: (arg: {
+    i18n: (key: string) => string;
+    fallbackFontName: string;
+    fontNames: string[];
+    isBody?: boolean;
+}) => {
+    '-': {
+        type: string;
+        widget: string;
+    };
+    borderWidth: {
+        title: string;
+        type: string;
+        widget: string;
+        span: number;
+        properties: {
+            top: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            right: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            bottom: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            left: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+        };
+    };
+    '--': {
+        type: string;
+        widget: string;
+    };
+    padding: {
+        title: string;
+        type: string;
+        widget: string;
+        span: number;
+        properties: {
+            top: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            right: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            bottom: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+            left: {
+                type: string;
+                widget: string;
+                props: {
+                    min: number;
+                    step: number;
+                };
+                span: number;
+                title: string;
+            };
+        };
+    };
+    alternateBackgroundColor?: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            disabledAlpha: boolean;
+        };
+        rules: {
+            pattern: string;
+            message: string;
+        }[];
+    } | undefined;
+    fontName: {
+        title: string;
+        type: string;
+        widget: string;
+        default: string;
+        placeholder: string;
+        props: {
+            options: {
+                label: string;
+                value: string;
+            }[];
+        };
+        span: number;
+    };
+    fontSize: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            min: number;
+        };
+        span: number;
+    };
+    characterSpacing: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            min: number;
+        };
+        span: number;
+    };
+    alignment: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            options: {
+                label: string;
+                value: import("../text/types.js").ALIGNMENT;
+            }[];
+        };
+        span: number;
+    };
+    verticalAlignment: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            options: {
+                label: string;
+                value: import("../text/types.js").VERTICAL_ALIGNMENT;
+            }[];
+        };
+        span: number;
+    };
+    lineHeight: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            step: number;
+            min: number;
+        };
+        span: number;
+    };
+    fontColor: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            disabledAlpha: boolean;
+        };
+        rules: {
+            pattern: string;
+            message: string;
+        }[];
+    };
+    borderColor: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            disabledAlpha: boolean;
+        };
+        rules: {
+            pattern: string;
+            message: string;
+        }[];
+    };
+    backgroundColor: {
+        title: string;
+        type: string;
+        widget: string;
+        props: {
+            disabledAlpha: boolean;
+        };
+        rules: {
+            pattern: string;
+            message: string;
+        }[];
+    };
+};
+export declare const getColumnStylesPropPanelSchema: ({ head, i18n, }: {
+    head: string[];
+    i18n: (key: string) => string;
+}) => {
+    alignment: {
+        type: string;
+        widget: string;
+        title: string;
+        column: number;
+        properties: {};
+    };
+};
+export declare const getBody: (value: string | string[][]) => string[][];
+export declare const getBodyWithRange: (value: string | string[][], range?: {
+    start: number;
+    end?: number | undefined;
+}) => string[][];

package/dist/types/src/tables/index.d.ts

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

package/dist/types/src/tables/pdfRender.d.ts

@@ -0,0 +1,3 @@
+import type { TableSchema } from './types.js';
+import type { PDFRenderProps } from '@pdfme/common';
+export declare const pdfRender: (arg: PDFRenderProps<TableSchema>) => Promise<void>;

package/dist/types/src/tables/propPanel.d.ts

@@ -0,0 +1,3 @@
+import type { PropPanel } from '@pdfme/common';
+import type { TableSchema } from './types.js';
+export declare const propPanel: PropPanel<TableSchema>;

package/dist/types/src/tables/tableHelper.d.ts

@@ -0,0 +1,10 @@
+import { Schema, BasePdf, CommonOptions } from '@pdfme/common';
+import { Table } from './classes.js';
+interface CreateTableArgs {
+    schema: Schema;
+    basePdf: BasePdf;
+    options: CommonOptions;
+    _cache: Map<string | number, unknown>;
+}
+export declare function createSingleTable(body: string[][], args: CreateTableArgs): Promise<Table>;
+export {};

package/dist/types/src/tables/types.d.ts

@@ -0,0 +1,88 @@
+import type { ALIGNMENT, VERTICAL_ALIGNMENT } from '../text/types.js';
+import type { Schema } from '@pdfme/common';
+export type Spacing = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+type BorderInsets = Spacing;
+type BoxDimensions = Spacing;
+export interface CellStyle {
+    fontName?: string;
+    alignment: ALIGNMENT;
+    verticalAlignment: VERTICAL_ALIGNMENT;
+    fontSize: number;
+    lineHeight: number;
+    characterSpacing: number;
+    fontColor: string;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: BoxDimensions;
+    padding: BoxDimensions;
+}
+export type CellSchema = Schema & CellStyle;
+export interface TableSchema extends Schema {
+    showHead: boolean;
+    head: string[];
+    headWidthPercentages: number[];
+    repeatHead?: boolean;
+    tableStyles: {
+        borderColor: string;
+        borderWidth: number;
+    };
+    headStyles: CellStyle;
+    bodyStyles: CellStyle & {
+        alternateBackgroundColor: string;
+    };
+    columnStyles: {
+        alignment?: {
+            [colIndex: number]: ALIGNMENT;
+        };
+    };
+}
+export interface Styles {
+    fontName: string | undefined;
+    backgroundColor: string;
+    textColor: string;
+    lineHeight: number;
+    characterSpacing: number;
+    alignment: 'left' | 'center' | 'right' | 'justify';
+    verticalAlignment: 'top' | 'middle' | 'bottom';
+    fontSize: number;
+    cellPadding: Spacing;
+    lineColor: string;
+    lineWidth: BorderInsets;
+    cellWidth: number;
+    minCellHeight: number;
+    minCellWidth: number;
+}
+export interface TableInput {
+    settings: Settings;
+    styles: StylesProps;
+    content: ContentInput;
+}
+interface ContentInput {
+    body: string[][];
+    head: string[][];
+    columns: number[];
+}
+export interface Settings {
+    startY: number;
+    margin: Spacing;
+    tableWidth: number;
+    showHead: boolean;
+    tableLineWidth: number;
+    tableLineColor: string;
+}
+export interface StylesProps {
+    styles: Partial<Styles>;
+    headStyles: Partial<Styles>;
+    bodyStyles: Partial<Styles>;
+    alternateRowStyles: Partial<Styles>;
+    columnStyles: {
+        [key: string]: Partial<Styles>;
+    };
+}
+export type Section = 'head' | 'body';
+export {};

package/dist/types/src/tables/uiRender.d.ts

@@ -0,0 +1,3 @@
+import type { UIRenderProps } from '@pdfme/common';
+import type { TableSchema } from './types.js';
+export declare const uiRender: (arg: UIRenderProps<TableSchema>) => Promise<void>;

package/dist/types/src/text/constants.d.ts

@@ -0,0 +1,23 @@
+import { ALIGNMENT, VERTICAL_ALIGNMENT, DYNAMIC_FONT_SIZE_FIT } from './types.js';
+export declare const DEFAULT_FONT_SIZE = 13;
+export declare const ALIGN_LEFT: ALIGNMENT;
+export declare const ALIGN_CENTER: ALIGNMENT;
+export declare const ALIGN_RIGHT: ALIGNMENT;
+export declare const ALIGN_JUSTIFY: ALIGNMENT;
+export declare const DEFAULT_ALIGNMENT: ALIGNMENT;
+export declare const VERTICAL_ALIGN_TOP: VERTICAL_ALIGNMENT;
+export declare const VERTICAL_ALIGN_MIDDLE: VERTICAL_ALIGNMENT;
+export declare const VERTICAL_ALIGN_BOTTOM: VERTICAL_ALIGNMENT;
+export declare const DEFAULT_VERTICAL_ALIGNMENT: VERTICAL_ALIGNMENT;
+export declare const DEFAULT_LINE_HEIGHT = 1;
+export declare const DEFAULT_CHARACTER_SPACING = 0;
+export declare const DEFAULT_FONT_COLOR = "#000000";
+export declare const PLACEHOLDER_FONT_COLOR = "#A0A0A0";
+export declare const DYNAMIC_FIT_VERTICAL: DYNAMIC_FONT_SIZE_FIT;
+export declare const DYNAMIC_FIT_HORIZONTAL: DYNAMIC_FONT_SIZE_FIT;
+export declare const DEFAULT_DYNAMIC_FIT: DYNAMIC_FONT_SIZE_FIT;
+export declare const DEFAULT_DYNAMIC_MIN_FONT_SIZE = 4;
+export declare const DEFAULT_DYNAMIC_MAX_FONT_SIZE = 72;
+export declare const FONT_SIZE_ADJUSTMENT = 0.25;
+export declare const LINE_START_FORBIDDEN_CHARS: string[];
+export declare const LINE_END_FORBIDDEN_CHARS: string[];

package/dist/types/src/text/extraFormatter.d.ts

@@ -0,0 +1,25 @@
+export declare enum Formatter {
+    STRIKETHROUGH = "strikethrough",
+    UNDERLINE = "underline",
+    ALIGNMENT = "alignment",
+    VERTICAL_ALIGNMENT = "verticalAlignment"
+}
+interface GroupButtonBoolean {
+    key: Formatter;
+    icon: string;
+    type: 'boolean';
+}
+interface GroupButtonString {
+    key: Formatter;
+    icon: string;
+    type: 'select';
+    value: string;
+}
+type GroupButton = GroupButtonBoolean | GroupButtonString;
+export declare function getExtraFormatterSchema(i18n: (key: string) => string): {
+    title: string;
+    widget: string;
+    buttons: GroupButton[];
+    span: number;
+};
+export {};

package/dist/types/src/text/helper.d.ts

@@ -0,0 +1,39 @@
+import * as fontkit from 'fontkit';
+import type { Font as FontKitFont } from 'fontkit';
+import { Font } from '@pdfme/common';
+import type { TextSchema, FontWidthCalcValues } from './types.js';
+export declare const getBrowserVerticalFontAdjustments: (fontKitFont: FontKitFont, fontSize: number, lineHeight: number, verticalAlignment: string) => {
+    topAdj: number;
+    bottomAdj: number;
+};
+export declare const getFontDescentInPt: (fontKitFont: FontKitFont, fontSize: number) => number;
+export declare const heightOfFontAtSize: (fontKitFont: FontKitFont, fontSize: number) => number;
+export declare const widthOfTextAtSize: (text: string, fontKitFont: FontKitFont, fontSize: number, characterSpacing: number) => number;
+export declare const getFontKitFont: (fontName: string | undefined, font: Font, _cache: Map<string | number, fontkit.Font>) => Promise<fontkit.Font>;
+/**
+ * Recursively splits the line at getSplitPosition.
+ * If there is some leftover, split the rest again in the same manner.
+ */
+export declare const getSplittedLines: (textLine: string, calcValues: FontWidthCalcValues) => string[];
+/**
+ * If using dynamic font size, iteratively increment or decrement the
+ * font size to fit the containing box.
+ * Calculating space usage involves splitting lines where they exceed
+ * the box width based on the proposed size.
+ */
+export declare const calculateDynamicFontSize: ({ textSchema, fontKitFont, value, startingFontSize, }: {
+    textSchema: TextSchema;
+    fontKitFont: FontKitFont;
+    value: string;
+    startingFontSize?: number | undefined;
+}) => number;
+export declare const splitTextToSize: (arg: {
+    value: string;
+    characterSpacing: number;
+    boxWidthInPt: number;
+    fontSize: number;
+    fontKitFont: fontkit.Font;
+}) => string[];
+export declare const isFirefox: () => boolean;
+export declare const filterStartJP: (lines: string[]) => string[];
+export declare const filterEndJP: (lines: string[]) => string[];

package/dist/types/src/text/icons/index.d.ts

@@ -0,0 +1,9 @@
+export declare const TextStrikethroughIcon: string;
+export declare const TextUnderlineIcon: string;
+export declare const TextAlignLeftIcon: string;
+export declare const TextAlignCenterIcon: string;
+export declare const TextAlignRightIcon: string;
+export declare const TextAlignJustifyIcon: string;
+export declare const TextVerticalAlignTopIcon: string;
+export declare const TextVerticalAlignMiddleIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 24 24\"><path d=\"M8 19h3v4h2v-4h3l-4-4l-4 4zm8-14h-3V1h-2v4H8l4 4l4-4zM4 11v2h16v-2H4z\" fill=\"currentColor\"></path></svg>";
+export declare const TextVerticalAlignBottomIcon: string;

package/dist/types/src/text/index.d.ts

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

package/dist/types/src/text/pdfRender.d.ts

@@ -0,0 +1,3 @@
+import type { TextSchema } from './types.js';
+import { PDFRenderProps } from '@pdfme/common';
+export declare const pdfRender: (arg: PDFRenderProps<TextSchema>) => Promise<void>;

package/dist/types/src/text/propPanel.d.ts

@@ -0,0 +1,3 @@
+import { PropPanel } from '@pdfme/common';
+import type { TextSchema } from './types.js';
+export declare const propPanel: PropPanel<TextSchema>;

package/dist/types/src/text/types.d.ts

@@ -0,0 +1,28 @@
+import type { Schema } from '@pdfme/common';
+import type { Font as FontKitFont } from 'fontkit';
+export type ALIGNMENT = 'left' | 'center' | 'right' | 'justify';
+export type VERTICAL_ALIGNMENT = 'top' | 'middle' | 'bottom';
+export type DYNAMIC_FONT_SIZE_FIT = 'horizontal' | 'vertical';
+export type FontWidthCalcValues = {
+    font: FontKitFont;
+    fontSize: number;
+    characterSpacing: number;
+    boxWidthInPt: number;
+};
+export interface TextSchema extends Schema {
+    fontName?: string;
+    alignment: ALIGNMENT;
+    verticalAlignment: VERTICAL_ALIGNMENT;
+    fontSize: number;
+    lineHeight: number;
+    strikethrough?: boolean;
+    underline?: boolean;
+    characterSpacing: number;
+    dynamicFontSize?: {
+        min: number;
+        max: number;
+        fit: DYNAMIC_FONT_SIZE_FIT;
+    };
+    fontColor: string;
+    backgroundColor: string;
+}

package/dist/types/src/text/uiRender.d.ts

@@ -0,0 +1,11 @@
+import type { Font as FontKitFont } from 'fontkit';
+import { UIRenderProps } from '@pdfme/common';
+import type { TextSchema } from './types.js';
+export declare const uiRender: (arg: UIRenderProps<TextSchema>) => Promise<void>;
+export declare const buildStyledTextContainer: (arg: UIRenderProps<TextSchema>, fontKitFont: FontKitFont, value: string) => HTMLDivElement;
+/**
+ * Firefox doesn't support 'plaintext-only' contentEditable mode, which we want to avoid mark-up.
+ * This function adds a workaround for Firefox to make the contentEditable element behave like 'plaintext-only'.
+ */
+export declare const makeElementPlainTextContentEditable: (element: HTMLElement) => void;
+export declare const mapVerticalAlignToFlex: (verticalAlignmentValue: string | undefined) => "center" | "flex-end" | "flex-start";

package/dist/types/src/utils.d.ts

@@ -0,0 +1,40 @@
+import { Color } from '@pdfme/pdf-lib';
+import { Schema, Mode, ColorType } from '@pdfme/common';
+import { IconNode } from 'lucide';
+export declare const convertForPdfLayoutProps: ({ schema, pageHeight, applyRotateTranslate, }: {
+    schema: Schema;
+    pageHeight: number;
+    applyRotateTranslate?: boolean;
+}) => {
+    position: {
+        x: number;
+        y: number;
+    };
+    height: number;
+    width: number;
+    rotate: import("@pdfme/pdf-lib").Degrees;
+    opacity: number | undefined;
+};
+export declare const rotatePoint: (point: {
+    x: number;
+    y: number;
+}, pivot: {
+    x: number;
+    y: number;
+}, angleDegrees: number) => {
+    x: number;
+    y: number;
+};
+export declare const getDynamicHeightsForTable: (value: string, args: {
+    schema: Schema;
+    basePdf: import("@pdfme/common").BasePdf;
+    options: import("@pdfme/common").CommonOptions;
+    _cache: Map<string | number, unknown>;
+}) => Promise<number[]>;
+export declare const addAlphaToHex: (hex: string, alphaPercentage: number) => string;
+export declare const isEditable: (mode: Mode, schema: Schema) => boolean;
+export declare const hex2RgbColor: (hexString: string | undefined) => import("@pdfme/pdf-lib").RGB | undefined;
+export declare const hex2PrintingColor: (color?: string | Color, colorType?: ColorType) => Color | undefined;
+export declare const readFile: (input: File | FileList | null) => Promise<string | ArrayBuffer>;
+export declare const createErrorElm: () => HTMLDivElement;
+export declare const createSvgStr: (icon: IconNode, attrs?: Record<string, string>) => string;