@pdfme/generator 1.0.0-beta.2

package/dist/types/common/src/type.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { Lang, Size, Alignment, BarcodeSchemaType, SchemaType, CommonSchema as _CommonSchema, TextSchema, ImageSchema, BarcodeSchema, Schema, SchemaForUI, Font, BasePdf, Template, CommonProps, GeneratorOptions, GenerateProps, UIOptions, UIProps, PreviewProps, PreviewReactProps, DesignerProps, DesignerReactProps } from './schema';
+export declare type Lang = z.infer<typeof Lang>;
+export declare type Size = z.infer<typeof Size>;
+export declare type Alignment = z.infer<typeof Alignment>;
+export declare type SchemaType = z.infer<typeof SchemaType>;
+export declare const schemaTypes: readonly ["text", "image", "qrcode", "japanpost", "ean13", "ean8", "code39", "code128", "nw7", "itf14", "upca", "upce"];
+export declare type BarCodeType = z.infer<typeof BarcodeSchemaType>;
+export declare type TextSchema = z.infer<typeof TextSchema>;
+declare type CommonSchema = z.infer<typeof _CommonSchema>;
+export declare const isTextSchema: (arg: CommonSchema) => arg is {
+    rotate?: number | undefined;
+    alignment?: "left" | "center" | "right" | undefined;
+    fontSize?: number | undefined;
+    fontName?: string | undefined;
+    fontColor?: string | undefined;
+    backgroundColor?: string | undefined;
+    characterSpacing?: number | undefined;
+    lineHeight?: number | undefined;
+    type: "text";
+    height: number;
+    width: number;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+export declare type ImageSchema = z.infer<typeof ImageSchema>;
+export declare const isImageSchema: (arg: CommonSchema) => arg is {
+    rotate?: number | undefined;
+    type: "image";
+    height: number;
+    width: number;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+export declare type BarcodeSchema = z.infer<typeof BarcodeSchema>;
+export declare const isBarcodeSchema: (arg: CommonSchema) => arg is {
+    rotate?: number | undefined;
+    type: "qrcode" | "japanpost" | "ean13" | "ean8" | "code39" | "code128" | "nw7" | "itf14" | "upca" | "upce";
+    height: number;
+    width: number;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+export declare type Schema = z.infer<typeof Schema>;
+export declare type SchemaForUI = z.infer<typeof SchemaForUI>;
+export declare type Font = z.infer<typeof Font>;
+export declare type BasePdf = z.infer<typeof BasePdf>;
+export declare type Template = z.infer<typeof Template>;
+export declare type CommonProps = z.infer<typeof CommonProps>;
+export declare type GeneratorOptions = z.infer<typeof GeneratorOptions>;
+export declare type GenerateProps = z.infer<typeof GenerateProps>;
+export declare type UIOptions = z.infer<typeof UIOptions>;
+export declare type UIProps = z.infer<typeof UIProps>;
+export declare type PreviewProps = z.infer<typeof PreviewProps>;
+export declare type PreviewReactProps = z.infer<typeof PreviewReactProps>;
+export declare type DesignerProps = z.infer<typeof DesignerProps>;
+export declare type DesignerReactProps = z.infer<typeof DesignerReactProps>;
+export {};

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

@@ -0,0 +1,12 @@
+export declare const uuid: () => string;
+export declare const set: <T extends object>(obj: T, path: string | string[], value: any) => void;
+export declare const debounce: <T extends Function>(cb: T, wait?: number) => T;
+export declare const cloneDeep: <T>(value: T) => T;
+export declare const uniq: <T>(array: T[]) => T[];
+export declare const round: (number: number, precision: number) => number;
+export declare const b64toUint8Array: (base64: string) => Uint8Array;
+export declare const b64toBlob: (base64: string) => Blob;
+export declare const arrayMove: <T>(array: T[], from: number, to: number) => T[];
+export declare const flatten: <T>(arr: T[][]) => T[];
+export declare const pt2mm: (pt: number) => number;
+export declare const mm2pt: (mm: number) => number;

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

@@ -0,0 +1 @@
+export declare const TOOL_NAME: "pdfme (https://github.com/hand-dot/pdfme)";

package/dist/types/generator/src/generate.d.ts

@@ -0,0 +1,3 @@
+import { GenerateProps } from '@pdfme/common';
+declare const generate: (props: GenerateProps) => Promise<Uint8Array>;
+export default generate;

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

@@ -0,0 +1,67 @@
+import { PDFPage, PDFFont, PDFDocument, PDFImage, PDFEmbeddedPage } from 'pdf-lib';
+import { Schema, Font, BasePdf, BarCodeType } from '../../common/src/type';
+export interface InputImageCache {
+    [key: string]: PDFImage;
+}
+export declare const createBarCode: ({ type, input, width, height, backgroundColor, }: {
+    type: BarCodeType;
+    input: string;
+    width: number;
+    height: number;
+    backgroundColor?: string | undefined;
+}) => Promise<Buffer>;
+declare type EmbedPdfBox = {
+    mediaBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    bleedBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    trimBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export declare const embedAndGetFontObj: (arg: {
+    pdfDoc: PDFDocument;
+    font: Font;
+}) => Promise<{
+    [key: string]: PDFFont;
+}>;
+export declare const getEmbeddedPagesAndEmbedPdfBoxes: (arg: {
+    pdfDoc: PDFDocument;
+    basePdf: BasePdf;
+}) => Promise<{
+    embeddedPages: PDFEmbeddedPage[];
+    embedPdfBoxes: EmbedPdfBox[];
+}>;
+interface TextSchemaSetting {
+    fontObj: {
+        [key: string]: PDFFont;
+    };
+    fallbackFontName: string;
+    splitThreshold: number;
+}
+export declare const drawInputByTemplateSchema: (arg: {
+    input: string;
+    templateSchema: Schema;
+    pdfDoc: PDFDocument;
+    page: PDFPage;
+    pageHeight: number;
+    textSchemaSetting: TextSchemaSetting;
+    inputImageCache: InputImageCache;
+}) => Promise<void>;
+export declare const drawEmbeddedPage: (arg: {
+    page: PDFPage;
+    embeddedPage: PDFEmbeddedPage;
+    embedPdfBox: EmbedPdfBox;
+}) => void;
+export {};

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

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import { PDFPage, PDFFont, PDFDocument, PDFImage, PDFEmbeddedPage } from 'pdf-lib';
+import { Schema, Font, BasePdf, BarCodeType } from '@pdfme/common';
+export interface InputImageCache {
+    [key: string]: PDFImage;
+}
+export declare const createBarCode: ({ type, input, width, height, backgroundColor, }: {
+    type: BarCodeType;
+    input: string;
+    width: number;
+    height: number;
+    backgroundColor?: string | undefined;
+}) => Promise<Buffer>;
+declare type EmbedPdfBox = {
+    mediaBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    bleedBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    trimBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export declare const embedAndGetFontObj: (arg: {
+    pdfDoc: PDFDocument;
+    font: Font;
+}) => Promise<{
+    [key: string]: PDFFont;
+}>;
+export declare const getEmbeddedPagesAndEmbedPdfBoxes: (arg: {
+    pdfDoc: PDFDocument;
+    basePdf: BasePdf;
+}) => Promise<{
+    embeddedPages: PDFEmbeddedPage[];
+    embedPdfBoxes: EmbedPdfBox[];
+}>;
+interface TextSchemaSetting {
+    fontObj: {
+        [key: string]: PDFFont;
+    };
+    fallbackFontName: string;
+    splitThreshold: number;
+}
+export declare const drawInputByTemplateSchema: (arg: {
+    input: string;
+    templateSchema: Schema;
+    pdfDoc: PDFDocument;
+    page: PDFPage;
+    pageHeight: number;
+    textSchemaSetting: TextSchemaSetting;
+    inputImageCache: InputImageCache;
+}) => Promise<void>;
+export declare const drawEmbeddedPage: (arg: {
+    page: PDFPage;
+    embeddedPage: PDFEmbeddedPage;
+    embedPdfBox: EmbedPdfBox;
+}) => void;
+export {};

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

@@ -0,0 +1,3 @@
+import generate from './generate';
+import { BLANK_PDF, Lang, Size, Alignment, SchemaType, schemaTypes, BarCodeType, TextSchema, isTextSchema, ImageSchema, isImageSchema, BarcodeSchema, isBarcodeSchema, Schema, SchemaForUI, Font, BasePdf, Template, CommonProps, GeneratorOptions, GenerateProps, UIOptions, UIProps, PreviewProps, PreviewReactProps, DesignerProps, DesignerReactProps, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, validateBarcodeInput } from '@pdfme/common';
+export { generate, BLANK_PDF, Lang, Size, Alignment, SchemaType, schemaTypes, BarCodeType, TextSchema, isTextSchema, ImageSchema, isImageSchema, BarcodeSchema, isBarcodeSchema, Schema, SchemaForUI, Font, BasePdf, Template, CommonProps, GeneratorOptions, GenerateProps, UIOptions, UIProps, PreviewProps, PreviewReactProps, DesignerProps, DesignerReactProps, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, validateBarcodeInput, };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@pdfme/generator",
+  "version": "1.0.0-beta.2",
+  "author": "hand-dot",
+  "license": "MIT",
+  "description": "TypeScript base PDF generator and React base UI. Open source, developed by the community, and completely free to use under the MIT license!",
+  "homepage": "https://pdfme.com",
+  "repository": "git@github.com:pdfme/pdfme.git",
+  "bugs": {
+    "url": "https://github.com/pdfme/pdfme/issues"
+  },
+  "main": "dist/@pdfme/generator.js",
+  "module": "src/index.ts",
+  "types": "dist/types/index.d.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "develop": "webpack-dev-server --mode development",
+    "build": "NODE_ENV=production webpack --mode production",
+    "clean": "rimraf dist",
+    "lint": "tsc --noEmit",
+    "test": "jest",
+    "lint:watch": "tsc -w --noEmit",
+    "test:watch": "jest --coverage --watch",
+    "prune": "ts-prune src"
+  },
+  "dependencies": {
+    "@pdfme/common": "^1.0.0-beta.1",
+    "@pdf-lib/fontkit": "^1.1.1",
+    "pdf-lib": "^1.17.1",
+    "bwip-js": "^3.0.4"
+  },
+  "devDependencies": {
+    "@types/bwip-js": "^3.0.0",
+    "@types/pngjs": "^6.0.1",
+    "jsqr": "^1.4.0",
+    "pdf2json": "^2.0.0",
+    "pngjs": "^6.0.0"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "\\.(ttf)$": "<rootDir>/../../fontTransformer.js"
+    },
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "testMatch": [
+      "**/*.test.ts"
+    ]
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const TOOL_NAME = 'pdfme (https://github.com/hand-dot/pdfme)' as const;

package/src/generate.ts

@@ -0,0 +1,94 @@
+import { PDFDocument } from 'pdf-lib';
+import fontkit from '@pdf-lib/fontkit';
+import {
+  GenerateProps,
+  Template,
+  Font,
+  getDefaultFont,
+  getFallbackFontName,
+  checkGenerateProps,
+} from '@pdfme/common';
+
+import {
+  getEmbeddedPagesAndEmbedPdfBoxes,
+  drawInputByTemplateSchema,
+  drawEmbeddedPage,
+  embedAndGetFontObj,
+  InputImageCache,
+} from './helper';
+import { TOOL_NAME } from './constants';
+
+const preprocessing = async (arg: {
+  inputs: { [key: string]: string }[];
+  template: Template;
+  font: Font;
+}) => {
+  const { template, font } = arg;
+
+  const { basePdf } = template;
+
+  const pdfDoc = await PDFDocument.create();
+  pdfDoc.registerFontkit(fontkit);
+
+  const fallbackFontName = getFallbackFontName(font);
+  const fontObj = await embedAndGetFontObj({ pdfDoc, font });
+
+  const pagesAndBoxes = await getEmbeddedPagesAndEmbedPdfBoxes({ pdfDoc, basePdf });
+  const { embeddedPages, embedPdfBoxes } = pagesAndBoxes;
+
+  return { pdfDoc, fontObj, fallbackFontName, embeddedPages, embedPdfBoxes };
+};
+
+const postProcessing = (pdfDoc: PDFDocument) => {
+  pdfDoc.setProducer(TOOL_NAME);
+  pdfDoc.setCreator(TOOL_NAME);
+};
+
+const generate = async (props: GenerateProps) => {
+  checkGenerateProps(props);
+  const { inputs, template, options = {} } = props;
+  const { font = getDefaultFont(), splitThreshold = 3 } = options;
+  const { schemas } = template;
+
+  const preRes = await preprocessing({ inputs, template, font });
+  const { pdfDoc, fontObj, fallbackFontName, embeddedPages, embedPdfBoxes } = preRes;
+
+  const inputImageCache: InputImageCache = {};
+  for (let i = 0; i < inputs.length; i += 1) {
+    const inputObj = inputs[i];
+    const keys = Object.keys(inputObj);
+    for (let j = 0; j < embeddedPages.length; j += 1) {
+      const embeddedPage = embeddedPages[j];
+      const { width: pageWidth, height: pageHeight } = embeddedPage;
+      const embedPdfBox = embedPdfBoxes[j];
+
+      const page = pdfDoc.addPage([pageWidth, pageHeight]);
+
+      drawEmbeddedPage({ page, embeddedPage, embedPdfBox });
+      for (let l = 0; l < keys.length; l += 1) {
+        const key = keys[l];
+        const schema = schemas[j];
+        const templateSchema = schema[key];
+        const input = inputObj[key];
+        const textSchemaSetting = { fontObj, fallbackFontName, splitThreshold };
+
+        // eslint-disable-next-line no-await-in-loop
+        await drawInputByTemplateSchema({
+          input,
+          templateSchema,
+          pdfDoc,
+          page,
+          pageHeight,
+          textSchemaSetting,
+          inputImageCache,
+        });
+      }
+    }
+  }
+
+  postProcessing(pdfDoc);
+
+  return pdfDoc.save();
+};
+
+export default generate;