@pdfme/generator 0.0.0

package/dist/types/__tests__/generate.test.d.ts

@@ -0,0 +1 @@
+import 'jest-image-snapshot';

package/dist/types/__tests__/integration-other.test.d.ts

@@ -0,0 +1 @@
+import 'jest-image-snapshot';

package/dist/types/__tests__/integration-playground.test.d.ts

@@ -0,0 +1 @@
+import 'jest-image-snapshot';

package/dist/types/__tests__/integration-segmenter.test.d.ts

@@ -0,0 +1 @@
+import 'jest-image-snapshot';

package/dist/types/__tests__/integration-textType.test.d.ts

@@ -0,0 +1 @@
+import 'jest-image-snapshot';

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

@@ -0,0 +1,3 @@
+import { Font } from '@pdfme/common';
+export declare const getFont: () => Font;
+export declare const pdfToImages: (pdf: ArrayBuffer | Uint8Array) => Promise<Buffer[]>;

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { Schema, Plugins, GeneratorOptions, Template, PDFRenderProps } from '@pdfme/common';
+import { PDFPage, PDFDocument, PDFEmbeddedPage } from '@pdfme/pdf-lib';
+import type { EmbedPdfBox } from './types.js';
+export declare const getEmbedPdfPages: (arg: {
+    template: Template;
+    pdfDoc: PDFDocument;
+}) => Promise<{
+    basePages: (PDFEmbeddedPage | PDFPage)[];
+    embedPdfBoxes: EmbedPdfBox[];
+}>;
+export declare const validateRequiredFields: (template: Template, inputs: Record<string, unknown>[]) => void;
+export declare const preprocessing: (arg: {
+    template: Template;
+    userPlugins: Plugins;
+}) => Promise<{
+    pdfDoc: PDFDocument;
+    renderObj: Record<string, (arg: PDFRenderProps<Schema & {
+        [key: string]: unknown;
+    }>) => Promise<void> | void>;
+}>;
+export declare const postProcessing: (props: {
+    pdfDoc: PDFDocument;
+    options: GeneratorOptions;
+}) => void;
+export declare const insertPage: (arg: {
+    basePage: PDFEmbeddedPage | PDFPage;
+    embedPdfBox: EmbedPdfBox;
+    pdfDoc: PDFDocument;
+}) => PDFPage;

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

@@ -0,0 +1,2 @@
+import generate from './generate.js';
+export { generate };

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

@@ -0,0 +1,20 @@
+export 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;
+    };
+};

package/eslint.config.mjs

@@ -0,0 +1,22 @@
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Import the root config
+const rootConfigPath = resolve(__dirname, '../../eslint.config.mjs');
+const rootConfig = await import(rootConfigPath);
+
+export default [
+  ...rootConfig.default,
+  {
+    files: ['src/**/*.ts'],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.esm.json'],
+        tsconfigRootDir: __dirname,
+      },
+    },
+  },
+];

package/jest.setup.js

