@pdfme/schemas 5.0.0-dev.3 → 5.0.0-dev.5

package/src/date/helper.ts

@@ -0,0 +1,262 @@
+import type * as CSS from 'csstype';
+import { format } from 'date-fns';
+import { zhCN, ja, ko, ar, th, pl, it, de, es, fr, Locale } from 'date-fns/locale';
+import {
+  Lang,
+  Plugin,
+  getDefaultFont,
+  getFallbackFontName,
+  DEFAULT_FONT_NAME,
+  PropPanelSchema,
+} from '@pdfme/common';
+import text from '../text';
+import { DEFAULT_OPACITY, HEX_COLOR_PATTERN } from '../constants.js';
+import { mapVerticalAlignToFlex, getBackgroundColor } from '../text/uiRender';
+import { getFontKitFont, getBrowserVerticalFontAdjustments } from '../text/helper.js';
+import {
+  DEFAULT_FONT_SIZE,
+  DEFAULT_ALIGNMENT,
+  DEFAULT_VERTICAL_ALIGNMENT,
+  DEFAULT_LINE_HEIGHT,
+  DEFAULT_CHARACTER_SPACING,
+  DEFAULT_FONT_COLOR,
+} from '../text/constants.js';
+import { DateSchema } from './types';
+import { getExtraFormatterSchema, Formatter } from '../text/extraFormatter';
+
+const getLocale = (lang: Lang): Locale | undefined =>
+  ({ en: undefined, zh: zhCN, ja, ko, ar, th, pl, it, de, es, fr }[lang]);
+
+export const getPlugin = ({
+  type,
+  defaultFormat,
+  icon,
+  inputType,
+  formatsByLang,
+}: {
+  type: 'date' | 'time' | 'dateTime';
+  defaultFormat: string;
+  icon: string;
+  inputType: string;
+  formatsByLang: Record<Lang, string[]>;
+}) => {
+  const plugin: Plugin<DateSchema> = {
+    ui: async (arg) => {
+      const { schema, value, onChange, rootElement, mode, options, _cache } = arg;
+      rootElement.innerHTML = '';
+
+      const font = options?.font || getDefaultFont();
+      const fontKitFont = await getFontKitFont(schema.fontName, font, _cache);
+
+      const { topAdj, bottomAdj } = getBrowserVerticalFontAdjustments(
+        fontKitFont,
+        schema.fontSize ?? DEFAULT_FONT_SIZE,
+        DEFAULT_LINE_HEIGHT,
+        schema.verticalAlignment ?? DEFAULT_VERTICAL_ALIGNMENT
+      );
+
+      const topAdjustment = topAdj.toString();
+      const bottomAdjustment = bottomAdj.toString();
+      const textStyle: CSS.Properties = {
+        fontFamily: schema.fontName ? `'${schema.fontName}'` : 'inherit',
+        color: schema.fontColor ?? DEFAULT_FONT_COLOR,
+        fontSize: `${schema.fontSize ?? DEFAULT_FONT_SIZE}pt`,
+        letterSpacing: `${schema.characterSpacing ?? DEFAULT_CHARACTER_SPACING}pt`,
+        textAlign: schema.alignment ?? DEFAULT_ALIGNMENT,
+        backgroundColor: getBackgroundColor(value, schema),
+
+        margin: '0',
+        width: `${schema.width}mm`,
+        height: `${schema.height}mm`,
+        display: 'flex',
+        flexDirection: 'column',
+        justifyContent: mapVerticalAlignToFlex(schema.verticalAlignment),
+        paddingTop: `${topAdjustment}px`,
+        marginBottom: `${bottomAdjustment}px`,
+        position: 'relative',
+      };
+
+      const textElement = document.createElement('p');
+      Object.assign(textElement.style, textStyle);
+      rootElement.appendChild(textElement);
+
+      textElement.textContent = value
+        ? format(
+            type === 'time' ? new Date(`2021-01-01T${value}`) : new Date(value),
+            schema.format,
+            { locale: getLocale(options?.lang || 'en') }
+          )
+        : '';
+
+      if (mode !== 'viewer' && !(mode === 'form' && schema.readOnly)) {
+        const dateTimeInput = document.createElement('input');
+        dateTimeInput.type = inputType;
+        dateTimeInput.value = value;
+
+        const dateTimeInputStyle: CSS.Properties = {
+          ...textStyle,
+          opacity: '0',
+          position: 'absolute',
+          top: '0',
+          left: '0',
+          border: 'none',
+          zIndex: '-1',
+        };
+
+        Object.assign(dateTimeInput.style, dateTimeInputStyle);
+        rootElement.appendChild(dateTimeInput);
+
+        textElement.style.cursor = 'pointer';
+        textElement.addEventListener('click', () => {
+          dateTimeInput.showPicker();
+          textElement.style.opacity = '0';
+          dateTimeInput.style.opacity = '1';
+          dateTimeInput.style.zIndex = '1';
+        });
+
+        dateTimeInput.addEventListener('change', (e) => {
+          if (onChange && e.target instanceof HTMLInputElement) {
+            onChange({ key: 'content', value: e.target.value });
+          }
+        });
+
+        dateTimeInput.addEventListener('blur', () => {
+          textElement.style.opacity = '1';
+          dateTimeInput.style.opacity = '0';
+          dateTimeInput.style.zIndex = '-1';
+        });
+
+        const removeButton = document.createElement('button');
+        removeButton.textContent = 'x';
+        const buttonWidth = 30;
+        const removeButtonStyle: CSS.Properties = {
+          position: 'absolute',
+          top: '0px',
+          right: `-${buttonWidth}px`,
+          padding: '5px',
+          width: `${buttonWidth}px`,
+          height: `${buttonWidth}px`,
+        };
+        Object.assign(removeButton.style, removeButtonStyle);
+        removeButton.addEventListener('click', () => {
+          onChange && onChange({ key: 'content', value: '' });
+        });
+        rootElement.appendChild(removeButton);
+      }
+    },
+    pdf: (arg) => {
+      const { schema, value, options } = arg;
+      if (!value) return void 0;
+      const lang = (options.language || 'en') as Lang;
+      const locale = getLocale(lang);
+      const date = schema.type === 'time' ? new Date(`2021-01-01T${value}`) : new Date(value);
+      const formattedValue = format(date, schema.format, { locale });
+      return text.pdf(
+        Object.assign(arg, {
+          value: formattedValue,
+          schema: { ...schema, lineHeight: DEFAULT_LINE_HEIGHT },
+        })
+      );
+    },
+    propPanel: {
+      schema: ({ options, i18n }) => {
+        const font = options.font || { [DEFAULT_FONT_NAME]: { data: '', fallback: true } };
+        const lang = options.lang || 'en';
+        const locale = getLocale(lang);
+
+        const fontNames = Object.keys(font);
+        const fallbackFontName = getFallbackFontName(font);
+
+        const formatter = getExtraFormatterSchema(i18n);
+        formatter.buttons = formatter.buttons.filter(
+          (button) => button.key !== Formatter.STRIKETHROUGH && button.key !== Formatter.UNDERLINE
+        );
+
+        const currentDate = new Date();
+
+        const dateSchema: Record<string, PropPanelSchema> = {
+          format: {
+            title: i18n('schemas.date.format'),
+            type: 'string',
+            widget: 'select',
+            props: {
+              options: formatsByLang[lang].map((formatString) => ({
+                label: `${formatString} (${format(currentDate, formatString, { locale })})`,
+                value: formatString,
+              })),
+            },
+            span: 24,
+          },
+          fontName: {
+            title: i18n('schemas.text.fontName'),
+            type: 'string',
+            widget: 'select',
+            default: fallbackFontName,
+            props: { options: fontNames.map((name) => ({ label: name, value: name })) },
+            span: 12,
+          },
+          fontSize: {
+            title: i18n('schemas.text.size'),
+            type: 'number',
+            widget: 'inputNumber',
+            span: 6,
+            props: { min: 0 },
+          },
+          characterSpacing: {
+            title: i18n('schemas.text.spacing'),
+            type: 'number',
+            widget: 'inputNumber',
+            span: 6,
+            props: { min: 0 },
+          },
+          formatter,
+          fontColor: {
+            title: i18n('schemas.textColor'),
+            type: 'string',
+            widget: 'color',
+            rules: [
+              {
+                pattern: HEX_COLOR_PATTERN,
+                message: i18n('validation.hexColor'),
+              },
+            ],
+          },
+          backgroundColor: {
+            title: i18n('schemas.bgColor'),
+            type: 'string',
+            widget: 'color',
+            rules: [
+              {
+                pattern: HEX_COLOR_PATTERN,
+                message: i18n('validation.hexColor'),
+              },
+            ],
+          },
+        };
+
+        return dateSchema;
+      },
+      defaultSchema: {
+        name: '',
+        format: defaultFormat,
+        type,
+        content: format(new Date(), defaultFormat),
+        position: { x: 0, y: 0 },
+        width: 70,
+        height: 10,
+        rotate: 0,
+        alignment: DEFAULT_ALIGNMENT,
+        verticalAlignment: DEFAULT_VERTICAL_ALIGNMENT,
+        fontSize: DEFAULT_FONT_SIZE,
+        characterSpacing: DEFAULT_CHARACTER_SPACING,
+        fontColor: DEFAULT_FONT_COLOR,
+        fontName: undefined,
+        backgroundColor: '',
+        opacity: DEFAULT_OPACITY,
+      },
+    },
+    icon,
+  };
+
+  return plugin;
+};

