@solar-angular/ui-zorro 1.0.0

package/README.md

@@ -0,0 +1,7 @@
+# ui-zorro
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test ui-zorro` to execute the unit tests.

package/crud/editor-drawer/editor-drawer.component.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from '../editor';
+import * as i0 from "@angular/core";
+export declare class SunEditorDrawer<T extends Record<string, any>> {
+    editor: Editor<T>;
+    width: string | number;
+    primaryKey: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SunEditorDrawer<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SunEditorDrawer<any>, "sun-editor-drawer", never, { "editor": { "alias": "editor"; "required": false; }; "width": { "alias": "width"; "required": false; }; "primaryKey": { "alias": "primaryKey"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/crud/editor-drawer/index.d.ts

@@ -0,0 +1 @@
+export * from './editor-drawer.component';

package/crud/editor.d.ts

@@ -0,0 +1,35 @@
+import { FormGroup } from '@angular/forms';
+import { AbstractFormGroupSchema } from '@fluent-form/core';
+import { Observable } from 'rxjs';
+export declare class Editor<T> {
+    private _visible;
+    /** 模型初始值 */
+    originalModel: T;
+    model: T;
+    loading: boolean;
+    schema: AbstractFormGroupSchema;
+    /** 是否在保存完之后固定抽屉 */
+    pin: boolean;
+    form?: FormGroup;
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * 自动控制 loading 状态
+     */
+    withLoading<X>(): (observable: Observable<X>) => Observable<X>;
+    /**
+     * next 时自动重置表单 或 收起编辑器
+     */
+    withAttach<X>(): (observable: Observable<X>) => Observable<X>;
+    /**
+     * 呈现编辑器
+     */
+    present(): void;
+    /**
+     * 关闭编辑器
+     */
+    dismiss(): void;
+    togglePin(): void;
+    reset(): void;
+    fill(model: T): void;
+}

package/crud/index.d.ts

@@ -0,0 +1,4 @@
+export * from './editor';
+export * from './editor-drawer';
+export * from './page';
+export * from './searcher';

package/crud/page.d.ts

@@ -0,0 +1,52 @@
+import { MessageService } from '@solar-angular/ui-zorro/message';
+import { Menu } from '@solar-kit/planets/earth';
+import { Observable } from 'rxjs';
+import { Editor } from './editor';
+import { Searcher } from './searcher';
+/**
+ * 增删改查页面
+ * @template T Searcher 的模型类型
+ * @template U Editor 的模型类型，默认为 T
+ * @template V Data 的模型类型，默认为 U
+ */
+export declare abstract class CrudPage<T, U = T, V = U> {
+    protected data: V[];
+    protected pageSize: number;
+    protected pageNo: number;
+    protected loading: boolean;
+    protected searcher: Searcher<T>;
+    protected editor: Editor<U>;
+    /** 当前页面的菜单列 */
+    readonly menus$: Observable<Menu[]>;
+    readonly message: MessageService;
+    protected withTableLoading<X>(): (observable: Observable<X>) => Observable<X>;
+    /**
+     * {@link MessageService.withLoading()} 的快捷方式
+     * @param content
+     */
+    protected withLoading<X>(content?: string): (observable: Observable<X>) => Observable<X>;
+    /**
+     * {@link MessageService.withDeleteLoading()} 的快捷方式
+     * @param content
+     */
+    protected withDeleteLoading<X>(): (observable: Observable<X>) => Observable<X>;
+    /**
+     * {@link MessageService.withSaveLoading()} 的快捷方式
+     * @param content
+     */
+    protected withSaveLoading<X>(): (observable: Observable<X>) => Observable<X>;
+    /**
+     * 编辑
+     * @param entity
+     */
+    protected edit(entity: U): void;
+}
+/**
+ * 带分页的增删改查页面
+ * @template T Searcher 的模型类型
+ * @template U Editor 的模型类型，默认为 T
+ * @template V Data 的模型类型，默认为 U
+ */
+export declare abstract class PagingCrudPage<T, U = T, V = U> extends CrudPage<T, U, V> {
+    protected totalSize: number;
+}

package/crud/searcher.d.ts

@@ -0,0 +1,8 @@
+import { FormGroup } from '@angular/forms';
+import { AbstractFormGroupSchema } from '@fluent-form/core';
+export declare class Searcher<T> {
+    form?: FormGroup;
+    model: Partial<T>;
+    schema: AbstractFormGroupSchema;
+    reset(): void;
+}

package/esm2022/crud/editor-drawer/editor-drawer.component.mjs

@@ -0,0 +1,34 @@
+import { Component, Input } from '@angular/core';
+import { NzDrawerModule } from 'ng-zorro-antd/drawer';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import { NzSpinModule } from 'ng-zorro-antd/spin';
+import { NzTypographyModule } from 'ng-zorro-antd/typography';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-zorro-antd/drawer";
+import * as i2 from "ng-zorro-antd/spin";
+import * as i3 from "ng-zorro-antd/icon";
+import * as i4 from "ng-zorro-antd/typography";
+export class SunEditorDrawer {
+    constructor() {
+        this.width = 600;
+        this.primaryKey = 'id';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SunEditorDrawer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: SunEditorDrawer, isStandalone: true, selector: "sun-editor-drawer", inputs: { editor: "editor", width: "width", primaryKey: "primaryKey" }, ngImport: i0, template: "<nz-drawer\n  nzWrapClassName=\"sun-editor-drawer-wrapper\"\n  [nzWidth]=\"width\"\n  [nzClosable]=\"false\"\n  [nzTitle]=\"editorTitle\"\n  [nzFooter]=\"editorFooter\"\n  [(nzVisible)]=\"editor.visible\"\n  (nzOnClose)=\"editor.visible = false\">\n  <nz-spin *nzDrawerContent [nzSpinning]=\"editor.loading\">\n    <ng-content />\n  </nz-spin>\n</nz-drawer>\n\n<ng-template #editorTitle>\n  <div>{{ editor.model[primaryKey] ? '\u7F16\u8F91\u6761\u76EE' : '\u65B0\u589E\u6761\u76EE' }}</div>\n\n  <span nz-icon nzType=\"pushpin\" [nzTheme]=\"editor.pin ? 'twotone' : 'outline'\" (click)=\"editor.togglePin()\"></span>\n</ng-template>\n\n<ng-template #editorFooter>\n  <small nz-typography nzType=\"secondary\">\n    \u6CE8\u610F\uFF1A\u6807\u7B7E\u4E0A\u5E26\u6709\n    <span nz-typography nzType=\"danger\" style=\"font-family: SimSun, sans-serif\">*</span>\n    \u7B26\u53F7\u7684\u9879\u76EE\u4E3A\u5FC5\u586B\u9879\n  </small>\n</ng-template>\n", styles: ["::ng-deep .sun-editor-drawer-wrapper .ant-drawer-title{display:flex;justify-content:space-between;align-items:center}\n"], dependencies: [{ kind: "ngmodule", type: NzDrawerModule }, { kind: "component", type: i1.NzDrawerComponent, selector: "nz-drawer", inputs: ["nzContent", "nzCloseIcon", "nzClosable", "nzMaskClosable", "nzMask", "nzCloseOnNavigation", "nzNoAnimation", "nzKeyboard", "nzTitle", "nzExtra", "nzFooter", "nzPlacement", "nzSize", "nzMaskStyle", "nzBodyStyle", "nzWrapClassName", "nzWidth", "nzHeight", "nzZIndex", "nzOffsetX", "nzOffsetY", "nzVisible"], outputs: ["nzOnViewInit", "nzOnClose", "nzVisibleChange"], exportAs: ["nzDrawer"] }, { kind: "directive", type: i1.NzDrawerContentDirective, selector: "[nzDrawerContent]", exportAs: ["nzDrawerContent"] }, { kind: "ngmodule", type: NzSpinModule }, { kind: "component", type: i2.NzSpinComponent, selector: "nz-spin", inputs: ["nzIndicator", "nzSize", "nzTip", "nzDelay", "nzSimple", "nzSpinning"], exportAs: ["nzSpin"] }, { kind: "ngmodule", type: NzIconModule }, { kind: "directive", type: i3.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "ngmodule", type: NzTypographyModule }, { kind: "component", type: i4.NzTypographyComponent, selector: "  nz-typography,  [nz-typography],  p[nz-paragraph],  span[nz-text],  h1[nz-title], h2[nz-title], h3[nz-title], h4[nz-title]  ", inputs: ["nzCopyable", "nzEditable", "nzDisabled", "nzExpandable", "nzEllipsis", "nzCopyTooltips", "nzCopyIcons", "nzEditTooltip", "nzEditIcon", "nzContent", "nzEllipsisRows", "nzType", "nzCopyText", "nzSuffix"], outputs: ["nzContentChange", "nzCopy", "nzExpandChange", "nzOnEllipsis"], exportAs: ["nzTypography"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SunEditorDrawer, decorators: [{
+            type: Component,
+            args: [{ selector: 'sun-editor-drawer', standalone: true, imports: [
+                        NzDrawerModule,
+                        NzSpinModule,
+                        NzIconModule,
+                        NzTypographyModule
+                    ], template: "<nz-drawer\n  nzWrapClassName=\"sun-editor-drawer-wrapper\"\n  [nzWidth]=\"width\"\n  [nzClosable]=\"false\"\n  [nzTitle]=\"editorTitle\"\n  [nzFooter]=\"editorFooter\"\n  [(nzVisible)]=\"editor.visible\"\n  (nzOnClose)=\"editor.visible = false\">\n  <nz-spin *nzDrawerContent [nzSpinning]=\"editor.loading\">\n    <ng-content />\n  </nz-spin>\n</nz-drawer>\n\n<ng-template #editorTitle>\n  <div>{{ editor.model[primaryKey] ? '\u7F16\u8F91\u6761\u76EE' : '\u65B0\u589E\u6761\u76EE' }}</div>\n\n  <span nz-icon nzType=\"pushpin\" [nzTheme]=\"editor.pin ? 'twotone' : 'outline'\" (click)=\"editor.togglePin()\"></span>\n</ng-template>\n\n<ng-template #editorFooter>\n  <small nz-typography nzType=\"secondary\">\n    \u6CE8\u610F\uFF1A\u6807\u7B7E\u4E0A\u5E26\u6709\n    <span nz-typography nzType=\"danger\" style=\"font-family: SimSun, sans-serif\">*</span>\n    \u7B26\u53F7\u7684\u9879\u76EE\u4E3A\u5FC5\u586B\u9879\n  </small>\n</ng-template>\n", styles: ["::ng-deep .sun-editor-drawer-wrapper .ant-drawer-title{display:flex;justify-content:space-between;align-items:center}\n"] }]
+        }], propDecorators: { editor: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], primaryKey: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/crud/editor-drawer/index.mjs

@@ -0,0 +1,2 @@
+export * from './editor-drawer.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9jcnVkL2VkaXRvci1kcmF3ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZWRpdG9yLWRyYXdlci5jb21wb25lbnQnO1xuIl19

package/esm2022/crud/editor.mjs

@@ -0,0 +1,65 @@
+import { form } from '@fluent-form/core';
+import { finalize, tap } from 'rxjs';
+export class Editor {
+    constructor() {
+        this._visible = false;
+        /** 模型初始值 */
+        this.originalModel = {};
+        this.model = {};
+        this.loading = false;
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.schema = form(() => { });
+        /** 是否在保存完之后固定抽屉 */
+        this.pin = false;
+    }
+    get visible() {
+        return this._visible;
+    }
+    set visible(value) {
+        // 手动判断一下，因为双向绑定的原因，这里会被设置两次
+        if (this._visible !== value) {
+            if (!value) {
+                this.reset(); // 关闭的时候自动重置
+            }
+        }
+        this._visible = value;
+    }
+    /**
+     * 自动控制 loading 状态
+     */
+    withLoading() {
+        this.loading = true;
+        return (observable) => {
+            return observable.pipe(finalize(() => this.loading = false));
+        };
+    }
+    /**
+     * next 时自动重置表单 或 收起编辑器
+     */
+    withAttach() {
+        return (observable) => observable.pipe(tap(() => this.pin ? this.reset() : this.dismiss()));
+    }
+    /**
+     * 呈现编辑器
+     */
+    present() {
+        this.visible = true;
+    }
+    /**
+     * 关闭编辑器
+     */
+    dismiss() {
+        this.visible = false;
+    }
+    togglePin() {
+        this.pin = !this.pin;
+    }
+    reset() {
+        this.fill({});
+    }
+    fill(model) {
+        this.originalModel = model;
+        this.model = model;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/crud/index.mjs

@@ -0,0 +1,5 @@
+export * from './editor';
+export * from './editor-drawer';
+export * from './page';
+export * from './searcher';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9jcnVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VkaXRvcic7XG5leHBvcnQgKiBmcm9tICcuL2VkaXRvci1kcmF3ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9wYWdlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoZXInO1xuIl19

package/esm2022/crud/page.mjs

@@ -0,0 +1,69 @@
+import { inject } from '@angular/core';
+import { MenuService } from '@solar-angular/planets/earth';
+import { MessageService } from '@solar-angular/ui-zorro/message';
+import { finalize, shareReplay } from 'rxjs';
+import { Editor } from './editor';
+import { Searcher } from './searcher';
+/**
+ * 增删改查页面
+ * @template T Searcher 的模型类型
+ * @template U Editor 的模型类型，默认为 T
+ * @template V Data 的模型类型，默认为 U
+ */
+export class CrudPage {
+    constructor() {
+        this.data = [];
+        this.pageSize = 10;
+        this.pageNo = 1;
+        this.loading = false;
+        this.searcher = new Searcher();
+        this.editor = new Editor();
+        /** 当前页面的菜单列 */
+        this.menus$ = inject(MenuService).menus$.pipe(shareReplay(1));
+        this.message = inject(MessageService);
+    }
+    withTableLoading() {
+        return (observable) => {
+            this.loading = true;
+            return observable.pipe(finalize(() => this.loading = false));
+        };
+    }
+    /**
+     * {@link MessageService.withLoading()} 的快捷方式
+     * @param content
+     */
+    withLoading(content) {
+        return this.message.withLoading(content);
+    }
+    /**
+     * {@link MessageService.withDeleteLoading()} 的快捷方式
+     * @param content
+     */
+    withDeleteLoading() {
+        return this.message.withDeleteLoading();
+    }
+    /**
+     * {@link MessageService.withSaveLoading()} 的快捷方式
+     * @param content
+     */
+    withSaveLoading() {
+        return this.message.withSaveLoading();
+    }
+    /**
+     * 编辑
+     * @param entity
+     */
+    edit(entity) {
+        this.editor.fill(entity);
+        this.editor.present();
+    }
+}
+/**
+ * 带分页的增删改查页面
+ * @template T Searcher 的模型类型
+ * @template U Editor 的模型类型，默认为 T
+ * @template V Data 的模型类型，默认为 U
+ */
+export class PagingCrudPage extends CrudPage {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/crud/searcher.mjs

@@ -0,0 +1,9 @@
+export class Searcher {
+    constructor() {
+        this.model = {};
+    }
+    reset() {
+        this.form?.reset({});
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9jcnVkL3NlYXJjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxRQUFRO0lBQXJCO1FBRUUsVUFBSyxHQUFlLEVBQUUsQ0FBQztJQU96QixDQUFDO0lBSEMsS0FBSztRQUNILElBQUksQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZCLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZvcm1Hcm91cCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IEFic3RyYWN0Rm9ybUdyb3VwU2NoZW1hIH0gZnJvbSAnQGZsdWVudC1mb3JtL2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgU2VhcmNoZXI8VD4ge1xuICBmb3JtPzogRm9ybUdyb3VwO1xuICBtb2RlbDogUGFydGlhbDxUPiA9IHt9O1xuXG4gIHNjaGVtYSE6IEFic3RyYWN0Rm9ybUdyb3VwU2NoZW1hO1xuXG4gIHJlc2V0KCkge1xuICAgIHRoaXMuZm9ybT8ucmVzZXQoe30pO1xuICB9XG59XG4iXX0=

package/esm2022/crud/solar-angular-ui-zorro-crud.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sYXItYW5ndWxhci11aS16b3Jyby1jcnVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvdWktem9ycm8vY3J1ZC9zb2xhci1hbmd1bGFyLXVpLXpvcnJvLWNydWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/fluent-form/components.mjs

@@ -0,0 +1,15 @@
+import { button } from '@fluent-form/ui-zorro';
+export function searchButton() {
+    return button().icon('search').content('查询').type('primary');
+}
+export function addButton() {
+    return button().icon('plus').content('新增').type('primary').mode('button');
+}
+export function saveButton() {
+    return button()
+        .content('保存')
+        .type('primary')
+        .variants({ block: true })
+        .disabled(({ control }) => control.invalid);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fluent-form/controls.mjs

@@ -0,0 +1,104 @@
+import { cascader, checkboxGroup, datePicker, dateRangePicker, number, radioGroup, select, text, toggle } from '@fluent-form/ui-zorro';
+import { levels2tree, tree2list } from '@solar-angular/core';
+export function cellphoneText(key = 'cellphone', length = 11) {
+    return text(key).type('tel').length(length);
+}
+export function integer(key) {
+    return number(key).precision(0);
+}
+export function enabledToggle(key = 'enabled', defaultValue = true) {
+    return toggle(key).placeholder(['有效', '无效']).defaultValue(defaultValue);
+}
+export function finishedToggle(key = 'finished', defaultValue = false) {
+    return toggle(key).placeholder(['已完成', '未完成']).defaultValue(defaultValue);
+}
+export function genderRadioGroup(key = 'gender') {
+    return radioGroup(key).options([
+        { label: '女', value: 0 /* Gender.Woman */ },
+        { label: '男', value: 1 /* Gender.Man */ }
+    ]);
+}
+export function categoryCascader(key, channels, categories) {
+    return entityCascader(key).options(levels2tree([channels, categories], 'channel'));
+}
+/**
+ * 通用的实体多选框
+ *
+ * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'
+ * @param key
+ */
+export function entityCheckboxGroup(key) {
+    return checkboxGroup(key).config({ labelProperty: 'fullName', valueProperty: 'id' });
+}
+/**
+ * 通用的实体单选框
+ *
+ * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'
+ * @param key
+ */
+export function entityRadioGroup(key) {
+    return radioGroup(key).config({ labelProperty: 'fullName', valueProperty: 'id' });
+}
+/**
+ * 通用的实体选择器
+ *
+ * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'
+ * @param key
+ */
+export function entitySelect(key) {
+    return select(key).config({ labelProperty: 'fullName', valueProperty: 'id' });
+}
+/**
+ * 通用的实体联级选择器
+ *
+ * - 多字段模式下不支持以下选项：
+ *   - 不支持使用函数作为 options
+ *   - 不支持 fetchOptions 选项
+ *
+ * options 选项可以使用 `list2tree()` 或 `levels2tree()` 来构造
+ *
+ * @param key
+ */
+export function entityCascader(key) {
+    let list;
+    return cascader(key)
+        .trigger('hover')
+        .mapper({
+        parser: (value, schema) => {
+            if (!value)
+                return null;
+            // 如果输入的是数组，则说明当前是多字段模式，不需要做处理
+            if (Array.isArray(value))
+                return value;
+            // 如果输入的是叶子节点，我们需要转为 [父节点, ..., 叶子节点]
+            list ??= tree2list(schema.options);
+            // 找到选中的叶子节点
+            let node = list.find(node => node.id === value && node.isLeaf);
+            const levels = [];
+            while (node) {
+                levels.unshift(node.id);
+                node = node.parent;
+            }
+            return levels;
+        },
+        formatter: value => {
+            // 多字段模式，不需要处理
+            if (Array.isArray(key))
+                return value;
+            // 输出的是节点数组，我们只要叶子节点
+            return value?.[value.length - 1];
+        }
+    })
+        .config({ labelProperty: 'fullName', valueProperty: 'id' });
+}
+export function datetimePicker(key, format = 'yyyy-MM-dd HH:mm') {
+    return datePicker(key)
+        .time({ nzFormat: 'HH:mm' })
+        .format(format);
+}
+export function datetimeRangePicker(key, format = 'yyyy-MM-dd HH:mm') {
+    return dateRangePicker(key)
+        .time({ nzFormat: 'HH:mm' })
+        .format(format);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controls.js","sourceRoot":"","sources":["../../../../packages/ui-zorro/fluent-form/controls.ts"],"names":[],"mappings":"AACA,OAAO,EAAuN,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC5V,OAAO,EAAY,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKvE,MAAM,UAAU,aAAa,CAAC,GAAG,GAAG,WAAW,EAAE,MAAM,GAAG,EAAE;IAC1D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,GAAoB;IAC1C,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,MAAuB,SAAS,EAAE,YAAY,GAAG,IAAI;IACjF,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;AAC1E,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,MAAuB,UAAU,EAAE,YAAY,GAAG,KAAK;IACpF,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,GAAG,GAAG,QAAQ;IAC7C,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;QAC7B,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,sBAAc,EAAE;QACnC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,oBAAY,EAAE;KAClC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,GAAc,EAAE,QAAmB,EAAE,UAAsB;IAC1F,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AACrF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAW;IAC7C,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;AACvF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAW;IAC1C,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;AACpF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,GAAoB;IAC/C,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;AAChF,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,GAAc;IAC3C,IAAI,IAAgB,CAAC;IAErB,OAAO,QAAQ,CAAC,GAAG,CAAC;SACjB,OAAO,CAAC,OAAO,CAAC;SAChB,MAAM,CAAC;QACN,MAAM,EAAE,CAAC,KAA+C,EAAE,MAAM,EAAE,EAAE;YAClE,IAAI,CAAC,KAAK;gBAAE,OAAO,IAAI,CAAC;YAExB,8BAA8B;YAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC;YAEvC,qCAAqC;YACrC,IAAI,KAAK,SAAS,CAAE,MAAgC,CAAC,OAAqB,CAAC,CAAC;YAC5E,YAAY;YACZ,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC;YAE/D,MAAM,MAAM,GAAG,EAAE,CAAC;YAElB,OAAO,IAAI,EAAE,CAAC;gBACZ,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBACxB,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;YACrB,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,SAAS,EAAE,KAAK,CAAC,EAAE;YACjB,cAAc;YACd,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YAErC,oBAAoB;YACpB,OAAO,KAAK,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACnC,CAAC;KACF,CAAC;SACD,MAAM,CAAC,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,MAAM,GAAG,kBAAkB;IACrE,OAAO,UAAU,CAAC,GAAG,CAAC;SACnB,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;SAC3B,MAAM,CAAC,MAAM,CAAC,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,GAAc,EAAE,MAAM,GAAG,kBAAkB;IAC7E,OAAO,eAAe,CAAC,GAAG,CAAC;SACxB,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;SAC3B,MAAM,CAAC,MAAM,CAAC,CAAC;AACpB,CAAC","sourcesContent":["import { SchemaKey, SingleSchemaKey, UnstableBuilder } from '@fluent-form/core';\nimport { CascaderControlSchema, CheckboxGroupControlSchema, DatePickerControlSchema, DateRangePickerControlSchema, NumberControlSchema, RadioGroupControlSchema, SelectControlSchema, TextControlSchema, ToggleControlSchema, cascader, checkboxGroup, datePicker, dateRangePicker, number, radioGroup, select, text, toggle } from '@fluent-form/ui-zorro';\nimport { TreeNode, levels2tree, tree2list } from '@solar-angular/core';\nimport { Category, Channel } from '@solar-kit/planets/earth';\nimport { Gender } from '@solar-kit/planets/sun';\nimport { KindOrKey } from './typing';\n\nexport function cellphoneText(key = 'cellphone', length = 11): UnstableBuilder<TextControlSchema, KindOrKey | 'type' | 'length'> {\n  return text(key).type('tel').length(length);\n}\n\nexport function integer(key: SingleSchemaKey): UnstableBuilder<NumberControlSchema, KindOrKey | 'precision'> {\n  return number(key).precision(0);\n}\n\nexport function enabledToggle(key: SingleSchemaKey = 'enabled', defaultValue = true): UnstableBuilder<ToggleControlSchema, KindOrKey | 'placeholder' | 'defaultValue'> {\n  return toggle(key).placeholder(['有效', '无效']).defaultValue(defaultValue);\n}\n\nexport function finishedToggle(key: SingleSchemaKey = 'finished', defaultValue = false): UnstableBuilder<ToggleControlSchema, KindOrKey | 'placeholder' | 'defaultValue'> {\n  return toggle(key).placeholder(['已完成', '未完成']).defaultValue(defaultValue);\n}\n\nexport function genderRadioGroup(key = 'gender'): UnstableBuilder<RadioGroupControlSchema, KindOrKey | 'options'> {\n  return radioGroup(key).options([\n    { label: '女', value: Gender.Woman },\n    { label: '男', value: Gender.Man }\n  ]);\n}\n\nexport function categoryCascader(key: SchemaKey, channels: Channel[], categories: Category[]): UnstableBuilder<CascaderControlSchema, KindOrKey | 'options' | 'trigger' | 'config' | 'mapper'> {\n  return entityCascader(key).options(levels2tree([channels, categories], 'channel'));\n}\n\n/**\n * 通用的实体多选框\n *\n * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'\n * @param key\n */\nexport function entityCheckboxGroup(key: string): UnstableBuilder<CheckboxGroupControlSchema, KindOrKey | 'config'> {\n  return checkboxGroup(key).config({ labelProperty: 'fullName', valueProperty: 'id' });\n}\n\n/**\n * 通用的实体单选框\n *\n * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'\n * @param key\n */\nexport function entityRadioGroup(key: string): UnstableBuilder<RadioGroupControlSchema, KindOrKey | 'config'> {\n  return radioGroup(key).config({ labelProperty: 'fullName', valueProperty: 'id' });\n}\n\n/**\n * 通用的实体选择器\n *\n * 已经配置了 labelProperty: 'fullName', valueProperty: 'id'\n * @param key\n */\nexport function entitySelect(key: SingleSchemaKey): UnstableBuilder<SelectControlSchema, KindOrKey | 'config'> {\n  return select(key).config({ labelProperty: 'fullName', valueProperty: 'id' });\n}\n\n/**\n * 通用的实体联级选择器\n *\n * - 多字段模式下不支持以下选项：\n *   - 不支持使用函数作为 options\n *   - 不支持 fetchOptions 选项\n *\n * options 选项可以使用 `list2tree()` 或 `levels2tree()` 来构造\n *\n * @param key\n */\nexport function entityCascader(key: SchemaKey): UnstableBuilder<CascaderControlSchema, KindOrKey | 'trigger' | 'config' | 'mapper'> {\n  let list: TreeNode[];\n\n  return cascader(key)\n    .trigger('hover')\n    .mapper({\n      parser: (value: TreeNode['id'] | TreeNode['id'][] | null, schema) => {\n        if (!value) return null;\n\n        // 如果输入的是数组，则说明当前是多字段模式，不需要做处理\n        if (Array.isArray(value)) return value;\n\n        // 如果输入的是叶子节点，我们需要转为 [父节点, ..., 叶子节点]\n        list ??= tree2list((schema as CascaderControlSchema).options as TreeNode[]);\n        // 找到选中的叶子节点\n        let node = list.find(node => node.id === value && node.isLeaf);\n\n        const levels = [];\n\n        while (node) {\n          levels.unshift(node.id);\n          node = node.parent;\n        }\n\n        return levels;\n      },\n      formatter: value => {\n        // 多字段模式，不需要处理\n        if (Array.isArray(key)) return value;\n\n        // 输出的是节点数组，我们只要叶子节点\n        return value?.[value.length - 1];\n      }\n    })\n    .config({ labelProperty: 'fullName', valueProperty: 'id' });\n}\n\nexport function datetimePicker(key: string, format = 'yyyy-MM-dd HH:mm'): UnstableBuilder<DatePickerControlSchema, KindOrKey | 'time' | 'format'> {\n  return datePicker(key)\n    .time({ nzFormat: 'HH:mm' })\n    .format(format);\n}\n\nexport function datetimeRangePicker(key: SchemaKey, format = 'yyyy-MM-dd HH:mm'): UnstableBuilder<DateRangePickerControlSchema, KindOrKey | 'time' | 'format'> {\n  return dateRangePicker(key)\n    .time({ nzFormat: 'HH:mm' })\n    .format(format);\n}\n"]}

package/esm2022/fluent-form/form.mjs

@@ -0,0 +1,15 @@
+import { form } from '@fluent-form/core';
+import { headless } from '@fluent-form/ui-zorro';
+/**
+ * 实体表单
+ *
+ * 内置了一个 Headless ID 控件图示：`headless('id')`
+ * @param schemas
+ */
+export function entityForm(composeFn) {
+    return form(() => {
+        headless('id');
+        composeFn();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3VpLXpvcnJvL2ZsdWVudC1mb3JtL2Zvcm0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3pDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUdqRDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxVQUFVLENBQUMsU0FBMEI7SUFDbkQsT0FBTyxJQUFJLENBQUMsR0FBRyxFQUFFO1FBQ2YsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2YsU0FBUyxFQUFFLENBQUM7SUFDZCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmb3JtIH0gZnJvbSAnQGZsdWVudC1mb3JtL2NvcmUnO1xuaW1wb3J0IHsgaGVhZGxlc3MgfSBmcm9tICdAZmx1ZW50LWZvcm0vdWktem9ycm8nO1xuaW1wb3J0IHsgTnpTYWZlQW55IH0gZnJvbSAnbmctem9ycm8tYW50ZC9jb3JlL3R5cGVzJztcblxuLyoqXG4gKiDlrp7kvZPooajljZVcbiAqXG4gKiDlhoXnva7kuobkuIDkuKogSGVhZGxlc3MgSUQg5o6n5Lu25Zu+56S677yaYGhlYWRsZXNzKCdpZCcpYFxuICogQHBhcmFtIHNjaGVtYXNcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGVudGl0eUZvcm0oY29tcG9zZUZuOiAoKSA9PiBOelNhZmVBbnkpIHtcbiAgcmV0dXJuIGZvcm0oKCkgPT4ge1xuICAgIGhlYWRsZXNzKCdpZCcpO1xuICAgIGNvbXBvc2VGbigpO1xuICB9KTtcbn1cbiJdfQ==

package/esm2022/fluent-form/index.mjs

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './controls';
+export * from './form';
+export * from './patchers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9mbHVlbnQtZm9ybS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRyb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybSc7XG5leHBvcnQgKiBmcm9tICcuL3BhdGNoZXJzJztcbiJdfQ==

package/esm2022/fluent-form/patchers.mjs

@@ -0,0 +1,57 @@
+function parseLabel(label) {
+    if (typeof label === 'string') {
+        return label;
+    }
+    return label.content ?? '';
+}
+function autoPlaceholder(schema, action) {
+    const label = schema['label'];
+    if (label && typeof label !== 'function') {
+        schema['placeholder'] ??= action + parseLabel(label);
+    }
+    return schema;
+}
+/**
+ * 为文本框字段自动添加 placeholder
+ */
+export function useAutoPlaceholderPatchers() {
+    return [
+        {
+            selector: ['text', 'number'],
+            patch: schema => autoPlaceholder(schema, '请输入')
+        },
+        {
+            selector: 'textarea',
+            patch: schema => autoPlaceholder(schema, '请填写')
+        },
+        {
+            selector: ['date-picker', 'time-picker', 'select', 'cascader', 'tree-select'],
+            patch: schema => autoPlaceholder(schema, '请选择')
+        }
+    ];
+}
+/**
+ * 1. 自动为非必填字段添加清除按钮
+ * 2. 为选择器添加搜索功能
+ */
+export function useImprovedPickerPatchers() {
+    return [
+        {
+            selector: ['date-picker', 'time-picker', 'select', 'cascader', 'tree-select'],
+            patch: schema => {
+                if (!schema['required']) {
+                    schema['clearable'] ??= true;
+                }
+                return schema;
+            }
+        },
+        {
+            selector: ['select', 'cascader', 'tree-select'],
+            patch: schema => {
+                schema['searchable'] ??= true;
+                return schema;
+            }
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0Y2hlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9mbHVlbnQtZm9ybS9wYXRjaGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxTQUFTLFVBQVUsQ0FBQyxLQUFxQjtJQUN2QyxJQUFJLE9BQU8sS0FBSyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQzlCLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUVELE9BQU8sS0FBSyxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7QUFDN0IsQ0FBQztBQUVELFNBQVMsZUFBZSxDQUFDLE1BQWtDLEVBQUUsTUFBYztJQUN6RSxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFOUIsSUFBSSxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssVUFBVSxFQUFFLENBQUM7UUFDeEMsTUFBYyxDQUFDLGFBQWEsQ0FBQyxLQUFLLE1BQU0sR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSwwQkFBMEI7SUFDeEMsT0FBTztRQUNMO1lBQ0UsUUFBUSxFQUFFLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQztZQUM1QixLQUFLLEVBQUUsTUFBTSxDQUFDLEVBQUUsQ0FBQyxlQUFlLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQztTQUNoRDtRQUNEO1lBQ0UsUUFBUSxFQUFFLFVBQVU7WUFDcEIsS0FBSyxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUM7U0FDaEQ7UUFDRDtZQUNFLFFBQVEsRUFBRSxDQUFDLGFBQWEsRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxhQUFhLENBQUM7WUFDN0UsS0FBSyxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsZUFBZSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUM7U0FDaEQ7S0FDRixDQUFDO0FBQ0osQ0FBQztBQUVEOzs7R0FHRztBQUNILE1BQU0sVUFBVSx5QkFBeUI7SUFDdkMsT0FBTztRQUNMO1lBQ0UsUUFBUSxFQUFFLENBQUMsYUFBYSxFQUFFLGFBQWEsRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLGFBQWEsQ0FBQztZQUM3RSxLQUFLLEVBQUUsTUFBTSxDQUFDLEVBQUU7Z0JBQ2QsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsRUFBRSxDQUFDO29CQUN4QixNQUFNLENBQUMsV0FBVyxDQUFDLEtBQUssSUFBSSxDQUFDO2dCQUMvQixDQUFDO2dCQUVELE9BQU8sTUFBTSxDQUFDO1lBQ2hCLENBQUM7U0FDRjtRQUNEO1lBQ0UsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxhQUFhLENBQUM7WUFDL0MsS0FBSyxFQUFFLE1BQU0sQ0FBQyxFQUFFO2dCQUNkLE1BQU0sQ0FBQyxZQUFZLENBQUMsS0FBSyxJQUFJLENBQUM7Z0JBRTlCLE9BQU8sTUFBTSxDQUFDO1lBQ2hCLENBQUM7U0FDRjtLQUNGLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZW1hUGF0Y2hlciB9IGZyb20gJ0BmbHVlbnQtZm9ybS9jb3JlJztcbmltcG9ydCB7IEFic3RyYWN0Wm9ycm9Db250cm9sU2NoZW1hLCBMYWJlbCB9IGZyb20gJ0BmbHVlbnQtZm9ybS91aS16b3Jybyc7XG5cbmZ1bmN0aW9uIHBhcnNlTGFiZWwobGFiZWw6IHN0cmluZyB8IExhYmVsKTogc3RyaW5nIHtcbiAgaWYgKHR5cGVvZiBsYWJlbCA9PT0gJ3N0cmluZycpIHtcbiAgICByZXR1cm4gbGFiZWw7XG4gIH1cblxuICByZXR1cm4gbGFiZWwuY29udGVudCA/PyAnJztcbn1cblxuZnVuY3Rpb24gYXV0b1BsYWNlaG9sZGVyKHNjaGVtYTogQWJzdHJhY3Rab3Jyb0NvbnRyb2xTY2hlbWEsIGFjdGlvbjogc3RyaW5nKSB7XG4gIGNvbnN0IGxhYmVsID0gc2NoZW1hWydsYWJlbCddO1xuXG4gIGlmIChsYWJlbCAmJiB0eXBlb2YgbGFiZWwgIT09ICdmdW5jdGlvbicpIHtcbiAgICAoc2NoZW1hIGFzIGFueSlbJ3BsYWNlaG9sZGVyJ10gPz89IGFjdGlvbiArIHBhcnNlTGFiZWwobGFiZWwpO1xuICB9XG5cbiAgcmV0dXJuIHNjaGVtYTtcbn1cblxuLyoqXG4gKiDkuLrmlofmnKzmoYblrZfmrrXoh6rliqjmt7vliqAgcGxhY2Vob2xkZXJcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVzZUF1dG9QbGFjZWhvbGRlclBhdGNoZXJzKCk6IFNjaGVtYVBhdGNoZXJbXSB7XG4gIHJldHVybiBbXG4gICAge1xuICAgICAgc2VsZWN0b3I6IFsndGV4dCcsICdudW1iZXInXSxcbiAgICAgIHBhdGNoOiBzY2hlbWEgPT4gYXV0b1BsYWNlaG9sZGVyKHNjaGVtYSwgJ+ivt+i+k+WFpScpXG4gICAgfSxcbiAgICB7XG4gICAgICBzZWxlY3RvcjogJ3RleHRhcmVhJyxcbiAgICAgIHBhdGNoOiBzY2hlbWEgPT4gYXV0b1BsYWNlaG9sZGVyKHNjaGVtYSwgJ+ivt+Whq+WGmScpXG4gICAgfSxcbiAgICB7XG4gICAgICBzZWxlY3RvcjogWydkYXRlLXBpY2tlcicsICd0aW1lLXBpY2tlcicsICdzZWxlY3QnLCAnY2FzY2FkZXInLCAndHJlZS1zZWxlY3QnXSxcbiAgICAgIHBhdGNoOiBzY2hlbWEgPT4gYXV0b1BsYWNlaG9sZGVyKHNjaGVtYSwgJ+ivt+mAieaLqScpXG4gICAgfVxuICBdO1xufVxuXG4vKipcbiAqIDEuIOiHquWKqOS4uumdnuW/heWhq+Wtl+autea3u+WKoOa4hemZpOaMiemSrlxuICogMi4g5Li66YCJ5oup5Zmo5re75Yqg5pCc57Si5Yqf6IO9XG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB1c2VJbXByb3ZlZFBpY2tlclBhdGNoZXJzKCk6IFNjaGVtYVBhdGNoZXJbXSB7XG4gIHJldHVybiBbXG4gICAge1xuICAgICAgc2VsZWN0b3I6IFsnZGF0ZS1waWNrZXInLCAndGltZS1waWNrZXInLCAnc2VsZWN0JywgJ2Nhc2NhZGVyJywgJ3RyZWUtc2VsZWN0J10sXG4gICAgICBwYXRjaDogc2NoZW1hID0+IHtcbiAgICAgICAgaWYgKCFzY2hlbWFbJ3JlcXVpcmVkJ10pIHtcbiAgICAgICAgICBzY2hlbWFbJ2NsZWFyYWJsZSddID8/PSB0cnVlO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIHNjaGVtYTtcbiAgICAgIH1cbiAgICB9LFxuICAgIHtcbiAgICAgIHNlbGVjdG9yOiBbJ3NlbGVjdCcsICdjYXNjYWRlcicsICd0cmVlLXNlbGVjdCddLFxuICAgICAgcGF0Y2g6IHNjaGVtYSA9PiB7XG4gICAgICAgIHNjaGVtYVsnc2VhcmNoYWJsZSddID8/PSB0cnVlO1xuXG4gICAgICAgIHJldHVybiBzY2hlbWE7XG4gICAgICB9XG4gICAgfVxuICBdO1xufVxuIl19

package/esm2022/fluent-form/solar-angular-ui-zorro-fluent-form.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29sYXItYW5ndWxhci11aS16b3Jyby1mbHVlbnQtZm9ybS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3VpLXpvcnJvL2ZsdWVudC1mb3JtL3NvbGFyLWFuZ3VsYXItdWktem9ycm8tZmx1ZW50LWZvcm0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/fluent-form/typing.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvdWktem9ycm8vZmx1ZW50LWZvcm0vdHlwaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBLaW5kT3JLZXkgPSAna2luZCcgfCAna2V5JztcbiJdfQ==

package/esm2022/index.mjs

@@ -0,0 +1,2 @@
+export default void 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFlLEtBQUssQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgdm9pZCAwXG4iXX0=

package/esm2022/media-uploader/index.mjs

@@ -0,0 +1,2 @@
+export * from './media-uploader.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy91aS16b3Jyby9tZWRpYS11cGxvYWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tZWRpYS11cGxvYWRlci5jb21wb25lbnQnO1xuIl19