@aemforms/af-core 0.22.25 → 0.22.26

package/lib/esm/data/DataValue.js

@@ -0,0 +1,46 @@
+export default class DataValue {
+    $_name;
+    $_value;
+    $_type;
+    $_fields = [];
+    constructor($_name, $_value, $_type = typeof $_value) {
+        this.$_name = $_name;
+        this.$_value = $_value;
+        this.$_type = $_type;
+    }
+    valueOf() {
+        return this.$_value;
+    }
+    get $name() {
+        return this.$_name;
+    }
+    get $value() {
+        const enabled = this.$_fields.find(x => x.enabled !== false);
+        if (!enabled && this.$_fields.length) {
+            return undefined;
+        }
+        return this.$_value;
+    }
+    setValue(typedValue, originalValue, fromField) {
+        this.$_value = typedValue;
+        this.$_fields.forEach(x => {
+            if (fromField !== x) {
+                x.value = originalValue;
+            }
+        });
+    }
+    get $type() {
+        return this.$_type;
+    }
+    $bindToField(field) {
+        if (this.$_fields.indexOf(field) === -1) {
+            this.$_fields.push(field);
+        }
+    }
+    $convertToDataValue() {
+        return this;
+    }
+    get $isDataGroup() {
+        return false;
+    }
+}

package/lib/esm/data/EmptyDataValue.d.ts

@@ -0,0 +1,14 @@
+import DataValue from './DataValue.js';
+declare class NullDataValueClass extends DataValue {
+    constructor();
+    setValue(): void;
+    $bindToField(): void;
+    $length(): number;
+    $convertToDataValue(): DataValue;
+    $addDataNode(): void;
+    $removeDataNode(): void;
+    $getDataNode(): this;
+    $containsDataNode(): boolean;
+}
+declare const NullDataValue: NullDataValueClass;
+export default NullDataValue;

package/lib/esm/data/EmptyDataValue.js

@@ -0,0 +1,29 @@
+import DataValue from './DataValue.js';
+const value = Symbol('NullValue');
+class NullDataValueClass extends DataValue {
+    constructor() {
+        super('', value, 'null');
+    }
+    setValue() {
+    }
+    $bindToField() {
+    }
+    $length() {
+        return 0;
+    }
+    $convertToDataValue() {
+        return this;
+    }
+    $addDataNode() {
+    }
+    $removeDataNode() {
+    }
+    $getDataNode() {
+        return this;
+    }
+    $containsDataNode() {
+        return false;
+    }
+}
+const NullDataValue = new NullDataValueClass();
+export default NullDataValue;

package/lib/esm/index.d.ts

@@ -0,0 +1,21 @@
+export * from './FormInstance.js';
+export * from './types/index.js';
+export * from './controller/Events.js';
+export * from './utils/TranslationUtils.js';
+export * from './utils/JsonUtils.js';
+export * from './utils/SchemaUtils.js';
+import { getFileSizeInBytes, extractFileInfo, isEmpty } from './utils/FormUtils.js';
+import { BaseNode } from './BaseNode.js';
+import Checkbox from './Checkbox.js';
+import CheckboxGroup from './CheckboxGroup.js';
+import Container from './Container.js';
+import Field from './Field.js';
+import { Fieldset } from './Fieldset.js';
+import { FileObject } from './FileObject.js';
+import FileUpload from './FileUpload.js';
+import FormMetaData from './FormMetaData.js';
+import Node from './Node.js';
+import Scriptable from './Scriptable.js';
+import Form from './Form.js';
+import { FunctionRuntime, request } from './rules/FunctionRuntime.js';
+export { Form, BaseNode, Checkbox, CheckboxGroup, Container, Field, Fieldset, FileObject, FileUpload, FormMetaData, Node, Scriptable, getFileSizeInBytes, extractFileInfo, FunctionRuntime, request, isEmpty };

package/lib/esm/index.js

@@ -0,0 +1,21 @@
+export * from './FormInstance.js';
+export * from './types/index.js';
+export * from './controller/Events.js';
+export * from './utils/TranslationUtils.js';
+export * from './utils/JsonUtils.js';
+export * from './utils/SchemaUtils.js';
+import { getFileSizeInBytes, extractFileInfo, isEmpty } from './utils/FormUtils.js';
+import { BaseNode } from './BaseNode.js';
+import Checkbox from './Checkbox.js';
+import CheckboxGroup from './CheckboxGroup.js';
+import Container from './Container.js';
+import Field from './Field.js';
+import { Fieldset } from './Fieldset.js';
+import { FileObject } from './FileObject.js';
+import FileUpload from './FileUpload.js';
+import FormMetaData from './FormMetaData.js';
+import Node from './Node.js';
+import Scriptable from './Scriptable.js';
+import Form from './Form.js';
+import { FunctionRuntime, request } from './rules/FunctionRuntime.js';
+export { Form, BaseNode, Checkbox, CheckboxGroup, Container, Field, Fieldset, FileObject, FileUpload, FormMetaData, Node, Scriptable, getFileSizeInBytes, extractFileInfo, FunctionRuntime, request, isEmpty };

