@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/esm2022/tableview/action/components/editor/action-editor.component.mjs

@@ -0,0 +1,97 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, EventEmitter, Injector, Input, Output, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { CommonsInternalError, ComponentDirective, DialogKeydownHandlerDirective } from '@mediusinc/mng-commons/core';
+import { ActionEditorDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
+import { ActionEditorInjectorContextComponent } from './injector-context/action-editor-injector-context.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@mediusinc/mng-commons/core";
+export class ActionEditorComponent {
+    constructor() {
+        this.injContextCmpType = ActionEditorInjectorContextComponent;
+        this.injector = inject(Injector);
+        this.destroyRef = inject(DestroyRef);
+        this.dialogConfig = inject(DynamicDialogConfig, { optional: true });
+        this.actionRunEventEmitter = new EventEmitter();
+        this.actionCancelEventEmitter = new EventEmitter();
+        this.isDialog = false;
+    }
+    get actionEditor() {
+        return this.actionEditorWInjContextCmp;
+    }
+    get formEditorCmp() {
+        return this.actionEditor?.formEditorCmp;
+    }
+    ngOnInit() {
+        let dialogData = undefined;
+        if (this.dialogConfig?.data) {
+            dialogData = this.dialogConfig.data;
+            this.isDialog = true;
+            // set injector from provided one
+            this.injector = dialogData.injector;
+        }
+        this.actionEditorWInjContextInputData = {
+            isDialog: this.isDialog,
+            dialogConfig: this.dialogConfig ?? undefined,
+            descriptor: dialogData?.action.descriptor ?? this.action,
+            actionInstance: dialogData?.action.instance,
+            previousActionInstance: dialogData?.action.previousInstance,
+            itemId: dialogData?.action.instance.activationParameters?.itemId ?? this.itemIdInput,
+            item: dialogData?.action.instance.activationParameters?.item ?? this.itemInput,
+            actionData: dialogData?.action.instance.activationParameters?.actionData ?? this.actionData,
+            dataProvider: this.dataProvider
+        };
+    }
+    ngOnChanges(changes) {
+        if (changes['itemIdInput'] && !changes['itemIdInput'].firstChange) {
+            this.actionEditorWInjContextCmp?.updateItemId(this.itemIdInput);
+        }
+        if (changes['itemInput'] && !changes['itemInput'].firstChange) {
+            this.actionEditorWInjContextCmp?.updateItem(this.itemInput);
+        }
+    }
+    onActionEditorWInjContextCmp(cmp) {
+        if (this.actionEditorWInjContextCmp) {
+            throw new CommonsInternalError('Action editor injection context component is already initialized');
+        }
+        this.actionEditorWInjContextCmp = cmp;
+        this.actionEditorWInjContextCmp.actionCancelEventEmitter.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(action => {
+            this.actionCancelEventEmitter.emit(action);
+        });
+        this.actionEditorWInjContextCmp.actionRunEventEmitter.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(action => {
+            this.actionRunEventEmitter.emit(action);
+        });
+    }
+    cancel() {
+        this.actionEditorWInjContextCmp?.cancel();
+    }
+    triggerSubmit() {
+        this.actionEditorWInjContextCmp?.triggerSubmit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ActionEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: ActionEditorComponent, isStandalone: true, selector: "mng-action-editor", inputs: { action: "action", itemIdInput: ["itemId", "itemIdInput"], itemInput: ["item", "itemInput"], actionData: "actionData", dataProvider: "dataProvider" }, outputs: { actionRunEventEmitter: "actionSubmit", actionCancelEventEmitter: "actionCancel" }, usesOnChanges: true, hostDirectives: [{ directive: i1.DialogKeydownHandlerDirective }], ngImport: i0, template: "<div\n    [mngComponent]=\"injContextCmpType\"\n    [inputs]=\"{\n        data: actionEditorWInjContextInputData\n    }\"\n    [nodeInjector]=\"injector\"\n    (instanceCreated)=\"onActionEditorWInjContextCmp($event)\"></div>\n", dependencies: [{ kind: "directive", type: ComponentDirective, selector: "[mngComponent]", inputs: ["mngComponent", "injectionToken", "inputs", "attachToHost", "nodeInjector"], outputs: ["instanceCreated"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ActionEditorComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'mng-action-editor', imports: [ComponentDirective], hostDirectives: [DialogKeydownHandlerDirective], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n    [mngComponent]=\"injContextCmpType\"\n    [inputs]=\"{\n        data: actionEditorWInjContextInputData\n    }\"\n    [nodeInjector]=\"injector\"\n    (instanceCreated)=\"onActionEditorWInjContextCmp($event)\"></div>\n" }]
+        }], propDecorators: { action: [{
+                type: Input,
+                args: [{ required: true }]
+            }], itemIdInput: [{
+                type: Input,
+                args: ['itemId']
+            }], itemInput: [{
+                type: Input,
+                args: ['item']
+            }], actionData: [{
+                type: Input
+            }], dataProvider: [{
+                type: Input
+            }], actionRunEventEmitter: [{
+                type: Output,
+                args: ['actionSubmit']
+            }], actionCancelEventEmitter: [{
+                type: Output,
+                args: ['actionCancel']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action-editor.component.js","sourceRoot":"","sources":["../../../../../../tableview/src/action/components/editor/action-editor.component.ts","../../../../../../tableview/src/action/components/editor/action-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {ChangeDetectionStrategy, Component, DestroyRef, EventEmitter, Injector, Input, OnChanges, OnInit, Output, SimpleChanges, Type, inject} from '@angular/core';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\n\nimport {DynamicDialogConfig} from 'primeng/dynamicdialog';\n\nimport {ActionData, CommonsInternalError, ComponentDirective, DialogKeydownHandlerDirective, IDataProvider, IdType} from '@mediusinc/mng-commons/core';\nimport {ActionEditorDescriptorInst} from '@mediusinc/mng-commons/tableview/api';\n\nimport {ActionEditorDialogData} from '../../models/action-editor-dialog-data.model';\nimport {ActionEditorInjectorContextComponent, ActionEditorInjectorContextInputData} from './injector-context/action-editor-injector-context.component';\n\n@Component({\n    standalone: true,\n    selector: 'mng-action-editor',\n    templateUrl: './action-editor.component.html',\n    imports: [ComponentDirective],\n    hostDirectives: [DialogKeydownHandlerDirective],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class ActionEditorComponent<T = any, S = any> implements OnInit, OnChanges {\n    public readonly injContextCmpType = ActionEditorInjectorContextComponent as Type<any>;\n\n    public injector = inject(Injector);\n    public readonly destroyRef = inject(DestroyRef);\n    private readonly dialogConfig = inject(DynamicDialogConfig, {optional: true});\n\n    // metadata and editor mode input\n    @Input({required: true}) public action!: ActionEditorDescriptorInst<T, S>;\n\n    // data source inputs\n    @Input('itemId') public itemIdInput?: IdType;\n    @Input('item') public itemInput?: T;\n    @Input() public actionData?: ActionData;\n    @Input() public dataProvider?: IDataProvider<T, S>;\n\n    @Output('actionSubmit') public actionRunEventEmitter = new EventEmitter<T | null | undefined>();\n    @Output('actionCancel') public actionCancelEventEmitter = new EventEmitter<T | null | undefined>();\n\n    private actionEditorWInjContextCmp?: ActionEditorInjectorContextComponent<T, S>;\n    public actionEditorWInjContextInputData?: ActionEditorInjectorContextInputData<T, S>;\n\n    private isDialog = false;\n\n    public get actionEditor() {\n        return this.actionEditorWInjContextCmp;\n    }\n\n    public get formEditorCmp() {\n        return this.actionEditor?.formEditorCmp;\n    }\n\n    ngOnInit() {\n        let dialogData: ActionEditorDialogData<T, S> | undefined = undefined;\n\n        if (this.dialogConfig?.data) {\n            dialogData = this.dialogConfig.data as ActionEditorDialogData<T, S>;\n            this.isDialog = true;\n\n            // set injector from provided one\n            this.injector = dialogData.injector;\n        }\n\n        this.actionEditorWInjContextInputData = {\n            isDialog: this.isDialog,\n            dialogConfig: this.dialogConfig ?? undefined,\n            descriptor: dialogData?.action.descriptor ?? this.action,\n            actionInstance: dialogData?.action.instance,\n            previousActionInstance: dialogData?.action.previousInstance,\n            itemId: dialogData?.action.instance.activationParameters?.itemId ?? this.itemIdInput,\n            item: dialogData?.action.instance.activationParameters?.item ?? this.itemInput,\n            actionData: dialogData?.action.instance.activationParameters?.actionData ?? this.actionData,\n            dataProvider: this.dataProvider\n        };\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['itemIdInput'] && !changes['itemIdInput'].firstChange) {\n            this.actionEditorWInjContextCmp?.updateItemId(this.itemIdInput);\n        }\n        if (changes['itemInput'] && !changes['itemInput'].firstChange) {\n            this.actionEditorWInjContextCmp?.updateItem(this.itemInput);\n        }\n    }\n\n    public onActionEditorWInjContextCmp(cmp: ActionEditorInjectorContextComponent<T, S>) {\n        if (this.actionEditorWInjContextCmp) {\n            throw new CommonsInternalError('Action editor injection context component is already initialized');\n        }\n        this.actionEditorWInjContextCmp = cmp;\n        this.actionEditorWInjContextCmp.actionCancelEventEmitter.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(action => {\n            this.actionCancelEventEmitter.emit(action);\n        });\n        this.actionEditorWInjContextCmp.actionRunEventEmitter.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(action => {\n            this.actionRunEventEmitter.emit(action);\n        });\n    }\n\n    public cancel() {\n        this.actionEditorWInjContextCmp?.cancel();\n    }\n\n    public triggerSubmit() {\n        this.actionEditorWInjContextCmp?.triggerSubmit();\n    }\n}\n","<div\n    [mngComponent]=\"injContextCmpType\"\n    [inputs]=\"{\n        data: actionEditorWInjContextInputData\n    }\"\n    [nodeInjector]=\"injector\"\n    (instanceCreated)=\"onActionEditorWInjContextCmp($event)\"></div>\n"]}