@aemforms/af-core 0.15.0

package/lib/index.js

@@ -0,0 +1,59 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileSizeInBytes = exports.Scriptable = exports.Node = exports.FormMetaData = exports.FileUpload = exports.FileObject = exports.Fieldset = exports.Field = exports.Container = exports.CheckboxGroup = exports.Checkbox = exports.BaseNode = exports.Form = void 0;
+__exportStar(require("./FormInstance"), exports);
+__exportStar(require("./types/index"), exports);
+__exportStar(require("./controller/index"), exports);
+__exportStar(require("./utils/TranslationUtils"), exports);
+__exportStar(require("./utils/JsonUtils"), exports);
+__exportStar(require("./utils/SchemaUtils"), exports);
+const FormUtils_1 = require("./utils/FormUtils");
+Object.defineProperty(exports, "getFileSizeInBytes", { enumerable: true, get: function () { return FormUtils_1.getFileSizeInBytes; } });
+const BaseNode_1 = require("./BaseNode");
+Object.defineProperty(exports, "BaseNode", { enumerable: true, get: function () { return BaseNode_1.BaseNode; } });
+const Checkbox_1 = __importDefault(require("./Checkbox"));
+exports.Checkbox = Checkbox_1.default;
+const CheckboxGroup_1 = __importDefault(require("./CheckboxGroup"));
+exports.CheckboxGroup = CheckboxGroup_1.default;
+const Container_1 = __importDefault(require("./Container"));
+exports.Container = Container_1.default;
+const Field_1 = __importDefault(require("./Field"));
+exports.Field = Field_1.default;
+const Fieldset_1 = require("./Fieldset");
+Object.defineProperty(exports, "Fieldset", { enumerable: true, get: function () { return Fieldset_1.Fieldset; } });
+const FileObject_1 = require("./FileObject");
+Object.defineProperty(exports, "FileObject", { enumerable: true, get: function () { return FileObject_1.FileObject; } });
+const FileUpload_1 = __importDefault(require("./FileUpload"));
+exports.FileUpload = FileUpload_1.default;
+const FormMetaData_1 = __importDefault(require("./FormMetaData"));
+exports.FormMetaData = FormMetaData_1.default;
+const Node_1 = __importDefault(require("./Node"));
+exports.Node = Node_1.default;
+const Scriptable_1 = __importDefault(require("./Scriptable"));
+exports.Scriptable = Scriptable_1.default;
+const Form_1 = __importDefault(require("./Form"));
+exports.Form = Form_1.default;

package/lib/rules/FunctionRuntime.d.ts

@@ -0,0 +1,44 @@
+declare type HTTP_VERB = 'GET' | 'POST';
+/**
+ * Implementation of generic request API. This API can be used to make external web request
+ * @param context                   expression execution context(consists of current form, current field, current event)
+ * @param uri                       request URI
+ * @param httpVerb                  http verb (for example, GET or POST)
+ * @param payload                   request payload
+ * @param success                   success handler
+ * @param error                     error handler
+ * @param payloadContentType        content type of the request
+ * @private
+ */
+export declare const request: (context: any, uri: string, httpVerb: HTTP_VERB, payload: any, success: string, error: string, payloadContentType?: string) => Promise<void>;
+export declare const submit: (context: any, success: string, error: string, submitAs?: 'json' | 'multipart', input_data?: any) => Promise<void>;
+/**
+ * Implementation of function runtime
+ * @private
+ */
+declare class FunctionRuntimeImpl {
+    getFunctions(): {
+        validate: {
+            _func: (args: Array<unknown>, data: unknown, interpreter: any) => any;
+            _signature: never[];
+        };
+        getData: {
+            _func: (args: unknown, data: unknown, interpreter: any) => 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[];
+        };
+    };
+}
+declare const FunctionRuntime: FunctionRuntimeImpl;
+export default FunctionRuntime;

package/lib/rules/FunctionRuntime.js

