@pdfme/common 1.0.0-beta.10

package/dist/types/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';
+declare type CommonSchema = z.infer<typeof _CommonSchema>;
+export declare const schemaTypes: readonly ["text", "image", "qrcode", "japanpost", "ean13", "ean8", "code39", "code128", "nw7", "itf14", "upca", "upce"];
+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";
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+};
+export declare const isImageSchema: (arg: CommonSchema) => arg is {
+    rotate?: number | undefined;
+    type: "image";
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+};
+export declare const isBarcodeSchema: (arg: CommonSchema) => arg is {
+    rotate?: number | undefined;
+    type: "qrcode" | "japanpost" | "ean13" | "ean8" | "code39" | "code128" | "nw7" | "itf14" | "upca" | "upce";
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+};
+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 type BarCodeType = z.infer<typeof BarcodeSchemaType>;
+export declare type TextSchema = z.infer<typeof TextSchema>;
+export declare type ImageSchema = z.infer<typeof ImageSchema>;
+export declare type BarcodeSchema = z.infer<typeof BarcodeSchema>;
+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/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@pdfme/common",
+  "version": "1.0.0-beta.10",
+  "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": {
+    "type": "git",
+    "url": "git@github.com:pdfme/pdfme.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pdfme/pdfme/issues"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "develop": "webpack --watch --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": {
+    "zod": "^3.11.6"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "\\.(ttf)$": "<rootDir>../../fontTransformer.js"
+    },
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "testMatch": [
+      "**/*.test.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/constants.ts

@@ -0,0 +1,8 @@
+export const DEFAULT_FONT_SIZE = 13;
+export const DEFAULT_ALIGNMENT = 'left';
+export const DEFAULT_LINE_HEIGHT = 1;
+export const DEFAULT_CHARACTER_SPACING = 0;
+export const DEFAULT_FONT_COLOR = '#000';
+
+export const BLANK_PDF =
+  'data:application/pdf;base64,JVBERi0xLjcKJeLjz9MKNSAwIG9iago8PAovRmlsdGVyIC9GbGF0ZURlY29kZQovTGVuZ3RoIDM4Cj4+CnN0cmVhbQp4nCvkMlAwUDC1NNUzMVGwMDHUszRSKErlCtfiyuMK5AIAXQ8GCgplbmRzdHJlYW0KZW5kb2JqCjQgMCBvYmoKPDwKL1R5cGUgL1BhZ2UKL01lZGlhQm94IFswIDAgNTk1LjQ0IDg0MS45Ml0KL1Jlc291cmNlcyA8PAo+PgovQ29udGVudHMgNSAwIFIKL1BhcmVudCAyIDAgUgo+PgplbmRvYmoKMiAwIG9iago8PAovVHlwZSAvUGFnZXMKL0tpZHMgWzQgMCBSXQovQ291bnQgMQo+PgplbmRvYmoKMSAwIG9iago8PAovVHlwZSAvQ2F0YWxvZwovUGFnZXMgMiAwIFIKPj4KZW5kb2JqCjMgMCBvYmoKPDwKL3RyYXBwZWQgKGZhbHNlKQovQ3JlYXRvciAoU2VyaWYgQWZmaW5pdHkgRGVzaWduZXIgMS4xMC40KQovVGl0bGUgKFVudGl0bGVkLnBkZikKL0NyZWF0aW9uRGF0ZSAoRDoyMDIyMDEwNjE0MDg1OCswOScwMCcpCi9Qcm9kdWNlciAoaUxvdmVQREYpCi9Nb2REYXRlIChEOjIwMjIwMTA2MDUwOTA5WikKPj4KZW5kb2JqCjYgMCBvYmoKPDwKL1NpemUgNwovUm9vdCAxIDAgUgovSW5mbyAzIDAgUgovSUQgWzwyODhCM0VENTAyOEU0MDcyNERBNzNCOUE0Nzk4OUEwQT4gPEY1RkJGNjg4NkVERDZBQUNBNDRCNEZDRjBBRDUxRDlDPl0KL1R5cGUgL1hSZWYKL1cgWzEgMiAyXQovRmlsdGVyIC9GbGF0ZURlY29kZQovSW5kZXggWzAgN10KL0xlbmd0aCAzNgo+PgpzdHJlYW0KeJxjYGD4/5+RUZmBgZHhFZBgDAGxakAEP5BgEmFgAABlRwQJCmVuZHN0cmVhbQplbmRvYmoKc3RhcnR4cmVmCjUzMgolJUVPRgo=';

package/src/helper.ts

@@ -0,0 +1,214 @@
+import { z } from 'zod';
+import Helvetica from './assets/Helvetica.ttf';
+import { Template, Schema, BasePdf, Font, CommonProps, isTextSchema, BarCodeType } from './type';
+import {
+  Template as TemplateSchema,
+  PreviewProps as PreviewPropsSchema,
+  DesignerProps as DesignerPropsSchema,
+  GenerateProps as GeneratePropsSchema,
+  UIProps as UIPropsSchema,
+} from './schema';
+
+const DEFAULT_FONT_NAME = 'Helvetica';
+
+const blob2Base64Pdf = (blob: Blob) => {
+  return new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      if ((reader.result as string).startsWith('data:application/pdf;')) {
+        resolve(reader.result as string);
+      } else {
+        reject(Error('template.basePdf must be pdf data.'));
+      }
+    };
+    reader.readAsDataURL(blob);
+  });
+};
+
+export const getB64BasePdf = (basePdf: BasePdf) => {
+  const needFetchFromNetwork =
+    typeof basePdf === 'string' && !basePdf.startsWith('data:application/pdf;');
+  if (needFetchFromNetwork && typeof window !== 'undefined') {
+    return fetch(basePdf)
+      .then((res) => res.blob())
+      .then(blob2Base64Pdf)
+      .catch((e: Error) => {
+        throw e;
+      });
+  }
+
+  return basePdf as string;
+};
+
+const getByteString = (base64: string) => {
+  if (typeof window !== 'undefined' && window.atob) {
+    return window.atob(base64);
+  } else {
+    return Buffer.from(base64, 'base64').toString('binary');
+  }
+};
+
+export const b64toUint8Array = (base64: string) => {
+  const data = base64.split(';base64,')[1] ? base64.split(';base64,')[1] : base64;
+
+  const byteString = getByteString(data);
+
+  const unit8arr = new Uint8Array(byteString.length);
+  for (let i = 0; i < byteString.length; i += 1) {
+    unit8arr[i] = byteString.charCodeAt(i);
+  }
+  return unit8arr;
+};
+
+export const getFallbackFontName = (font: Font) => {
+  const initial = '';
+  const fallbackFontName = Object.entries(font).reduce((acc, cur) => {
+    const [fontName, fontValue] = cur;
+
+    return !acc && fontValue.fallback ? fontName : acc;
+  }, initial);
+  if (fallbackFontName === initial) {
+    throw Error(`fallback flag is not found in font. true fallback flag must be only one.`);
+  }
+
+  return fallbackFontName;
+};
+
+export const getDefaultFont = (): Font => ({
+  [DEFAULT_FONT_NAME]: { data: b64toUint8Array(Helvetica), fallback: true },
+});
+
+const uniq = <T>(array: Array<T>) => Array.from(new Set(array));
+
+const getFontNamesInSchemas = (schemas: { [key: string]: Schema }[]) =>
+  uniq(
+    schemas
+      .map((s) => Object.values(s).map((v) => (isTextSchema(v) ? v.fontName : '')))
+      .reduce((acc, cur) => acc.concat(cur), [] as (string | undefined)[])
+      .filter(Boolean) as string[]
+  );
+
+export const checkFont = (arg: { font: Font; template: Template }) => {
+  const {
+    font,
+    template: { schemas },
+  } = arg;
+  const fontValues = Object.values(font);
+  const fallbackFontNum = fontValues.reduce((acc, cur) => (cur.fallback ? acc + 1 : acc), 0);
+  if (fallbackFontNum === 0) {
+    throw Error(`fallback flag is not found in font. true fallback flag must be only one.`);
+  }
+  if (fallbackFontNum > 1) {
+    throw Error(
+      `${fallbackFontNum} fallback flags found in font. true fallback flag must be only one.`
+    );
+  }
+
+  const fontNamesInSchemas = getFontNamesInSchemas(schemas);
+  const fontNames = Object.keys(font);
+  if (fontNamesInSchemas.some((f) => !fontNames.includes(f))) {
+    throw Error(
+      `${fontNamesInSchemas
+        .filter((f) => !fontNames.includes(f))
+        .join()} of template.schemas is not found in font.`
+    );
+  }
+};
+
+const checkProps = <T>(data: unknown, zodSchema: z.ZodType<T>) => {
+  try {
+    zodSchema.parse(data);
+  } catch (e) {
+    if (e instanceof z.ZodError) {
+      const messages = e.issues.map(
+        (issue) => `ERROR POSITION: ${issue.path.join('.')}
+ERROR MESSAGE: ${issue.message}
+--------------------------`
+      );
+
+      const message = messages.join('\n');
+      throw Error(`Invalid argument:
+--------------------------
+${message}`);
+    }
+  }
+  const commonProps = data as CommonProps;
+  const { template, options } = commonProps;
+  const font = options?.font;
+  if (font) {
+    checkFont({ font, template });
+  }
+};
+
+export const checkTemplate = (data: unknown) => checkProps(data, TemplateSchema);
+export const checkUIProps = (data: unknown) => checkProps(data, UIPropsSchema);
+export const checkPreviewProps = (data: unknown) => checkProps(data, PreviewPropsSchema);
+export const checkDesignerProps = (data: unknown) => checkProps(data, DesignerPropsSchema);
+export const checkGenerateProps = (data: unknown) => checkProps(data, GeneratePropsSchema);
+
+export const validateBarcodeInput = (type: BarCodeType, input: string) => {
+  if (!input) return false;
+  if (type === 'qrcode') {
+    // 500文字以下
+    return input.length < 500;
+  }
+  if (type === 'japanpost') {
+    // 郵便番号は数字(0-9)のみ。住所表示番号は英数字(0-9,A-Z)とハイフン(-)が使用可能です。
+    const regexp = /^(\d{7})(\d|[A-Z]|-)+$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'ean13') {
+    // 有効文字は数値(0-9)のみ。チェックデジットを含まない12桁orチェックデジットを含む13桁。
+    const regexp = /^\d{12}$|^\d{13}$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'ean8') {
+    // 有効文字は数値(0-9)のみ。チェックデジットを含まない7桁orチェックデジットを含む8桁。
+    const regexp = /^\d{7}$|^\d{8}$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'code39') {
+    // 有効文字は数字(0-9)。アルファベット大文字(A-Z)、記号(-.$/+%)、半角スペース。
+    const regexp = /^(\d|[A-Z]|\-|\.|\$|\/|\+|\%|\s)+$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'code128') {
+    // 有効文字は漢字、ひらがな、カタカナ以外。
+    // https://qiita.com/graminume/items/2ac8dd9c32277fa9da64
+    return !input.match(
+      /([\u30a0-\u30ff\u3040-\u309f\u3005-\u3006\u30e0-\u9fcf]|[Ａ-Ｚａ-ｚ０-９！＂＃＄％＆＇（）＊＋，－．／：；＜＝＞？＠［＼］＾＿｀｛｜｝〜])+/
+    );
+  }
+  if (type === 'nw7') {
+    // 有効文字はNW-7は数字(0-9)と記号(-.$:/+)。
+    // スタートコード／ストップコードとして、コードの始まりと終わりはアルファベット(A-D)のいずれかを使用してください。
+    const regexp = /^[A-Da-d]([0-9\-\.\$\:\/\+])+[A-Da-d]$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'itf14') {
+    // 有効文字は数値(0-9)のみ。 チェックデジットを含まない13桁orチェックデジットを含む14桁。
+    const regexp = /^\d{13}$|^\d{14}$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'upca') {
+    // 有効文字は数値(0-9)のみ。 チェックデジットを含まない11桁orチェックデジットを含む12桁。
+    const regexp = /^\d{11}$|^\d{12}$/;
+
+    return regexp.test(input);
+  }
+  if (type === 'upce') {
+    // 有効文字は数値(0-9)のみ。 1桁目に指定できる数字(ナンバーシステムキャラクタ)は0のみ。
+    // チェックデジットを含まない7桁orチェックデジットを含む8桁。
+    const regexp = /^0(\d{6}$|\d{7}$)/;
+
+    return regexp.test(input);
+  }
+
+  return false;
+};

