ngx-histaff-alpha 5.2.2 → 5.2.3

package/lib/app/libraries/core-radio-group/core-radio-group/core-radio-group.component.d.ts

@@ -1,4 +1,4 @@
-import { OnDestroy, OnInit } from '@angular/core';
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
 import { CoreFormControlBaseComponent } from '../../core-form-control-base/core-form-control-base.component';
 import { AlertService } from '../../alert/alert.service';
 import { BehaviorSubject, Subscription } from 'rxjs';
@@ -12,16 +12,21 @@ export interface ICoreRadioOption {
 export declare class CoreRadioGroupComponent extends CoreFormControlBaseComponent implements OnInit, OnDestroy {
     private mls;
     private alertService;
+    private cdr;
     options$: BehaviorSubject<ICoreRadioOption[]>;
     vertical: boolean;
+    columnCount: number;
+    gapY: number;
     options: ICoreRadioOption[];
     lang: string;
     subscriptions: Subscription[];
     disabledMessage: EnumTranslateKey;
-    constructor(mls: MultiLanguageService, alertService: AlertService);
+    constructor(mls: MultiLanguageService, alertService: AlertService, cdr: ChangeDetectorRef);
     ngOnInit(): void;
     onLabelClick(e: ICoreRadioOption): void;
+    get useMultiColumn(): boolean;
+    get containerStyle(): any;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreRadioGroupComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CoreRadioGroupComponent, "core-radio-group", never, { "options$": { "alias": "options$"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoreRadioGroupComponent, "core-radio-group", never, { "options$": { "alias": "options$"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "columnCount": { "alias": "columnCount"; "required": false; }; "gapY": { "alias": "gapY"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/app/libraries/core-rule-tree/core-rule-tree.component.d.ts

@@ -48,8 +48,8 @@ export declare class CoreRuleTreeComponent extends BaseComponent {
     addCondition(groupForm: FormGroup): void;
     removeCondition(filterGroup: FormGroup, index: number): void;
     resolveControl(fieldName: string): IFormBaseControl | undefined;
-    private trueLeaf;
     safeStringify(obj: any): string;
+    formatDateToYMD(date: Date): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreRuleTreeComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<CoreRuleTreeComponent, "core-rule-tree", never, { "$totalCols": { "alias": "$totalCols"; "required": false; "isSignal": true; }; "$mainForm": { "alias": "$mainForm"; "required": false; "isSignal": true; }; "$filterStringInput": { "alias": "$filterStringInput"; "required": false; "isSignal": true; }; "$expressionInput": { "alias": "$expressionInput"; "required": false; "isSignal": true; }; }, { "$jsonEmitter": "$jsonEmitter"; "$expressionEmitter": "$expressionEmitter"; }, never, never, true, never>;
 }

package/lib/app/libraries/core-workflow-builder/constants/INITIAL_PROCESS_DEFINITION.d.ts

@@ -0,0 +1,2 @@
+import { IStep } from '../interfaces/IStep';
+export declare const INITIAL_PROCESS_DEFINITION: IStep[];

package/lib/app/libraries/core-workflow-builder/core-workflow-consume/core-workflow-consume.component.d.ts

@@ -0,0 +1,9 @@
+import { CoreWorkflowListComponent } from '../core-workflow-list/core-workflow-list.component';
+import { IWfWorkflow } from '../interfaces/IWfWorkflow';
+import * as i0 from "@angular/core";
+export declare class CoreWorkflowConsumeComponent extends CoreWorkflowListComponent {
+    sendRequest(flow: IWfWorkflow): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreWorkflowConsumeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CoreWorkflowConsumeComponent, "core-workflow-consume", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/core-workflow-list/core-workflow-list.component.d.ts

@@ -8,18 +8,20 @@ import { IWfWorkflow } from '../interfaces/IWfWorkflow';
 import { AlertService } from '../../alert/alert.service';
 import { Subject } from 'rxjs';
 import { IWfWorkflowGroup } from '../interfaces/IWfWorkflowGroup';
+import { CoreFormDesignService } from '../../core-form-design/core-form-design.service';
 import * as i0 from "@angular/core";
 export declare class CoreWorkflowListComponent extends BaseComponent implements AfterViewInit {
-    private router;
-    private route;
+    router: Router;
+    route: ActivatedRoute;
     coreWorkflowService: CoreWorkflowService;
-    private appService;
+    coreFormDesignService: CoreFormDesignService;
+    appService: AppService;
     private alertService;
     mls: MultiLanguageService;
     $loading: import("@angular/core").WritableSignal<boolean>;
     $sortMode: import("@angular/core").WritableSignal<boolean>;
     orderChanges$: Subject<IWfWorkflowGroup[]>;
-    constructor(router: Router, route: ActivatedRoute, coreWorkflowService: CoreWorkflowService, appService: AppService, alertService: AlertService, mls: MultiLanguageService);
+    constructor(router: Router, route: ActivatedRoute, coreWorkflowService: CoreWorkflowService, coreFormDesignService: CoreFormDesignService, appService: AppService, alertService: AlertService, mls: MultiLanguageService);
     createWorkflowGroup(): void;
     createWorkflow(groupId: number | undefined): void;
     editWorkflow(flow: IWfWorkflow): void;

package/lib/app/libraries/core-workflow-builder/core-workflow.service.d.ts

@@ -1,5 +1,5 @@
 import { WritableSignal } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
 import { AppService } from '../../services/app.service';
 import { IWfWorkflowGroup } from './interfaces/IWfWorkflowGroup';
 import { IWfWorkflow } from './interfaces/IWfWorkflow';
@@ -8,6 +8,7 @@ import { EnumWorkflowStepType } from './enums/EnumWorkflowStepType';
 import { IWorkflowBranch } from './interfaces/IWorkflowBranch';
 import { IWorkflowInsertPoint } from './interfaces/IWorkflowInsertPoint';
 import { IFormBaseControl } from '../core-form/core-form/enum-interfaces';
+import { IActorAssignment } from './interfaces/IActorAssignment';
 import * as i0 from "@angular/core";
 export declare class CoreWorkflowService {
     private appService;
@@ -18,12 +19,18 @@ export declare class CoreWorkflowService {
     $currentStep: WritableSignal<IStep | null>;
     $availableCols: WritableSignal<IFormBaseControl[]>;
     $showStepConfig: WritableSignal<boolean>;
+    $stepUpdated: WritableSignal<number>;
     standardConnectorHeight: number;
     $currentSteps: WritableSignal<IStep[]>;
+    $showCurrentStepsPreview: WritableSignal<boolean>;
+    $selectedActorAssignment: WritableSignal<IActorAssignment | null>;
     insertContext$: BehaviorSubject<IWorkflowInsertPoint | null>;
     insertAnchorPoint$: BehaviorSubject<DOMRect | null>;
+    subscriptions: Subscription[];
+    $stepsJsonPreview: import("@angular/core").Signal<string>;
     constructor(appService: AppService);
-    refresh(): void;
+    updateStep(updatedStep: IStep): void;
+    refresh(endpoint?: string): void;
     createConditionalBranchStep(branchId: string): IStep;
     createStep(type: EnumWorkflowStepType, branchId: string, label: string): {
         id: `${string}-${string}-${string}-${string}-${string}`;
@@ -38,6 +45,10 @@ export declare class CoreWorkflowService {
     loadAfInstance(afInstanceId: string): Observable<any>;
     extractValidFieldsFromSections(sectionsJson: string): IFormBaseControl[];
     updateGroupOrder(newOrder: IWfWorkflowGroup[]): Observable<any>;
+    updateStepsSignalAfterNestedChange(signal: WritableSignal<IStep[]>, mutate: (draft: IStep[]) => void): void;
+    saveCurrentSteps(): void;
+    getById(id: string): void;
+    extractActorAssignment(step: IStep | null): IActorAssignment | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreWorkflowService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CoreWorkflowService>;
 }

package/lib/app/libraries/core-workflow-builder/enums/EnumActorSourceType.d.ts

@@ -0,0 +1,10 @@
+export declare enum EnumActorSourceType {
+    Employee = "Employee",// Direct EMPLOYEE_ID
+    Manager = "Manager",// LM of original requester (supports level: N)
+    DepartmentSupervisor = "DepartmentSupervisor",// Supervisor in requester's ORG (supports level: N)
+    Position = "Position",// Fixed HU_POSITION.ID → MASTER
+    Requester = "Requester",// Original workflow initiator
+    StepRecipient = "StepRecipient",// Actor of a referenced previous step
+    UserGroup = "UserGroup",// SYS_USER.GROUP_ID
+    SelfSelection = "SelfSelection"
+}

package/lib/app/libraries/core-workflow-builder/interfaces/IActorAssignment.d.ts

@@ -0,0 +1,7 @@
+import { EnumActorSourceType } from "../enums/EnumActorSourceType";
+export interface IActorAssignment {
+    source: EnumActorSourceType;
+    level?: number;
+    stepKey?: string;
+    staticValueIds?: number[];
+}

package/lib/app/libraries/core-workflow-builder/interfaces/IStepConfig.d.ts

@@ -1,5 +1,38 @@
-export interface IStepConfig {
-    description?: string;
-    condition?: Record<string, any>;
-    [key: string]: any;
+import { IFormBaseControl } from "../../core-form/core-form/enum-interfaces";
+export interface IBaseStepConfig {
+    permissions?: any[];
+    ccRecipients?: string[];
+    label?: string;
+}
+export type IStepConfig = ISubmitStepConfig | IApprovalStepConfig | IHandlerStepConfig | ICcStepConfig | IEndStepConfig | IBranchCardConfig;
+export interface IBranchCardConfig {
+    conditionJson?: any;
+    conditionExpression?: string;
+    fields?: IFormBaseControl[];
+    isFallback?: boolean;
+}
+export interface IApprovalStepConfig extends IBaseStepConfig {
+    approvers: any[];
+    approvalType: 'Manual' | 'Auto-approve' | 'Auto-reject';
+    selectionMethod?: 'Single' | 'Multi';
+    routingLogic?: 'AllMustApprove' | 'AnyCanApprove' | 'Sequential';
+}
+export interface ICcStepConfig extends IBaseStepConfig {
+    recipients: any[];
+}
+export interface ISubmitStepConfig extends IBaseStepConfig {
+    allowedSubmitters: any[];
+}
+export interface IEndStepConfig extends IBaseStepConfig {
+}
+export interface IHandlerStepConfig extends IBaseStepConfig {
+    kind: 'Handler';
+    handler: any;
+    autoComplete?: boolean;
+}
+export interface IActorStepConfig extends IBaseStepConfig {
+    selection: 'User' | 'Manager' | 'Department' | 'Role' | 'FormField';
+    allowSelfSelect?: boolean;
+    multiSelect?: boolean;
+    behavior?: 'Approve' | 'Notify' | 'Task' | 'Trigger';
 }

package/lib/app/libraries/core-workflow-builder/interfaces/IWfWorkflow.d.ts

@@ -1,4 +1,5 @@
 import { IFormBaseControl } from "../../core-form/core-form/enum-interfaces";
+import { IStep } from "./IStep";
 export interface IWfWorkflow {
     id: string;
     groupId: number;
@@ -7,4 +8,6 @@ export interface IWfWorkflow {
     afInstanceId?: string;
     description?: string;
     fields?: IFormBaseControl[];
+    steps: IStep[];
+    processDefinition?: string;
 }

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-node/wf-node.component.d.ts

@@ -13,6 +13,7 @@ export declare class WfNodeComponent extends BaseComponent implements AfterViewI
     branchPriority: number;
     stepGroup: IStep[];
     conditionalBranches: IWorkflowBranch[];
+    isRootLevelStepGroup: boolean;
     grandParentSteps: IStep[] | null;
     isInFallbackBranch: boolean;
     branchHeader: ElementRef;
@@ -29,6 +30,7 @@ export declare class WfNodeComponent extends BaseComponent implements AfterViewI
     bridgeLineService: BridgeLineService;
     stepNameEditMode: boolean;
     onInputBlur(): void;
+    onStepNameChanged(newName: string): void;
     getBranchColumnElements(): HTMLElement[];
     private setupClickOutsideListener;
     private removeClickOutsideListener;
@@ -42,5 +44,5 @@ export declare class WfNodeComponent extends BaseComponent implements AfterViewI
     openConditionEditor(): void;
     openNoneBranchRelatedEditor(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WfNodeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WfNodeComponent, "wf-node", never, { "branchId": { "alias": "branchId"; "required": true; }; "step": { "alias": "step"; "required": true; }; "index": { "alias": "index"; "required": true; }; "branchPriority": { "alias": "branchPriority"; "required": true; }; "stepGroup": { "alias": "stepGroup"; "required": true; }; "conditionalBranches": { "alias": "conditionalBranches"; "required": false; }; "grandParentSteps": { "alias": "grandParentSteps"; "required": false; }; "isInFallbackBranch": { "alias": "isInFallbackBranch"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfNodeComponent, "wf-node", never, { "branchId": { "alias": "branchId"; "required": true; }; "step": { "alias": "step"; "required": true; }; "index": { "alias": "index"; "required": true; }; "branchPriority": { "alias": "branchPriority"; "required": true; }; "stepGroup": { "alias": "stepGroup"; "required": true; }; "conditionalBranches": { "alias": "conditionalBranches"; "required": false; }; "isRootLevelStepGroup": { "alias": "isRootLevelStepGroup"; "required": false; }; "grandParentSteps": { "alias": "grandParentSteps"; "required": false; }; "isInFallbackBranch": { "alias": "isInFallbackBranch"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-process-design.component.d.ts

@@ -1,10 +1,19 @@
+import { AfterViewInit } from '@angular/core';
 import { CoreWorkflowService } from '../core-workflow.service';
 import { ICoreButtonVNS } from '../../core-button-group-vns/core-button-group-vns/ICoreButtonVNS';
+import { BaseComponent } from '../../base-component/base/base.component';
+import { MultiLanguageService } from '../../../services/multi-language.service';
+import { ActivatedRoute } from '@angular/router';
 import * as i0 from "@angular/core";
-export declare class WfProcessDesignComponent {
-    coreWorkflowService: CoreWorkflowService;
-    constructor(coreWorkflowService: CoreWorkflowService);
+export declare class WfProcessDesignComponent extends BaseComponent implements AfterViewInit {
+    mls: MultiLanguageService;
+    private route;
+    wfs: CoreWorkflowService;
+    $loading: import("@angular/core").WritableSignal<boolean>;
+    id: string | null;
+    constructor(mls: MultiLanguageService, route: ActivatedRoute);
     onCorePageHeaderButtonClicked(e: ICoreButtonVNS): void;
+    ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WfProcessDesignComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<WfProcessDesignComponent, "wf-process-design", never, {}, {}, never, never, true, never>;
 }

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-actor-selector/wf-actor-selector.component.d.ts

@@ -0,0 +1,40 @@
+import { ChangeDetectorRef, WritableSignal } from '@angular/core';
+import { BaseComponent } from '../../../../base-component/base/base.component';
+import { EnumActorSourceType } from '../../../enums/EnumActorSourceType';
+import { ICoreRadioOption } from '../../../../core-radio-group/core-radio-group/core-radio-group.component';
+import { BehaviorSubject } from 'rxjs';
+import { IActorAssignment } from '../../../interfaces/IActorAssignment';
+import { ICoreDropdownOption } from '../../../../../interfaces/ICoreDropdownOption';
+import { ICoreParamControl } from '../../../../core-header-params/enum-and-interfaces';
+import { CoreWorkflowService } from '../../../core-workflow.service';
+import { IStepConfig } from '../../../interfaces/IStepConfig';
+import * as i0 from "@angular/core";
+export declare class WfActorSelectorComponent extends BaseComponent {
+    wfs: CoreWorkflowService;
+    $value: WritableSignal<IActorAssignment | null>;
+    $valueChange: import("@angular/core").OutputEmitterRef<IActorAssignment | null>;
+    levelSpecificOptions$: BehaviorSubject<ICoreDropdownOption[]>;
+    employeeObjectList$: BehaviorSubject<any[]>;
+    positionObjectList$: BehaviorSubject<any[]>;
+    onNgModelChange: (ngModel: string, value: any) => void;
+    levelSpecificControl: ICoreParamControl;
+    employeeIdsControl: ICoreParamControl;
+    positionIdsControl: ICoreParamControl;
+    cdr: ChangeDetectorRef;
+    readonly AVAILABLE_SOURCES: EnumActorSourceType[];
+    ngOnInit(): void;
+    updateLevelOptions(source: EnumActorSourceType): void;
+    actorSourceOptions$: BehaviorSubject<ICoreRadioOption[]>;
+    unsupportedYetactorSourceOptions$: BehaviorSubject<ICoreRadioOption[]>;
+    $showEmployeeSeeker: import("@angular/core").Signal<boolean>;
+    $showPositionSeeker: import("@angular/core").Signal<boolean>;
+    $showLevel: import("@angular/core").Signal<boolean>;
+    $showStepKey: import("@angular/core").Signal<boolean>;
+    onSourceChanged(newSource: EnumActorSourceType): void;
+    onStaticValueSelected(value: number[]): void;
+    onLevelChanged(level: number): void;
+    onStepKeyChanged(key: string): void;
+    updateCurrentStepConfigPatch<T extends IStepConfig>(patch: Partial<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfActorSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfActorSelectorComponent, "wf-actor-selector", never, {}, { "$valueChange": "$valueChange"; }, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-approver-config/wf-approver-config.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class WfApproverConfigComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfApproverConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfApproverConfigComponent, "wf-approver-config", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-cc-config/wf-cc-config.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class WfCcConfigComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfCcConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfCcConfigComponent, "wf-cc-config", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-end-config/wf-end-config.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class WfEndConfigComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfEndConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfEndConfigComponent, "wf-end-config", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-handler-config/wf-handler-config.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class WfHandlerConfigComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfHandlerConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfHandlerConfigComponent, "wf-handler-config", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-step-config-shell.component.d.ts

@@ -1,24 +1,23 @@
-import { AfterViewInit, ElementRef, Renderer2, ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { ElementRef, Renderer2, ChangeDetectorRef } from '@angular/core';
 import { FormGroup } from '@angular/forms';
 import { CoreWorkflowService } from '../../core-workflow.service';
+import { EnumWorkflowStepType } from '../../enums/EnumWorkflowStepType';
 import { DomService } from '../../../services/dom.service';
 import * as i0 from "@angular/core";
-export declare class WfStepConfigShellComponent implements AfterViewInit, OnDestroy {
+export declare class WfStepConfigShellComponent {
     coreWorkflowService: CoreWorkflowService;
     private domService;
     $container: import("@angular/core").Signal<ElementRef<any> | undefined>;
-    listenerFn: () => void;
     renderer: Renderer2;
     cdr: ChangeDetectorRef;
+    enumType: typeof EnumWorkflowStepType;
     constructor(coreWorkflowService: CoreWorkflowService, domService: DomService);
-    ngAfterViewInit(): void;
     $stepFormGroup: import("@angular/core").Signal<FormGroup<any>>;
     $isBranchCard: import("@angular/core").Signal<boolean>;
     $canRenderRuleTree: import("@angular/core").Signal<boolean>;
     buildFormGroupFromStep(config?: any): FormGroup;
     close(): void;
     save(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WfStepConfigShellComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<WfStepConfigShellComponent, "wf-step-config-shell", never, {}, {}, never, never, true, never>;
 }

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-step-config-shell/wf-submit-config/wf-submit-config.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class WfSubmitConfigComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfSubmitConfigComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfSubmitConfigComponent, "wf-submit-config", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-steps-preview/wf-steps-preview.component.d.ts

@@ -0,0 +1,8 @@
+import { CoreWorkflowService } from '../../core-workflow.service';
+import { BaseComponent } from '../../../base-component/base/base.component';
+import * as i0 from "@angular/core";
+export declare class WfStepsPreviewComponent extends BaseComponent {
+    wfs: CoreWorkflowService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WfStepsPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WfStepsPreviewComponent, "wf-steps-preview", never, {}, {}, never, never, true, never>;
+}

package/lib/app/libraries/core-workflow-builder/wf-process-design/wf-workflow-canvas.component.d.ts

@@ -1,4 +1,4 @@
-import { ElementRef, WritableSignal } from '@angular/core';
+import { AfterViewInit, ChangeDetectorRef, ElementRef, OnDestroy, WritableSignal } from '@angular/core';
 import { IStep } from '../interfaces/IStep';
 import { CoreWorkflowService } from '../core-workflow.service';
 import { EnumWorkflowStepType } from '../enums/EnumWorkflowStepType';
@@ -7,16 +7,40 @@ import { IWorkflowInsertPoint } from '../interfaces/IWorkflowInsertPoint';
 import { IWorkflowBranch } from '../interfaces/IWorkflowBranch';
 import { BaseComponent } from '../../base-component/base/base.component';
 import { MultiLanguageService } from '../../../services/multi-language.service';
+import { ApplicationHelpService } from '../../../services/application-help.service';
+import { DomService } from '../../services/dom.service';
 import * as i0 from "@angular/core";
-export declare class WfWorkflowCanvasComponent extends BaseComponent {
+export declare class WfWorkflowCanvasComponent extends BaseComponent implements AfterViewInit, OnDestroy {
     mls: MultiLanguageService;
+    $width: WritableSignal<number>;
+    $height: WritableSignal<number>;
     $container: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    $printArea: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    $zoomTools: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    $parent: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    hotKeys: string[];
     enumType: typeof EnumWorkflowStepType;
     ROOT_BRANCH_ID: string;
-    coreWorkflowService: CoreWorkflowService;
+    wfs: CoreWorkflowService;
     $steps: WritableSignal<IStep[]>;
+    applicationHelpService: ApplicationHelpService;
+    domService: DomService;
     insertIndex: number | null;
+    $previewZIndex: WritableSignal<number>;
+    $scale: WritableSignal<number>;
+    $scalePercent: import("@angular/core").Signal<string>;
+    cdr: ChangeDetectorRef;
+    $mouseDown: WritableSignal<boolean>;
+    $isDragging: import("@angular/core").Signal<boolean>;
+    $startX: WritableSignal<any>;
+    $scrollLeft: WritableSignal<any>;
+    $startY: WritableSignal<any>;
+    $scrollTop: WritableSignal<any>;
     constructor(mls: MultiLanguageService);
+    startDragging(e: any, flag: any): void;
+    stopDragging(e: any, flag: any): void;
+    moveEvent(e: any): void;
+    ngAfterViewInit(): void;
     findBranchById(branchId: string, steps?: IStep[]): IWorkflowBranch | undefined;
     safeInsertStep(branchId: string | null, index: number, newStep: IStep): void;
     insertStep(event: IInsertStepEvent): void;
@@ -28,6 +52,11 @@ export declare class WfWorkflowCanvasComponent extends BaseComponent {
     tempOnLabelClicked(): void;
     onInsert(event: IInsertStepEvent): void;
     clearInsertContext(): void;
+    showStepsJSON(): void;
+    zoonIn(): void;
+    zoonOut(): void;
+    zoonFeat(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WfWorkflowCanvasComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<WfWorkflowCanvasComponent, "wf-workflow-canvas", never, {}, {}, never, never, true, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-histaff-alpha",
-  "version": "5.2.2",
+  "version": "5.2.3",
   "peerDependencies": {
     "@angular/common": "^19.0.1",
     "@angular/core": "^19.0.1"