@pdfme/common 0.0.0

package/src/helper.ts

@@ -0,0 +1,284 @@
+import { z } from 'zod';
+import { Buffer } from 'buffer';
+import {
+  Schema,
+  Template,
+  Font,
+  BasePdf,
+  Plugins,
+  BlankPdf,
+  LegacySchemaPageArray,
+  SchemaPageArray,
+} from './types.js';
+import {
+  Inputs as InputsSchema,
+  UIOptions as UIOptionsSchema,
+  Template as TemplateSchema,
+  PreviewProps as PreviewPropsSchema,
+  DesignerProps as DesignerPropsSchema,
+  GenerateProps as GeneratePropsSchema,
+  UIProps as UIPropsSchema,
+  BlankPdf as BlankPdfSchema,
+} from './schema.js';
+import {
+  MM_TO_PT_RATIO,
+  PT_TO_MM_RATIO,
+  PT_TO_PX_RATIO,
+  DEFAULT_FONT_NAME,
+  DEFAULT_FONT_VALUE,
+} from './constants.js';
+
+export const cloneDeep = structuredClone;
+
+const uniq = <T>(array: Array<T>) => Array.from(new Set(array));
+
+export const getFallbackFontName = (font: Font) => {
+  const initial = '';
+  const fallbackFontName = Object.entries(font).reduce((acc, cur) => {
+    const [fontName, fontValue] = cur as [string, { data: string | ArrayBuffer | Uint8Array; fallback?: boolean; subset?: boolean }];
+
+    return !acc && fontValue.fallback ? fontName : acc;
+  }, initial);
+  if (fallbackFontName === initial) {
+    throw Error(
+      `[@pdfme/common] 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(DEFAULT_FONT_VALUE), fallback: true },
+});
+
+export const mm2pt = (mm: number): number => {
+  return parseFloat(String(mm)) * MM_TO_PT_RATIO;
+};
+
+export const pt2mm = (pt: number): number => {
+  return pt * PT_TO_MM_RATIO;
+};
+
+export const pt2px = (pt: number): number => {
+  return pt * PT_TO_PX_RATIO;
+};
+
+export const px2mm = (px: number): number => {
+  // http://www.endmemo.com/sconvert/millimeterpixel.php
+  const ratio = 0.26458333333333;
+  return parseFloat(String(px)) * ratio;
+};
+
+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('[@pdfme/common] template.basePdf must be pdf data.'));
+      }
+    };
+    reader.readAsDataURL(blob);
+  });
+};
+
+export const isHexValid = (hex: string): boolean => {
+  return /^#(?:[A-Fa-f0-9]{3,4}|[A-Fa-f0-9]{6}|[A-Fa-f0-9]{8})$/i.test(hex);
+};
+
+/**
+ * Migrate from legacy keyed object format to array format
+ * @param template Template
+ */
+export const migrateTemplate = (template: Template) => {
+  if (!template.schemas) {
+    return;
+  }
+
+  if (
+    Array.isArray(template.schemas) &&
+    template.schemas.length > 0 &&
+    !Array.isArray(template.schemas[0])
+  ) {
+    template.schemas = (template.schemas as unknown as LegacySchemaPageArray).map(
+      (page: Record<string, Schema>) =>
+        Object.entries(page).map(([key, value]) => ({
+          ...value,
+          name: key,
+        })),
+    );
+  }
+};
+
+export const getInputFromTemplate = (template: Template): { [key: string]: string }[] => {
+  migrateTemplate(template);
+
+  const input: { [key: string]: string } = {};
+  template.schemas.forEach((page) => {
+    page.forEach((schema) => {
+      if (!schema.readOnly) {
+        input[schema.name] = schema.content || '';
+      }
+    });
+  });
+
+  return [input];
+};
+
+export const getB64BasePdf = async (
+  customPdf: ArrayBuffer | Uint8Array | string,
+): Promise<string> => {
+  if (
+    typeof customPdf === 'string' &&
+    !customPdf.startsWith('data:application/pdf;') &&
+    typeof window !== 'undefined'
+  ) {
+    const response = await fetch(customPdf);
+    const blob = await response.blob();
+    return blob2Base64Pdf(blob);
+  }
+
+  if (typeof customPdf === 'string') {
+    return customPdf;
+  }
+
+  const uint8Array = customPdf instanceof Uint8Array ? customPdf : new Uint8Array(customPdf);
+  return 'data:application/pdf;base64,' + Buffer.from(uint8Array).toString('base64');
+};
+
+export const isBlankPdf = (basePdf: BasePdf): basePdf is BlankPdf =>
+  BlankPdfSchema.safeParse(basePdf).success;
+
+const getByteString = (base64: string) => 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;
+};
+
+const getFontNamesInSchemas = (schemas: SchemaPageArray) =>
+  uniq(
+    schemas
+      .map((p) => p.map((v) => (v as Schema & { fontName?: string }).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 as number);
+  if (fallbackFontNum === 0) {
+    throw Error(
+      `[@pdfme/common] fallback flag is not found in font. true fallback flag must be only one.
+Check this document: https://pdfme.com/docs/custom-fonts#about-font-type`,
+    );
+  }
+  if (fallbackFontNum > 1) {
+    throw Error(
+      `[@pdfme/common] ${fallbackFontNum} fallback flags found in font. true fallback flag must be only one.
+Check this document: https://pdfme.com/docs/custom-fonts#about-font-type`,
+    );
+  }
+
+  const fontNamesInSchemas = getFontNamesInSchemas(schemas);
+  const fontNames = Object.keys(font);
+  if (fontNamesInSchemas.some((f) => !fontNames.includes(f))) {
+    throw Error(
+      `[@pdfme/common] ${fontNamesInSchemas
+        .filter((f) => !fontNames.includes(f))
+        .join()} of template.schemas is not found in font.
+Check this document: https://pdfme.com/docs/custom-fonts`,
+    );
+  }
+};
+
+export const checkPlugins = (arg: { plugins: Plugins; template: Template }) => {
+  const {
+    plugins,
+    template: { schemas },
+  } = arg;
+  const allSchemaTypes = uniq(schemas.map((p) => p.map((v) => v.type)).flat());
+
+  const pluginsSchemaTypes = Object.values(plugins).map((p) =>
+    p ? (p.propPanel.defaultSchema as Schema).type : undefined,
+  );
+
+  if (allSchemaTypes.some((s) => !pluginsSchemaTypes.includes(s))) {
+    throw Error(
+      `[@pdfme/common] ${allSchemaTypes
+        .filter((s) => !pluginsSchemaTypes.includes(s))
+        .join()} of template.schemas is not found in plugins.`,
+    );
+  }
+};
+
+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}
+--------------------------`,
+      );
+      throw Error(`[@pdfme/common] Invalid argument:
+--------------------------
+${messages.join('\n')}`);
+    } else {
+      throw Error(
+        `[@pdfme/common] Unexpected parsing error: ${e instanceof Error ? e.message : String(e)}`,
+      );
+    }
+  }
+
+  // Check fonts if template and options exist
+  if (data && typeof data === 'object' && 'template' in data && 'options' in data) {
+    const { template, options } = data as { template: Template; options: { font?: Font } };
+    if (options && options.font) {
+      checkFont({ font: options.font, template });
+    }
+  }
+
+  // Check plugins if template and plugins exist
+  if (data && typeof data === 'object' && 'template' in data && 'plugins' in data) {
+    const { template, plugins } = data as { template: Template; plugins: Plugins };
+    if (plugins) {
+      checkPlugins({ plugins, template });
+    }
+  }
+};
+
+export const checkInputs = (data: unknown) => checkProps(data, InputsSchema);
+export const checkUIOptions = (data: unknown) => checkProps(data, UIOptionsSchema);
+export const checkPreviewProps = (data: unknown) => checkProps(data, PreviewPropsSchema);
+export const checkDesignerProps = (data: unknown) => checkProps(data, DesignerPropsSchema);
+export const checkUIProps = (data: unknown) => {
+  if (typeof data === 'object' && data !== null && 'template' in data) {
+    migrateTemplate(data.template as Template);
+  }
+  checkProps(data, UIPropsSchema);
+};
+export const checkTemplate = (template: unknown) => {
+  migrateTemplate(template as Template);
+  checkProps(template, TemplateSchema);
+};
+export const checkGenerateProps = (data: unknown) => {
+  if (typeof data === 'object' && data !== null && 'template' in data) {
+    migrateTemplate(data.template as Template);
+  }
+  checkProps(data, GeneratePropsSchema);
+};

package/src/index.ts

@@ -0,0 +1,136 @@
+import { PDFME_VERSION } from './version.js';
+import {
+  MM_TO_PT_RATIO,
+  PT_TO_MM_RATIO,
+  PT_TO_PX_RATIO,
+  BLANK_PDF,
+  BLANK_A4_PDF,
+  CUSTOM_A4_PDF,
+  ZOOM,
+  DEFAULT_FONT_NAME,
+} from './constants.js';
+import type {
+  ChangeSchemaItem,
+  ChangeSchemas,
+  SchemaPageArray,
+  PropPanel,
+  PropPanelSchema,
+  PropPanelWidgetProps,
+  PDFRenderProps,
+  Mode,
+  UIRenderProps,
+  Plugin,
+  Lang,
+  Dict,
+  Size,
+  Schema,
+  SchemaForUI,
+  Font,
+  ColorType,
+  BasePdf,
+  BlankPdf,
+  CustomPdf,
+  Template,
+  CommonOptions,
+  GeneratorOptions,
+  Plugins,
+  PluginRegistry,
+  GenerateProps,
+  UIOptions,
+  UIProps,
+  PreviewProps,
+  DesignerProps,
+} from './types.js';
+import {
+  cloneDeep,
+  getFallbackFontName,
+  getDefaultFont,
+  getB64BasePdf,
+  b64toUint8Array,
+  checkFont,
+  checkInputs,
+  checkUIOptions,
+  checkTemplate,
+  checkUIProps,
+  checkPreviewProps,
+  checkDesignerProps,
+  checkGenerateProps,
+  mm2pt,
+  pt2mm,
+  pt2px,
+  px2mm,
+  isHexValid,
+  getInputFromTemplate,
+  isBlankPdf,
+} from './helper.js';
+import { getDynamicTemplate } from './dynamicTemplate.js';
+import { replacePlaceholders } from './expression.js';
+import { pluginRegistry } from './pluginRegistry.js';
+
+export {
+  PDFME_VERSION,
+  MM_TO_PT_RATIO,
+  PT_TO_MM_RATIO,
+  PT_TO_PX_RATIO,
+  BLANK_PDF,
+  BLANK_A4_PDF,
+  CUSTOM_A4_PDF,
+  ZOOM,
+  DEFAULT_FONT_NAME,
+  cloneDeep,
+  getFallbackFontName,
+  getDefaultFont,
+  getB64BasePdf,
+  b64toUint8Array,
+  mm2pt,
+  pt2mm,
+  pt2px,
+  px2mm,
+  isHexValid,
+  getInputFromTemplate,
+  isBlankPdf,
+  getDynamicTemplate,
+  replacePlaceholders,
+  checkFont,
+  checkInputs,
+  checkUIOptions,
+  checkTemplate,
+  checkUIProps,
+  checkPreviewProps,
+  checkDesignerProps,
+  checkGenerateProps,
+  pluginRegistry,
+};
+
+export type {
+  Lang,
+  Dict,
+  Size,
+  Schema,
+  SchemaForUI,
+  Font,
+  ColorType,
+  BasePdf,
+  BlankPdf,
+  CustomPdf,
+  Template,
+  CommonOptions,
+  GeneratorOptions,
+  Plugin,
+  Plugins,
+  PluginRegistry,
+  GenerateProps,
+  UIOptions,
+  UIProps,
+  PreviewProps,
+  DesignerProps,
+  ChangeSchemaItem,
+  ChangeSchemas,
+  SchemaPageArray,
+  PropPanel,
+  PropPanelSchema,
+  PropPanelWidgetProps,
+  PDFRenderProps,
+  UIRenderProps,
+  Mode,
+};

package/src/pluginRegistry.ts

@@ -0,0 +1,30 @@
+import { Plugins, Plugin, PluginRegistry } from './types.js';
+
+/**
+ * Wraps plugins collection with utility methods
+ */
+export const pluginRegistry = (plugins: Plugins): PluginRegistry => {
+  return {
+    plugins: plugins,
+    entries: (): [string, Plugin][] => Object.entries(plugins),
+    values: (): Plugin[] => Object.values(plugins),
+    exists: (): boolean => Object.values(plugins).length > 0,
+    findWithLabelByType(type: string): [string, Plugin | undefined] {
+      for (const [label, plugin] of Object.entries(this.plugins) as [string, Plugin][]) {
+        if (!plugin || typeof plugin !== 'object') continue;
+        if (!plugin.propPanel || typeof plugin.propPanel !== 'object') continue;
+
+        const defaultSchema = plugin.propPanel.defaultSchema as Record<string, unknown>;
+
+        if (defaultSchema && 'type' in defaultSchema && defaultSchema.type === type) {
+          return [label, plugin];
+        }
+      }
+      return ['', undefined];
+    },
+    findByType(type: string): Plugin | undefined {
+      const [, plugin] = this.findWithLabelByType(type);
+      return plugin;
+    },
+  };
+};

package/src/schema.ts

@@ -0,0 +1,223 @@
+import { z } from 'zod';
+
+const langs = ['en', 'zh', 'ja', 'ko', 'ar', 'th', 'pl', 'it', 'de', 'es', 'fr'] as const;
+
+export const Lang = z.enum(langs);
+export const Dict = z.object({
+  // -----------------used in ui-----------------
+  cancel: z.string(),
+  close: z.string(),
+  set: z.string(),
+  clear: z.string(),
+  field: z.string(),
+  fieldName: z.string(),
+  align: z.string(),
+  width: z.string(),
+  opacity: z.string(),
+  height: z.string(),
+  rotate: z.string(),
+  edit: z.string(),
+  required: z.string(),
+  editable: z.string(),
+  plsInputName: z.string(),
+  fieldMustUniq: z.string(),
+  notUniq: z.string(),
+  noKeyName: z.string(),
+  fieldsList: z.string(),
+  editField: z.string(),
+  type: z.string(),
+  errorOccurred: z.string(),
+  errorBulkUpdateFieldName: z.string(),
+  commitBulkUpdateFieldName: z.string(),
+  bulkUpdateFieldName: z.string(),
+  addPageAfter: z.string(),
+  removePage: z.string(),
+  removePageConfirm: z.string(),
+  // --------------------validation-------------------
+  'validation.uniqueName': z.string(),
+  'validation.hexColor': z.string(),
+  'validation.dateTimeFormat': z.string(),
+  'validation.outOfBounds': z.string(),
+
+  // -----------------used in schemas-----------------
+  'schemas.color': z.string(),
+  'schemas.borderWidth': z.string(),
+  'schemas.borderColor': z.string(),
+  'schemas.backgroundColor': z.string(),
+  'schemas.textColor': z.string(),
+  'schemas.bgColor': z.string(),
+  'schemas.horizontal': z.string(),
+  'schemas.vertical': z.string(),
+  'schemas.left': z.string(),
+  'schemas.center': z.string(),
+  'schemas.right': z.string(),
+  'schemas.top': z.string(),
+  'schemas.middle': z.string(),
+  'schemas.bottom': z.string(),
+  'schemas.padding': z.string(),
+
+  'schemas.text.fontName': z.string(),
+  'schemas.text.size': z.string(),
+  'schemas.text.spacing': z.string(),
+  'schemas.text.textAlign': z.string(),
+  'schemas.text.verticalAlign': z.string(),
+  'schemas.text.lineHeight': z.string(),
+  'schemas.text.min': z.string(),
+  'schemas.text.max': z.string(),
+  'schemas.text.fit': z.string(),
+  'schemas.text.dynamicFontSize': z.string(),
+  'schemas.text.format': z.string(),
+  'schemas.radius': z.string(),
+
+  'schemas.mvt.typingInstructions': z.string(),
+  'schemas.mvt.sampleField': z.string(),
+  'schemas.mvt.variablesSampleData': z.string(),
+
+  'schemas.barcodes.barColor': z.string(),
+  'schemas.barcodes.includetext': z.string(),
+
+  'schemas.table.alternateBackgroundColor': z.string(),
+  'schemas.table.tableStyle': z.string(),
+  'schemas.table.showHead': z.string(),
+  'schemas.table.repeatHead': z.string(),
+  'schemas.table.headStyle': z.string(),
+  'schemas.table.bodyStyle': z.string(),
+  'schemas.table.columnStyle': z.string(),
+
+  'schemas.date.format': z.string(),
+  'schemas.date.locale': z.string(),
+
+  'schemas.select.options': z.string(),
+  'schemas.select.optionPlaceholder': z.string(),
+
+  'schemas.radioGroup.groupName': z.string(),
+});
+export const Mode = z.enum(['viewer', 'form', 'designer']);
+
+export const ColorType = z.enum(['rgb', 'cmyk']).optional();
+
+export const Size = z.object({ height: z.number(), width: z.number() });
+
+export const Schema = z
+  .object({
+    name: z.string(),
+    type: z.string(),
+    content: z.string().optional(),
+    position: z.object({ x: z.number(), y: z.number() }),
+    width: z.number(),
+    height: z.number(),
+    rotate: z.number().optional(),
+    opacity: z.number().optional(),
+    readOnly: z.boolean().optional(),
+    required: z.boolean().optional(),
+    __bodyRange: z.object({ start: z.number(), end: z.number().optional() }).optional(),
+    __isSplit: z.boolean().optional(),
+  })
+  .passthrough();
+
+const SchemaForUIAdditionalInfo = z.object({ id: z.string() });
+export const SchemaForUI = Schema.merge(SchemaForUIAdditionalInfo);
+
+const ArrayBufferSchema: z.ZodSchema<ArrayBuffer> = z.any().refine((v) => v instanceof ArrayBuffer);
+const Uint8ArraySchema: z.ZodSchema<Uint8Array<ArrayBuffer>> = z
+  .any()
+  .refine((v) => v instanceof Uint8Array && v.buffer instanceof ArrayBuffer);
+
+export const BlankPdf = z.object({
+  width: z.number(),
+  height: z.number(),
+  padding: z.tuple([z.number(), z.number(), z.number(), z.number()]),
+  staticSchema: z.array(Schema).optional(),
+});
+
+export const CustomPdf = z.union([z.string(), ArrayBufferSchema, Uint8ArraySchema]);
+
+export const BasePdf = z.union([CustomPdf, BlankPdf]);
+
+// Legacy keyed structure for BC - we convert to SchemaPageArray on import
+export const LegacySchemaPageArray = z.array(z.record(z.string(), Schema));
+export const SchemaPageArray = z.array(z.array(Schema));
+
+export const Template = z
+  .object({
+    schemas: SchemaPageArray,
+    basePdf: BasePdf,
+    pdfmeVersion: z.string().optional(),
+  })
+  .passthrough();
+
+export const Inputs = z.array(z.record(z.string(), z.any())).min(1);
+
+export const Font = z.record(
+  z.string(),
+  z.object({
+    data: z.union([z.string(), ArrayBufferSchema, Uint8ArraySchema]),
+    fallback: z.boolean().optional(),
+    subset: z.boolean().optional(),
+  }),
+);
+
+export const Plugin = z
+  .object({
+    ui: z.any(),
+    pdf: z.any(),
+    propPanel: z.object({
+      schema: z.unknown(),
+      widgets: z.record(z.string(), z.any()).optional(),
+      defaultSchema: Schema,
+    }),
+    icon: z.string().optional(),
+  })
+  .passthrough();
+
+export const CommonOptions = z.object({ font: Font.optional() }).passthrough();
+
+const CommonProps = z.object({
+  template: Template,
+  options: CommonOptions.optional(),
+  plugins: z.record(z.string(), Plugin).optional(),
+});
+
+// -------------------generate-------------------
+
+export const GeneratorOptions = CommonOptions.extend({
+  colorType: ColorType,
+  author: z.string().optional(),
+  creationDate: z.date().optional(),
+  creator: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  lang: Lang.optional(),
+  modificationDate: z.date().optional(),
+  producer: z.string().optional(),
+  subject: z.string().optional(),
+  title: z.string().optional(),
+});
+
+export const GenerateProps = CommonProps.extend({
+  inputs: Inputs,
+  options: GeneratorOptions.optional(),
+}).strict();
+
+// ---------------------ui------------------------
+
+export const UIOptions = CommonOptions.extend({
+  lang: Lang.optional(),
+  labels: z.record(z.string(), z.string()).optional(),
+  theme: z.record(z.string(), z.unknown()).optional(),
+  icons: z.record(z.string(), z.string()).optional(),
+  requiredByDefault: z.boolean().optional(),
+  maxZoom: z.number().optional(),
+  sidebarOpen: z.boolean().optional(),
+  zoomLevel: z.number().optional(),
+});
+
+const HTMLElementSchema: z.ZodSchema<HTMLElement> = z.any().refine((v) => v instanceof HTMLElement);
+
+export const UIProps = CommonProps.extend({
+  domContainer: HTMLElementSchema,
+  options: UIOptions.optional(),
+});
+
+export const PreviewProps = UIProps.extend({ inputs: Inputs }).strict();
+
+export const DesignerProps = UIProps.extend({}).strict();