@acorex/platform 1.0.0

package/esm2022/schema/lib/widget/widget-base.mjs

@@ -0,0 +1,110 @@
+import { AXFormatService } from '@acorex/core/format';
+import { ChangeDetectorRef, EventEmitter, Injectable, Input, Output, inject } from '@angular/core';
+import { cloneDeep, merge } from 'lodash-es';
+import { AXP_WIDGET_TOKEN } from './widget-token';
+import * as i0 from "@angular/core";
+export class AXPWidgetBase {
+    constructor() {
+        this.cdr = inject(ChangeDetectorRef);
+        this.token = inject(AXP_WIDGET_TOKEN);
+        this.formatService = inject(AXFormatService);
+        this.markForCheck = inject(ChangeDetectorRef).markForCheck;
+    }
+    get schema() {
+        return this.token.schema;
+    }
+    get prop() {
+        return this.token.prop;
+    }
+    //   protected get multiple(): boolean {
+    //     return this.token.prop.multiple ?? false;
+    //   }
+    get formats() {
+        return merge(cloneDeep(this.schema.formats), this.token.prop.formats);
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        this.render();
+        this.cdr.markForCheck();
+    }
+    render() { }
+    setOption(name, value) {
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetBase, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { context: [{
+                type: Input
+            }] } });
+export class AXPWidgetEditBase extends AXPWidgetBase {
+    constructor() {
+        super(...arguments);
+        this.valueChange = new EventEmitter();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.valueChange.emit(v);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    get validations() {
+        const merged = [...(this.schema.validationRules ?? []), ...(this.token.prop.validationRules ?? [])];
+        return merged;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetEditBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetEditBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetEditBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+export class AXPWidgetFilterBase extends AXPWidgetBase {
+    constructor() {
+        super(...arguments);
+        this.operatorChange = new EventEmitter();
+        this.valueChange = new EventEmitter();
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(op) {
+        this._operator = op;
+        this.operatorChange.emit(op);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.valueChange.emit(v);
+        this.render();
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetFilterBase, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetFilterBase }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetFilterBase, decorators: [{
+            type: Injectable
+        }], propDecorators: { operatorChange: [{
+                type: Output
+            }], operator: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/schema/lib/widget/widget-column-renderer.mjs

@@ -0,0 +1,99 @@
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, TemplateRef, ViewChild, inject, } from '@angular/core';
+import { assign, cloneDeep, merge } from 'lodash-es';
+import { AXPSchemaRegistryService } from '../schema-registery.service';
+import { AXP_WIDGET_TOKEN } from './widget-token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    constructor() {
+        super(...arguments);
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.mergedOptions = {};
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+    }
+    get template() {
+        return this._template;
+    }
+    get loadingEnabled() {
+        return true;
+    }
+    get name() {
+        return `col-${this.dataField}`;
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+    }
+    async ngOnInit() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        if (schema?.component?.column)
+            this.component = await schema?.component?.column.component();
+        this.mergedOptions = merge(cloneDeep(schema?.component.column?.options), this.options) || {};
+        const tokenValue = {
+            prop: {
+                name: this.dataField,
+                formats: { default: this.displayFormat },
+            },
+            schema: schema,
+        };
+        this.widgetInjector = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        this.width = this.mergedOptions.width ?? '200px';
+        this.cdr.markForCheck();
+    }
+    getInputs(data) {
+        return assign(this.mergedOptions, { context: data });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: AXPWidgetColumnRendererComponent, selector: "axp-widget-column-renderer", inputs: { width: "width", caption: "caption", headerTemplate: "headerTemplate", allowSorting: "allowSorting", fixed: "fixed", options: "options", dataField: "dataField", displayFormat: "displayFormat", schemaName: ["schema", "schemaName"] }, providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }], viewQueries: [{ propertyName: "_template", first: true, predicate: TemplateRef, descendants: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container
+        *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
+      ></ng-container>
+      }
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetColumnRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-column-renderer',
+                    template: `
+    <ng-template let-row>
+      @if(component && widgetInjector && row?.data) {
+      <ng-container
+        *ngComponentOutlet="component; injector: widgetInjector; inputs: getInputs(row.data)"
+      ></ng-container>
+      }
+    </ng-template>
+  `,
+                    providers: [{ provide: AXDataTableColumnComponent, useExisting: AXPWidgetColumnRendererComponent }],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    inputs: ['width', 'caption', 'headerTemplate', 'allowSorting', 'fixed'],
+                }]
+        }], propDecorators: { _template: [{
+                type: ViewChild,
+                args: [TemplateRef]
+            }], options: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], displayFormat: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/schema/lib/widget/widget-filter-renderer.mjs

