@pdfme/schemas 3.1.5 → 3.2.0-dev.1

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

@@ -0,0 +1,6 @@
+import type { Schema, Plugin } from '@pdfme/common';
+interface LineSchema extends Schema {
+    color: string;
+}
+declare const lineSchema: Plugin<LineSchema>;
+export default lineSchema;

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

@@ -0,0 +1,144 @@
+import { Schema } from '@pdfme/common';
+interface Shape extends Schema {
+    type: 'ellipse' | 'rectangle';
+    borderWidth: number;
+    borderColor: string;
+    color: string;
+}
+export declare const rectangle: {
+    propPanel: {
+        defaultSchema: {
+            type: "ellipse" | "rectangle";
+            borderWidth: number;
+            borderColor: string;
+            color: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            width: number;
+            height: number;
+            readOnly?: boolean | undefined;
+            readOnlyValue?: string | undefined;
+            rotate?: number | undefined;
+            opacity?: number | undefined;
+        };
+        schema: ((propPanelProps: Omit<{
+            rootElement: HTMLDivElement;
+            activeSchema: {
+                width: number;
+                height: number;
+                type: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                data: string;
+                id: string;
+                key: string;
+                opacity?: number | undefined;
+                rotate?: number | undefined;
+                readOnly?: boolean | undefined;
+                readOnlyValue?: string | undefined;
+            };
+            activeElements: HTMLElement[];
+            changeSchemas: import("@pdfme/common").ChangeSchemas;
+            schemas: {
+                width: number;
+                height: number;
+                type: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                data: string;
+                id: string;
+                key: string;
+                opacity?: number | undefined;
+                rotate?: number | undefined;
+                readOnly?: boolean | undefined;
+                readOnlyValue?: string | undefined;
+            }[];
+            pageSize: {
+                width: number;
+                height: number;
+            };
+            options: import("@pdfme/common").UIOptions;
+            theme: import("antd").GlobalToken;
+            i18n: (key: string) => string;
+        }, "rootElement">) => Record<string, Partial<import("form-render").SchemaBase>>) | Record<string, Partial<import("form-render").SchemaBase>>;
+        widgets?: Record<string, (props: import("@pdfme/common").PropPanelWidgetProps) => void> | undefined;
+        defaultValue: string;
+    };
+    pdf: (arg: import("@pdfme/common").PDFRenderProps<Shape>) => void | Promise<void>;
+    ui: (arg: import("@pdfme/common").UIRenderProps<Shape>) => void | Promise<void>;
+};
+export declare const ellipse: {
+    propPanel: {
+        defaultSchema: {
+            type: "ellipse" | "rectangle";
+            borderWidth: number;
+            borderColor: string;
+            color: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            width: number;
+            height: number;
+            readOnly?: boolean | undefined;
+            readOnlyValue?: string | undefined;
+            rotate?: number | undefined;
+            opacity?: number | undefined;
+        };
+        schema: ((propPanelProps: Omit<{
+            rootElement: HTMLDivElement;
+            activeSchema: {
+                width: number;
+                height: number;
+                type: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                data: string;
+                id: string;
+                key: string;
+                opacity?: number | undefined;
+                rotate?: number | undefined;
+                readOnly?: boolean | undefined;
+                readOnlyValue?: string | undefined;
+            };
+            activeElements: HTMLElement[];
+            changeSchemas: import("@pdfme/common").ChangeSchemas;
+            schemas: {
+                width: number;
+                height: number;
+                type: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                data: string;
+                id: string;
+                key: string;
+                opacity?: number | undefined;
+                rotate?: number | undefined;
+                readOnly?: boolean | undefined;
+                readOnlyValue?: string | undefined;
+            }[];
+            pageSize: {
+                width: number;
+                height: number;
+            };
+            options: import("@pdfme/common").UIOptions;
+            theme: import("antd").GlobalToken;
+            i18n: (key: string) => string;
+        }, "rootElement">) => Record<string, Partial<import("form-render").SchemaBase>>) | Record<string, Partial<import("form-render").SchemaBase>>;
+        widgets?: Record<string, (props: import("@pdfme/common").PropPanelWidgetProps) => void> | undefined;
+        defaultValue: string;
+    };
+    pdf: (arg: import("@pdfme/common").PDFRenderProps<Shape>) => void | Promise<void>;
+    ui: (arg: import("@pdfme/common").UIRenderProps<Shape>) => void | Promise<void>;
+};
+export {};

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

