@aemforms/af-core 0.22.18 → 0.22.20

package/lib/esm/types/Json.js

@@ -0,0 +1,7 @@
+export const translationProps = ['description', 'placeholder', 'enum', 'enumNames', 'label.value', 'constraintMessages.accept',
+    'constraintMessages.enum', 'constraintMessages.exclusiveMinimum', 'constraintMessages.exclusiveMaximum', 'constraintMessages.format', 'constraintMessages.maxFileSize', 'constraintMessages.maxLength',
+    'constraintMessages.maximum', 'constraintMessages.maxItems', 'constraintMessages.minLength', 'constraintMessages.minimum', 'constraintMessages.minItems', 'constraintMessages.pattern', 'constraintMessages.required',
+    'constraintMessages.step', 'constraintMessages.type', 'constraintMessages.validationExpression'];
+export const constraintProps = ['accept', 'enum', 'exclusiveMinimum', 'exclusiveMaximum',
+    'format', 'maxFileSize', 'maxLength', 'maximum', 'maxItems',
+    'minLength', 'minimum', 'minItems', 'pattern', 'required', 'step', 'validationExpression', 'enumNames'];

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

@@ -0,0 +1,131 @@
+import { ConstraintsJson, ContainerJson, FieldJson, FieldsetJson, FormJson, Label, MetaDataJson } from './Json.js';
+import RuleEngine from '../rules/RuleEngine.js';
+import EventQueue from '../controller/EventQueue.js';
+import DataGroup from '../data/DataGroup.js';
+import { Logger } from '../controller/Logger.js';
+export interface ScriptableField {
+    rules?: {
+        [key: string]: string;
+    };
+    events?: {
+        [key: string]: string;
+    };
+    ruleEngine: RuleEngine;
+}
+interface WithState<T> {
+    getState: () => any;
+}
+declare type stateProps = {
+    id: string;
+    index: number;
+    ':type': string;
+};
+export declare type State<T> = stateProps & (T extends ContainerJson ? T & {
+    items: Array<State<FieldJson | ContainerJson>>;
+} : T);
+export declare type Subscription = {
+    unsubscribe(): void;
+};
+export interface Action {
+    type: string;
+    payload: any;
+    metadata: any;
+    readonly isCustomEvent: boolean;
+    readonly target: FormModel | FieldModel | FieldsetModel;
+    readonly originalAction?: Action;
+}
+export declare type callbackFn = (action: Action) => void;
+export interface WithController {
+    subscribe(callback: callbackFn, eventName?: string): Subscription;
+    dispatch(action: Action): void;
+}
+export interface BaseModel extends ConstraintsJson, WithController {
+    readonly name?: string;
+    readonly dataRef?: string | null;
+    readonly id: string;
+    readonly index: number;
+    readonly qualifiedName: string;
+    label?: Label;
+    description?: string;
+    readOnly?: boolean;
+    enabled?: boolean;
+    visible?: boolean;
+    placeholder?: string;
+    valid?: boolean;
+    readonly ':type': string;
+    readonly 'fieldType': string;
+    properties: {
+        [key: string]: any;
+    };
+    readonly isContainer: boolean;
+    readonly parent: ContainerModel | null;
+    readonly items?: Array<FieldsetModel | FieldModel>;
+    value: any;
+    readonly default?: any;
+    readonly repeatable?: boolean;
+    readonly language?: string;
+    validate(): Array<ValidationError>;
+    reset(): any;
+    importData(a?: DataGroup): any;
+    getRuleNode(): any;
+    ruleNodeReference(): any;
+    _initialize(): any;
+    _addDependent(dependent: BaseModel): any;
+}
+export interface FieldModel extends BaseModel, ScriptableField, WithState<FieldJson> {
+    parent: ContainerModel;
+    readonly editFormat?: string;
+    readonly displayFormat?: string;
+    readonly displayValue?: string;
+    readonly editValue?: string;
+}
+export interface FormMetaDataModel {
+    readonly version: string;
+    readonly grammar: string;
+}
+export interface ContainerModel extends BaseModel, ScriptableField {
+    items: Array<FieldsetModel | FieldModel>;
+    parent: ContainerModel;
+    indexOf(f: FieldModel | FieldsetModel): number;
+    isTransparent(): boolean;
+    activeChild: BaseModel | null;
+}
+export interface FieldsetModel extends ContainerModel, WithState<FieldsetJson> {
+    type?: 'array' | 'object';
+}
+export interface FormModel extends ContainerModel, WithState<FormJson> {
+    readonly id: string;
+    readonly data?: any;
+    readonly metadata?: MetaDataJson;
+    readonly title: string;
+    readonly logger: Logger;
+    importData(data: any): any;
+    exportData(): any;
+    getElement(id: string): FieldModel | FormModel | FieldsetModel;
+    getUniqueId(): string;
+    getEventQueue(): EventQueue;
+    visit(callBack: (field: FieldModel | FieldsetModel) => void): void;
+    fieldAdded(field: FieldModel | FieldsetModel): void;
+}
+export interface IFormFieldFactory {
+    createField(child: FieldsetJson | FieldJson, options: {
+        form: FormModel;
+        parent: ContainerModel;
+    }): FieldModel | FieldsetModel;
+}
+export interface IFileObject {
+    name: string;
+    mediaType: string;
+    data?: any;
+    size?: number;
+}
+export interface IValidationError {
+    fieldName: string;
+    errorMessages: Array<string>;
+}
+export declare class ValidationError implements IValidationError {
+    fieldName: string;
+    errorMessages: Array<string>;
+    constructor(fieldName?: string, errorMessages?: Array<any>);
+}
+export {};