package/src/date/time.ts

@@ -0,0 +1,31 @@
+import { Lang } from '@pdfme/common';
+import { getPlugin } from './helper';
+
+const type = 'time';
+
+const inputType = 'time';
+
+const defaultFormat = 'HH:mm';
+
+const formatsByLang: Record<Lang, string[]> = {
+  en: [defaultFormat, 'hh:mm a', 'HH:mm:ss', 'hh:mm:ss a'],
+  zh: [defaultFormat, 'HH时mm分', 'HH:mm:ss'],
+  ja: [defaultFormat, 'HH時mm分', 'HH:mm:ss'],
+  ko: [defaultFormat, 'a h시 mm분', 'HH:mm:ss'],
+  ar: [defaultFormat, 'hh:mm a', 'HH:mm:ss'],
+  th: [defaultFormat, 'HH.mm', 'HH:mm:ss'],
+  pl: [defaultFormat, 'HH:mm:ss'],
+  it: [defaultFormat, 'HH.mm', 'HH:mm:ss'],
+  de: [defaultFormat, 'HH.mm', 'HH:mm:ss'],
+  es: [defaultFormat, 'hh:mm a', 'HH:mm:ss'],
+  fr: [defaultFormat, 'HH:mm:ss'],
+};
+
+const icon =
+  '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" ' +
+  'viewBox="0 0 24 24" fill="none" stroke="currentColor" ' +
+  'stroke-width="2" stroke-linecap="round" stroke-linejoin="round" ' +
+  'class="lucide lucide-clock"><circle cx="12" cy="12" r="10"/>' +
+  '<polyline points="12 6 12 12 16 14"/></svg>';
+
+export default getPlugin({ type, defaultFormat, icon, inputType, formatsByLang });

