@aemforms/af-core 0.22.25 → 0.22.26

package/lib/esm/utils/FormUtils.js

@@ -0,0 +1,187 @@
+import { isFile } from './JsonUtils.js';
+import { FileObject } from '../FileObject.js';
+const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'.split('');
+const fileSizeRegex = /^(\d*\.?\d+)(\\?(?=[KMGT])([KMGT])(?:i?B)?|B?)$/i;
+export const randomWord = (l) => {
+    const ret = [];
+    for (let i = 0; i <= l; i++) {
+        const randIndex = Math.floor(Math.random() * (chars.length));
+        ret.push(chars[randIndex]);
+    }
+    return ret.join('');
+};
+export const isEmpty = (value) => {
+    return value === '' || value === null || value === undefined;
+};
+export const getAttachments = (input) => {
+    const items = input.items || [];
+    return items?.reduce((acc, item) => {
+        let ret = null;
+        if (item.isContainer) {
+            ret = getAttachments(item);
+        }
+        else {
+            if (isFile(item.getState())) {
+                ret = {};
+                const name = item.name || '';
+                const dataRef = (item.dataRef != null)
+                    ? item.dataRef
+                    : (name.length > 0 ? item.name : undefined);
+                if (item.value instanceof Array) {
+                    ret[item.id] = item.value.map((x) => {
+                        return { ...x, 'dataRef': dataRef };
+                    });
+                }
+                else if (item.value != null) {
+                    ret[item.id] = { ...item.value, 'dataRef': dataRef };
+                }
+            }
+        }
+        return Object.assign(acc, ret);
+    }, {});
+};
+export const getFileSizeInBytes = (str) => {
+    let retVal = 0;
+    if (typeof str === 'string') {
+        const matches = fileSizeRegex.exec(str.trim());
+        if (matches != null) {
+            retVal = sizeToBytes(parseFloat(matches[1]), (matches[2] || 'kb').toUpperCase());
+        }
+    }
+    return retVal;
+};
+const sizeToBytes = (size, symbol) => {
+    const sizes = { 'KB': 1, 'MB': 2, 'GB': 3, 'TB': 4 };
+    const i = Math.pow(1024, sizes[symbol]);
+    return Math.round(size * i);
+};
+export const IdGenerator = function* (initial = 50) {
+    const initialize = function () {
+        const arr = [];
+        for (let i = 0; i < initial; i++) {
+            arr.push(randomWord(10));
+        }
+        return arr;
+    };
+    const passedIds = {};
+    let ids = initialize();
+    do {
+        let x = ids.pop();
+        while (x in passedIds) {
+            if (ids.length === 0) {
+                ids = initialize();
+            }
+            x = ids.pop();
+        }
+        passedIds[x] = true;
+        yield ids.pop();
+        if (ids.length === 0) {
+            ids = initialize();
+        }
+    } while (ids.length > 0);
+};
+export const isDataUrl = (str) => {
+    const dataUrlRegex = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+    return dataUrlRegex.exec(str.trim()) != null;
+};
+export const extractFileInfo = (file) => {
+    if (file !== null) {
+        let retVal = null;
+        if (file instanceof FileObject) {
+            retVal = file;
+        }
+        else if (typeof File !== 'undefined' && file instanceof File) {
+            retVal = {
+                name: file.name,
+                mediaType: file.type,
+                size: file.size,
+                data: file
+            };
+        }
+        else if (typeof file === 'string' && isDataUrl(file)) {
+            const result = dataURItoBlob(file);
+            if (result !== null) {
+                const { blob, name } = result;
+                retVal = {
+                    name: name,
+                    mediaType: blob.type,
+                    size: blob.size,
+                    data: blob
+                };
+            }
+        }
+        else {
+            let jFile = file;
+            try {
+                jFile = JSON.parse(file);
+                retVal = jFile;
+                if (!retVal.mediaType) {
+                    retVal.mediaType = retVal.type;
+                }
+            }
+            catch (ex) {
+            }
+            if (typeof jFile?.data === 'string' && isDataUrl(jFile?.data)) {
+                const result = dataURItoBlob(jFile?.data);
+                if (result !== null) {
+                    const blob = result.blob;
+                    retVal = {
+                        name: jFile?.name,
+                        mediaType: jFile?.type || jFile?.mediaType,
+                        size: blob.size,
+                        data: blob
+                    };
+                }
+            }
+            else if (typeof jFile === 'string') {
+                const fileName = jFile.split('/').pop();
+                retVal = {
+                    name: fileName,
+                    mediaType: 'application/octet-stream',
+                    size: 0,
+                    data: jFile
+                };
+            }
+            else if (typeof jFile === 'object') {
+                retVal = {
+                    name: jFile?.name,
+                    mediaType: jFile?.type || jFile?.mediaType,
+                    size: jFile?.size,
+                    data: jFile?.data
+                };
+            }
+        }
+        if (retVal !== null && retVal.data != null) {
+            return new FileObject(retVal);
+        }
+        return null;
+    }
+    else {
+        return null;
+    }
+};
+export const dataURItoBlob = (dataURI) => {
+    const regex = /^data:([a-z]+\/[a-z0-9-+.]+)?(?:;name=([^;]+))?(;base64)?,(.+)$/;
+    const groups = regex.exec(dataURI);
+    if (groups !== null) {
+        const type = groups[1] || '';
+        const name = groups[2] || 'unknown';
+        const isBase64 = typeof groups[3] === 'string';
+        if (isBase64) {
+            const binary = atob(groups[4]);
+            const array = [];
+            for (let i = 0; i < binary.length; i++) {
+                array.push(binary.charCodeAt(i));
+            }
+            const blob = new window.Blob([new Uint8Array(array)], { type });
+            return { name, blob };
+        }
+        else {
+            const blob = new window.Blob([groups[4]], { type });
+            return { name, blob };
+        }
+    }
+    else {
+        return null;
+    }
+};

