@aemforms/af-core 0.22.25 → 0.22.26

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/esm/utils/DataRefParser.d.ts

@@ -0,0 +1,27 @@
+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 = {
+    type: TokenType;
+    value: string | number;
+    start: number;
+};
+export declare const identifier: (value: string, start: number) => {
+    type: string;
+    value: string;
+    start: number;
+};
+export declare const bracket: (value: number, start: number) => {
+    type: string;
+    value: number;
+    start: number;
+};
+export declare const global$: () => {
+    type: string;
+    start: number;
+    value: string;
+};
+export declare const tokenize: (stream: string) => Token[];
+export declare const resolveData: <T extends DataValue>(data: DataGroup, input: Token[] | string, create?: T | undefined) => DataGroup | DataValue | undefined;
+export {};

package/lib/esm/utils/DataRefParser.js

@@ -0,0 +1,222 @@
+import DataGroup from '../data/DataGroup.js';
+const TOK_DOT = 'DOT';
+const TOK_IDENTIFIER = 'Identifier';
+export const TOK_GLOBAL = 'Global';
+const TOK_BRACKET = 'bracket';
+const TOK_NUMBER = 'Number';
+const globalStartToken = '$';
+export const identifier = (value, start) => {
+    return {
+        type: TOK_IDENTIFIER,
+        value,
+        start
+    };
+};
+export const bracket = (value, start) => {
+    return {
+        type: TOK_BRACKET,
+        value,
+        start
+    };
+};
+export const global$ = () => {
+    return {
+        type: TOK_GLOBAL,
+        start: 0,
+        value: globalStartToken
+    };
+};
+const isAlphaNum = function (ch) {
+    return (ch >= 'a' && ch <= 'z')
+        || (ch >= 'A' && ch <= 'Z')
+        || (ch >= '0' && ch <= '9')
+        || ch === '_';
+};
+const isGlobal = (prev, stream, pos) => {
+    return prev === null && stream[pos] === globalStartToken;
+};
+const isIdentifier = (stream, pos) => {
+    const ch = stream[pos];
+    if (ch === '$') {
+        return stream.length > pos && isAlphaNum(stream[pos + 1]);
+    }
+    return (ch >= 'a' && ch <= 'z')
+        || (ch >= 'A' && ch <= 'Z')
+        || ch === '_';
+};
+const isNum = (ch) => {
+    return (ch >= '0' && ch <= '9');
+};
+class Tokenizer {
+    stream;
+    _current;
+    _tokens = [];
+    _result_tokens = [];
+    constructor(stream) {
+        this.stream = stream;
+        this._current = 0;
+    }
+    _consumeGlobal() {
+        this._current += 1;
+        return global$();
+    }
+    _consumeUnquotedIdentifier(stream) {
+        const start = this._current;
+        this._current += 1;
+        while (this._current < stream.length && isAlphaNum(stream[this._current])) {
+            this._current += 1;
+        }
+        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) {
+            let current = this._current;
+            if (stream[current] === '\\' && (stream[current + 1] === '\\'
+                || stream[current + 1] === '"')) {
+                current += 2;
+            }
+            else {
+                current += 1;
+            }
+            this._current = current;
+        }
+        this._current += 1;
+        return identifier(JSON.parse(stream.slice(start, this._current)), start);
+    }
+    _consumeNumber(stream) {
+        const start = this._current;
+        this._current += 1;
+        const maxLength = stream.length;
+        while (isNum(stream[this._current]) && this._current < maxLength) {
+            this._current += 1;
+        }
+        const n = stream.slice(start, this._current);
+        const value = parseInt(n, 10);
+        return { type: TOK_NUMBER, value, start };
+    }
+    _consumeBracket(stream) {
+        const start = this._current;
+        this._current += 1;
+        let value;
+        if (isNum(stream[this._current])) {
+            value = this._consumeNumber(stream).value;
+        }
+        else {
+            throw new Error(`unexpected exception at position ${this._current}. Must be a character`);
+        }
+        if (this._current < this.stream.length && stream[this._current] !== ']') {
+            throw new Error(`unexpected exception at position ${this._current}. Must be a character`);
+        }
+        this._current++;
+        return bracket(value, start);
+    }
+    tokenize() {
+        const stream = this.stream;
+        while (this._current < stream.length) {
+            const prev = this._tokens.length ? this._tokens.slice(-1)[0] : null;
+            if (isGlobal(prev, stream, this._current)) {
+                const token = this._consumeGlobal();
+                this._tokens.push(token);
+                this._result_tokens.push(token);
+            }
+            else if (isIdentifier(stream, this._current)) {
+                const token = this._consumeUnquotedIdentifier(stream);
+                this._tokens.push(token);
+                this._result_tokens.push(token);
+            }
+            else if (stream[this._current] === '.' && prev != null && prev.type !== TOK_DOT) {
+                this._tokens.push({
+                    type: TOK_DOT,
+                    value: '.',
+                    start: this._current
+                });
+                this._current += 1;
+            }
+            else if (stream[this._current] === '[') {
+                const token = this._consumeBracket(stream);
+                this._tokens.push(token);
+                this._result_tokens.push(token);
+            }
+            else if (stream[this._current] === '"') {
+                const token = this._consumeQuotedIdentifier(stream);
+                this._tokens.push(token);
+                this._result_tokens.push(token);
+            }
+            else {
+                const p = Math.max(0, this._current - 2);
+                const s = Math.min(this.stream.length, this._current + 2);
+                throw new Error(`Exception at parsing stream ${this.stream.slice(p, s)}`);
+            }
+        }
+        return this._result_tokens;
+    }
+}
+export const tokenize = (stream) => {
+    return new Tokenizer(stream).tokenize();
+};
+export const resolveData = (data, input, create) => {
+    let tokens;
+    if (typeof input === 'string') {
+        tokens = tokenize(input);
+    }
+    else {
+        tokens = input;
+    }
+    let result = data;
+    let i = 0;
+    const createIntermediateNode = (token, nextToken, create) => {
+        return nextToken === null ? create :
+            (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 === TOK_GLOBAL) {
+            result = data;
+        }
+        else if (token.type === TOK_IDENTIFIER) {
+            if (result instanceof DataGroup && result.$type === 'object') {
+                if (result.$containsDataNode(token.value) && result.$getDataNode(token.value).$value !== null) {
+                    result = result.$getDataNode(token.value);
+                }
+                else if (create) {
+                    const nextToken = i < tokens.length - 1 ? tokens[i + 1] : null;
+                    const toCreate = createIntermediateNode(token, nextToken, create);
+                    result.$addDataNode(token.value, toCreate);
+                    result = toCreate;
+                }
+                else {
+                    result = undefined;
+                }
+            }
+            else {
+                throw new Error(`Looking for ${token.value} in ${result.$value}`);
+            }
+        }
+        else if (token.type === TOK_BRACKET) {
+            if (result instanceof DataGroup && result.$type === 'array') {
+                const index = token.value;
+                if (index < result.$length) {
+                    result = result.$getDataNode(index);
+                }
+                else if (create) {
+                    const nextToken = i < tokens.length - 1 ? tokens[i + 1] : null;
+                    const toCreate = createIntermediateNode(token, nextToken, create);
+                    result.$addDataNode(index, toCreate);
+                    result = toCreate;
+                }
+                else {
+                    result = undefined;
+                }
+            }
+            else {
+                throw new Error(`Looking for index ${token.value} in non array${result.$value}`);
+            }
+        }
+        i += 1;
+    }
+    return result;
+};

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

@@ -0,0 +1,8 @@
+export declare const request: (url: string, data?: any, options?: RequestOptions) => any;
+export declare type RequestOptions = {
+    contentType?: string;
+    method?: 'POST' | 'GET';
+    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;