package/src/date/types.ts

@@ -0,0 +1,13 @@
+import { Schema } from '@pdfme/common';
+import { ALIGNMENT, VERTICAL_ALIGNMENT } from '../text/types';
+
+export interface DateSchema extends Schema {
+  format: string;
+  fontName?: string;
+  alignment: ALIGNMENT;
+  verticalAlignment: VERTICAL_ALIGNMENT;
+  fontSize: number;
+  characterSpacing: number;
+  fontColor: string;
+  backgroundColor: string;
+}

package/src/index.ts

@@ -6,6 +6,10 @@ import barcodes from './barcodes/index.js';
 import line from './shapes/line.js';
 import table from './tables/index.js';
 import { rectangle, ellipse } from './shapes/rectAndEllipse.js';
+import dateTime from './date/dateTime.js';
+import date from './date/date.js';
+import time from './date/time.js';
+import select from './select/index.js';
 
 const builtInPlugins = { Text: text };
 
@@ -21,4 +25,8 @@ export {
   line,
   rectangle,
   ellipse,
+  dateTime,
+  date,
+  time,
+  select,
 };

package/src/select/index.ts

@@ -0,0 +1,199 @@
+import type * as CSS from 'csstype';
+import { propPanel as parentPropPanel } from '../text/propPanel';
+import { Plugin, PropPanelWidgetProps, SchemaForUI } from '@pdfme/common';
+import text from '../text';
+import { TextSchema } from '../text/types';
+
+const selectIcon =
+  '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevron-down"><path d="m6 9 6 6 6-6"/></svg>';
+
+interface Select extends TextSchema {
+  options: string[];
+}
+
+const addOptions = (props: PropPanelWidgetProps) => {
+  const { rootElement, changeSchemas, activeSchema, i18n } = props;
+
+  rootElement.innerHTML = '';
+
+  const selectSchema = activeSchema as SchemaForUI & Select;
+  const currentOptions = selectSchema.options ? [...selectSchema.options] : [];
+
+  const container = document.createElement('div');
+
+  const inputStyle = {
+    flexGrow: '1',
+    padding: '8px',
+    border: '1px solid #ccc',
+    borderRadius: '4px',
+  };
+
+  const buttonStyle = { border: 'none', borderRadius: '4px', cursor: 'pointer' };
+
+  const updateSchemas = () => {
+    changeSchemas([
+      { key: 'options', value: currentOptions, schemaId: activeSchema.id },
+      { key: 'content', value: currentOptions[0] || '', schemaId: activeSchema.id },
+    ]);
+  };
+
+  const formContainer = document.createElement('div');
+  Object.assign(formContainer.style, {
+    display: 'flex',
+    alignItems: 'center',
+    marginBottom: '10px',
+  });
+
+  const input = document.createElement('input');
+  input.type = 'text';
+  input.placeholder = i18n('schemas.select.optionPlaceholder');
+  Object.assign(input.style, inputStyle, { marginRight: '10px' });
+
+  const addButton = document.createElement('button');
+  addButton.textContent = '+';
+  Object.assign(addButton.style, buttonStyle, {
+    width: '25px',
+    height: '25px',
+    padding: '4px 8px',
+  });
+
+  addButton.addEventListener('click', () => {
+    const newValue = input.value.trim();
+    if (newValue) {
+      currentOptions.push(newValue);
+      updateSchemas();
+      renderOptions();
+      input.value = '';
+    }
+  });
+
+  formContainer.appendChild(input);
+  formContainer.appendChild(addButton);
+
+  const optionsList = document.createElement('ul');
+  Object.assign(optionsList.style, { listStyle: 'none', padding: '0' });
+
+  const renderOptions = () => {
+    optionsList.innerHTML = '';
+    currentOptions.forEach((option, index) => {
+      const li = document.createElement('li');
+      Object.assign(li.style, { display: 'flex', alignItems: 'center', marginBottom: '5px' });
+
+      const optionInput = document.createElement('input');
+      optionInput.type = 'text';
+      optionInput.value = option;
+      Object.assign(optionInput.style, inputStyle, { marginRight: '10px' });
+
+      optionInput.addEventListener('change', () => {
+        currentOptions[index] = optionInput.value;
+        updateSchemas();
+      });
+
+      const removeButton = document.createElement('button');
+      removeButton.textContent = 'x';
+      Object.assign(removeButton.style, buttonStyle, { padding: '4px 8px' });
+
+      removeButton.addEventListener('click', () => {
+        currentOptions.splice(index, 1);
+        updateSchemas();
+        renderOptions();
+      });
+
+      li.appendChild(optionInput);
+      li.appendChild(removeButton);
+      optionsList.appendChild(li);
+    });
+  };
+
+  container.appendChild(formContainer);
+  container.appendChild(optionsList);
+  rootElement.appendChild(container);
+
+  renderOptions();
+};
+
+const schema: Plugin<Select> = {
+  ui: async (arg) => {
+    const { schema, value, onChange, rootElement, mode } = arg;
+    await text.ui(Object.assign(arg, { mode: 'viewer' }));
+
+    if (mode !== 'viewer' && !(mode === 'form' && schema.readOnly)) {
+      const buttonWidth = 30;
+      const selectButton = document.createElement('button');
+      selectButton.innerHTML = selectIcon;
+      const selectButtonStyle: CSS.Properties = {
+        position: 'absolute',
+        zIndex: -1,
+        right: `-${buttonWidth}px`,
+        top: '0',
+        padding: '0',
+        margin: '0',
+        cursor: 'pointer',
+        height: `${buttonWidth}px`,
+        width: `${buttonWidth}px`,
+      };
+      Object.assign(selectButton.style, selectButtonStyle);
+
+      rootElement.appendChild(selectButton);
+
+      const selectElement = document.createElement('select');
+      const selectElementStyle: CSS.Properties = {
+        opacity: '0',
+        position: 'absolute',
+        width: `calc(100% + ${buttonWidth}px)`,
+        height: '100%',
+        top: '0',
+        left: '0',
+        appearance: 'initial',
+      };
+      Object.assign(selectElement.style, selectElementStyle);
+      selectElement.value = value;
+
+      selectElement.addEventListener('change', (e) => {
+        if (onChange && e.target instanceof HTMLSelectElement) {
+          onChange && onChange({ key: 'content', value: e.target.value });
+        }
+      });
+
+      selectElement.innerHTML = schema.options
+        .map(
+          (option) =>
+            `<option value="${option}" ${option === value ? 'selected' : ''}>${option}</option>`
+        )
+        .join('');
+      rootElement.appendChild(selectElement);
+    }
+  },
+  pdf: text.pdf,
+  propPanel: {
+    ...text.propPanel,
+    widgets: { ...parentPropPanel.widgets, addOptions },
+    schema: (propPanelProps: Omit<PropPanelWidgetProps, 'rootElement'>) => {
+      if (typeof parentPropPanel.schema !== 'function') {
+        throw Error('Oops, is text schema no longer a function?');
+      }
+
+      return {
+        ...parentPropPanel.schema(propPanelProps),
+        '-------': { type: 'void', widget: 'Divider' },
+
+        optionsContainer: {
+          title: (propPanelProps as PropPanelWidgetProps).i18n('schemas.select.options'),
+          type: 'string',
+          widget: 'Card',
+          span: 24,
+          properties: { options: { widget: 'addOptions' } },
+        },
+      };
+    },
+    defaultSchema: {
+      ...text.propPanel.defaultSchema,
+      type: 'select',
+      content: 'option1',
+      options: ['option1', 'option2'],
+    },
+  },
+  icon: selectIcon,
+};
+
+export default schema;