@@ -0,0 +1,271 @@
+"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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submit = exports.request = void 0;
+/**
+ * Implementation of function runtime in rule engine
+ */
+const JsonUtils_1 = require("../utils/JsonUtils");
+const Controller_1 = require("../controller/Controller");
+const Fetch_1 = require("../utils/Fetch");
+const FileObject_1 = require("../FileObject");
+const FormUtils_1 = require("../utils/FormUtils");
+/**
+ * Implementation of generic request API. This API can be used to make external web request
+ * @param context                   expression execution context(consists of current form, current field, current event)
+ * @param uri                       request URI
+ * @param httpVerb                  http verb (for example, GET or POST)
+ * @param payload                   request payload
+ * @param success                   success handler
+ * @param error                     error handler
+ * @param payloadContentType        content type of the request
+ * @private
+ */
+const request = (context, uri, httpVerb, payload, success, error, payloadContentType = 'application/json') => __awaiter(void 0, void 0, void 0, function* () {
+    const endpoint = uri;
+    const requestOptions = {
+        method: httpVerb
+    };
+    let result;
+    let inputPayload;
+    try {
+        if (payload && payload instanceof FileObject_1.FileObject && payload.data instanceof File) {
+            // todo: have to implement array type
+            const formData = new FormData();
+            formData.append(payload.name, payload.data);
+            inputPayload = formData;
+        }
+        else if (payload && typeof payload === 'object' && Object.keys(payload).length > 0) {
+            if (payloadContentType.length > 0) {
+                requestOptions.headers = {
+                    'Content-Type': payloadContentType // this should match content type of the payload
+                };
+            }
+            inputPayload = JSON.stringify(payload);
+        }
+        result = yield (0, Fetch_1.request)(endpoint, inputPayload, requestOptions);
+    }
+    catch (e) {
+        //todo: define error payload
+        context.form.logger.error('Error invoking a rest API');
+        context.form.dispatch(new Controller_1.CustomEvent(error, {}, true));
+        return;
+    }
+    context.form.dispatch(new Controller_1.CustomEvent(success, result, true));
+});
+exports.request = request;
+/**
+ * Create multi part form data using form data and form attachments
+ * @param data              form data
+ * @param attachments       form events
+ * @private
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const multipartFormData = (data, attachments) => {
+    const formData = new FormData();
+    formData.append(':data', data);
+    formData.append(':contentType', 'application/json');
+    const transformAttachment = (objValue, formData) => {
+        const newValue = {
+            ':name': objValue.name,
+            ':contentType': objValue.mediaType,
+            ':data': objValue.data,
+            ':bindRef': objValue.dataRef
+        };
+        if ((objValue === null || objValue === void 0 ? void 0 : objValue.data) instanceof File) {
+            let attIdentifier = `${objValue === null || objValue === void 0 ? void 0 : objValue.dataRef}/${objValue === null || objValue === void 0 ? void 0 : objValue.name}`;
+            if (!attIdentifier.startsWith('/')) {
+                attIdentifier = `/${attIdentifier}`;
+            }
+            formData.append(attIdentifier, objValue.data);
+            newValue[':data'] = `#${attIdentifier}`;
+        }
+        return newValue;
+    };
+    // @ts-ignore
+    const submitAttachments = Object.keys(attachments).reduce((acc, curr) => {
+        const objValue = attachments[curr];
+        if (objValue && objValue instanceof Array) {
+            return [...acc, ...objValue.map((x) => transformAttachment(x, formData))];
+        }
+        else {
+            return [...acc, transformAttachment(objValue, formData)];
+        }
+    }, []);
+    if ((submitAttachments === null || submitAttachments === void 0 ? void 0 : submitAttachments.length) > 0) {
+        formData.append(':attachments', (0, JsonUtils_1.jsonString)(submitAttachments));
+    }
+    return formData;
+};
+const submit = (context, success, error, submitAs = 'json', input_data = null) => __awaiter(void 0, void 0, void 0, function* () {
+    const endpoint = context.form.action;
+    let data = input_data;
+    if (typeof data != 'object' || data == null) {
+        data = context.form.exportData();
+    }
+    // todo: have to implement sending of attachments here
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const attachments = (0, FormUtils_1.getAttachments)(context.$form);
+    let submitContentType = submitAs;
+    //let formData: any;
+    //if (Object.keys(attachments).length > 0) {
+    //    multipartFormData(jsonString(data), attachments);
+    //    submitContentType = 'multipart/form-data';
+    //} else {
+    const formData = { 'data': data };
+    submitContentType = 'application/json';
+    //}
+    // note: don't send multipart/form-data let browser decide on the content type
+    yield (0, exports.request)(context, endpoint, 'POST', formData, success, error, submitContentType);
+});
+exports.submit = submit;
+/**
+ * Helper function to create an action
+ * @param name          name of the event
+ * @param payload       event payload
+ * @param dispatch      true to trigger the event on all the fields in DFS order starting from the top level form element, false otherwise
+ * @private
+ */
+const createAction = (name, payload = {}) => {
+    switch (name) {
+        case 'change':
+            return new Controller_1.Change(payload);
+        case 'submit':
+            return new Controller_1.Submit(payload);
+        case 'click':
+            return new Controller_1.Click(payload);
+        case 'addItem':
+            return new Controller_1.AddItem(payload);
+        case 'removeItem':
+            return new Controller_1.RemoveItem(payload);
+        default:
+            console.error('invalid action');
+    }
+};
+/**
+ * Implementation of function runtime
+ * @private
+ */
+class FunctionRuntimeImpl {
+    getFunctions() {
+        // todo: remove these once json-formula exposes a way to call them from custom functions
+        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();
+        }
+        return {
+            validate: {
+                _func: (args, data, interpreter) => {
+                    const element = args[0];
+                    if (typeof element === 'string' || typeof element === 'undefined') {
+                        return interpreter.globals.form.validate();
+                    }
+                    else {
+                        return interpreter.globals.form.getElement(element.$id).validate();
+                    }
+                },
+                _signature: []
+            },
+            getData: {
+                _func: (args, data, interpreter) => {
+                    return interpreter.globals.form.exportData();
+                },
+                _signature: []
+            },
+            submitForm: {
+                _func: (args, data, interpreter) => {
+                    // success: string, error: string, submit_as: 'json' | 'multipart' = 'json', data: any = null
+                    const success = toString(args[0]);
+                    const error = toString(args[1]);
+                    const submit_as = args.length > 2 ? toString(args[2]) : 'json';
+                    const submit_data = args.length > 3 ? valueOf(args[3]) : null;
+                    interpreter.globals.form.dispatch(new Controller_1.Submit({
+                        success,
+                        error,
+                        submit_as,
+                        data: submit_data
+                    }));
+                    return {};
+                },
+                _signature: []
+            },
+            // todo: only supports application/json for now
+            request: {
+                _func: (args, data, interpreter) => {
+                    const uri = toString(args[0]);
+                    const httpVerb = toString(args[1]);
+                    const payload = valueOf(args[2]);
+                    const success = valueOf(args[3]);
+                    const error = valueOf(args[4]);
+                    (0, exports.request)(interpreter.globals, uri, httpVerb, payload, success, error, 'application/json');
+                    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 Controller_1.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: []
+            }
+        };
+    }
+}
+const FunctionRuntime = new FunctionRuntimeImpl();
+exports.default = FunctionRuntime;

