@ssv/ngx.command 3.0.0-dev.36 → 3.0.0-dev.40

package/README.md

@@ -31,18 +31,15 @@ Choose the version corresponding to your Angular version:
 In order to start working with Command, you need to create a new instance of it.
 
 ```ts
-import { Command, CommandAsync, ICommand } from "@ssv/ngx.command";
+import { command, commandAsync } from "@ssv/ngx.command";
 
 isValid$ = new BehaviorSubject(false);
 
-// use `CommandAsync` when execute function returns an observable/promise OR else 3rd argument must be true.
-saveCmd = new Command(() => this.save()), this.isValid$);
+// non async
+saveCmd = command(() => this.save()), this.isValid$);
 
-// using CommandAsync
-saveCmd = new CommandAsync(() => Observable.timer(2000), this.isValid$);
-
-// using ICommand interface
-saveCmd: ICommand = new CommandAsync(() => Observable.timer(2000), this.isValid$);
+// async - returns an observable/promise.
+saveCmd = commandAsync(() => Observable.timer(2000), this.isValid$);
 ```
 
 ## Command Attribute (Directive)
@@ -135,12 +132,12 @@ In order to use with `NgForm` easily, you can use the following utility method.
 This will make canExecute respond to `form.valid` and for `form.dirty` - also can optionally disable validity or dirty.
 
 ```ts
-import { CommandAsync, canExecuteFromNgForm } from "@ssv/ngx.command";
+import { commandAsync, canExecuteFromNgForm } from "@ssv/ngx.command";
 
-loginCmd = new CommandAsync(x => this.login(), canExecuteFromNgForm(this.form));
+loginCmd = commandAsync(x => this.login(), canExecuteFromNgForm(this.form));
 
 // options - disable dirty check
-loginCmd = new CommandAsync(x => this.login(), canExecuteFromNgForm(this.form, {
+loginCmd = commandAsync(x => this.login(), canExecuteFromNgForm(this.form, {
   dirty: false
 }));
 

package/command-ref.directive.d.ts

@@ -0,0 +1,29 @@
+import { OnInit, OnDestroy } from "@angular/core";
+import { ICommand, CommandCreator } from "./command.model";
+import * as i0 from "@angular/core";
+/**
+ * Command creator ref, directive which allows creating Command in the template
+ * and associate it to a command (in order to share executions).
+ * @example
+ * ### Most common usage
+ * ```html
+ * <div #actionCmd="ssvCommandRef" [ssvCommandRef]="{host: this, execute: removeHero$, canExecute: isValid$}">
+ *    <button [ssvCommand]="actionCmd.command" [ssvCommandParams]="hero">
+ *      Remove
+ *    </button>
+ *    <button [ssvCommand]="actionCmd.command" [ssvCommandParams]="hero">
+ *       Remove
+ *    </button>
+ * </div>
+ * ```
+ *
+ */
+export declare class CommandRefDirective implements OnInit, OnDestroy {
+    commandCreator: CommandCreator | undefined;
+    get command(): ICommand;
+    private _command;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandRefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandRefDirective, "[ssvCommandRef]", ["ssvCommandRef"], { "commandCreator": { "alias": "ssvCommandRef"; "required": false; }; }, {}, never, never, true, never>;
+}

package/command.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from "rxjs";
+import type { ICommand } from "./command.model";
+import { type Signal } from "@angular/core";
+export type ExecuteFn = (...args: any[]) => unknown;
+export type ExecuteAsyncFn = (...args: any[]) => Observable<unknown> | Promise<unknown>;
+export type CanExecute = Signal<boolean> | Observable<boolean>;
+/** Creates an async {@link Command}. Must be used within an injection context.
+ * NOTE: this auto injects `DestroyRef` and handles auto destroy. {@link ICommand.autoDestroy} should not be used.
+ */
+export declare function commandAsync(execute: ExecuteAsyncFn, canExecute$?: CanExecute): Command;
+/** Creates a {@link Command}. Must be used within an injection context.
+ * NOTE: this auto injects `DestroyRef` and handles auto destroy. {@link ICommand.autoDestroy} should not be used.
+ */
+export declare function command(execute: ExecuteFn, canExecute$?: CanExecute, isAsync?: boolean): Command;
+/**
+ * Command object used to encapsulate information which is needed to perform an action.
+ */
+export declare class Command implements ICommand {
+    /** Determines whether the command is currently executing, as a snapshot value. */
+    get isExecuting(): boolean;
+    /** Determines whether the command can execute or not, as a snapshot value. */
+    get canExecute(): boolean;
+    /** Determines whether the command is currently executing, as an observable. */
+    get isExecuting$(): Observable<boolean>;
+    /** Determines whether to auto destroy when having 0 subscribers. */
+    autoDestroy: boolean;
+    /** Determines whether the command can execute or not, as an observable. */
+    readonly canExecute$: Observable<boolean>;
+    private _isExecuting$;
+    private _isExecuting;
+    private _canExecute;
+    private executionPipe$;
+    private isExecuting$$;
+    private canExecute$$;
+    private executionPipe$$;
+    private subscribersCount;
+    /**
+     * Creates an instance of Command.
+     *
+     * @param execute Execute function to invoke - use `isAsync: true` when `Observable<any>`.
+     * @param canExecute Observable which determines whether it can execute or not.
+     * @param isAsync Indicates that the execute function is async e.g. Observable.
+     */
+    constructor(execute: ExecuteFn, canExecute$?: CanExecute, isAsync?: boolean);
+    /** Execute function to invoke. */
+    execute(...args: unknown[]): void;
+    /** Disposes all resources held by subscriptions. */
+    destroy(): void;
+    subscribe(): void;
+    unsubscribe(): void;
+    private buildExecutionPipe;
+}
+/**
+ * Async Command object used to encapsulate information which is needed to perform an action,
+ * which takes an execute function as Observable/Promise.
+ */
+export declare class CommandAsync extends Command {
+    constructor(execute: ExecuteAsyncFn, canExecute$?: CanExecute);
+}

package/command.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnInit, OnDestroy } from "@angular/core";
+import { type CommandOptions } from "./command.options";
+import { CommandCreator, type ICommand } from "./command.model";
+import * as i0 from "@angular/core";
+export declare class CommandDirective implements OnInit, OnDestroy {
+    private readonly globalOptions;
+    private readonly renderer;
+    private readonly element;
+    private readonly cdr;
+    commandOrCreator: ICommand | CommandCreator | undefined;
+    get commandOptions(): CommandOptions;
+    set commandOptions(value: Partial<CommandOptions>);
+    commandParams: unknown | unknown[];
+    get command(): ICommand;
+    private _command;
+    private _commandOptions;
+    private _destroy$;
+    ngOnInit(): void;
+    onClick(): void;
+    ngOnDestroy(): void;
+    private trySetDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandDirective, "[ssvCommand]", ["ssvCommand"], { "commandOrCreator": { "alias": "ssvCommand"; "required": false; }; "commandOptions": { "alias": "ssvCommandOptions"; "required": false; }; "commandParams": { "alias": "ssvCommandParams"; "required": false; }; }, {}, never, never, true, never>;
+}

package/command.model.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from "rxjs";
+export interface ICommand {
+    /** Determines whether the command is currently executing, as a snapshot value. */
+    readonly isExecuting: boolean;
+    /** Determines whether the command is currently executing, as an observable. */
+    readonly isExecuting$: Observable<boolean>;
+    /** Determines whether the command can execute or not, as a snapshot value. */
+    readonly canExecute: boolean;
+    /** Determines whether the command can execute or not, as an observable. */
+    readonly canExecute$: Observable<boolean>;
+    /** Determines whether to auto destroy when having 0 subscribers (defaults to `true`). */
+    autoDestroy: boolean;
+    /** Execute function to invoke. */
+    execute(...args: unknown[]): void;
+    /** Disposes all resources held by subscriptions. */
+    destroy(): void;
+    /** Subscribe listener, in order to handle auto disposing. */
+    subscribe(): void;
+    /** Unsubscribe listener, in order to handle auto disposing. */
+    unsubscribe(): void;
+}
+export interface CommandCreator {
+    execute: (...args: any[]) => Observable<unknown> | Promise<unknown> | void;
+    canExecute?: Observable<boolean> | Function;
+    params?: unknown | unknown[];
+    isAsync?: boolean;
+    host: unknown;
+}

package/command.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./command.directive";
+import * as i2 from "./command-ref.directive";
+export declare class SsvCommandModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SsvCommandModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SsvCommandModule, never, [typeof i1.CommandDirective, typeof i2.CommandRefDirective], [typeof i1.CommandDirective, typeof i2.CommandRefDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SsvCommandModule>;
+}

package/command.options.d.ts

@@ -0,0 +1,18 @@
+import { type EnvironmentProviders, InjectionToken } from "@angular/core";
+export interface CommandOptions {
+    /**
+     * Css Class which gets added/removed on the Command element's host while Command `isExecuting$`.
+     */
+    executingCssClass: string;
+    /** Determines whether the disabled will be handled by the directive or not.
+     * Disable handled by directive's doesn't always play nice when used with other component/pipe/directive and they also handle disabled.
+     * This disables the handling manually and need to pass explicitly `[disabled]="!saveCmd.canExecute"`.
+     */
+    handleDisabled: boolean;
+    /** Determine whether to set a `delay(1)` when setting the disabled. Which might be needed when working with external
+     * components/directives (such as material button)
+     */
+    hasDisabledDelay: boolean;
+}
+export declare const COMMAND_OPTIONS: InjectionToken<CommandOptions>;
+export declare function provideSsvCommandOptions(options: Partial<CommandOptions> | ((defaults: Readonly<CommandOptions>) => Partial<CommandOptions>)): EnvironmentProviders;

package/command.util.d.ts

@@ -0,0 +1,15 @@
+import { AbstractControl, AbstractControlDirective } from "@angular/forms";
+import { Observable } from "rxjs";
+import { CommandCreator, ICommand } from "./command.model";
+/** Determines whether the arg object is of type `Command`. */
+export declare function isCommand(arg: unknown): arg is ICommand;
+/** Determines whether the arg object is of type `CommandCreator`. */
+export declare function isCommandCreator(arg: unknown): arg is CommandCreator;
+export interface CanExecuteFormOptions {
+    /** Determines whether to check for validity. (defaults: true) */
+    validity?: boolean;
+    /** Determines whether to check whether UI has been touched. (defaults: true) */
+    dirty?: boolean;
+}
+/** Get form is valid as an observable. */
+export declare function canExecuteFromNgForm(form: AbstractControl | AbstractControlDirective, options?: CanExecuteFormOptions): Observable<boolean>;

package/esm2022/command-ref.directive.mjs

@@ -0,0 +1,57 @@
+import { Directive, Input } from "@angular/core";
+import { isCommandCreator } from "./command.util";
+import { Command } from "./command";
+import * as i0 from "@angular/core";
+const NAME_CAMEL = "ssvCommandRef";
+/**
+ * Command creator ref, directive which allows creating Command in the template
+ * and associate it to a command (in order to share executions).
+ * @example
+ * ### Most common usage
+ * ```html
+ * <div #actionCmd="ssvCommandRef" [ssvCommandRef]="{host: this, execute: removeHero$, canExecute: isValid$}">
+ *    <button [ssvCommand]="actionCmd.command" [ssvCommandParams]="hero">
+ *      Remove
+ *    </button>
+ *    <button [ssvCommand]="actionCmd.command" [ssvCommandParams]="hero">
+ *       Remove
+ *    </button>
+ * </div>
+ * ```
+ *
+ */
+export class CommandRefDirective {
+    commandCreator;
+    get command() { return this._command; }
+    _command;
+    ngOnInit() {
+        if (isCommandCreator(this.commandCreator)) {
+            const isAsync = this.commandCreator.isAsync || this.commandCreator.isAsync === undefined;
+            const execFn = this.commandCreator.execute.bind(this.commandCreator.host);
+            this._command = new Command(execFn, this.commandCreator.canExecute, isAsync);
+        }
+        else {
+            throw new Error(`${NAME_CAMEL}: [${NAME_CAMEL}] is not defined properly!`);
+        }
+    }
+    ngOnDestroy() {
+        // console.log("[commandRef::destroy]");
+        if (this._command) {
+            this._command.destroy();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CommandRefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: CommandRefDirective, isStandalone: true, selector: "[ssvCommandRef]", inputs: { commandCreator: ["ssvCommandRef", "commandCreator"] }, exportAs: ["ssvCommandRef"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CommandRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                    exportAs: NAME_CAMEL,
+                    standalone: true,
+                }]
+        }], propDecorators: { commandCreator: [{
+                type: Input,
+                args: [NAME_CAMEL]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/command.directive.mjs

@@ -0,0 +1,165 @@
+import { Directive, Input, HostListener, ElementRef, Renderer2, ChangeDetectorRef, inject, } from "@angular/core";
+import { Subject, tap, delay, takeUntil } from "rxjs";
+import { COMMAND_OPTIONS } from "./command.options";
+import { Command } from "./command";
+import { isCommand, isCommandCreator } from "./command.util";
+import * as i0 from "@angular/core";
+/**
+ * Controls the state of a component in sync with `Command`.
+ *
+ * @example
+ * ### Most common usage
+ * ```html
+ * <button [ssvCommand]="saveCmd">Save</button>
+ * ```
+ *
+ *
+ * ### Usage with options
+ * ```html
+ * <button [ssvCommand]="saveCmd" [ssvCommandOptions]="{executingCssClass: 'in-progress'}">Save</button>
+ * ```
+ *
+ *
+ * ### Usage with params
+ * This is useful for collections (loops) or using multiple actions with different args.
+ * *NOTE: This will share the `isExecuting` when used with multiple controls.*
+ *
+ * #### With single param
+ *
+ * ```html
+ * <button [ssvCommand]="saveCmd" [ssvCommandParams]="{id: 1}">Save</button>
+ * ```
+ * *NOTE: if you have only 1 argument as an array, it should be enclosed within an array e.g. `[['apple', 'banana']]`,
+ * else it will spread and you will `arg1: "apple", arg2: "banana"`*
+ *
+ * #### With multi params
+ * ```html
+ * <button [ssvCommand]="saveCmd" [ssvCommandParams]="[{id: 1}, 'hello', hero]">Save</button>
+ * ```
+ *
+ * ### Usage with Command Creator
+ * This is useful for collections (loops) or using multiple actions with different args, whilst not sharing `isExecuting`.
+ *
+ *
+ * ```html
+ * <button [ssvCommand]="{host: this, execute: removeHero$, canExecute: isValid$, params: [hero, 1337, 'xx']}">Save</button>
+ * ```
+ *
+ */
+const NAME_CAMEL = "ssvCommand";
+// let nextUniqueId = 0;
+export class CommandDirective {
+    // readonly id = `${NAME_CAMEL}-${nextUniqueId++}`;
+    globalOptions = inject(COMMAND_OPTIONS);
+    renderer = inject(Renderer2);
+    element = inject(ElementRef);
+    cdr = inject(ChangeDetectorRef);
+    commandOrCreator;
+    get commandOptions() { return this._commandOptions; }
+    set commandOptions(value) {
+        if (value === this._commandOptions) {
+            return;
+        }
+        this._commandOptions = {
+            ...this.globalOptions,
+            ...value,
+        };
+    }
+    commandParams;
+    get command() { return this._command; }
+    _command;
+    _commandOptions = this.globalOptions;
+    _destroy$ = new Subject();
+    ngOnInit() {
+        // console.log("[ssvCommand::init]", this.globalOptions);
+        if (!this.commandOrCreator) {
+            throw new Error(`${NAME_CAMEL}: [${NAME_CAMEL}] should be defined!`);
+        }
+        else if (isCommand(this.commandOrCreator)) {
+            this._command = this.commandOrCreator;
+        }
+        else if (isCommandCreator(this.commandOrCreator)) {
+            const isAsync = this.commandOrCreator.isAsync || this.commandOrCreator.isAsync === undefined;
+            // todo: find something like this for ivy (or angular10+)
+            // const hostComponent = (this.viewContainer as any)._view.component;
+            const execFn = this.commandOrCreator.execute.bind(this.commandOrCreator.host);
+            this.commandParams = this.commandParams || this.commandOrCreator.params;
+            const canExec = this.commandOrCreator.canExecute instanceof Function
+                ? this.commandOrCreator.canExecute.bind(this.commandOrCreator.host, this.commandParams)()
+                : this.commandOrCreator.canExecute;
+            // console.log("[ssvCommand::init] command creator", {
+            // 	firstParam: this.commandParams ? this.commandParams[0] : null,
+            // 	params: this.commandParams
+            // });
+            this._command = new Command(execFn, canExec, isAsync);
+        }
+        else {
+            throw new Error(`${NAME_CAMEL}: [${NAME_CAMEL}] is not defined properly!`);
+        }
+        this._command.subscribe();
+        this._command.canExecute$.pipe(this.commandOptions.hasDisabledDelay
+            ? delay(1)
+            : tap(() => { }), tap(x => {
+            this.trySetDisabled(!x);
+            // console.log("[ssvCommand::canExecute$]", { canExecute: x });
+            this.cdr.markForCheck();
+        }), takeUntil(this._destroy$)).subscribe();
+        if (this._command.isExecuting$) {
+            this._command.isExecuting$.pipe(tap(x => {
+                // console.log("[ssvCommand::isExecuting$]", x, this.commandOptions);
+                if (x) {
+                    this.renderer.addClass(this.element.nativeElement, this.commandOptions.executingCssClass);
+                }
+                else {
+                    this.renderer.removeClass(this.element.nativeElement, this.commandOptions.executingCssClass);
+                }
+            }), takeUntil(this._destroy$)).subscribe();
+        }
+    }
+    onClick() {
+        // console.log("[ssvCommand::onClick]", this.commandParams);
+        if (Array.isArray(this.commandParams)) {
+            this._command.execute(...this.commandParams);
+        }
+        else {
+            this._command.execute(this.commandParams);
+        }
+    }
+    ngOnDestroy() {
+        // console.log("[ssvCommand::destroy]");
+        this._destroy$.next();
+        this._destroy$.complete();
+        if (this._command) {
+            this._command.unsubscribe();
+        }
+    }
+    trySetDisabled(disabled) {
+        if (this.commandOptions.handleDisabled) {
+            // console.warn(">>>> disabled", { id: this.id, disabled });
+            this.renderer.setProperty(this.element.nativeElement, "disabled", disabled);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CommandDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: CommandDirective, isStandalone: true, selector: "[ssvCommand]", inputs: { commandOrCreator: ["ssvCommand", "commandOrCreator"], commandOptions: ["ssvCommandOptions", "commandOptions"], commandParams: ["ssvCommandParams", "commandParams"] }, host: { listeners: { "click": "onClick()" } }, exportAs: ["ssvCommand"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: CommandDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                    exportAs: NAME_CAMEL,
+                    standalone: true,
+                }]
+        }], propDecorators: { commandOrCreator: [{
+                type: Input,
+                args: [NAME_CAMEL]
+            }], commandOptions: [{
+                type: Input,
+                args: [`${NAME_CAMEL}Options`]
+            }], commandParams: [{
+                type: Input,
+                args: [`${NAME_CAMEL}Params`]
+            }], onClick: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.directive.js","sourceRoot":"","sources":["../../../../libs/ngx.command/src/command.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tDirective,\n\tOnInit,\n\tOnDestroy,\n\tInput,\n\tHostListener,\n\tElementRef,\n\tRenderer2,\n\tChangeDetectorRef,\n\tinject,\n} from \"@angular/core\";\nimport { Subject, tap, delay, takeUntil } from \"rxjs\";\n\nimport { type CommandOptions, COMMAND_OPTIONS } from \"./command.options\";\nimport { Command } from \"./command\";\nimport { isCommand, isCommandCreator } from \"./command.util\";\nimport { CommandCreator, type ICommand } from \"./command.model\";\n\n/**\n * Controls the state of a component in sync with `Command`.\n *\n * @example\n * ### Most common usage\n * ```html\n * <button [ssvCommand]=\"saveCmd\">Save</button>\n * ```\n *\n *\n * ### Usage with options\n * ```html\n * <button [ssvCommand]=\"saveCmd\" [ssvCommandOptions]=\"{executingCssClass: 'in-progress'}\">Save</button>\n * ```\n *\n *\n * ### Usage with params\n * This is useful for collections (loops) or using multiple actions with different args.\n * *NOTE: This will share the `isExecuting` when used with multiple controls.*\n *\n * #### With single param\n *\n * ```html\n * <button [ssvCommand]=\"saveCmd\" [ssvCommandParams]=\"{id: 1}\">Save</button>\n * ```\n * *NOTE: if you have only 1 argument as an array, it should be enclosed within an array e.g. `[['apple', 'banana']]`,\n * else it will spread and you will `arg1: \"apple\", arg2: \"banana\"`*\n *\n * #### With multi params\n * ```html\n * <button [ssvCommand]=\"saveCmd\" [ssvCommandParams]=\"[{id: 1}, 'hello', hero]\">Save</button>\n * ```\n *\n * ### Usage with Command Creator\n * This is useful for collections (loops) or using multiple actions with different args, whilst not sharing `isExecuting`.\n *\n *\n * ```html\n * <button [ssvCommand]=\"{host: this, execute: removeHero$, canExecute: isValid$, params: [hero, 1337, 'xx']}\">Save</button>\n * ```\n *\n */\n\nconst NAME_CAMEL = \"ssvCommand\";\n\n// let nextUniqueId = 0;\n\n@Directive({\n\tselector: `[${NAME_CAMEL}]`,\n\texportAs: NAME_CAMEL,\n\tstandalone: true,\n})\nexport class CommandDirective implements OnInit, OnDestroy {\n\n\t// readonly id = `${NAME_CAMEL}-${nextUniqueId++}`;\n\tprivate readonly globalOptions = inject(COMMAND_OPTIONS);\n\tprivate readonly renderer = inject(Renderer2);\n\tprivate readonly element = inject(ElementRef);\n\tprivate readonly cdr = inject(ChangeDetectorRef);\n\n\t@Input(NAME_CAMEL) commandOrCreator: ICommand | CommandCreator | undefined;\n\n\t@Input(`${NAME_CAMEL}Options`)\n\tget commandOptions(): CommandOptions { return this._commandOptions; }\n\tset commandOptions(value: Partial<CommandOptions>) {\n\t\tif (value === this._commandOptions) {\n\t\t\treturn;\n\t\t}\n\t\tthis._commandOptions = {\n\t\t\t...this.globalOptions,\n\t\t\t...value,\n\t\t};\n\t}\n\n\t@Input(`${NAME_CAMEL}Params`) commandParams: unknown | unknown[];\n\n\tget command(): ICommand { return this._command; }\n\n\tprivate _command!: ICommand;\n\tprivate _commandOptions: CommandOptions = this.globalOptions;\n\tprivate _destroy$ = new Subject<void>();\n\n\tngOnInit(): void {\n\t\t// console.log(\"[ssvCommand::init]\", this.globalOptions);\n\t\tif (!this.commandOrCreator) {\n\t\t\tthrow new Error(`${NAME_CAMEL}: [${NAME_CAMEL}] should be defined!`);\n\t\t} else if (isCommand(this.commandOrCreator)) {\n\t\t\tthis._command = this.commandOrCreator;\n\t\t} else if (isCommandCreator(this.commandOrCreator)) {\n\t\t\tconst isAsync = this.commandOrCreator.isAsync || this.commandOrCreator.isAsync === undefined;\n\n\t\t\t// todo: find something like this for ivy (or angular10+)\n\t\t\t// const hostComponent = (this.viewContainer as any)._view.component;\n\n\t\t\tconst execFn = this.commandOrCreator.execute.bind(this.commandOrCreator.host);\n\t\t\tthis.commandParams = this.commandParams || this.commandOrCreator.params;\n\n\t\t\tconst canExec = this.commandOrCreator.canExecute instanceof Function\n\t\t\t\t? this.commandOrCreator.canExecute.bind(this.commandOrCreator.host, this.commandParams)()\n\t\t\t\t: this.commandOrCreator.canExecute;\n\n\t\t\t// console.log(\"[ssvCommand::init] command creator\", {\n\t\t\t// \tfirstParam: this.commandParams ? this.commandParams[0] : null,\n\t\t\t// \tparams: this.commandParams\n\t\t\t// });\n\t\t\tthis._command = new Command(execFn, canExec, isAsync);\n\t\t} else {\n\t\t\tthrow new Error(`${NAME_CAMEL}: [${NAME_CAMEL}] is not defined properly!`);\n\t\t}\n\n\t\tthis._command.subscribe();\n\t\tthis._command.canExecute$.pipe(\n\t\t\tthis.commandOptions.hasDisabledDelay\n\t\t\t\t? delay(1)\n\t\t\t\t: tap(() => { /* stub */ }),\n\t\t\ttap(x => {\n\t\t\t\tthis.trySetDisabled(!x);\n\t\t\t\t// console.log(\"[ssvCommand::canExecute$]\", { canExecute: x });\n\t\t\t\tthis.cdr.markForCheck();\n\t\t\t}),\n\t\t\ttakeUntil(this._destroy$),\n\t\t).subscribe();\n\n\t\tif (this._command.isExecuting$) {\n\t\t\tthis._command.isExecuting$.pipe(\n\t\t\t\ttap(x => {\n\t\t\t\t\t// console.log(\"[ssvCommand::isExecuting$]\", x, this.commandOptions);\n\t\t\t\t\tif (x) {\n\t\t\t\t\t\tthis.renderer.addClass(\n\t\t\t\t\t\t\tthis.element.nativeElement,\n\t\t\t\t\t\t\tthis.commandOptions.executingCssClass\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.renderer.removeClass(\n\t\t\t\t\t\t\tthis.element.nativeElement,\n\t\t\t\t\t\t\tthis.commandOptions.executingCssClass\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}),\n\t\t\t\ttakeUntil(this._destroy$),\n\t\t\t).subscribe();\n\t\t}\n\t}\n\n\t@HostListener(\"click\")\n\tonClick(): void {\n\t\t// console.log(\"[ssvCommand::onClick]\", this.commandParams);\n\t\tif (Array.isArray(this.commandParams)) {\n\t\t\tthis._command.execute(...this.commandParams);\n\t\t} else {\n\t\t\tthis._command.execute(this.commandParams);\n\t\t}\n\t}\n\n\tngOnDestroy(): void {\n\t\t// console.log(\"[ssvCommand::destroy]\");\n\t\tthis._destroy$.next();\n\t\tthis._destroy$.complete();\n\t\tif (this._command) {\n\t\t\tthis._command.unsubscribe();\n\t\t}\n\t}\n\n\tprivate trySetDisabled(disabled: boolean) {\n\t\tif (this.commandOptions.handleDisabled) {\n\t\t\t// console.warn(\">>>> disabled\", { id: this.id, disabled });\n\t\t\tthis.renderer.setProperty(this.element.nativeElement, \"disabled\", disabled);\n\t\t}\n\t}\n\n}\n\n"]}