package/src/index.ts

@@ -0,0 +1,95 @@
+import {
+  DEFAULT_FONT_SIZE,
+  DEFAULT_ALIGNMENT,
+  DEFAULT_LINE_HEIGHT,
+  DEFAULT_CHARACTER_SPACING,
+  DEFAULT_FONT_COLOR,
+  BLANK_PDF,
+} from './constants';
+import { schemaTypes, isImageSchema, isBarcodeSchema, isTextSchema } from './type';
+import type {
+  Lang,
+  Size,
+  Alignment,
+  SchemaType,
+  BarCodeType,
+  TextSchema,
+  ImageSchema,
+  BarcodeSchema,
+  Schema,
+  SchemaForUI,
+  Font,
+  BasePdf,
+  Template,
+  CommonProps,
+  GeneratorOptions,
+  GenerateProps,
+  UIOptions,
+  UIProps,
+  PreviewProps,
+  PreviewReactProps,
+  DesignerProps,
+  DesignerReactProps,
+} from './type';
+import {
+  getB64BasePdf,
+  b64toUint8Array,
+  getFallbackFontName,
+  getDefaultFont,
+  checkFont,
+  checkTemplate,
+  checkUIProps,
+  checkPreviewProps,
+  checkDesignerProps,
+  checkGenerateProps,
+  validateBarcodeInput,
+} from './helper';
+
+export {
+  DEFAULT_FONT_SIZE,
+  DEFAULT_ALIGNMENT,
+  DEFAULT_LINE_HEIGHT,
+  DEFAULT_CHARACTER_SPACING,
+  DEFAULT_FONT_COLOR,
+  BLANK_PDF,
+  schemaTypes,
+  isTextSchema,
+  isImageSchema,
+  isBarcodeSchema,
+  getB64BasePdf,
+  b64toUint8Array,
+  getFallbackFontName,
+  getDefaultFont,
+  checkFont,
+  checkTemplate,
+  checkUIProps,
+  checkPreviewProps,
+  checkDesignerProps,
+  checkGenerateProps,
+  validateBarcodeInput,
+};
+
+export type {
+  Lang,
+  Size,
+  Alignment,
+  SchemaType,
+  BarCodeType,
+  TextSchema,
+  ImageSchema,
+  BarcodeSchema,
+  Schema,
+  SchemaForUI,
+  Font,
+  BasePdf,
+  Template,
+  CommonProps,
+  GeneratorOptions,
+  GenerateProps,
+  UIOptions,
+  UIProps,
+  PreviewProps,
+  PreviewReactProps,
+  DesignerProps,
+  DesignerReactProps,
+};

