@acorex/platform 18.0.0 → 18.0.2

package/esm2022/common/lib/schema/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: "18.0.2", ngImport: i0, type: AXPWidgetFilterRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.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: "18.0.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/common/src/lib/schema/widget/widget-filter-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';\r\nimport {\r\n  ChangeDetectionStrategy,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ComponentRef,\r\n  EventEmitter,\r\n  Injector,\r\n  Input,\r\n  Output,\r\n  inject,\r\n} from '@angular/core';\r\nimport { assign, cloneDeep, isEqual, merge } from 'lodash-es';\r\nimport { AXPComponentOptions } from '../component-loader';\r\nimport { AXPSchemaRegistryService } from '../schema-registery.service';\r\nimport { AXPWidgetBase, AXPWidgetFilterBase } from './widget-base';\r\nimport { AXP_WIDGET_TOKEN } from './widget-token';\r\n\r\n@Component({\r\n  selector: 'axp-widget-filter-renderer',\r\n  template: `\r\n    @if(isLoading){\r\n    <ax-skeleton [animated]=\"true\" class=\"ax-w-full ax-h-8 ax-rounded\"></ax-skeleton>\r\n    } @else {\r\n    <ng-template [cdkPortalOutlet]=\"portal\" (attached)=\"handleAttached($event)\"></ng-template>\r\n    }\r\n  `,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  host: { style: 'display: contents;' },\r\n})\r\nexport class AXPWidgetFilterRendererComponent {\r\n  private widgetRegistery = inject(AXPSchemaRegistryService);\r\n  protected isLoading = true;\r\n\r\n  @Output()\r\n  valueChange: EventEmitter<any> = new EventEmitter<any>();\r\n  @Output()\r\n  operatorChange: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n  private _value: any;\r\n  @Input()\r\n  public get value(): any {\r\n    return this._value;\r\n  }\r\n\r\n  public set value(v: any) {\r\n    this._value = v;\r\n    this.updateValue();\r\n    this.valueChange.emit(v);\r\n  }\r\n\r\n  private _operator: any;\r\n  @Input()\r\n  public get operator(): any {\r\n    return this._operator;\r\n  }\r\n\r\n  public set operator(op: any) {\r\n    this._operator = op;\r\n    this.updateOperator();\r\n    this.operatorChange.emit(op);\r\n  }\r\n\r\n  @Input()\r\n  prop!: any;\r\n\r\n  private _schemaName!: string;\r\n  @Input('schema')\r\n  public get schemaName(): string {\r\n    return this._schemaName;\r\n  }\r\n  public set schemaName(v: string) {\r\n    this._schemaName = v;\r\n    setTimeout(async () => {\r\n      await this.render();\r\n    });\r\n  }\r\n\r\n  private injector = inject(Injector);\r\n  private cdr = inject(ChangeDetectorRef);\r\n  private instance!: AXPWidgetFilterBase;\r\n  private options: AXPComponentOptions = {};\r\n  protected portal!: ComponentPortal<any>;\r\n\r\n  private async render() {\r\n    const schema = this.widgetRegistery.resolve(this.schemaName);\r\n    this.options =\r\n      merge(\r\n        cloneDeep(this.prop?.component?.common?.options),\r\n        cloneDeep(this.prop?.component?.filter?.options),\r\n        schema?.component?.filter?.options\r\n      ) || {};\r\n    const tokenValue = {\r\n      prop: this.prop,\r\n      schema: schema,\r\n    };\r\n    const token = Injector.create({\r\n      parent: this.injector,\r\n      providers: [\r\n        {\r\n          provide: AXP_WIDGET_TOKEN,\r\n          useValue: tokenValue,\r\n        },\r\n      ],\r\n    });\r\n    if (schema?.component && schema.component.filter?.component) {\r\n      var com = await schema.component.filter?.component();\r\n      this.portal = new ComponentPortal(com, null, token);\r\n      this.isLoading = false;\r\n      this.cdr.markForCheck();\r\n    }\r\n  }\r\n\r\n  private updateValue() {\r\n    if (this.instance) {\r\n      this.instance.value = this.value;\r\n    }\r\n  }\r\n\r\n  private updateOperator() {\r\n    if (this.instance) {\r\n      this.instance.operator = this.operator;\r\n    }\r\n  }\r\n\r\n  protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef) {\r\n    portalOutletRef = portalOutletRef as ComponentRef<AXPWidgetBase>;\r\n    this.instance = portalOutletRef.instance as AXPWidgetFilterBase;\r\n    // console.log(this.schemaName, this.instance);\r\n    assign(this.instance, this.options);\r\n    this.updateValue();\r\n    this.updateOperator();\r\n    this.instance.valueChange.subscribe((v) => {\r\n      if (!isEqual(v, this.value)) {\r\n        this.value = v;\r\n      }\r\n    });\r\n    this.instance.operatorChange.subscribe((op) => {\r\n      if (!isEqual(op, this.operator)) {\r\n        this.operator = op;\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/common/lib/schema/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, get, merge, set } 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 = get(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) => {
+                set(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: "18.0.2", ngImport: i0, type: AXPWidgetRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.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: "18.0.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/common/src/lib/schema/widget/widget-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXUnsubscriber } from '@acorex/core/utils';\r\nimport { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';\r\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, Injector, Input, inject } from '@angular/core';\r\nimport { assign, cloneDeep, get, merge, set } from 'lodash-es';\r\nimport { AXPComponentOptions } from '../component-loader';\r\nimport { AXPSchemaRegistryService } from '../schema-registery.service';\r\nimport { AXPWidgetBase, AXPWidgetEditBase } from './widget-base';\r\nimport { AXP_WIDGET_TOKEN } from './widget-token';\r\n\r\n@Component({\r\n  selector: 'axp-widget-renderer',\r\n  template: `\r\n    @if(isLoading){\r\n    <ax-skeleton [animated]=\"true\" class=\"ax-w-full  lg:ax-w-[50%] ax-h-8 ax-rounded\"></ax-skeleton>\r\n    } @else {\r\n    <ng-template [cdkPortalOutlet]=\"portal\" (attached)=\"handleAttached($event)\"></ng-template>\r\n    }\r\n  `,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  host: { style: 'display: contents;' },\r\n  providers: [\r\n    {\r\n      provide: AXUnsubscriber,\r\n    },\r\n  ],\r\n})\r\nexport class AXPWidgetRendererComponent {\r\n  private widgetRegistery = inject(AXPSchemaRegistryService);\r\n  private subscriber = inject(AXUnsubscriber);\r\n\r\n  private _context: any;\r\n  @Input()\r\n  public get context(): any {\r\n    return this._context;\r\n  }\r\n\r\n  public set context(v: any) {\r\n    this._context = v;\r\n    if (this.instance) {\r\n      this.instance.context = v;\r\n    }\r\n    this.updateValue();\r\n  }\r\n\r\n  @Input()\r\n  prop!: any;\r\n\r\n  @Input()\r\n  mode: 'view' | 'edit' = 'view';\r\n\r\n  protected isLoading = true;\r\n\r\n  private _schemaName!: string;\r\n  @Input('schema')\r\n  public get schemaName(): string {\r\n    return this._schemaName;\r\n  }\r\n  public set schemaName(v: string) {\r\n    this._schemaName = v;\r\n    setTimeout(async () => {\r\n      //TODO: move to better place\r\n      await this.render();\r\n    });\r\n  }\r\n\r\n  private injector = inject(Injector);\r\n  private cdr = inject(ChangeDetectorRef);\r\n  private instance!: AXPWidgetBase | AXPWidgetEditBase;\r\n  private options: AXPComponentOptions = {};\r\n  protected portal!: ComponentPortal<any>;\r\n\r\n  private async render() {\r\n    const schema = this.widgetRegistery.resolve(this.schemaName);\r\n    this.options =\r\n      merge(\r\n        cloneDeep(this.prop?.component?.common?.options),\r\n        cloneDeep(this.prop?.component?.[this.mode]?.options),\r\n        schema?.component?.[this.mode]?.options\r\n      ) || {};\r\n    const tokenValue = {\r\n      prop: this.prop,\r\n      schema: schema,\r\n    };\r\n    const token = Injector.create({\r\n      parent: this.injector,\r\n      providers: [\r\n        {\r\n          provide: AXP_WIDGET_TOKEN,\r\n          useValue: tokenValue,\r\n        },\r\n      ],\r\n    });\r\n    if (schema?.component && schema.component[this.mode]?.component) {\r\n      var com = await schema.component[this.mode]?.component();\r\n      this.portal = new ComponentPortal(com, null, token);\r\n      this.isLoading = false;\r\n      this.cdr.markForCheck();\r\n    }\r\n  }\r\n\r\n  private updateValue() {\r\n    if (this.instance && this.context && this.instance instanceof AXPWidgetEditBase) {\r\n      this.instance.value = get(this.context, this.prop.name);\r\n    }\r\n  }\r\n\r\n  private updateProps() {\r\n    if (this.instance) {\r\n      assign(this.instance, this.options);\r\n    }\r\n  }\r\n\r\n  protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef) {\r\n    portalOutletRef = portalOutletRef as ComponentRef<AXPWidgetBase>;\r\n    this.instance = portalOutletRef.instance as AXPWidgetBase;\r\n    this.instance.context = this.context;\r\n    this.updateProps();\r\n    this.updateValue();\r\n    if (this.instance instanceof AXPWidgetEditBase) {\r\n      this.instance.valueChange.pipe(this.subscriber.takeUntilDestroy).subscribe((v) => {\r\n        set(this.context, this.prop.name, v);\r\n\r\n        if (this.options['reference']) {\r\n          const valueField = this.prop.component?.common?.options?.valueField || 'id';\r\n          const referenceField = this.options['referenceField'];\r\n\r\n          if (referenceField) {\r\n            if (Array.isArray(v)) {\r\n              this.context[referenceField] = v.map((item: any) => item[valueField]);\r\n            } else {\r\n              this.context[referenceField] = v?.[valueField];\r\n            }\r\n          } else {\r\n            this.context[`${this.prop.name}Id`] = v[valueField];\r\n          }\r\n        }\r\n      });\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/common/lib/schema/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LXRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wbGF0Zm9ybS9jb21tb24vc3JjL2xpYi9zY2hlbWEvd2lkZ2V0L3dpZGdldC10b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBaUIvQyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsa0JBQWtCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEFYUERpc3BsYXlGb3JtYXQgfSBmcm9tICcuLi9mb3JtYXRzJztcclxuaW1wb3J0IHsgQVhQU2NoZW1hQ29uZmlnIH0gZnJvbSAnLi4vc2NoZW1hLnR5cGVzJztcclxuaW1wb3J0IHsgQVhQVmFsaWRhdGlvblJ1bGVzIH0gZnJvbSAnLi4vLi4vYXBwJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVhQV2lkZ2V0UHJvcGVydHkge1xyXG4gIG5hbWU6IHN0cmluZztcclxuICBkZXNjcmlwdGlvbj86IHN0cmluZyxcclxuICBmb3JtYXRzOiBBWFBEaXNwbGF5Rm9ybWF0O1xyXG4gIHZhbGlkYXRpb25SdWxlcz86IEFYUFZhbGlkYXRpb25SdWxlc1xyXG4gIGNhbkVkaXQ6IGJvb2xlYW47XHJcbn1cclxuZXhwb3J0IGludGVyZmFjZSBBWFBXaWRnZXRUb2tlblR5cGUge1xyXG4gIHNjaGVtYTogQVhQU2NoZW1hQ29uZmlnO1xyXG4gIHByb3A6IEFYUFdpZGdldFByb3BlcnR5O1xyXG59XHJcblxyXG5leHBvcnQgY29uc3QgQVhQX1dJREdFVF9UT0tFTiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxBWFBXaWRnZXRUb2tlblR5cGU+KCdBWFBfV0lER0VUX1RPS0VOJyk7XHJcblxyXG4iXX0=

package/esm2022/common/lib/schema/widgets/avatar/avatar-widget-edit.component.mjs

@@ -0,0 +1,160 @@
+import { AXAvatarModule } from '@acorex/components/avatar';
+import { AXButtonModule } from '@acorex/components/button';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXImageModule } from '@acorex/components/image';
+import { AXLoadingModule } from '@acorex/components/loading';
+// import { FakePersonService } from '@acorex/platform/mocks';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { AXPDataProvider } from '../../../data';
+import { AXPWidgetEditBase } from '../../widget';
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/components/avatar";
+import * as i2 from "@acorex/components/image";
+import * as i3 from "@acorex/components/loading";
+import * as i4 from "@acorex/components/decorators";
+export class AXPAvatarWidgetEditComponent extends AXPWidgetEditBase {
+    constructor() {
+        super(...arguments);
+        this.dataService = inject(AXPDataProvider);
+        this.dialogService = inject(AXDialogService);
+    }
+    ngOnInit() {
+        this.render();
+    }
+    render() {
+        const rawValue = this.rawValue;
+        if (rawValue == null)
+            return;
+        this.loadImageById(rawValue);
+    }
+    handleRemoveItem(item) {
+        this.src = null;
+        this.value = null;
+    }
+    async handleAddItem() {
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.accept = 'image/*';
+        input.click();
+        input.addEventListener('change', async () => {
+            const file = input.files?.[0];
+            if (file) {
+                const maxSize = 1 * 1024 * 1024; // Example size limit: 1MB
+                const maxResolution = { width: 1920, height: 1080 }; // Example resolution limit
+                if (file.size > maxSize) {
+                    this.dialogService.alert('File too large!', `The selected file exceeds the maximum size of ${maxSize / (1024 * 1024)}MB.`, 'warning');
+                    return;
+                }
+                const image = new Image();
+                image.src = URL.createObjectURL(file);
+                image.onload = async () => {
+                    const { width, height } = image;
+                    if (width > maxResolution.width || height > maxResolution.height) {
+                        this.dialogService.alert('Resolution too high!', `The selected file exceeds the maximum resolution of ${maxResolution.width}x${maxResolution.height}.`, 'warning');
+                        return;
+                    }
+                    // If file size and resolution are within limits, proceed with upload
+                    try {
+                        const resolved = await this.dataService.uploadFile(file, file.name);
+                        console.log('resolved', resolved);
+                        this.src = URL.createObjectURL(file); // Show the image temporarily
+                        this.value = resolved; // Store the file ID
+                    }
+                    catch (error) {
+                        this.dialogService.alert('Something went wrong!', `${error}`, 'warning');
+                    }
+                };
+            }
+        }, { once: true });
+    }
+    async loadImageById(fileId) {
+        try {
+            const blob = await this.dataService.viewFile(fileId, '');
+            this.src = URL.createObjectURL(blob);
+            this.cdr.markForCheck(); // Explicitly mark for check since OnPush is used
+        }
+        catch (error) {
+            console.error('Failed to load image by ID:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAvatarWidgetEditComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPAvatarWidgetEditComponent, isStandalone: true, selector: "axp-number-widget-edit", usesInheritance: true, ngImport: i0, template: `
+    <div class="ax-w-fit ax-flex flex-row ax-border ax-rounded-lg ax-shadow-md ax-overflow-hidden">
+      @if(src){
+      <ax-avatar color="secondary" [size]="120" look="sharp">
+        <ax-image [src]="src">
+          <ax-loading></ax-loading>
+        </ax-image>
+      </ax-avatar>
+      } @else {
+      <ax-avatar color="secondary" [size]="120" look="sharp">
+        <ax-loading></ax-loading>
+      </ax-avatar>
+      }
+      <div class="ax-flex ax-w-14 ax-flex-col ax-items-center  ax-justify-around  ax-cursor-pointer ax-border-l-2">
+        <div
+          (click)="handleAddItem()"
+          class="ax-h-[50%] ax-flex ax-items-center ax-justify-center ax-w-full ax-border-b-2 hover:ax-bg-gray-100 hover:ax-text-blue-700 ax-cursor-pointer"
+        >
+          <ax-icon>
+            <i class="fa-solid fa-camera"></i>
+          </ax-icon>
+        </div>
+
+        <div
+          (click)="handleRemoveItem(src)"
+          class="ax-h-[50%] ax-flex ax-items-center  ax-justify-center ax-w-full ax-cursor-pointer  hover:ax-bg-gray-100"
+        >
+          <ax-prefix>
+            <i class="fa-solid fa-trash ax-text-danger"></i>
+          </ax-prefix>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: AXAvatarModule }, { kind: "component", type: i1.AXAvatarComponent, selector: "ax-avatar", inputs: ["color", "size", "look"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "component", type: i3.AXLoadingComponent, selector: "ax-loading", inputs: ["visible", "type", "context"], outputs: ["visibleChange"] }, { kind: "ngmodule", type: AXButtonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i4.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i4.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-sub-title, ax-placeholder, ax-overlay" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAvatarWidgetEditComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'axp-number-widget-edit',
+                    template: `
+    <div class="ax-w-fit ax-flex flex-row ax-border ax-rounded-lg ax-shadow-md ax-overflow-hidden">
+      @if(src){
+      <ax-avatar color="secondary" [size]="120" look="sharp">
+        <ax-image [src]="src">
+          <ax-loading></ax-loading>
+        </ax-image>
+      </ax-avatar>
+      } @else {
+      <ax-avatar color="secondary" [size]="120" look="sharp">
+        <ax-loading></ax-loading>
+      </ax-avatar>
+      }
+      <div class="ax-flex ax-w-14 ax-flex-col ax-items-center  ax-justify-around  ax-cursor-pointer ax-border-l-2">
+        <div
+          (click)="handleAddItem()"
+          class="ax-h-[50%] ax-flex ax-items-center ax-justify-center ax-w-full ax-border-b-2 hover:ax-bg-gray-100 hover:ax-text-blue-700 ax-cursor-pointer"
+        >
+          <ax-icon>
+            <i class="fa-solid fa-camera"></i>
+          </ax-icon>
+        </div>
+
+        <div
+          (click)="handleRemoveItem(src)"
+          class="ax-h-[50%] ax-flex ax-items-center  ax-justify-center ax-w-full ax-cursor-pointer  hover:ax-bg-gray-100"
+        >
+          <ax-prefix>
+            <i class="fa-solid fa-trash ax-text-danger"></i>
+          </ax-prefix>
+        </div>
+      </div>
+    </div>
+  `,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXAvatarModule, AXImageModule, AXLoadingModule, AXButtonModule, AXDecoratorModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avatar-widget-edit.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/platform/common/src/lib/schema/widgets/avatar/avatar-widget-edit.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AXAvatarModule } from '@acorex/components/avatar';\r\nimport { AXButtonModule } from '@acorex/components/button';\r\nimport { AXDecoratorModule } from '@acorex/components/decorators';\r\nimport { AXDialogService } from '@acorex/components/dialog';\r\nimport { AXImageModule } from '@acorex/components/image';\r\nimport { AXLoadingModule } from '@acorex/components/loading';\r\n// import { FakePersonService } from '@acorex/platform/mocks';\r\nimport { ChangeDetectionStrategy, Component, OnInit, inject } from '@angular/core';\r\nimport { AXPDataProvider } from '../../../data';\r\nimport { AXPWidgetEditBase } from '../../widget';\r\n\r\n@Component({\r\n  selector: 'axp-number-widget-edit',\r\n  template: `\r\n    <div class=\"ax-w-fit ax-flex flex-row ax-border ax-rounded-lg ax-shadow-md ax-overflow-hidden\">\r\n      @if(src){\r\n      <ax-avatar color=\"secondary\" [size]=\"120\" look=\"sharp\">\r\n        <ax-image [src]=\"src\">\r\n          <ax-loading></ax-loading>\r\n        </ax-image>\r\n      </ax-avatar>\r\n      } @else {\r\n      <ax-avatar color=\"secondary\" [size]=\"120\" look=\"sharp\">\r\n        <ax-loading></ax-loading>\r\n      </ax-avatar>\r\n      }\r\n      <div class=\"ax-flex ax-w-14 ax-flex-col ax-items-center  ax-justify-around  ax-cursor-pointer ax-border-l-2\">\r\n        <div\r\n          (click)=\"handleAddItem()\"\r\n          class=\"ax-h-[50%] ax-flex ax-items-center ax-justify-center ax-w-full ax-border-b-2 hover:ax-bg-gray-100 hover:ax-text-blue-700 ax-cursor-pointer\"\r\n        >\r\n          <ax-icon>\r\n            <i class=\"fa-solid fa-camera\"></i>\r\n          </ax-icon>\r\n        </div>\r\n\r\n        <div\r\n          (click)=\"handleRemoveItem(src)\"\r\n          class=\"ax-h-[50%] ax-flex ax-items-center  ax-justify-center ax-w-full ax-cursor-pointer  hover:ax-bg-gray-100\"\r\n        >\r\n          <ax-prefix>\r\n            <i class=\"fa-solid fa-trash ax-text-danger\"></i>\r\n          </ax-prefix>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  standalone: true,\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  imports: [AXAvatarModule, AXImageModule, AXLoadingModule, AXButtonModule, AXDecoratorModule],\r\n})\r\nexport class AXPAvatarWidgetEditComponent extends AXPWidgetEditBase implements OnInit {\r\n  dataService = inject(AXPDataProvider);\r\n  private dialogService = inject(AXDialogService);\r\n  protected src!: string | null;\r\n\r\n  ngOnInit() {\r\n    this.render();\r\n  }\r\n  override render() {\r\n    const rawValue = this.rawValue;\r\n    if (rawValue == null) return;\r\n    this.loadImageById(rawValue);\r\n  }\r\n\r\n  protected handleRemoveItem(item: any) {\r\n    this.src = null;\r\n    this.value = null;\r\n  }\r\n\r\n  protected async handleAddItem() {\r\n    const input = document.createElement('input');\r\n    input.type = 'file';\r\n    input.accept = 'image/*';\r\n    input.click();\r\n    input.addEventListener(\r\n      'change',\r\n      async () => {\r\n        const file = input.files?.[0];\r\n        if (file) {\r\n          const maxSize = 1 * 1024 * 1024; // Example size limit: 1MB\r\n          const maxResolution = { width: 1920, height: 1080 }; // Example resolution limit\r\n\r\n          if (file.size > maxSize) {\r\n            this.dialogService.alert('File too large!', `The selected file exceeds the maximum size of ${maxSize / (1024 * 1024)}MB.`, 'warning');\r\n            return;\r\n          }\r\n\r\n          const image = new Image();\r\n          image.src = URL.createObjectURL(file);\r\n          image.onload = async () => {\r\n            const { width, height } = image;\r\n\r\n            if (width > maxResolution.width || height > maxResolution.height) {\r\n              this.dialogService.alert(\r\n                'Resolution too high!',\r\n                `The selected file exceeds the maximum resolution of ${maxResolution.width}x${maxResolution.height}.`,\r\n                'warning'\r\n              );\r\n              return;\r\n            }\r\n\r\n            // If file size and resolution are within limits, proceed with upload\r\n            try {\r\n              const resolved = await this.dataService.uploadFile(file, file.name);\r\n              console.log('resolved', resolved);\r\n              this.src = URL.createObjectURL(file); // Show the image temporarily\r\n              this.value = resolved; // Store the file ID\r\n            } catch (error) {\r\n              this.dialogService.alert('Something went wrong!', `${error}`, 'warning');\r\n            }\r\n          };\r\n        }\r\n      },\r\n      { once: true }\r\n    );\r\n  }\r\n\r\n  private async loadImageById(fileId: string) {\r\n    try {\r\n      const blob = await this.dataService.viewFile(fileId, '');\r\n      this.src = URL.createObjectURL(blob);\r\n      this.cdr.markForCheck(); // Explicitly mark for check since OnPush is used\r\n    } catch (error) {\r\n      console.error('Failed to load image by ID:', error);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/common/lib/schema/widgets/avatar/avatar-widget-view.component.mjs

@@ -0,0 +1,63 @@
+import { AXAvatarModule } from '@acorex/components/avatar';
+import { AXImageModule } from '@acorex/components/image';
+import { AXLoadingModule } from '@acorex/components/loading';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { AXPDataProvider } from '../../../data';
+import { AXPWidgetBase } from '../../widget/widget-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/components/avatar";
+import * as i2 from "@acorex/components/image";
+import * as i3 from "@acorex/components/loading";
+export class AXPAvatarWidgetViewComponent extends AXPWidgetBase {
+    constructor() {
+        super(...arguments);
+        this.dataService = inject(AXPDataProvider);
+    }
+    ngOnInit() {
+        this.render();
+    }
+    render() {
+        const rawValue = this.rawValue;
+        if (rawValue == null)
+            return;
+        this.loadImageById(rawValue);
+    }
+    async loadImageById(fileId) {
+        try {
+            const blob = await this.dataService.viewFile(fileId, '');
+            this.src = URL.createObjectURL(blob);
+            this.cdr.markForCheck(); // Explicitly mark for check since OnPush is used
+        }
+        catch (error) {
+            console.error('Failed to load image by ID:', error);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAvatarWidgetViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPAvatarWidgetViewComponent, isStandalone: true, selector: "ax-Avatar-widget-view", inputs: { context: "context", value: "value" }, usesInheritance: true, ngImport: i0, template: ` @if(src){<ax-avatar class="ax-shadow-" color="secondary" [size]="120" look="soft">
+      <ax-image [src]="src"> <ax-loading></ax-loading></ax-image>
+    </ax-avatar>
+    } @else {
+    <ax-avatar color="secondary" [size]="120" look="sharp">
+      <ax-loading></ax-loading>
+    </ax-avatar>
+    }`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXAvatarModule }, { kind: "component", type: i1.AXAvatarComponent, selector: "ax-avatar", inputs: ["color", "size", "look"] }, { kind: "ngmodule", type: AXImageModule }, { kind: "component", type: i2.AXImageComponent, selector: "ax-image", inputs: ["overlayMode", "src", "alt", "priority", "lazy"], outputs: ["onLoad", "onError"] }, { kind: "ngmodule", type: AXLoadingModule }, { kind: "component", type: i3.AXLoadingComponent, selector: "ax-loading", inputs: ["visible", "type", "context"], outputs: ["visibleChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPAvatarWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ax-Avatar-widget-view',
+                    template: ` @if(src){<ax-avatar class="ax-shadow-" color="secondary" [size]="120" look="soft">
+      <ax-image [src]="src"> <ax-loading></ax-loading></ax-image>
+    </ax-avatar>
+    } @else {
+    <ax-avatar color="secondary" [size]="120" look="sharp">
+      <ax-loading></ax-loading>
+    </ax-avatar>
+    }`,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXAvatarModule, AXImageModule, AXLoadingModule],
+                    inputs: ['context', 'value'],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/schema/widgets/checkbox/checkbox-widget-column.component.mjs

@@ -0,0 +1,53 @@
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { AXPWidgetBase } from '../../widget/widget-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@acorex/components/decorators";
+export class AXPCheckboxWidgetColumnComponent extends AXPWidgetBase {
+    render() {
+        this.value = !!this.rawValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCheckboxWidgetColumnComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: AXPCheckboxWidgetColumnComponent, isStandalone: true, selector: "ng-component", inputs: { context: "context", trulyText: "trulyText", falsyText: "falsyText", negative: "negative", width: "width", allowResizing: "allowResizing" }, usesInheritance: true, ngImport: i0, template: `<div>
+    @if(value){ @if(trulyText){
+    <span [class]="negative ? 'ax-text-danger' : 'ax-text-success'">{{ trulyText }}</span>
+    }@else { @if(negative){
+    <ax-icon class="fa-solid fa-check ax-text-danger"> </ax-icon>
+    }@else{
+    <ax-icon class="fa-solid fa-check ax-text-success"> </ax-icon>
+
+    } } }@else { @if(falsyText){
+    <span [class]="negative ? 'ax-text-success' : 'ax-text-danger'">{{ falsyText }}</span>
+    }@else { @if(negative){
+    <ax-icon class="fa-solid fa-xmark ax-text-success"> </ax-icon>
+    }@else{
+    <ax-icon class="fa-solid fa-xmark ax-text-danger"> </ax-icon>
+    } } }
+  </div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AXPCheckboxWidgetColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `<div>
+    @if(value){ @if(trulyText){
+    <span [class]="negative ? 'ax-text-danger' : 'ax-text-success'">{{ trulyText }}</span>
+    }@else { @if(negative){
+    <ax-icon class="fa-solid fa-check ax-text-danger"> </ax-icon>
+    }@else{
+    <ax-icon class="fa-solid fa-check ax-text-success"> </ax-icon>
+
+    } } }@else { @if(falsyText){
+    <span [class]="negative ? 'ax-text-success' : 'ax-text-danger'">{{ falsyText }}</span>
+    }@else { @if(negative){
+    <ax-icon class="fa-solid fa-xmark ax-text-success"> </ax-icon>
+    }@else{
+    <ax-icon class="fa-solid fa-xmark ax-text-danger"> </ax-icon>
+    } } }
+  </div>`,
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [AXDecoratorModule],
+                    inputs: ['context', 'trulyText', 'falsyText', 'negative', 'width', 'allowResizing'],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtd2lkZ2V0LWNvbHVtbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3BsYXRmb3JtL2NvbW1vbi9zcmMvbGliL3NjaGVtYS93aWRnZXRzL2NoZWNrYm94L2NoZWNrYm94LXdpZGdldC1jb2x1bW4uY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDBCQUEwQixDQUFDOzs7QUF1QnpELE1BQU0sT0FBTyxnQ0FBaUMsU0FBUSxhQUFhO0lBTTlDLE1BQU07UUFDdkIsSUFBSSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUMvQixDQUFDOzhHQVJVLGdDQUFnQztrR0FBaEMsZ0NBQWdDLHFQQXJCakM7Ozs7Ozs7Ozs7Ozs7OztTQWVILDJEQUdHLGlCQUFpQjs7MkZBR2hCLGdDQUFnQztrQkF0QjVDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOzs7Ozs7Ozs7Ozs7Ozs7U0FlSDtvQkFDUCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLE9BQU8sRUFBRSxDQUFDLGlCQUFpQixDQUFDO29CQUM1QixNQUFNLEVBQUUsQ0FBQyxTQUFTLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLGVBQWUsQ0FBQztpQkFDcEYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBWERlY29yYXRvck1vZHVsZSB9IGZyb20gJ0BhY29yZXgvY29tcG9uZW50cy9kZWNvcmF0b3JzJztcclxuaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBBWFBXaWRnZXRCYXNlIH0gZnJvbSAnLi4vLi4vd2lkZ2V0L3dpZGdldC1iYXNlJztcclxuQENvbXBvbmVudCh7XHJcbiAgdGVtcGxhdGU6IGA8ZGl2PlxyXG4gICAgQGlmKHZhbHVlKXsgQGlmKHRydWx5VGV4dCl7XHJcbiAgICA8c3BhbiBbY2xhc3NdPVwibmVnYXRpdmUgPyAnYXgtdGV4dC1kYW5nZXInIDogJ2F4LXRleHQtc3VjY2VzcydcIj57eyB0cnVseVRleHQgfX08L3NwYW4+XHJcbiAgICB9QGVsc2UgeyBAaWYobmVnYXRpdmUpe1xyXG4gICAgPGF4LWljb24gY2xhc3M9XCJmYS1zb2xpZCBmYS1jaGVjayBheC10ZXh0LWRhbmdlclwiPiA8L2F4LWljb24+XHJcbiAgICB9QGVsc2V7XHJcbiAgICA8YXgtaWNvbiBjbGFzcz1cImZhLXNvbGlkIGZhLWNoZWNrIGF4LXRleHQtc3VjY2Vzc1wiPiA8L2F4LWljb24+XHJcblxyXG4gICAgfSB9IH1AZWxzZSB7IEBpZihmYWxzeVRleHQpe1xyXG4gICAgPHNwYW4gW2NsYXNzXT1cIm5lZ2F0aXZlID8gJ2F4LXRleHQtc3VjY2VzcycgOiAnYXgtdGV4dC1kYW5nZXInXCI+e3sgZmFsc3lUZXh0IH19PC9zcGFuPlxyXG4gICAgfUBlbHNlIHsgQGlmKG5lZ2F0aXZlKXtcclxuICAgIDxheC1pY29uIGNsYXNzPVwiZmEtc29saWQgZmEteG1hcmsgYXgtdGV4dC1zdWNjZXNzXCI+IDwvYXgtaWNvbj5cclxuICAgIH1AZWxzZXtcclxuICAgIDxheC1pY29uIGNsYXNzPVwiZmEtc29saWQgZmEteG1hcmsgYXgtdGV4dC1kYW5nZXJcIj4gPC9heC1pY29uPlxyXG4gICAgfSB9IH1cclxuICA8L2Rpdj5gLFxyXG4gIHN0YW5kYWxvbmU6IHRydWUsXHJcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXHJcbiAgaW1wb3J0czogW0FYRGVjb3JhdG9yTW9kdWxlXSxcclxuICBpbnB1dHM6IFsnY29udGV4dCcsICd0cnVseVRleHQnLCAnZmFsc3lUZXh0JywgJ25lZ2F0aXZlJywgJ3dpZHRoJywgJ2FsbG93UmVzaXppbmcnXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFYUENoZWNrYm94V2lkZ2V0Q29sdW1uQ29tcG9uZW50IGV4dGVuZHMgQVhQV2lkZ2V0QmFzZSB7XHJcbiAgcHJvdGVjdGVkIHZhbHVlITogYm9vbGVhbjtcclxuICBwcm90ZWN0ZWQgbmVnYXRpdmUhOiBib29sZWFuO1xyXG4gIHByb3RlY3RlZCB0cnVseVRleHQhOiBib29sZWFuO1xyXG4gIHByb3RlY3RlZCBmYWxzeVRleHQhOiBib29sZWFuO1xyXG5cclxuICBwcm90ZWN0ZWQgb3ZlcnJpZGUgcmVuZGVyKCk6IHZvaWQge1xyXG4gICAgdGhpcy52YWx1ZSA9ICEhdGhpcy5yYXdWYWx1ZTtcclxuICB9XHJcbn1cclxuIl19