@aemforms/af-core 0.15.0

package/lib/utils/Fetch.js

@@ -0,0 +1,29 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = void 0;
+const request = (url, data = null, options = {}) => {
+    const opts = Object.assign(Object.assign({}, defaultRequestOptions), options);
+    return fetch(url, Object.assign(Object.assign({}, opts), { body: data })).then((response) => {
+        var _a;
+        if (!response.ok) {
+            throw new Error(response.statusText);
+        }
+        if ((_a = response === null || response === void 0 ? void 0 : response.headers.get('Content-Type')) === null || _a === void 0 ? void 0 : _a.includes('application/json')) {
+            return response.json();
+        }
+        else {
+            return response.text();
+        }
+    });
+};
+exports.request = request;
+const defaultRequestOptions = {
+    method: 'GET'
+};

package/lib/utils/FormUtils.d.ts

@@ -0,0 +1,47 @@
+import { ContainerModel } from '../types';
+/**
+ * Utility to generate a random word from seed
+ * @param l seed value
+ * @returns random word
+ */
+export declare const randomWord: (l: number) => string;
+/**
+ * Utility to check if the value is empty
+ * @param value value
+ * @returns `true` if value is empty, `false` otherwise
+ */
+export declare const isEmpty: (value: any) => boolean;
+/**
+ * @param input
+ * @private
+ */
+export declare const getAttachments: (input: ContainerModel) => any;
+/**
+ * Converts file size in string to bytes based on IEC specification
+ * @param str   file size
+ * @returns file size as bytes (in kb) based on IEC specification
+ */
+export declare const getFileSizeInBytes: (str: any) => number;
+/**
+ * Converts number to bytes based on the symbol as per IEC specification
+ * @param size      size as number
+ * @param symbol    symbol to use (for example, kb, mb, gb or tb)
+ * @returns number as bytes based on the symbol
+ */
+export declare const sizeToBytes: (size: number, symbol: string) => number;
+/**
+ * ID Generator
+ * @param initial
+ * @constructor
+ * @private
+ */
+export declare const IdGenerator: (initial?: number) => Generator<string, void, string>;
+/**
+ * Utility to convert data URI to a `blob` object
+ * @param dataURI uri to convert to blob
+ * @returns `Blob` object for the data URI
+ */
+export declare const dataURItoBlob: (dataURI: string) => {
+    blob: Blob;
+    name: string;
+};

package/lib/utils/FormUtils.js

