ngx-axis-appforge 0.0.0-watch

package/axis-components/design/index.d.ts

@@ -0,0 +1,282 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy, ChangeDetectorRef, ComponentRef, ElementRef, ViewContainerRef } from '@angular/core';
+import * as ngx_axis_appforge_core from 'ngx-axis-appforge/core';
+import { OptionsNode, FlatNode, OptionsChangeEvent, FilteredTreeResult, Base, BaseOptions, ScopeDirective, DynamicDirective, ElementNode, ValueAccessOptions, ValueAccess, Example, FunFieldValueBase, ScopeInfo, EventHandlerDesc, NextInfo, DesignConfig } from 'ngx-axis-appforge/core';
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Observable, Subscription, Subject } from 'rxjs';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { NzTreeFlattener, NzTreeFlatDataSource } from 'ng-zorro-antd/tree-view';
+import { SelectionModel } from '@angular/cdk/collections';
+import { ClipboardService } from 'ngx-clipboard';
+
+declare class DragDrop {
+    private optionsNodes;
+    private optionIdflatNodes;
+    private treeControl;
+    private onChange;
+    constructor(optionsNodes: Map<string, OptionsNode>, optionIdflatNodes: Map<string, FlatNode>, treeControl: FlatTreeControl<FlatNode, string>, onChange: (e: OptionsChangeEvent) => void);
+    dragNode?: OptionsNode;
+    dropNode?: OptionsNode;
+    targetIndex?: number | string;
+    element?: HTMLElement;
+    pos?: number;
+    canDrag(nodeId: string): boolean;
+    onDragStart(e: DragEvent, nodeId: string): void;
+    onDragOver(e: DragEvent, nodeId: string): void;
+    private updateElementStyle;
+    onDragEnd(e: DragEvent, nodeId: string): undefined;
+    private canDrop;
+    private getPos;
+}
+
+declare class Tree implements OnDestroy {
+    private cdRef;
+    readonly node: _angular_core.InputSignal<OptionsNode | null | undefined>;
+    readonly optionsNodes: _angular_core.InputSignal<Map<string, OptionsNode>>;
+    onChange: _angular_core.OutputEmitterRef<OptionsChangeEvent>;
+    readonly onSelect: _angular_core.OutputEmitterRef<string[]>;
+    readonly onContextMenu: _angular_core.OutputEmitterRef<{
+        nodeId: string;
+        event: MouseEvent;
+    }>;
+    readonly dragdrop: _angular_core.Signal<DragDrop>;
+    readonly optionIdflatNodes: Map<string, FlatNode>;
+    readonly flatNodeMap: Map<string, OptionsNode>;
+    readonly nestedNodeMap: Map<string, FlatNode>;
+    searchValue: _angular_core.WritableSignal<string>;
+    readonly originData$: BehaviorSubject<OptionsNode[]>;
+    readonly searchValue$: BehaviorSubject<string>;
+    readonly selectListSelection: SelectionModel<string>;
+    readonly design: Design;
+    private readonly subs;
+    readonly transformer: (node: OptionsNode, level: number) => FlatNode;
+    readonly treeControl: FlatTreeControl<FlatNode, string>;
+    readonly treeFlattener: NzTreeFlattener<OptionsNode, FlatNode, string>;
+    readonly dataSource: NzTreeFlatDataSource<OptionsNode, FlatNode, string>;
+    readonly filteredData$: rxjs.Observable<FilteredTreeResult>;
+    constructor(cdRef: ChangeDetectorRef);
+    hasChild: (_: number, node: FlatNode) => boolean;
+    get hasExpanded(): boolean;
+    onNodeClick(e: MouseEvent, node: FlatNode): void;
+    select(nodeId: string, opt?: {
+        sendEvent: boolean;
+    }): void;
+    selectOne(nodeId: string, opt?: {
+        sendEvent: boolean;
+    }): void;
+    toggleSelect(nodeId: string, opt?: {
+        sendEvent: boolean;
+    }): void;
+    unSelect(nodeId: string, opt?: {
+        sendEvent: boolean;
+    }): void;
+    unSelectAll(opt?: {
+        sendEvent: boolean;
+    }): void;
+    private sendSelectEvent;
+    selectByNodeIds(nodeIds: string[]): void;
+    expandByNodeIds(nodeIds: string[]): void;
+    toggleExpanded(): void;
+    reset(): void;
+    contextMenu(e: MouseEvent, nodeId: string): void;
+    removeSelected(): void;
+    addNodeForSelected(nodes: OptionsNode[], deleteSuccess?: boolean, historyDesc?: string): void;
+    private deleteNode;
+    addRootComponent(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tree, "axis-design-tree", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; "optionsNodes": { "alias": "optionsNodes"; "required": true; "isSignal": true; }; }, { "onChange": "onChange"; "onSelect": "onSelect"; "onContextMenu": "onContextMenu"; }, never, never, true, never>;
+}
+
+declare class Preview implements OnDestroy {
+    constructor();
+    readonly loadAndOptions: _angular_core.InputSignal<[Promise<any>, any] | undefined>;
+    readonly optionsNodes: _angular_core.InputSignal<Map<string, OptionsNode>>;
+    readonly injectData: _angular_core.InputSignal<Observable<any>>;
+    readonly httpContextData: _angular_core.InputSignal<any>;
+    readonly httpContextDataSubject: BehaviorSubject<any>;
+    httpContextDataSub?: Subscription;
+    readonly fileBaseUrl: _angular_core.InputSignal<string | undefined>;
+    readonly fileBaseUrlSubject: BehaviorSubject<string>;
+    fileBaseUrlSub?: Subscription;
+    readonly injectFunc: _angular_core.InputSignal<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    } | undefined>;
+    readonly injectFuncSubject: BehaviorSubject<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    }>;
+    injectFuncSub?: Subscription;
+    readonly loader: ngx_axis_appforge_core.ComponentsLoader;
+    readonly onChange: _angular_core.OutputEmitterRef<OptionsChangeEvent>;
+    readonly onSelect: _angular_core.OutputEmitterRef<string[]>;
+    readonly onContextMenu: _angular_core.OutputEmitterRef<{
+        nodeId: string;
+        event: MouseEvent;
+    }>;
+    readonly elementOptionIds: Map<HTMLElement, string>;
+    readonly elementComponentRefs: Map<HTMLElement, ComponentRef<Base<BaseOptions>>>;
+    readonly optionIdElements: Map<string, HTMLElement[]>;
+    readonly scopeSubjects: Map<string, BehaviorSubject<ScopeDirective | undefined>>;
+    private readonly dragService;
+    private readonly selectService;
+    readonly selected: Map<string, number>;
+    dynamicDirective?: DynamicDirective;
+    initScope(scope: ScopeDirective): void;
+    initElement(ref: ComponentRef<Base<BaseOptions>>, options: any): Promise<void>;
+    getNodeByElement(element: HTMLElement): OptionsNode | undefined;
+    onSelectChange(elements: HTMLElement[]): void;
+    onDragStart(): void;
+    onDragEnd(e?: OptionsChangeEvent): void;
+    forceRender(): void;
+    refresh(): void;
+    private getParentComponentRef;
+    getComponentRef(nodeId: string): ComponentRef<Base<BaseOptions>> | undefined;
+    selectByNodeIds(nodeIds?: string[]): void;
+    getAndUpdateScopeSubject(scopeId: string, initScope?: ScopeDirective): BehaviorSubject<ScopeDirective | undefined>;
+    updateScopeWithSelectedElement(scopeId: string): void;
+    dragForOuter(node: ElementNode): void;
+    dragEndForOuter(): string | undefined;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Preview, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Preview, "axis-design-preview", never, { "loadAndOptions": { "alias": "loadAndOptions"; "required": true; "isSignal": true; }; "optionsNodes": { "alias": "optionsNodes"; "required": true; "isSignal": true; }; "injectData": { "alias": "injectData"; "required": true; "isSignal": true; }; "httpContextData": { "alias": "httpContextData"; "required": false; "isSignal": true; }; "fileBaseUrl": { "alias": "fileBaseUrl"; "required": false; "isSignal": true; }; "injectFunc": { "alias": "injectFunc"; "required": false; "isSignal": true; }; }, { "onChange": "onChange"; "onSelect": "onSelect"; "onContextMenu": "onContextMenu"; }, never, never, true, never>;
+}
+
+declare class ShortcutKey {
+    private design;
+    constructor(design: Design);
+    private cutNodeIds?;
+    onKeyPress(e: KeyboardEvent): void;
+    private doEvent;
+    onlyPreview(): void;
+    forceRender(): void;
+    shortcutKeysInfo(): void;
+    copy(): void;
+    cut(): void;
+    paste(): Promise<void>;
+    private isComponentObj;
+}
+
+declare class DesignOptions extends ValueAccessOptions {
+    readonly injectData: _angular_core.WritableSignal<any>;
+    readonly injectFunc: _angular_core.WritableSignal<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    } | undefined>;
+    readonly allPermissions: _angular_core.WritableSignal<{
+        [permission: string]: string;
+    }>;
+    readonly httpContextData: _angular_core.WritableSignal<any>;
+    readonly fileBaseUrl: _angular_core.WritableSignal<string>;
+}
+
+declare class Toolbar {
+    readonly design: Design;
+    readonly cdr: ChangeDetectorRef;
+    readonly onlyPreview: _angular_core.WritableSignal<boolean>;
+    readonly shortcutKeysModal: _angular_core.ModelSignal<boolean>;
+    readonly history: {
+        options: any;
+        time: Date;
+        desc: string;
+    }[];
+    historyIndex: number;
+    putHistory(options: any, desc: string): void;
+    undo(): void;
+    redo(): void;
+    switchHistory(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Toolbar, "axis-toolbar", never, { "shortcutKeysModal": { "alias": "shortcutKeysModal"; "required": false; "isSignal": true; }; }, { "shortcutKeysModal": "shortcutKeysModalChange"; }, never, never, true, never>;
+}
+
+declare class Design extends ValueAccess<DesignOptions> implements OnDestroy {
+    constructor();
+    options: DesignOptions;
+    element: ElementRef<any>;
+    clipboard: ClipboardService;
+    loader: ngx_axis_appforge_core.ComponentsLoader;
+    injectDataObs: Observable<any>;
+    private funcByInject;
+    readonly injectFunc: _angular_core.Signal<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    } | undefined>;
+    treeNode: _angular_core.WritableSignal<OptionsNode | null | undefined>;
+    loadAndOptions: _angular_core.WritableSignal<[Promise<any>, any] | undefined>;
+    menu: ViewContainerRef;
+    readonly chooseComponentVisible: _angular_core.ModelSignal<boolean>;
+    readonly chooseComponentSubject: Subject<Example | undefined>;
+    readonly chooseComponentTags: _angular_core.WritableSignal<string[]>;
+    cacheSized: [number, number];
+    setting: ViewContainerRef;
+    settingRef?: ComponentRef<FunFieldValueBase>;
+    settingOptionsNodeId?: string;
+    settingOptionsStr: _angular_core.ModelSignal<string>;
+    preview: Preview;
+    tree: Tree;
+    codeEditor?: DynamicDirective;
+    tools: Toolbar;
+    readonly shortcutKey: ShortcutKey;
+    onKeyPress(e: KeyboardEvent): void;
+    readonly optionsNodes: Map<string, OptionsNode>;
+    readonly optionsNodeScopes: Map<string, OptionsNode[]>;
+    readonly scopeInfos: Map<string, ScopeInfo>;
+    readonly componentsInfo: Map<string, {
+        component: string;
+        componentName: string;
+        eventHandlerDescs: {
+            [name: string]: EventHandlerDesc;
+        };
+    }>;
+    readonly componentsCounter: Map<string, number>;
+    readonly scopInfoSubjects: Map<string, BehaviorSubject<ScopeInfo[]>>;
+    readonly changeSubject: Subject<OptionsChangeEvent>;
+    setInitValue(value: any): void;
+    writeValue(value: any): void;
+    inspect(nextInfo: NextInfo): Promise<OptionsNode | undefined>;
+    onChangeOptionsConfig(e: OptionsChangeEvent): void;
+    render(value: any): void;
+    onSettingChange(settingValue: any): void;
+    onTreeSelect(nodeIds: string[]): void;
+    onPreviewSelect(nodeIds: string[]): void;
+    private updateScopeWithNodeId;
+    loadSetting(nodeId: string, force?: boolean): void;
+    private buildScopeInfosGetter;
+    private buildScopeInfoSubject;
+    private buildComponentInfoForSetting;
+    private buildComponentRefForSetting;
+    onContextMenu(e: MouseEvent, nodeId: string): void;
+    chooseComponent(...tags: string[]): Observable<{
+        options?: any;
+        config?: DesignConfig;
+    }>;
+    private genNewComponentId;
+    onCmplibDragStart(example: Example, element: HTMLElement): void;
+    onCmplibDragEnd(): Promise<void>;
+    onPaste(objs: any[]): void;
+    replaceExampleId(example: any): any;
+    private buildIdMap;
+    private isComponentObj;
+    onNodesMove(nodeIds: string[]): void;
+    onEditorChange(optionsStr: string): void;
+    syncToSetting(): void;
+    syncToCode(): void;
+    layoutEditor(e?: number[]): void;
+    private resetSetting;
+    private reset;
+    private getAllParentNodes;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Design, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Design, "axis-design", never, { "chooseComponentVisible": { "alias": "chooseComponentVisible"; "required": false; "isSignal": true; }; "settingOptionsStr": { "alias": "settingOptionsStr"; "required": false; "isSignal": true; }; }, { "chooseComponentVisible": "chooseComponentVisibleChange"; "settingOptionsStr": "settingOptionsStrChange"; }, never, never, true, never>;
+}
+
+export { Design };