@@ -0,0 +1,2 @@
+const { toMatchImageSnapshot } = require('jest-image-snapshot');
+expect.extend({ toMatchImageSnapshot });

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@pdfme/generator",
+  "version": "0.0.0",
+  "sideEffects": false,
+  "author": "hand-dot",
+  "license": "MIT",
+  "keywords": [
+    "pdf",
+    "pdf-generation",
+    "pdf-designer",
+    "pdf-viewer",
+    "typescript",
+    "react"
+  ],
+  "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": {
+    "type": "git",
+    "url": "git@github.com:pdfme/pdfme.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pdfme/pdfme/issues"
+  },
+  "main": "dist/cjs/src/index.js",
+  "module": "dist/esm/src/index.js",
+  "types": "dist/types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./dist/node/src/index.js",
+        "default": "./dist/esm/src/index.js"
+      },
+      "require": "./dist/cjs/src/index.js",
+      "types": "./dist/types/src/index.d.ts"
+    }
+  },
+  "scripts": {
+    "dev": "tsc -p tsconfig.esm.json -w",
+    "build": "run-p build:cjs build:esm build:node",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:node": "tsc -p tsconfig.node.json",
+    "clean": "rimraf dist",
+    "lint": "eslint --ext .ts src --config eslint.config.mjs",
+    "test": "jest",
+    "test:update-snapshots": "jest --updateSnapshot",
+    "prune": "ts-prune src",
+    "prettier": "prettier --write 'src/**/*.ts'"
+  },
+  "dependencies": {
+    "@pdfme/pdf-lib": "*",
+    "fontkit": "^2.0.2"
+  },
+  "devDependencies": {
+    "@pdfme/common": "*",
+    "@pdfme/converter": "*",
+    "@pdfme/schemas": "*"
+  },
+  "peerDependencies": {
+    "@pdfme/common": "latest",
+    "@pdfme/schemas": "latest"
+  },
+  "jest": {
+    "resolver": "ts-jest-resolver",
+    "setupFilesAfterEnv": [
+      "<rootDir>/jest.setup.js"
+    ],
+    "moduleNameMapper": {
+      "^@pdfme/schemas/utils$": "<rootDir>/../schemas/src/utils.ts",
+      "^.+\\\\.(css|less|scss)$": "identity-obj-proxy"
+    },
+    "transformIgnorePatterns": [
+      "/node_modules/(?!(air-datepicker)/)"
+    ],
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "transform": {
+      "^.+\\.ts?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.esm.json"
+        }
+      ],
+      "^.+\\.css$": "<rootDir>/__tests__/cssTransform.cjs"
+    },
+    "testMatch": [
+      "**/*.test.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/constants.ts

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

package/src/generate.ts

@@ -0,0 +1,167 @@
+import * as pdfLib from '@pdfme/pdf-lib';
+import type { GenerateProps, Schema, PDFRenderProps, Template } from '@pdfme/common';
+import {
+  checkGenerateProps,
+  getDynamicTemplate,
+  isBlankPdf,
+  replacePlaceholders,
+  pt2mm,
+  cloneDeep,
+} from '@pdfme/common';
+import { getDynamicHeightsForTable } from '@pdfme/schemas';
+import {
+  insertPage,
+  preprocessing,
+  postProcessing,
+  getEmbedPdfPages,
+  validateRequiredFields,
+} from './helper.js';
+
+const generate = async (props: GenerateProps): Promise<Uint8Array<ArrayBuffer>> => {
+  checkGenerateProps(props);
+  const { inputs, template: _template, options = {}, plugins: userPlugins = {} } = props;
+  const template = cloneDeep(_template);
+
+  const basePdf = template.basePdf;
+
+  if (inputs.length === 0) {
+    throw new Error(
+      '[@pdfme/generator] inputs should not be empty, pass at least an empty object in the array',
+    );
+  }
+
+  validateRequiredFields(template, inputs);
+
+  const { pdfDoc, renderObj } = await preprocessing({ template, userPlugins });
+
+  const _cache = new Map<string, unknown>();
+
+  for (let i = 0; i < inputs.length; i += 1) {
+    const input = inputs[i];
+
+    // Get the dynamic template with proper typing
+    const dynamicTemplate: Template = await getDynamicTemplate({
+      template,
+      input,
+      options,
+      _cache,
+      getDynamicHeights: (value, args) => {
+        switch (args.schema.type) {
+          case 'table':
+            return getDynamicHeightsForTable(value, args);
+          default:
+            return Promise.resolve([args.schema.height]);
+        }
+      },
+    });
+    const { basePages, embedPdfBoxes } = await getEmbedPdfPages({
+      template: dynamicTemplate,
+      pdfDoc,
+    });
+
+    // Add proper type assertion for dynamicTemplate.schemas
+    const schemas = dynamicTemplate.schemas as Schema[][];
+    // Create a type-safe array of schema names without using Set spread which requires downlevelIteration
+    const schemaNameSet = new Set<string>();
+    schemas.forEach((page: Schema[]) => {
+      page.forEach((schema: Schema) => {
+        if (schema.name) {
+          schemaNameSet.add(schema.name);
+        }
+      });
+    });
+    const schemaNames = Array.from(schemaNameSet);
+
+    for (let j = 0; j < basePages.length; j += 1) {
+      const basePage = basePages[j];
+      const embedPdfBox = embedPdfBoxes[j];
+
+      const boundingBoxLeft =
+        basePage instanceof pdfLib.PDFEmbeddedPage ? pt2mm(embedPdfBox.mediaBox.x) : 0;
+      const boundingBoxBottom =
+        basePage instanceof pdfLib.PDFEmbeddedPage ? pt2mm(embedPdfBox.mediaBox.y) : 0;
+
+      const page = insertPage({ basePage, embedPdfBox, pdfDoc });
+
+      if (isBlankPdf(basePdf) && basePdf.staticSchema) {
+        for (let k = 0; k < basePdf.staticSchema.length; k += 1) {
+          const staticSchema = basePdf.staticSchema[k];
+          const render = renderObj[staticSchema.type];
+          if (!render) {
+            continue;
+          }
+          const value = staticSchema.readOnly
+            ? replacePlaceholders({
+                content: staticSchema.content || '',
+                variables: { ...input, totalPages: basePages.length, currentPage: j + 1 },
+                schemas: schemas, // Use the properly typed schemas variable
+              })
+            : staticSchema.content || '';
+
+          staticSchema.position = {
+            x: staticSchema.position.x + boundingBoxLeft,
+            y: staticSchema.position.y - boundingBoxBottom,
+          };
+
+          // Create properly typed render props for static schema
+          const staticRenderProps: PDFRenderProps<Schema> = {
+            value,
+            schema: staticSchema,
+            basePdf,
+            pdfLib,
+            pdfDoc,
+            page,
+            options,
+            _cache,
+          };
+          await render(staticRenderProps);
+        }
+      }
+
+      for (let l = 0; l < schemaNames.length; l += 1) {
+        const name = schemaNames[l];
+        const schemaPage = schemas[j] || [];
+        const schema = schemaPage.find((s: Schema) => s.name == name);
+        if (!schema) {
+          continue;
+        }
+
+        const render = renderObj[schema.type];
+        if (!render) {
+          continue;
+        }
+        const value: string = schema.readOnly
+          ? replacePlaceholders({
+              content: schema.content || '',
+              variables: { ...input, totalPages: basePages.length, currentPage: j + 1 },
+              schemas: schemas, // Use the properly typed schemas variable
+            })
+          : ((input[name] || '') as string);
+
+        schema.position = {
+          x: schema.position.x + boundingBoxLeft,
+          y: schema.position.y - boundingBoxBottom,
+        };
+
+        // Create properly typed render props
+        const renderProps: PDFRenderProps<Schema> = {
+          value,
+          schema,
+          basePdf,
+          pdfLib,
+          pdfDoc,
+          page,
+          options,
+          _cache,
+        };
+        await render(renderProps);
+      }
+    }
+  }
+
+  postProcessing({ pdfDoc, options });
+
+  return pdfDoc.save();
+};
+
+export default generate;

package/src/helper.ts

@@ -0,0 +1,172 @@
+import * as fontkit from 'fontkit';
+import {
+  Schema,
+  Plugins,
+  GeneratorOptions,
+  Template,
+  PDFRenderProps,
+  getB64BasePdf,
+  isBlankPdf,
+  mm2pt,
+  pluginRegistry,
+  BasePdf,
+} from '@pdfme/common';
+import { builtInPlugins } from '@pdfme/schemas';
+import { PDFPage, PDFDocument, PDFEmbeddedPage, TransformationMatrix } from '@pdfme/pdf-lib';
+import { TOOL_NAME } from './constants.js';
+import type { EmbedPdfBox } from './types.js';
+
+export const getEmbedPdfPages = async (arg: { template: Template; pdfDoc: PDFDocument }) => {
+  const {
+    template: { schemas, basePdf },
+    pdfDoc,
+  } = arg as { template: { schemas: Schema[][]; basePdf: BasePdf }; pdfDoc: PDFDocument };
+  let basePages: (PDFEmbeddedPage | PDFPage)[] = [];
+  let embedPdfBoxes: EmbedPdfBox[] = [];
+
+  if (isBlankPdf(basePdf)) {
+    const { width: _width, height: _height } = basePdf;
+    const width = mm2pt(_width);
+    const height = mm2pt(_height);
+    basePages = schemas.map(() => {
+      const page = PDFPage.create(pdfDoc);
+      page.setSize(width, height);
+      return page;
+    });
+    embedPdfBoxes = schemas.map(() => ({
+      mediaBox: { x: 0, y: 0, width, height },
+      bleedBox: { x: 0, y: 0, width, height },
+      trimBox: { x: 0, y: 0, width, height },
+    }));
+  } else {
+    const willLoadPdf = await getB64BasePdf(basePdf);
+    const embedPdf = await PDFDocument.load(willLoadPdf);
+    const embedPdfPages = embedPdf.getPages();
+    embedPdfBoxes = embedPdfPages.map((p) => ({
+      mediaBox: p.getMediaBox(),
+      bleedBox: p.getBleedBox(),
+      trimBox: p.getTrimBox(),
+    }));
+    const boundingBoxes = embedPdfPages.map((p) => {
+      const { x, y, width, height } = p.getMediaBox();
+      return { left: x, bottom: y, right: width, top: height + y };
+    });
+    const transformationMatrices = embedPdfPages.map(
+      () => [1, 0, 0, 1, 0, 0] as TransformationMatrix,
+    );
+    basePages = await pdfDoc.embedPages(embedPdfPages, boundingBoxes, transformationMatrices);
+  }
+  return { basePages, embedPdfBoxes };
+};
+
+export const validateRequiredFields = (template: Template, inputs: Record<string, unknown>[]) => {
+  (template.schemas as Schema[][]).forEach((schemaPage: Schema[]) =>
+    schemaPage.forEach((schema: Schema) => {
+      if (schema.required && !schema.readOnly && !inputs.some((input) => input[schema.name])) {
+        throw new Error(
+          `[@pdfme/generator] input for '${schema.name}' is required to generate this PDF`,
+        );
+      }
+    }),
+  );
+};
+
+export const preprocessing = async (arg: { template: Template; userPlugins: Plugins }) => {
+  const { template, userPlugins } = arg;
+  const { schemas, basePdf } = template as { schemas: Schema[][]; basePdf: BasePdf };
+  const staticSchema: Schema[] = isBlankPdf(basePdf) ? (basePdf.staticSchema ?? []) : [];
+
+  const pdfDoc = await PDFDocument.create();
+  // @ts-expect-error registerFontkit method is not in type definitions but exists at runtime
+  pdfDoc.registerFontkit(fontkit);
+
+  const plugins = pluginRegistry(
+    Object.values(userPlugins).length > 0 ? userPlugins : builtInPlugins,
+  );
+
+  const schemaTypes = Array.from(
+    new Set(
+      schemas
+        .flatMap((schemaPage: Schema[]) => schemaPage.map((schema: Schema) => schema.type))
+        .concat(staticSchema.map((schema: Schema) => schema.type)),
+    ),
+  );
+
+  const renderObj = schemaTypes.reduce(
+    (
+      acc: Record<
+        string,
+        (arg: PDFRenderProps<Schema & { [key: string]: unknown }>) => Promise<void> | void
+      >,
+      type: string,
+    ) => {
+      const plugin = plugins.findByType(type);
+
+      if (!plugin || !plugin.pdf) {
+        throw new Error(`[@pdfme/generator] Plugin or renderer for type ${type} not found.
+Check this document: https://pdfme.com/docs/custom-schemas`);
+      }
+
+      // Use type assertion to handle the pdf function with schema type
+      return {
+        ...acc,
+        [type]: plugin.pdf as (
+          arg: PDFRenderProps<Schema & { [key: string]: unknown }>,
+        ) => Promise<void> | void,
+      };
+    },
+    {} as Record<
+      string,
+      (arg: PDFRenderProps<Schema & { [key: string]: unknown }>) => Promise<void> | void
+    >,
+  );
+
+  return { pdfDoc, renderObj };
+};
+
+export const postProcessing = (props: { pdfDoc: PDFDocument; options: GeneratorOptions }) => {
+  const { pdfDoc, options } = props;
+  const {
+    author = TOOL_NAME,
+    creationDate = new Date(),
+    creator = TOOL_NAME,
+    keywords = [],
+    lang = 'en',
+    modificationDate = new Date(),
+    producer = TOOL_NAME,
+    subject = '',
+    title = '',
+  } = options;
+  pdfDoc.setAuthor(author);
+  pdfDoc.setCreationDate(creationDate);
+  pdfDoc.setCreator(creator);
+  pdfDoc.setKeywords(keywords);
+  pdfDoc.setLanguage(lang);
+  pdfDoc.setModificationDate(modificationDate);
+  pdfDoc.setProducer(producer);
+  pdfDoc.setSubject(subject);
+  pdfDoc.setTitle(title);
+};
+
+export const insertPage = (arg: {
+  basePage: PDFEmbeddedPage | PDFPage;
+  embedPdfBox: EmbedPdfBox;
+  pdfDoc: PDFDocument;
+}) => {
+  const { basePage, embedPdfBox, pdfDoc } = arg;
+  const size = basePage instanceof PDFEmbeddedPage ? basePage.size() : basePage.getSize();
+  const insertedPage =
+    basePage instanceof PDFEmbeddedPage
+      ? pdfDoc.addPage([size.width, size.height])
+      : pdfDoc.addPage(basePage);
+
+  if (basePage instanceof PDFEmbeddedPage) {
+    insertedPage.drawPage(basePage);
+    const { mediaBox, bleedBox, trimBox } = embedPdfBox;
+    insertedPage.setMediaBox(mediaBox.x, mediaBox.y, mediaBox.width, mediaBox.height);
+    insertedPage.setBleedBox(bleedBox.x, bleedBox.y, bleedBox.width, bleedBox.height);
+    insertedPage.setTrimBox(trimBox.x, trimBox.y, trimBox.width, trimBox.height);
+  }
+
+  return insertedPage;
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+import generate from './generate.js';
+
+export { generate };

package/src/types.ts

@@ -0,0 +1,5 @@
+export 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 };
+};

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "./dist/cjs",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "skipLibCheck": true
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist/esm",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "skipLibCheck": true
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.esm",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@pdfme/common": [
+        "packages/common/dist/esm/src"
+      ],
+      "@pdfme/schemas": [
+        "packages/schemas/dist/esm/src"
+      ],
+      "@pdfme/schemas/utils": [
+        "packages/schemas/dist/esm/src/utils"
+      ]
+    }
+  },
+}

package/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist/node",
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "skipLibCheck": true
+  }
+}