@campxdev/pdfme 1.2.2 → 1.3.0

package/dist/cjs/schemas.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var index = require('./chunks/index-CVqJfcgy.js');
-var index$1 = require('./chunks/index-C8qZMUOU.js');
+var index = require('./chunks/index-CsEKt088.js');
+var fontSizePxWidget = require('./chunks/fontSizePxWidget-Drk8HKGH.js');
 var lucide = require('lucide');
-var helper = require('./chunks/helper-BfoMn47R.js');
+var helper = require('./chunks/helper-DGH62Z2s.js');
 var AirDatepicker = require('air-datepicker');
 var localeAr = require('air-datepicker/locale/ar');
 var localeBg = require('air-datepicker/locale/bg');
@@ -108,11 +108,470 @@ var localeUk__default = /*#__PURE__*/_interopDefault(localeUk);
 var localeZh__default = /*#__PURE__*/_interopDefault(localeZh);
 var dateFns__namespace = /*#__PURE__*/_interopNamespace(dateFns);
 
-const textSchema = {
-    pdf: index.pdfRender,
-    ui: index.uiRender,
-    propPanel: index.propPanel,
-    icon: index.createSvgStr(lucide.TextCursorInput),
+const pdfRender$2 = async (arg) => {
+    const { value, schema, pageContext, ...rest } = arg;
+    // Static mode: no template text → render value directly as plain text
+    if (!schema.text) {
+        await index.pdfRender({ value, schema, ...rest });
+        return;
+    }
+    // readOnly: value is already resolved by generate.ts via replacePlaceholders
+    if (schema.readOnly) {
+        await index.pdfRender({ value, schema, ...rest });
+        return;
+    }
+    // Dynamic mode (form): substitute variables in template
+    if (!fontSizePxWidget.validateVariables(value, schema)) {
+        return;
+    }
+    const renderArgs = {
+        value: fontSizePxWidget.substituteVariables(schema.text, value || '{}', pageContext),
+        schema,
+        ...rest,
+    };
+    await index.pdfRender(renderArgs);
+};
+
+const insertVariableWidget = fontSizePxWidget.createInsertVariableWidget('text');
+const mapDynamicVariables = (props) => {
+    const { rootElement, changeSchemas, activeSchema } = props;
+    const mvtSchema = activeSchema;
+    const text = mvtSchema.text ?? '';
+    if (!text) {
+        rootElement.style.display = 'none';
+        return;
+    }
+    const variables = JSON.parse(mvtSchema.content || '{}');
+    const variablesChanged = updateVariablesFromText(text, variables);
+    const varNames = Object.keys(variables);
+    if (variablesChanged) {
+        changeSchemas([
+            { key: 'content', value: JSON.stringify(variables), schemaId: activeSchema.id },
+            { key: 'variables', value: varNames, schemaId: activeSchema.id },
+            { key: 'readOnly', value: varNames.length === 0, schemaId: activeSchema.id },
+        ]);
+    }
+    // No UI needed — sample data is auto-generated from variable paths
+    rootElement.style.display = 'none';
+};
+const propPanel$1 = {
+    schema: (propPanelProps) => {
+        if (typeof index.propPanel.schema !== 'function') {
+            throw new Error('Oops, is text schema no longer a function?');
+        }
+        // Safely call schema function with proper type handling
+        const parentSchema = typeof index.propPanel.schema === 'function' ? index.propPanel.schema(propPanelProps) : {};
+        return {
+            insertVariablePicker: {
+                type: 'void',
+                widget: 'insertVariableWidget',
+                bind: false,
+                span: 24,
+            },
+            '----': { type: 'void', widget: 'Divider' },
+            ...parentSchema,
+            dynamicVariables: {
+                type: 'object',
+                widget: 'mapDynamicVariables',
+                bind: false,
+                span: 0,
+            },
+        };
+    },
+    widgets: { ...(index.propPanel.widgets || {}), mapDynamicVariables, insertVariableWidget },
+    defaultSchema: {
+        ...index.propPanel.defaultSchema,
+        readOnly: false,
+        type: 'text',
+        text: 'Type Something...',
+        width: 50,
+        height: 15,
+        content: '{}',
+        variables: [],
+    },
+};
+/** Known JS globals/keywords that should NOT be treated as user-defined variables */
+const RESERVED_NAMES$1 = new Set([
+    'true', 'false', 'null', 'undefined', 'typeof', 'instanceof', 'in',
+    'void', 'delete', 'new', 'this', 'NaN', 'Infinity',
+    'Math', 'String', 'Number', 'Boolean', 'Array', 'Object', 'Date', 'JSON',
+    'isNaN', 'parseFloat', 'parseInt', 'decodeURI', 'decodeURIComponent',
+    'encodeURI', 'encodeURIComponent', 'date', 'dateTime',
+    'currentPage', 'totalPages',
+]);
+/**
+ * Extract full dot-notation paths from an expression string.
+ * E.g. "student.marks.sem1 > 80" → ["student.marks.sem1"]
+ * Handles method calls: "student.name.toUpperCase()" → ["student.name"]
+ * Skips string literals and reserved names.
+ */
+const extractDotPaths = (expr) => {
+    // Replace string literals with spaces (preserving positions for nextChar lookup)
+    const cleaned = expr.replace(/'[^']*'|"[^"]*"|`[^`]*`/g, (m) => ' '.repeat(m.length));
+    const pathRegex = /[a-zA-Z_$][a-zA-Z0-9_$]*(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*)*/g;
+    const paths = new Set();
+    let m;
+    while ((m = pathRegex.exec(cleaned)) !== null) {
+        let path = m[0];
+        // If followed by '(', the last segment is a method call — trim it
+        const nextChar = cleaned[m.index + path.length];
+        if (nextChar === '(') {
+            const lastDot = path.lastIndexOf('.');
+            if (lastDot !== -1) {
+                path = path.substring(0, lastDot);
+            }
+            else {
+                // Standalone function call like parseInt(...) — skip
+                continue;
+            }
+        }
+        const root = path.split('.')[0];
+        if (!RESERVED_NAMES$1.has(root))
+            paths.add(path);
+    }
+    return Array.from(paths);
+};
+/**
+ * Build a nested default object from dot-paths.
+ * E.g. ["student.name", "student.marks.sem1"] →
+ *   { name: "NAME", marks: { sem1: "SEM1" } }
+ * Merges into an existing object, only adding missing leaves.
+ * Returns true if anything was added.
+ */
+const buildNestedDefault = (obj, paths) => {
+    let added = false;
+    for (const path of paths) {
+        const parts = path.split('.');
+        if (parts.length <= 1)
+            continue; // no nested parts
+        let current = obj;
+        for (let i = 1; i < parts.length - 1; i++) {
+            if (!(parts[i] in current) || typeof current[parts[i]] !== 'object' || current[parts[i]] === null) {
+                current[parts[i]] = {};
+                added = true;
+            }
+            current = current[parts[i]];
+        }
+        const leaf = parts[parts.length - 1];
+        if (!(leaf in current)) {
+            current[leaf] = path.replace(/\./g, '_').toUpperCase();
+            added = true;
+        }
+    }
+    return added;
+};
+const updateVariablesFromText = (text, variables) => {
+    // Find all {...} blocks and extract dot-notation paths from each
+    const blockRegex = /\{([^{}]+)\}/g;
+    const allPaths = new Set();
+    let blockMatch;
+    while ((blockMatch = blockRegex.exec(text)) !== null) {
+        for (const path of extractDotPaths(blockMatch[1])) {
+            allPaths.add(path);
+        }
+    }
+    // Group paths by root identifier
+    const rootToPaths = new Map();
+    for (const path of allPaths) {
+        const root = path.split('.')[0];
+        if (!rootToPaths.has(root))
+            rootToPaths.set(root, []);
+        rootToPaths.get(root).push(path);
+    }
+    const allRoots = new Set(rootToPaths.keys());
+    let changed = false;
+    for (const [root, paths] of rootToPaths) {
+        const hasNested = paths.some((p) => p.includes('.'));
+        if (hasNested) {
+            // Parse existing value or start fresh
+            let obj = {};
+            if (root in variables) {
+                try {
+                    const parsed = JSON.parse(variables[root]);
+                    if (typeof parsed === 'object' && parsed !== null) {
+                        obj = parsed;
+                    }
+                }
+                catch {
+                    /* not JSON, will rebuild */
+                }
+            }
+            const added = buildNestedDefault(obj, paths);
+            if (!(root in variables) || added) {
+                variables[root] = JSON.stringify(obj);
+                changed = true;
+            }
+        }
+        else {
+            if (!(root in variables)) {
+                variables[root] = root.toUpperCase();
+                changed = true;
+            }
+        }
+    }
+    // Remove variables whose root is no longer referenced
+    for (const varName of Object.keys(variables)) {
+        if (!allRoots.has(varName)) {
+            delete variables[varName];
+            changed = true;
+        }
+    }
+    return changed;
+};
+
+const uiRender$2 = async (arg) => {
+    const { value, schema, rootElement, mode, onChange, pageContext, ...rest } = arg;
+    // Static mode: no template text → delegate to plain text behavior
+    if (!schema.text) {
+        await index.uiRender(arg);
+        return;
+    }
+    // Dynamic mode: template with optional variables
+    let text = schema.text;
+    let numVariables = (schema.variables || []).length;
+    if (mode === 'form' && numVariables > 0) {
+        await formUiRender(arg);
+        return;
+    }
+    await index.uiRender({
+        value: index.isEditable(mode, schema) ? text : fontSizePxWidget.substituteVariables(text, value, pageContext),
+        schema,
+        mode: mode === 'form' ? 'viewer' : mode, // if no variables for form it's just a viewer
+        rootElement,
+        onChange: (arg) => {
+            if (!Array.isArray(arg)) {
+                if (onChange) {
+                    onChange({ key: 'text', value: arg.value });
+                }
+            }
+            else {
+                throw new Error('onChange is not an array, the parent text plugin has changed...');
+            }
+        },
+        ...rest,
+    });
+    const textBlock = rootElement.querySelector('#text-' + String(schema.id));
+    if (!textBlock) {
+        throw new Error('Text block not found. Ensure the text block has an id of "text-" + schema.id');
+    }
+    if (mode === 'designer') {
+        textBlock.addEventListener('keyup', (event) => {
+            text = textBlock.textContent || '';
+            if (keyPressShouldBeChecked(event)) {
+                const newNumVariables = countUniqueVariableNames(text);
+                if (numVariables !== newNumVariables) {
+                    if (onChange) {
+                        onChange({ key: 'text', value: text });
+                    }
+                    numVariables = newNumVariables;
+                }
+            }
+        });
+    }
+};
+/** Re-evaluate all expression spans inside a container using current variable values */
+const refreshExpressionSpans = (container, variables, pageCtx) => {
+    container.querySelectorAll('[data-expr]').forEach((span) => {
+        const expr = span.getAttribute('data-expr');
+        span.textContent = fontSizePxWidget.substituteVariables(`{${expr}}`, variables, pageCtx);
+    });
+};
+const formUiRender = async (arg) => {
+    const { value, schema, rootElement, onChange, stopEditing, theme, _cache, options, pageContext } = arg;
+    const rawText = schema.text;
+    if (rootElement.parentElement) {
+        // remove the outline for the whole schema, we'll apply outlines on each individual variable field instead
+        rootElement.parentElement.style.outline = '';
+    }
+    const variables = value
+        ? JSON.parse(value) || {}
+        : {};
+    const substitutedText = fontSizePxWidget.substituteVariables(rawText, variables, pageContext);
+    const font = options?.font || helper.getDefaultFont();
+    const fontKitFont = await index.getFontKitFont(schema.fontName, font, _cache);
+    const textBlock = index.buildStyledTextContainer(arg, fontKitFont, substitutedText);
+    // Tokenize rawText into static text, simple-identifier variables (editable), and
+    // complex expressions (evaluated, static). This supports both {name} and {price * 1.1}.
+    const tokens = tokenizeTemplate(rawText, variables, pageContext);
+    // Find variables that have inline editable spans (standalone {var} tokens)
+    const inlineVarNames = new Set(tokens.filter((t) => t.type === 'simpleVar')
+        .map(t => t.name));
+    // Variables that only appear inside expressions — need separate input fields
+    const expressionOnlyVars = (schema.variables || []).filter(v => !inlineVarNames.has(v));
+    if (expressionOnlyVars.length > 0) {
+        const varSection = document.createElement('div');
+        Object.assign(varSection.style, {
+            width: '100%',
+            padding: '2px 4px',
+            boxSizing: 'border-box',
+            display: 'flex',
+            flexWrap: 'wrap',
+            gap: '4px',
+            marginBottom: '2px',
+        });
+        for (const varName of expressionOnlyVars) {
+            const row = document.createElement('div');
+            Object.assign(row.style, { display: 'flex', alignItems: 'center', gap: '2px' });
+            const label = document.createElement('label');
+            label.textContent = varName + ':';
+            Object.assign(label.style, {
+                fontSize: '9px', whiteSpace: 'nowrap', color: theme.colorText,
+            });
+            const input = document.createElement('input');
+            input.type = 'text';
+            input.value = variables[varName] ?? '';
+            Object.assign(input.style, {
+                width: '60px',
+                fontSize: '9px',
+                border: `1px dashed ${theme.colorPrimary}`,
+                borderRadius: '2px',
+                padding: '1px 3px',
+                outline: 'none',
+            });
+            input.addEventListener('input', (e) => {
+                variables[varName] = e.target.value;
+                if (onChange)
+                    onChange({ key: 'content', value: JSON.stringify(variables) });
+                refreshExpressionSpans(textBlock, variables, pageContext);
+            });
+            row.appendChild(label);
+            row.appendChild(input);
+            varSection.appendChild(row);
+        }
+        rootElement.insertBefore(varSection, textBlock);
+    }
+    for (const token of tokens) {
+        if (token.type === 'text') {
+            const span = document.createElement('span');
+            span.style.letterSpacing = 'inherit';
+            span.textContent = token.text;
+            textBlock.appendChild(span);
+        }
+        else if (token.type === 'simpleVar') {
+            const varName = token.name;
+            const span = document.createElement('span');
+            span.style.outline = `${theme.colorPrimary} dashed 1px`;
+            index.makeElementPlainTextContentEditable(span);
+            span.textContent = variables[varName] ?? '';
+            span.addEventListener('blur', (e) => {
+                const newValue = e.target.textContent || '';
+                if (newValue !== variables[varName]) {
+                    variables[varName] = newValue;
+                    if (onChange)
+                        onChange({ key: 'content', value: JSON.stringify(variables) });
+                    if (stopEditing)
+                        stopEditing();
+                    refreshExpressionSpans(textBlock, variables, pageContext);
+                }
+            });
+            textBlock.appendChild(span);
+        }
+        else {
+            // Complex expression — show evaluated result as static span with data-expr for re-evaluation
+            const span = document.createElement('span');
+            span.style.letterSpacing = 'inherit';
+            span.textContent = token.evaluated;
+            span.setAttribute('data-expr', token.raw);
+            textBlock.appendChild(span);
+        }
+    }
+};
+// Simple identifier regex — matches {name}, {orderId}, etc. but NOT {price * 1.1}
+const SIMPLE_VAR_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+/** Tokenize a template string into static text, simple-identifier vars, and complex expressions. */
+const tokenizeTemplate = (rawText, variables, pageCtx) => {
+    const tokens = [];
+    let i = 0;
+    while (i < rawText.length) {
+        if (rawText[i] !== '{') {
+            const start = i;
+            while (i < rawText.length && rawText[i] !== '{')
+                i++;
+            tokens.push({ type: 'text', text: rawText.slice(start, i) });
+        }
+        else {
+            // Find matching closing brace (handle nested braces)
+            let depth = 1;
+            let j = i + 1;
+            while (j < rawText.length && depth > 0) {
+                if (rawText[j] === '{')
+                    depth++;
+                else if (rawText[j] === '}')
+                    depth--;
+                j++;
+            }
+            const inner = rawText.slice(i + 1, j - 1);
+            if (SIMPLE_VAR_RE.test(inner)) {
+                tokens.push({ type: 'simpleVar', name: inner });
+            }
+            else {
+                // Evaluate the expression using substituteVariables on just this segment
+                const evaluated = fontSizePxWidget.substituteVariables(`{${inner}}`, variables, pageCtx);
+                tokens.push({ type: 'expression', evaluated, raw: inner });
+            }
+            i = j;
+        }
+    }
+    return tokens;
+};
+/** Reserved names — JS globals and expression builtins (must match propPanel's set) */
+const RESERVED_NAMES = new Set([
+    'true', 'false', 'null', 'undefined', 'typeof', 'instanceof', 'in',
+    'void', 'delete', 'new', 'this', 'NaN', 'Infinity',
+    'Math', 'String', 'Number', 'Boolean', 'Array', 'Object', 'Date', 'JSON',
+    'isNaN', 'parseFloat', 'parseInt', 'decodeURI', 'decodeURIComponent',
+    'encodeURI', 'encodeURIComponent', 'date', 'dateTime',
+    'currentPage', 'totalPages',
+]);
+/** Count unique user-defined variable identifiers in all {...} blocks */
+const countUniqueVariableNames = (content) => {
+    const blockRegex = /\{([^{}]+)\}/g;
+    const allIds = new Set();
+    let blockMatch;
+    while ((blockMatch = blockRegex.exec(content)) !== null) {
+        const cleaned = blockMatch[1].replace(/'[^']*'|"[^"]*"|`[^`]*`/g, '');
+        const tokenRegex = /\.?[a-zA-Z_$][a-zA-Z0-9_$]*/g;
+        let m;
+        while ((m = tokenRegex.exec(cleaned)) !== null) {
+            const token = m[0];
+            if (!token.startsWith('.') && !RESERVED_NAMES.has(token)) {
+                allIds.add(token);
+            }
+        }
+    }
+    return allIds.size;
+};
+/**
+ * An optimisation to try to minimise jank while typing.
+ * Only check whether variables were modified based on certain key presses.
+ * Regex would otherwise be performed on every key press (which isn't terrible, but this code helps).
+ */
+const keyPressShouldBeChecked = (event) => {
+    if (event.key === 'ArrowUp' ||
+        event.key === 'ArrowDown' ||
+        event.key === 'ArrowLeft' ||
+        event.key === 'ArrowRight') {
+        return false;
+    }
+    const selection = window.getSelection();
+    const contenteditable = event.target;
+    const isCursorAtEnd = selection?.focusOffset === contenteditable?.textContent?.length;
+    if (isCursorAtEnd) {
+        return event.key === '}' || event.key === 'Backspace' || event.key === 'Delete';
+    }
+    const isCursorAtStart = selection?.anchorOffset === 0;
+    if (isCursorAtStart) {
+        return event.key === '{' || event.key === 'Backspace' || event.key === 'Delete';
+    }
+    return true;
+};
+
+const schema$3 = {
+    pdf: pdfRender$2,
+    ui: uiRender$2,
+    propPanel: propPanel$1,
+    icon: index.createSvgStr(lucide.Type),
+    uninterruptedEditMode: true,
 };
 
 const isValidSVG = (svgString) => {
@@ -224,12 +683,12 @@ const getBarcodeCacheKey = (schema, value) => {
 };
 const pdfRender$1 = async (arg) => {
     const { value, schema, pdfDoc, page, _cache } = arg;
-    if (!index$1.validateBarcodeInput(schema.type, value))
+    if (!fontSizePxWidget.validateBarcodeInput(schema.type, value))
         return;
     const inputBarcodeCacheKey = getBarcodeCacheKey(schema, value);
     let image = _cache.get(inputBarcodeCacheKey);
     if (!image) {
-        const imageBuf = await index$1.createBarCode({
+        const imageBuf = await fontSizePxWidget.createBarCode({
             ...schema,
             type: schema.type,
             input: value,
@@ -243,11 +702,11 @@ const pdfRender$1 = async (arg) => {
 };
 
 const defaultColors = {
-    backgroundColor: index$1.DEFAULT_BARCODE_BG_COLOR,
-    barColor: index$1.DEFAULT_BARCODE_COLOR,
+    backgroundColor: fontSizePxWidget.DEFAULT_BARCODE_BG_COLOR,
+    barColor: fontSizePxWidget.DEFAULT_BARCODE_COLOR,
 };
-const defaultTextColors = { textColor: index$1.DEFAULT_BARCODE_COLOR };
-const defaultIncludetext = { includetext: index$1.DEFAULT_BARCODE_INCLUDETEXT };
+const defaultTextColors = { textColor: fontSizePxWidget.DEFAULT_BARCODE_COLOR };
+const defaultIncludetext = { includetext: fontSizePxWidget.DEFAULT_BARCODE_INCLUDETEXT };
 const position = { x: 0, y: 0 };
 const default40x20 = { width: 40, height: 20 };
 const barcodeDefaults = [
@@ -255,7 +714,7 @@ const barcodeDefaults = [
         defaultSchema: {
             name: '',
             type: 'qrcode',
-            content: 'https://pdfme.com/',
+            content: '',
             position,
             ...defaultColors,
             width: 30,
@@ -485,7 +944,7 @@ const blobToDataURL = (blob) => new Promise((resolve, reject) => {
     reader.readAsDataURL(blob);
 });
 const createBarcodeImage = async (schema, value) => {
-    const imageBuf = await index$1.createBarCode({
+    const imageBuf = await fontSizePxWidget.createBarCode({
         ...schema,
         input: value,
     });
@@ -551,7 +1010,7 @@ const uiRender$1 = async (arg) => {
     if (!value)
         return;
     try {
-        if (!index$1.validateBarcodeInput(schema.type, value))
+        if (!fontSizePxWidget.validateBarcodeInput(schema.type, value))
             throw new Error('[@campxdev/schemas/barcodes] Invalid barcode input');
         const imgElm = await createBarcodeImageElm(schema, value);
         container.appendChild(imgElm);
@@ -562,7 +1021,7 @@ const uiRender$1 = async (arg) => {
     }
 };
 
-const barcodes = index$1.BARCODE_TYPES.reduce((acc, type) => Object.assign(acc, {
+const barcodes = fontSizePxWidget.BARCODE_TYPES.reduce((acc, type) => Object.assign(acc, {
     [type]: {
         pdf: pdfRender$1,
         ui: uiRender$1,
@@ -571,8 +1030,8 @@ const barcodes = index$1.BARCODE_TYPES.reduce((acc, type) => Object.assign(acc,
     },
 }), {});
 
-const rectanglePdfRender = index$1.rectangle.pdf;
-const cellPdfRender = index$1.cellSchema.pdf;
+const rectanglePdfRender = fontSizePxWidget.rectangle.pdf;
+const cellPdfRender = fontSizePxWidget.cellSchema.pdf;
 async function drawCell(arg, cell) {
     await cellPdfRender({
         ...arg,
@@ -686,7 +1145,7 @@ function createButton(options) {
     button.onclick = options.onClick;
     return button;
 }
-const cellUiRender = index$1.cellSchema.ui;
+const cellUiRender = fontSizePxWidget.cellSchema.ui;
 const convertToCellStyle = (styles) => ({
     fontName: styles.fontName,
     alignment: styles.alignment,
@@ -1261,7 +1720,7 @@ const getPlugin = ({ type, icon }) => {
                 justifyContent: index.mapVerticalAlignToFlex(index.VERTICAL_ALIGN_MIDDLE),
             };
             Object.assign(textElement.style, textElementStyle);
-            await textSchema.ui({
+            await index.textSchema.ui({
                 ...arg,
                 rootElement: textElement,
                 mode: 'viewer',
@@ -1372,7 +1831,7 @@ const getPlugin = ({ type, icon }) => {
             if (!value)
                 return void 0;
             const locale = getAirDatepickerLocale(schema.locale || options.lang || defaultLocale);
-            return textSchema.pdf({
+            return index.textSchema.pdf({
                 ...arg,
                 value: getFmtValue(value, type, schema, locale),
                 schema: {
@@ -1609,7 +2068,7 @@ const addOptions = (props) => {
 const schema$2 = {
     ui: async (arg) => {
         const { schema, value, onChange, rootElement, mode } = arg;
-        await textSchema.ui(Object.assign(arg, { mode: 'viewer' }));
+        await index.textSchema.ui(Object.assign(arg, { mode: 'viewer' }));
         if (mode !== 'viewer' && !(mode === 'form' && schema.readOnly)) {
             const buttonWidth = 30;
             const selectButton = document.createElement('button');
@@ -1653,9 +2112,9 @@ const schema$2 = {
             rootElement.appendChild(selectElement);
         }
     },
-    pdf: textSchema.pdf,
+    pdf: index.textSchema.pdf,
     propPanel: {
-        ...textSchema.propPanel,
+        ...index.textSchema.propPanel,
         widgets: { ...index.propPanel.widgets, addOptions },
         schema: (propPanelProps) => {
             if (typeof index.propPanel.schema !== 'function') {
@@ -1677,7 +2136,7 @@ const schema$2 = {
             };
         },
         defaultSchema: {
-            ...textSchema.propPanel.defaultSchema,
+            ...index.textSchema.propPanel.defaultSchema,
             type: 'select',
             content: 'option1',
             options: ['option1', 'option2'],
@@ -1822,23 +2281,26 @@ const schema = {
 
 exports.builtInPlugins = index.builtInPlugins;
 exports.getDynamicHeightsForTable = index.getDynamicHeightsForTable;
-exports.multiVariableText = index.schema;
-exports.dynamicBarcode = index$1.dynamicBarcode;
-exports.dynamicQrCode = index$1.dynamicQrCode;
-exports.dynamicTable = index$1.dynamicTableSchema;
-exports.ellipse = index$1.ellipse;
-exports.image = index$1.imageSchema;
-exports.line = index$1.lineSchema;
-exports.rectangle = index$1.rectangle;
-exports.signature = index$1.signature;
-exports.variableBarcodes = index$1.variableBarcodes;
+exports.richText = index.schema;
+exports.singleVariableText = index.schema$1;
+exports.text = index.textSchema;
+exports.dynamicBarcode = fontSizePxWidget.dynamicBarcode;
+exports.dynamicQrCode = fontSizePxWidget.dynamicQrCode;
+exports.dynamicTable = fontSizePxWidget.dynamicTableSchema;
+exports.ellipse = fontSizePxWidget.ellipse;
+exports.fontSizePxWidget = fontSizePxWidget.fontSizePxWidget;
+exports.image = fontSizePxWidget.imageSchema;
+exports.line = fontSizePxWidget.lineSchema;
+exports.rectangle = fontSizePxWidget.rectangle;
+exports.signature = fontSizePxWidget.signature;
+exports.variableBarcodes = fontSizePxWidget.variableBarcodes;
 exports.barcodes = barcodes;
 exports.checkbox = schema;
 exports.date = date;
 exports.dateTime = dateTime;
+exports.multiVariableText = schema$3;
 exports.radioGroup = schema$1;
 exports.select = schema$2;
 exports.svg = svgSchema;
 exports.table = tableSchema;
-exports.text = textSchema;
 exports.time = time;