@brandup/ui 1.0.1 → 1.0.2

package/dist/cjs/index.js

@@ -67,15 +67,6 @@ class UIElement {
             isExecuting: false
         };
     }
-    registerAsyncCommand(name, delegate, canExecute) {
-        name = this.verifyCommandName(name);
-        this.__commandHandlers[name] = {
-            name: name,
-            delegate,
-            canExecute,
-            isExecuting: false
-        };
-    }
     hasCommand(name) {
         return name.toLowerCase() in this.__commandHandlers;
     }
@@ -83,71 +74,48 @@ class UIElement {
         if (!this.__element)
             throw new Error("UIElement is not set HTMLElement.");
         const key = name.toLowerCase();
-        if (!(key in this.__commandHandlers))
+        const handler = this.__commandHandlers[key];
+        if (!handler)
             throw new Error(`Command "${name}" is not registered.`);
         const context = {
             target: elem,
             uiElem: this,
             transparent: false
         };
-        const handler = this.__commandHandlers[key];
         if (handler.isExecuting)
-            return { result: exports.CommandsExecStatus.AlreadyExecuting, context };
+            return { status: "already", context };
         handler.isExecuting = true;
         if (!this._onCanExecCommand(name, elem)) {
             handler.isExecuting = false;
-            return { result: exports.CommandsExecStatus.NotAllow, context };
+            return { status: "disallow", context };
         }
-        if (handler.canExecute && !handler.canExecute(elem, context)) {
+        if (handler.canExecute && !handler.canExecute(context)) {
             handler.isExecuting = false;
-            return { result: exports.CommandsExecStatus.NotAllow, context };
+            return { status: "disallow", context };
         }
         this.raiseEvent("command", {
             name: handler.name,
             uiElem: this,
             elem: this.__element
         });
-        if (handler.execute) {
-            // Если команда синхронная.
-            try {
-                handler.execute(elem, context);
-            }
-            finally {
-                handler.isExecuting = false;
+        let isAsync;
+        try {
+            const handlerResult = handler.execute(context);
+            if (handlerResult && handlerResult instanceof Promise) {
+                isAsync = true;
+                elem.classList.add(CommandExecutingCssClassName);
+                handlerResult
+                    .finally(() => {
+                    elem.classList.remove(CommandExecutingCssClassName);
+                    handler.isExecuting = false;
+                });
             }
         }
-        else if (handler.delegate) {
-            // Если команда асинхронная.
-            elem.classList.add(CommandExecutingCssClassName);
-            let timeoutId = 0;
-            const endFunc = () => {
+        finally {
+            if (!isAsync)
                 handler.isExecuting = false;
-                elem.classList.remove(CommandExecutingCssClassName);
-            };
-            const asyncContext = {
-                target: elem,
-                uiElem: this,
-                transparent: context.transparent,
-                complate: () => {
-                    clearTimeout(timeoutId);
-                    endFunc();
-                }
-            };
-            const handlerResult = handler.delegate(asyncContext);
-            if (handlerResult && handlerResult instanceof Promise)
-                handlerResult.finally(() => asyncContext.complate());
-            if (handler.isExecuting && asyncContext.timeout) {
-                timeoutId = window.setTimeout(() => {
-                    if (asyncContext.timeoutCallback)
-                        asyncContext.timeoutCallback();
-                    endFunc();
-                }, asyncContext.timeout);
-            }
-            context.transparent = asyncContext.transparent;
         }
-        else
-            throw new Error("Not set command execute flow.");
-        return { result: exports.CommandsExecStatus.Success, context: context };
+        return { status: "success", context: context };
     }
     verifyCommandName(name) {
         const key = name.toLowerCase();
@@ -170,12 +138,6 @@ class UIElement {
         delete elem[ElemPropertyName];
     }
 }
-exports.CommandsExecStatus = void 0;
-(function (CommandsExecStatus) {
-    CommandsExecStatus[CommandsExecStatus["NotAllow"] = 1] = "NotAllow";
-    CommandsExecStatus[CommandsExecStatus["AlreadyExecuting"] = 2] = "AlreadyExecuting";
-    CommandsExecStatus[CommandsExecStatus["Success"] = 3] = "Success";
-})(exports.CommandsExecStatus || (exports.CommandsExecStatus = {}));
 const fundUiElementByCommand = (elem, commandName) => {
     while (elem) {
         if (elem.dataset[ElemAttributeName]) {
@@ -207,14 +169,13 @@ const commandClickHandler = (e) => {
     if (!commandName)
         throw new Error("Command data attribute is not have value.");
     const uiElem = fundUiElementByCommand(commandElem, commandName);
-    if (uiElem === null) {
-        console.warn(`Not find handler for command "${commandName}".`);
-    }
-    else {
-        const commandResult = uiElem.execCommand(commandName, commandElem);
-        if (commandResult.context.transparent)
+    if (uiElem) {
+        const result = uiElem.execCommand(commandName, commandElem);
+        if (result.status == "success" && result.context.transparent)
             return;
     }
+    else
+        console.warn(`Not find handler for command "${commandName}".`);
     e.preventDefault();
     e.stopPropagation();
     e.stopImmediatePropagation();

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/mjs/index.js

@@ -65,15 +65,6 @@ class UIElement {
             isExecuting: false
         };
     }
-    registerAsyncCommand(name, delegate, canExecute) {
-        name = this.verifyCommandName(name);
-        this.__commandHandlers[name] = {
-            name: name,
-            delegate,
-            canExecute,
-            isExecuting: false
-        };
-    }
     hasCommand(name) {
         return name.toLowerCase() in this.__commandHandlers;
     }
@@ -81,71 +72,48 @@ class UIElement {
         if (!this.__element)
             throw new Error("UIElement is not set HTMLElement.");
         const key = name.toLowerCase();
-        if (!(key in this.__commandHandlers))
+        const handler = this.__commandHandlers[key];
+        if (!handler)
             throw new Error(`Command "${name}" is not registered.`);
         const context = {
             target: elem,
             uiElem: this,
             transparent: false
         };
-        const handler = this.__commandHandlers[key];
         if (handler.isExecuting)
-            return { result: CommandsExecStatus.AlreadyExecuting, context };
+            return { status: "already", context };
         handler.isExecuting = true;
         if (!this._onCanExecCommand(name, elem)) {
             handler.isExecuting = false;
-            return { result: CommandsExecStatus.NotAllow, context };
+            return { status: "disallow", context };
         }
-        if (handler.canExecute && !handler.canExecute(elem, context)) {
+        if (handler.canExecute && !handler.canExecute(context)) {
             handler.isExecuting = false;
-            return { result: CommandsExecStatus.NotAllow, context };
+            return { status: "disallow", context };
         }
         this.raiseEvent("command", {
             name: handler.name,
             uiElem: this,
             elem: this.__element
         });
-        if (handler.execute) {
-            // Если команда синхронная.
-            try {
-                handler.execute(elem, context);
-            }
-            finally {
-                handler.isExecuting = false;
+        let isAsync;
+        try {
+            const handlerResult = handler.execute(context);
+            if (handlerResult && handlerResult instanceof Promise) {
+                isAsync = true;
+                elem.classList.add(CommandExecutingCssClassName);
+                handlerResult
+                    .finally(() => {
+                    elem.classList.remove(CommandExecutingCssClassName);
+                    handler.isExecuting = false;
+                });
             }
         }
-        else if (handler.delegate) {
-            // Если команда асинхронная.
-            elem.classList.add(CommandExecutingCssClassName);
-            let timeoutId = 0;
-            const endFunc = () => {
+        finally {
+            if (!isAsync)
                 handler.isExecuting = false;
-                elem.classList.remove(CommandExecutingCssClassName);
-            };
-            const asyncContext = {
-                target: elem,
-                uiElem: this,
-                transparent: context.transparent,
-                complate: () => {
-                    clearTimeout(timeoutId);
-                    endFunc();
-                }
-            };
-            const handlerResult = handler.delegate(asyncContext);
-            if (handlerResult && handlerResult instanceof Promise)
-                handlerResult.finally(() => asyncContext.complate());
-            if (handler.isExecuting && asyncContext.timeout) {
-                timeoutId = window.setTimeout(() => {
-                    if (asyncContext.timeoutCallback)
-                        asyncContext.timeoutCallback();
-                    endFunc();
-                }, asyncContext.timeout);
-            }
-            context.transparent = asyncContext.transparent;
         }
-        else
-            throw new Error("Not set command execute flow.");
-        return { result: CommandsExecStatus.Success, context: context };
+        return { status: "success", context: context };
     }
     verifyCommandName(name) {
         const key = name.toLowerCase();
@@ -168,12 +136,6 @@ class UIElement {
         delete elem[ElemPropertyName];
     }
 }
-var CommandsExecStatus;
-(function (CommandsExecStatus) {
-    CommandsExecStatus[CommandsExecStatus["NotAllow"] = 1] = "NotAllow";
-    CommandsExecStatus[CommandsExecStatus["AlreadyExecuting"] = 2] = "AlreadyExecuting";
-    CommandsExecStatus[CommandsExecStatus["Success"] = 3] = "Success";
-})(CommandsExecStatus || (CommandsExecStatus = {}));
 const fundUiElementByCommand = (elem, commandName) => {
     while (elem) {
         if (elem.dataset[ElemAttributeName]) {
@@ -205,19 +167,18 @@ const commandClickHandler = (e) => {
     if (!commandName)
         throw new Error("Command data attribute is not have value.");
     const uiElem = fundUiElementByCommand(commandElem, commandName);
-    if (uiElem === null) {
-        console.warn(`Not find handler for command "${commandName}".`);
-    }
-    else {
-        const commandResult = uiElem.execCommand(commandName, commandElem);
-        if (commandResult.context.transparent)
+    if (uiElem) {
+        const result = uiElem.execCommand(commandName, commandElem);
+        if (result.status == "success" && result.context.transparent)
             return;
     }
+    else
+        console.warn(`Not find handler for command "${commandName}".`);
     e.preventDefault();
     e.stopPropagation();
     e.stopImmediatePropagation();
 };
 window.addEventListener("click", commandClickHandler, false);
 
-export { CommandAttributeName, CommandExecutingCssClassName, CommandsExecStatus, ElemAttributeName, ElemPropertyName, UIElement };
+export { CommandAttributeName, CommandExecutingCssClassName, ElemAttributeName, ElemPropertyName, UIElement };
 //# sourceMappingURL=index.js.map

package/dist/mjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types.d.ts

@@ -2,9 +2,8 @@ declare const ElemAttributeName = "uiElement";
 declare const ElemPropertyName = "brandupUiElement";
 declare const CommandAttributeName = "command";
 declare const CommandExecutingCssClassName = "executing";
-type CommandDelegate = (elem: HTMLElement, context: CommandContext) => void;
-type CommandCanExecuteDelegate = (elem: HTMLElement, context: CommandContext) => boolean;
-type CommandAsyncDelegate = (context: CommandAsyncContext) => void | Promise<void>;
+type CommandDelegate = (context: CommandContext) => void | Promise<void | any>;
+type CommandCanExecuteDelegate = (context: CommandContext) => boolean;
 declare abstract class UIElement {
     private __element;
     private __events;
@@ -19,7 +18,6 @@ declare abstract class UIElement {
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     dispatchEvent(event: Event): boolean;
     registerCommand(name: string, execute: CommandDelegate, canExecute?: CommandCanExecuteDelegate): void;
-    registerAsyncCommand(name: string, delegate: CommandAsyncDelegate, canExecute?: CommandCanExecuteDelegate): void;
     hasCommand(name: string): boolean;
     execCommand(name: string, elem: HTMLElement): CommandExecutionResult;
     private verifyCommandName;
@@ -44,7 +42,7 @@ interface CommandContext {
     transparent: boolean;
 }
 interface CommandExecutionResult {
-    result: CommandsExecStatus;
+    status: CommandExecStatus;
     context: CommandContext;
 }
 interface CommandAsyncContext extends CommandContext {
@@ -52,10 +50,6 @@ interface CommandAsyncContext extends CommandContext {
     complate: VoidFunction;
     timeoutCallback?: VoidFunction;
 }
-declare enum CommandsExecStatus {
-    NotAllow = 1,
-    AlreadyExecuting = 2,
-    Success = 3
-}
+type CommandExecStatus = "disallow" | "already" | "success";
 
-export { type CommandAsyncContext, type CommandAsyncDelegate, CommandAttributeName, type CommandCanExecuteDelegate, type CommandContext, type CommandDelegate, type CommandEventArgs, CommandExecutingCssClassName, type CommandExecutionResult, CommandsExecStatus, ElemAttributeName, ElemPropertyName, type EventOptions, UIElement };
+export { type CommandAsyncContext, CommandAttributeName, type CommandCanExecuteDelegate, type CommandContext, type CommandDelegate, type CommandEventArgs, type CommandExecStatus, CommandExecutingCssClassName, type CommandExecutionResult, ElemAttributeName, ElemPropertyName, type EventOptions, UIElement };

package/package.json

@@ -22,27 +22,12 @@
     "email": "it@brandup.online"
   },
   "license": "Apache-2.0",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/types.d.ts",
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^25.0.8",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
-    "rollup": "^4.19.0",
-    "rollup-plugin-dts": "^6.1.1",
-    "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "tslib": "^2.6.3",
-    "typescript": "^5.5.3"
-  },
   "files": [
     "dist",
     "README.md"
-  ],
-  "scripts": {
-    "build": "rollup -c --bundleConfigAsCjs",
-    "watch": "rollup -c -w --bundleConfigAsCjs"
-  }
+  ]
 }