@@ -0,0 +1,172 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataURItoBlob = exports.IdGenerator = exports.sizeToBytes = exports.getFileSizeInBytes = exports.getAttachments = exports.isEmpty = exports.randomWord = void 0;
+/**
+ * Defines generic utilities to interact with form runtime model
+ */
+const JsonUtils_1 = require("./JsonUtils");
+const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'.split('');
+const fileSizeRegex = /^(\d*\.?\d+)(\\?(?=[KMGT])([KMGT])(?:i?B)?|B?)$/i;
+/**
+ * Utility to generate a random word from seed
+ * @param l seed value
+ * @returns random word
+ */
+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('');
+};
+exports.randomWord = randomWord;
+/**
+ * Utility to check if the value is empty
+ * @param value value
+ * @returns `true` if value is empty, `false` otherwise
+ */
+const isEmpty = (value) => {
+    return value === '' || value === null || value === undefined;
+};
+exports.isEmpty = isEmpty;
+/**
+ * @param input
+ * @private
+ */
+const getAttachments = (input) => {
+    const items = input.items || [];
+    return items === null || items === void 0 ? void 0 : items.reduce((acc, item) => {
+        let ret = null;
+        if (item.isContainer) {
+            ret = (0, exports.getAttachments)(item);
+        }
+        else {
+            if ((0, JsonUtils_1.isFile)(item.getState())) {
+                ret = {}; // @ts-ignore
+                const name = item.name || '';
+                const dataRef = (item.dataRef != null)
+                    ? item.dataRef
+                    : (name.length > 0 ? item.name : undefined);
+                //@ts-ignore
+                if (item.value instanceof Array) {
+                    // @ts-ignore
+                    ret[item.id] = item.value.map((x) => {
+                        return Object.assign(Object.assign({}, x), { 'dataRef': dataRef });
+                    });
+                }
+                else if (item.value != null) {
+                    // @ts-ignore
+                    ret[item.id] = Object.assign(Object.assign({}, item.value), { 'dataRef': dataRef });
+                }
+            }
+        }
+        return Object.assign(acc, ret);
+    }, {});
+};
+exports.getAttachments = getAttachments;
+/**
+ * Converts file size in string to bytes based on IEC specification
+ * @param str   file size
+ * @returns file size as bytes (in kb) based on IEC specification
+ */
+const getFileSizeInBytes = (str) => {
+    let retVal = 0;
+    if (typeof str === 'string') {
+        const matches = fileSizeRegex.exec(str.trim());
+        if (matches != null) {
+            retVal = (0, exports.sizeToBytes)(parseFloat(matches[1]), (matches[2] || 'kb').toUpperCase());
+        }
+    }
+    return retVal;
+};
+exports.getFileSizeInBytes = getFileSizeInBytes;
+/**
+ * Converts number to bytes based on the symbol as per IEC specification
+ * @param size      size as number
+ * @param symbol    symbol to use (for example, kb, mb, gb or tb)
+ * @returns number as bytes based on the symbol
+ */
+const sizeToBytes = (size, symbol) => {
+    const sizes = { 'KB': 1, 'MB': 2, 'GB': 3, 'TB': 4 };
+    // @ts-ignore
+    const i = Math.pow(1024, sizes[symbol]);
+    return Math.round(size * i);
+};
+exports.sizeToBytes = sizeToBytes;
+/**
+ * ID Generator
+ * @param initial
+ * @constructor
+ * @private
+ */
+const IdGenerator = function* (initial = 50) {
+    const initialize = function () {
+        const arr = [];
+        for (let i = 0; i < initial; i++) {
+            arr.push((0, exports.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);
+};
+exports.IdGenerator = IdGenerator;
+/**
+ * Utility to convert data URI to a `blob` object
+ * @param dataURI uri to convert to blob
+ * @returns `Blob` object for the data URI
+ */
+const dataURItoBlob = (dataURI) => {
+    // Split metadata from data
+    const splitted = dataURI.split(',');
+    // Split params
+    const params = splitted[0].split(';');
+    // Get mime-type from params
+    const type = params[0].replace('data:', '');
+    // Filter the name property from params
+    const properties = params.filter(param => {
+        return param.split('=')[0] === 'name';
+    });
+    // Look for the name and use unknown if no name property.
+    let name;
+    if (properties.length !== 1) {
+        name = 'unknown';
+    }
+    else {
+        // Because we filtered out the other property,
+        // we only have the name case here.
+        name = properties[0].split('=')[1];
+    }
+    // Built the Uint8Array Blob parameter from the base64 string.
+    const binary = atob(splitted[1]);
+    const array = [];
+    for (let i = 0; i < binary.length; i++) {
+        array.push(binary.charCodeAt(i));
+    }
+    // Create the blob object
+    const blob = new window.Blob([new Uint8Array(array)], { type });
+    return { blob, name };
+};
+exports.dataURItoBlob = dataURItoBlob;

package/lib/utils/JsonUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Defines generic utilities to interact with form model definition which is represented as json
+ */
+import { FieldsetJson, FieldJson } from '../types';
+/**
+ * Get the property value form the json
+ * @param data      object as json
+ * @param key       name of the key
+ * @param def       default value
+ * @typeParam P     type for the default value
+ */
+export declare const getProperty: <P>(data: any, key: string, def: P) => P;
+/**
+ * Checks if the input item provided is a form file attachment field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form file attachment, `false` otherwise
+ */
+export declare const isFile: (item: FieldsetJson | FieldJson) => boolean;
+/**
+ * Utility to check if the given form field has any data constraints
+ * @param item form field to check
+ * @returns `true` if `item` has data constraints, `false` otherwise
+ */
+export declare const checkIfConstraintsArePresent: (item: FieldsetJson | FieldJson) => boolean;
+/**
+ * Checks if the input item provided is a form check box field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form check box, `false` otherwise
+ */
+export declare const isCheckbox: (item: FieldsetJson | FieldJson) => boolean;
+/**
+ * Checks if the input item provided is a form check box group field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form check box group, `false` otherwise
+ */
+export declare const isCheckboxGroup: (item: FieldsetJson | FieldJson) => boolean;
+/**
+ * Clones an object completely including any nested objects or arrays
+ * @param obj
+ * @private
+ */
+export declare function deepClone(obj: any): any;
+/**
+ * Checks if the key got added in current object
+ * @param currentObj
+ * @param prevObj
+ * @param objKey
+ */
+export declare function checkIfKeyAdded(currentObj: any, prevObj: any, objKey: string): boolean;
+/**
+ * Prettifies obj as json string
+ * @param obj object to prettify
+ * @return json string
+ */
+export declare const jsonString: (obj: any) => string;

package/lib/utils/JsonUtils.js

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonString = exports.checkIfKeyAdded = exports.deepClone = exports.isCheckboxGroup = exports.isCheckbox = exports.checkIfConstraintsArePresent = exports.isFile = exports.getProperty = void 0;
+/**
+ * Defines generic utilities to interact with form model definition which is represented as json
+ */
+const types_1 = require("../types");
+const SchemaUtils_1 = require("./SchemaUtils");
+/**
+ * Get the property value form the json
+ * @param data      object as json
+ * @param key       name of the key
+ * @param def       default value
+ * @typeParam P     type for the default value
+ */
+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;
+};
+exports.getProperty = getProperty;
+/**
+ * Checks if the input item provided is a form file attachment field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form file attachment, `false` otherwise
+ */
+const isFile = function (item) {
+    return ((item === null || item === void 0 ? void 0 : item.type) === 'file' || (item === null || item === void 0 ? void 0 : item.type) === 'file[]') ||
+        (((item === null || item === void 0 ? void 0 : item.type) === 'string' || (item === null || item === void 0 ? void 0 : item.type) === 'string[]') &&
+            ((item === null || item === void 0 ? void 0 : item.format) === 'binary' || (item === null || item === void 0 ? void 0 : item.format) === 'data-url'));
+};
+exports.isFile = isFile;
+/**
+ * Utility to check if the given form field has any data constraints
+ * @param item form field to check
+ * @returns `true` if `item` has data constraints, `false` otherwise
+ */
+const checkIfConstraintsArePresent = function (item) {
+    // @ts-ignore
+    return types_1.constraintProps.some(cp => item[cp] !== undefined);
+};
+exports.checkIfConstraintsArePresent = checkIfConstraintsArePresent;
+/**
+ * Checks if the input item provided is a form check box field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form check box, `false` otherwise
+ */
+const isCheckbox = function (item) {
+    const fieldType = (item === null || item === void 0 ? void 0 : item.fieldType) || (0, SchemaUtils_1.defaultFieldTypes)(item);
+    return fieldType === 'checkbox';
+};
+exports.isCheckbox = isCheckbox;
+/**
+ * Checks if the input item provided is a form check box group field
+ * @param item  input item it could be {@link FieldsetJson | Fieldset} or {@link FieldJson | Field}
+ * @returns `true` if `item` is a form check box group, `false` otherwise
+ */
+const isCheckboxGroup = function (item) {
+    const fieldType = (item === null || item === void 0 ? void 0 : item.fieldType) || (0, SchemaUtils_1.defaultFieldTypes)(item);
+    return fieldType === 'checkbox-group';
+};
+exports.isCheckboxGroup = isCheckboxGroup;
+/**
+ * Clones an object completely including any nested objects or arrays
+ * @param obj
+ * @private
+ */
+function deepClone(obj) {
+    let result;
+    if (obj instanceof Array) {
+        result = [];
+        result = obj.map(x => deepClone(x));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        result = {};
+        Object.entries(obj).forEach(([key, value]) => {
+            result[key] = deepClone(value);
+        });
+    }
+    else {
+        result = obj;
+    }
+    return result;
+}
+exports.deepClone = deepClone;
+/**
+ * Checks if the key got added in current object
+ * @param currentObj
+ * @param prevObj
+ * @param objKey
+ */
+function checkIfKeyAdded(currentObj, prevObj, objKey) {
+    if (currentObj != null && prevObj != null) {
+        // add the new key
+        const newPrvObj = Object.assign({}, prevObj);
+        newPrvObj[objKey] = currentObj[objKey];
+        // do compare using json stringify
+        const newJsonStr = (0, exports.jsonString)(currentObj).replace((0, exports.jsonString)(newPrvObj), '');
+        return newJsonStr === '';
+    }
+    else {
+        return false;
+    }
+}
+exports.checkIfKeyAdded = checkIfKeyAdded;
+/**
+ * Prettifies obj as json string
+ * @param obj object to prettify
+ * @return json string
+ */
+const jsonString = (obj) => {
+    return JSON.stringify(obj, null, 2);
+};
+exports.jsonString = jsonString;

package/lib/utils/LogUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Defines utilities for logging
+ */
+import { callbackFn } from '../types';
+export declare const logFormCallbacks: (callbacks: {
+    [key: string]: callbackFn[];
+}) => void;

package/lib/utils/LogUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFormCallbacks = void 0;
+const logFormCallbacks = (callbacks) => {
+    const s = Object.entries(callbacks).map(([id, fn]) => {
+        return `${id} : ${fn.length}`;
+    }).join(' ');
+    console.log(s);
+};
+exports.logFormCallbacks = logFormCallbacks;

package/lib/utils/SchemaUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Defines generic utilities to convert form model definition to json schema
+ */
+import { FormJson } from '../types';
+/**
+ * Returns the default view type for a given form field object based on `adaptive form specification`
+ * @param schema    schema item for which default view type is to found
+ * @returns default view type
+ */
+export declare const defaultFieldTypes: (schema: any) => string;
+/**
+ * Creates a json schema from form model definition
+ * @param form {@link FormJson | form model definition}
+ * @returns json schema of form model definition
+ */
+export declare const exportDataSchema: (form: FormJson) => any;

package/lib/utils/SchemaUtils.js

@@ -0,0 +1,92 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportDataSchema = exports.defaultFieldTypes = void 0;
+// const primitives = ['string', 'boolean', 'number'];
+// const containers = ['object', 'array', 'number'];
+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'];
+/**
+ * Returns the default view type for a given form field object based on `adaptive form specification`
+ * @param schema    schema item for which default view type is to found
+ * @returns default view type
+ */
+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';
+};
+exports.defaultFieldTypes = defaultFieldTypes;
+const fieldSchema = (input) => {
+    var _a;
+    if ('items' in input) {
+        const fieldset = input;
+        const items = fieldset.items;
+        if (fieldset.type === 'array') {
+            return {
+                type: 'array',
+                items: fieldSchema(items[0]),
+                minItems: fieldset === null || fieldset === void 0 ? void 0 : fieldset.minItems,
+                maxItems: fieldset === null || fieldset === void 0 ? void 0 : 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 Object.assign({ title: (_a = field.label) === null || _a === void 0 ? void 0 : _a.value, description: field.description }, schema);
+    }
+};
+/**
+ * Creates a json schema from form model definition
+ * @param form {@link FormJson | form model definition}
+ * @returns json schema of form model definition
+ */
+const exportDataSchema = (form) => {
+    return fieldSchema(form);
+};
+exports.exportDataSchema = exportDataSchema;

package/lib/utils/TranslationUtils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Defines generic utilities to translated form model definition
+ */
+import { FieldJson, FieldsetJson, FormJson } from '../types';
+/** Token used while creating translation specific properties from `adaptive form specification` */
+export declare const TRANSLATION_TOKEN = "##";
+/** Name of the object which holds all translation specific properties */
+export declare const TRANSLATION_ID = "afs:translationIds";
+export declare const CUSTOM_PROPS_KEY = "properties";
+declare type formElementJson = FieldJson | FieldsetJson | FormJson | any;
+/**
+ * @private
+ */
+export declare const invalidateTranslation: (input: formElementJson, updates: any) => void;
+/**
+ * @private
+ */
+export declare const addTranslationId: (input: formElementJson, additionalTranslationProps?: string[]) => formElementJson;
+/**
+ * @param input
+ * @param additionalTranslationProps
+ * @private
+ */
+export declare const createTranslationObj: (input: formElementJson, additionalTranslationProps?: string[]) => any;
+/**
+ * Creates translation object with [BCP 47](https://tools.ietf.org/search/bcp47) language tags as key and value is a translation object. Key of translation object is
+ * generated based on the form hierarchy and it is separated by "##" token to signify that the id is machine generated (ie its not a human generated string)
+ * @param input             form model definition
+ * @param additionalTranslationProps    optional properties which needs to be translated, by default, only OOTB properties of form model definition is translated
+ * @param bcp47LangTags     optional additional language tags
+ * @returns translation object for each bcp 47 language tag
+ */
+export declare const createTranslationObject: (input: formElementJson, additionalTranslationProps?: string[], bcp47LangTags?: string[]) => any;
+export {};