@ssv/ngx.command 2.2.0 → 2.3.0-dev.3

package/README.md

@@ -6,7 +6,7 @@
 [commandpatternwiki]: https://en.wikipedia.org/wiki/Command_pattern
 
 # @ssv/ngx.command
-[![CircleCI](https://circleci.com/gh/sketch7/ngx.command.svg?style=shield)](https://circleci.com/gh/sketch7/ngx.command)
+[![CI](https://github.com/sketch7/ngx.command/actions/workflows/ci.yml/badge.svg)](https://github.com/sketch7/ngx.command/actions/workflows/ci.yml)
 [![npm version](https://badge.fury.io/js/%40ssv%2Fngx.command.svg)](https://badge.fury.io/js/%40ssv%2Fngx.command)
 
 [Command pattern][commandpatternwiki] implementation for angular. Command's are used to encapsulate information which is needed to perform an action.
@@ -27,10 +27,10 @@ npm install @ssv/ngx.command
 
 Choose the version corresponding to your Angular version:
 
- | Angular          | library |
- | ---------------- | ------- |
- | 10               | 2.x+    |
- | 4 to 9 (non ivy) | 1.x+    |
+ | Angular | library |
+ | ------- | ------- |
+ | 10+     | 2.x+    |
+ | 4 to 9  | 1.x+    |
 
 
 # Usage
@@ -186,9 +186,9 @@ import { SsvCommandModule } from "@ssv/ngx.command";
 ### Setup Machine for Development
 Install/setup the following:
 
-- NodeJS v10+
+- NodeJS v18.16.0+
 - Visual Studio Code or similar code editor
-- TypeScript 3.1+
+- TypeScript 5.0+
 - Git + SourceTree, SmartGit or similar (optional)
 - Ensure to install **global NPM modules** using the following:
 

package/command-ref.directive.d.ts

@@ -1,5 +1,6 @@
 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).
@@ -23,4 +24,6 @@ export declare class CommandRefDirective implements OnInit, OnDestroy {
     private _command;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandRefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandRefDirective, "[ssvCommandRef]", ["ssvCommandRef"], { "commandCreator": "ssvCommandRef"; }, {}, never, never, false, never>;
 }

package/command.directive.d.ts

@@ -1,6 +1,7 @@
 import { OnInit, OnDestroy, ElementRef, Renderer2, ChangeDetectorRef } from "@angular/core";
 import { CommandOptions } from "./config";
 import { CommandCreator, ICommand } from "./command.model";
+import * as i0 from "@angular/core";
 export declare class CommandDirective implements OnInit, OnDestroy {
     private config;
     private renderer;
@@ -19,4 +20,6 @@ export declare class CommandDirective implements OnInit, OnDestroy {
     onClick(): void;
     ngOnDestroy(): void;
     private trySetDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommandDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CommandDirective, "[ssvCommand]", ["ssvCommand"], { "commandOrCreator": "ssvCommand"; "commandOptions": "ssvCommandOptions"; "commandParams": "ssvCommandParams"; }, {}, never, never, false, never>;
 }

package/esm2020/command-ref.directive.mjs

@@ -0,0 +1,54 @@
+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 {
+    get command() { return this._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();
+        }
+    }
+}
+CommandRefDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CommandRefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CommandRefDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CommandRefDirective, selector: "[ssvCommandRef]", inputs: { commandCreator: ["ssvCommandRef", "commandCreator"] }, exportAs: ["ssvCommandRef"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CommandRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                    exportAs: NAME_CAMEL
+                }]
+        }], propDecorators: { commandCreator: [{
+                type: Input,
+                args: [NAME_CAMEL]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/command.directive.mjs

@@ -0,0 +1,166 @@
+import { Directive, Input, HostListener, Inject, } from "@angular/core";
+import { Subject } from "rxjs";
+import { tap, delay, takeUntil } from "rxjs/operators";
+import { COMMAND_CONFIG } from "./config";
+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 {
+    constructor(config, renderer, element, cdr) {
+        this.config = config;
+        this.renderer = renderer;
+        this.element = element;
+        this.cdr = cdr;
+        this._commandOptions = this.config;
+        this._destroy$ = new Subject();
+    }
+    get commandOptions() { return this._commandOptions; }
+    set commandOptions(value) {
+        if (value === this._commandOptions) {
+            return;
+        }
+        this._commandOptions = {
+            ...this.config,
+            ...value,
+        };
+    }
+    get command() { return this._command; }
+    ngOnInit() {
+        // console.log("[ssvCommand::init]", this.config);
+        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);
+        }
+    }
+}
+CommandDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CommandDirective, deps: [{ token: COMMAND_CONFIG }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+CommandDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: CommandDirective, 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: "15.2.9", ngImport: i0, type: CommandDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                    exportAs: NAME_CAMEL
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [COMMAND_CONFIG]
+                }] }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, 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":["../../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\tInject,\n\tRenderer2,\n\tChangeDetectorRef,\n} from \"@angular/core\";\nimport { Subject } from \"rxjs\";\nimport { tap, delay, takeUntil } from \"rxjs/operators\";\n\nimport { CommandOptions, COMMAND_CONFIG } from \"./config\";\nimport { Command } from \"./command\";\nimport { isCommand, isCommandCreator } from \"./command.util\";\nimport { CommandCreator, 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})\nexport class CommandDirective implements OnInit, OnDestroy {\n\n\t// readonly id = `${NAME_CAMEL}-${nextUniqueId++}`;\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: CommandOptions) {\n\t\tif (value === this._commandOptions) {\n\t\t\treturn;\n\t\t}\n\t\tthis._commandOptions = {\n\t\t\t...this.config,\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\tprivate _command!: ICommand;\n\tprivate _commandOptions: CommandOptions = this.config;\n\tprivate _destroy$ = new Subject<void>();\n\n\tconstructor(\n\t\t@Inject(COMMAND_CONFIG) private config: CommandOptions,\n\t\tprivate renderer: Renderer2,\n\t\tprivate element: ElementRef,\n\t\tprivate cdr: ChangeDetectorRef,\n\t) { }\n\n\tngOnInit(): void {\n\t\t// console.log(\"[ssvCommand::init]\", this.config);\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"]}