package/axis-components/dropdown/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/dropdown/design/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../../axis-components/dropdown/design/config.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,cAAA,MAAA,EAAA,YAAA;;;;"}

package/axis-components/dropdown/index.d.ts

@@ -0,0 +1,25 @@
+import * as _angular_core from '@angular/core';
+import { BaseOptions, Base, EventHandlerOptions } from 'ngx-axis-appforge/core';
+import { NzContextMenuService } from 'ng-zorro-antd/dropdown';
+import { Observable } from 'rxjs';
+
+declare class DropdownOptions extends BaseOptions {
+    readonly trigger: _angular_core.WritableSignal<"click" | "hover" | "contextMenu">;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    readonly placement: _angular_core.WritableSignal<"bottomLeft" | "bottomCenter" | "bottomRight" | "topLeft" | "topCenter" | "topRight">;
+    readonly menu: _angular_core.WritableSignal<any>;
+    readonly child: _angular_core.WritableSignal<any>;
+}
+
+declare class Dropdown extends Base<DropdownOptions> {
+    private contextMenu;
+    constructor(contextMenu: NzContextMenuService);
+    options: DropdownOptions;
+    readonly visible: _angular_core.ModelSignal<boolean>;
+    onContextMenu(event: MouseEvent, menu: any): void;
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dropdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dropdown, "axis-dropdown", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; }, never, never, true, never>;
+}
+
+export { Dropdown };

