@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/code/resource-yaml-display/component.mjs

@@ -0,0 +1,133 @@
+import { __decorate, __metadata } from "tslib";
+import { CodeEditorModule } from '@alauda/code-editor';
+import { CARD_MODULE, CHECKBOX_MODULE } from '@alauda/ui';
+import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { BehaviorSubject, combineLatest, Observable, map, distinctUntilChanged, } from 'rxjs';
+import { YamlUtilService, ObservableInput, } from '../../core/public-api';
+import { TranslateModule } from '../../translate/translate.module';
+import { viewActions, yamlReadOptions } from '../code-editor-configs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/public-api";
+import * as i2 from "@alauda/ui";
+import * as i3 from "@angular/forms";
+import * as i4 from "@alauda/code-editor";
+import * as i5 from "../../translate/translate.pipe";
+function ResourceYamlDisplayComponent_aui_card_0_ng_container_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function ResourceYamlDisplayComponent_aui_card_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-card");
+    i0.ɵɵtemplate(1, ResourceYamlDisplayComponent_aui_card_0_ng_container_1_Template, 1, 0, "ng-container", 2);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    i0.ɵɵnextContext();
+    const _r1 = i0.ɵɵreference(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngTemplateOutlet", _r1);
+} }
+function ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_3_Template(rf, ctx) { if (rf & 1) {
+    const _r7 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "aui-checkbox", 7);
+    i0.ɵɵlistener("ngModelChange", function ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_3_Template_aui_checkbox_ngModelChange_0_listener($event) { i0.ɵɵrestoreView(_r7); const ctx_r6 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r6.conciseChange($event)); });
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngModel", i0.ɵɵpipeBind1(1, 2, ctx_r4.concise$$));
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(3, 4, "preview_concise_yaml"), " ");
+} }
+function ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_4_Template(rf, ctx) { if (rf & 1) {
+    const _r9 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "aui-checkbox", 8);
+    i0.ɵɵlistener("ngModelChange", function ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_4_Template_aui_checkbox_ngModelChange_0_listener($event) { i0.ɵɵrestoreView(_r9); const ctx_r8 = i0.ɵɵnextContext(2); return i0.ɵɵresetView(ctx_r8.reduce$$.next($event)); });
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵpipe(2, "async");
+    i0.ɵɵtext(3);
+    i0.ɵɵpipe(4, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r5 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("hidden", i0.ɵɵpipeBind1(1, 3, ctx_r5.concise$$))("ngModel", i0.ɵɵpipeBind1(2, 5, ctx_r5.reduce$$));
+    i0.ɵɵadvance(3);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(4, 7, "hide_manage_fields_field"), " ");
+} }
+function ResourceYamlDisplayComponent_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-code-editor", 3);
+    i0.ɵɵpipe(1, "async");
+    i0.ɵɵelementContainerStart(2, 4);
+    i0.ɵɵtemplate(3, ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_3_Template, 4, 6, "aui-checkbox", 5);
+    i0.ɵɵtemplate(4, ResourceYamlDisplayComponent_ng_template_1_aui_checkbox_4_Template, 5, 9, "aui-checkbox", 6);
+    i0.ɵɵelementContainerEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngModel", i0.ɵɵpipeBind1(1, 5, ctx_r2.yaml$))("options", ctx_r2.editorOptions)("actionsConfig", ctx_r2.viewActions);
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngIf", ctx_r2.conciseEnable);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r2.manageFieldActionEnable);
+} }
+export class ResourceYamlDisplayComponent {
+    constructor(yamlUtil) {
+        this.yamlUtil = yamlUtil;
+        this.concise$$ = new BehaviorSubject(false);
+        this.reduce$$ = new BehaviorSubject(true);
+        this.hasWrapper = true;
+        this.conciseEnable = true;
+        this.manageFieldActionEnable = true;
+        this.yaml$ = combineLatest([
+            this.resource$,
+            this.concise$$,
+            this.reduce$$.pipe(distinctUntilChanged()),
+        ]).pipe(map(([resource, concise, reduce]) => this.yamlUtil.generateFilteredYamlResource(resource, concise, reduce)));
+        this.editorOptions = yamlReadOptions;
+        this.viewActions = viewActions;
+    }
+    conciseChange(value) {
+        this.concise$$.next(value);
+        if (value) {
+            this.reduce$$.next(true);
+        }
+    }
+    static { this.ɵfac = function ResourceYamlDisplayComponent_Factory(t) { return new (t || ResourceYamlDisplayComponent)(i0.ɵɵdirectiveInject(i1.YamlUtilService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: ResourceYamlDisplayComponent, selectors: [["acl-resource-yaml-display"]], inputs: { hasWrapper: "hasWrapper", conciseEnable: "conciseEnable", manageFieldActionEnable: "manageFieldActionEnable", resource: "resource" }, standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 3, vars: 2, consts: [[4, "ngIf", "ngIfElse"], ["content", ""], [4, "ngTemplateOutlet"], ["name", "yaml", 3, "ngModel", "options", "actionsConfig"], ["auiCodeEditorToolbarLeft", ""], ["class", "aui-code-editor-toolbar__control-button", 3, "ngModel", "ngModelChange", 4, "ngIf"], ["class", "aui-code-editor-toolbar__control-button", 3, "hidden", "ngModel", "ngModelChange", 4, "ngIf"], [1, "aui-code-editor-toolbar__control-button", 3, "ngModel", "ngModelChange"], [1, "aui-code-editor-toolbar__control-button", 3, "hidden", "ngModel", "ngModelChange"]], template: function ResourceYamlDisplayComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, ResourceYamlDisplayComponent_aui_card_0_Template, 2, 1, "aui-card", 0);
+            i0.ɵɵtemplate(1, ResourceYamlDisplayComponent_ng_template_1_Template, 5, 7, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor);
+        } if (rf & 2) {
+            const _r1 = i0.ɵɵreference(2);
+            i0.ɵɵproperty("ngIf", ctx.hasWrapper)("ngIfElse", _r1);
+        } }, dependencies: [i2.CardComponent, NgIf,
+            FormsModule, i3.NgControlStatus, i3.NgModel, i2.CheckboxComponent, CodeEditorModule, i4.CodeEditorComponent, TranslateModule, i5.TranslatePipe, AsyncPipe,
+            NgTemplateOutlet], styles: ["[_nghost-%COMP%]:not(.dialog-content){display:block;height:calc(100vh - (var(--acl-page-header-height) + 44px) - 161px)}[_nghost-%COMP%]:not(.dialog-content)     .aui-code-editor{min-height:100%}[_nghost-%COMP%]:not(.dialog-content) > .aui-card[_ngcontent-%COMP%]{height:100%}[_nghost-%COMP%]:not(.dialog-content) > .aui-card[_ngcontent-%COMP%]   .aui-card__content[_ngcontent-%COMP%], [_nghost-%COMP%]:not(.dialog-content) > .aui-card[_ngcontent-%COMP%]   aui-code-editor[_ngcontent-%COMP%], [_nghost-%COMP%]:not(.dialog-content) > .aui-card[_ngcontent-%COMP%]   .aui-code-editor[_ngcontent-%COMP%]{height:100%;min-height:100%}[_nghost-%COMP%]{display:block}[_nghost-%COMP%]     aui-card, [_nghost-%COMP%]     .aui-card, [_nghost-%COMP%]     .aui-card__content{height:100%}[_nghost-%COMP%]     .aui-checkbox{margin-right:0}[_nghost-%COMP%]   aui-code-editor[_ngcontent-%COMP%]{height:100%}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ResourceYamlDisplayComponent.prototype, "resource$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ResourceYamlDisplayComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-resource-yaml-display', preserveWhitespaces: false, standalone: true, imports: [
+                    CARD_MODULE,
+                    NgIf,
+                    FormsModule,
+                    CHECKBOX_MODULE,
+                    CodeEditorModule,
+                    TranslateModule,
+                    AsyncPipe,
+                    NgTemplateOutlet,
+                ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<aui-card *ngIf=\"hasWrapper; else content\">\n  <ng-container *ngTemplateOutlet=\"content\" />\n</aui-card>\n<ng-template #content>\n  <aui-code-editor\n    name=\"yaml\"\n    [ngModel]=\"yaml$ | async\"\n    [options]=\"editorOptions\"\n    [actionsConfig]=\"viewActions\"\n  >\n    <ng-container auiCodeEditorToolbarLeft>\n      <aui-checkbox\n        *ngIf=\"conciseEnable\"\n        class=\"aui-code-editor-toolbar__control-button\"\n        [ngModel]=\"concise$$ | async\"\n        (ngModelChange)=\"conciseChange($event)\"\n      >\n        {{ 'preview_concise_yaml' | translate }}\n      </aui-checkbox>\n      <aui-checkbox\n        *ngIf=\"manageFieldActionEnable\"\n        [hidden]=\"concise$$ | async\"\n        class=\"aui-code-editor-toolbar__control-button\"\n        [ngModel]=\"reduce$$ | async\"\n        (ngModelChange)=\"reduce$$.next($event)\"\n      >\n        {{ 'hide_manage_fields_field' | translate }}\n      </aui-checkbox>\n    </ng-container>\n  </aui-code-editor>\n</ng-template>\n", styles: [":host(:not(.dialog-content)){display:block;height:calc(100vh - (var(--acl-page-header-height) + 44px) - 161px)}:host(:not(.dialog-content)) ::ng-deep .aui-code-editor{min-height:100%}:host(:not(.dialog-content))>.aui-card{height:100%}:host(:not(.dialog-content))>.aui-card .aui-card__content,:host(:not(.dialog-content))>.aui-card aui-code-editor,:host(:not(.dialog-content))>.aui-card .aui-code-editor{height:100%;min-height:100%}:host{display:block}:host ::ng-deep aui-card,:host ::ng-deep .aui-card,:host ::ng-deep .aui-card__content{height:100%}:host ::ng-deep .aui-checkbox{margin-right:0}:host aui-code-editor{height:100%}\n"] }]
+    }], function () { return [{ type: i1.YamlUtilService }]; }, { hasWrapper: [{
+            type: Input
+        }], conciseEnable: [{
+            type: Input
+        }], manageFieldActionEnable: [{
+            type: Input
+        }], resource: [{
+            type: Input
+        }], resource$: [] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvZGUvcmVzb3VyY2UteWFtbC1kaXNwbGF5L2NvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb2RlL3Jlc291cmNlLXlhbWwtZGlzcGxheS90ZW1wbGF0ZS5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsV0FBVyxFQUFFLGVBQWUsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMxRCxPQUFPLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3BFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQ0wsZUFBZSxFQUNmLGFBQWEsRUFDYixVQUFVLEVBQ1YsR0FBRyxFQUNILG9CQUFvQixHQUNyQixNQUFNLE1BQU0sQ0FBQztBQUVkLE9BQU8sRUFFTCxlQUFlLEVBRWYsZUFBZSxHQUNoQixNQUFNLHVCQUF1QixDQUFDO0FBQy9CLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNuRSxPQUFPLEVBQUUsV0FBVyxFQUFFLGVBQWUsRUFBRSxNQUFNLHdCQUF3QixDQUFDOzs7Ozs7OztJQ25CcEUsd0JBQTRDOzs7SUFEOUMsZ0NBQTJDO0lBQ3pDLDBHQUE0QztJQUM5QyxpQkFBVzs7OztJQURNLGVBQXlCO0lBQXpCLHNDQUF5Qjs7OztJQVVwQyx1Q0FLQztJQURDLDZOQUFpQixlQUFBLDRCQUFxQixDQUFBLElBQUM7O0lBRXZDLFlBQ0Y7O0lBQUEsaUJBQWU7OztJQUpiLGdFQUE2QjtJQUc3QixlQUNGO0lBREUsNkVBQ0Y7Ozs7SUFDQSx1Q0FNQztJQURDLDZOQUFpQixlQUFBLDRCQUFxQixDQUFBLElBQUM7OztJQUV2QyxZQUNGOztJQUFBLGlCQUFlOzs7SUFOYiwrREFBNEIsa0RBQUE7SUFLNUIsZUFDRjtJQURFLGlGQUNGOzs7SUF2QkosMENBS0M7O0lBQ0MsZ0NBQXVDO0lBQ3JDLDZHQU9lO0lBQ2YsNkdBUWU7SUFDakIsMEJBQWU7SUFDakIsaUJBQWtCOzs7SUF2QmhCLDREQUF5QixpQ0FBQSxxQ0FBQTtJQU1wQixlQUFtQjtJQUFuQiwyQ0FBbUI7SUFRbkIsZUFBNkI7SUFBN0IscURBQTZCOztBRG9CdEMsTUFBTSxPQUFPLDRCQUE0QjtJQW9CdkMsWUFBNkIsUUFBeUI7UUFBekIsYUFBUSxHQUFSLFFBQVEsQ0FBaUI7UUFuQnRELGNBQVMsR0FBRyxJQUFJLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV2QyxhQUFRLEdBQUcsSUFBSSxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7UUFHckMsZUFBVSxHQUFHLElBQUksQ0FBQztRQUdsQixrQkFBYSxHQUFHLElBQUksQ0FBQztRQUdyQiw0QkFBdUIsR0FBRyxJQUFJLENBQUM7UUFVL0IsVUFBSyxHQUFHLGFBQWEsQ0FBQztZQUNwQixJQUFJLENBQUMsU0FBUztZQUNkLElBQUksQ0FBQyxTQUFTO1lBQ2QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLEVBQUUsQ0FBQztTQUMzQyxDQUFDLENBQUMsSUFBSSxDQUNMLEdBQUcsQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsRUFBRSxFQUFFLENBQ2xDLElBQUksQ0FBQyxRQUFRLENBQUMsNEJBQTRCLENBQUMsUUFBUSxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FDdEUsQ0FDRixDQUFDO1FBRUYsa0JBQWEsR0FBRyxlQUFlLENBQUM7UUFDaEMsZ0JBQVcsR0FBRyxXQUFXLENBQUM7SUFiK0IsQ0FBQztJQWUxRCxhQUFhLENBQUMsS0FBYztRQUMxQixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUMzQixJQUFJLEtBQUssRUFBRTtZQUNULElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1NBQzFCO0lBQ0gsQ0FBQzs2RkF4Q1UsNEJBQTRCO29FQUE1Qiw0QkFBNEI7WUN4Q3pDLHVGQUVXO1lBQ1gsOEhBMkJjOzs7WUE5QkgscUNBQWtCLGlCQUFBOzhDRDhCekIsSUFBSTtZQUNKLFdBQVcsd0RBRVgsZ0JBQWdCLDBCQUNoQixlQUFlLG9CQUNmLFNBQVM7WUFDVCxnQkFBZ0I7O0FBc0JUO0lBRFIsZUFBZSxFQUFFOzhCQUNHLFVBQVU7K0RBQWU7dUZBbEJuQyw0QkFBNEI7Y0FsQnhDLFNBQVM7MkJBQ0UsMkJBQTJCLHVCQUdoQixLQUFLLGNBQ2QsSUFBSSxXQUNQO29CQUNQLFdBQVc7b0JBQ1gsSUFBSTtvQkFDSixXQUFXO29CQUNYLGVBQWU7b0JBQ2YsZ0JBQWdCO29CQUNoQixlQUFlO29CQUNmLFNBQVM7b0JBQ1QsZ0JBQWdCO2lCQUNqQixtQkFDZ0IsdUJBQXVCLENBQUMsTUFBTTtrRUFRL0MsVUFBVTtrQkFEVCxLQUFLO1lBSU4sYUFBYTtrQkFEWixLQUFLO1lBSU4sdUJBQXVCO2tCQUR0QixLQUFLO1lBSU4sUUFBUTtrQkFEUCxLQUFLO1lBSUcsU0FBUyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvZGVFZGl0b3JNb2R1bGUgfSBmcm9tICdAYWxhdWRhL2NvZGUtZWRpdG9yJztcbmltcG9ydCB7IENBUkRfTU9EVUxFLCBDSEVDS0JPWF9NT0RVTEUgfSBmcm9tICdAYWxhdWRhL3VpJztcbmltcG9ydCB7IEFzeW5jUGlwZSwgTmdJZiwgTmdUZW1wbGF0ZU91dGxldCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge1xuICBCZWhhdmlvclN1YmplY3QsXG4gIGNvbWJpbmVMYXRlc3QsXG4gIE9ic2VydmFibGUsXG4gIG1hcCxcbiAgZGlzdGluY3RVbnRpbENoYW5nZWQsXG59IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQge1xuICBLdWJlcm5ldGVzUmVzb3VyY2UsXG4gIFlhbWxVdGlsU2VydmljZSxcbiAgQXJyYXlhYmxlLFxuICBPYnNlcnZhYmxlSW5wdXQsXG59IGZyb20gJy4uLy4uL2NvcmUvcHVibGljLWFwaSc7XG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICcuLi8uLi90cmFuc2xhdGUvdHJhbnNsYXRlLm1vZHVsZSc7XG5pbXBvcnQgeyB2aWV3QWN0aW9ucywgeWFtbFJlYWRPcHRpb25zIH0gZnJvbSAnLi4vY29kZS1lZGl0b3ItY29uZmlncyc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2FjbC1yZXNvdXJjZS15YW1sLWRpc3BsYXknLFxuICB0ZW1wbGF0ZVVybDogJ3RlbXBsYXRlLmh0bWwnLFxuICBzdHlsZVVybHM6IFsnc3R5bGVzLnNjc3MnXSxcbiAgcHJlc2VydmVXaGl0ZXNwYWNlczogZmFsc2UsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGltcG9ydHM6IFtcbiAgICBDQVJEX01PRFVMRSxcbiAgICBOZ0lmLFxuICAgIEZvcm1zTW9kdWxlLFxuICAgIENIRUNLQk9YX01PRFVMRSxcbiAgICBDb2RlRWRpdG9yTW9kdWxlLFxuICAgIFRyYW5zbGF0ZU1vZHVsZSxcbiAgICBBc3luY1BpcGUsXG4gICAgTmdUZW1wbGF0ZU91dGxldCxcbiAgXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIFJlc291cmNlWWFtbERpc3BsYXlDb21wb25lbnQ8VCBleHRlbmRzIEt1YmVybmV0ZXNSZXNvdXJjZT4ge1xuICBjb25jaXNlJCQgPSBuZXcgQmVoYXZpb3JTdWJqZWN0KGZhbHNlKTtcblxuICByZWR1Y2UkJCA9IG5ldyBCZWhhdmlvclN1YmplY3QodHJ1ZSk7XG5cbiAgQElucHV0KClcbiAgaGFzV3JhcHBlciA9IHRydWU7XG5cbiAgQElucHV0KClcbiAgY29uY2lzZUVuYWJsZSA9IHRydWU7XG5cbiAgQElucHV0KClcbiAgbWFuYWdlRmllbGRBY3Rpb25FbmFibGUgPSB0cnVlO1xuXG4gIEBJbnB1dCgpXG4gIHJlc291cmNlOiBBcnJheWFibGU8VD47XG5cbiAgQE9ic2VydmFibGVJbnB1dCgpXG4gIHJlYWRvbmx5IHJlc291cmNlJCE6IE9ic2VydmFibGU8QXJyYXlhYmxlPFQ+PjtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHlhbWxVdGlsOiBZYW1sVXRpbFNlcnZpY2UpIHt9XG5cbiAgeWFtbCQgPSBjb21iaW5lTGF0ZXN0KFtcbiAgICB0aGlzLnJlc291cmNlJCxcbiAgICB0aGlzLmNvbmNpc2UkJCxcbiAgICB0aGlzLnJlZHVjZSQkLnBpcGUoZGlzdGluY3RVbnRpbENoYW5nZWQoKSksXG4gIF0pLnBpcGUoXG4gICAgbWFwKChbcmVzb3VyY2UsIGNvbmNpc2UsIHJlZHVjZV0pID0+XG4gICAgICB0aGlzLnlhbWxVdGlsLmdlbmVyYXRlRmlsdGVyZWRZYW1sUmVzb3VyY2UocmVzb3VyY2UsIGNvbmNpc2UsIHJlZHVjZSksXG4gICAgKSxcbiAgKTtcblxuICBlZGl0b3JPcHRpb25zID0geWFtbFJlYWRPcHRpb25zO1xuICB2aWV3QWN0aW9ucyA9IHZpZXdBY3Rpb25zO1xuXG4gIGNvbmNpc2VDaGFuZ2UodmFsdWU6IGJvb2xlYW4pIHtcbiAgICB0aGlzLmNvbmNpc2UkJC5uZXh0KHZhbHVlKTtcbiAgICBpZiAodmFsdWUpIHtcbiAgICAgIHRoaXMucmVkdWNlJCQubmV4dCh0cnVlKTtcbiAgICB9XG4gIH1cbn1cbiIsIjxhdWktY2FyZCAqbmdJZj1cImhhc1dyYXBwZXI7IGVsc2UgY29udGVudFwiPlxuICA8bmctY29udGFpbmVyICpuZ1RlbXBsYXRlT3V0bGV0PVwiY29udGVudFwiIC8+XG48L2F1aS1jYXJkPlxuPG5nLXRlbXBsYXRlICNjb250ZW50PlxuICA8YXVpLWNvZGUtZWRpdG9yXG4gICAgbmFtZT1cInlhbWxcIlxuICAgIFtuZ01vZGVsXT1cInlhbWwkIHwgYXN5bmNcIlxuICAgIFtvcHRpb25zXT1cImVkaXRvck9wdGlvbnNcIlxuICAgIFthY3Rpb25zQ29uZmlnXT1cInZpZXdBY3Rpb25zXCJcbiAgPlxuICAgIDxuZy1jb250YWluZXIgYXVpQ29kZUVkaXRvclRvb2xiYXJMZWZ0PlxuICAgICAgPGF1aS1jaGVja2JveFxuICAgICAgICAqbmdJZj1cImNvbmNpc2VFbmFibGVcIlxuICAgICAgICBjbGFzcz1cImF1aS1jb2RlLWVkaXRvci10b29sYmFyX19jb250cm9sLWJ1dHRvblwiXG4gICAgICAgIFtuZ01vZGVsXT1cImNvbmNpc2UkJCB8IGFzeW5jXCJcbiAgICAgICAgKG5nTW9kZWxDaGFuZ2UpPVwiY29uY2lzZUNoYW5nZSgkZXZlbnQpXCJcbiAgICAgID5cbiAgICAgICAge3sgJ3ByZXZpZXdfY29uY2lzZV95YW1sJyB8IHRyYW5zbGF0ZSB9fVxuICAgICAgPC9hdWktY2hlY2tib3g+XG4gICAgICA8YXVpLWNoZWNrYm94XG4gICAgICAgICpuZ0lmPVwibWFuYWdlRmllbGRBY3Rpb25FbmFibGVcIlxuICAgICAgICBbaGlkZGVuXT1cImNvbmNpc2UkJCB8IGFzeW5jXCJcbiAgICAgICAgY2xhc3M9XCJhdWktY29kZS1lZGl0b3ItdG9vbGJhcl9fY29udHJvbC1idXR0b25cIlxuICAgICAgICBbbmdNb2RlbF09XCJyZWR1Y2UkJCB8IGFzeW5jXCJcbiAgICAgICAgKG5nTW9kZWxDaGFuZ2UpPVwicmVkdWNlJCQubmV4dCgkZXZlbnQpXCJcbiAgICAgID5cbiAgICAgICAge3sgJ2hpZGVfbWFuYWdlX2ZpZWxkc19maWVsZCcgfCB0cmFuc2xhdGUgfX1cbiAgICAgIDwvYXVpLWNoZWNrYm94PlxuICAgIDwvbmctY29udGFpbmVyPlxuICA8L2F1aS1jb2RlLWVkaXRvcj5cbjwvbmctdGVtcGxhdGU+XG4iXX0=

package/esm2022/core/abstract/base-form-container.mjs

@@ -0,0 +1,131 @@
+import { __decorate, __metadata } from "tslib";
+import { NotificationService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { Directive, Injector, Input, ViewChild } from '@angular/core';
+import { FormBuilder, NgForm } from '@angular/forms';
+import { identity } from 'lodash-es';
+import { Observable } from 'rxjs';
+import { createActions, yamlWriteOptions, } from '../../code/code-editor-configs';
+import { InterceptDeactivateService } from '../public-api';
+import { isErrorMessage } from '../types/public-api';
+import { ObservableInput } from '../utils/decorators';
+import { parse, stringify } from '../utils/yaml';
+import * as i0 from "@angular/core";
+const _c0 = ["resourceForm"];
+/**
+ * http://confluence.alauda.cn/display/FRON/Issue-Angular+related
+ * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制
+ */
+export class BaseFormContainer {
+    constructor(injector) {
+        this.isUpdate = false;
+        this.codeEditorOptions = yamlWriteOptions;
+        this.actionsConfig = createActions;
+        this.formView = 'UI';
+        this.submitting = false;
+        this.fillResource = identity;
+        this.notification = injector.get(NotificationService);
+        this.location = injector.get(Location);
+        this.fb = injector.get(FormBuilder);
+        this.interceptDeactivate = injector.get(InterceptDeactivateService);
+        this.form = this.fb.group({ resource: this.fb.control('') });
+    }
+    ngOnInit() {
+        this.resource = this.initResource;
+        this.form.patchValue({
+            resource: this.initResource,
+        });
+    }
+    switchFormView(view) {
+        let resource;
+        if (view === 'UI') {
+            try {
+                resource = this.yamlToResource(this.yaml);
+                this.form.patchValue({
+                    resource,
+                });
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+        else {
+            resource = this.form.get('resource').value;
+            this.originalYaml = this.yaml = this.resourceToYaml(resource);
+        }
+        this.resource = resource;
+        this.formView = view;
+    }
+    cancel(escape) {
+        this.interceptDeactivate.back(escape);
+    }
+    checkForm() {
+        this.ngForm.onSubmit(null);
+        if (this.formView === 'UI' && this.ngForm.invalid) {
+            return false;
+        }
+        if (this.formView === 'YAML') {
+            try {
+                this.resource = this.yamlToResource(this.yaml);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        const resource = this.form.get('resource').value;
+        this.resource = this.fillResource(resource);
+        return true;
+    }
+    yamlToResource(yaml) {
+        try {
+            return parse(yaml);
+        }
+        catch (e) {
+            if (isErrorMessage(e)) {
+                this.notification.error(e.message);
+            }
+            throw e;
+        }
+    }
+    resourceToYaml(resource) {
+        try {
+            if (Array.isArray(resource)) {
+                return resource
+                    .map(r => stringify(r, { blockQuote: 'literal' }))
+                    .join('\n---\r\n\n');
+            }
+            return stringify(resource, { blockQuote: 'literal' });
+        }
+        catch (error) {
+            console.error(error);
+            return '{}';
+        }
+    }
+    updateResource(resource) {
+        this.form.patchValue({ resource });
+        this.resource = resource;
+    }
+    static { this.ɵfac = function BaseFormContainer_Factory(t) { return new (t || BaseFormContainer)(i0.ɵɵdirectiveInject(i0.Injector)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseFormContainer, viewQuery: function BaseFormContainer_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.ngForm = _t.first);
+        } }, inputs: { isUpdate: "isUpdate", initResource: "initResource" } }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], BaseFormContainer.prototype, "initResource$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseFormContainer, [{
+        type: Directive
+    }], function () { return [{ type: i0.Injector }]; }, { isUpdate: [{
+            type: Input
+        }], initResource: [{
+            type: Input
+        }], initResource$: [], ngForm: [{
+            type: ViewChild,
+            args: ['resourceForm', { static: false }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-form-container.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/abstract/base-form-container.ts"],"names":[],"mappings":"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","sourcesContent":["import { NotificationService } from '@alauda/ui';\nimport { Location } from '@angular/common';\nimport { Directive, Injector, Input, OnInit, ViewChild } from '@angular/core';\nimport { FormBuilder, FormGroup, NgForm } from '@angular/forms';\nimport { identity } from 'lodash-es';\nimport { Observable } from 'rxjs';\n\nimport {\n  createActions,\n  yamlWriteOptions,\n} from '../../code/code-editor-configs';\nimport { InterceptDeactivateService } from '../public-api';\nimport { isErrorMessage } from '../types/public-api';\nimport { ObservableInput } from '../utils/decorators';\nimport { parse, stringify } from '../utils/yaml';\n\n/**\n * http://confluence.alauda.cn/display/FRON/Issue-Angular+related\n * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制\n */\n@Directive()\nexport abstract class BaseFormContainer<T = any> implements OnInit {\n  @Input()\n  isUpdate = false;\n\n  @Input()\n  initResource: T;\n\n  @ObservableInput()\n  initResource$: Observable<T>;\n\n  @ViewChild('resourceForm', { static: false })\n  private readonly ngForm: NgForm;\n\n  codeEditorOptions = yamlWriteOptions;\n  actionsConfig = createActions;\n  formView: 'UI' | 'YAML' = 'UI';\n  submitting = false;\n\n  resource: T;\n  yaml: string;\n  // 支持带 '恢复' 的 codeEditor\n  originalYaml: string;\n  fb: FormBuilder;\n  interceptDeactivate: InterceptDeactivateService;\n\n  form: FormGroup;\n\n  protected notification: NotificationService;\n  protected location: Location;\n  protected fillResource: (resource: T) => T = identity;\n\n  abstract submit(): void;\n\n  constructor(injector: Injector) {\n    this.notification = injector.get(NotificationService);\n    this.location = injector.get(Location);\n    this.fb = injector.get(FormBuilder);\n    this.interceptDeactivate = injector.get(InterceptDeactivateService);\n    this.form = this.fb.group({ resource: this.fb.control('') });\n  }\n\n  ngOnInit() {\n    this.resource = this.initResource;\n    this.form.patchValue({\n      resource: this.initResource,\n    });\n  }\n\n  switchFormView(view: 'YAML' | 'UI') {\n    let resource: T;\n    if (view === 'UI') {\n      try {\n        resource = this.yamlToResource(this.yaml);\n        this.form.patchValue({\n          resource,\n        });\n      } catch (err) {\n        console.error(err);\n      }\n    } else {\n      resource = this.form.get('resource').value;\n      this.originalYaml = this.yaml = this.resourceToYaml(resource);\n    }\n    this.resource = resource;\n    this.formView = view;\n  }\n\n  cancel(escape?: boolean) {\n    this.interceptDeactivate.back(escape);\n  }\n\n  protected checkForm() {\n    this.ngForm.onSubmit(null);\n    if (this.formView === 'UI' && this.ngForm.invalid) {\n      return false;\n    }\n    if (this.formView === 'YAML') {\n      try {\n        this.resource = this.yamlToResource(this.yaml);\n        return true;\n      } catch {\n        return false;\n      }\n    }\n    const resource = this.form.get('resource').value as T;\n    this.resource = this.fillResource(resource);\n\n    return true;\n  }\n\n  protected yamlToResource(yaml: string) {\n    try {\n      return parse<T>(yaml);\n    } catch (e) {\n      if (isErrorMessage(e)) {\n        this.notification.error(e.message);\n      }\n      throw e;\n    }\n  }\n\n  protected resourceToYaml(resource: T) {\n    try {\n      if (Array.isArray(resource)) {\n        return resource\n          .map(r => stringify(r, { blockQuote: 'literal' }))\n          .join('\\n---\\r\\n\\n');\n      }\n      return stringify(resource, { blockQuote: 'literal' });\n    } catch (error) {\n      console.error(error);\n      return '{}';\n    }\n  }\n\n  protected updateResource(resource: T) {\n    this.form.patchValue({ resource });\n    this.resource = resource;\n  }\n}\n"]}

package/esm2022/core/abstract/base-nested-form-control.mjs

@@ -0,0 +1,195 @@
+import { coerceAttrBoolean } from '@alauda/ui';
+import { ChangeDetectorRef, Directive, inject, Input, QueryList, ViewChildren, } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm, } from '@angular/forms';
+import { assocPath, identity, mergeDeepRight, path } from 'ramda';
+import { ReplaySubject, startWith, switchMap, Subject, takeUntil, debounceTime, merge, combineLatest, filter, map, tap, take, of, } from 'rxjs';
+import * as i0 from "@angular/core";
+export function createNestedFormControl({ autoEmitChange = false, asyncValidator = false, } = {}) {
+    return class NestedFormControl extends BaseNestedFormControl {
+        constructor() {
+            super(...arguments);
+            this.autoEmitChange = autoEmitChange;
+            this.asyncValidator = asyncValidator;
+        }
+    };
+}
+export class BaseNestedFormControl {
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(val) {
+        this._disabled = coerceAttrBoolean(val);
+    }
+    constructor() {
+        this._disabled = false;
+        this.model = null;
+        this.submitted = false;
+        this.autoEmitChange = false;
+        this.asyncValidator = false;
+        this.cdr = inject(ChangeDetectorRef);
+        this.destroy$$ = new Subject();
+        this.hostForm = inject(NgForm, { optional: true }) ??
+            inject(FormGroupDirective, { optional: true });
+        if (this.hostForm) {
+            this.hostForm.ngSubmit.pipe(takeUntil(this.destroy$$)).subscribe(() => {
+                this.submitted = this.hostForm.submitted;
+                this.onSubmitted?.();
+                this.cdr.markForCheck();
+            });
+        }
+    }
+    ngAfterViewInit() {
+        this.controls.changes
+            .pipe(startWith(this.controls), switchMap((controls) => controls.length
+            ? merge(...controls.toArray().map(control => control.statusChanges))
+            : of(null)), debounceTime(0))
+            .subscribe(() => {
+            this.onValidatorChange?.();
+        });
+        if (this.autoEmitChange) {
+            this.controls.changes
+                .pipe(startWith(this.controls), switchMap((controls) => merge(...controls.toArray().map(control => control.valueChanges))))
+                .pipe(debounceTime(0))
+                .subscribe(() => {
+                this.emitModel(this.model);
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    writeValue(value) {
+        this.model = this.valueIn(value);
+        this.cdr.markForCheck();
+    }
+    validate(_control) {
+        const getErrors = () => this.controls?.reduce((acc, control) => {
+            if (control.errors) {
+                return mergeDeepRight(acc, control.name ? { [control.name]: control.errors } : control.errors);
+            }
+            return acc;
+        }, {});
+        return this.asyncValidator
+            ? combineLatest((this.controls?.toArray() ?? []).map(control => control.statusChanges.pipe(startWith(control.status)))).pipe(debounceTime(0), filter(statuses => statuses.includes('INVALID') || !statuses.includes('PENDING')), take(1), map(() => getErrors()), tap(() => {
+                this.cdr.markForCheck();
+            }))
+            : getErrors();
+    }
+    emitModel(model = this.model) {
+        this.model = model;
+        this.emitValue(this.modelOut(this.model));
+    }
+    emitValue(value) {
+        if (this.onChange) {
+            this.onChange(value);
+        }
+    }
+    valueIn(value) {
+        return value;
+    }
+    modelOut(model) {
+        return model;
+    }
+    static { this.ɵfac = function BaseNestedFormControl_Factory(t) { return new (t || BaseNestedFormControl)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseNestedFormControl, viewQuery: function BaseNestedFormControl_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(NgControl, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.controls = _t);
+        } }, inputs: { disabled: "disabled" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseNestedFormControl, [{
+        type: Directive
+    }], function () { return []; }, { controls: [{
+            type: ViewChildren,
+            args: [NgControl]
+        }], disabled: [{
+            type: Input
+        }] }); })();
+/**
+ * @deprecated use {@link BaseNestedFormControl} instead.
+ */
+export class BaseNestedFormControlPure extends BaseNestedFormControl {
+    constructor() {
+        super();
+        this.model$ = new ReplaySubject(1);
+        this.model$.subscribe(model => {
+            this.model = model;
+            this.cdr.markForCheck();
+        });
+    }
+    writeValue(value) {
+        this.model$.next(this.valueIn(value));
+    }
+    emitValue(value) {
+        if (this.onChange) {
+            this.onChange(value);
+            this.writeValue(value);
+        }
+    }
+    static { this.ɵfac = function BaseNestedFormControlPure_Factory(t) { return new (t || BaseNestedFormControlPure)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseNestedFormControlPure, features: [i0.ɵɵInheritDefinitionFeature] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseNestedFormControlPure, [{
+        type: Directive
+    }], function () { return []; }, null); })();
+function collectPaths(mapper, parent) {
+    return Object.entries(mapper).reduce((acc, [key, value]) => {
+        const path = typeof value === 'string' ? value.split('.') : value;
+        if (Array.isArray(path)) {
+            acc.push([parent.concat(key), path]);
+            return acc;
+        }
+        return acc.concat(collectPaths(path, parent.concat(key)));
+    }, []);
+}
+export function dataTransfer(mapper) {
+    const tuples = collectPaths(mapper, []);
+    let _source;
+    let _target = {};
+    return [
+        source => {
+            _source = source;
+            return tuples.reduce((acc, [left, right]) => {
+                const newValue = path(right, source);
+                if (path(left, acc) === newValue) {
+                    return acc;
+                }
+                return (_target = assocPath(left, newValue, acc));
+            }, _target);
+        },
+        target => {
+            _target = target;
+            return tuples.reduce((acc, [left, right]) => {
+                const newValue = path(left, target);
+                if (path(right, acc) === newValue) {
+                    return acc;
+                }
+                return (_source = assocPath(right, newValue, acc));
+            }, _source);
+        },
+    ];
+}
+function parsePath(path) {
+    return typeof path === 'string' ? path.split('.') : path;
+}
+export function copyValue(from, to, mapper = identity) {
+    const fromPath = parsePath(from);
+    const toPath = parsePath(to);
+    return (object) => assocPath(toPath, mapper(path(fromPath, object)), object);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-nested-form-control.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/abstract/base-nested-form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceAttrBoolean } from '@alauda/ui';\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Directive,\n  inject,\n  Input,\n  OnDestroy,\n  QueryList,\n  ViewChildren,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  ValidationErrors,\n} from '@angular/forms';\nimport { assocPath, identity, mergeDeepRight, path } from 'ramda';\nimport {\n  ReplaySubject,\n  startWith,\n  switchMap,\n  Subject,\n  takeUntil,\n  debounceTime,\n  merge,\n  Observable,\n  combineLatest,\n  filter,\n  map,\n  tap,\n  take,\n  of,\n} from 'rxjs';\n\nexport function createNestedFormControl<V, M = V>({\n  autoEmitChange = false,\n  asyncValidator = false,\n}: {\n  autoEmitChange?: boolean;\n  asyncValidator?: boolean;\n} = {}): // workaround: https://github.com/microsoft/TypeScript/issues/30355\nnew () => BaseNestedFormControl<V, M> {\n  return class NestedFormControl extends BaseNestedFormControl<V, M> {\n    protected override autoEmitChange = autoEmitChange;\n    protected override asyncValidator = asyncValidator;\n  };\n}\n\n@Directive()\nexport class BaseNestedFormControl<V, M = V>\n  implements AfterViewInit, OnDestroy, ControlValueAccessor\n{\n  @ViewChildren(NgControl)\n  protected controls: QueryList<NgControl>;\n\n  @Input()\n  get disabled() {\n    return this._disabled;\n  }\n\n  set disabled(val: boolean | '') {\n    this._disabled = coerceAttrBoolean(val);\n  }\n\n  private _disabled = false;\n\n  onValidatorChange: () => void;\n  onChange: (_: V) => void;\n  onTouched: () => void;\n  onSubmitted: () => void;\n\n  model: M = null;\n  submitted = false;\n\n  protected autoEmitChange = false;\n  protected asyncValidator = false;\n  protected cdr = inject(ChangeDetectorRef);\n  protected destroy$$ = new Subject<void>();\n  protected hostForm =\n    inject(NgForm, { optional: true }) ??\n    inject(FormGroupDirective, { optional: true });\n\n  constructor() {\n    if (this.hostForm) {\n      this.hostForm.ngSubmit.pipe(takeUntil(this.destroy$$)).subscribe(() => {\n        this.submitted = this.hostForm.submitted;\n        this.onSubmitted?.();\n        this.cdr.markForCheck();\n      });\n    }\n  }\n\n  ngAfterViewInit() {\n    this.controls.changes\n      .pipe(\n        startWith(this.controls),\n        switchMap((controls: QueryList<NgControl>) =>\n          controls.length\n            ? merge(...controls.toArray().map(control => control.statusChanges))\n            : of(null),\n        ),\n        debounceTime(0),\n      )\n      .subscribe(() => {\n        this.onValidatorChange?.();\n      });\n\n    if (this.autoEmitChange) {\n      this.controls.changes\n        .pipe(\n          startWith(this.controls),\n          switchMap((controls: QueryList<NgControl>) =>\n            merge(...controls.toArray().map(control => control.valueChanges)),\n          ),\n        )\n        .pipe(debounceTime(0))\n        .subscribe(() => {\n          this.emitModel(this.model);\n        });\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  registerOnValidatorChange(fn: () => void) {\n    this.onValidatorChange = fn;\n  }\n\n  registerOnChange(fn: (_: V) => void) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void) {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n\n  writeValue(value: V) {\n    this.model = this.valueIn(value);\n    this.cdr.markForCheck();\n  }\n\n  validate(\n    _control?: AbstractControl,\n  ): ValidationErrors | null | Observable<ValidationErrors | null> {\n    const getErrors = () =>\n      this.controls?.reduce((acc, control) => {\n        if (control.errors) {\n          return mergeDeepRight(\n            acc,\n            control.name ? { [control.name]: control.errors } : control.errors,\n          );\n        }\n        return acc;\n      }, {} as ValidationErrors);\n\n    return this.asyncValidator\n      ? combineLatest(\n          (this.controls?.toArray() ?? []).map(control =>\n            control.statusChanges.pipe(startWith(control.status)),\n          ),\n        ).pipe(\n          debounceTime(0),\n          filter(\n            statuses =>\n              statuses.includes('INVALID') || !statuses.includes('PENDING'),\n          ),\n          take(1),\n          map(() => getErrors()),\n          tap(() => {\n            this.cdr.markForCheck();\n          }),\n        )\n      : getErrors();\n  }\n\n  emitModel(model: M = this.model) {\n    this.model = model;\n    this.emitValue(this.modelOut(this.model));\n  }\n\n  emitValue(value: V) {\n    if (this.onChange) {\n      this.onChange(value);\n    }\n  }\n\n  protected valueIn(value: V): M {\n    return value as any;\n  }\n\n  protected modelOut(model: M): V {\n    return model as any;\n  }\n}\n\n/**\n * @deprecated use {@link BaseNestedFormControl} instead.\n */\n@Directive()\nexport class BaseNestedFormControlPure<V, M = V> extends BaseNestedFormControl<\n  V,\n  M\n> {\n  model$ = new ReplaySubject<M>(1);\n\n  constructor() {\n    super();\n\n    this.model$.subscribe(model => {\n      this.model = model;\n      this.cdr.markForCheck();\n    });\n  }\n\n  override writeValue(value: V) {\n    this.model$.next(this.valueIn(value));\n  }\n\n  override emitValue(value: V) {\n    if (this.onChange) {\n      this.onChange(value);\n      this.writeValue(value);\n    }\n  }\n}\n\ntype Path = string | Array<string | number>;\n\ninterface Mapper {\n  [x: string]: Mapper | Path;\n}\n\ntype PathTuple = [string[], string[]];\n\nfunction collectPaths(mapper: Mapper, parent: string[]): PathTuple[] {\n  return Object.entries(mapper).reduce((acc, [key, value]) => {\n    const path = typeof value === 'string' ? value.split('.') : value;\n    if (Array.isArray(path)) {\n      acc.push([parent.concat(key), path]);\n      return acc;\n    }\n    return acc.concat(collectPaths(path, parent.concat(key)));\n  }, []);\n}\n\nexport function dataTransfer<\n  S extends object,\n  T extends object,\n  M extends Record<keyof T, Path | Mapper> = Record<keyof T, Path | Mapper>,\n>(mapper: M): [(source: S) => T, (target: T) => S] {\n  const tuples = collectPaths(mapper, []);\n  let _source: S;\n  let _target: T = {} as T;\n  return [\n    source => {\n      _source = source;\n      return tuples.reduce((acc, [left, right]) => {\n        const newValue = path<unknown>(right, source);\n\n        if (path(left, acc) === newValue) {\n          return acc;\n        }\n\n        return (_target = assocPath<unknown, T>(left, newValue, acc));\n      }, _target);\n    },\n    target => {\n      _target = target;\n      return tuples.reduce((acc, [left, right]) => {\n        const newValue = path<unknown>(left, target);\n\n        if (path(right, acc) === newValue) {\n          return acc;\n        }\n\n        return (_source = assocPath<unknown, S>(right, newValue, acc));\n      }, _source);\n    },\n  ];\n}\n\nfunction parsePath(path: Path): Array<string | number> {\n  return typeof path === 'string' ? path.split('.') : path;\n}\n\nexport function copyValue<T extends object>(\n  from: Path,\n  to: Path,\n  mapper: (v: any) => any = identity,\n) {\n  const fromPath = parsePath(from);\n  const toPath = parsePath(to);\n  return (object: T) =>\n    assocPath(toPath, mapper(path(fromPath, object)), object);\n}\n"]}

package/esm2022/core/abstract/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './base-form-container';
+export * from './base-nested-form-control';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL2Fic3RyYWN0L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXNlLWZvcm0tY29udGFpbmVyJztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1uZXN0ZWQtZm9ybS1jb250cm9sJztcbiJdfQ==

package/esm2022/core/components/public-api.mjs

@@ -0,0 +1,7 @@
+export * from './tree/tree/component';
+export * from './tree/node/component';
+export * from './tree/outlet';
+export * from './tree/padding';
+export * from './tree/toggle';
+export * from './tree/module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL2NvbXBvbmVudHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHJlZS90cmVlL2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUvbm9kZS9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90cmVlL291dGxldCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUvcGFkZGluZyc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUvdG9nZ2xlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJlZS9tb2R1bGUnO1xuIl19

package/esm2022/core/components/tree/module.mjs

@@ -0,0 +1,41 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NestedTreeNodeComponent, TreeNodeDefDirective, } from './node/component';
+import { TreeNodeOutletDirective } from './outlet';
+import { TreeNodePaddingDirective } from './padding';
+import { TreeNodeToggleDirective } from './toggle';
+import { TreeComponent } from './tree/component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    TreeComponent,
+    TreeNodeDefDirective,
+    TreeNodePaddingDirective,
+    TreeNodeOutletDirective,
+    TreeNodeToggleDirective,
+    NestedTreeNodeComponent,
+];
+export class TreeViewModule {
+    static { this.ɵfac = function TreeViewModule_Factory(t) { return new (t || TreeViewModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: TreeViewModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TreeViewModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: [COMPONENTS],
+                exports: [COMPONENTS],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(TreeViewModule, { declarations: [TreeComponent,
+        TreeNodeDefDirective,
+        TreeNodePaddingDirective,
+        TreeNodeOutletDirective,
+        TreeNodeToggleDirective,
+        NestedTreeNodeComponent], imports: [CommonModule], exports: [TreeComponent,
+        TreeNodeDefDirective,
+        TreeNodePaddingDirective,
+        TreeNodeOutletDirective,
+        TreeNodeToggleDirective,
+        NestedTreeNodeComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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