package/lib/esm/utils/JsonUtils.d.ts

@@ -0,0 +1,11 @@
+import { FieldsetJson, FieldJson } from '../types/index.js';
+export declare const getProperty: <P>(data: any, key: string, def: P) => P;
+export declare const isFile: (item: FieldsetJson | FieldJson) => boolean;
+export declare const checkIfConstraintsArePresent: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckbox: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckboxGroup: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isDateField: (item: FieldsetJson | FieldJson) => boolean;
+export declare function deepClone(obj: any, idGenerator?: () => string): any;
+export declare function checkIfKeyAdded(currentObj: any, prevObj: any, objKey: string): boolean;
+export declare const jsonString: (obj: any) => string;
+export declare const isRepeatable: (obj: FieldsetJson | FieldJson) => boolean;

package/lib/esm/utils/JsonUtils.js

@@ -0,0 +1,76 @@
+import { constraintProps } from '../types/index.js';
+import { defaultFieldTypes } from './SchemaUtils.js';
+export const getProperty = (data, key, def) => {
+    if (key in data) {
+        return data[key];
+    }
+    else if (!key.startsWith(':')) {
+        const prefixedKey = `:${key}`;
+        if (prefixedKey in data) {
+            return data[prefixedKey];
+        }
+    }
+    return def;
+};
+export const isFile = function (item) {
+    return (item?.type === 'file' || item?.type === 'file[]') ||
+        ((item?.type === 'string' || item?.type === 'string[]') &&
+            (item?.format === 'binary' || item?.format === 'data-url'));
+};
+export const checkIfConstraintsArePresent = function (item) {
+    return constraintProps.some(cp => item[cp] !== undefined);
+};
+export const isCheckbox = function (item) {
+    const fieldType = item?.fieldType || defaultFieldTypes(item);
+    return fieldType === 'checkbox';
+};
+export const isCheckboxGroup = function (item) {
+    const fieldType = item?.fieldType || defaultFieldTypes(item);
+    return fieldType === 'checkbox-group';
+};
+export const isDateField = function (item) {
+    const fieldType = item?.fieldType || defaultFieldTypes(item);
+    return (fieldType === 'text-input' && item?.format === 'date') || fieldType === 'date-input';
+};
+export function deepClone(obj, idGenerator) {
+    let result;
+    if (obj instanceof Array) {
+        result = [];
+        result = obj.map(x => deepClone(x, idGenerator));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        result = {};
+        Object.entries(obj).forEach(([key, value]) => {
+            result[key] = deepClone(value, idGenerator);
+        });
+    }
+    else {
+        result = obj;
+    }
+    if (idGenerator && result && result.id) {
+        result.id = idGenerator();
+    }
+    return result;
+}
+export function checkIfKeyAdded(currentObj, prevObj, objKey) {
+    if (currentObj != null && prevObj != null) {
+        const newPrvObj = { ...prevObj };
+        newPrvObj[objKey] = currentObj[objKey];
+        const newJsonStr = jsonString(currentObj).replace(jsonString(newPrvObj), '');
+        return newJsonStr === '';
+    }
+    else {
+        return false;
+    }
+}
+export const jsonString = (obj) => {
+    return JSON.stringify(obj, null, 2);
+};
+export const isRepeatable = (obj) => {
+    return ((obj.repeatable &&
+        ((obj.minOccur === undefined && obj.maxOccur === undefined) ||
+            (obj.minOccur !== undefined && obj.maxOccur !== undefined && obj.maxOccur !== 0) ||
+            (obj.minOccur !== undefined && obj.maxOccur !== undefined && obj.minOccur !== 0 && obj.maxOccur !== 0) ||
+            (obj.minOccur !== undefined && obj.minOccur >= 0) ||
+            (obj.maxOccur !== undefined && obj.maxOccur !== 0))) || false);
+};

