@acorex/platform 18.0.9 → 18.0.11

package/fesm2022/acorex-platform-workflow.mjs

@@ -21,10 +21,10 @@ class AXPWorkflowEventService {
     get events$() {
         return this.eventSubject.asObservable();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -58,10 +58,10 @@ class AXPWorkflowRegistryService {
     getFunctionNames() {
         return Array.from(this.functionsMap.keys());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowRegistryService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowRegistryService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
@@ -100,17 +100,17 @@ class AXPWorkflowAction {
     dispatch(event) {
         this.eventService.dispatch(event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowAction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowAction, decorators: [{
             type: Injectable
         }] });
 class AXPWorkflowFunction {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowFunction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowFunction, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowFunction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowFunction, decorators: [{
             type: Injectable
         }] });
 function createWorkFlowEvent(type) {
@@ -292,10 +292,10 @@ class AXPWorkflowService {
         }
         return this.injector.get(functionType);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowService, deps: [{ token: AXPWorkflowRegistryService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -320,10 +320,10 @@ class AXPStartWorkflowAction extends AXPWorkflowAction {
             throw e;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPStartWorkflowAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPStartWorkflowAction, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPStartWorkflowAction, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -409,11 +409,11 @@ class AXPWorkflowModule {
             f();
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowModule, deps: [{ token: 'AXPWorkflowModuleFactory', optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPWorkflowModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPWorkflowModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],

package/layout/builder/lib/builder/builder.service.d.ts

@@ -1,6 +1,13 @@
 import { Subject } from 'rxjs';
 import { AXPLayoutContextEvent } from './widget.types';
 import * as i0 from "@angular/core";
+export type AXPLayoutElementAPI = {
+    [name: string]: Subject<any> | Function;
+};
+export declare abstract class AXPLayoutElement {
+    abstract get id(): string | null;
+    api(): AXPLayoutElementAPI;
+}
 export declare class AXPLayoutBuilderService {
     private readonly context$;
     private readonly variables$;
@@ -8,6 +15,7 @@ export declare class AXPLayoutBuilderService {
     readonly onChanged: Subject<AXPLayoutContextEvent>;
     private debouncers;
     private debouncerSubscriptions;
+    private widgets;
     get context(): any;
     get variables(): any;
     get functions(): {
@@ -20,6 +28,8 @@ export declare class AXPLayoutBuilderService {
     setFunctions(key: string, value: any): void;
     setValue(path: string, value: any, debounceMs?: number): void;
     getValue(path: string): any;
+    registerWidget(id: string, widget: AXPLayoutElement): void;
+    getWidget(id: string): AXPLayoutElement | undefined;
     private unsubscribeDebouncers;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutBuilderService, never>;

package/layout/builder/lib/builder/layout.types.d.ts

@@ -1,30 +1 @@
-import { AXPWidgetNode } from "./widget.types";
-import { AXPGridLayoutOptions } from "@acorex/platform/common";
-export interface AXPLayoutPage {
-    id: string;
-    title: string;
-    forms: AXPLayoutForm[];
-}
-export interface AXPLayoutForm {
-    id: string;
-    title: string;
-}
-export interface AXPLayoutFormRootGroup {
-    id: string;
-    title: string;
-    layout?: AXPGridLayoutOptions;
-}
-export interface AXPLayoutFormGroup {
-    id: string;
-    title: string;
-    groups: AXPLayoutFormGroup;
-    fields: AXPLayoutFormField[];
-}
-export interface AXPLayoutFormField {
-    name: string;
-    title: string;
-    description?: string;
-    order?: number;
-    editable: boolean;
-    widget: AXPWidgetNode;
-}
+export {};

package/layout/builder/lib/builder/widget-container.component.d.ts

@@ -1,15 +1,15 @@
 import { EventEmitter } from "@angular/core";
+import { AXPLayoutContextEvent } from "./widget.types";
 import * as i0 from "@angular/core";
 export declare class AXPWidgetContainerComponent {
-    contextChange: EventEmitter<any>;
-    private _context;
-    get context(): any;
-    set context(v: any);
+    readonly onChanged: EventEmitter<AXPLayoutContextEvent>;
+    context: import("@angular/core").ModelSignal<any>;
     set variables(v: any);
     set functions(v: any);
     private unsubscriber;
     private builderService;
+    private ef;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetContainerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetContainerComponent, "axp-widgets-container", never, { "context": { "alias": "context"; "required": false; }; "variables": { "alias": "variables"; "required": false; }; "functions": { "alias": "functions"; "required": false; }; }, { "contextChange": "contextChange"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetContainerComponent, "axp-widgets-container", never, { "context": { "alias": "context"; "required": false; "isSignal": true; }; "variables": { "alias": "variables"; "required": false; }; "functions": { "alias": "functions"; "required": false; }; }, { "onChanged": "onChanged"; "context": "contextChange"; }, never, ["*"], false, never>;
 }

package/layout/builder/lib/builder/widget-registery.service.d.ts

@@ -5,6 +5,7 @@ export declare class AXPWidgetRegistryService {
     register(widget: AXPWidgetConfig): void;
     extend(parentName: string, widget: AXPWidgetConfig): void;
     resolve(name: string): AXPWidgetConfig | undefined;
+    all(): AXPWidgetConfig[];
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetRegistryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetRegistryService>;
 }

package/layout/builder/lib/builder/widget-renderer.component.d.ts

@@ -3,12 +3,17 @@ import { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal
 import { WritableSignal } from '@angular/core';
 import { AXPLayoutBuilderService } from './builder.service';
 import { AXPWidgetRegistryService } from './widget-registery.service';
-import { AXPWidgetNode } from './widget.types';
+import { AXPWidgetComponent, AXPWidgetNode, AXPWidgetRenderMode } from './widget.types';
 import * as i0 from "@angular/core";
 export declare class AXPWidgetRendererComponent {
     private _node;
     get node(): AXPWidgetNode;
     set node(v: AXPWidgetNode);
+    private _mode;
+    get mode(): AXPWidgetRenderMode;
+    set mode(v: AXPWidgetRenderMode);
+    parentNode: AXPWidgetComponent | null;
+    index: number | null;
     protected mergedOptions: WritableSignal<any>;
     private injector;
     protected builderService: AXPLayoutBuilderService;
@@ -39,5 +44,5 @@ export declare class AXPWidgetRendererComponent {
     private evaluateTrigger;
     private evaluateAction;
     static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetRendererComponent, "axp-widget-renderer", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetRendererComponent, "axp-widget-renderer", never, { "node": { "alias": "node"; "required": true; }; "mode": { "alias": "mode"; "required": false; }; "parentNode": { "alias": "parentNode"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, false, never>;
 }

package/layout/builder/lib/builder/widget.types.d.ts

@@ -1,77 +1,133 @@
+import { AXPMetaData, AXPOptionsData, AXPPartialNested, AXPValidationRules } from '@acorex/platform/core';
 import { InjectionToken } from '@angular/core';
+import { Subject } from 'rxjs';
+import { AXPLayoutElement } from './builder.service';
 import * as i0 from "@angular/core";
-export type AXPWidgetNodeOptions = Record<string, any>;
+export type AXPWidgetTrigger = {
+    event: string;
+    action: string;
+    disabled?: boolean;
+};
+export type AXPWidgetTriggers = AXPWidgetTrigger[];
+export interface AXPWidgetPropertyGroup {
+    name: string;
+    title: string;
+    order: number;
+}
+export interface AXPWidgetProperty {
+    name: string;
+    title: string;
+    description?: string;
+    group: AXPWidgetPropertyGroup;
+    schema: {
+        dataType: 'string' | 'number' | 'object' | 'boolean' | 'array';
+        nullable?: boolean;
+        defaultValue?: any | string | ((context: any | null) => any);
+        interface: Required<Pick<AXPWidgetNode, 'path'>> & Omit<AXPWidgetNode, 'path'>;
+    };
+    options?: AXPOptionsData;
+    validations?: AXPValidationRules;
+    visible: boolean;
+}
+export declare function cloneProperty(property: AXPWidgetProperty, values: AXPPartialNested<AXPWidgetProperty>): AXPWidgetProperty;
 export interface AXPWidgetNode {
     type: string;
-    path: string;
-    id?: string;
+    path?: string;
+    name?: string;
+    defaultValue?: any;
     formula?: string;
     children?: AXPWidgetNode[];
-    mode: 'view' | 'edit' | 'designer';
-    options?: AXPWidgetNodeOptions;
-    triggers?: {
-        event: string;
-        action: string;
-        disabled?: boolean;
-    }[];
+    options?: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+}
+export interface AXPWidgetNodeToken {
+    config: AXPWidgetConfig;
+    node: AXPWidgetNode;
+    options?: AXPOptionsData;
 }
 export interface AXPWidgetColumnNode {
     type: string;
     path: string;
-    options?: AXPWidgetNodeOptions;
+    options?: AXPOptionsData;
+}
+export interface AXPWidgetColumnNodeToken extends AXPWidgetColumnNode {
+    config: AXPWidgetConfig;
 }
-export declare const AXP_WIDGET_TOKEN: InjectionToken<AXPWidgetNode>;
-export declare const AXP_WIDGET_COLUMN_TOKEN: InjectionToken<AXPWidgetColumnNode>;
+export declare const AXP_WIDGET_TOKEN: InjectionToken<AXPWidgetNodeToken>;
+export declare const AXP_WIDGET_COLUMN_TOKEN: InjectionToken<AXPWidgetColumnNodeToken>;
 export interface AXPWidgetComponentConfig {
     component: () => Promise<any>;
-    defaultOptions?: any;
+    properties?: AXPWidgetProperty[];
+}
+export interface AXPWidgetConfigComponents {
+    designer: AXPWidgetComponentConfig;
+    view: AXPWidgetComponentConfig;
+    edit?: AXPWidgetComponentConfig;
+    print?: AXPWidgetComponentConfig;
+    column?: AXPWidgetComponentConfig;
+    filter?: AXPWidgetComponentConfig;
 }
 export interface AXPWidgetConfig {
     name: string;
-    defaultOptions?: any;
-    components: {
-        view: AXPWidgetComponentConfig;
-        [name: string]: AXPWidgetComponentConfig;
-    };
-    meta?: {
-        [key: string]: any;
-    };
+    title: string;
+    icon?: string;
+    description?: string;
+    properties?: AXPWidgetProperty[];
+    components: AXPWidgetConfigComponents;
+    meta?: AXPMetaData;
+    container?: boolean;
+    visible?: boolean;
 }
+export type AXPWidgetRenderMode = keyof AXPWidgetConfigComponents;
 export interface AXPLayoutContextEvent {
     oldValue: any;
     newValue: any;
     path?: string | null;
     data: any;
 }
-export declare abstract class AXPWidgetBase<T = any | null | void> {
-    private readonly token;
-    private readonly cdr;
-    protected readonly id: string | undefined;
+export declare abstract class AXPWidgetComponent<T = any | null | void> extends AXPLayoutElement {
+    protected readonly token: AXPWidgetNodeToken;
     protected readonly path: string;
-    protected readonly mode: "view" | "edit" | "designer";
-    protected readonly type: string;
-    protected readonly children: AXPWidgetNode[] | undefined;
+    protected readonly name: string | undefined;
+    protected readonly defaultValue: any;
+    protected readonly _children: import("@angular/core").WritableSignal<AXPWidgetNode[]>;
+    protected children: import("@angular/core").Signal<AXPWidgetNode[]>;
+    protected readonly config: AXPWidgetConfig;
+    protected _options: import("@angular/core").WritableSignal<any>;
+    protected options: import("@angular/core").Signal<any>;
     private readonly contextService;
-    private readonly rawValue;
+    protected readonly rawValue: import("@angular/core").Signal<T>;
+    readonly onReady: Subject<void>;
+    private isRendered;
+    private _id;
+    get id(): string | null;
+    parent: AXPWidgetComponent | null | undefined;
+    index: number | null | undefined;
+    mode: AXPWidgetRenderMode;
+    private _fullPath;
     ngOnInit(): void;
-    getValue(): any;
+    private nextRender;
+    private initRender;
+    getValue<T>(): T_1;
     setValue(value: T): void;
-    setOption(path: string, value: any): void;
     setOptions(values: any): void;
     call(name: string, ...args: any[]): void;
+    setChildren(children: AXPWidgetNode[]): void;
     onValueChanged(oldValue: T, newValue: T): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetBase<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetBase<any>>;
+    private detectFullPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetComponent<any>>;
 }
-export declare abstract class AXPColumnWidgetBase<T = any | null | void> {
+export declare abstract class AXPContainerWidgetComponent<T> extends AXPWidgetComponent<T> {
+    readonly node: AXPWidgetNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPContainerWidgetComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPContainerWidgetComponent<any>>;
+}
+export declare abstract class AXPColumnWidgetComponent<T = any | null | void> {
     private readonly token;
     protected readonly path: string;
-    protected readonly options: AXPWidgetNodeOptions | undefined;
-    private _rawValue;
-    get rawValue(): any;
-    set rawValue(v: any);
-    ngOnInit(): void;
-    setOptions(values: any): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPColumnWidgetBase<any>, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPColumnWidgetBase<any>>;
+    protected readonly options: AXPOptionsData;
+    protected readonly rawValue: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPColumnWidgetComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPColumnWidgetComponent<any>>;
 }

package/layout/designer/README.md

@@ -0,0 +1,4 @@
+# @acorex/platform/designer
+
+Secondary entry point of `@acorex/platform`. It can be used by importing from `@acorex/platform/designer`.
+            

package/layout/designer/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/board/board.component';
+export * from './lib/buttons/add-widget-button/add-widget-button.component';
+export * from './lib/designer.module';
+export * from './lib/designer.service';
+export * from './lib/designer/designer.component';
+export * from './lib/property-viewer/widget-property-viewer.component';
+export * from './lib/widget-designer-renderer.component';

package/layout/designer/lib/board/board.component.d.ts

@@ -0,0 +1,10 @@
+import { AXPDesignerService } from '../designer.service';
+import * as i0 from "@angular/core";
+export declare class AXPDesignerBoardComponent {
+    protected context: any;
+    protected service: AXPDesignerService;
+    private get __class();
+    private handleKeyboardEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerBoardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDesignerBoardComponent, "axp-designer-board", never, {}, {}, never, never, true, never>;
+}

package/layout/designer/lib/breadcrumbs/breadcrumbs.component.d.ts

@@ -0,0 +1,11 @@
+import { AXPWidgetNode } from '@acorex/platform/layout/builder';
+import { AXPDesignerService } from '../designer.service';
+import * as i0 from "@angular/core";
+export declare class AXPDesignerBreadcrumbsComponent {
+    protected service: AXPDesignerService;
+    protected getTitle(node: AXPWidgetNode): string;
+    protected handleClick(node: AXPWidgetNode): void;
+    protected handleMouseOver(node: AXPWidgetNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerBreadcrumbsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDesignerBreadcrumbsComponent, "axp-designer-breadcrumbs", never, {}, {}, never, never, true, never>;
+}

package/layout/designer/lib/buttons/add-widget-button/add-widget-button.component.d.ts

@@ -0,0 +1,9 @@
+import { AXClickEvent } from '@acorex/components/common';
+import * as i0 from "@angular/core";
+export declare class AXPDesignerAddWidgetButtonComponent {
+    private designerService;
+    private parent;
+    handleClick(e: AXClickEvent): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerAddWidgetButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDesignerAddWidgetButtonComponent, "axp-designer-add-widget-button", never, {}, {}, never, never, true, never>;
+}

package/layout/designer/lib/designer/designer.component.d.ts

@@ -0,0 +1,18 @@
+import { AXTabStripChangedEvent } from '@acorex/components/tabs';
+import { AXPWidgetConfig, AXPWidgetRenderMode } from '@acorex/platform/layout/builder';
+import { WritableSignal } from '@angular/core';
+import { AXPDesignerService } from '../designer.service';
+import * as i0 from "@angular/core";
+export declare class AXPLayoutDesignerComponent {
+    protected currentTabIndex: WritableSignal<number>;
+    protected service: AXPDesignerService;
+    protected tabs: {
+        mode: AXPWidgetRenderMode;
+        title: string;
+    }[];
+    protected handleTabChange(event: AXTabStripChangedEvent): void;
+    private get __class();
+    protected nodeConfig: import("@angular/core").Signal<AXPWidgetConfig | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPLayoutDesignerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPLayoutDesignerComponent, "axp-layout-designer", never, {}, {}, never, never, true, never>;
+}

package/layout/designer/lib/designer.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class AXPDesignerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPDesignerModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPDesignerModule>;
+}

package/layout/designer/lib/designer.service.d.ts

@@ -0,0 +1,103 @@
+import { AXPWidgetComponent, AXPWidgetConfig, AXPWidgetNode, AXPWidgetRenderMode } from '@acorex/platform/layout/builder';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface AXPDesignerFocusCommand {
+    widget: AXPWidgetNode | null;
+}
+export interface AXPDesignerUpdateCommand {
+    values: any;
+    mode: "init" | "update";
+}
+export interface AXPDesignerUpdateEvent {
+    values: any;
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerSelectCommand {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerRegisterCommand {
+    id: number;
+    widget: AXPWidgetNode;
+    config: AXPWidgetConfig;
+    instance: AXPWidgetComponent;
+}
+export interface AXPDesignerSelectEvent {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerRefreshCommand {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerRefreshEvent {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerAddNodeCommand {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerAddNodeEvent {
+    widget: AXPWidgetNode;
+}
+export interface AXPDesignerFocusEvent {
+    widget: AXPWidgetNode | null;
+}
+export declare class AXPDesignerService {
+    private clipboard;
+    private undoStack;
+    private redoStack;
+    private maxHistorySize;
+    canUndo: import("@angular/core").WritableSignal<boolean>;
+    canRedo: import("@angular/core").WritableSignal<boolean>;
+    canCutCopy: import("@angular/core").Signal<boolean>;
+    canPaste: import("@angular/core").Signal<boolean>;
+    private popupService;
+    private widgetRegisteryService;
+    readonly root: import("@angular/core").WritableSignal<AXPWidgetNode>;
+    breadcrumbs: import("@angular/core").Signal<AXPWidgetNode[]>;
+    selectedNode: import("@angular/core").WritableSignal<AXPWidgetNode | null>;
+    private _lastSelectedNode;
+    private _focusedNode;
+    focusedNode: () => AXPWidgetNode | null;
+    private _mode;
+    mode: import("@angular/core").Signal<keyof import("@acorex/platform/layout/builder").AXPWidgetConfigComponents>;
+    setMode(mode: AXPWidgetRenderMode): void;
+    readonly onSelected: Subject<AXPDesignerSelectEvent>;
+    readonly onRefresh: Subject<AXPDesignerRefreshEvent>;
+    register(command: AXPDesignerRegisterCommand): void;
+    select(command: AXPDesignerSelectCommand): void;
+    readonly onUpdate: Subject<AXPDesignerUpdateEvent>;
+    update(command: AXPDesignerUpdateCommand): void;
+    readonly onFocused: Subject<AXPDesignerFocusEvent>;
+    focus(command: AXPDesignerFocusCommand): void;
+    refresh(command: AXPDesignerRefreshCommand): void;
+    private findBreadcrumbs;
+    showPicker(currentNode: AXPWidgetNode): Promise<void>;
+    private createPage;
+    findWidgetById(root: AXPWidgetNode, id: string): AXPWidgetNode | null;
+    private findParent;
+    private findNearestContainer;
+    addWidget(currentNode: AXPWidgetNode, node: AXPWidgetNode): AXPWidgetNode | null;
+    removeWidget(node: AXPWidgetNode): void;
+    private saveStateForUndo;
+    private applyState;
+    undo(): void;
+    redo(): void;
+    private formatOutputJSON;
+    copy(widget?: AXPWidgetNode | null): void;
+    cut(widget?: AXPWidgetNode | null): void;
+    paste(parentNode?: AXPWidgetNode): void;
+    export(): string;
+    download(): void;
+    /**
+     * Generates a well-formed, unique name for a new widget node based on its type.
+     * @param type The type of the widget (e.g., 'textBox', 'numberBox').
+     * @returns A unique name for the widget (e.g., 'textBox1', 'numberBox2').
+     */
+    private generateUniqueName;
+    /**
+     * Collects all existing widget names from the widget tree.
+     * @param node The current node being inspected.
+     * @param names A set to store existing names.
+     */
+    private collectAllNames;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDesignerService>;
+}

package/layout/designer/lib/outline/outline.component.d.ts

@@ -0,0 +1,17 @@
+import { AXPWidgetConfig, AXPWidgetNode } from '@acorex/platform/layout/builder';
+import { AXPDesignerService } from '../designer.service';
+import * as i0 from "@angular/core";
+export declare class AXPDesignerOutlineComponent {
+    protected service: AXPDesignerService;
+    protected collapsedStates: Map<any, boolean>;
+    protected root: import("@angular/core").WritableSignal<AXPWidgetNode>;
+    constructor();
+    private toggleCollapse;
+    protected isCollapsed(node: any): boolean;
+    protected getConfig(node: AXPWidgetNode): AXPWidgetConfig;
+    protected handleClick(e: MouseEvent, node: AXPWidgetNode): void;
+    protected handleToggleClick(event: MouseEvent, item: any): void;
+    protected handleMouseOver(e: MouseEvent, node: AXPWidgetNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDesignerOutlineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPDesignerOutlineComponent, "axp-designer-outline", never, {}, {}, never, never, true, never>;
+}

package/layout/designer/lib/property-viewer/widget-property-viewer.component.d.ts

@@ -0,0 +1,41 @@
+import { AXTabStripChangedEvent } from '@acorex/components/tabs';
+import { AXPLayoutContextEvent, AXPWidgetConfig, AXPWidgetNode, AXPWidgetProperty } from '@acorex/platform/layout/builder';
+import { EventEmitter, WritableSignal } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface AXPWidgetPropertyTab {
+    name: string;
+    title: string;
+    groups: {
+        name: string;
+        title: string;
+        isCollapsed: boolean;
+        props: AXPWidgetProperty[];
+    }[];
+}
+export interface AXPWidgetPropertiesChangedEvent {
+    values: any;
+    mode: 'init' | 'update';
+}
+export declare class AXPWidgetPropertyViewerComponent {
+    widget: import("@angular/core").InputSignal<AXPWidgetNode>;
+    private widgetRegistryService;
+    protected currentTabIndex: WritableSignal<number>;
+    protected config: WritableSignal<AXPWidgetConfig | null>;
+    protected allPoperties: AXPWidgetProperty[];
+    protected tabs: WritableSignal<AXPWidgetPropertyTab[]>;
+    protected groups: import("@angular/core").Signal<{
+        name: string;
+        title: string;
+        isCollapsed: boolean;
+        props: AXPWidgetProperty[];
+    }[]>;
+    onChanged: EventEmitter<AXPWidgetPropertiesChangedEvent>;
+    protected context: WritableSignal<any>;
+    protected initialContext: any;
+    constructor();
+    private fillTabs;
+    protected handleContextChange(e: AXPLayoutContextEvent): void;
+    protected handleTabChange(event: AXTabStripChangedEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetPropertyViewerComponent, "axp-widget-property-viewer", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
+}