@myrtex-org/form 1.0.0

package/fesm2022/myrtex-org-form.mjs

@@ -0,0 +1,891 @@
+import * as i0 from '@angular/core';
+import { NgModule, inject, Injectable } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ObjectFormRoutingModule } from '@object-form/object-form-routing.module';
+import { ObjectFormComponent } from '@object-form/object-form.component';
+import * as i2 from '@ngrx/store';
+import { StoreModule, createAction, props, createFeatureSelector, createSelector, createReducer, on } from '@ngrx/store';
+import * as i1 from '@ngrx/effects';
+import { EffectsModule, createEffect, ofType } from '@ngrx/effects';
+import { objectReducer as objectReducer$1, ObjectFormEffects as ObjectFormEffects$1, initialObjectFormState as initialObjectFormState$1, objectFormActions as objectFormActions$1, EApplicationActions as EApplicationActions$1, objectFormSelectors as objectFormSelectors$1 } from '@object-form/store';
+import { STATE_NAME } from '@object-form/constants';
+import * as i4 from '@object-form/services';
+import { ObjectFormService } from '@object-form/services';
+import { ApplicationContent } from '@object-form/components/object-form-content/object-form-content.component';
+import { FormHeaderModule, MenuAdminModule } from '@myrtex-org/templates';
+import { FormsModule } from '@angular/forms';
+import { InputTextComponent, InputTextareaComponent, InputLinkComponent, InputSwitchComponent, InputNumberComponent, InputSelectComponent, InputDateComponent, InputInnComponent, InputFileComponent, InputPhoneComponent, InputCheckboxGroupComponent, InputRadioGroupComponent, InputTableComponent, ContentTitleComponent, ContentTextComponent, ContentTooltipComponent, ContentFileComponent, ContentDividerComponent } from '@object-form/components/elements';
+import * as i5 from '@myrtex-org/ui';
+import { LoaderModule, InputTextModule, LabelModule, ContentWrapperModule, EditorModule, InputTextareaModule, ButtonModule, CheckboxModule, SwitchModule, InputNumberModule, InputSelectModule, InputDateTimeModule, InputTimepickerModule, InputFileModule, AlertModule, CheckboxGroupModule, RadioGroupModule, DropdownModule, InputTelModule, LinkModule, ErrorMessageModule, ModalModule, ToasterServiceModule, AutoSaveStore, ToasterType } from '@myrtex-org/ui';
+import { HTTP_INTERCEPTORS, HttpHeaders } from '@angular/common/http';
+import { DxDataGridModule } from 'devextreme-angular';
+import { DxiColumnModule, DxiItemModule, DxoToolbarModule } from 'devextreme-angular/ui/nested';
+import { ConcurrencyInterceptor as ConcurrencyInterceptor$1 } from '@core/interceptors';
+import { ConcurrencyStoreService as ConcurrencyStoreService$1 } from '@core/services';
+import { FormDispenser } from '@object-form/components/form-dispenser/form-dispenser.component';
+import { sharedSelectors as sharedSelectors$1, EFFECTS as EFFECTS$1, sharedStoreReducer as sharedStoreReducer$1 } from '@shared-store/store';
+import * as fromHelpers from '@object-form/helpers';
+import { getValueModel } from '@object-form/helpers';
+import { withLatestFrom, switchMap, catchError, map, distinctUntilChanged, tap, debounceTime } from 'rxjs/operators';
+import { of, forkJoin, throwError } from 'rxjs';
+import * as i3 from '@angular/router';
+import { FORM_SHARED_STORE_MODULE_NAME } from '@shared-store/constants';
+import { routerReducer } from '@ngrx/router-store';
+import { ROUTER_STATE_NAME, selectRouter, selectQueryParam, selectRouteParam } from '@myrtex-org/ui-composite';
+
+class ObjectFormModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormModule, declarations: [ObjectFormComponent,
+            ApplicationContent,
+            InputTextComponent,
+            InputTextareaComponent,
+            InputLinkComponent,
+            InputSwitchComponent,
+            InputNumberComponent,
+            InputSelectComponent,
+            InputDateComponent,
+            InputInnComponent,
+            InputFileComponent,
+            InputPhoneComponent,
+            InputCheckboxGroupComponent,
+            InputRadioGroupComponent,
+            InputTableComponent,
+            ContentTitleComponent,
+            ContentTextComponent,
+            ContentTooltipComponent,
+            ContentFileComponent,
+            ContentDividerComponent], imports: [CommonModule,
+            ObjectFormRoutingModule, i2.StoreFeatureModule, i1.EffectsFeatureModule, FormDispenser,
+            FormHeaderModule,
+            MenuAdminModule,
+            LoaderModule,
+            InputTextModule,
+            LabelModule,
+            ContentWrapperModule,
+            EditorModule,
+            InputTextareaModule,
+            ButtonModule,
+            FormsModule,
+            CheckboxModule,
+            SwitchModule,
+            InputNumberModule,
+            InputSelectModule,
+            InputDateTimeModule,
+            InputTimepickerModule,
+            InputFileModule,
+            AlertModule,
+            CheckboxGroupModule,
+            RadioGroupModule,
+            DropdownModule,
+            InputTelModule,
+            LinkModule,
+            ErrorMessageModule,
+            DxDataGridModule,
+            DxiColumnModule,
+            DxiItemModule,
+            DxoToolbarModule,
+            ModalModule,
+            ToasterServiceModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormModule, providers: [
+            ObjectFormService,
+            ConcurrencyStoreService$1,
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: ConcurrencyInterceptor$1,
+                multi: true
+            }
+        ], imports: [CommonModule,
+            ObjectFormRoutingModule,
+            StoreModule.forFeature(STATE_NAME, objectReducer$1),
+            EffectsModule.forFeature([ObjectFormEffects$1]),
+            FormDispenser,
+            FormHeaderModule,
+            MenuAdminModule,
+            LoaderModule,
+            InputTextModule,
+            LabelModule,
+            ContentWrapperModule,
+            EditorModule,
+            InputTextareaModule,
+            ButtonModule,
+            FormsModule,
+            CheckboxModule,
+            SwitchModule,
+            InputNumberModule,
+            InputSelectModule,
+            InputDateTimeModule,
+            InputTimepickerModule,
+            InputFileModule,
+            AlertModule,
+            CheckboxGroupModule,
+            RadioGroupModule,
+            DropdownModule,
+            InputTelModule,
+            LinkModule,
+            ErrorMessageModule,
+            DxDataGridModule,
+            DxiColumnModule,
+            DxiItemModule,
+            DxoToolbarModule,
+            ModalModule,
+            ToasterServiceModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ObjectFormComponent,
+                        ApplicationContent,
+                        InputTextComponent,
+                        InputTextareaComponent,
+                        InputLinkComponent,
+                        InputSwitchComponent,
+                        InputNumberComponent,
+                        InputSelectComponent,
+                        InputDateComponent,
+                        InputInnComponent,
+                        InputFileComponent,
+                        InputPhoneComponent,
+                        InputCheckboxGroupComponent,
+                        InputRadioGroupComponent,
+                        InputTableComponent,
+                        ContentTitleComponent,
+                        ContentTextComponent,
+                        ContentTooltipComponent,
+                        ContentFileComponent,
+                        ContentDividerComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        ObjectFormRoutingModule,
+                        StoreModule.forFeature(STATE_NAME, objectReducer$1),
+                        EffectsModule.forFeature([ObjectFormEffects$1]),
+                        FormDispenser,
+                        FormHeaderModule,
+                        MenuAdminModule,
+                        LoaderModule,
+                        InputTextModule,
+                        LabelModule,
+                        ContentWrapperModule,
+                        EditorModule,
+                        InputTextareaModule,
+                        ButtonModule,
+                        FormsModule,
+                        CheckboxModule,
+                        SwitchModule,
+                        InputNumberModule,
+                        InputSelectModule,
+                        InputDateTimeModule,
+                        InputTimepickerModule,
+                        InputFileModule,
+                        AlertModule,
+                        CheckboxGroupModule,
+                        RadioGroupModule,
+                        DropdownModule,
+                        InputTelModule,
+                        LinkModule,
+                        ErrorMessageModule,
+                        DxDataGridModule,
+                        DxiColumnModule,
+                        DxiItemModule,
+                        DxoToolbarModule,
+                        ModalModule,
+                        ToasterServiceModule
+                    ],
+                    providers: [
+                        ObjectFormService,
+                        ConcurrencyStoreService$1,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: ConcurrencyInterceptor$1,
+                            multi: true
+                        }
+                    ]
+                }]
+        }] });
+
+var EApplicationActions;
+(function (EApplicationActions) {
+    EApplicationActions["LoadTemplatePending"] = "[Application] Load Template Pending";
+    EApplicationActions["LoadTemplateSuccess"] = "[Application] Load Template Success";
+    EApplicationActions["LoadTemplateError"] = "[Application] Load Template Error";
+    EApplicationActions["LoadApplicationPending"] = "[Application] Load Application Pending";
+    EApplicationActions["LoadApplicationSuccess"] = "[Application] Load Application Success";
+    EApplicationActions["LoadApplicationError"] = "[Application] Load Application Error";
+    EApplicationActions["SaveApplicationPending"] = "[Application] Save Application Pending";
+    EApplicationActions["SaveApplicationSuccess"] = "[Application] Save Application Success";
+    EApplicationActions["SaveApplicationError"] = "[Application] Save Application Error";
+    EApplicationActions["CopyApplicationPending"] = "[Application] Copy Application Pending";
+    EApplicationActions["CopyApplicationSuccess"] = "[Application] Copy Application Success";
+    EApplicationActions["CopyApplicationError"] = "[Application] Copy Application Error";
+    EApplicationActions["UpdateValues"] = "[Application] Update Application Values";
+    EApplicationActions["AccessUpdateValues"] = "[Application] Access Update Application Values";
+    EApplicationActions["SaveValuesPending"] = "[Application] Save Application Values Pending";
+    EApplicationActions["SaveValuesSuccess"] = "[Application] Save Application Values Success";
+    EApplicationActions["SaveValuesError"] = "[Application] Save Application Values Error";
+    EApplicationActions["UpdateSelectedSectionSysName"] = "[Application] Update Selected Section SysName";
+    EApplicationActions["LoadSectionFilesPending"] = "[Application] Load Section Files Pending";
+    EApplicationActions["LoadSectionFilesSuccess"] = "[Application] Load Section Files Success";
+    EApplicationActions["LoadSectionFilesError"] = "[Application] Load Section Files Error";
+    EApplicationActions["ToggleCheckRequired"] = "[Application] Toggle Check Required";
+    EApplicationActions["UpdateCheckRequired"] = "[Application] Update Check Required";
+    EApplicationActions["LoadPreviewTemplatePending"] = "[Application] Load Preview Template Pending";
+    EApplicationActions["LoadPreviewTemplateSuccess"] = "[Application] Load Preview Template Success";
+    EApplicationActions["LoadPreviewTemplateError"] = "[Application] Load Preview Template Error";
+    EApplicationActions["CheckAllDependencyRules"] = "[Application] Check All Dependency Rule";
+})(EApplicationActions || (EApplicationActions = {}));
+const loadTemplatePending = createAction(EApplicationActions.LoadTemplatePending);
+const loadTemplateSuccess = createAction(EApplicationActions.LoadTemplateSuccess, props());
+const loadTemplateError = createAction(EApplicationActions.LoadTemplateError);
+const loadApplicationPending = createAction(EApplicationActions.LoadApplicationPending, props());
+const loadApplicationSuccess = createAction(EApplicationActions.LoadApplicationSuccess, props());
+const loadApplicationError = createAction(EApplicationActions.LoadApplicationError);
+const saveApplicationPending = createAction(EApplicationActions.SaveApplicationPending);
+const saveApplicationSuccess = createAction(EApplicationActions.SaveApplicationSuccess);
+const saveApplicationError = createAction(EApplicationActions.SaveApplicationError);
+const copyApplicationPending = createAction(EApplicationActions.CopyApplicationPending, props());
+const copyApplicationSuccess = createAction(EApplicationActions.CopyApplicationSuccess);
+const copyApplicationError = createAction(EApplicationActions.CopyApplicationError);
+const updateValues = createAction(EApplicationActions.UpdateValues, props());
+const accessUpdateValues = createAction(EApplicationActions.AccessUpdateValues);
+const saveValuesPending = createAction(EApplicationActions.SaveValuesPending);
+const saveValuesSuccess = createAction(EApplicationActions.SaveValuesSuccess, props());
+const saveValuesError = createAction(EApplicationActions.SaveValuesError);
+const updateSelectedSectionSysName = createAction(EApplicationActions.UpdateSelectedSectionSysName, props());
+const loadSectionFilesPending = createAction(EApplicationActions.LoadSectionFilesPending);
+const loadSectionFilesSuccess = createAction(EApplicationActions.LoadSectionFilesSuccess, props());
+const loadSectionFilesError = createAction(EApplicationActions.LoadSectionFilesError);
+const toggleCheckRequired = createAction(EApplicationActions.ToggleCheckRequired);
+const updateCheckRequired = createAction(EApplicationActions.UpdateCheckRequired, props());
+const loadPreviewTemplatePending = createAction(EApplicationActions.LoadPreviewTemplatePending, props());
+const loadPreviewTemplateSuccess = createAction(EApplicationActions.LoadPreviewTemplateSuccess, props());
+const loadPreviewTemplateError = createAction(EApplicationActions.LoadPreviewTemplateError);
+const checkAllDependencyRules = createAction(EApplicationActions.CheckAllDependencyRules);
+
+var objectForm_actions = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get EApplicationActions () { return EApplicationActions; },
+    accessUpdateValues: accessUpdateValues,
+    checkAllDependencyRules: checkAllDependencyRules,
+    copyApplicationError: copyApplicationError,
+    copyApplicationPending: copyApplicationPending,
+    copyApplicationSuccess: copyApplicationSuccess,
+    loadApplicationError: loadApplicationError,
+    loadApplicationPending: loadApplicationPending,
+    loadApplicationSuccess: loadApplicationSuccess,
+    loadPreviewTemplateError: loadPreviewTemplateError,
+    loadPreviewTemplatePending: loadPreviewTemplatePending,
+    loadPreviewTemplateSuccess: loadPreviewTemplateSuccess,
+    loadSectionFilesError: loadSectionFilesError,
+    loadSectionFilesPending: loadSectionFilesPending,
+    loadSectionFilesSuccess: loadSectionFilesSuccess,
+    loadTemplateError: loadTemplateError,
+    loadTemplatePending: loadTemplatePending,
+    loadTemplateSuccess: loadTemplateSuccess,
+    saveApplicationError: saveApplicationError,
+    saveApplicationPending: saveApplicationPending,
+    saveApplicationSuccess: saveApplicationSuccess,
+    saveValuesError: saveValuesError,
+    saveValuesPending: saveValuesPending,
+    saveValuesSuccess: saveValuesSuccess,
+    toggleCheckRequired: toggleCheckRequired,
+    updateCheckRequired: updateCheckRequired,
+    updateSelectedSectionSysName: updateSelectedSectionSysName,
+    updateValues: updateValues
+});
+
+const objectFeature = createFeatureSelector(STATE_NAME);
+const selectIsLoading = createSelector(objectFeature, (state) => state.isLoading);
+const selectIsObjectSaveLoading = createSelector(objectFeature, (state) => state.isObjectSaveLoading);
+const selectIsEdited = createSelector(objectFeature, (state) => state.isEdited);
+const selectIsCheckRequired = createSelector(objectFeature, (state) => state.isCheckRequired);
+const selectMenuModel = createSelector(objectFeature, (state) => state.menuModel);
+const selectSectionSettings = createSelector(objectFeature, sharedSelectors$1.selectRouteNestedParam('sectionSysName'), (state, sectionSysName) => {
+    return state.settings?.sections.find(s => s.sysName === sectionSysName) || null;
+});
+const selectSectionValues = createSelector(objectFeature, (state) => state.sectionValues);
+const selectObjectId = createSelector(sharedSelectors$1.selectRouteNestedParam('objectId'), (applicationId) => applicationId);
+const selectSectionFiles = createSelector(objectFeature, (state) => state.sectionFiles);
+const selectTemplateSysName$1 = createSelector(objectFeature, (state) => state.settings?.sysName);
+const selectValueModel = (settings) => createSelector(objectFeature, (state) => getValueModel(settings, state.sectionValues));
+const selectDependencyRulesResults = createSelector(objectFeature, state => state.dependencyRuleCheckResults);
+
+var objectForm_selector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    selectDependencyRulesResults: selectDependencyRulesResults,
+    selectIsCheckRequired: selectIsCheckRequired,
+    selectIsEdited: selectIsEdited,
+    selectIsLoading: selectIsLoading,
+    selectIsObjectSaveLoading: selectIsObjectSaveLoading,
+    selectMenuModel: selectMenuModel,
+    selectObjectId: selectObjectId,
+    selectSectionFiles: selectSectionFiles,
+    selectSectionSettings: selectSectionSettings,
+    selectSectionValues: selectSectionValues,
+    selectTemplateSysName: selectTemplateSysName$1,
+    selectValueModel: selectValueModel
+});
+
+const objectReducerCreator = createReducer(initialObjectFormState$1, on(objectFormActions$1.loadApplicationPending, (state) => {
+    return { ...state, isLoading: true };
+}), on(objectFormActions$1.loadApplicationSuccess, (state, { templateSettings, sectionValues, applicationId, isDraft }) => {
+    return {
+        ...state,
+        isLoading: false,
+        settings: templateSettings,
+        sectionValues: sectionValues,
+        isEdited: isDraft,
+        menuModel: fromHelpers.getMenuModel(templateSettings, sectionValues, applicationId)
+    };
+}), on(objectFormActions$1.loadApplicationError, (state) => {
+    return { ...state, isLoading: false };
+}), on(objectFormActions$1.updateValues, (state, { value }) => {
+    const dependenceRulesResults = fromHelpers.getDependenceRulesResults(state.dependencyRuleCheckResults, state.sectionValues, value, state.settings?.dependenceRules.rules);
+    const selectedSectionValues = state.sectionValues.map((sectionValue) => {
+        // пришлось отказаться от условия проверки выбранной секции,
+        // т.к. зависимые поля могут находиться в других секциях, а их необходимо обнулять.
+        return fromHelpers.getUpdatedValues(sectionValue, Array.isArray(value) ? value : [value], fromHelpers.getValuesToClean(dependenceRulesResults));
+    });
+    return {
+        ...state,
+        sectionValues: selectedSectionValues,
+        isEdited: true,
+        dependencyRuleCheckResults: dependenceRulesResults
+    };
+}), on(objectFormActions$1.saveValuesSuccess, (state, { result, applicationId }) => {
+    const updatedSectionValues = state.sectionValues.map((sectionValue) => {
+        const section = {
+            ...sectionValue,
+            percent: result.fillness.find(x => x.name === sectionValue.sysName)?.percent || 0
+        };
+        return fromHelpers.getUpdatedValues(section, result.values);
+    });
+    return {
+        ...state,
+        sectionValues: updatedSectionValues,
+        isEdited: true,
+        menuModel: fromHelpers.getMenuModel(state.settings, updatedSectionValues, applicationId)
+    };
+}), on(objectFormActions$1.saveValuesError, (state) => {
+    return { ...state };
+}), on(objectFormActions$1.saveApplicationPending, (state) => {
+    return { ...state, isApplicationSaveLoading: true };
+}), on(objectFormActions$1.saveApplicationSuccess, (state) => {
+    return { ...state, isApplicationSaveLoading: false, isEdited: false };
+}), on(objectFormActions$1.saveApplicationError, (state) => {
+    return { ...state, isApplicationSaveLoading: false };
+}), on(objectFormActions$1.updateSelectedSectionSysName, (state, { sectionSysName }) => {
+    return { ...state, selectedSectionSysName: sectionSysName };
+}), on(objectFormActions$1.loadSectionFilesPending, (state) => {
+    return { ...state, sectionFiles: [] };
+}), on(objectFormActions$1.loadSectionFilesSuccess, (state, { sectionFiles }) => {
+    return { ...state, sectionFiles: sectionFiles };
+}), on(objectFormActions$1.toggleCheckRequired, (state) => {
+    return { ...state, isCheckRequired: !state.isCheckRequired };
+}), on(objectFormActions$1.updateCheckRequired, (state, { isCheckRequired }) => {
+    return { ...state, isCheckRequired: isCheckRequired };
+}), on(objectFormActions$1.loadPreviewTemplatePending, (state) => {
+    return { ...state, isLoading: true };
+}), on(objectFormActions$1.loadPreviewTemplateSuccess, (state, { templateSettings, templateSysName }) => {
+    return {
+        ...state,
+        isLoading: false,
+        settings: templateSettings,
+        menuModel: fromHelpers.getPreviewMenuModel(templateSettings, templateSysName)
+    };
+}), on(objectFormActions$1.loadPreviewTemplateError, (state) => {
+    return { ...state, isLoading: false };
+}), on(objectFormActions$1.checkAllDependencyRules, (state) => {
+    const dependenceResults = state.settings?.dependenceRules.rules
+        .map(rule => (fromHelpers.checkDependenceRule(rule, state.sectionValues)))
+        .flat() || [];
+    return { ...state, dependencyRuleCheckResults: dependenceResults };
+}));
+function objectReducer(state, action) {
+    return objectReducerCreator(state, action);
+}
+
+class ObjectFormEffects {
+    constructor(_actions$, _store, _router, _applicationService, _toasterService) {
+        this._actions$ = _actions$;
+        this._store = _store;
+        this._router = _router;
+        this._applicationService = _applicationService;
+        this._toasterService = _toasterService;
+        this._autoSaveStore = inject(AutoSaveStore);
+        this.loadTemplatePending$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.LoadTemplatePending), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('objectId')), this._store.select(sharedSelectors$1.selectRouteNestedParam('templateSysName'))), switchMap(([_, applicationId, templateSysName]) => {
+            if (applicationId) {
+                return this._applicationService.getTemplate(applicationId).pipe(switchMap(({ templateSysName }) => ([
+                    objectFormActions$1.loadTemplateSuccess({ templateSysName }),
+                    objectFormActions$1.loadApplicationPending({ templateSysName })
+                ])), catchError(() => {
+                    return of(objectFormActions$1.loadTemplateError());
+                }));
+            }
+            else {
+                return of(objectFormActions$1.loadPreviewTemplatePending({ templateSysName }));
+            }
+        })));
+        this.loadPreviewTemplatePending = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.LoadPreviewTemplatePending), map((props) => props.templateSysName), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('sectionSysName'))), switchMap(([templateSysName, sectionSysName]) => {
+            return this._applicationService.getTemplateSettings(templateSysName).pipe(map((templateSettings) => {
+                const activeSection = templateSettings.sections.find((s) => s.sysName === sectionSysName);
+                if (!activeSection && templateSettings.sections.length) {
+                    this._router.navigate([`/form/application/preview/${templateSysName}/${templateSettings.sections[0].sysName}`]);
+                }
+                return objectFormActions$1.loadPreviewTemplateSuccess({ templateSettings, templateSysName });
+            }), catchError((error) => {
+                return of(objectFormActions$1.loadPreviewTemplateError());
+            }));
+        })));
+        this.loadApplicationPending$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.LoadApplicationPending), map((props) => props.templateSysName), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('objectId')), this._store.select(sharedSelectors$1.selectRouteNestedParam('sectionSysName'))), switchMap(([templateSysName, applicationId, sectionSysName]) => {
+            const requests = [
+                this._applicationService.getTemplateSettings(templateSysName),
+                this._applicationService.getSectionValues(applicationId)
+            ];
+            return forkJoin(requests).pipe(switchMap(([templateSettings, valueDto]) => {
+                const activeSection = templateSettings.sections.find((s) => s.sysName === sectionSysName);
+                if (!activeSection && templateSettings.sections.length) {
+                    this._router.navigate([`/form/application/${applicationId}/${templateSettings.sections[0].sysName}`]);
+                }
+                return [
+                    objectFormActions$1.loadApplicationSuccess({
+                        templateSettings: templateSettings,
+                        sectionValues: valueDto.value.sectionValues,
+                        applicationId: applicationId,
+                        isDraft: valueDto.isDraft
+                    }),
+                    objectFormActions$1.checkAllDependencyRules()
+                ];
+            }), catchError(() => {
+                return of(objectFormActions$1.loadApplicationError());
+            }));
+        })));
+        this.checkCanUpdateValues$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.UpdateValues), map((props) => props.value), distinctUntilChanged(), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('templateSysName'))), tap(([value, templateSysName]) => {
+            if (templateSysName) {
+                return;
+            }
+            this._store.dispatch(objectFormActions$1.accessUpdateValues());
+        })), { dispatch: false });
+        this.saveValuesDebounced$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.AccessUpdateValues), distinctUntilChanged(), debounceTime(1500), tap(() => {
+            this._autoSaveStore.start();
+            this._store.dispatch(objectFormActions$1.saveValuesPending());
+        })), { dispatch: false });
+        this.updateApplicationValues$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.SaveValuesPending), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('objectId')), this._store.select(objectFormSelectors$1.selectSectionValues)), switchMap(([_, applicationId, sectionValues]) => {
+            return this._applicationService.updateApplicationValues(applicationId, sectionValues).pipe(map((result) => {
+                this._autoSaveStore.success();
+                return objectFormActions$1.saveValuesSuccess({ result, applicationId });
+            }), catchError((error) => {
+                this._autoSaveStore.error();
+                return of(objectFormActions$1.saveValuesError());
+            }));
+        })));
+        this.saveApplicationPending$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.SaveApplicationPending), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('objectId'))), switchMap(([_, applicationId]) => {
+            return this._applicationService.saveApplication(applicationId).pipe(map(() => {
+                this._toasterService.show({
+                    title: 'Сохранено успешно',
+                    type: ToasterType.Positive
+                });
+                return objectFormActions$1.saveApplicationSuccess();
+            }), catchError(() => {
+                this._toasterService.show({
+                    title: 'Возникли ошибки при сохранении, повторите',
+                    type: ToasterType.Negative
+                });
+                return of(objectFormActions$1.saveApplicationError());
+            }));
+        })));
+        this.copyApplicationPending$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.CopyApplicationPending), map((action) => action), switchMap((action) => {
+            return this._applicationService.copyApplication(action).pipe(map((result) => {
+                this._toasterService.show({
+                    title: 'Копировнаие прошло успешно',
+                    type: ToasterType.Positive
+                });
+                window.open('/form/application/' + result.id, '_blank');
+                return objectFormActions$1.copyApplicationSuccess();
+            }), catchError(() => {
+                this._toasterService.show({
+                    title: 'Возникли ошибки при копировании заявки, повторите',
+                    type: ToasterType.Negative
+                });
+                return of(objectFormActions$1.copyApplicationError());
+            }));
+        })), { dispatch: false });
+        this.loadSectionFilesPending$ = createEffect(() => this._actions$.pipe(ofType(EApplicationActions$1.LoadSectionFilesPending), withLatestFrom(this._store.select(sharedSelectors$1.selectRouteNestedParam('objectId')), this._store.select(sharedSelectors$1.selectRouteNestedParam('sectionSysName'))), switchMap(([_, applicationId, sectionSysName]) => {
+            return this._applicationService.getSectionFiles(applicationId, sectionSysName).pipe(map((sectionFiles) => {
+                return objectFormActions$1.loadSectionFilesSuccess({ sectionFiles: sectionFiles });
+            }), catchError(() => {
+                return of(objectFormActions$1.loadSectionFilesError());
+            }));
+        })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormEffects, deps: [{ token: i1.Actions }, { token: i2.Store }, { token: i3.Router }, { token: i4.ObjectFormService }, { token: i5.ToasterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormEffects }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectFormEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Actions }, { type: i2.Store }, { type: i3.Router }, { type: i4.ObjectFormService }, { type: i5.ToasterService }] });
+
+const initialObjectFormState = {
+    isLoading: false,
+    isEdited: false,
+    isCheckRequired: false,
+    isObjectSaveLoading: false,
+    settings: null,
+    selectedSectionSysName: null,
+    sectionValues: [],
+    menuModel: {
+        items: []
+    },
+    sectionFiles: [],
+    dependencyRuleCheckResults: []
+};
+
+class SharedStoreModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SharedStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: SharedStoreModule, imports: [CommonModule, i1.EffectsFeatureModule, i2.StoreFeatureModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SharedStoreModule, imports: [CommonModule,
+            EffectsModule.forFeature(EFFECTS$1),
+            StoreModule.forFeature(FORM_SHARED_STORE_MODULE_NAME, sharedStoreReducer$1)] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SharedStoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        EffectsModule.forFeature(EFFECTS$1),
+                        StoreModule.forFeature(FORM_SHARED_STORE_MODULE_NAME, sharedStoreReducer$1),
+                    ]
+                }]
+        }] });
+
+const EFFECTS = [];
+
+const sharedStoreReducer = {
+    [ROUTER_STATE_NAME]: routerReducer
+};
+
+const initialSharedStoreState = {};
+
+const selectRouteNestedParams = createSelector(selectRouter, (router) => {
+    let currentRoute = router?.state?.root;
+    let params = {};
+    while (currentRoute?.firstChild) {
+        currentRoute = currentRoute.firstChild;
+        params = {
+            ...params,
+            ...currentRoute.params,
+        };
+    }
+    return params;
+});
+const selectRouteNestedParam = (param) => createSelector(selectRouteNestedParams, (params) => {
+    return params && params[param];
+});
+const selectTemplateSysName = createSelector(selectRouteNestedParam('templateSysName'), (rparam) => {
+    return rparam || null;
+});
+const selectIdFromQuery = createSelector(selectQueryParam('id'), (rparam) => {
+    return rparam || null;
+});
+const selectSectionSysName = createSelector(selectRouteParam('sectionSysName'), (rparam) => {
+    return rparam || null;
+});
+
+var sharedStore_selector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    selectIdFromQuery: selectIdFromQuery,
+    selectRouteNestedParam: selectRouteNestedParam,
+    selectRouteNestedParams: selectRouteNestedParams,
+    selectSectionSysName: selectSectionSysName,
+    selectTemplateSysName: selectTemplateSysName
+});
+
+var TemplateStatus;
+(function (TemplateStatus) {
+    TemplateStatus[TemplateStatus["draft"] = 0] = "draft";
+    TemplateStatus[TemplateStatus["active"] = 1] = "active";
+    TemplateStatus[TemplateStatus["archived"] = 2] = "archived";
+})(TemplateStatus || (TemplateStatus = {}));
+const templateStatusCaption = {
+    [TemplateStatus.draft]: 'черновик',
+    [TemplateStatus.active]: 'активен',
+    [TemplateStatus.archived]: 'архив',
+};
+const getTemplateStatusText = (status) => {
+    return templateStatusCaption[status];
+};
+
+var ComponentSizeEnum;
+(function (ComponentSizeEnum) {
+    ComponentSizeEnum["Large"] = "large";
+    ComponentSizeEnum["Medium"] = "medium";
+    ComponentSizeEnum["Small"] = "small";
+})(ComponentSizeEnum || (ComponentSizeEnum = {}));
+
+var DateFormatEnum;
+(function (DateFormatEnum) {
+    DateFormatEnum["Day"] = "\u0434\u0434.\u043C\u043C.\u0433\u0433\u0433\u0433";
+    DateFormatEnum["Month"] = "\u043C\u043C.\u0433\u0433\u0433\u0433";
+    DateFormatEnum["Year"] = "\u0433\u0433\u0433\u0433";
+})(DateFormatEnum || (DateFormatEnum = {}));
+const DateFormatLabelEnum = {
+    [DateFormatEnum.Day]: 'дд.мм.гггг',
+    [DateFormatEnum.Month]: 'мм.гггг',
+    [DateFormatEnum.Year]: 'гггг',
+};
+
+var DateTypeEnum;
+(function (DateTypeEnum) {
+    DateTypeEnum["Date"] = "date";
+    DateTypeEnum["DateTime"] = "date-time";
+})(DateTypeEnum || (DateTypeEnum = {}));
+const DateTypeLabelEnum = {
+    [DateTypeEnum.Date]: 'Дата',
+    [DateTypeEnum.DateTime]: 'Дата и время',
+};
+
+var InnTypeEnum;
+(function (InnTypeEnum) {
+    InnTypeEnum["Personal"] = "personal";
+    InnTypeEnum["Legal"] = "legal";
+    InnTypeEnum["ForeignLegal"] = "foreign-legal";
+})(InnTypeEnum || (InnTypeEnum = {}));
+const InnTypeLabelEnum = {
+    [InnTypeEnum.Personal]: 'ФЛ/ИП',
+    [InnTypeEnum.Legal]: 'ЮЛ',
+    [InnTypeEnum.ForeignLegal]: 'Иностранное ЮЛ',
+};
+
+var InputState;
+(function (InputState) {
+    InputState["Edit"] = "edit";
+    InputState["Auto"] = "auto";
+    InputState["Formula"] = "formula";
+})(InputState || (InputState = {}));
+var CustomInputStateEnum;
+(function (CustomInputStateEnum) {
+    CustomInputStateEnum[CustomInputStateEnum["Edit"] = 0] = "Edit";
+    CustomInputStateEnum[CustomInputStateEnum["Auto"] = 1] = "Auto";
+    CustomInputStateEnum[CustomInputStateEnum["Formula"] = 2] = "Formula";
+})(CustomInputStateEnum || (CustomInputStateEnum = {}));
+const CustomInputStateEnumLabel = {
+    [CustomInputStateEnum.Edit]: InputState.Edit,
+    [CustomInputStateEnum.Auto]: InputState.Auto,
+    [CustomInputStateEnum.Formula]: InputState.Formula,
+};
+
+var ComponentType;
+(function (ComponentType) {
+    ComponentType["Section"] = "section";
+    ComponentType["Group"] = "group";
+    ComponentType["InputText"] = "inputText";
+    ComponentType["InputTextarea"] = "inputTextarea";
+    ComponentType["InputSwitch"] = "inputSwitch";
+    ComponentType["InputLink"] = "inputLink";
+    ComponentType["InputSelect"] = "inputSelect";
+    ComponentType["InputNumber"] = "inputNumber";
+    ComponentType["InputDate"] = "inputDate";
+    ComponentType["InputINN"] = "inputINN";
+    ComponentType["InputFile"] = "inputFile";
+    ComponentType["InputPhone"] = "inputPhone";
+    ComponentType["InputCheckboxGroup"] = "inputCheckboxGroup";
+    ComponentType["InputRadioGroup"] = "inputRadioGroup";
+    ComponentType["InputTable"] = "inputTable";
+    ComponentType["ContentTitle"] = "title";
+    ComponentType["ContentText"] = "text";
+    ComponentType["ContentTooltip"] = "tooltip";
+    ComponentType["ContentFile"] = "file";
+    ComponentType["ContentDivider"] = "divider";
+})(ComponentType || (ComponentType = {}));
+const ComponentShortType = {
+    [ComponentType.Section]: 's',
+    [ComponentType.Group]: 'g',
+    [ComponentType.InputText]: 'itt',
+    [ComponentType.InputTextarea]: 'ita',
+    [ComponentType.InputSwitch]: 'isw',
+    [ComponentType.InputLink]: 'il',
+    [ComponentType.InputSelect]: 'ist',
+    [ComponentType.InputNumber]: 'in',
+    [ComponentType.InputDate]: 'id',
+    [ComponentType.InputINN]: 'inn',
+    [ComponentType.InputFile]: 'if',
+    [ComponentType.InputPhone]: 'ip',
+    [ComponentType.InputCheckboxGroup]: 'icg',
+    [ComponentType.InputRadioGroup]: 'irg',
+    [ComponentType.InputTable]: 'itb',
+    [ComponentType.ContentTitle]: 'ct',
+    [ComponentType.ContentText]: 'ctt',
+    [ComponentType.ContentTooltip]: 'ctp',
+    [ComponentType.ContentFile]: 'cf',
+    [ComponentType.ContentDivider]: 'cd',
+};
+
+var ValueType;
+(function (ValueType) {
+    ValueType["Undefined"] = "undefined";
+    ValueType["Short"] = "short";
+    ValueType["Int"] = "int";
+    ValueType["Long"] = "long";
+    ValueType["Float"] = "float";
+    ValueType["Double"] = "double";
+    ValueType["Decimal"] = "decimal";
+    ValueType["String"] = "string";
+    ValueType["Guid"] = "guid";
+    ValueType["DateTime"] = "dateTime";
+    ValueType["Boolean"] = "boolean";
+    ValueType["IntArray"] = "int[]";
+    ValueType["StringArray"] = "string[]";
+    ValueType["GuidArray"] = "guid[]";
+})(ValueType || (ValueType = {}));
+
+var ConditionOperatorType;
+(function (ConditionOperatorType) {
+    ConditionOperatorType["undefined"] = "undefined";
+    ConditionOperatorType["filled"] = "filled";
+})(ConditionOperatorType || (ConditionOperatorType = {}));
+const getConditionOperatorsList = () => {
+    return [{
+            value: ConditionOperatorType.filled,
+            text: conditionOperatorTypeLabel[ConditionOperatorType.filled]
+        }];
+};
+const conditionOperatorTypeLabel = {
+    [ConditionOperatorType.filled]: 'заполнено'
+};
+
+var LogicalOperatorType;
+(function (LogicalOperatorType) {
+    LogicalOperatorType["undefined"] = "undefined";
+    LogicalOperatorType["or"] = "or";
+    LogicalOperatorType["and"] = "and";
+})(LogicalOperatorType || (LogicalOperatorType = {}));
+
+var DependenceActionType;
+(function (DependenceActionType) {
+    DependenceActionType["undefined"] = "undefined";
+    DependenceActionType["show"] = "show";
+})(DependenceActionType || (DependenceActionType = {}));
+const getDependenceActionsList = () => {
+    return [{
+            value: DependenceActionType.show,
+            text: 'показать'
+        }];
+};
+
+var TemplateComponentsGroupTypeEnum;
+(function (TemplateComponentsGroupTypeEnum) {
+    TemplateComponentsGroupTypeEnum[TemplateComponentsGroupTypeEnum["Components"] = 1] = "Components";
+    TemplateComponentsGroupTypeEnum[TemplateComponentsGroupTypeEnum["Content"] = 2] = "Content";
+})(TemplateComponentsGroupTypeEnum || (TemplateComponentsGroupTypeEnum = {}));
+const TemplateComponentsGroupTypeLabels = {
+    [TemplateComponentsGroupTypeEnum.Components]: 'Поля',
+    [TemplateComponentsGroupTypeEnum.Content]: 'Контент',
+};
+
+function isNumeric(str) {
+    if (typeof str != 'string') {
+        return false; // we only process strings!
+    }
+    return !isNaN(str) && !isNaN(parseInt(str)) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+        !isNaN(parseFloat(str)); // ...and ensure strings of whitespace fail
+}
+const isNullOrUndefined = (model) => {
+    return model === null || typeof model === 'undefined';
+};
+
+class ConcurrencyInterceptor {
+    constructor(_toasterService) {
+        this._toasterService = _toasterService;
+    }
+    intercept(req, next) {
+        return next.handle(req).pipe(catchError(error => {
+            return this.handleError(error);
+        }));
+    }
+    handleError(error) {
+        if (error.status === 409) {
+            this._toasterService.show({
+                title: 'Данные были изменены.',
+                message: 'Для продолжения работы обновите страницу.',
+                type: ToasterType.Negative
+            });
+        }
+        return throwError(error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyInterceptor, deps: [{ token: i5.ToasterService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i5.ToasterService }] });
+
+const tokenKey = 'Csy-Token';
+const eTag = "ETag";
+const ifMatch = "If-Match";
+class ConcurrencyStoreService {
+    constructor() {
+        this._store = {};
+    }
+    get(key) {
+        const info = this._store[key];
+        if (!info) {
+            return null;
+        }
+        return info;
+    }
+    set(key, info) {
+        this._store[key] = info;
+    }
+    getHeaders(key) {
+        let headers = new HttpHeaders();
+        if (key) {
+            const info = this.get(key);
+            if (info?.token) {
+                headers = headers.append(tokenKey, info.token);
+            }
+            if (info?.eTag) {
+                headers = headers.append(ifMatch, info.eTag);
+            }
+        }
+        return { headers: headers, observe: 'response' };
+    }
+    appendHeaders(key, headers) {
+        if (key) {
+            const info = this.get(key);
+            if (info?.token) {
+                headers = headers.set(tokenKey, info.token);
+            }
+            if (info?.eTag) {
+                headers = headers.set(ifMatch, info.eTag);
+            }
+        }
+        return headers;
+    }
+    fromHeaders(key, response) {
+        if (key) {
+            const info = {
+                token: response.headers.get(tokenKey),
+                eTag: response.headers.get(eTag)
+            };
+            if (info.token || info.eTag) {
+                this.set(key, info);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyStoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyStoreService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConcurrencyStoreService, decorators: [{
+            type: Injectable
+        }] });
+
+/*
+ * Public API Surface of myrtex-form
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ComponentShortType, ComponentSizeEnum, ComponentType, ConcurrencyInterceptor, ConcurrencyStoreService, ConditionOperatorType, CustomInputStateEnum, CustomInputStateEnumLabel, DateFormatEnum, DateFormatLabelEnum, DateTypeEnum, DateTypeLabelEnum, DependenceActionType, EApplicationActions, EFFECTS, InnTypeEnum, InnTypeLabelEnum, InputState, LogicalOperatorType, ObjectFormEffects, ObjectFormModule, SharedStoreModule, TemplateComponentsGroupTypeEnum, TemplateComponentsGroupTypeLabels, TemplateStatus, ValueType, conditionOperatorTypeLabel, getConditionOperatorsList, getDependenceActionsList, getTemplateStatusText, initialObjectFormState, initialSharedStoreState, isNullOrUndefined, isNumeric, objectForm_actions as objectFormActions, objectForm_selector as objectFormSelectors, objectReducer, sharedStore_selector as sharedSelectors, sharedStoreReducer };
+//# sourceMappingURL=myrtex-org-form.mjs.map