package/lib/esm/types/Model.js

@@ -0,0 +1,8 @@
+export class ValidationError {
+    fieldName;
+    errorMessages;
+    constructor(fieldName = '', errorMessages = []) {
+        this.errorMessages = errorMessages;
+        this.fieldName = fieldName;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './Json.js';
+export * from './Model.js';

package/lib/esm/types/index.js

@@ -0,0 +1,2 @@
+export * from './Json.js';
+export * from './Model.js';

package/lib/{utils → esm/utils}/DataRefParser.d.ts

@@ -1,8 +1,5 @@
-/**
- * Defines utilities to parse form data
- */
-import DataGroup from '../data/DataGroup';
-import DataValue from '../data/DataValue';
+import DataGroup from '../data/DataGroup.js';
+import DataValue from '../data/DataValue.js';
 declare type TokenType = string;
 export declare const TOK_GLOBAL: TokenType;
 export declare type Token = {

package/lib/{utils → esm/utils}/DataRefParser.js

@@ -1,50 +1,31 @@
-"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 });
-exports.resolveData = exports.tokenize = exports.global$ = exports.bracket = exports.identifier = exports.TOK_GLOBAL = void 0;
-/**
- * Defines utilities to parse form data
- */
-const DataGroup_1 = __importDefault(require("../data/DataGroup"));
+import DataGroup from '../data/DataGroup.js';
 const TOK_DOT = 'DOT';
 const TOK_IDENTIFIER = 'Identifier';
-exports.TOK_GLOBAL = 'Global';
+export const TOK_GLOBAL = 'Global';
 const TOK_BRACKET = 'bracket';
 const TOK_NUMBER = 'Number';
 const globalStartToken = '$';
-const identifier = (value, start) => {
+export const identifier = (value, start) => {
     return {
         type: TOK_IDENTIFIER,
         value,
         start
     };
 };
-exports.identifier = identifier;
-const bracket = (value, start) => {
+export const bracket = (value, start) => {
     return {
         type: TOK_BRACKET,
         value,
         start
     };
 };
-exports.bracket = bracket;
-const global$ = () => {
+export const global$ = () => {
     return {
-        type: exports.TOK_GLOBAL,
+        type: TOK_GLOBAL,
         start: 0,
         value: globalStartToken
     };
 };
-exports.global$ = global$;
 const isAlphaNum = function (ch) {
     return (ch >= 'a' && ch <= 'z')
         || (ch >= 'A' && ch <= 'Z')
@@ -52,16 +33,13 @@ const isAlphaNum = function (ch) {
         || ch === '_';
 };
 const isGlobal = (prev, stream, pos) => {
-    // global tokens occur only at the start of an expression
     return prev === null && stream[pos] === globalStartToken;
 };
 const isIdentifier = (stream, pos) => {
     const ch = stream[pos];
-    // $ is special -- it's allowed to be part of an identifier if it's the first character
     if (ch === '$') {
         return stream.length > pos && isAlphaNum(stream[pos + 1]);
     }
-    // return whether character 'isAlpha'
     return (ch >= 'a' && ch <= 'z')
         || (ch >= 'A' && ch <= 'Z')
         || ch === '_';
@@ -70,15 +48,17 @@ const isNum = (ch) => {
     return (ch >= '0' && ch <= '9');
 };
 class Tokenizer {
+    stream;
+    _current;
+    _tokens = [];
+    _result_tokens = [];
     constructor(stream) {
         this.stream = stream;
-        this._tokens = [];
-        this._result_tokens = [];
         this._current = 0;
     }
     _consumeGlobal() {
         this._current += 1;
-        return (0, exports.global$)();
+        return global$();
     }
     _consumeUnquotedIdentifier(stream) {
         const start = this._current;
@@ -86,14 +66,13 @@ class Tokenizer {
         while (this._current < stream.length && isAlphaNum(stream[this._current])) {
             this._current += 1;
         }
-        return (0, exports.identifier)(stream.slice(start, this._current), start);
+        return identifier(stream.slice(start, this._current), start);
     }
     _consumeQuotedIdentifier(stream) {
         const start = this._current;
         this._current += 1;
         const maxLength = stream.length;
         while (stream[this._current] !== '"' && this._current < maxLength) {
-            // You can escape a double quote and you can escape an escape.
             let current = this._current;
             if (stream[current] === '\\' && (stream[current + 1] === '\\'
                 || stream[current + 1] === '"')) {
@@ -105,7 +84,7 @@ class Tokenizer {
             this._current = current;
         }
         this._current += 1;
-        return (0, exports.identifier)(JSON.parse(stream.slice(start, this._current)), start);
+        return identifier(JSON.parse(stream.slice(start, this._current)), start);
     }
     _consumeNumber(stream) {
         const start = this._current;
@@ -132,7 +111,7 @@ class Tokenizer {
             throw new Error(`unexpected exception at position ${this._current}. Must be a character`);
         }
         this._current++;
-        return (0, exports.bracket)(value, start);
+        return bracket(value, start);
     }
     tokenize() {
         const stream = this.stream;
@@ -157,8 +136,6 @@ class Tokenizer {
                 this._current += 1;
             }
             else if (stream[this._current] === '[') {
-                // No need to increment this._current.  This happens
-                // in _consumeLBracket
                 const token = this._consumeBracket(stream);
                 this._tokens.push(token);
                 this._result_tokens.push(token);
@@ -177,14 +154,13 @@ class Tokenizer {
         return this._result_tokens;
     }
 }
-const tokenize = (stream) => {
+export const tokenize = (stream) => {
     return new Tokenizer(stream).tokenize();
 };
-exports.tokenize = tokenize;
-const resolveData = (data, input, create) => {
+export const resolveData = (data, input, create) => {
     let tokens;
     if (typeof input === 'string') {
-        tokens = (0, exports.tokenize)(input);
+        tokens = tokenize(input);
     }
     else {
         tokens = input;
@@ -193,17 +169,16 @@ const resolveData = (data, input, create) => {
     let i = 0;
     const createIntermediateNode = (token, nextToken, create) => {
         return nextToken === null ? create :
-            (nextToken.type === TOK_BRACKET) ? new DataGroup_1.default(token.value, [], 'array') :
-                new DataGroup_1.default(token.value, {});
+            (nextToken.type === TOK_BRACKET) ? new DataGroup(token.value, [], 'array') :
+                new DataGroup(token.value, {});
     };
     while (i < tokens.length && result != null) {
         const token = tokens[i];
-        if (token.type === exports.TOK_GLOBAL) {
+        if (token.type === TOK_GLOBAL) {
             result = data;
         }
         else if (token.type === TOK_IDENTIFIER) {
-            if (result instanceof DataGroup_1.default && result.$type === 'object') {
-                //@ts-ignore
+            if (result instanceof DataGroup && result.$type === 'object') {
                 if (result.$containsDataNode(token.value) && result.$getDataNode(token.value).$value !== null) {
                     result = result.$getDataNode(token.value);
                 }
@@ -222,10 +197,9 @@ const resolveData = (data, input, create) => {
             }
         }
         else if (token.type === TOK_BRACKET) {
-            if (result instanceof DataGroup_1.default && result.$type === 'array') {
+            if (result instanceof DataGroup && result.$type === 'array') {
                 const index = token.value;
                 if (index < result.$length) {
-                    //@ts-ignore
                     result = result.$getDataNode(index);
                 }
                 else if (create) {
@@ -246,4 +220,3 @@ const resolveData = (data, input, create) => {
     }
     return result;
 };
-exports.resolveData = resolveData;

package/lib/{utils → esm/utils}/Fetch.d.ts

@@ -5,3 +5,4 @@ export declare type RequestOptions = {
     headers?: any;
     mode?: string;
 };
+export declare const convertQueryString: (endpoint: string, payload: string | null) => string;

package/lib/esm/utils/Fetch.js

@@ -0,0 +1,61 @@
+export const request = (url, data = null, options = {}) => {
+    const opts = { ...defaultRequestOptions, ...options };
+    const updatedUrl = opts.method === 'GET' && data ? convertQueryString(url, data) : url;
+    if (opts.method !== 'GET') {
+        opts.body = data;
+    }
+    return fetch(updatedUrl, {
+        ...opts
+    }).then(async (response) => {
+        let body;
+        if (!response.ok) {
+            console.error(`Error fetching response from ${url} : ${response.statusText}`);
+            body = response.statusText;
+        }
+        else {
+            if (response?.headers?.get('Content-Type')?.includes('application/json')) {
+                body = await response.json();
+            }
+            else {
+                body = await response.text();
+            }
+        }
+        const headers = {};
+        response?.headers?.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            status: response.status,
+            body,
+            headers
+        };
+    });
+};
+const defaultRequestOptions = {
+    method: 'GET'
+};
+export const convertQueryString = (endpoint, payload) => {
+    if (!payload) {
+        return endpoint;
+    }
+    let updatedPayload = {};
+    try {
+        updatedPayload = JSON.parse(payload);
+    }
+    catch (err) {
+        console.log('Query params invalid');
+    }
+    const params = [];
+    Object.keys(updatedPayload).forEach((key) => {
+        if (Array.isArray(updatedPayload[key])) {
+            params.push(`${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(updatedPayload[key]))}`);
+        }
+        else {
+            params.push(`${encodeURIComponent(key)}=${encodeURIComponent(updatedPayload[key])}`);
+        }
+    });
+    if (!params.length) {
+        return endpoint;
+    }
+    return endpoint.includes('?') ? `${endpoint}&${params.join('&')}` : `${endpoint}?${params.join('&')}`;
+};

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

@@ -0,0 +1,9 @@
+import { ContainerModel, FieldJson, FieldModel, FieldsetJson, FieldsetModel, FormModel, IFormFieldFactory } from '../types/index.js';
+declare class FormFieldFactoryImpl implements IFormFieldFactory {
+    createField(child: FieldsetJson | FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    }): FieldModel | FieldsetModel;
+}
+export declare const FormFieldFactory: FormFieldFactoryImpl;
+export {};

package/lib/esm/utils/FormCreationUtils.js

@@ -0,0 +1,74 @@
+import { InstanceManager } from '../InstanceManager.js';
+import { Fieldset } from '../Fieldset.js';
+import { isCheckbox, isCheckboxGroup, isDateField, isFile, isRepeatable } from './JsonUtils.js';
+import FileUpload from '../FileUpload.js';
+import Checkbox from '../Checkbox.js';
+import CheckboxGroup from '../CheckboxGroup.js';
+import DateField from '../DateField.js';
+import Field from '../Field.js';
+const alternateFieldTypeMapping = {
+    'text': 'text-input',
+    'number': 'number-input',
+    'email': 'text-input',
+    'file': 'file-input',
+    'range': 'range',
+    'textarea': 'multiline-input'
+};
+class FormFieldFactoryImpl {
+    createField(child, _options) {
+        let retVal;
+        const options = {
+            ..._options,
+            fieldFactory: this
+        };
+        child.fieldType = child.fieldType ? (child.fieldType in alternateFieldTypeMapping ?
+            alternateFieldTypeMapping[child.fieldType] : child.fieldType)
+            : 'text-input';
+        if (isRepeatable(child)) {
+            const newChild = {
+                ...child,
+                ...('items' in child && { 'type': 'object' }),
+                minOccur: undefined,
+                maxOccur: undefined,
+                repeatable: undefined,
+                name: undefined
+            };
+            const newJson = {
+                ...{
+                    minItems: child.minOccur || 0,
+                    maxItems: child.maxOccur || -1,
+                    fieldType: child.fieldType,
+                    type: 'array',
+                    name: child.name,
+                    dataRef: child.dataRef
+                },
+                ...{
+                    'items': [newChild]
+                }
+            };
+            retVal = new InstanceManager(newJson, options);
+        }
+        else if ('items' in child) {
+            retVal = new Fieldset(child, options);
+        }
+        else {
+            if (isFile(child) || child.fieldType === 'file-input') {
+                retVal = new FileUpload(child, options);
+            }
+            else if (isCheckbox(child)) {
+                retVal = new Checkbox(child, options);
+            }
+            else if (isCheckboxGroup(child)) {
+                retVal = new CheckboxGroup(child, options);
+            }
+            else if (isDateField(child)) {
+                retVal = new DateField(child, options);
+            }
+            else {
+                retVal = new Field(child, options);
+            }
+        }
+        return retVal;
+    }
+}
+export const FormFieldFactory = new FormFieldFactoryImpl();

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

@@ -0,0 +1,12 @@
+import { ContainerModel } from '../types/index.js';
+export declare const randomWord: (l: number) => string;
+export declare const isEmpty: (value: any) => boolean;
+export declare const getAttachments: (input: ContainerModel) => any;
+export declare const getFileSizeInBytes: (str: any) => number;
+export declare const IdGenerator: (initial?: number) => Generator<string, void, string>;
+export declare const isDataUrl: (str: string) => boolean;
+export declare const extractFileInfo: (file: any) => any;
+export declare const dataURItoBlob: (dataURI: string) => {
+    name: string;
+    blob: Blob;
+} | null;