@pdfme/generator 2.1.0 → 2.2.1

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

@@ -0,0 +1,3 @@
+import type { Renderer } from './types';
+declare const renderer: Renderer;
+export default renderer;

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

@@ -0,0 +1,19 @@
+import { PDFPage, PDFDocument, PDFEmbeddedPage } from '@pdfme/pdf-lib';
+import { Font, BasePdf } from '@pdfme/common';
+import type { EmbedPdfBox } from "./types";
+export declare const embedAndGetFontObj: (arg: {
+    pdfDoc: PDFDocument;
+    font: Font;
+}) => Promise<any>;
+export declare const getEmbeddedPagesAndEmbedPdfBoxes: (arg: {
+    pdfDoc: PDFDocument;
+    basePdf: BasePdf;
+}) => Promise<{
+    embeddedPages: PDFEmbeddedPage[];
+    embedPdfBoxes: EmbedPdfBox[];
+}>;
+export declare const drawEmbeddedPage: (arg: {
+    page: PDFPage;
+    embeddedPage: PDFEmbeddedPage;
+    embedPdfBox: EmbedPdfBox;
+}) => void;

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

@@ -0,0 +1,16 @@
+import { PDFPage } from '@pdfme/pdf-lib';
+import { Schema, TextSchema, Alignment } from '@pdfme/common';
+export declare const hex2RgbColor: (hexString: string | undefined) => import("@pdfme/pdf-lib").RGB | undefined;
+export declare const calcX: (x: number, alignment: Alignment, boxWidth: number, textWidth: number) => number;
+export declare const calcY: (y: number, pageHeight: number, itemHeight: number) => number;
+export declare const renderBackgroundColor: (arg: {
+    schema: TextSchema;
+    page: PDFPage;
+    pageHeight: number;
+}) => void;
+export declare const convertSchemaDimensionsToPt: (schema: Schema) => {
+    width: number;
+    height: number;
+    rotate: import("@pdfme/pdf-lib").Degrees;
+};
+export declare const getCacheKey: (schema: Schema, input: string) => string;

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

@@ -0,0 +1,2 @@
+import type { RenderProps } from "../types";
+export declare const renderBarcode: (arg: RenderProps) => Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { RenderProps } from "../types";
+export declare const renderImage: (arg: RenderProps) => Promise<void>;

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

@@ -0,0 +1,2 @@
+import type { RenderProps } from "../types";
+export declare const renderText: (arg: RenderProps) => Promise<void>;

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