package/src/schema.ts

@@ -0,0 +1,118 @@
+/* eslint dot-notation: "off"*/
+import { z } from 'zod';
+
+const langs = ['en', 'ja'] as const;
+export const Lang = z.enum(langs);
+
+export const Size = z.object({ height: z.number(), width: z.number() });
+
+const alignments = ['left', 'center', 'right'] as const;
+export const Alignment = z.enum(alignments);
+
+// prettier-ignore
+export const barcodeSchemaTypes = ['qrcode', 'japanpost', 'ean13', 'ean8', 'code39', 'code128', 'nw7', 'itf14', 'upca', 'upce'] as const;
+const notBarcodeSchemaTypes = ['text', 'image'] as const;
+export const schemaTypes = [...notBarcodeSchemaTypes, ...barcodeSchemaTypes] as const;
+
+export const BarcodeSchemaType = z.enum(barcodeSchemaTypes);
+export const SchemaType = z.enum(schemaTypes);
+
+export const CommonSchema = z.object({
+  type: SchemaType,
+  position: z.object({ x: z.number(), y: z.number() }),
+  width: z.number(),
+  height: z.number(),
+  rotate: z.number().optional(),
+});
+
+export const TextSchema = CommonSchema.extend({
+  type: z.literal(SchemaType.Enum.text),
+  alignment: Alignment.optional(),
+  fontSize: z.number().optional(),
+  fontName: z.string().optional(),
+  fontColor: z.string().optional(),
+  backgroundColor: z.string().optional(),
+  characterSpacing: z.number().optional(),
+  lineHeight: z.number().optional(),
+});
+
+export const ImageSchema = CommonSchema.extend({ type: z.literal(SchemaType.Enum.image) });
+
+export const BarcodeSchema = CommonSchema.extend({ type: BarcodeSchemaType });
+
+export const Schema = z.union([TextSchema, ImageSchema, BarcodeSchema]);
+
+const SchemaForUIAdditionalInfo = z.object({ id: z.string(), key: z.string(), data: z.string() });
+export const SchemaForUI = z.union([
+  TextSchema.merge(SchemaForUIAdditionalInfo),
+  ImageSchema.merge(SchemaForUIAdditionalInfo),
+  BarcodeSchema.merge(SchemaForUIAdditionalInfo),
+]);
+
+const ArrayBufferSchema: z.ZodSchema<ArrayBuffer> = z.any().refine((v) => v instanceof ArrayBuffer);
+const Uint8ArraySchema: z.ZodSchema<Uint8Array> = z.any().refine((v) => v instanceof Uint8Array);
+const Data = z.union([ArrayBufferSchema, Uint8ArraySchema]);
+
+export const Font = z.record(
+  z.object({ data: Data, fallback: z.boolean().optional(), subset: z.boolean().optional() })
+);
+
+export const BasePdf = z.union([z.string(), Data]);
+
+export const Template = z.object({
+  schemas: z.array(z.record(Schema)),
+  basePdf: BasePdf,
+  sampledata: z.array(z.record(z.string())).length(1).optional(),
+  columns: z.array(z.string()).optional(),
+});
+
+const Inputs = z.array(z.record(z.string())).min(1);
+
+const CommonOptions = z.object({ font: Font.optional() });
+
+export const CommonProps = z.object({
+  template: Template,
+  options: CommonOptions.optional(),
+});
+
+// -------------------generate-------------------
+
+export const GeneratorOptions = CommonOptions.extend({
+  splitThreshold: z.number().optional(),
+});
+
+export const GenerateProps = CommonProps.extend({
+  inputs: Inputs,
+  options: GeneratorOptions.optional(),
+}).strict();
+
+// ---------------------------------------------
+
+export const UIOptions = CommonOptions.extend({ lang: Lang.optional() });
+
+const HTMLElementSchema: z.ZodSchema<HTMLElement> = z.any().refine((v) => v instanceof HTMLElement);
+
+export const UIProps = CommonProps.extend({
+  domContainer: HTMLElementSchema,
+  options: UIOptions.optional(),
+});
+
+// -----------------Form, Viewer-----------------
+
+export const PreviewProps = UIProps.extend({ inputs: Inputs }).strict();
+export const PreviewReactProps = PreviewProps.omit({ domContainer: true }).extend({
+  onChangeInput: z
+    .function()
+    .args(z.object({ index: z.number(), value: z.string(), key: z.string() }))
+    .returns(z.void())
+    .optional(),
+  size: Size,
+});
+
+// ---------------Designer---------------
+
+export const DesignerProps = UIProps.extend({}).strict();
+export const DesignerReactProps = DesignerProps.omit({ domContainer: true }).extend({
+  onSaveTemplate: z.function().args(Template).returns(z.void()),
+  size: Size,
+});