package/lib/esm/utils/LogUtils.d.ts

@@ -0,0 +1,4 @@
+import { callbackFn } from '../types/index.js';
+export declare const logFormCallbacks: (callbacks: {
+    [key: string]: callbackFn[];
+}) => void;

package/lib/esm/utils/LogUtils.js

@@ -0,0 +1,6 @@
+export const logFormCallbacks = (callbacks) => {
+    const s = Object.entries(callbacks).map(([id, fn]) => {
+        return `${id} : ${fn.length}`;
+    }).join(' ');
+    console.log(s);
+};

package/lib/esm/utils/SchemaUtils.d.ts

@@ -0,0 +1,3 @@
+import { FormJson } from '../types/index.js';
+export declare const defaultFieldTypes: (schema: any) => string;
+export declare const exportDataSchema: (form: FormJson) => any;

package/lib/esm/utils/SchemaUtils.js

@@ -0,0 +1,71 @@
+const objToMap = (o) => new Map(Object.entries(o));
+const stringViewTypes = objToMap({ 'date': 'date-input', 'data-url': 'file-input', 'binary': 'file-input' });
+const typeToViewTypes = objToMap({
+    'number': 'number-input',
+    'boolean': 'checkbox',
+    'object': 'panel',
+    'array': 'panel',
+    'file': 'file-input',
+    'file[]': 'file-input'
+});
+const arrayTypes = ['string[]', 'boolean[]', 'number[]', 'array'];
+export const defaultFieldTypes = (schema) => {
+    const type = schema.type || 'string';
+    if ('enum' in schema) {
+        const enums = schema.enum;
+        if (enums.length > 2 || arrayTypes.indexOf(type) > -1) {
+            return 'drop-down';
+        }
+        else {
+            return 'checkbox';
+        }
+    }
+    if (type === 'string' || type === 'string[]') {
+        return stringViewTypes.get(schema.format) || 'text-input';
+    }
+    return typeToViewTypes.get(type) || 'text-input';
+};
+const fieldSchema = (input) => {
+    if ('items' in input) {
+        const fieldset = input;
+        const items = fieldset.items;
+        if (fieldset.type === 'array') {
+            return {
+                type: 'array',
+                items: fieldSchema(items[0]),
+                minItems: fieldset?.minItems,
+                maxItems: fieldset?.maxItems
+            };
+        }
+        else {
+            const iter = items.filter(x => x.name != null);
+            return {
+                type: 'object',
+                properties: Object.fromEntries(iter.map(item => [item.name, fieldSchema(item)])),
+                required: iter.filter(x => x.required).map(x => x.name)
+            };
+        }
+    }
+    else {
+        const field = input;
+        const schemaProps = ['type', 'maxLength', 'minLength', 'minimum', 'maximum', 'format', 'pattern', 'step', 'enum'];
+        const schema = schemaProps.reduce((acc, prop) => {
+            const p = prop;
+            if (prop in field && field[p] != undefined) {
+                acc[prop] = field[p];
+            }
+            return acc;
+        }, {});
+        if (field.dataRef === 'none' || Object.keys(schema).length == 0) {
+            return undefined;
+        }
+        return {
+            title: field.label?.value,
+            description: field.description,
+            ...schema
+        };
+    }
+};
+export const exportDataSchema = (form) => {
+    return fieldSchema(form);
+};