package/src/text/extraFormatter.ts

@@ -35,14 +35,17 @@ interface GroupButtonString {
   key: Formatter;
   icon: string;
   type: 'select';
-  value: String;
+  value: string;
 }
 
 export type GroupButton = GroupButtonBoolean | GroupButtonString;
 
-export function getExtraFormatterSchema(
-  i18n: (key: keyof Dict | string) => string
-): Record<string, any> {
+export function getExtraFormatterSchema(i18n: (key: keyof Dict | string) => string): {
+  title: string;
+  widget: string;
+  buttons: GroupButton[];
+  span: number;
+} {
   const buttons: GroupButton[] = [
     { key: Formatter.STRIKETHROUGH, icon: TextStrikethroughIcon, type: 'boolean' },
     { key: Formatter.UNDERLINE, icon: TextUnderlineIcon, type: 'boolean' },

package/src/text/uiRender.ts

@@ -228,7 +228,7 @@ export const buildStyledTextContainer = async (arg: UIRenderProps<TextSchema>, v
   };
 
   const textBlock = document.createElement('div');
-  textBlock.id = 'text-' + schema.id;
+  textBlock.id = 'text-' + String(schema.id);
   Object.assign(textBlock.style, textBlockStyle);
 
   container.appendChild(textBlock);
@@ -265,7 +265,7 @@ export const makeElementPlainTextContentEditable = (element: HTMLElement) => {
   });
 };
 
-const mapVerticalAlignToFlex = (verticalAlignmentValue: string | undefined) => {
+export const mapVerticalAlignToFlex = (verticalAlignmentValue: string | undefined) => {
   switch (verticalAlignmentValue) {
     case VERTICAL_ALIGN_TOP:
       return 'flex-start';
@@ -277,7 +277,7 @@ const mapVerticalAlignToFlex = (verticalAlignmentValue: string | undefined) => {
   return 'flex-start';
 };
 
-const getBackgroundColor = (value: string, schema: TextSchema) => {
+export const getBackgroundColor = (value: string, schema: { backgroundColor?: string }) => {
   if (!value || !schema.backgroundColor) return 'transparent';
-  return schema.backgroundColor as string;
+  return schema.backgroundColor;
 };