package/axis-components/dropdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../axis-components/dropdown/dropdown.options.ts","../../../../axis-components/dropdown/dropdown.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;AAGA,cAAA,eAAA,SAAA,WAAA;sBAEoB,aAAA,CAAA,cAAA;uBACC,aAAA,CAAA,cAAA;wBACC,aAAA,CAAA,cAAA;mBAEL,aAAA,CAAA,cAAA;oBACC,aAAA,CAAA,cAAA;AACjB;;ACLD,cAAA,QAAA,SAAA,IAAA,CAAA,eAAA;AASc;AAAQ,6BAAA,oBAAA;;sBAMJ,aAAA,CAAA,WAAA;;AASP,gBAAA,mBAAA,QAAA,UAAA;;;AAaV;;;;"}

package/axis-components/dynamic-container/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/dynamic-container/design/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../../axis-components/dynamic-container/design/config.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,cAAA,MAAA,EAAA,YAAA;;;;"}

package/axis-components/dynamic-container/index.d.ts

@@ -0,0 +1,44 @@
+import * as _angular_core from '@angular/core';
+import { ValueAccessOptions, ValueAccess } from 'ngx-axis-appforge/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+
+declare class DynamicContainerOptions extends ValueAccessOptions {
+    readonly injectData: _angular_core.WritableSignal<any>;
+    readonly injectFunc: _angular_core.WritableSignal<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    } | undefined>;
+    readonly httpContextData: _angular_core.WritableSignal<any>;
+    readonly fileBaseUrl: _angular_core.WritableSignal<string>;
+    readonly child: _angular_core.WritableSignal<any>;
+}
+
+declare class DynamicContainer extends ValueAccess<DynamicContainerOptions> {
+    constructor();
+    options: DynamicContainerOptions;
+    private funcByInject;
+    readonly injectFunc: _angular_core.Signal<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    } | undefined>;
+    readonly injectFuncSubject: BehaviorSubject<{
+        [name: string]: Function | {
+            func: Function;
+            type: string;
+        };
+    }>;
+    injectFuncSub?: Subscription;
+    readonly httpContextDataSubject: BehaviorSubject<any>;
+    httpContextDataSub?: Subscription;
+    readonly fileBaseUrlSubject: BehaviorSubject<string>;
+    fileBaseUrlSub?: Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicContainer, "axis-dynamic-container", never, {}, {}, never, never, true, never>;
+}
+
+export { DynamicContainer };

