@aemforms/af-core 0.22.67 → 0.22.69

package/esm/types/src/BaseNode.d.ts

@@ -0,0 +1,99 @@
+import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormCreationMode, FormModel, Primitives, ValidationError } from './types/index';
+import DataGroup from './data/DataGroup';
+import DataValue from './data/DataValue';
+export declare const editableProperties: string[];
+export declare const dynamicProps: string[];
+export declare const staticFields: string[];
+export declare const target: unique symbol;
+export declare const qualifiedName: unique symbol;
+export declare function dependencyTracked(): (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare const include: (...fieldTypes: string[]) => (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare const exclude: (...fieldTypes: string[]) => (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare abstract class BaseNode<T extends BaseJson> implements BaseModel {
+    private _options;
+    private _ruleNode;
+    private _lang?;
+    private _callbacks;
+    private _dependents;
+    protected _jsonModel: T & {
+        id: string;
+    };
+    private _tokens;
+    get isContainer(): boolean;
+    constructor(params: T, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    abstract value: Primitives;
+    abstract reset(): any;
+    protected setupRuleNode(): void;
+    ruleNodeReference(): this;
+    getRuleNode(): any;
+    private getFromRule;
+    get id(): string;
+    get index(): number;
+    get parent(): ContainerModel;
+    get type(): string | undefined;
+    get repeatable(): any;
+    get fieldType(): string;
+    get ':type'(): string;
+    get name(): string | undefined;
+    get description(): string | undefined;
+    set description(d: string | undefined);
+    get dataRef(): string | null | undefined;
+    get visible(): boolean | undefined;
+    set visible(v: boolean | undefined);
+    get form(): FormModel;
+    get ruleEngine(): import("./rules/RuleEngine").default;
+    get label(): import("./types/Json").Label | undefined;
+    set label(l: import("./types/Json").Label | undefined);
+    get uniqueItems(): boolean | undefined;
+    isTransparent(): boolean;
+    getState(forRestore?: boolean): T & {
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
+        properties: {
+            [key: string]: any;
+        };
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        repeatable: boolean | undefined;
+        ':type': string;
+        id: string;
+    };
+    subscribe(callback: callbackFn, eventName?: string): {
+        unsubscribe: () => void;
+    };
+    _addDependent(dependent: BaseModel): void;
+    removeDependent(dependent: BaseModel): void;
+    abstract validate(): Array<ValidationError>;
+    abstract executeAction(action: Action): any;
+    queueEvent(action: Action): void;
+    dispatch(action: Action): void;
+    notifyDependents(action: Action): void;
+    protected isEmpty(value?: any): boolean;
+    _setProperty<T>(prop: string, newValue: T, notify?: boolean, notifyChildren?: (action: Action) => void): any;
+    _bindToDataModel(contextualDataModel: DataGroup): void;
+    private _data?;
+    getDataNode(): DataValue | undefined;
+    get lang(): string | undefined;
+    get properties(): {
+        [key: string]: any;
+    };
+    set properties(p: {
+        [key: string]: any;
+    });
+    abstract defaultDataModel(name: string | number): DataValue | undefined;
+    abstract importData(a: DataGroup): any;
+    getNonTransparentParent(): ContainerModel;
+    _initialize(mode?: FormCreationMode): void;
+    protected _applyUpdates(propNames: string[], updates: any): any;
+    get qualifiedName(): any;
+    focus(): void;
+    protected _getDefaults(): any;
+    protected _applyDefaultsInModel(): void;
+}

package/esm/types/src/Captcha.d.ts

@@ -0,0 +1,5 @@
+import Field from './Field';
+declare class Captcha extends Field {
+    getDataNode(): undefined;
+}
+export default Captcha;

package/esm/types/src/Checkbox.d.ts

@@ -0,0 +1,84 @@
+import Field from './Field';
+declare class Checkbox extends Field {
+    private offValue;
+    _getConstraintObject(): {
+        enum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        accept: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMinimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMaximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        format: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxFileSize: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        pattern: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        required: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        type: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        uniqueItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+    };
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        label: {
+            visible: boolean;
+            richText: boolean;
+        };
+        required: boolean;
+        type: string | undefined;
+    };
+    get enum(): any[];
+}
+export default Checkbox;

package/esm/types/src/CheckboxGroup.d.ts

@@ -0,0 +1,23 @@
+import Field from './Field';
+import { ContainerModel, FieldJson, FormModel } from './types/index';
+declare class CheckboxGroup extends Field {
+    constructor(params: FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    protected _getFallbackType(): string | undefined;
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        enum: never[];
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        label: {
+            visible: boolean;
+            richText: boolean;
+        };
+        required: boolean;
+        type: string | undefined;
+    };
+}
+export default CheckboxGroup;

package/esm/types/src/Container.d.ts

@@ -0,0 +1,75 @@
+import { Action, BaseModel, ContainerJson, ContainerModel, FieldModel, FieldsetModel, FormCreationMode, FormModel, IFormFieldFactory, RulesJson } from './types/index';
+import Scriptable from './Scriptable';
+import DataGroup from './data/DataGroup';
+declare abstract class Container<T extends ContainerJson & RulesJson> extends Scriptable<T> implements ContainerModel {
+    protected _children: Array<FieldModel | FieldsetModel>;
+    protected _childrenReference: any;
+    private _itemTemplate;
+    private fieldFactory;
+    constructor(json: T, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+        fieldFactory: IFormFieldFactory;
+        mode: 'create' | 'restore';
+    });
+    protected _getDefaults(): any;
+    ruleNodeReference(): any;
+    get items(): (FieldModel | FieldsetModel)[];
+    get maxItems(): number;
+    set maxItems(m: number);
+    get minItems(): number;
+    set minItems(m: number);
+    hasDynamicItems(): boolean;
+    get isContainer(): boolean;
+    private _activeChild;
+    private isSiteContainer;
+    private isAFormField;
+    private _getFormAndSitesState;
+    private getItemsState;
+    getState(isRepeatableChild?: boolean, forRestore?: boolean): T & {
+        items: any[];
+        enabled: boolean | undefined;
+        readOnly: any;
+        ':items'?: undefined;
+        ':itemsOrder'?: undefined;
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
+        properties: {
+            [key: string]: any;
+        };
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        repeatable: boolean | undefined;
+        ':type': string;
+        id: string;
+    };
+    private _createChild;
+    private walkSiteContainerItems;
+    private _addChildToRuleNode;
+    private _addChild;
+    indexOf(f: FieldModel | FieldsetModel): number;
+    defaultDataModel(name: string): DataGroup | undefined;
+    _canHaveRepeatingChildren(mode?: FormCreationMode): boolean;
+    _initialize(mode?: FormCreationMode): void;
+    private _initializeSiteContainer;
+    addItem(action: Action): void;
+    removeItem(action: Action): void;
+    queueEvent(action: Action): void;
+    reset(): void;
+    validate(): import("./types/Model").ValidationError[];
+    dispatch(action: Action): void;
+    importData(contextualDataModel: DataGroup): void;
+    syncDataAndFormModel(contextualDataModel?: DataGroup): void;
+    get activeChild(): BaseModel | null;
+    set activeChild(c: BaseModel | null);
+    get enabled(): boolean | undefined;
+    set enabled(e: boolean | undefined);
+    get readOnly(): any;
+    set readOnly(e: any);
+    notifyChildren(action: Action): void;
+}
+export default Container;

package/esm/types/src/DateField.d.ts

@@ -0,0 +1,9 @@
+import Field from './Field';
+declare class DateField extends Field {
+    private locale?;
+    private _dataFormat;
+    protected _applyDefaults(): void;
+    get value(): any;
+    set value(value: any);
+}
+export default DateField;

package/esm/types/src/EmailInput.d.ts

@@ -0,0 +1,16 @@
+import Field from './Field';
+declare class EmailInput extends Field {
+    protected _getDefaults(): {
+        format: string;
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        label: {
+            visible: boolean;
+            richText: boolean;
+        };
+        required: boolean;
+        type: string | undefined;
+    };
+}
+export default EmailInput;

package/esm/types/src/Field.d.ts

@@ -0,0 +1,223 @@
+import { ConstraintsMessages, ContainerModel, FieldJson, FieldModel, FormModel, ValidationError } from './types';
+import Scriptable from './Scriptable';
+import DataValue from './data/DataValue';
+import DataGroup from './data/DataGroup';
+declare class Field extends Scriptable<FieldJson> implements FieldModel {
+    constructor(params: FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    private _ruleNodeReference;
+    _initialize(): any;
+    ruleNodeReference(): any;
+    protected _getDefaults(): {
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        label: {
+            visible: boolean;
+            richText: boolean;
+        };
+        required: boolean;
+        type: string | undefined;
+    };
+    protected _getFallbackType(): string | undefined;
+    protected _applyDefaults(): void;
+    private unset;
+    private coerceParam;
+    get editFormat(): string | undefined;
+    get displayFormat(): string | undefined;
+    get placeholder(): string | undefined;
+    get readOnly(): boolean | undefined;
+    set readOnly(e: boolean | undefined);
+    get enabled(): boolean | undefined;
+    set enabled(e: boolean | undefined);
+    get valid(): any;
+    set valid(e: any);
+    get validity(): any;
+    get emptyValue(): "" | null | undefined;
+    get enum(): any[] | undefined;
+    set enum(e: any[] | undefined);
+    get enumNames(): string[] | import("./types").EnumName[] | undefined;
+    set enumNames(e: string[] | import("./types").EnumName[] | undefined);
+    get required(): boolean;
+    set required(r: boolean);
+    get maximum(): number | undefined;
+    set maximum(m: number | undefined);
+    get minimum(): number | undefined;
+    set minimum(m: number | undefined);
+    private withCategory;
+    get editValue(): any;
+    get displayValue(): any;
+    protected getDataNodeValue(typedValue: any): any;
+    private updateDataNodeAndTypedValue;
+    get value(): any;
+    set value(v: any);
+    reset(): void;
+    protected _updateRuleNodeReference(value: any): void;
+    protected getInternalType(): string | undefined;
+    valueOf(): any;
+    toString(): any;
+    getErrorMessage(constraint: keyof (ConstraintsMessages)): string;
+    get errorMessage(): string | undefined;
+    set errorMessage(e: string | undefined);
+    get screenReaderText(): string | undefined;
+    _getConstraintObject(): {
+        enum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        accept: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMinimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMaximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        format: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxFileSize: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        pattern: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        required: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        type: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        uniqueItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+    };
+    private isArrayType;
+    private checkEnum;
+    private checkStep;
+    private checkValidationExpression;
+    private getConstraints;
+    get format(): string | undefined;
+    get enforceEnum(): boolean | undefined;
+    get tooltip(): string | undefined;
+    get maxLength(): number | undefined;
+    get minLength(): number | undefined;
+    get pattern(): string | undefined;
+    get step(): number | undefined;
+    get exclusiveMinimum(): number | undefined;
+    set exclusiveMinimum(eM: number | undefined);
+    get exclusiveMaximum(): number | undefined;
+    set exclusiveMaximum(eM: number | undefined);
+    get default(): any;
+    private isNotEmpty;
+    protected evaluateConstraints(): any;
+    triggerValidationEvent(changes: any): void;
+    validate(): ValidationError[];
+    importData(contextualDataModel: DataGroup): void;
+    defaultDataModel(name: string | number): DataValue;
+    getState(isRepeatableChild?: boolean, forRestore?: boolean): {
+        editFormat: string | undefined;
+        displayFormat: string | undefined;
+        editValue: any;
+        displayValue: any;
+        enabled: boolean | undefined;
+        readOnly: boolean | undefined;
+        description?: string | undefined;
+        rules?: import("./types").Items<string> | undefined;
+        events?: import("./types").Items<string | string[] | undefined> | undefined;
+        enumNames?: string[] | import("./types").EnumName[] | undefined;
+        enum?: any[] | undefined;
+        accept?: string[] | undefined;
+        enforceEnum?: boolean | undefined;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        format?: string | undefined;
+        maxFileSize?: string | number | undefined;
+        maxLength?: number | undefined;
+        maximum?: number | undefined;
+        maxItems?: number | undefined;
+        minOccur?: number | undefined;
+        maxOccur?: number | undefined;
+        minLength?: number | undefined;
+        minimum?: number | undefined;
+        minItems?: number | undefined;
+        pattern?: string | undefined;
+        required?: boolean | undefined;
+        step?: number | undefined;
+        type?: string | undefined;
+        validationExpression?: string | undefined;
+        uniqueItems?: boolean | undefined;
+        dataRef?: string | null | undefined;
+        lang?: string | undefined;
+        ':type': string;
+        appliedCssClassNames?: string | undefined;
+        label?: import("./types").Label | undefined;
+        visible?: boolean | undefined;
+        name?: string | undefined;
+        constraintMessages?: ConstraintsMessages | undefined;
+        fieldType?: string | undefined;
+        errorMessage?: string | undefined;
+        properties: {
+            [key: string]: any;
+        };
+        repeatable: boolean | undefined;
+        screenReaderText?: string | undefined;
+        tooltip?: string | undefined;
+        altText?: string | undefined;
+        viewType?: string | undefined;
+        placeholder?: string | undefined;
+        valid?: boolean | undefined;
+        validity?: any;
+        validationMessage?: string | undefined;
+        default?: any;
+        value?: any;
+        emptyValue?: "" | "undefined" | "null" | undefined;
+        _dependents?: string[] | undefined;
+        allowedComponents?: undefined;
+        columnClassNames?: undefined;
+        columnCount?: undefined;
+        gridClassNames?: undefined;
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        id: string;
+    };
+    markAsInvalid(message: string, constraint?: keyof (ConstraintsMessages) | null): void;
+}
+export default Field;

package/esm/types/src/Fieldset.d.ts

@@ -0,0 +1,16 @@
+import Container from './Container';
+import { ContainerModel, FieldsetJson, FieldsetModel, FormCreationMode, FormModel, IFormFieldFactory } from './types/index';
+export declare class Fieldset extends Container<FieldsetJson> implements FieldsetModel {
+    constructor(params: FieldsetJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+        fieldFactory: IFormFieldFactory;
+        mode: FormCreationMode;
+    });
+    protected _getDefaults(): any;
+    private _applyDefaults;
+    get type(): "array" | "object" | undefined;
+    get items(): (import("./types/Model").FieldModel | FieldsetModel)[];
+    get value(): null;
+    get fieldType(): string;
+}

package/esm/types/src/FileObject.d.ts

@@ -0,0 +1,16 @@
+import { IFileObject } from './types/index';
+export declare class FileObject implements IFileObject {
+    data: any;
+    mediaType: string;
+    name: string;
+    size: number;
+    constructor(init?: Partial<FileObject>);
+    get type(): string;
+    toJSON(): {
+        name: string;
+        size: number;
+        mediaType: string;
+        data: any;
+    };
+    equals(obj: IFileObject): boolean;
+}

package/esm/types/src/FileUpload.d.ts

@@ -0,0 +1,27 @@
+import Field from './Field';
+import { FieldModel } from './types/index';
+import DataGroup from './data/DataGroup';
+declare class FileUpload extends Field implements FieldModel {
+    protected _getDefaults(): {
+        accept: string[];
+        maxFileSize: string;
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        label: {
+            visible: boolean;
+            richText: boolean;
+        };
+        required: boolean;
+        type: string | undefined;
+    };
+    protected _getFallbackType(): string | undefined;
+    get maxFileSize(): number;
+    get accept(): string[] | undefined;
+    protected _applyUpdates(propNames: string[], updates: any): any;
+    protected getInternalType(): "file" | "file[]";
+    protected getDataNodeValue(typedValue: any): any;
+    private _serialize;
+    importData(dataModel: DataGroup): void;
+}
+export default FileUpload;