package/esm2020/command.mjs

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { combineLatest, Subscription, Subject, BehaviorSubject, of, EMPTY } from "rxjs";
+import { tap, map, filter, switchMap, catchError, finalize, take } from "rxjs/operators";
+/**
+ * Command object used to encapsulate information which is needed to perform an action.
+ */
+export class Command {
+    /**
+     * 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, canExecute$, isAsync) {
+        /** Determines whether to auto destroy when having 0 subscribers. */
+        this.autoDestroy = true;
+        this._isExecuting$ = new BehaviorSubject(false);
+        this._isExecuting = false;
+        this._canExecute = true;
+        this.executionPipe$ = new Subject();
+        this.isExecuting$$ = Subscription.EMPTY;
+        this.canExecute$$ = Subscription.EMPTY;
+        this.executionPipe$$ = Subscription.EMPTY;
+        this.subscribersCount = 0;
+        if (canExecute$) {
+            this.canExecute$ = combineLatest([
+                this._isExecuting$,
+                canExecute$
+            ]).pipe(map(([isExecuting, canExecuteResult]) => {
+                // console.log("[command::combineLatest$] update!", { isExecuting, canExecuteResult });
+                this._isExecuting = isExecuting;
+                this._canExecute = !isExecuting && !!canExecuteResult;
+                return this._canExecute;
+            }));
+            this.canExecute$$ = this.canExecute$.subscribe();
+        }
+        else {
+            this.canExecute$ = this._isExecuting$.pipe(map(x => {
+                const canExecute = !x;
+                this._canExecute = canExecute;
+                return canExecute;
+            }));
+            this.isExecuting$$ = this._isExecuting$
+                .pipe(tap(x => this._isExecuting = x))
+                .subscribe();
+        }
+        this.executionPipe$$ = this.buildExecutionPipe(execute, isAsync).subscribe();
+    }
+    /** Determines whether the command is currently executing, as a snapshot value. */
+    get isExecuting() {
+        return this._isExecuting;
+    }
+    /** Determines whether the command can execute or not, as a snapshot value. */
+    get canExecute() {
+        return this._canExecute;
+    }
+    /** Determines whether the command is currently executing, as an observable. */
+    get isExecuting$() {
+        return this._isExecuting$.asObservable();
+    }
+    /** Execute function to invoke. */
+    execute(...args) {
+        // console.warn("[command::execute]", args);
+        this.executionPipe$.next(args);
+    }
+    /** Disposes all resources held by subscriptions. */
+    destroy() {
+        // console.warn("[command::destroy]");
+        this.executionPipe$$.unsubscribe();
+        this.canExecute$$.unsubscribe();
+        this.isExecuting$$.unsubscribe();
+    }
+    subscribe() {
+        this.subscribersCount++;
+    }
+    unsubscribe() {
+        this.subscribersCount--;
+        // console.log("[command::unsubscribe]", { autoDestroy: this.autoDestroy, subscribersCount: this.subscribersCount });
+        if (this.autoDestroy && this.subscribersCount <= 0) {
+            this.destroy();
+        }
+    }
+    buildExecutionPipe(execute, isAsync) {
+        let pipe$ = this.executionPipe$.pipe(
+        // tap(x => console.warn(">>>> executionPipe", this._canExecute)),
+        filter(() => this._canExecute), tap(() => {
+            // console.log("[command::executionPipe$] do#1 - set execute", { args: x });
+            this._isExecuting$.next(true);
+        }));
+        const execFn = isAsync
+            ? switchMap(args => {
+                if (args) {
+                    return execute(...args);
+                }
+                return execute();
+            })
+            : tap((args) => {
+                if (args) {
+                    execute(...args);
+                    return;
+                }
+                execute();
+            });
+        pipe$ = pipe$.pipe(switchMap(args => of(args).pipe(execFn, finalize(() => {
+            // console.log("[command::executionPipe$]  finalize inner#1 - set idle");
+            this._isExecuting$.next(false);
+        }), take(1), catchError(error => {
+            console.error("Unhandled execute error", error);
+            return EMPTY;
+        }))), tap(() => {
+            // console.log("[command::executionPipe$] tap#2 - set idle");
+            this._isExecuting$.next(false);
+        }));
+        return pipe$;
+    }
+}
+/**
+ * Async Command object used to encapsulate information which is needed to perform an action,
+ * which takes an execute function as Observable/Promise.
+ */
+export class CommandAsync extends Command {
+    constructor(execute, canExecute$) {
+        super(execute, canExecute$, true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"command.js","sourceRoot":"","sources":["../../src/command.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Observable, combineLatest, Subscription, Subject, BehaviorSubject, of, EMPTY } from \"rxjs\";\nimport { tap, map, filter, switchMap, catchError, finalize, take } from \"rxjs/operators\";\nimport { ICommand } from \"./command.model\";\n\n/**\n * Command object used to encapsulate information which is needed to perform an action.\n */\nexport class Command implements ICommand {\n\n\t/** Determines whether the command is currently executing, as a snapshot value. */\n\tget isExecuting(): boolean {\n\t\treturn this._isExecuting;\n\t}\n\n\t/** Determines whether the command can execute or not, as a snapshot value. */\n\tget canExecute(): boolean {\n\t\treturn this._canExecute;\n\t}\n\n\t/** Determines whether the command is currently executing, as an observable. */\n\tget isExecuting$(): Observable<boolean> {\n\t\treturn this._isExecuting$.asObservable();\n\t}\n\n\t/** Determines whether to auto destroy when having 0 subscribers. */\n\tautoDestroy = true;\n\n\t/** Determines whether the command can execute or not, as an observable. */\n\treadonly canExecute$: Observable<boolean>;\n\n\tprivate _isExecuting$ = new BehaviorSubject<boolean>(false);\n\tprivate _isExecuting = false;\n\tprivate _canExecute = true;\n\tprivate executionPipe$ = new Subject<unknown[] | undefined>();\n\tprivate isExecuting$$ = Subscription.EMPTY;\n\tprivate canExecute$$ = Subscription.EMPTY;\n\tprivate executionPipe$$ = Subscription.EMPTY;\n\tprivate subscribersCount = 0;\n\n\t/**\n\t * Creates an instance of Command.\n\t *\n\t * @param execute Execute function to invoke - use `isAsync: true` when `Observable<any>`.\n\t * @param canExecute Observable which determines whether it can execute or not.\n\t * @param isAsync Indicates that the execute function is async e.g. Observable.\n\t */\n\tconstructor(\n\t\texecute: (...args: unknown[]) => unknown,\n\t\tcanExecute$?: Observable<boolean>,\n\t\tisAsync?: boolean,\n\t) {\n\t\tif (canExecute$) {\n\t\t\tthis.canExecute$ = combineLatest([\n\t\t\t\tthis._isExecuting$,\n\t\t\t\tcanExecute$\n\t\t\t]).pipe(\n\t\t\t\tmap(([isExecuting, canExecuteResult]) => {\n\t\t\t\t\t// console.log(\"[command::combineLatest$] update!\", { isExecuting, canExecuteResult });\n\t\t\t\t\tthis._isExecuting = isExecuting;\n\t\t\t\t\tthis._canExecute = !isExecuting && !!canExecuteResult;\n\t\t\t\t\treturn this._canExecute;\n\t\t\t\t}),\n\t\t\t);\n\t\t\tthis.canExecute$$ = this.canExecute$.subscribe();\n\t\t} else {\n\t\t\tthis.canExecute$ = this._isExecuting$.pipe(\n\t\t\t\tmap(x => {\n\t\t\t\t\tconst canExecute = !x;\n\t\t\t\t\tthis._canExecute = canExecute;\n\t\t\t\t\treturn canExecute;\n\t\t\t\t})\n\t\t\t);\n\t\t\tthis.isExecuting$$ = this._isExecuting$\n\t\t\t\t.pipe(tap(x => this._isExecuting = x))\n\t\t\t\t.subscribe();\n\t\t}\n\t\tthis.executionPipe$$ = this.buildExecutionPipe(execute, isAsync).subscribe();\n\t}\n\n\t/** Execute function to invoke. */\n\texecute(...args: unknown[]): void {\n\t\t// console.warn(\"[command::execute]\", args);\n\t\tthis.executionPipe$.next(args);\n\t}\n\n\t/** Disposes all resources held by subscriptions. */\n\tdestroy(): void {\n\t\t// console.warn(\"[command::destroy]\");\n\t\tthis.executionPipe$$.unsubscribe();\n\t\tthis.canExecute$$.unsubscribe();\n\t\tthis.isExecuting$$.unsubscribe();\n\t}\n\n\tsubscribe(): void {\n\t\tthis.subscribersCount++;\n\t}\n\n\tunsubscribe(): void {\n\t\tthis.subscribersCount--;\n\t\t// console.log(\"[command::unsubscribe]\", { autoDestroy: this.autoDestroy, subscribersCount: this.subscribersCount });\n\t\tif (this.autoDestroy && this.subscribersCount <= 0) {\n\t\t\tthis.destroy();\n\t\t}\n\t}\n\n\tprivate buildExecutionPipe(execute: (...args: unknown[]) => any, isAsync?: boolean): Observable<unknown> {\n\t\tlet pipe$ = this.executionPipe$.pipe(\n\t\t\t// tap(x => console.warn(\">>>> executionPipe\", this._canExecute)),\n\t\t\tfilter(() => this._canExecute),\n\t\t\ttap(() => {\n\t\t\t\t// console.log(\"[command::executionPipe$] do#1 - set execute\", { args: x });\n\t\t\t\tthis._isExecuting$.next(true);\n\t\t\t})\n\t\t);\n\n\t\tconst execFn = isAsync\n\t\t\t? switchMap<unknown[] | undefined, any[]>(args => {\n\t\t\t\tif (args) {\n\t\t\t\t\treturn execute(...args);\n\t\t\t\t}\n\t\t\t\treturn execute();\n\t\t\t})\n\t\t\t: tap((args: unknown[] | undefined) => {\n\t\t\t\tif (args) {\n\t\t\t\t\texecute(...args);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\texecute();\n\t\t\t});\n\n\t\tpipe$ = pipe$.pipe(\n\t\t\tswitchMap(args => of(args).pipe(\n\t\t\t\texecFn,\n\t\t\t\tfinalize(() => {\n\t\t\t\t\t// console.log(\"[command::executionPipe$]  finalize inner#1 - set idle\");\n\t\t\t\t\tthis._isExecuting$.next(false);\n\t\t\t\t}),\n\t\t\t\ttake(1),\n\t\t\t\tcatchError(error => {\n\t\t\t\t\tconsole.error(\"Unhandled execute error\", error);\n\t\t\t\t\treturn EMPTY;\n\t\t\t\t}),\n\t\t\t)),\n\t\t\ttap(\n\t\t\t\t() => {\n\t\t\t\t\t// console.log(\"[command::executionPipe$] tap#2 - set idle\");\n\t\t\t\t\tthis._isExecuting$.next(false);\n\t\t\t\t},\n\t\t\t)\n\t\t);\n\t\treturn pipe$;\n\t}\n\n}\n\n/**\n * Async Command object used to encapsulate information which is needed to perform an action,\n * which takes an execute function as Observable/Promise.\n */\nexport class CommandAsync extends Command {\n\n\tconstructor(\n\t\texecute: (...args: unknown[]) => Observable<unknown> | Promise<unknown>,\n\t\tcanExecute$?: Observable<boolean>,\n\t) {\n\t\tsuper(execute, canExecute$, true);\n\t}\n\n}\n"]}

package/esm2020/command.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbWFuZC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb21tYW5kLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSBcInJ4anNcIjtcblxuZXhwb3J0IGludGVyZmFjZSBJQ29tbWFuZCB7XG5cdC8qKiBEZXRlcm1pbmVzIHdoZXRoZXIgdGhlIGNvbW1hbmQgaXMgY3VycmVudGx5IGV4ZWN1dGluZywgYXMgYSBzbmFwc2hvdCB2YWx1ZS4gKi9cblx0cmVhZG9ubHkgaXNFeGVjdXRpbmc6IGJvb2xlYW47XG5cdC8qKiBEZXRlcm1pbmVzIHdoZXRoZXIgdGhlIGNvbW1hbmQgaXMgY3VycmVudGx5IGV4ZWN1dGluZywgYXMgYW4gb2JzZXJ2YWJsZS4gKi9cblx0cmVhZG9ubHkgaXNFeGVjdXRpbmckOiBPYnNlcnZhYmxlPGJvb2xlYW4+O1xuXHQvKiogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSBjb21tYW5kIGNhbiBleGVjdXRlIG9yIG5vdCwgYXMgYSBzbmFwc2hvdCB2YWx1ZS4gKi9cblx0cmVhZG9ubHkgY2FuRXhlY3V0ZTogYm9vbGVhbjtcblx0LyoqIERldGVybWluZXMgd2hldGhlciB0aGUgY29tbWFuZCBjYW4gZXhlY3V0ZSBvciBub3QsIGFzIGFuIG9ic2VydmFibGUuICovXG5cdHJlYWRvbmx5IGNhbkV4ZWN1dGUkOiBPYnNlcnZhYmxlPGJvb2xlYW4+O1xuXG5cdC8qKiBEZXRlcm1pbmVzIHdoZXRoZXIgdG8gYXV0byBkZXN0cm95IHdoZW4gaGF2aW5nIDAgc3Vic2NyaWJlcnMgKGRlZmF1bHRzIHRvIGB0cnVlYCkuICovXG5cdGF1dG9EZXN0cm95OiBib29sZWFuO1xuXG5cdC8qKiBFeGVjdXRlIGZ1bmN0aW9uIHRvIGludm9rZS4gKi9cblx0ZXhlY3V0ZSguLi5hcmdzOiB1bmtub3duW10pOiB2b2lkO1xuXG5cdC8qKiBEaXNwb3NlcyBhbGwgcmVzb3VyY2VzIGhlbGQgYnkgc3Vic2NyaXB0aW9ucy4gKi9cblx0ZGVzdHJveSgpOiB2b2lkO1xuXG5cdC8qKiBTdWJzY3JpYmUgbGlzdGVuZXIsIGluIG9yZGVyIHRvIGhhbmRsZSBhdXRvIGRpc3Bvc2luZy4gKi9cblx0c3Vic2NyaWJlKCk6IHZvaWQ7XG5cblx0LyoqIFVuc3Vic2NyaWJlIGxpc3RlbmVyLCBpbiBvcmRlciB0byBoYW5kbGUgYXV0byBkaXNwb3NpbmcuICovXG5cdHVuc3Vic2NyaWJlKCk6IHZvaWQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tbWFuZENyZWF0b3Ige1xuXHRleGVjdXRlOiAoLi4uYXJnczogdW5rbm93bltdKSA9PiBPYnNlcnZhYmxlPHVua25vd24+IHwgUHJvbWlzZTx1bmtub3duPiB8IHZvaWQ7XG5cdC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvYmFuLXR5cGVzXG5cdGNhbkV4ZWN1dGU/OiBPYnNlcnZhYmxlPGJvb2xlYW4+IHwgRnVuY3Rpb247XG5cdHBhcmFtczogdW5rbm93biB8IHVua25vd25bXTtcblx0aXNBc3luYz86IGJvb2xlYW47XG5cdGhvc3Q6IHVua25vd247XG59XG4iXX0=

package/esm2020/command.util.mjs

@@ -0,0 +1,29 @@
+import { of } from "rxjs";
+import { map, distinctUntilChanged, startWith, delay } from "rxjs/operators";
+import { Command } from "./command";
+/** Determines whether the arg object is of type `Command`. */
+export function isCommand(arg) {
+    return arg instanceof Command;
+}
+/** Determines whether the arg object is of type `CommandCreator`. */
+export function isCommandCreator(arg) {
+    if (arg instanceof Command) {
+        return false;
+    }
+    else if (isAssumedType(arg) && arg.execute && arg.host) {
+        return true;
+    }
+    return false;
+}
+/** Get form is valid as an observable. */
+export function canExecuteFromNgForm(form, options) {
+    const opts = { validity: true, dirty: true, ...options };
+    return form.statusChanges
+        ? form.statusChanges.pipe(// todo: remove cast when working correctly
+        delay(0), startWith(form.valid), map(() => !!(!opts.validity || form.valid) && !!(!opts.dirty || form.dirty)), distinctUntilChanged())
+        : of(true);
+}
+function isAssumedType(x) {
+    return x !== null && typeof x === "object";
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/config.mjs

@@ -0,0 +1,8 @@
+import { InjectionToken } from "@angular/core";
+export const COMMAND_DEFAULT_CONFIG = Object.freeze({
+    executingCssClass: "executing",
+    handleDisabled: true,
+    hasDisabledDelay: false,
+});
+export const COMMAND_CONFIG = new InjectionToken("command-config");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBb0IvQyxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQ25ELGlCQUFpQixFQUFFLFdBQVc7SUFDOUIsY0FBYyxFQUFFLElBQUk7SUFDcEIsZ0JBQWdCLEVBQUUsS0FBSztDQUNMLENBQUMsQ0FBQztBQUVyQixNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQWlCLGdCQUFnQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29tbWFuZE9wdGlvbnMge1xuXHQvKipcblx0ICogQ3NzIENsYXNzIHdoaWNoIGdldHMgYWRkZWQvcmVtb3ZlZCBvbiB0aGUgQ29tbWFuZCBlbGVtZW50J3MgaG9zdCB3aGlsZSBDb21tYW5kIGBpc0V4ZWN1dGluZyRgLlxuXHQgKi9cblx0ZXhlY3V0aW5nQ3NzQ2xhc3M6IHN0cmluZztcblxuXHQvKiogRGV0ZXJtaW5lcyB3aGV0aGVyIHRoZSBkaXNhYmxlZCB3aWxsIGJlIGhhbmRsZWQgYnkgdGhlIGRpcmVjdGl2ZSBvciBub3QuXG5cdCAqIERpc2FibGUgaGFuZGxlZCBieSBkaXJlY3RpdmUncyBkb2Vzbid0IGFsd2F5cyBwbGF5IG5pY2Ugd2hlbiB1c2VkIHdpdGggb3RoZXIgY29tcG9uZW50L3BpcGUvZGlyZWN0aXZlIGFuZCB0aGV5IGFsc28gaGFuZGxlIGRpc2FibGVkLlxuXHQgKiBUaGlzIGRpc2FibGVzIHRoZSBoYW5kbGluZyBtYW51YWxseSBhbmQgbmVlZCB0byBwYXNzIGV4cGxpY2l0bHkgYFtkaXNhYmxlZF09XCIhc2F2ZUNtZC5jYW5FeGVjdXRlXCJgLlxuXHQgKi9cblx0aGFuZGxlRGlzYWJsZWQ6IGJvb2xlYW47XG5cblx0LyoqIERldGVybWluZSB3aGV0aGVyIHRvIHNldCBhIGBkZWxheSgxKWAgd2hlbiBzZXR0aW5nIHRoZSBkaXNhYmxlZC4gV2hpY2ggbWlnaHQgYmUgbmVlZGVkIHdoZW4gd29ya2luZyB3aXRoIGV4dGVybmFsXG5cdCAqIGNvbXBvbmVudHMvZGlyZWN0aXZlcyAoc3VjaCBhcyBtYXRlcmlhbCBidXR0b24pXG5cdCAqL1xuXHRoYXNEaXNhYmxlZERlbGF5OiBib29sZWFuO1xufVxuXG5leHBvcnQgY29uc3QgQ09NTUFORF9ERUZBVUxUX0NPTkZJRyA9IE9iamVjdC5mcmVlemUoe1xuXHRleGVjdXRpbmdDc3NDbGFzczogXCJleGVjdXRpbmdcIixcblx0aGFuZGxlRGlzYWJsZWQ6IHRydWUsXG5cdGhhc0Rpc2FibGVkRGVsYXk6IGZhbHNlLFxufSBhcyBDb21tYW5kT3B0aW9ucyk7XG5cbmV4cG9ydCBjb25zdCBDT01NQU5EX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxDb21tYW5kT3B0aW9ucz4oXCJjb21tYW5kLWNvbmZpZ1wiKTtcbiJdfQ==

package/esm2020/index.mjs

@@ -0,0 +1,8 @@
+export * from "./command";
+export * from "./command.directive";
+export * from "./command-ref.directive";
+export * from "./command.util";
+export * from "./config";
+export * from "./module";
+export * from "./version";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kLmRpcmVjdGl2ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29tbWFuZC1yZWYuZGlyZWN0aXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kLnV0aWxcIjtcbmV4cG9ydCB7IENvbW1hbmRDcmVhdG9yLCBJQ29tbWFuZCB9IGZyb20gXCIuL2NvbW1hbmQubW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbmZpZ1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kdWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi92ZXJzaW9uXCI7XG4iXX0=

package/esm2020/module.mjs

@@ -0,0 +1,49 @@
+import { NgModule, InjectionToken, Optional } from "@angular/core";
+import { CommandDirective } from "./command.directive";
+import { CommandRefDirective } from "./command-ref.directive";
+import { COMMAND_DEFAULT_CONFIG, COMMAND_CONFIG } from "./config";
+import * as i0 from "@angular/core";
+/** @internal */
+export const MODULE_CONFIG_DATA = new InjectionToken("@ssv/ngx.command/configData");
+const components = [
+    CommandDirective,
+    CommandRefDirective
+];
+export class SsvCommandModule {
+    static forRoot(config) {
+        return {
+            ngModule: SsvCommandModule,
+            providers: [
+                { provide: MODULE_CONFIG_DATA, useValue: config },
+            ],
+        };
+    }
+}
+SsvCommandModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvCommandModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SsvCommandModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SsvCommandModule, declarations: [CommandDirective,
+        CommandRefDirective], exports: [CommandDirective,
+        CommandRefDirective] });
+SsvCommandModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvCommandModule, providers: [
+        { provide: COMMAND_CONFIG, useFactory: _moduleConfigFactory, deps: [[MODULE_CONFIG_DATA, new Optional()]] },
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SsvCommandModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: components,
+                    providers: [
+                        { provide: COMMAND_CONFIG, useFactory: _moduleConfigFactory, deps: [[MODULE_CONFIG_DATA, new Optional()]] },
+                    ],
+                    exports: [...components],
+                }]
+        }] });
+/** @internal */
+export function _moduleConfigFactory(config) {
+    const cfg = typeof config === "function" ? config() : config;
+    return cfg
+        ? {
+            ...COMMAND_DEFAULT_CONFIG,
+            ...cfg,
+        }
+        : COMMAND_DEFAULT_CONFIG;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUF1QixjQUFjLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXhGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBa0Isc0JBQXNCLEVBQUUsY0FBYyxFQUFFLE1BQU0sVUFBVSxDQUFDOztBQUVsRixnQkFBZ0I7QUFDaEIsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxjQUFjLENBQWlCLDZCQUE2QixDQUFDLENBQUM7QUFFcEcsTUFBTSxVQUFVLEdBQUc7SUFDbEIsZ0JBQWdCO0lBQ2hCLG1CQUFtQjtDQUNuQixDQUFDO0FBU0YsTUFBTSxPQUFPLGdCQUFnQjtJQUU1QixNQUFNLENBQUMsT0FBTyxDQUFDLE1BQWtFO1FBQ2hGLE9BQU87WUFDTixRQUFRLEVBQUUsZ0JBQWdCO1lBQzFCLFNBQVMsRUFBRTtnQkFDVixFQUFFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFO2FBQ2pEO1NBQ0QsQ0FBQztJQUNILENBQUM7OzZHQVRXLGdCQUFnQjs4R0FBaEIsZ0JBQWdCLGlCQVg1QixnQkFBZ0I7UUFDaEIsbUJBQW1CLGFBRG5CLGdCQUFnQjtRQUNoQixtQkFBbUI7OEdBVVAsZ0JBQWdCLGFBTGpCO1FBQ1YsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxvQkFBb0IsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLGtCQUFrQixFQUFFLElBQUksUUFBUSxFQUFFLENBQUMsQ0FBQyxFQUFFO0tBQzNHOzJGQUdXLGdCQUFnQjtrQkFQNUIsUUFBUTttQkFBQztvQkFDVCxZQUFZLEVBQUUsVUFBVTtvQkFDeEIsU0FBUyxFQUFFO3dCQUNWLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsb0JBQW9CLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxrQkFBa0IsRUFBRSxJQUFJLFFBQVEsRUFBRSxDQUFDLENBQUMsRUFBRTtxQkFDM0c7b0JBQ0QsT0FBTyxFQUFFLENBQUMsR0FBRyxVQUFVLENBQUM7aUJBQ3hCOztBQWNELGdCQUFnQjtBQUNoQixNQUFNLFVBQVUsb0JBQW9CLENBQUMsTUFBK0M7SUFDbkYsTUFBTSxHQUFHLEdBQUcsT0FBTyxNQUFNLEtBQUssVUFBVSxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzdELE9BQU8sR0FBRztRQUNULENBQUMsQ0FBQztZQUNELEdBQUcsc0JBQXNCO1lBQ3pCLEdBQUcsR0FBRztTQUNOO1FBQ0QsQ0FBQyxDQUFDLHNCQUFzQixDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTW9kdWxlV2l0aFByb3ZpZGVycywgSW5qZWN0aW9uVG9rZW4sIE9wdGlvbmFsIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuaW1wb3J0IHsgQ29tbWFuZERpcmVjdGl2ZSB9IGZyb20gXCIuL2NvbW1hbmQuZGlyZWN0aXZlXCI7XG5pbXBvcnQgeyBDb21tYW5kUmVmRGlyZWN0aXZlIH0gZnJvbSBcIi4vY29tbWFuZC1yZWYuZGlyZWN0aXZlXCI7XG5pbXBvcnQgeyBDb21tYW5kT3B0aW9ucywgQ09NTUFORF9ERUZBVUxUX0NPTkZJRywgQ09NTUFORF9DT05GSUcgfSBmcm9tIFwiLi9jb25maWdcIjtcblxuLyoqIEBpbnRlcm5hbCAqL1xuZXhwb3J0IGNvbnN0IE1PRFVMRV9DT05GSUdfREFUQSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxDb21tYW5kT3B0aW9ucz4oXCJAc3N2L25neC5jb21tYW5kL2NvbmZpZ0RhdGFcIik7XG5cbmNvbnN0IGNvbXBvbmVudHMgPSBbXG5cdENvbW1hbmREaXJlY3RpdmUsXG5cdENvbW1hbmRSZWZEaXJlY3RpdmVcbl07XG5cbkBOZ01vZHVsZSh7XG5cdGRlY2xhcmF0aW9uczogY29tcG9uZW50cyxcblx0cHJvdmlkZXJzOiBbXG5cdFx0eyBwcm92aWRlOiBDT01NQU5EX0NPTkZJRywgdXNlRmFjdG9yeTogX21vZHVsZUNvbmZpZ0ZhY3RvcnksIGRlcHM6IFtbTU9EVUxFX0NPTkZJR19EQVRBLCBuZXcgT3B0aW9uYWwoKV1dIH0sXG5cdF0sXG5cdGV4cG9ydHM6IFsuLi5jb21wb25lbnRzXSxcbn0pXG5leHBvcnQgY2xhc3MgU3N2Q29tbWFuZE1vZHVsZSB7XG5cblx0c3RhdGljIGZvclJvb3QoY29uZmlnPzogUGFydGlhbDxDb21tYW5kT3B0aW9ucz4gfCAoKCkgPT4gUGFydGlhbDxDb21tYW5kT3B0aW9ucz4pKTogTW9kdWxlV2l0aFByb3ZpZGVyczxTc3ZDb21tYW5kTW9kdWxlPiB7XG5cdFx0cmV0dXJuIHtcblx0XHRcdG5nTW9kdWxlOiBTc3ZDb21tYW5kTW9kdWxlLFxuXHRcdFx0cHJvdmlkZXJzOiBbXG5cdFx0XHRcdHsgcHJvdmlkZTogTU9EVUxFX0NPTkZJR19EQVRBLCB1c2VWYWx1ZTogY29uZmlnIH0sXG5cdFx0XHRdLFxuXHRcdH07XG5cdH1cblxufVxuXG4vKiogQGludGVybmFsICovXG5leHBvcnQgZnVuY3Rpb24gX21vZHVsZUNvbmZpZ0ZhY3RvcnkoY29uZmlnOiBDb21tYW5kT3B0aW9ucyB8ICgoKSA9PiBDb21tYW5kT3B0aW9ucykpOiBDb21tYW5kT3B0aW9ucyB7XG5cdGNvbnN0IGNmZyA9IHR5cGVvZiBjb25maWcgPT09IFwiZnVuY3Rpb25cIiA/IGNvbmZpZygpIDogY29uZmlnO1xuXHRyZXR1cm4gY2ZnXG5cdFx0PyB7XG5cdFx0XHQuLi5DT01NQU5EX0RFRkFVTFRfQ09ORklHLFxuXHRcdFx0Li4uY2ZnLFxuXHRcdH1cblx0XHQ6IENPTU1BTkRfREVGQVVMVF9DT05GSUc7XG59XG4iXX0=

package/esm2020/ssv-ngx.command.mjs

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

package/esm2020/version.mjs

@@ -0,0 +1,2 @@
+export const VERSION = "0.0.0-PLACEHOLDER";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBWRVJTSU9OID0gXCIwLjAuMC1QTEFDRUhPTERFUlwiO1xuIl19