package/axis-components/dynamic-container/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../axis-components/dynamic-container/dynamic-container.options.ts","../../../../axis-components/dynamic-container/dynamic-container.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;AAGA,cAAA,uBAAA,SAAA,kBAAA;yBAEuB,aAAA,CAAA,cAAA;AACnB,yBAAmB,aAAA,CAAA,cAAA;;;;;AAAoG;8BAC/F,aAAA,CAAA,cAAA;0BACJ,aAAA,CAAA,cAAA;oBAEN,aAAA,CAAA,cAAA;AACjB;;ACJD,cAAA,gBAAA,SAAA,WAAA,CAAA,uBAAA;;;;AA8EE,yBAAmB,aAAA,CAAA,MAAA;;;;;AAShB;AACH,gCAAA,eAAA;;;;;AAAwH;;;;;;AAU/G;;;AAOV;;;;"}

package/axis-components/dynamic-value/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/dynamic-value/design/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../../axis-components/dynamic-value/design/config.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA,cAAA,MAAA,EAAA,YAAA;;;;"}

package/axis-components/dynamic-value/index.d.ts

@@ -0,0 +1,16 @@
+import * as _angular_core from '@angular/core';
+import { ValueAccessOptions, ValueAccess } from 'ngx-axis-appforge/core';
+
+declare class DynamicValueOptions extends ValueAccessOptions {
+    child: _angular_core.WritableSignal<any>;
+    initValue: _angular_core.WritableSignal<any>;
+}
+
+declare class DynamicValue extends ValueAccess<DynamicValueOptions> {
+    value: _angular_core.ModelSignal<any>;
+    options: DynamicValueOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicValue, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicValue, "axis-dynamic-value", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+export { DynamicValue };

package/axis-components/dynamic-value/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../axis-components/dynamic-value/dynamic-value.options.ts","../../../../axis-components/dynamic-value/dynamic-value.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;AAGA,cAAA,mBAAA,SAAA,kBAAA;AACI,WAAK,aAAA,CAAA,cAAA;AACI,eAAS,aAAA,CAAA,cAAA;AACrB;;ACAD,cAAA,YAAA,SAAA,WAAA,CAAA,mBAAA;AASW,WAAK,aAAA,CAAA,WAAA;;;;AAGf;;;;"}

package/axis-components/edit-table/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/edit-table/design/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../../axis-components/edit-table/design/config.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA,cAAA,MAAA,EAAA,YAAA;;;;"}

package/axis-components/edit-table/index.d.ts

@@ -0,0 +1,106 @@
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, WritableSignal } from '@angular/core';
+import { ValueAccessOptions, ValueAccess, RegisteValueAccessOptions } from 'ngx-axis-appforge/core';
+import { BaseTableOptions, SelectableTableOptions, ExpandableTableOptions, BaseTableFieldOptions, TableService, SelectService, ExpandService } from 'ngx-axis-appforge/axis-components/table-helper';
+import { UntypedFormGroup, FormArray, AbstractControl } from '@angular/forms';
+import { Subscription } from 'rxjs';
+
+declare class EditTableOptions extends ValueAccessOptions implements BaseTableOptions, SelectableTableOptions, ExpandableTableOptions {
+    readonly disabledAppend: _angular_core.WritableSignal<boolean>;
+    readonly disabledRemove: _angular_core.WritableSignal<boolean>;
+    readonly disabledRemoveFn: _angular_core.WritableSignal<string>;
+    readonly maxLength: _angular_core.WritableSignal<number | null>;
+    readonly addInitData: _angular_core.WritableSignal<any>;
+    readonly showExpand: _angular_core.WritableSignal<boolean>;
+    readonly expandMode: _angular_core.WritableSignal<"custom" | "tree">;
+    readonly treeChildrenFun: _angular_core.WritableSignal<string>;
+    readonly expandFormName: _angular_core.WritableSignal<string | undefined>;
+    readonly size: _angular_core.WritableSignal<"middle" | "small" | "default">;
+    readonly showOrder: _angular_core.WritableSignal<boolean>;
+    readonly showDataSize: _angular_core.WritableSignal<boolean>;
+    readonly bordered: _angular_core.WritableSignal<boolean>;
+    readonly outerBordered: _angular_core.WritableSignal<boolean>;
+    readonly width: _angular_core.WritableSignal<number | undefined>;
+    readonly showCheckbox: _angular_core.WritableSignal<boolean>;
+    readonly checkedFormName: _angular_core.WritableSignal<string>;
+    readonly singleCheck: _angular_core.WritableSignal<boolean>;
+    readonly disableCheckboxFn: _angular_core.WritableSignal<string | undefined>;
+    readonly defaultSelectFirstRow: _angular_core.WritableSignal<boolean>;
+    readonly checkboxLinkageForExpand: _angular_core.WritableSignal<boolean>;
+    readonly showTotal: _angular_core.WritableSignal<boolean>;
+    readonly totalTitle: _angular_core.WritableSignal<string>;
+    readonly showSubTotal: _angular_core.WritableSignal<boolean>;
+    readonly showPagination: _angular_core.WritableSignal<boolean>;
+    readonly pageSize: _angular_core.WritableSignal<number>;
+    readonly showSizeChanger: _angular_core.WritableSignal<boolean>;
+    readonly pageSizeOptions: _angular_core.WritableSignal<string>;
+    readonly useBackEndPaging: _angular_core.WritableSignal<boolean>;
+    readonly fields: _angular_core.WritableSignal<any[]>;
+    readonly expandRow: _angular_core.WritableSignal<any>;
+}
+declare class EditTableFieldOptions implements BaseTableFieldOptions {
+    readonly inuse: _angular_core.WritableSignal<boolean>;
+    readonly field: _angular_core.WritableSignal<string>;
+    readonly title: _angular_core.WritableSignal<string>;
+    readonly sortAble: _angular_core.WritableSignal<boolean>;
+    readonly sortOrder: _angular_core.WritableSignal<"descend" | "ascend" | null>;
+    readonly sortPriority: _angular_core.WritableSignal<number | null>;
+    readonly filterAble: _angular_core.WritableSignal<boolean>;
+    readonly filterMultiple: _angular_core.WritableSignal<boolean>;
+    readonly width: _angular_core.WritableSignal<number | null>;
+    readonly align: _angular_core.WritableSignal<"left" | "right" | "center">;
+    readonly freezeMode: _angular_core.WritableSignal<"left" | "right" | "none">;
+    readonly totalAble: _angular_core.WritableSignal<boolean>;
+    readonly totalFn: _angular_core.WritableSignal<string | undefined>;
+    readonly validators: _angular_core.WritableSignal<any[]>;
+    readonly child: _angular_core.WritableSignal<any>;
+}
+
+declare class EditTable extends ValueAccess<EditTableOptions> implements OnInit, OnDestroy {
+    tableSvc: TableService<EditTableOptions, EditTableFieldOptions>;
+    select: SelectService;
+    expand: ExpandService;
+    constructor(tableSvc: TableService<EditTableOptions, EditTableFieldOptions>, select: SelectService, expand: ExpandService, parentSelect?: SelectService);
+    options: EditTableOptions;
+    private readonly fb;
+    readonly fg: UntypedFormGroup;
+    get fa(): FormArray<AbstractControl>;
+    readonly rowData: WritableSignal<EditTableRowData[]>;
+    readonly scroll: _angular_core.Signal<{
+        x: string;
+        y: string;
+    }>;
+    readonly fields: _angular_core.Signal<EditTableFieldOptions[]>;
+    readonly setOfDisabledRemoveId: WritableSignal<Set<string>>;
+    readonly disabledAppend: _angular_core.Signal<boolean>;
+    readonly disabledRemove: _angular_core.Signal<boolean>;
+    readonly pageIndex: _angular_core.ModelSignal<number>;
+    ngOnInit(): void;
+    idRequired(field: EditTableFieldOptions): boolean;
+    private buildFields;
+    private buildScoll;
+    writeValue(value: any): void;
+    setInitValue(value: any): void;
+    childRegisteValueAccess(opt: RegisteValueAccessOptions, index: number, field: EditTableFieldOptions): void;
+    valueToFormValue(): void;
+    formValueToSelect(): void;
+    formValueToValue(): void;
+    buildRow(): EditTableRowData;
+    addRow(): void;
+    removeRow(index: number): void;
+    refreshStatus(row: EditTableRowData): void;
+    ngOnDestroy(): void;
+    onSelectedChange(checkedIds: Set<any>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditTable, [null, null, null, { optional: true; skipSelf: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditTable, "axis-edit-table", never, { "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; }, { "pageIndex": "pageIndexChange"; }, never, never, true, never>;
+}
+interface EditTableRowData {
+    key: string;
+    status: WritableSignal<'ignore' | 'invalid' | 'success'>;
+    control: AbstractControl;
+    subs: Subscription[];
+    disabledRemove: WritableSignal<boolean>;
+}
+
+export { EditTable };
+export type { EditTableRowData };

package/axis-components/edit-table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sources":["../../../../axis-components/edit-table/edit-table.options.ts","../../../../axis-components/edit-table/edit-table.ts"],"sourcesContent":[null,null],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCC;AAED;;;;;;;;;;;;;;;;AAgBC;;ACvCD;AAeqB;AAAwE;AAA8B;AAAtG;;AAkCnB;AACA;AAGA;;AAIA;;;AAAoD;;;;;;AAOpD;AAQA;AAIA;AAIA;AAkBS;AAOA;;;;;AAiDT;;;;AAgFS;AAOT;;;AASD;;;;;;AAQC;AACD;;;"}

package/axis-components/editor/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/editor/index.d.ts

@@ -0,0 +1,33 @@
+import * as _angular_core from '@angular/core';
+import { ValueAccessOptions, ValueAccess, EventHandlerOptions } from 'ngx-axis-appforge/core';
+import { NzCodeEditorComponent } from 'ng-zorro-antd/code-editor';
+import { Observable } from 'rxjs';
+import { NzTooltipDirective } from 'ng-zorro-antd/tooltip';
+
+declare class EditorOptions extends ValueAccessOptions {
+    readonly mode: _angular_core.WritableSignal<"json" | "javascript" | "plain_text" | "sql" | "html">;
+    readonly otherOptions: _angular_core.WritableSignal<any>;
+    readonly typescriptExtLibs: _angular_core.WritableSignal<{
+        content: string;
+        filePath?: string;
+    }[]>;
+}
+
+declare class Editor extends ValueAccess<EditorOptions> {
+    options: EditorOptions;
+    writeValue(value: any): void;
+    config: _angular_core.Signal<any>;
+    readonly fullScreen: _angular_core.WritableSignal<boolean>;
+    private document;
+    private renderer;
+    tooltip?: NzTooltipDirective;
+    editor: NzCodeEditorComponent;
+    mouseenter(): void;
+    keydown(e: KeyboardEvent): void;
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    toggleFullScreen(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Editor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Editor, "axis-editor", never, {}, {}, never, never, true, never>;
+}
+
+export { Editor };

package/axis-components/flex/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/flex/index.d.ts

@@ -0,0 +1,20 @@
+import * as _angular_core from '@angular/core';
+import { NzJustify, NzAlign, NzWrap } from 'ng-zorro-antd/flex';
+import { BaseOptions, Base } from 'ngx-axis-appforge/core';
+
+declare class FlexOptions extends BaseOptions {
+    readonly direction: _angular_core.WritableSignal<"horizontal" | "vertical">;
+    readonly justify: _angular_core.WritableSignal<NzJustify>;
+    readonly align: _angular_core.WritableSignal<NzAlign>;
+    readonly gap: _angular_core.WritableSignal<string>;
+    readonly wrap: _angular_core.WritableSignal<NzWrap>;
+    readonly children: _angular_core.WritableSignal<any[]>;
+}
+
+declare class Flex extends Base<FlexOptions> {
+    options: FlexOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Flex, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Flex, "axis-flex", never, {}, {}, never, never, true, never>;
+}
+
+export { Flex };

package/axis-components/form/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };

package/axis-components/form/index.d.ts

@@ -0,0 +1,31 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { ValueAccessOptions, ValueAccess, RegisteFormControlOptions, EventHandlerOptions } from 'ngx-axis-appforge/core';
+import { UntypedFormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+
+declare class FormOptions extends ValueAccessOptions {
+    readonly submitConfirm: _angular_core.WritableSignal<boolean>;
+    readonly child: _angular_core.WritableSignal<any>;
+}
+
+declare class Form extends ValueAccess<FormOptions> implements OnInit {
+    constructor();
+    options: FormOptions;
+    private readonly fb;
+    private readonly modal;
+    readonly fg: UntypedFormGroup;
+    private oriFormValue;
+    private oriValue;
+    private resetSubject;
+    writeValue(value: any): void;
+    setInitValue(value: any): void;
+    ngOnInit(): void;
+    registerControl(opt: RegisteFormControlOptions): void;
+    reset(emitEvent?: boolean): void;
+    onEvents(e: EventHandlerOptions<any>): Observable<boolean> | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Form, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Form, "axis-form", never, {}, {}, never, never, true, never>;
+}
+
+export { Form };

package/axis-components/form-item/design/index.d.ts

@@ -0,0 +1,5 @@
+import { DesignConfig } from 'ngx-axis-appforge/core';
+
+declare const Config: DesignConfig;
+
+export { Config };