package/src/type.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import {
+  Lang,
+  Size,
+  Alignment,
+  barcodeSchemaTypes,
+  schemaTypes as _schemaTypes,
+  BarcodeSchemaType,
+  SchemaType,
+  CommonSchema as _CommonSchema,
+  TextSchema,
+  ImageSchema,
+  BarcodeSchema,
+  Schema,
+  SchemaForUI,
+  Font,
+  BasePdf,
+  Template,
+  CommonProps,
+  GeneratorOptions,
+  GenerateProps,
+  UIOptions,
+  UIProps,
+  PreviewProps,
+  PreviewReactProps,
+  DesignerProps,
+  DesignerReactProps,
+} from './schema';
+
+type CommonSchema = z.infer<typeof _CommonSchema>;
+export const schemaTypes = _schemaTypes;
+export const isTextSchema = (arg: CommonSchema): arg is TextSchema => arg.type === 'text';
+export const isImageSchema = (arg: CommonSchema): arg is ImageSchema => arg.type === 'image';
+export const isBarcodeSchema = (arg: CommonSchema): arg is BarcodeSchema =>
+  barcodeSchemaTypes.map((t) => t as string).includes(arg.type);
+
+export type Lang = z.infer<typeof Lang>;
+export type Size = z.infer<typeof Size>;
+export type Alignment = z.infer<typeof Alignment>;
+export type SchemaType = z.infer<typeof SchemaType>;
+export type BarCodeType = z.infer<typeof BarcodeSchemaType>;
+export type TextSchema = z.infer<typeof TextSchema>;
+export type ImageSchema = z.infer<typeof ImageSchema>;
+export type BarcodeSchema = z.infer<typeof BarcodeSchema>;
+export type Schema = z.infer<typeof Schema>;
+export type SchemaForUI = z.infer<typeof SchemaForUI>;
+export type Font = z.infer<typeof Font>;
+export type BasePdf = z.infer<typeof BasePdf>;
+export type Template = z.infer<typeof Template>;
+export type CommonProps = z.infer<typeof CommonProps>;
+export type GeneratorOptions = z.infer<typeof GeneratorOptions>;
+export type GenerateProps = z.infer<typeof GenerateProps>;
+export type UIOptions = z.infer<typeof UIOptions>;
+export type UIProps = z.infer<typeof UIProps>;
+export type PreviewProps = z.infer<typeof PreviewProps>;
+export type PreviewReactProps = z.infer<typeof PreviewReactProps>;
+export type DesignerProps = z.infer<typeof DesignerProps>;
+export type DesignerReactProps = z.infer<typeof DesignerReactProps>;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "noImplicitAny": true,
+    "target": "ES2015",
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "module": "ES2015",
+    "lib": ["es6", "dom", "es2016", "es2017"],
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "types": ["node", "jest", "@types/jest"],
+    "typeRoots": ["node_modules/@types"],
+    "sourceMap": true
+  },
+  "baseUrl": ".",
+  "include": ["declaration.d.ts", "src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/webpack.config.js

@@ -0,0 +1,54 @@
+const path = require('path');
+const webpack = require('webpack');
+// const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+const pkg = require('./package.json');
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+const BANNER = [
+  '@name ' + pkg.name,
+  '@version ' + pkg.version + ' | ' + new Date().toDateString(),
+  '@author ' + pkg.author,
+  '@license ' + pkg.license,
+].join('\n');
+
+const config = {
+  optimization: { minimize: isProduction },
+  resolve: {
+    extensions: ['.ts', '.js'],
+  },
+  plugins: [
+    // new BundleAnalyzerPlugin(),
+    new webpack.BannerPlugin({
+      banner: BANNER,
+      entryOnly: true,
+    }),
+  ],
+  devtool: 'source-map',
+  devServer: {
+    historyApiFallback: false,
+    host: '0.0.0.0',
+  },
+  entry: './src/index.ts',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'index.js',
+    globalObject: 'this',
+    library: {
+      type: 'umd',
+    },
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+      },
+      {
+        test: /\.(ttf)$/i,
+        use: ['url-loader'],
+      },
+    ],
+  },
+};
+module.exports = config;