package/lib/esm/utils/TranslationUtils.d.ts

@@ -0,0 +1,11 @@
+import { FieldJson, FieldsetJson, FormJson } from '../types/index.js';
+export declare const TRANSLATION_TOKEN = "##";
+export declare const TRANSLATION_ID = "afs:translationIds";
+export declare const CUSTOM_PROPS_KEY = "properties";
+declare type formElementJson = FieldJson | FieldsetJson | FormJson | any;
+export declare const invalidateTranslation: (input: formElementJson, updates: any) => void;
+export declare const addTranslationId: (input: formElementJson, additionalTranslationProps?: string[]) => formElementJson;
+export declare const getOrElse: (input: any, key: string | string[], defaultValue?: any) => any;
+export declare const createTranslationObj: (input: formElementJson, additionalTranslationProps?: string[]) => any;
+export declare const createTranslationObject: (input: formElementJson, additionalTranslationProps?: string[], bcp47LangTags?: string[]) => any;
+export {};

package/lib/esm/utils/TranslationUtils.js

@@ -0,0 +1,115 @@
+import { translationProps } from '../types/index.js';
+export const TRANSLATION_TOKEN = '##';
+export const TRANSLATION_ID = 'afs:translationIds';
+export const CUSTOM_PROPS_KEY = 'properties';
+const defaultBcp47LangTags = [
+    'de-DE',
+    'en-US',
+    'es-ES',
+    'fr-FR',
+    'it-IT',
+    'ja-JP',
+    'ko-KR',
+    'pt-BR',
+    'zh-CN',
+    'zh-TW'
+];
+export const invalidateTranslation = (input, updates) => {
+    translationProps.forEach((prop) => {
+        if (prop in updates && input?.[CUSTOM_PROPS_KEY]?.[TRANSLATION_ID]?.[prop]) {
+            delete input?.[CUSTOM_PROPS_KEY]?.[TRANSLATION_ID]?.[prop];
+        }
+    });
+};
+export const addTranslationId = (input, additionalTranslationProps = []) => {
+    const model = input;
+    const transProps = [...translationProps, ...additionalTranslationProps];
+    _createTranslationId(model, '', transProps);
+    return model;
+};
+const _createTranslationId = (input, path, transProps) => {
+    Object.entries(input).forEach(([key, value]) => {
+        if (typeof value == 'object') {
+            if (input instanceof Array) {
+                if (value && 'name' in value) {
+                    _createTranslationId(value, `${path === '' ? path : path + TRANSLATION_TOKEN}${value.name}`, transProps);
+                }
+            }
+            else {
+                _createTranslationId(value, ((key === 'items') ? path : `${path === '' ? path : path + TRANSLATION_TOKEN}${key}`), transProps);
+            }
+        }
+        else {
+            if (':type' in input ||
+                'type' in input ||
+                'fieldType' in input) {
+                for (const transProp of transProps) {
+                    if (getOrElse(input, transProp) != null) {
+                        if (!(CUSTOM_PROPS_KEY in input)) {
+                            input[CUSTOM_PROPS_KEY] = {};
+                        }
+                        if (!(TRANSLATION_ID in input[CUSTOM_PROPS_KEY])) {
+                            input[CUSTOM_PROPS_KEY][TRANSLATION_ID] = {};
+                        }
+                        if (!(transProp in input[CUSTOM_PROPS_KEY][TRANSLATION_ID])) {
+                            input[CUSTOM_PROPS_KEY][TRANSLATION_ID][transProp] = `${path}${TRANSLATION_TOKEN}${transProp}${TRANSLATION_TOKEN}${Math.floor(Math.random() * 10000) + 1}`;
+                        }
+                    }
+                }
+            }
+        }
+    });
+};
+const _createTranslationObj = (input, translationObj, translationProps) => {
+    Object.values(input).forEach((value) => {
+        if (typeof value == 'object') {
+            _createTranslationObj(value, translationObj, translationProps);
+        }
+        else {
+            for (const translationProp of translationProps) {
+                const objValue = getOrElse(input, translationProp);
+                if (objValue && input?.[CUSTOM_PROPS_KEY]?.[TRANSLATION_ID]?.[translationProp]) {
+                    if (objValue instanceof Array) {
+                        objValue.forEach((item, index) => {
+                            if (typeof item === 'string') {
+                                translationObj[`${input[CUSTOM_PROPS_KEY][TRANSLATION_ID][translationProp]}${TRANSLATION_TOKEN}${index}`] = item;
+                            }
+                        });
+                    }
+                    else {
+                        translationObj[`${input[CUSTOM_PROPS_KEY][TRANSLATION_ID][translationProp]}`] = objValue;
+                    }
+                }
+            }
+        }
+    });
+};
+export const getOrElse = (input, key, defaultValue = null) => {
+    if (!key) {
+        return defaultValue;
+    }
+    const arr = Array.isArray(key) ? key : key.split('.');
+    let objValue = input, index = 0;
+    while (index < arr.length && objValue.hasOwnProperty(arr[index])) {
+        objValue = objValue[arr[index]];
+        index++;
+    }
+    return index == arr.length ? objValue : defaultValue;
+};
+export const createTranslationObj = (input, additionalTranslationProps = []) => {
+    const obj = {};
+    const transProps = [...translationProps, ...additionalTranslationProps];
+    _createTranslationObj(input, obj, transProps);
+    return obj;
+};
+export const createTranslationObject = (input, additionalTranslationProps = [], bcp47LangTags = []) => {
+    const transProps = [...translationProps, ...additionalTranslationProps];
+    const inputCopy = JSON.parse(JSON.stringify(input));
+    const obj = createTranslationObj(addTranslationId(inputCopy, additionalTranslationProps), transProps);
+    const langTags = [...defaultBcp47LangTags, ...bcp47LangTags];
+    const allLangs = {};
+    for (const langTag of langTags) {
+        allLangs[langTag] = JSON.parse(JSON.stringify(obj));
+    }
+    return [inputCopy, allLangs];
+};

package/lib/esm/utils/ValidationUtils.d.ts

@@ -0,0 +1,19 @@
+declare type ValidationResult = {
+    valid: boolean;
+    value: any;
+};
+export declare const coerceType: (param: any, type: 'string' | 'number' | 'boolean') => string | number | boolean;
+declare type ValidConstraintsType = {
+    date: ValidationConstraints[];
+    string: ValidationConstraints[];
+    number: ValidationConstraints[];
+    array: ValidationConstraints[];
+    file: ValidationConstraints[];
+};
+export declare const ValidConstraints: ValidConstraintsType;
+export declare type ValidationConstraints = 'type' | 'format' | 'minimum' | 'maximum' | 'exclusiveMinimum' | 'exclusiveMaximum' | 'minItems' | 'maxItems' | 'uniqueItems' | 'minLength' | 'maxLength' | 'pattern' | 'required' | 'enum' | 'accept' | 'maxFileSize';
+declare type ConstraintsObject = {
+    [key in ValidationConstraints]: (constraint: any, inputVal: any) => ValidationResult;
+};
+export declare const Constraints: ConstraintsObject;
+export {};