package/lib/rules/RuleEngine.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Implementation of rule engine
+ * @module
+ * @private
+ */
+import { BaseModel } from '../types';
+import { Formula } from '@adobe/json-formula';
+/**
+ * Implementation of rule engine
+ * @private
+ */
+declare class RuleEngine {
+    private _context;
+    private _globalNames;
+    compileRule(rule: string): Formula;
+    execute(node: any, data: any, globals: any, useValueOf?: boolean): any;
+    /**
+     * Listen to subscriber for
+     * @param subscriber
+     */
+    trackDependency(subscriber: BaseModel): void;
+}
+export default RuleEngine;

package/lib/rules/RuleEngine.js

@@ -0,0 +1,67 @@
+"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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Controller_1 = require("../controller/Controller");
+const json_formula_1 = require("@adobe/json-formula");
+const FunctionRuntime_1 = __importDefault(require("./FunctionRuntime"));
+/**
+ * Implementation of AddDependant event
+ * @private
+ */
+class AddDependent extends Controller_1.ActionImpl {
+    constructor(payload) {
+        super(payload, 'addDependent');
+    }
+    payloadToJson() {
+        return this.payload.getState();
+    }
+}
+/**
+ * Implementation of rule engine
+ * @private
+ */
+class RuleEngine {
+    constructor() {
+        this._globalNames = [
+            '$form',
+            '$field',
+            '$event'
+        ];
+    }
+    compileRule(rule) {
+        const customFunctions = FunctionRuntime_1.default.getFunctions();
+        return new json_formula_1.Formula(rule, customFunctions, undefined, this._globalNames);
+    }
+    execute(node, data, globals, useValueOf = false) {
+        const oldContext = this._context;
+        this._context = globals;
+        const res = node.search(data, globals);
+        let finalRes = res;
+        if (useValueOf) {
+            if (typeof res === 'object' && res !== null) {
+                finalRes = Object.getPrototypeOf(res).valueOf.call(res);
+            }
+        }
+        this._context = oldContext;
+        return finalRes;
+    }
+    /**
+     * Listen to subscriber for
+     * @param subscriber
+     */
+    trackDependency(subscriber) {
+        if (this._context && this._context.field !== undefined && this._context.field !== subscriber) {
+            subscriber.dispatch(new AddDependent(this._context.field));
+        }
+    }
+}
+exports.default = RuleEngine;