@@ -0,0 +1,36 @@
+import type { PDFImage } from '@pdfme/pdf-lib';
+import type { GeneratorOptions, Schema } from '@pdfme/common';
+import type { PDFPage, PDFDocument } from '@pdfme/pdf-lib';
+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;
+    };
+};
+export interface RenderProps {
+    value: string;
+    schema: Schema;
+    pdfDoc: PDFDocument;
+    page: PDFPage;
+    options: GeneratorOptions;
+    _cache: Map<string, PDFImage>;
+}
+export interface Renderer {
+    [key: string]: {
+        render: (arg: RenderProps) => Promise<void>;
+    } | undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfme/generator",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "sideEffects": false,
   "author": "hand-dot",
   "license": "MIT",
@@ -48,16 +48,11 @@
   "dependencies": {
     "@pdfme/pdf-lib": "^1.17.3",
     "atob": "^2.1.2",
-    "bwip-js": "^3.2.2",
     "fontkit": "^2.0.2"
   },
   "devDependencies": {
     "@pdfme/common": "file:../common",
-    "@types/bwip-js": "^3.0.0",
-    "@types/pngjs": "^6.0.1",
-    "jsqr": "^1.4.0",
-    "pdf2json": "^2.0.0",
-    "pngjs": "^6.0.0"
+    "pdf2json": "^2.0.0"
   },
   "peerDependencies": {
     "@pdfme/common": "^2.1.0"

package/src/builtInRenderer.ts

@@ -0,0 +1,14 @@
+import type { BarCodeType } from '@pdfme/common';
+import type { Renderer } from './types';
+import { renderText } from './renders/text';
+import { renderImage } from './renders/image';
+import { renderBarcode } from './renders/barcodes';
+
+const barCodeTypes: BarCodeType[] = ['qrcode', 'japanpost', 'ean13', 'ean8', 'code39', 'code128', 'nw7', 'itf14', 'upca', 'upce', 'gs1datamatrix']
+
+const renderer: Renderer = {
+    text: { render: renderText, },
+    image: { render: renderImage, },
+    ...barCodeTypes.reduce((acc, barcodeType) => Object.assign(acc, { [barcodeType]: { render: renderBarcode } }), {}),
+}
+export default renderer

package/src/generate.ts

@@ -1,43 +1,25 @@
 import { PDFDocument } from '@pdfme/pdf-lib';
 import * as fontkit from 'fontkit';
-import type {
-  Font,
-  GenerateProps,
-  SchemaInputs,
-  Template,
-} from '@pdfme/common';
-import {
-  getDefaultFont,
-  getFallbackFontName,
-  checkGenerateProps,
-} from '@pdfme/common';
-import {
-  getEmbeddedPagesAndEmbedPdfBoxes,
-  drawInputByTemplateSchema,
-  drawEmbeddedPage,
-  embedAndGetFontObj,
-  InputImageCache,
-} from './helper.js';
-import { TOOL_NAME } from './constants.js';
-
-const preprocessing = async (arg: { inputs: SchemaInputs[]; template: Template; font: Font }) => {
-  const { template, font } = arg;
+import type { GenerateProps, Template, } from '@pdfme/common';
+import { checkGenerateProps, } from '@pdfme/common';
+import builtInRenderer from './builtInRenderer';
+import { drawEmbeddedPage, getEmbeddedPagesAndEmbedPdfBoxes, } from './pdfUtils'
+import { TOOL_NAME } from './constants';
+
+const preprocessing = async ({ template }: { template: Template; }) => {
   const { basePdf } = template;
-  const fallbackFontName = getFallbackFontName(font);
 
   const pdfDoc = await PDFDocument.create();
   // @ts-ignore
   pdfDoc.registerFontkit(fontkit);
 
-  const pdfFontObj = await embedAndGetFontObj({ pdfDoc, font });
-
   const pagesAndBoxes = await getEmbeddedPagesAndEmbedPdfBoxes({ pdfDoc, basePdf });
   const { embeddedPages, embedPdfBoxes } = pagesAndBoxes;
 
-  return { pdfDoc, pdfFontObj, fallbackFontName, embeddedPages, embedPdfBoxes };
+  return { pdfDoc, embeddedPages, embedPdfBoxes };
 };
 
-const postProcessing = (pdfDoc: PDFDocument) => {
+const postProcessing = ({ pdfDoc }: { pdfDoc: PDFDocument }) => {
   pdfDoc.setProducer(TOOL_NAME);
   pdfDoc.setCreator(TOOL_NAME);
 };
@@ -45,13 +27,13 @@ const postProcessing = (pdfDoc: PDFDocument) => {
 const generate = async (props: GenerateProps) => {
   checkGenerateProps(props);
   const { inputs, template, options = {} } = props;
-  const { font = getDefaultFont() } = options;
-  const { schemas } = template;
 
-  const preRes = await preprocessing({ inputs, template, font });
-  const { pdfDoc, pdfFontObj, fallbackFontName, embeddedPages, embedPdfBoxes } = preRes;
+  const { pdfDoc, embeddedPages, embedPdfBoxes } = await preprocessing({ template });
+
+  // TODO: In the future, when we support custom schemas, we will create the registry using options.renderer instead of {}.
+  const rendererRegistry = Object.assign(builtInRenderer, {});
+  const _cache = new Map();
 
-  const inputImageCache: InputImageCache = {};
   for (let i = 0; i < inputs.length; i += 1) {
     const inputObj = inputs[i];
     const keys = Object.keys(inputObj);
@@ -65,24 +47,24 @@ const generate = async (props: GenerateProps) => {
       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 fontSetting = { font, pdfFontObj, fallbackFontName };
-
-        await drawInputByTemplateSchema({
-          input,
-          templateSchema,
-          pdfDoc,
-          page,
-          fontSetting,
-          inputImageCache,
-        });
+        const schemaObj = template.schemas[j];
+        const schema = schemaObj[key];
+        const value = inputObj[key];
+
+        if (!schema || !value) {
+          continue;
+        }
+
+        const renderer = rendererRegistry[schema.type];
+        if (!renderer) {
+          throw new Error(`Renderer for type ${schema.type} not found`);
+        }
+        await renderer.render({ value, schema, pdfDoc, page, options, _cache });
       }
     }
   }
 
-  postProcessing(pdfDoc);
+  postProcessing({ pdfDoc });
 
   return pdfDoc.save();
 };

package/src/pdfUtils.ts

@@ -0,0 +1,76 @@
+import { PDFPage, PDFFont, PDFDocument, PDFEmbeddedPage, TransformationMatrix } from '@pdfme/pdf-lib';
+import { getB64BasePdf, Font, BasePdf } from '@pdfme/common';
+import type { EmbedPdfBox } from "./types"
+
+const embedAndGetFontObjCache = new WeakMap();
+export const embedAndGetFontObj = async (arg: { pdfDoc: PDFDocument; font: Font }) => {
+    const { pdfDoc, font } = arg;
+    if (embedAndGetFontObjCache.has(pdfDoc)) {
+        return embedAndGetFontObjCache.get(pdfDoc);
+    }
+
+    const fontValues = await Promise.all(
+        Object.values(font).map(async (v) => {
+            let fontData = v.data;
+            if (typeof fontData === 'string' && fontData.startsWith('http')) {
+                fontData = await fetch(fontData).then((res) => res.arrayBuffer());
+            }
+            return pdfDoc.embedFont(fontData, {
+                subset: typeof v.subset === 'undefined' ? true : v.subset,
+            });
+        })
+    );
+
+    const fontObj = Object.keys(font).reduce(
+        (acc, cur, i) => Object.assign(acc, { [cur]: fontValues[i] }),
+        {} as { [key: string]: PDFFont }
+    )
+
+    embedAndGetFontObjCache.set(pdfDoc, fontObj);
+    return fontObj;
+};
+
+export const getEmbeddedPagesAndEmbedPdfBoxes = async (arg: {
+    pdfDoc: PDFDocument;
+    basePdf: BasePdf;
+}) => {
+    const { pdfDoc, basePdf } = arg;
+    let embeddedPages: PDFEmbeddedPage[] = [];
+    let embedPdfBoxes: EmbedPdfBox[] = [];
+    const willLoadPdf = typeof basePdf === 'string' ? await getB64BasePdf(basePdf) : 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
+    );
+
+    embeddedPages = await pdfDoc.embedPages(embedPdfPages, boundingBoxes, transformationMatrices);
+
+    return { embeddedPages, embedPdfBoxes };
+};
+
+export const drawEmbeddedPage = (arg: {
+    page: PDFPage;
+    embeddedPage: PDFEmbeddedPage;
+    embedPdfBox: EmbedPdfBox;
+}) => {
+    const { page, embeddedPage, embedPdfBox } = arg;
+    page.drawPage(embeddedPage);
+    const { mediaBox: mb, bleedBox: bb, trimBox: tb } = embedPdfBox;
+    page.setMediaBox(mb.x, mb.y, mb.width, mb.height);
+    page.setBleedBox(bb.x, bb.y, bb.width, bb.height);
+    page.setTrimBox(tb.x, tb.y, tb.width, tb.height);
+};

package/src/renderUtils.ts

@@ -0,0 +1,68 @@
+import { PDFPage, degrees, rgb, } from '@pdfme/pdf-lib';
+import { Schema, TextSchema, Alignment, mm2pt } from '@pdfme/common';
+
+const hex2rgb = (hex: string) => {
+  if (hex.slice(0, 1) === '#') hex = hex.slice(1);
+  if (hex.length === 3)
+    hex =
+      hex.slice(0, 1) +
+      hex.slice(0, 1) +
+      hex.slice(1, 2) +
+      hex.slice(1, 2) +
+      hex.slice(2, 3) +
+      hex.slice(2, 3);
+
+  return [hex.slice(0, 2), hex.slice(2, 4), hex.slice(4, 6)].map((str) => parseInt(str, 16));
+};
+
+export const hex2RgbColor = (hexString: string | undefined) => {
+  if (hexString) {
+    const [r, g, b] = hex2rgb(hexString);
+
+    return rgb(r / 255, g / 255, b / 255);
+  }
+
+  // eslint-disable-next-line no-undefined
+  return undefined;
+};
+
+export const calcX = (x: number, alignment: Alignment, boxWidth: number, textWidth: number) => {
+  let addition = 0;
+  if (alignment === 'center') {
+    addition = (boxWidth - textWidth) / 2;
+  } else if (alignment === 'right') {
+    addition = boxWidth - textWidth;
+  }
+
+  return mm2pt(x) + addition;
+};
+
+export const calcY = (y: number, pageHeight: number, itemHeight: number) => pageHeight - mm2pt(y) - itemHeight;
+
+export const renderBackgroundColor = (arg: {
+  schema: TextSchema;
+  page: PDFPage;
+  pageHeight: number;
+}) => {
+  const { schema, page, pageHeight } = arg;
+  if (!schema.backgroundColor) return;
+  const { width, height } = convertSchemaDimensionsToPt(schema);
+  const color = hex2RgbColor(schema.backgroundColor);
+  page.drawRectangle({
+    x: calcX(schema.position.x, 'left', width, width),
+    y: calcY(schema.position.y, pageHeight, height),
+    width,
+    height,
+    color,
+  });
+};
+
+export const convertSchemaDimensionsToPt = (schema: Schema) => {
+  const width = mm2pt(schema.width);
+  const height = mm2pt(schema.height);
+  const rotate = degrees(schema.rotate ? schema.rotate : 0);
+
+  return { width, height, rotate };
+};
+
+export const getCacheKey = (schema: Schema, input: string) => `${schema.type}${input}`;

package/src/renders/barcodes.ts

@@ -0,0 +1,32 @@
+import {
+    createBarCode,
+    validateBarcodeInput,
+    BarCodeType,
+} from '@pdfme/common';
+import type { RenderProps } from "../types"
+import { calcX, calcY, convertSchemaDimensionsToPt, getCacheKey } from '../renderUtils'
+
+export const renderBarcode = async (arg: RenderProps) => {
+    const { value, schema, pdfDoc, page, _cache } = arg;
+    if (!validateBarcodeInput(schema.type as BarCodeType, value)) return;
+
+    const { width, height, rotate } = convertSchemaDimensionsToPt(schema);
+    const opt = {
+        x: calcX(schema.position.x, 'left', width, width),
+        y: calcY(schema.position.y, page.getHeight(), height),
+        rotate,
+        width,
+        height,
+    };
+    const inputBarcodeCacheKey = getCacheKey(schema, value);
+    let image = _cache.get(inputBarcodeCacheKey);
+    if (!image) {
+        const imageBuf = await createBarCode(
+            Object.assign(schema, { type: schema.type as BarCodeType, input: value })
+        );
+        image = await pdfDoc.embedPng(imageBuf);
+        _cache.set(inputBarcodeCacheKey, image)
+    }
+
+    page.drawImage(image, opt);
+}

package/src/renders/image.ts

@@ -0,0 +1,24 @@
+import type { RenderProps } from "../types"
+import { calcX, calcY, convertSchemaDimensionsToPt, getCacheKey } from '../renderUtils'
+
+
+export const renderImage = async (arg: RenderProps) => {
+    const { value, schema, pdfDoc, page, _cache } = arg;
+
+    const { width, height, rotate } = convertSchemaDimensionsToPt(schema);
+    const opt = {
+        x: calcX(schema.position.x, 'left', width, width),
+        y: calcY(schema.position.y, page.getHeight(), height),
+        rotate,
+        width,
+        height,
+    };
+    const inputImageCacheKey = getCacheKey(schema, value);
+    let image = _cache.get(inputImageCacheKey);
+    if (!image) {
+        const isPng = value.startsWith('data:image/png;');
+        image = await (isPng ? pdfDoc.embedPng(value) : pdfDoc.embedJpg(value));
+        _cache.set(inputImageCacheKey, image);
+    }
+    page.drawImage(image, opt);
+}

package/src/renders/text.ts

@@ -0,0 +1,114 @@
+import { setCharacterSpacing, } from '@pdfme/pdf-lib';
+import {
+  TextSchema,
+  Font,
+  DEFAULT_FONT_SIZE,
+  DEFAULT_ALIGNMENT,
+  DEFAULT_LINE_HEIGHT,
+  DEFAULT_CHARACTER_SPACING,
+  DEFAULT_FONT_COLOR,
+  DEFAULT_VERTICAL_ALIGNMENT,
+  VERTICAL_ALIGN_TOP,
+  VERTICAL_ALIGN_MIDDLE,
+  VERTICAL_ALIGN_BOTTOM,
+  calculateDynamicFontSize,
+  heightOfFontAtSize,
+  getFontDescentInPt,
+  getFontKitFont,
+  getSplittedLines,
+  widthOfTextAtSize,
+  FontWidthCalcValues,
+  getDefaultFont,
+  getFallbackFontName,
+} from '@pdfme/common';
+import type { RenderProps } from "../types"
+import { embedAndGetFontObj } from '../pdfUtils'
+import {
+  hex2RgbColor,
+  calcX,
+  calcY,
+  renderBackgroundColor,
+  convertSchemaDimensionsToPt
+} from '../renderUtils'
+
+const getFontProp = async ({ value, font, schema }: { value: string, font: Font, schema: TextSchema }) => {
+  const fontSize = schema.dynamicFontSize ? await calculateDynamicFontSize({ textSchema: schema, font, value }) : schema.fontSize ?? DEFAULT_FONT_SIZE;
+  const color = hex2RgbColor(schema.fontColor ?? DEFAULT_FONT_COLOR);
+  const alignment = schema.alignment ?? DEFAULT_ALIGNMENT;
+  const verticalAlignment = schema.verticalAlignment ?? DEFAULT_VERTICAL_ALIGNMENT;
+  const lineHeight = schema.lineHeight ?? DEFAULT_LINE_HEIGHT;
+  const characterSpacing = schema.characterSpacing ?? DEFAULT_CHARACTER_SPACING;
+
+  return { fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing };
+};
+
+export const renderText = async (arg: RenderProps) => {
+  const { value, pdfDoc, page, options } = arg;
+  const schema = arg.schema as TextSchema;
+
+  const { font = getDefaultFont() } = options;
+
+  const [pdfFontObj, fontKitFont, fontProp] = await Promise.all([
+    embedAndGetFontObj({ pdfDoc, font }),
+    getFontKitFont(schema, font),
+    getFontProp({ value, font, schema: schema })
+  ])
+
+  const { fontSize, color, alignment, verticalAlignment, lineHeight, characterSpacing } = fontProp;
+
+  const pdfFontValue = pdfFontObj[schema.fontName ? schema.fontName : getFallbackFontName(font)];
+
+  const pageHeight = page.getHeight();
+  renderBackgroundColor({ schema, page, pageHeight });
+
+  const { width, height, rotate } = convertSchemaDimensionsToPt(schema);
+
+  page.pushOperators(setCharacterSpacing(characterSpacing));
+
+  const firstLineTextHeight = heightOfFontAtSize(fontKitFont, fontSize);
+  const descent = getFontDescentInPt(fontKitFont, fontSize);
+  const halfLineHeightAdjustment = lineHeight === 0 ? 0 : ((lineHeight - 1) * fontSize) / 2;
+
+  const fontWidthCalcValues: FontWidthCalcValues = {
+    font: fontKitFont,
+    fontSize,
+    characterSpacing,
+    boxWidthInPt: width,
+  };
+
+  let lines: string[] = [];
+  value.split(/\r|\n|\r\n/g).forEach((line) => {
+    lines = lines.concat(getSplittedLines(line, fontWidthCalcValues));
+  });
+
+  // Text lines are rendered from the bottom upwards, we need to adjust the position down
+  let yOffset = 0;
+  if (verticalAlignment === VERTICAL_ALIGN_TOP) {
+    yOffset = firstLineTextHeight + halfLineHeightAdjustment;
+  } else {
+    const otherLinesHeight = lineHeight * fontSize * (lines.length - 1);
+
+    if (verticalAlignment === VERTICAL_ALIGN_BOTTOM) {
+      yOffset = height - otherLinesHeight + descent - halfLineHeightAdjustment;
+    } else if (verticalAlignment === VERTICAL_ALIGN_MIDDLE) {
+      yOffset = (height - otherLinesHeight - firstLineTextHeight + descent) / 2 + firstLineTextHeight;
+    }
+  }
+
+  lines.forEach((line, rowIndex) => {
+    const textWidth = widthOfTextAtSize(line, fontKitFont, fontSize, characterSpacing);
+    const rowYOffset = lineHeight * fontSize * rowIndex;
+
+    page.drawText(line, {
+      x: calcX(schema.position.x, alignment, width, textWidth),
+      y: calcY(schema.position.y, pageHeight, yOffset) - rowYOffset,
+      rotate,
+      size: fontSize,
+      color,
+      lineHeight: lineHeight * fontSize,
+      maxWidth: width,
+      font: pdfFontValue,
+      wordBreaks: [''],
+    });
+  });
+};

package/src/types.ts

@@ -0,0 +1,23 @@
+import type { PDFImage } from '@pdfme/pdf-lib';
+import type { GeneratorOptions, Schema, } from '@pdfme/common';
+import type { PDFPage, PDFDocument, } from '@pdfme/pdf-lib';
+
+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 };
+};
+
+export interface RenderProps {
+    value: string;
+    schema: Schema;
+    pdfDoc: PDFDocument;
+    page: PDFPage;
+    options: GeneratorOptions;
+
+    _cache: Map<string, PDFImage>;
+}
+
+export interface Renderer {
+    [key: string]: { render: (arg: RenderProps) => Promise<void> } | undefined;
+}

package/dist/cjs/__tests__/helper.test.js

@@ -1,53 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const helper_1 = require("../src/helper");
-const jsqr_1 = __importDefault(require("jsqr"));
-const pngjs_1 = require("pngjs");
-/**
- * 生成したQRコード（png）画像から入力データが正常に読み取れるかをテスト
- */
-describe('createBarCode', () => {
-    describe('qrcode', () => {
-        // テスト名, input, expected
-        const tests = [
-            ['URL', 'https://www.google.com/', 'https://www.google.com/'],
-            ['ひらがな', 'てすとです', 'てすとです'],
-            ['ひらがな2', 'あいうえおあいうえお２', 'あいうえおあいうえお２'],
-            ['カタカナ', 'テストです', 'テストです'],
-            ['漢字', 'お正月', 'お正月'],
-            ['中国語', '新年快乐', '新年快乐'],
-            ['タイ語', 'สวัสดีปีใหม่', 'สวัสดีปีใหม่'],
-        ];
-        for (const t of tests) {
-            // eslint-disable-next-line no-loop-func
-            test(`${t[0]}: ${t[1]}`, () => __awaiter(void 0, void 0, void 0, function* () {
-                const buffer = (yield (0, helper_1.createBarCode)({
-                    type: 'qrcode',
-                    input: t[1],
-                    width: 10,
-                    height: 10,
-                    backgroundColor: '00000000', // 背景色を指定しないとjsQRでうまく解析できない
-                }));
-                const png = pngjs_1.PNG.sync.read(buffer);
-                const pngData = new Uint8ClampedArray(png.data);
-                const qr = (0, jsqr_1.default)(pngData, png.width, png.height);
-                expect(qr).not.toBeNull();
-                const dataBuffer = Buffer.from(qr.binaryData);
-                expect(dataBuffer.toString('utf8')).toEqual(t[2]);
-            }));
-        }
-    });
-});
-//# sourceMappingURL=helper.test.js.map

package/dist/cjs/__tests__/helper.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"helper.test.js","sourceRoot":"","sources":["../../../__tests__/helper.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,0CAA8C;AAC9C,gDAAoC;AACpC,iCAA4B;AAE5B;;GAEG;AACH,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE;QACtB,wBAAwB;QACxB,MAAM,KAAK,GAAG;YACZ,CAAC,KAAK,EAAE,yBAAyB,EAAE,yBAAyB,CAAC;YAC7D,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;YAC1B,CAAC,OAAO,EAAE,aAAa,EAAE,aAAa,CAAC;YACvC,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;YAC1B,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC;YACpB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC;YACvB,CAAC,KAAK,EAAE,cAAc,EAAE,cAAc,CAAC;SACxC,CAAC;QACF,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE;YACrB,wCAAwC;YACxC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,GAAS,EAAE;gBAClC,MAAM,MAAM,GAAG,CAAC,MAAM,IAAA,sBAAa,EAAC;oBAClC,IAAI,EAAE,QAAQ;oBACd,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;oBACX,KAAK,EAAE,EAAE;oBACT,MAAM,EAAE,EAAE;oBACV,eAAe,EAAE,UAAU,EAAE,2BAA2B;iBACzD,CAAC,CAAW,CAAC;gBACd,MAAM,GAAG,GAAG,WAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAClC,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAChD,MAAM,EAAE,GAAG,IAAA,cAAI,EAAC,OAAO,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAW,CAAC;gBAC1D,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;gBAC1B,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;gBAC9C,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpD,CAAC,CAAA,CAAC,CAAC;SACJ;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}