@aemforms/af-core 0.22.68 → 0.22.70

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

@@ -0,0 +1,141 @@
+import { ConstraintsJson, ContainerJson, FieldJson, FieldsetJson, FormJson, Label, MetaDataJson } from './Json';
+import RuleEngine from '../rules/RuleEngine';
+import EventQueue from '../controller/EventQueue';
+import DataGroup from '../data/DataGroup';
+import { Logger } from '../controller/Logger';
+export interface ScriptableField {
+    rules?: {
+        [key: string]: string;
+    };
+    events?: {
+        [key: string]: string;
+    };
+    ruleEngine: RuleEngine;
+}
+interface WithState<T> {
+    getState: () => any;
+}
+type stateProps = {
+    id: string;
+    index: number;
+    ':type': string;
+};
+export type State<T> = stateProps & (T extends ContainerJson ? T & {
+    items: Array<State<FieldJson | ContainerJson>>;
+} : T);
+export 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 type callbackFn = (action: Action) => void;
+export interface WithController {
+    subscribe(callback: callbackFn, eventName?: string): Subscription;
+    dispatch(action: Action): void;
+}
+export type FormCreationMode = 'create' | 'restore';
+export interface BaseModel extends ConstraintsJson, WithController {
+    readonly lang?: string;
+    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;
+    validate(): Array<ValidationError>;
+    reset(): any;
+    importData(a?: DataGroup): any;
+    getRuleNode(): any;
+    ruleNodeReference(): any;
+    _initialize(mode?: FormCreationMode): 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 SubmitMetaDataModel {
+    lang: string;
+    captchaInfo: Record<string, any>;
+}
+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;
+    resolveQualifiedName(qualifiedName: string): FieldModel | FieldsetModel | null;
+    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 declare enum FocusOption {
+    NEXT_ITEM = "nextItem",
+    PREVIOUS_ITEM = "previousItem"
+}
+export {};

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

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

package/esm/types/src/utils/CoercionUtils.d.ts

@@ -0,0 +1 @@
+export declare function stringToNumber(str: string, language: string): number;

package/esm/types/src/utils/DataRefParser.d.ts

@@ -0,0 +1,33 @@
+import DataGroup from '../data/DataGroup';
+import DataValue from '../data/DataValue';
+type TokenType = string;
+export declare const TOK_GLOBAL: TokenType;
+export declare const TOK_REPEATABLE: TokenType;
+export 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 repeatable: () => {
+    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/esm/types/src/utils/Fetch.d.ts

@@ -0,0 +1,8 @@
+export declare const request: (url: string, data?: any, options?: RequestOptions) => any;
+export type RequestOptions = {
+    contentType?: string;
+    method?: 'POST' | 'GET';
+    headers?: any;
+    mode?: string;
+};
+export declare const convertQueryString: (endpoint: string, payload: string | null) => string;

package/esm/types/src/utils/FormCreationUtils.d.ts

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

package/esm/types/src/utils/FormUtils.d.ts

@@ -0,0 +1,14 @@
+import { ContainerModel } from '../types/index';
+export declare const randomWord: (l: number) => string;
+export declare const isEmpty: (value: any) => boolean;
+export declare const getAttachments: (input: ContainerModel, excludeUnbound?: boolean) => 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;
+export declare const sitesModelToFormModel: (sitesModel: any) => any;
+export declare const replaceTemplatePlaceholders: (str: string, values?: any[]) => string;

package/esm/types/src/utils/JsonUtils.d.ts

@@ -0,0 +1,13 @@
+import { FieldsetJson, FieldJson } from '../types/index';
+export declare const getProperty: <P>(data: any, key: string, def: P) => P;
+export declare const isFile: (item: FieldsetJson | FieldJson) => boolean;
+export declare const checkIfConstraintsArePresent: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckbox: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCheckboxGroup: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isEmailInput: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isDateField: (item: FieldsetJson | FieldJson) => boolean;
+export declare const isCaptcha: (item: FieldsetJson | FieldJson) => boolean;
+export declare function deepClone(obj: any, idGenerator?: () => string): any;
+export declare function checkIfKeyAdded(currentObj: any, prevObj: any, objKey: string): boolean;
+export declare const jsonString: (obj: any) => string;
+export declare const isRepeatable: (obj: FieldsetJson | FieldJson) => boolean;

package/esm/types/src/utils/LogUtils.d.ts

@@ -0,0 +1,4 @@
+import { callbackFn } from '../types/index';
+export declare const logFormCallbacks: (callbacks: {
+    [key: string]: callbackFn[];
+}) => void;

package/esm/types/src/utils/SchemaUtils.d.ts

@@ -0,0 +1,3 @@
+import { FormJson } from '../types/index';
+export declare const defaultFieldTypes: (schema: any) => string;
+export declare const exportDataSchema: (form: FormJson) => any;

package/esm/types/src/utils/TranslationUtils.d.ts

@@ -0,0 +1,11 @@
+import { FieldJson, FieldsetJson, FormJson } from '../types/index';
+export declare const TRANSLATION_TOKEN = "##";
+export declare const TRANSLATION_ID = "afs:translationIds";
+export declare const CUSTOM_PROPS_KEY = "properties";
+type formElementJson = FieldJson | FieldsetJson | FormJson | any;
+export declare const invalidateTranslation: (input: formElementJson, updates: any) => void;
+export declare const addTranslationId: (input: formElementJson, additionalTranslationProps?: string[]) => formElementJson;
+export declare const getOrElse: (input: any, key: string | string[], defaultValue?: any) => any;
+export declare const createTranslationObj: (input: formElementJson, additionalTranslationProps?: string[]) => any;
+export declare const createTranslationObject: (input: formElementJson, additionalTranslationProps?: string[], bcp47LangTags?: string[]) => any;
+export {};

package/esm/types/src/utils/ValidationUtils.d.ts

@@ -0,0 +1,20 @@
+type ValidationResult = {
+    valid: boolean;
+    value: any;
+};
+export declare const coerceType: (param: any, type: 'string' | 'number' | 'boolean') => string | number | boolean;
+type ValidConstraintsType = {
+    date: ValidationConstraints[];
+    string: ValidationConstraints[];
+    number: ValidationConstraints[];
+    array: ValidationConstraints[];
+    file: ValidationConstraints[];
+    email: ValidationConstraints[];
+};
+export declare const ValidConstraints: ValidConstraintsType;
+export type ValidationConstraints = 'type' | 'format' | 'minimum' | 'maximum' | 'exclusiveMinimum' | 'exclusiveMaximum' | 'minItems' | 'maxItems' | 'uniqueItems' | 'minLength' | 'maxLength' | 'pattern' | 'required' | 'enum' | 'accept' | 'maxFileSize';
+type ConstraintsObject = {
+    [key in ValidationConstraints]: (constraint: any, inputVal: any) => ValidationResult;
+};
+export declare const Constraints: ConstraintsObject;
+export {};

package/lib/BaseNode.d.ts

@@ -1,4 +1,4 @@
-import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormModel, Primitives, ValidationError } from './types/index';
+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[];
@@ -23,6 +23,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     constructor(params: T, _options: {
         form: FormModel;
         parent: ContainerModel;
+        mode?: 'create' | 'restore';
     });
     abstract value: Primitives;
     abstract reset(): any;
@@ -49,15 +50,18 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     set label(l: import("./types/Json").Label | undefined);
     get uniqueItems(): boolean | undefined;
     isTransparent(): boolean;
-    getState(isRepeatableChild?: boolean): T & {
+    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;
-        events: {};
-        rules: {};
         repeatable: boolean | undefined;
         ':type': string;
         id: string;
@@ -87,7 +91,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     abstract defaultDataModel(name: string | number): DataValue | undefined;
     abstract importData(a: DataGroup): any;
     getNonTransparentParent(): ContainerModel;
-    _initialize(): void;
+    _initialize(mode?: FormCreationMode): void;
     protected _applyUpdates(propNames: string[], updates: any): any;
     get qualifiedName(): any;
     focus(): void;

package/lib/BaseNode.js

@@ -238,8 +238,14 @@ class BaseNode {
         const isNonTransparent = ((_a = this.parent) === null || _a === void 0 ? void 0 : _a._jsonModel.type) === 'array';
         return !this._jsonModel.name && !isNonTransparent;
     }
-    getState(isRepeatableChild = false) {
-        return Object.assign(Object.assign({}, this._jsonModel), { properties: this.properties, index: this.index, parent: undefined, qualifiedName: this.qualifiedName, events: {}, rules: {}, repeatable: this.repeatable === true ? true : undefined, ':type': this[':type'] });
+    getState(forRestore = false) {
+        return Object.assign(Object.assign(Object.assign({}, this._jsonModel), { properties: this.properties, index: this.index, parent: undefined, qualifiedName: this.qualifiedName, repeatable: this.repeatable === true ? true : undefined, ':type': this[':type'] }), (forRestore ? {
+            _dependents: this._dependents.length ? this._dependents.map(x => x.node.id) : undefined,
+            allowedComponents: undefined,
+            columnClassNames: undefined,
+            columnCount: undefined,
+            gridClassNames: undefined
+        } : {}));
     }
     subscribe(callback, eventName = 'change') {
         this._callbacks[eventName] = this._callbacks[eventName] || [];
@@ -281,6 +287,16 @@ class BaseNode {
         this.form.getEventQueue().runPendingQueue();
     }
     notifyDependents(action) {
+        const depsToRestore = this._jsonModel._dependents;
+        if (depsToRestore) {
+            depsToRestore.forEach((x) => {
+                const node = this.form.getElement(x);
+                if (node) {
+                    this._addDependent(node);
+                }
+            });
+            this._jsonModel._dependents = undefined;
+        }
         const handlers = this._callbacks[action.type] || [];
         handlers.forEach(x => {
             x(new ActionImplWithTarget(action, this));
@@ -403,7 +419,7 @@ class BaseNode {
         }
         return nonTransparentParent;
     }
-    _initialize() {
+    _initialize(mode) {
         if (typeof this._data === 'undefined') {
             let dataNode, parent = this.parent;
             do {

package/lib/CheckboxGroup.d.ts

@@ -1,9 +1,10 @@
 import Field from './Field';
-import { ContainerModel, FieldJson, FormModel } from './types/index';
+import { ContainerModel, FieldJson, FormCreationMode, FormModel } from './types/index';
 declare class CheckboxGroup extends Field {
     constructor(params: FieldJson, _options: {
         form: FormModel;
         parent: ContainerModel;
+        mode: FormCreationMode;
     });
     protected _getFallbackType(): string | undefined;
     protected _getDefaults(): {

package/lib/Container.d.ts

@@ -1,4 +1,4 @@
-import { Action, BaseModel, ContainerJson, ContainerModel, FieldModel, FieldsetModel, FormModel, IFormFieldFactory, RulesJson } from './types/index';
+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 {
@@ -10,6 +10,7 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
         form: FormModel;
         parent: ContainerModel;
         fieldFactory: IFormFieldFactory;
+        mode?: 'create' | 'restore';
     });
     protected _getDefaults(): any;
     ruleNodeReference(): any;
@@ -25,18 +26,23 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     private isAFormField;
     private _getFormAndSitesState;
     private getItemsState;
-    getState(isRepeatableChild?: boolean): T & {
+    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;
-        events: {};
-        rules: {};
         repeatable: boolean | undefined;
         ':type': string;
         id: string;
@@ -47,7 +53,8 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     private _addChild;
     indexOf(f: FieldModel | FieldsetModel): number;
     defaultDataModel(name: string): DataGroup | undefined;
-    _initialize(): void;
+    _canHaveRepeatingChildren(mode?: FormCreationMode): boolean;
+    _initialize(mode?: FormCreationMode): void;
     private _initializeSiteContainer;
     addItem(action: Action): void;
     removeItem(action: Action): void;

package/lib/Container.js

@@ -19,7 +19,7 @@ const notifyChildrenAttributes = [
 ];
 class Container extends Scriptable_1.default {
     constructor(json, _options) {
-        super(json, { form: _options.form, parent: _options.parent });
+        super(json, { form: _options.form, parent: _options.parent, mode: _options.mode });
         this._children = [];
         this._itemTemplate = null;
         this._activeChild = null;
@@ -79,44 +79,43 @@ class Container extends Scriptable_1.default {
     isAFormField(item) {
         return ('fieldType' in item || 'id' in item || 'name' in item || 'dataRef' in item || 'type' in item);
     }
-    _getFormAndSitesState(isRepeatableChild = false) {
+    _getFormAndSitesState(isRepeatableChild = false, forRestore = false) {
         return this._jsonModel.items ? this._jsonModel.items.map((x) => {
             if (this.isSiteContainer(x)) {
                 const newObjWithId = Object.assign({}, ((x === null || x === void 0 ? void 0 : x.id) ? { id: this.form.getUniqueId() } : {}));
                 return Object.assign(Object.assign(Object.assign({}, x), newObjWithId), { ':items': this.walkSiteContainerItems(x) });
             }
             else if (this.isAFormField(x)) {
-                return Object.assign({}, this.form.getElement(x === null || x === void 0 ? void 0 : x.id).getState(isRepeatableChild));
+                return Object.assign({}, this.form.getElement(x === null || x === void 0 ? void 0 : x.id).getState(isRepeatableChild, forRestore));
             }
             else {
                 return x;
             }
         }) : [];
     }
-    getItemsState(isRepeatableChild = false) {
+    getItemsState(isRepeatableChild = false, forRestore = false) {
         if (this._jsonModel.type === 'array' || (0, JsonUtils_1.isRepeatable)(this._jsonModel) || isRepeatableChild) {
             if (isRepeatableChild) {
-                return this._getFormAndSitesState(isRepeatableChild);
+                return this._getFormAndSitesState(isRepeatableChild, forRestore);
             }
             else {
                 return this._children.map(x => {
-                    return Object.assign({}, x.getState(true));
+                    return Object.assign({}, x.getState(true, forRestore));
                 });
             }
         }
         else {
-            return this._getFormAndSitesState(isRepeatableChild);
+            return this._getFormAndSitesState(isRepeatableChild, forRestore);
         }
     }
-    getState(isRepeatableChild = false) {
-        return Object.assign(Object.assign({}, super.getState(isRepeatableChild)), { items: this.getItemsState(isRepeatableChild), enabled: this.enabled, readOnly: this.readOnly });
+    getState(isRepeatableChild = false, forRestore = false) {
+        return Object.assign(Object.assign(Object.assign({}, super.getState(forRestore)), (forRestore ? {
+            ':items': undefined,
+            ':itemsOrder': undefined
+        } : {})), { items: this.getItemsState(isRepeatableChild, forRestore), enabled: this.enabled, readOnly: this.readOnly });
     }
     _createChild(child, options) {
-        const { parent = this } = options;
-        return this.fieldFactory.createField(child, {
-            form: options.form,
-            parent
-        });
+        return this.fieldFactory.createField(child, options);
     }
     walkSiteContainerItems(x) {
         return Object.fromEntries(Object.entries(x[':items']).map(([key, value]) => {
@@ -128,7 +127,7 @@ class Container extends Scriptable_1.default {
             }
             else {
                 if (typeof value === 'object') {
-                    const newObjWithId = Object.assign({}, ((value === null || value === void 0 ? void 0 : value.id) ? { 'id': this.form.getUniqueId() } : {}));
+                    const newObjWithId = Object.assign({}, ((value === null || value === void 0 ? void 0 : value.id) ? { id: this.form.getUniqueId() } : {}));
                     return [key, Object.assign(Object.assign({}, value), newObjWithId)];
                 }
                 else {
@@ -162,7 +161,7 @@ class Container extends Scriptable_1.default {
             });
         }
     }
-    _addChild(itemJson, index, cloneIds = false) {
+    _addChild(itemJson, index, cloneIds = false, mode = 'create') {
         let nonTransparentParent = this;
         while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
             nonTransparentParent = nonTransparentParent.parent;
@@ -172,7 +171,7 @@ class Container extends Scriptable_1.default {
         }
         const form = this.form;
         const itemTemplate = Object.assign({ index }, (0, JsonUtils_1.deepClone)(itemJson, cloneIds ? () => { return form.getUniqueId(); } : undefined));
-        const retVal = this._createChild(itemTemplate, { parent: this, form: this.form });
+        const retVal = this._createChild(itemTemplate, { parent: this, form: this.form, mode });
         itemJson.id = retVal.id;
         this.form.fieldAdded(retVal);
         this._addChildToRuleNode(retVal, { parent: nonTransparentParent });
@@ -197,12 +196,20 @@ class Container extends Scriptable_1.default {
             return new DataGroup_1.default(name, instance, type);
         }
     }
-    _initialize() {
-        super._initialize();
+    _canHaveRepeatingChildren(mode = 'create') {
+        const items = this._jsonModel.items;
+        return this._jsonModel.type == 'array' && this.getDataNode() != null &&
+            (items.length === 1 || (items[0].repeatable == true && mode === 'restore'));
+    }
+    _initialize(mode) {
+        super._initialize(mode);
         const items = this._jsonModel.items || [];
         this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
-        if (this._jsonModel.type == 'array' && items.length === 1 && this.getDataNode() != null) {
+        if (this._canHaveRepeatingChildren(mode)) {
             this._itemTemplate = (0, JsonUtils_1.deepClone)(items[0]);
+            if (mode === 'restore') {
+                this._itemTemplate.repeatable = undefined;
+            }
             if (typeof (this._jsonModel.minItems) !== 'number') {
                 this._jsonModel.minItems = 0;
             }
@@ -213,9 +220,22 @@ class Container extends Scriptable_1.default {
                 this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
             }
             for (let i = 0; i < this._jsonModel.initialItems; i++) {
-                const child = this._addChild(this._itemTemplate, null, i > 0);
-                items[0].id = child.id;
-                child._initialize();
+                let child;
+                if (mode === 'restore') {
+                    let itemTemplate = this._itemTemplate;
+                    if (i < this._jsonModel.items.length) {
+                        itemTemplate = (0, JsonUtils_1.deepClone)(items[i]);
+                        itemTemplate.repeatable = undefined;
+                    }
+                    child = this._addChild(itemTemplate, undefined, i > this._jsonModel.items.length - 1, mode);
+                }
+                else {
+                    child = this._addChild(this._itemTemplate, undefined, i > this._jsonModel.items.length - 1);
+                }
+                if (mode === 'create') {
+                    items[0].id = child.id;
+                }
+                child._initialize(mode);
             }
         }
         else if (items.length > 0) {
@@ -224,11 +244,11 @@ class Container extends Scriptable_1.default {
                     this._initializeSiteContainer(item);
                 }
                 else if (this.isAFormField(item)) {
-                    const child = this._addChild(item);
-                    child._initialize();
+                    const child = this._addChild(item, undefined, false, mode);
+                    child._initialize(mode);
                 }
                 else {
-                    this.form.logger.warn('A container item was not initialized.');
+                    this.form.logger.warn(`A container item was not initialized. ${item}`);
                 }
             });
             this._jsonModel.minItems = this._children.length;
@@ -264,7 +284,7 @@ class Container extends Scriptable_1.default {
                 if (_data) {
                     dataNode.$addDataNode(instanceIndex, _data);
                 }
-                retVal._initialize();
+                retVal._initialize('create');
                 this.notifyDependents((0, Events_1.propertyChange)('items', retVal.getState(), null));
                 retVal.dispatch(new Events_1.Initialize());
                 retVal.dispatch(new Events_1.ExecuteRule());
@@ -341,7 +361,7 @@ class Container extends Scriptable_1.default {
             while (items2Add > 0) {
                 items2Add--;
                 const child = this._addChild(this._itemTemplate);
-                child._initialize();
+                child._initialize('create');
             }
             if (items2Remove > 0) {
                 this._children.splice(dataLength, items2Remove);

package/lib/Field.d.ts

@@ -6,6 +6,7 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
     constructor(params: FieldJson, _options: {
         form: FormModel;
         parent: ContainerModel;
+        mode?: 'create' | 'restore';
     });
     private _ruleNodeReference;
     _initialize(): any;
@@ -151,7 +152,7 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
     validate(): ValidationError[];
     importData(contextualDataModel: DataGroup): void;
     defaultDataModel(name: string | number): DataValue;
-    getState(): {
+    getState(isRepeatableChild?: boolean, forRestore?: boolean): {
         editFormat: string | undefined;
         displayFormat: string | undefined;
         editValue: any;
@@ -159,8 +160,8 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
         enabled: boolean | undefined;
         readOnly: boolean | undefined;
         description?: string | undefined;
-        rules: import("./types").Items<string> & {};
-        events: import("./types").Items<string | 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;
@@ -208,6 +209,11 @@ declare class Field extends Scriptable<FieldJson> implements FieldModel {
         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;