package/lib/types/Json.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Defines generic types based on `adaptive form specification`
+ */
+/** Type for `items property` based on `adaptive form specification` */
+export declare type Items<T> = {
+    [key: string]: T;
+};
+/** Type alias for primitive types */
+export declare type Primitives = string | number | boolean | null | undefined;
+/** Type for `label` based on `adaptive form specification` */
+export declare type Label = {
+    value: string;
+    richText?: boolean;
+    visible?: boolean;
+};
+/** Type for `constraint properties` which can be translated based on `adaptive form specification` */
+declare type TranslationConstraintsJson = {
+    enumNames?: string[];
+    enum?: any[];
+};
+/** Type for `constraint properties` based on `adaptive form specification` */
+export declare type ConstraintsJson = TranslationConstraintsJson & {
+    accept?: string[];
+    enforceEnum?: boolean;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    format?: string;
+    maxFileSize?: number | string;
+    maxLength?: number;
+    maximum?: number;
+    maxItems?: number;
+    minLength?: number;
+    minimum?: number;
+    minItems?: number;
+    pattern?: string;
+    required?: boolean;
+    step?: number;
+    type?: string;
+    validationExpression?: string;
+};
+/** Type for `constraint messages` based on `adaptive form specification` */
+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;
+    pattern?: string;
+    required?: string;
+    step?: string;
+    type?: string;
+    validationExpression?: string;
+};
+/** Type for `constraint messages` based on `adaptive form specification` */
+export declare type RulesJson = {
+    rules?: Items<string>;
+    events?: Items<string[] | string | undefined>;
+};
+/** Type for `generic form properties` which can be translated based on `adaptive form specification` */
+declare type TranslationBaseJson = {
+    description?: string;
+};
+/** Type for `generic form properties` based on `adaptive form specification` */
+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;
+    };
+};
+/** Type for `form field properties`which can be translated based on `adaptive form specification` */
+declare type TranslationFieldJson = {
+    placeholder?: string;
+};
+/** Type for `form field properties` based on `adaptive form specification` */
+export declare type FieldJson = BaseJson & TranslationFieldJson & {
+    readOnly?: boolean;
+    valid?: boolean;
+    default?: any;
+    value?: any;
+    emptyValue?: 'null' | 'undefined' | '';
+};
+/** Type for `form container properties` based on `adaptive form specification` */
+export declare type ContainerJson = BaseJson & {
+    items: Array<FieldJson | ContainerJson>;
+    initialItems?: number;
+};
+/** Type for `form metadata` based on `adaptive form specification` */
+export declare type MetaDataJson = {
+    version?: string;
+    grammar?: string;
+    locale?: string;
+};
+/** Type for `form fieldset` based on `adaptive form specification` */
+export declare type FieldsetJson = ContainerJson & {
+    'type'?: 'array' | 'object';
+};
+/** Type for `form model` based on `adaptive form specification` */
+export declare type FormJson = ContainerJson & {
+    metadata?: MetaDataJson;
+    data?: any;
+    title?: string;
+    action?: string;
+    adaptiveForm?: string;
+};
+/** Type for all properties which can be translated based on `adaptive form specification` */
+export declare type TranslationJson = TranslationBaseJson & TranslationFieldJson & TranslationConstraintsJson;
+/** Constant for all properties which can be translated based on `adaptive form specification` */
+export declare const translationProps: string[];
+/** Constant for all properties which are constraints based on `adaptive form specification` */
+export declare const constraintProps: string[];
+export {};

package/lib/types/Json.js

@@ -0,0 +1,16 @@
+"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.constraintProps = exports.translationProps = void 0;
+/** Constant for all properties which can be translated based on `adaptive form specification` */
+exports.translationProps = ['description', 'placeholder', 'enum', 'enumNames'];
+/** Constant for all properties which are constraints based on `adaptive form specification` */
+exports.constraintProps = ['accept', 'enum', 'exclusiveMinimum', 'exclusiveMaximum',
+    'format', 'maxFileSize', 'maxLength', 'maximum', 'maxItems',
+    'minLength', 'minimum', 'minItems', 'pattern', 'required', 'step', 'validationExpression', 'enumNames'];