package/lib/esm/rules/FunctionRuntime.d.ts

@@ -0,0 +1,51 @@
+declare type HTTP_VERB = 'GET' | 'POST';
+export declare const request: (context: any, uri: string, httpVerb: HTTP_VERB, payload: any, success: string, error: string, headers: any) => Promise<void>;
+export declare const submit: (context: any, success: string, error: string, submitAs?: 'application/json' | 'multipart/form-data', input_data?: any) => Promise<void>;
+export declare type CustomFunction = Function;
+export declare type FunctionDefinition = {
+    _func: CustomFunction;
+    _signature: Array<any>;
+};
+declare class FunctionRuntimeImpl {
+    private customFunctions;
+    registerFunctions(functions: {
+        [key: string]: FunctionDefinition | CustomFunction;
+    }): void;
+    unregisterFunctions(...names: string[]): void;
+    getFunctions(): {
+        validate: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        setFocus: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => void;
+            _signature: never[];
+        };
+        getData: {
+            _func: (args: unknown, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        exportData: {
+            _func: (args: unknown, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        importData: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        submitForm: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        request: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+        dispatchEvent: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => {};
+            _signature: never[];
+        };
+    };
+}
+export declare const FunctionRuntime: FunctionRuntimeImpl;
+export {};

package/lib/esm/rules/FunctionRuntime.js

@@ -0,0 +1,320 @@
+import { AddInstance, AddItem, Change, Click, CustomEvent, RemoveInstance, RemoveItem, Reset, Submit } from '../controller/Events.js';
+import { request as fRequest } from '../utils/Fetch.js';
+import { FileObject } from '../FileObject.js';
+import { getAttachments } from '../utils/FormUtils.js';
+import { jsonString } from '../utils/JsonUtils.js';
+const getCustomEventName = (name) => {
+    const eName = name;
+    if (eName.length > 0 && eName.startsWith('custom:')) {
+        return eName.substring('custom:'.length);
+    }
+    return eName;
+};
+export const request = async (context, uri, httpVerb, payload, success, error, headers) => {
+    const endpoint = uri;
+    const requestOptions = {
+        method: httpVerb
+    };
+    let result;
+    let inputPayload;
+    try {
+        if (payload && payload instanceof FileObject && payload.data instanceof File) {
+            const formData = new FormData();
+            formData.append(payload.name, payload.data);
+            inputPayload = formData;
+        }
+        else if (payload instanceof FormData) {
+            inputPayload = payload;
+        }
+        else if (payload && typeof payload === 'object' && Object.keys(payload).length > 0) {
+            const headerNames = Object.keys(headers);
+            if (headerNames.length > 0) {
+                requestOptions.headers = {
+                    ...headers,
+                    ...(headerNames.indexOf('Content-Type') === -1 ? { 'Content-Type': 'application/json' } : {})
+                };
+            }
+            else {
+                requestOptions.headers = { 'Content-Type': 'application/json' };
+            }
+            const contentType = requestOptions?.headers?.['Content-Type'] || 'application/json';
+            if (contentType === 'application/json') {
+                inputPayload = JSON.stringify(payload);
+            }
+            else if (contentType.indexOf('multipart/form-data') > -1) {
+                inputPayload = multipartFormData(payload);
+            }
+            else if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
+                inputPayload = urlEncoded(payload);
+            }
+        }
+        result = await fRequest(endpoint, inputPayload, requestOptions);
+    }
+    catch (e) {
+        context.form.logger.error('Error invoking a rest API');
+        const eName = getCustomEventName(error);
+        context.form.dispatch(new CustomEvent(eName, {}, true));
+        return;
+    }
+    const eName = getCustomEventName(success);
+    context.form.dispatch(new CustomEvent(eName, result, true));
+};
+const urlEncoded = (data) => {
+    const formData = new URLSearchParams();
+    Object.entries(data).forEach(([key, value]) => {
+        if (value != null && typeof value === 'object') {
+            formData.append(key, jsonString(value));
+        }
+        else {
+            formData.append(key, value);
+        }
+    });
+    return formData;
+};
+const multipartFormData = (data, attachments) => {
+    const formData = new FormData();
+    Object.entries(data).forEach(([key, value]) => {
+        if (value != null && typeof value === 'object') {
+            formData.append(key, jsonString(value));
+        }
+        else {
+            formData.append(key, value);
+        }
+    });
+    const addAttachmentToFormData = (objValue, formData) => {
+        if (objValue?.data instanceof File) {
+            let attIdentifier = `${objValue?.dataRef}/${objValue?.name}`;
+            if (!attIdentifier.startsWith('/')) {
+                attIdentifier = `/${attIdentifier}`;
+            }
+            formData.append(attIdentifier, objValue.data);
+        }
+    };
+    if (attachments) {
+        Object.keys(attachments).reduce((acc, curr) => {
+            const objValue = attachments[curr];
+            if (objValue && objValue instanceof Array) {
+                return [...acc, ...objValue.map((x) => addAttachmentToFormData(x, formData))];
+            }
+            else {
+                return [...acc, addAttachmentToFormData(objValue, formData)];
+            }
+        }, []);
+    }
+    return formData;
+};
+export const submit = async (context, success, error, submitAs = 'multipart/form-data', input_data = null) => {
+    const endpoint = context.form.action;
+    let data = input_data;
+    if (typeof data != 'object' || data == null) {
+        data = context.form.exportData();
+    }
+    const attachments = getAttachments(context.form);
+    let submitContentType = submitAs;
+    const submitDataAndMetaData = { 'data': data, 'submitMetadata': { 'lang': context.form.lang } };
+    let formData = submitDataAndMetaData;
+    if (Object.keys(attachments).length > 0 || submitAs === 'multipart/form-data') {
+        formData = multipartFormData(submitDataAndMetaData, attachments);
+        submitContentType = 'multipart/form-data';
+    }
+    await request(context, endpoint, 'POST', formData, success, error, {
+        'Content-Type': submitContentType
+    });
+};
+const createAction = (name, payload = {}) => {
+    switch (name) {
+        case 'change':
+            return new Change(payload);
+        case 'submit':
+            return new Submit(payload);
+        case 'click':
+            return new Click(payload);
+        case 'addItem':
+            return new AddItem(payload);
+        case 'removeItem':
+            return new RemoveItem(payload);
+        case 'reset':
+            return new Reset(payload);
+        case 'addInstance':
+            return new AddInstance(payload);
+        case 'removeInstance':
+            return new RemoveInstance(payload);
+        default:
+            console.error('invalid action');
+    }
+};
+class FunctionRuntimeImpl {
+    customFunctions = {};
+    registerFunctions(functions) {
+        Object.entries(functions).forEach(([name, funcDef]) => {
+            let finalFunction = funcDef;
+            if (typeof funcDef === 'function') {
+                finalFunction = {
+                    _func: (args) => {
+                        return funcDef(...args);
+                    },
+                    _signature: []
+                };
+            }
+            if (!finalFunction.hasOwnProperty('_func')) {
+                console.warn(`Unable to register function with name ${name}.`);
+                return;
+            }
+            this.customFunctions[name] = finalFunction;
+        });
+    }
+    unregisterFunctions(...names) {
+        names.forEach(name => {
+            if (name in this.customFunctions) {
+                delete this.customFunctions[name];
+            }
+        });
+    }
+    getFunctions() {
+        function isArray(obj) {
+            if (obj !== null) {
+                return Object.prototype.toString.call(obj) === '[object Array]';
+            }
+            return false;
+        }
+        function valueOf(a) {
+            if (a === null || a === undefined) {
+                return a;
+            }
+            if (isArray(a)) {
+                return a.map(i => valueOf(i));
+            }
+            return a.valueOf();
+        }
+        function toString(a) {
+            if (a === null || a === undefined) {
+                return '';
+            }
+            return a.toString();
+        }
+        const defaultFunctions = {
+            validate: {
+                _func: (args, data, interpreter) => {
+                    const element = args[0];
+                    let validation;
+                    if (typeof element === 'string' || typeof element === 'undefined') {
+                        validation = interpreter.globals.form.validate();
+                    }
+                    else {
+                        validation = interpreter.globals.form.getElement(element.$id).validate();
+                    }
+                    if (Array.isArray(validation) && validation.length) {
+                        interpreter.globals.form.logger.error('Form Validation Error');
+                    }
+                    return validation;
+                },
+                _signature: []
+            },
+            setFocus: {
+                _func: (args, data, interpreter) => {
+                    const element = args[0];
+                    try {
+                        const field = interpreter.globals.form.getElement(element.$id);
+                        interpreter.globals.form.setFocus(field);
+                    }
+                    catch (e) {
+                        interpreter.globals.form.logger.error('Invalid argument passed in setFocus. An element is expected');
+                    }
+                },
+                _signature: []
+            },
+            getData: {
+                _func: (args, data, interpreter) => {
+                    interpreter.globals.form.logger.warn('The `getData` function is depricated. Use `exportData` instead.');
+                    return interpreter.globals.form.exportData();
+                },
+                _signature: []
+            },
+            exportData: {
+                _func: (args, data, interpreter) => {
+                    return interpreter.globals.form.exportData();
+                },
+                _signature: []
+            },
+            importData: {
+                _func: (args, data, interpreter) => {
+                    const inputData = args[0];
+                    if (typeof inputData === 'object' && inputData !== null) {
+                        interpreter.globals.form.importData(inputData);
+                    }
+                    return {};
+                },
+                _signature: []
+            },
+            submitForm: {
+                _func: (args, data, interpreter) => {
+                    const success = toString(args[0]);
+                    const error = toString(args[1]);
+                    const submit_as = args.length > 2 ? toString(args[2]) : 'multipart/form-data';
+                    const submit_data = args.length > 3 ? valueOf(args[3]) : null;
+                    interpreter.globals.form.dispatch(new Submit({
+                        success,
+                        error,
+                        submit_as,
+                        data: submit_data
+                    }));
+                    return {};
+                },
+                _signature: []
+            },
+            request: {
+                _func: (args, data, interpreter) => {
+                    const uri = toString(args[0]);
+                    const httpVerb = toString(args[1]);
+                    const payload = valueOf(args[2]);
+                    let success, error, headers = {};
+                    if (typeof (args[3]) === 'string') {
+                        interpreter.globals.form.logger.warn('This usage of request is deprecated. Please see the documentation and update');
+                        success = valueOf(args[3]);
+                        error = valueOf(args[4]);
+                    }
+                    else {
+                        headers = valueOf(args[3]);
+                        success = valueOf(args[4]);
+                        error = valueOf(args[5]);
+                    }
+                    request(interpreter.globals, uri, httpVerb, payload, success, error, headers);
+                    return {};
+                },
+                _signature: []
+            },
+            dispatchEvent: {
+                _func: (args, data, interpreter) => {
+                    const element = args[0];
+                    let eventName = valueOf(args[1]);
+                    let payload = args.length > 2 ? valueOf(args[2]) : undefined;
+                    let dispatch = false;
+                    if (typeof element === 'string') {
+                        payload = eventName;
+                        eventName = element;
+                        dispatch = true;
+                    }
+                    let event;
+                    if (eventName.startsWith('custom:')) {
+                        event = new CustomEvent(eventName.substring('custom:'.length), payload, dispatch);
+                    }
+                    else {
+                        event = createAction(eventName, payload);
+                    }
+                    if (event != null) {
+                        if (typeof element === 'string') {
+                            interpreter.globals.form.dispatch(event);
+                        }
+                        else {
+                            interpreter.globals.form.getElement(element.$id).dispatch(event);
+                        }
+                    }
+                    return {};
+                },
+                _signature: []
+            }
+        };
+        return { ...defaultFunctions, ...this.customFunctions };
+    }
+}
+export const FunctionRuntime = new FunctionRuntimeImpl();

package/lib/esm/rules/RuleEngine.d.ts

@@ -0,0 +1,12 @@
+import { BaseModel } from '../types/index.js';
+declare class RuleEngine {
+    private _context;
+    private _globalNames;
+    private formulaEngine;
+    private debugInfo;
+    constructor();
+    compileRule(rule: string): any;
+    execute(node: any, data: any, globals: any, useValueOf?: boolean): any;
+    trackDependency(subscriber: BaseModel): void;
+}
+export default RuleEngine;

package/lib/esm/rules/RuleEngine.js

@@ -0,0 +1,47 @@
+import Formula from '@adobe/json-formula';
+import { FunctionRuntime } from './FunctionRuntime.js';
+class RuleEngine {
+    _context;
+    _globalNames = [
+        '$form',
+        '$field',
+        '$event'
+    ];
+    formulaEngine;
+    debugInfo = [];
+    constructor() {
+        const customFunctions = FunctionRuntime.getFunctions();
+        this.formulaEngine = new Formula(customFunctions, undefined, this.debugInfo);
+    }
+    compileRule(rule) {
+        return this.formulaEngine.compile(rule, this._globalNames);
+    }
+    execute(node, data, globals, useValueOf = false) {
+        const oldContext = this._context;
+        this._context = globals;
+        let res = undefined;
+        try {
+            res = this.formulaEngine.run(node, data, 'en-US', globals);
+        }
+        catch (err) {
+            this._context?.form?.logger?.error(err);
+        }
+        while (this.debugInfo.length > 0) {
+            this._context?.form?.logger?.debug(this.debugInfo.pop());
+        }
+        let finalRes = res;
+        if (useValueOf) {
+            if (typeof res === 'object' && res !== null) {
+                finalRes = Object.getPrototypeOf(res).valueOf.call(res);
+            }
+        }
+        this._context = oldContext;
+        return finalRes;
+    }
+    trackDependency(subscriber) {
+        if (this._context && this._context.field !== undefined && this._context.field !== subscriber) {
+            subscriber._addDependent(this._context.field);
+        }
+    }
+}
+export default RuleEngine;

package/lib/esm/types/Json.d.ts

@@ -0,0 +1,119 @@
+export declare type Items<T> = {
+    [key: string]: T;
+};
+export declare type Primitives = string | number | boolean | null | undefined;
+export declare type Label = {
+    value: string;
+    richText?: boolean;
+    visible?: boolean;
+};
+declare type TranslationConstraintsJson = {
+    enumNames?: string[];
+    enum?: any[];
+};
+export declare type ConstraintsJson = TranslationConstraintsJson & {
+    accept?: string[];
+    enforceEnum?: boolean;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    format?: string;
+    maxFileSize?: number | string;
+    maxLength?: number;
+    maximum?: number;
+    maxItems?: number;
+    minOccur?: number;
+    maxOccur?: number;
+    minLength?: number;
+    minimum?: number;
+    minItems?: number;
+    pattern?: string;
+    required?: boolean;
+    step?: number;
+    type?: string;
+    validationExpression?: string;
+    uniqueItems?: boolean;
+};
+export declare type ConstraintsMessages = {
+    accept?: string;
+    enum?: string;
+    exclusiveMinimum?: string;
+    exclusiveMaximum?: string;
+    format?: string;
+    maxFileSize?: string;
+    maxLength?: string;
+    maximum?: string;
+    maxItems?: string;
+    minLength?: string;
+    minimum?: string;
+    minItems?: string;
+    uniqueItems?: string;
+    pattern?: string;
+    required?: string;
+    step?: string;
+    type?: string;
+    validationExpression?: string;
+};
+export declare type RulesJson = {
+    rules?: Items<string>;
+    events?: Items<string[] | string | undefined>;
+};
+declare type TranslationBaseJson = {
+    description?: string;
+};
+export declare type BaseJson = TranslationBaseJson & RulesJson & ConstraintsJson & {
+    dataRef?: string | null;
+    ':type'?: string;
+    label?: Label;
+    enabled?: boolean;
+    visible?: boolean;
+    name?: string;
+    constraintMessages?: ConstraintsMessages;
+    fieldType?: string;
+    errorMessage?: string;
+    properties?: {
+        [key: string]: any;
+    };
+    repeatable?: boolean;
+    screenReaderText?: string;
+    tooltip?: string;
+    altText?: string;
+    viewType?: string;
+};
+declare type TranslationFieldJson = {
+    placeholder?: string;
+};
+export declare type FieldJson = BaseJson & TranslationFieldJson & {
+    readOnly?: boolean;
+    valid?: boolean;
+    default?: any;
+    value?: any;
+    displayFormat?: string;
+    editFormat?: string;
+    editValue?: string;
+    displayValue?: string;
+    emptyValue?: 'null' | 'undefined' | '';
+};
+export declare type ContainerJson = BaseJson & {
+    items: Array<FieldJson | ContainerJson>;
+    initialItems?: number;
+    activeChild?: string;
+};
+export declare type MetaDataJson = {
+    version?: string;
+    grammar?: string;
+};
+export declare type FieldsetJson = ContainerJson & {
+    'type'?: 'array' | 'object';
+};
+export declare type FormJson = ContainerJson & {
+    metadata?: MetaDataJson;
+    data?: any;
+    title?: string;
+    action?: string;
+    adaptiveForm?: string;
+    lang?: string;
+};
+export declare type TranslationJson = TranslationBaseJson & TranslationFieldJson & TranslationConstraintsJson;
+export declare const translationProps: string[];
+export declare const constraintProps: string[];
+export {};