@@ -1,4 +1,5 @@
 import type { Plugin } from '@pdfme/common';
 import type { TextSchema } from './types';
-declare const schema: Plugin<TextSchema>;
-export default schema;
+declare const textSchema: Plugin<TextSchema>;
+export default textSchema;
+export declare const readOnlyText: Plugin<TextSchema>;

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

@@ -1,3 +1,3 @@
-import { PDFRenderProps } from '@pdfme/common';
 import type { TextSchema } from './types';
+import { PDFRenderProps } from '@pdfme/common';
 export declare const pdfRender: (arg: PDFRenderProps<TextSchema>) => Promise<void>;

package/dist/types/src/{renderUtils.d.ts → utils.d.ts}

@@ -1,4 +1,4 @@
-import { Schema } from '@pdfme/common';
+import { Schema, Mode } from '@pdfme/common';
 export declare const convertForPdfLayoutProps: ({ schema, pageHeight, applyRotateTranslate, }: {
     schema: Schema;
     pageHeight: number;
@@ -24,3 +24,7 @@ export declare const rotatePoint: (point: {
     y: number;
 };
 export declare const addAlphaToHex: (hex: string, alphaPercentage: number) => string;
+export declare const isEditable: (mode: Mode, schema: Schema) => boolean;
+export declare const hex2RgbColor: (hexString: string | undefined) => import("@pdfme/pdf-lib").RGB | undefined;
+export declare const readFile: (input: File | FileList | null) => Promise<string | ArrayBuffer>;
+export declare const createErrorElm: () => HTMLDivElement;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfme/schemas",
-  "version": "3.1.5",
+  "version": "3.2.0-dev.1",
   "sideEffects": false,
   "author": "hand-dot",
   "license": "MIT",
@@ -32,7 +32,7 @@
     }
   },
   "scripts": {
-    "develop": "tsc -p tsconfig.esm.json -w",
+    "dev": "tsc -p tsconfig.esm.json -w",
     "build": "npm-run-all --parallel build:cjs build:esm",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:esm": "tsc -p tsconfig.esm.json",
@@ -43,8 +43,9 @@
     "prettier": "prettier --write 'src/**/*.ts'"
   },
   "dependencies": {
-    "@pdfme/pdf-lib": "^1.17.3",
+    "@pdfme/pdf-lib": "^1.18.3",
     "bwip-js": "^4.1.1",
+    "fast-xml-parser": "^4.3.2",
     "fontkit": "^2.0.2"
   },
   "devDependencies": {

package/src/barcodes/constants.ts

@@ -15,3 +15,5 @@ export const BARCODE_TYPES = [
 export const DEFAULT_BARCODE_BG_COLOR = '#ffffff';
 
 export const DEFAULT_BARCODE_COLOR = '#000000';
+
+export const DEFAULT_BARCODE_INCLUDETEXT = true;

package/src/barcodes/helper.ts

@@ -1,7 +1,7 @@
 import { b64toUint8Array } from '@pdfme/common';
 import bwipjs, { RenderOptions } from 'bwip-js';
 import { Buffer } from 'buffer';
-import { BARCODE_TYPES } from './constants.js';
+import { BARCODE_TYPES, DEFAULT_BARCODE_INCLUDETEXT } from './constants.js';
 import { BarcodeTypes } from './types';
 
 // GTIN-13, GTIN-8, GTIN-12, GTIN-14
@@ -133,11 +133,20 @@ export const createBarCode = async (arg: {
   backgroundColor?: string;
   barColor?: string;
   textColor?: string;
+  includetext?: boolean;
 }): Promise<Buffer> => {
-  const { type, input, width, height, backgroundColor, barColor, textColor } = arg;
+  const {
+    type,
+    input,
+    width,
+    height,
+    backgroundColor,
+    barColor,
+    textColor,
+    includetext = DEFAULT_BARCODE_INCLUDETEXT,
+  } = arg;
 
   const bcid = barCodeType2Bcid(type);
-  const includetext = true;
   const scale = 5;
   const bwipjsArg: RenderOptions = { bcid, text: input, width, height, scale, includetext };
 

package/src/barcodes/index.ts

@@ -5,7 +5,7 @@ import type { BarcodeSchema, BarcodeTypes } from './types';
 import { BARCODE_TYPES } from './constants.js';
 import { Plugin } from '@pdfme/common';
 
-const schemas = BARCODE_TYPES.reduce(
+const barcodes = BARCODE_TYPES.reduce(
   (acc, type) =>
     Object.assign(acc, {
       [type]: { pdf: pdfRender, ui: uiRender, propPanel: getPropPanelByBarcodeType(type) },
@@ -13,4 +13,4 @@ const schemas = BARCODE_TYPES.reduce(
   {} as Record<BarcodeTypes, Plugin<BarcodeSchema>>
 );
 
-export default schemas;
+export default barcodes;

package/src/barcodes/pdfRender.ts

@@ -1,10 +1,10 @@
 import { PDFRenderProps } from '@pdfme/common';
-import { convertForPdfLayoutProps } from '../renderUtils.js';
+import { convertForPdfLayoutProps } from '../utils.js';
 import type { BarcodeSchema } from './types';
 import { createBarCode, validateBarcodeInput } from './helper.js';
 
 const getBarcodeCacheKey = (schema: BarcodeSchema, value: string) => {
-  return `${schema.type}${schema.backgroundColor}${schema.barColor}${schema.textColor}${value}`;
+  return `${schema.type}${schema.backgroundColor}${schema.barColor}${schema.textColor}${value}${schema.includetext}`;
 };
 
 export const pdfRender = async (arg: PDFRenderProps<BarcodeSchema>) => {

package/src/barcodes/propPanel.ts

@@ -1,6 +1,10 @@
 import type { PropPanel } from '@pdfme/common';
 import type { BarcodeSchema } from './types';
-import { DEFAULT_BARCODE_COLOR, DEFAULT_BARCODE_BG_COLOR } from './constants.js';
+import {
+  DEFAULT_BARCODE_COLOR,
+  DEFAULT_BARCODE_BG_COLOR,
+  DEFAULT_BARCODE_INCLUDETEXT,
+} from './constants.js';
 import { DEFAULT_OPACITY, HEX_COLOR_PATTERN } from '../constants.js';
 
 const defaultColors = {
@@ -8,6 +12,7 @@ const defaultColors = {
   barColor: DEFAULT_BARCODE_COLOR,
 };
 const defaultTextColors = { textColor: DEFAULT_BARCODE_COLOR };
+const defaultIncludetext = { includetext: DEFAULT_BARCODE_INCLUDETEXT };
 const position = { x: 0, y: 0 };
 const default40x20 = { width: 40, height: 20 };
 
@@ -31,6 +36,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       width: 80,
       height: 7.2,
       rotate: 0,
@@ -44,6 +50,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       height: 16,
       rotate: 0,
@@ -57,6 +64,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       rotate: 0,
       opacity: DEFAULT_OPACITY,
@@ -69,6 +77,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       opacity: DEFAULT_OPACITY,
     },
@@ -80,6 +89,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       rotate: 0,
       opacity: DEFAULT_OPACITY,
@@ -92,6 +102,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       rotate: 0,
       opacity: DEFAULT_OPACITY,
@@ -104,6 +115,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       height: 12,
       rotate: 0,
@@ -117,6 +129,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       height: 16,
       rotate: 0,
@@ -130,6 +143,7 @@ const barcodeDefaults: { defaultValue: string; defaultSchema: BarcodeSchema }[]
       position,
       ...defaultColors,
       ...defaultTextColors,
+      ...defaultIncludetext,
       ...default40x20,
       rotate: 0,
       opacity: DEFAULT_OPACITY,
@@ -154,38 +168,44 @@ export const getPropPanelByBarcodeType = (barcodeType: string): PropPanel<Barcod
 
   const defaults = barcodeDefaults.find(({ defaultSchema }) => defaultSchema.type === barcodeType);
 
-  if (!defaults) throw new Error(`[@pdfme/schemas] No default for barcode type ${barcodeType}`);
+  if (!defaults)
+    throw new Error(`[@pdfme/schemas/barcodes] No default for barcode type ${barcodeType}`);
 
   return {
-    schema: ({ i18n }) => {
-      return {
-        barColor: {
-          title: i18n('schemas.barcodes.barColor'),
-          type: 'string',
-          widget: 'color',
-          rules: [
-            {
-              pattern: HEX_COLOR_PATTERN,
-              message: 'Please enter a valid hex color code.',
+    schema: ({ i18n }) => ({
+      barColor: {
+        title: i18n('schemas.barcodes.barColor'),
+        type: 'string',
+        widget: 'color',
+        rules: [
+          {
+            pattern: HEX_COLOR_PATTERN,
+            message: i18n('hexColorPrompt'),
+          },
+        ],
+      },
+      backgroundColor: {
+        title: i18n('schemas.bgColor'),
+        type: 'string',
+        widget: 'color',
+        rules: [
+          {
+            pattern: HEX_COLOR_PATTERN,
+            message: i18n('hexColorPrompt'),
+          },
+        ],
+      },
+      ...(barcodeHasText
+        ? {
+            textColor: { title: i18n('schemas.textColor'), type: 'string', widget: 'color' },
+            includetext: {
+              title: i18n('schemas.barcodes.includetext'),
+              type: 'boolean',
+              widget: 'switch',
             },
-          ],
-        },
-        backgroundColor: {
-          title: i18n('schemas.bgColor'),
-          type: 'string',
-          widget: 'color',
-          rules: [
-            {
-              pattern: HEX_COLOR_PATTERN,
-              message: 'Please enter a valid hex color code.',
-            },
-          ],
-        },
-        ...(barcodeHasText
-          ? { textColor: { title: i18n('schemas.textColor'), type: 'string', widget: 'color' } }
-          : {}),
-      };
-    },
+          }
+        : {}),
+    }),
     ...defaults,
   };
 };

package/src/barcodes/types.ts

@@ -6,6 +6,7 @@ export interface BarcodeSchema extends Schema {
   backgroundColor: string;
   barColor: string;
   textColor?: string;
+  includetext?: boolean;
 }
 
 export type BarcodeTypes = (typeof BARCODE_TYPES)[number];

package/src/barcodes/uiRender.ts

@@ -2,37 +2,10 @@ import type * as CSS from 'csstype';
 import { UIRenderProps } from '@pdfme/common';
 import type { BarcodeSchema } from './types';
 import { validateBarcodeInput, createBarCode } from './helper.js';
-import { addAlphaToHex } from '../renderUtils.js';
+import { addAlphaToHex, isEditable, createErrorElm } from '../utils.js';
 
 const fullSize = { width: '100%', height: '100%' };
 
-const createErrorBarcodeElm = () => {
-  const container = document.createElement('div');
-  const containerStyle: CSS.Properties = {
-    display: 'flex',
-    alignItems: 'center',
-    justifyContent: 'center',
-    ...fullSize,
-  };
-  Object.assign(container.style, containerStyle);
-
-  const span = document.createElement('span');
-  const spanStyle: CSS.Properties = {
-    color: 'white',
-    background: 'red',
-    padding: '0.25rem',
-    fontSize: '12pt',
-    fontWeight: 'bold',
-    borderRadius: '2px',
-  };
-  Object.assign(span.style, spanStyle);
-
-  span.textContent = 'ERROR';
-  container.appendChild(span);
-
-  return container;
-};
-
 const blobToDataURL = (blob: Blob): Promise<string> =>
   new Promise((resolve, reject) => {
     const reader = new FileReader();
@@ -71,20 +44,20 @@ export const uiRender = async (arg: UIRenderProps<BarcodeSchema>) => {
     alignItems: 'center',
     justifyContent: 'center',
     fontFamily: "'Open Sans', sans-serif",
-    opacity: schema.opacity,
   };
   Object.assign(container.style, containerStyle);
   rootElement.appendChild(container);
-  const editable = mode === 'form' || mode === 'designer';
+  const editable = isEditable(mode, schema);
   if (editable) {
     const input = document.createElement('input');
     const inputStyle: CSS.Properties = {
-      ...fullSize,
+      width: '100%',
       position: 'absolute',
       textAlign: 'center',
-      fontSize: '1rem',
-      color: '#000',
-      backgroundColor: editable || value ? addAlphaToHex(theme.colorPrimaryBg, 30) : 'none',
+      fontSize: '12pt',
+      fontWeight: 'bold',
+      color: theme.colorWhite,
+      backgroundColor: editable || value ? addAlphaToHex('#000000', 80) : 'none',
       border: 'none',
       display: 'flex',
       alignItems: 'center',
@@ -102,21 +75,18 @@ export const uiRender = async (arg: UIRenderProps<BarcodeSchema>) => {
       stopEditing && stopEditing();
     });
     container.appendChild(input);
-    if (mode === 'designer') {
-      input.setSelectionRange(value.length, value.length);
-      input.focus();
-    }
+    input.setSelectionRange(value.length, value.length);
+    input.focus();
   }
 
   if (!value) return;
   try {
     if (!validateBarcodeInput(schema.type, value))
-      throw new Error('[@pdfme/schemas] Invalid barcode input');
+      throw new Error('[@pdfme/schemas/barcodes] Invalid barcode input');
     const imgElm = await createBarcodeImageElm(schema, value);
     container.appendChild(imgElm);
   } catch (err) {
     console.error(`[@pdfme/ui] ${err}`);
-    const errorBarcodeElm = createErrorBarcodeElm();
-    container.appendChild(errorBarcodeElm);
+    container.appendChild(createErrorElm());
   }
 };

package/src/graphics/helper.ts

@@ -0,0 +1,147 @@
+// ref: https://github.com/image-size/image-size ----------------------------
+// The following code is adapted from the image-size code. Unnecessary formats and dependencies on Node have been removed.
+type IImage = {
+  validate: (input: Uint8Array) => boolean;
+  calculate: (input: Uint8Array) => { width: number; height: number } | undefined;
+};
+
+const decoder = new TextDecoder();
+const toUTF8String = (input: Uint8Array, start = 0, end = input.length) =>
+  decoder.decode(input.slice(start, end));
+
+const toHexString = (input: Uint8Array, start = 0, end = input.length) =>
+  input.slice(start, end).reduce((memo, i) => memo + ('0' + i.toString(16)).slice(-2), '');
+
+const readUInt16BE = (input: Uint8Array, offset = 0) => input[offset] * 2 ** 8 + input[offset + 1];
+
+const readUInt32BE = (input: Uint8Array, offset = 0) =>
+  input[offset] * 2 ** 24 +
+  input[offset + 1] * 2 ** 16 +
+  input[offset + 2] * 2 ** 8 +
+  input[offset + 3];
+
+const extractSize = (input: Uint8Array, index: number) => {
+  return {
+    height: readUInt16BE(input, index),
+    width: readUInt16BE(input, index + 2),
+  };
+};
+
+const validateInput = (input: Uint8Array, index: number): void => {
+  // index should be within buffer limits
+  if (index > input.length) {
+    throw new TypeError('Corrupt JPG, exceeded buffer limits');
+  }
+  // Every JPEG block must begin with a 0xFF
+  if (input[index] !== 0xff) {
+    throw new TypeError('Invalid JPG, marker table corrupted');
+  }
+};
+
+const JPG: IImage = {
+  validate: (input) => toHexString(input, 0, 2) === 'ffd8',
+
+  calculate(input) {
+    // Skip 4 chars, they are for signature
+    input = input.slice(4);
+
+    let next: number;
+    while (input.length) {
+      // read length of the next block
+      const i = readUInt16BE(input, 0);
+
+      // ensure correct format
+      validateInput(input, i);
+
+      // 0xFFC0 is baseline standard(SOF)
+      // 0xFFC1 is baseline optimized(SOF)
+      // 0xFFC2 is progressive(SOF2)
+      next = input[i + 1];
+      if (next === 0xc0 || next === 0xc1 || next === 0xc2) {
+        const size = extractSize(input, i + 5);
+
+        return size;
+      }
+
+      // move to the next block
+      input = input.slice(i + 2);
+    }
+
+    throw new TypeError('Invalid JPG, no size found');
+  },
+};
+
+const pngSignature = 'PNG\r\n\x1a\n';
+const pngImageHeaderChunkName = 'IHDR';
+
+// Used to detect "fried" png's: http://www.jongware.com/pngdefry.html
+const pngFriedChunkName = 'CgBI';
+
+const PNG: IImage = {
+  validate(input) {
+    if (pngSignature === toUTF8String(input, 1, 8)) {
+      let chunkName = toUTF8String(input, 12, 16);
+      if (chunkName === pngFriedChunkName) {
+        chunkName = toUTF8String(input, 28, 32);
+      }
+      if (chunkName !== pngImageHeaderChunkName) {
+        throw new TypeError('Invalid PNG');
+      }
+      return true;
+    }
+    return false;
+  },
+
+  calculate(input) {
+    if (toUTF8String(input, 12, 16) === pngFriedChunkName) {
+      return {
+        height: readUInt32BE(input, 36),
+        width: readUInt32BE(input, 32),
+      };
+    }
+    return {
+      height: readUInt32BE(input, 20),
+      width: readUInt32BE(input, 16),
+    };
+  },
+};
+
+const typeHandlers = {
+  jpg: JPG,
+  png: PNG,
+};
+
+type imageType = keyof typeof typeHandlers;
+
+function detector(input: Uint8Array): imageType | undefined {
+  const firstBytes: { [byte: number]: imageType } = {
+    0x89: 'png',
+    0xff: 'jpg',
+  };
+  const byte = input[0];
+  if (byte in firstBytes) {
+    const type = firstBytes[byte];
+    if (type && typeHandlers[type].validate(input)) {
+      return type;
+    }
+  }
+
+  const keys = Object.keys(typeHandlers) as imageType[];
+  return keys.find((key: imageType) => typeHandlers[key].validate(input));
+}
+
+export const imageSize = (imgBuffer: Buffer): { height: number; width: number } => {
+  const type = detector(imgBuffer);
+
+  if (typeof type !== 'undefined' && type in typeHandlers) {
+    const size = typeHandlers[type].calculate(imgBuffer);
+    if (size !== undefined) {
+      return size;
+    }
+  }
+
+  throw new TypeError(
+    '[@pdfme/schemas/images] Unsupported file type: ' + (type === undefined ? 'undefined' : type)
+  );
+};
+// ----------------------------