@@ -0,0 +1,133 @@
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Injector, Input, Output, inject, } from '@angular/core';
+import { assign, cloneDeep, isEqual, merge } from 'lodash-es';
+import { AXPSchemaRegistryService } from '../schema-registery.service';
+import { AXP_WIDGET_TOKEN } from './widget-token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/portal";
+import * as i2 from "@acorex/components/skeleton";
+export class AXPWidgetFilterRendererComponent {
+    constructor() {
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.isLoading = true;
+        this.valueChange = new EventEmitter();
+        this.operatorChange = new EventEmitter();
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+        this.options = {};
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+        this.updateValue();
+        this.valueChange.emit(v);
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(op) {
+        this._operator = op;
+        this.updateOperator();
+        this.operatorChange.emit(op);
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+        setTimeout(async () => {
+            await this.render();
+        });
+    }
+    async render() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        this.options =
+            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.filter?.options), schema?.component?.filter?.options) || {};
+        const tokenValue = {
+            prop: this.prop,
+            schema: schema,
+        };
+        const token = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        if (schema?.component && schema.component.filter?.component) {
+            var com = await schema.component.filter?.component();
+            this.portal = new ComponentPortal(com, null, token);
+            this.isLoading = false;
+            this.cdr.markForCheck();
+        }
+    }
+    updateValue() {
+        if (this.instance) {
+            this.instance.value = this.value;
+        }
+    }
+    updateOperator() {
+        if (this.instance) {
+            this.instance.operator = this.operator;
+        }
+    }
+    handleAttached(portalOutletRef) {
+        portalOutletRef = portalOutletRef;
+        this.instance = portalOutletRef.instance;
+        // console.log(this.schemaName, this.instance);
+        assign(this.instance, this.options);
+        this.updateValue();
+        this.updateOperator();
+        this.instance.valueChange.subscribe((v) => {
+            if (!isEqual(v, this.value)) {
+                this.value = v;
+            }
+        });
+        this.instance.operatorChange.subscribe((op) => {
+            if (!isEqual(op, this.operator)) {
+                this.operator = op;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetFilterRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: AXPWidgetFilterRendererComponent, selector: "axp-widget-filter-renderer", inputs: { value: "value", operator: "operator", prop: "prop", schemaName: ["schema", "schemaName"] }, outputs: { valueChange: "valueChange", operatorChange: "operatorChange" }, host: { styleAttribute: "display: contents;" }, ngImport: i0, template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetFilterRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-filter-renderer',
+                    template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents;' },
+                }]
+        }], propDecorators: { valueChange: [{
+                type: Output
+            }], operatorChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], operator: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-filter-renderer.js","sourceRoot":"","sources":["../../../../../../../libs/platform/schema/src/lib/widget/widget-filter-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  EventEmitter,\n  Injector,\n  Input,\n  Output,\n  inject,\n} from '@angular/core';\nimport { assign, cloneDeep, isEqual, merge } from 'lodash-es';\nimport { AXPComponentOptions } from '../component-loader';\nimport { AXPSchemaRegistryService } from '../schema-registery.service';\nimport { AXPWidgetBase, AXPWidgetFilterBase } from './widget-base';\nimport { AXP_WIDGET_TOKEN } from './widget-token';\n\n@Component({\n  selector: 'axp-widget-filter-renderer',\n  template: `\n    @if(isLoading){\n    <ax-skeleton [animated]=\"true\" class=\"ax-w-full ax-h-8 ax-rounded\"></ax-skeleton>\n    } @else {\n    <ng-template [cdkPortalOutlet]=\"portal\" (attached)=\"handleAttached($event)\"></ng-template>\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { style: 'display: contents;' },\n})\nexport class AXPWidgetFilterRendererComponent {\n  private widgetRegistery = inject(AXPSchemaRegistryService);\n  protected isLoading = true;\n\n  @Output()\n  valueChange: EventEmitter<any> = new EventEmitter<any>();\n  @Output()\n  operatorChange: EventEmitter<any> = new EventEmitter<any>();\n\n  private _value: any;\n  @Input()\n  public get value(): any {\n    return this._value;\n  }\n\n  public set value(v: any) {\n    this._value = v;\n    this.updateValue();\n    this.valueChange.emit(v);\n  }\n\n  private _operator: any;\n  @Input()\n  public get operator(): any {\n    return this._operator;\n  }\n\n  public set operator(op: any) {\n    this._operator = op;\n    this.updateOperator();\n    this.operatorChange.emit(op);\n  }\n\n  @Input()\n  prop!: any;\n\n  private _schemaName!: string;\n  @Input('schema')\n  public get schemaName(): string {\n    return this._schemaName;\n  }\n  public set schemaName(v: string) {\n    this._schemaName = v;\n    setTimeout(async () => {\n      await this.render();\n    });\n  }\n\n  private injector = inject(Injector);\n  private cdr = inject(ChangeDetectorRef);\n  private instance!: AXPWidgetFilterBase;\n  private options: AXPComponentOptions = {};\n  protected portal!: ComponentPortal<any>;\n\n  private async render() {\n    const schema = this.widgetRegistery.resolve(this.schemaName);\n    this.options =\n      merge(\n        cloneDeep(this.prop?.component?.common?.options),\n        cloneDeep(this.prop?.component?.filter?.options),\n        schema?.component?.filter?.options\n      ) || {};\n    const tokenValue = {\n      prop: this.prop,\n      schema: schema,\n    };\n    const token = Injector.create({\n      parent: this.injector,\n      providers: [\n        {\n          provide: AXP_WIDGET_TOKEN,\n          useValue: tokenValue,\n        },\n      ],\n    });\n    if (schema?.component && schema.component.filter?.component) {\n      var com = await schema.component.filter?.component();\n      this.portal = new ComponentPortal(com, null, token);\n      this.isLoading = false;\n      this.cdr.markForCheck();\n    }\n  }\n\n  private updateValue() {\n    if (this.instance) {\n      this.instance.value = this.value;\n    }\n  }\n\n  private updateOperator() {\n    if (this.instance) {\n      this.instance.operator = this.operator;\n    }\n  }\n\n  protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef) {\n    portalOutletRef = portalOutletRef as ComponentRef<AXPWidgetBase>;\n    this.instance = portalOutletRef.instance as AXPWidgetFilterBase;\n    // console.log(this.schemaName, this.instance);\n    assign(this.instance, this.options);\n    this.updateValue();\n    this.updateOperator();\n    this.instance.valueChange.subscribe((v) => {\n      if (!isEqual(v, this.value)) {\n        this.value = v;\n      }\n    });\n    this.instance.operatorChange.subscribe((op) => {\n      if (!isEqual(op, this.operator)) {\n        this.operator = op;\n      }\n    });\n  }\n}\n"]}

package/esm2022/schema/lib/widget/widget-renderer.mjs

@@ -0,0 +1,144 @@
+import { AXUnsubscriber } from '@acorex/core/utils';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, inject, } from '@angular/core';
+import { assign, cloneDeep, merge } from 'lodash-es';
+import { AXPSchemaRegistryService } from '../schema-registery.service';
+import { AXPWidgetEditBase } from './widget-base';
+import { AXP_WIDGET_TOKEN } from './widget-token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/portal";
+import * as i2 from "@acorex/components/skeleton";
+export class AXPWidgetRendererComponent {
+    constructor() {
+        this.widgetRegistery = inject(AXPSchemaRegistryService);
+        this.subscriber = inject(AXUnsubscriber);
+        this.mode = 'view';
+        this.isLoading = true;
+        this.injector = inject(Injector);
+        this.cdr = inject(ChangeDetectorRef);
+        this.options = {};
+    }
+    get context() {
+        return this._context;
+    }
+    set context(v) {
+        this._context = v;
+        if (this.instance) {
+            this.instance.context = v;
+        }
+        this.updateValue();
+    }
+    get schemaName() {
+        return this._schemaName;
+    }
+    set schemaName(v) {
+        this._schemaName = v;
+        setTimeout(async () => {
+            //TODO: move to better place
+            await this.render();
+        });
+    }
+    async render() {
+        const schema = this.widgetRegistery.resolve(this.schemaName);
+        this.options =
+            merge(cloneDeep(this.prop?.component?.common?.options), cloneDeep(this.prop?.component?.[this.mode]?.options), schema?.component?.[this.mode]?.options) || {};
+        const tokenValue = {
+            prop: this.prop,
+            schema: schema,
+        };
+        const token = Injector.create({
+            parent: this.injector,
+            providers: [
+                {
+                    provide: AXP_WIDGET_TOKEN,
+                    useValue: tokenValue,
+                },
+            ],
+        });
+        if (schema?.component && schema.component[this.mode]?.component) {
+            var com = await schema.component[this.mode]?.component();
+            this.portal = new ComponentPortal(com, null, token);
+            this.isLoading = false;
+            this.cdr.markForCheck();
+        }
+    }
+    updateValue() {
+        if (this.instance && this.context && this.instance instanceof AXPWidgetEditBase) {
+            this.instance.value = this.context[this.prop.name];
+        }
+    }
+    updateProps() {
+        if (this.instance) {
+            assign(this.instance, this.options);
+        }
+    }
+    handleAttached(portalOutletRef) {
+        portalOutletRef = portalOutletRef;
+        this.instance = portalOutletRef.instance;
+        this.instance.context = this.context;
+        this.updateProps();
+        this.updateValue();
+        if (this.instance instanceof AXPWidgetEditBase) {
+            this.instance.valueChange.pipe(this.subscriber.takeUntilDestroy).subscribe((v) => {
+                this.context[this.prop.name] = v;
+                if (this.options['reference']) {
+                    const valueField = this.prop.component?.common?.options?.valueField || 'id';
+                    const referenceField = this.options['referenceField'];
+                    if (referenceField) {
+                        if (Array.isArray(v)) {
+                            this.context[referenceField] = v.map((item) => item[valueField]);
+                        }
+                        else {
+                            this.context[referenceField] = v[valueField];
+                        }
+                    }
+                    else {
+                        this.context[`${this.prop.name}Id`] = v[valueField];
+                    }
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.1.2", type: AXPWidgetRendererComponent, selector: "axp-widget-renderer", inputs: { context: "context", prop: "prop", mode: "mode", schemaName: ["schema", "schemaName"] }, host: { styleAttribute: "display: contents;" }, providers: [
+            {
+                provide: AXUnsubscriber,
+            },
+        ], ngImport: i0, template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }, { kind: "component", type: i2.AXSkeletonComponent, selector: "ax-skeleton", inputs: ["animated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWidgetRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-widget-renderer',
+                    template: `
+    @if(isLoading){
+    <ax-skeleton [animated]="true" class="ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded"></ax-skeleton>
+    } @else {
+    <ng-template [cdkPortalOutlet]="portal" (attached)="handleAttached($event)"></ng-template>
+    }
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: { style: 'display: contents;' },
+                    providers: [
+                        {
+                            provide: AXUnsubscriber,
+                        },
+                    ],
+                }]
+        }], propDecorators: { context: [{
+                type: Input
+            }], prop: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], schemaName: [{
+                type: Input,
+                args: ['schema']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-renderer.js","sourceRoot":"","sources":["../../../../../../../libs/platform/schema/src/lib/widget/widget-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAA8B,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAClF,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EAET,QAAQ,EACR,KAAK,EACL,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAiB,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;;;;AAmBlD,MAAM,OAAO,0BAA0B;IAjBvC;QAkBU,oBAAe,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;QACnD,eAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAoB5C,SAAI,GAAoB,MAAM,CAAC;QAErB,cAAS,GAAG,IAAI,CAAC;QAenB,aAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5B,QAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAEhC,YAAO,GAAwB,EAAE,CAAC;KAuE3C;IA5GC,IACW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,IAAW,OAAO,CAAC,CAAM;QACvB,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAWD,IACW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAW,UAAU,CAAC,CAAS;QAC7B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,UAAU,CAAC,KAAK,IAAI,EAAE;YACpB,4BAA4B;YAC5B,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IAQO,KAAK,CAAC,MAAM;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,OAAO;YACV,KAAK,CACH,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAChD,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EACrD,MAAM,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,CACxC,IAAI,EAAE,CAAC;QACV,MAAM,UAAU,GAAG;YACjB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,MAAM;SACf,CAAC;QACF,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC;YAC5B,MAAM,EAAE,IAAI,CAAC,QAAQ;YACrB,SAAS,EAAE;gBACT;oBACE,OAAO,EAAE,gBAAgB;oBACzB,QAAQ,EAAE,UAAU;iBACrB;aACF;SACF,CAAC,CAAC;QACH,IAAI,MAAM,EAAE,SAAS,IAAI,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;YAChE,IAAI,GAAG,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC;YACzD,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;YACpD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,YAAY,iBAAiB,EAAE,CAAC;YAChF,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAEO,WAAW;QACjB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAES,cAAc,CAAC,eAA2C;QAClE,eAAe,GAAG,eAA8C,CAAC;QACjE,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC,QAAyB,CAAC;QAC1D,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QACrC,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,QAAQ,YAAY,iBAAiB,EAAE,CAAC;YAC/C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC/E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAEjC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC9B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,IAAI,IAAI,CAAC;oBAC5E,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;oBAEtD,IAAI,cAAc,EAAE,CAAC;wBACnB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;4BACrB,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;wBACxE,CAAC;6BAAM,CAAC;4BACN,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC;wBAC/C,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC;oBACtD,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;8GAhHU,0BAA0B;kGAA1B,0BAA0B,gMAN1B;YACT;gBACE,OAAO,EAAE,cAAc;aACxB;SACF,0BAbS;;;;;;GAMT;;2FASU,0BAA0B;kBAjBtC,SAAS;mBAAC;oBACT,QAAQ,EAAE,qBAAqB;oBAC/B,QAAQ,EAAE;;;;;;GAMT;oBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,IAAI,EAAE,EAAE,KAAK,EAAE,oBAAoB,EAAE;oBACrC,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,cAAc;yBACxB;qBACF;iBACF;8BAOY,OAAO;sBADjB,KAAK;gBAcN,IAAI;sBADH,KAAK;gBAIN,IAAI;sBADH,KAAK;gBAOK,UAAU;sBADpB,KAAK;uBAAC,QAAQ","sourcesContent":["import { AXUnsubscriber } from '@acorex/core/utils';\nimport { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  Injector,\n  Input,\n  inject,\n} from '@angular/core';\nimport { assign, cloneDeep, merge } from 'lodash-es';\nimport { AXPComponentOptions } from '../component-loader';\nimport { AXPSchemaRegistryService } from '../schema-registery.service';\nimport { AXPWidgetBase, AXPWidgetEditBase } from './widget-base';\nimport { AXP_WIDGET_TOKEN } from './widget-token';\n\n@Component({\n  selector: 'axp-widget-renderer',\n  template: `\n    @if(isLoading){\n    <ax-skeleton [animated]=\"true\" class=\"ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded\"></ax-skeleton>\n    } @else {\n    <ng-template [cdkPortalOutlet]=\"portal\" (attached)=\"handleAttached($event)\"></ng-template>\n    }\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: { style: 'display: contents;' },\n  providers: [\n    {\n      provide: AXUnsubscriber,\n    },\n  ],\n})\nexport class AXPWidgetRendererComponent {\n  private widgetRegistery = inject(AXPSchemaRegistryService);\n  private subscriber = inject(AXUnsubscriber);\n\n  private _context: any;\n  @Input()\n  public get context(): any {\n    return this._context;\n  }\n\n  public set context(v: any) {\n    this._context = v;\n    if (this.instance) {\n      this.instance.context = v;\n    }\n    this.updateValue();\n  }\n\n  @Input()\n  prop!: any;\n\n  @Input()\n  mode: 'view' | 'edit' = 'view';\n\n  protected isLoading = true;\n\n  private _schemaName!: string;\n  @Input('schema')\n  public get schemaName(): string {\n    return this._schemaName;\n  }\n  public set schemaName(v: string) {\n    this._schemaName = v;\n    setTimeout(async () => {\n      //TODO: move to better place\n      await this.render();\n    });\n  }\n\n  private injector = inject(Injector);\n  private cdr = inject(ChangeDetectorRef);\n  private instance!: AXPWidgetBase | AXPWidgetEditBase;\n  private options: AXPComponentOptions = {};\n  protected portal!: ComponentPortal<any>;\n\n  private async render() {\n    const schema = this.widgetRegistery.resolve(this.schemaName);\n    this.options =\n      merge(\n        cloneDeep(this.prop?.component?.common?.options),\n        cloneDeep(this.prop?.component?.[this.mode]?.options),\n        schema?.component?.[this.mode]?.options\n      ) || {};\n    const tokenValue = {\n      prop: this.prop,\n      schema: schema,\n    };\n    const token = Injector.create({\n      parent: this.injector,\n      providers: [\n        {\n          provide: AXP_WIDGET_TOKEN,\n          useValue: tokenValue,\n        },\n      ],\n    });\n    if (schema?.component && schema.component[this.mode]?.component) {\n      var com = await schema.component[this.mode]?.component();\n      this.portal = new ComponentPortal(com, null, token);\n      this.isLoading = false;\n      this.cdr.markForCheck();\n    }\n  }\n\n  private updateValue() {\n    if (this.instance && this.context && this.instance instanceof AXPWidgetEditBase) {\n      this.instance.value = this.context[this.prop.name];\n    }\n  }\n\n  private updateProps() {\n    if (this.instance) {\n      assign(this.instance, this.options);\n    }\n  }\n\n  protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef) {\n    portalOutletRef = portalOutletRef as ComponentRef<AXPWidgetBase>;\n    this.instance = portalOutletRef.instance as AXPWidgetBase;\n    this.instance.context = this.context;\n    this.updateProps();\n    this.updateValue();\n    if (this.instance instanceof AXPWidgetEditBase) {\n      this.instance.valueChange.pipe(this.subscriber.takeUntilDestroy).subscribe((v) => {\n        this.context[this.prop.name] = v;\n\n        if (this.options['reference']) {\n          const valueField = this.prop.component?.common?.options?.valueField || 'id';\n          const referenceField = this.options['referenceField'];\n\n          if (referenceField) {\n            if (Array.isArray(v)) {\n              this.context[referenceField] = v.map((item: any) => item[valueField]);\n            } else {\n              this.context[referenceField] = v[valueField];\n            }\n          } else {\n            this.context[`${this.prop.name}Id`] = v[valueField];\n          }\n        }\n      });\n    }\n  }\n}\n"]}

package/esm2022/schema/lib/widget/widget-token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const AXP_WIDGET_TOKEN = new InjectionToken('AXP_WIDGET_TOKEN');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LXRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wbGF0Zm9ybS9zY2hlbWEvc3JjL2xpYi93aWRnZXQvd2lkZ2V0LXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFnQi9DLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLElBQUksY0FBYyxDQUFxQixrQkFBa0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFYUERpc3BsYXlGb3JtYXQgfSBmcm9tICcuLi9mb3JtYXRzJztcbmltcG9ydCB7IEFYUFNjaGVtYUNvbmZpZywgQVhQVmFsaWRhdGlvblJ1bGVzIH0gZnJvbSAnLi4vc2NoZW1hJztcblxuZXhwb3J0IGludGVyZmFjZSBBWFBXaWRnZXRQcm9wZXJ0eSB7XG4gIG5hbWU6IHN0cmluZztcbiAgZGVzY3JpcHRpb24/OiBzdHJpbmcsXG4gIGZvcm1hdHM6IEFYUERpc3BsYXlGb3JtYXQ7XG4gIHZhbGlkYXRpb25SdWxlcz86IEFYUFZhbGlkYXRpb25SdWxlc1xuICBjYW5FZGl0OiBib29sZWFuO1xufVxuZXhwb3J0IGludGVyZmFjZSBBWFBXaWRnZXRUb2tlblR5cGUge1xuICBzY2hlbWE6IEFYUFNjaGVtYUNvbmZpZztcbiAgcHJvcDogQVhQV2lkZ2V0UHJvcGVydHk7XG59XG5cbmV4cG9ydCBjb25zdCBBWFBfV0lER0VUX1RPS0VOID0gbmV3IEluamVjdGlvblRva2VuPEFYUFdpZGdldFRva2VuVHlwZT4oJ0FYUF9XSURHRVRfVE9LRU4nKTtcbiJdfQ==

package/esm2022/workflow/acorex-platform-workflow.mjs

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

package/esm2022/workflow/index.mjs

@@ -0,0 +1,7 @@
+export * from './lib/errors.types';
+export * from './lib/workflow-event-dispatcher.service';
+export * from './lib/workflow-registery.service';
+export * from './lib/workflow.module';
+export * from './lib/workflow.service';
+export * from './lib/workflow.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL3dvcmtmbG93L3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2Vycm9ycy50eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi93b3JrZmxvdy1ldmVudC1kaXNwYXRjaGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd29ya2Zsb3ctcmVnaXN0ZXJ5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd29ya2Zsb3cubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dvcmtmbG93LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd29ya2Zsb3cudHlwZXMnO1xuIl19

package/esm2022/workflow/lib/errors.types.mjs

@@ -0,0 +1,8 @@
+export class AXPWorkflowError extends Error {
+    constructor(message, inner = null) {
+        super(message);
+        this.inner = inner;
+        this.name = 'AXPWorkflowError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wbGF0Zm9ybS93b3JrZmxvdy9zcmMvbGliL2Vycm9ycy50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZ0JBQWlCLFNBQVEsS0FBSztJQUN2QyxZQUFZLE9BQWUsRUFBUyxRQUFzQixJQUFJO1FBQzFELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQURpQixVQUFLLEdBQUwsS0FBSyxDQUFxQjtRQUUxRCxJQUFJLENBQUMsSUFBSSxHQUFHLGtCQUFrQixDQUFDO0lBQ25DLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBBWFBXb3JrZmxvd0Vycm9yIGV4dGVuZHMgRXJyb3Ige1xuICAgIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgcHVibGljIGlubmVyOiBFcnJvciB8IG51bGwgPSBudWxsKSB7XG4gICAgICAgIHN1cGVyKG1lc3NhZ2UpO1xuICAgICAgICB0aGlzLm5hbWUgPSAnQVhQV29ya2Zsb3dFcnJvcic7XG4gICAgfVxufSJdfQ==

package/esm2022/workflow/lib/workflow-event-dispatcher.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class AXPWorkflowEventService {
+    constructor() {
+        this.eventSubject = new Subject();
+    }
+    dispatch(event) {
+        this.eventSubject.next(event);
+    }
+    get events$() {
+        return this.eventSubject.asObservable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowEventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowEventService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: AXPWorkflowEventService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2Zsb3ctZXZlbnQtZGlzcGF0Y2hlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wbGF0Zm9ybS93b3JrZmxvdy9zcmMvbGliL3dvcmtmbG93LWV2ZW50LWRpc3BhdGNoZXIuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBTTNDLE1BQU0sT0FBTyx1QkFBdUI7SUFIcEM7UUFJVSxpQkFBWSxHQUFHLElBQUksT0FBTyxFQUFvQixDQUFDO0tBU3hEO0lBUEMsUUFBUSxDQUFDLEtBQXVCO1FBQzlCLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxJQUFJLE9BQU87UUFDVCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDMUMsQ0FBQzs4R0FUVSx1QkFBdUI7a0hBQXZCLHVCQUF1QixjQUZ0QixNQUFNOzsyRkFFUCx1QkFBdUI7a0JBSG5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgQVhQV29ya2Zsb3dFdmVudCB9IGZyb20gJy4vd29ya2Zsb3cudHlwZXMnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgQVhQV29ya2Zsb3dFdmVudFNlcnZpY2Uge1xuICBwcml2YXRlIGV2ZW50U3ViamVjdCA9IG5ldyBTdWJqZWN0PEFYUFdvcmtmbG93RXZlbnQ+KCk7XG5cbiAgZGlzcGF0Y2goZXZlbnQ6IEFYUFdvcmtmbG93RXZlbnQpOiB2b2lkIHtcbiAgICB0aGlzLmV2ZW50U3ViamVjdC5uZXh0KGV2ZW50KTtcbiAgfVxuXG4gIGdldCBldmVudHMkKCk6IE9ic2VydmFibGU8QVhQV29ya2Zsb3dFdmVudD4ge1xuICAgIHJldHVybiB0aGlzLmV2ZW50U3ViamVjdC5hc09ic2VydmFibGUoKTtcbiAgfVxufVxuIl19