react-elmish 4.2.0 → 4.4.0

package/.eslintrc

@@ -1,3 +1,3 @@
 {
-    "extends": "heck/node"
+    "extends": ["heck/node", "heck/groupImports"]
 }

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

package/README.md

@@ -5,6 +5,35 @@
 
 This library brings the elmish pattern to react.
 
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [More on messages](#more-on-messages)
+  - [Message arguments](#message-arguments)
+  - [Symbols instead of strings](#symbols-instead-of-strings)
+- [Dispatch commands in the update map or update function](#dispatch-commands-in-the-update-map-or-update-function)
+  - [Dispatch a message](#dispatch-a-message)
+  - [Call an async function](#call-an-async-function)
+  - [Dispatch a command from `init`](#dispatch-a-command-from-init)
+- [Subscriptions](#subscriptions)
+  - [Working with external sources of events](#working-with-external-sources-of-events)
+  - [Cleanup subscriptions](#cleanup-subscriptions)
+- [Setup](#setup)
+- [Error handling](#error-handling)
+- [React life cycle management](#react-life-cycle-management)
+- [Composition](#composition)
+  - [With an `UpdateMap`](#with-an-updatemap)
+- [With an update function](#with-an-update-function)
+- [Call back parent components](#call-back-parent-components)
+- [Testing](#testing)
+  - [Testing the model and simple message commands](#testing-the-model-and-simple-message-commands)
+  - [Testing all (async) messages](#testing-all-async-messages)
+  - [Testing with an UpdateMap](#testing-with-an-updatemap)
+  - [UI Tests](#ui-tests)
+- [Migrations](#migrations)
+  - [From v1.x to v2.x](#from-v1x-to-v2x)
+  - [From v2.x to v3.x](#from-v2x-to-v3x)
+  - [From v3.x to v4.x](#from-v3x-to-v4x)
+
 ## Installation
 
 `npm install react-elmish`
@@ -13,14 +42,14 @@ This library brings the elmish pattern to react.
 
 An elmish component basically consists of the following parts:
 
-* The **Model** holding the state of the component.
-* The **Props** for the component.
-* The **Init** function to create the initial model based on the props.
-* The **Messages** to dispatch which modify the model.
-* The **Update** function to modify the model based on a specific message.
-* The **View** which renders the component based on the current model.
+- The **Model** holding the state of the component.
+- The **Props** for the component.
+- The **Init** function to create the initial model based on the props.
+- The **Messages** to dispatch which modify the model.
+- The **Update** function to modify the model based on a specific message.
+- The **View** which renders the component based on the current model.
 
-### App.ts
+**App.ts:**
 
 First import everything from `react-elmish` and declare the **Message** discriminated union type:
 
@@ -101,7 +130,7 @@ export const update = (model: Model, msg: Msg, props: Props): UpdateReturnType<M
 
 > **Note:** If you are using **typescript** and **typescript-eslint** you should enable the [switch-exhaustive-check](https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/switch-exhaustiveness-check.md) rule.
 
-### App.tsx
+**App.tsx:**
 
 To put all this together and to render our component, we need a React component.
 
@@ -439,7 +468,7 @@ function subscription (model: Model): SubscriptionResult<Message> {
     }
 
     const destructor = () => {
-        clearInterval(timer1);
+        clearInterval(timer);
     }
 
     return [cmd.ofSub(sub), destructor];
@@ -522,7 +551,7 @@ You can handle errors easily with the following pattern.
         };
         ```
 
-        Your can also use the `errorHandler` helper function:
+        You can also use the `errorHandler` helper function:
 
         ```ts
         const updateMap = {
@@ -828,9 +857,7 @@ To inform the parent component about some action, let's say to close a dialog fo
     ```ts Dialog.ts
     ...
     case "close":
-        props.onClose();
-
-        return [{}];
+        return [{}, cmd.ofFunc.attempt(props.onClose, Msg.error)];
     ...
     ```
 
@@ -964,10 +991,12 @@ it("dispatches the correct message", async () => {
 
 This works for function components using the `useElmish` hook and class components.
 
-## Migration from v1.x to v2.x
+## Migrations
+
+### From v1.x to v2.x
 
-* Use `Logger` and `Message` instead of `ILogger` and `IMessage`.
-* The global declaration of the `Nullable` type was removed, because it is unexpected for this library to declare such a type. You can declare this type for yourself if needed:
+- Use `Logger` and `Message` instead of `ILogger` and `IMessage`.
+- The global declaration of the `Nullable` type was removed, because it is unexpected for this library to declare such a type. You can declare this type for yourself if needed:
 
     ```ts
     declare global {
@@ -975,7 +1004,7 @@ This works for function components using the `useElmish` hook and class componen
     }
     ```
 
-## Migration from v2.x to v3.x
+### From v2.x to v3.x
 
 The signature of `useElmish` has changed. It takes an options object now. Thus there is no need for the `useElmishMap` function. Use the new `useElmish` hook with an `UpdateMap` instead.
 
@@ -988,6 +1017,6 @@ import { useElmishMap } from "react-elmish/dist/legacy/useElmishMap";
 
 **Notice**: These functions are marked as deprecated and will be removed in a later release.
 
-## Migration from v3.x to v4.x
+### From v3.x to v4.x
 
 Because the legacy `useElmish` and `useElmishMap` have been removed, you have to convert all usages of `useElmish` to use the parameter object.

package/dist/Cmd.d.ts

@@ -1,37 +1,38 @@
 /**
  * Type of the dispatch function.
  */
-declare type Dispatch<TMsg> = (msg: TMsg) => void;
+declare type Dispatch<TMessage> = (msg: TMessage) => void;
 declare type FallbackHandler = (error?: Error) => void;
 declare type Sub<TMsg> = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler) => void;
 /**
  * Type of a command.
  */
-declare type Cmd<TMsg> = Sub<TMsg>[];
+declare type Cmd<TMessage> = Sub<TMessage>[];
 /**
  * Contains functions to create commands.
- * @template TMsg Type of the Message discriminated union.
+ * @template TMessage Type of the Message discriminated union.
  */
-interface Command<TMsg> {
+interface Command<TMessage> {
     /**
      * Represents an empty command.
+     * @deprecated Do return nothing (`undefined`) instead.
      */
     none: [];
     /**
      * Creates a command out of a specific message.
-     * @param {TMsg} msg The specific message.
+     * @param {TMessage} msg The specific message.
      */
-    ofMsg: (msg: TMsg) => Cmd<TMsg>;
+    ofMsg: (msg: TMessage) => Cmd<TMessage>;
     /**
      * Aggregates multiple commands.
-     * @param {Cmd<TMsg> []} commands Array of commands.
+     * @param {Cmd<TMessage> []} commands Array of commands.
      */
-    batch: (...commands: Cmd<TMsg>[]) => Cmd<TMsg>;
+    batch: (...commands: (Cmd<TMessage> | undefined | null)[]) => Cmd<TMessage>;
     /**
      * Command to call the subscriber.
-     * @param {Sub<TMsg>} sub The subscriber function.
+     * @param {Sub<TMessage>} sub The subscriber function.
      */
-    ofSub: (sub: Sub<TMsg>) => Cmd<TMsg>;
+    ofSub: (sub: Sub<TMessage>) => Cmd<TMessage>;
     /**
      * Provides functionalities to create commands from simple functions.
      */
@@ -43,21 +44,21 @@ interface Command<TMsg> {
         * @param ofError Creates the message to dispatch when an error occurred.
         * @param args The parameters of the task.
         */
-        either: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        either: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>;
         /**
         * Creates a command out of a simple function and ignores the error case.
         * @param task The function to call.
         * @param ofSuccess Creates the message to dispatch after a successful call of the task.
         * @param args The parameters of the task.
         */
-        perform: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        perform: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs) => Cmd<TMessage>;
         /**
         * Creates a command out of a simple function and ignores the success case.
         * @param task The function to call.
         * @param ofError Creates the message to dispatch when an error occurred.
         * @param args The parameters of the task.
         */
-        attempt: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        attempt: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>;
     };
     /**
      * Provides functionalities to create commands from async functions.
@@ -70,27 +71,27 @@ interface Command<TMsg> {
         * @param ofError Creates the message to dispatch when the promise is rejected.
         * @param args The parameters of the task.
         */
-        either: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        either: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>;
         /**
         * Creates a command out of an async function and ignores the error case.
         * @param task The async function to call.
         * @param ofSuccess Creates the message to dispatch when the promise is resolved.
         * @param args The parameters of the task.
         */
-        perform: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        perform: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs) => Cmd<TMessage>;
         /**
         * Creates a command out of an async function and ignores the success case.
         * @param task The async function to call.
         * @param ofError Creates the message to dispatch when the promise is rejected.
         * @param args The parameters of the task.
         */
-        attempt: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>;
+        attempt: <TArgs extends unknown[], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>;
     };
 }
 /**
  * Creates a typed instance of the Command class.
- * @template TMsg The type of the Msg discriminated union.
+ * @template TMessage The type of the Msg discriminated union.
  */
-declare function createCmd<TMsg>(): Command<TMsg>;
+declare function createCmd<TMessage>(): Command<TMessage>;
 export type { Dispatch, Cmd, };
 export { createCmd, };

package/dist/Cmd.js

@@ -15,12 +15,12 @@ exports.createCmd = createCmd;
 
 /**
  * Contains functions to create commands.
- * @template TMsg Type of the Message discriminated union.
+ * @template TMessage Type of the Message discriminated union.
  */
 
 /**
  * Creates a typed instance of the Command class.
- * @template TMsg The type of the Msg discriminated union.
+ * @template TMessage The type of the Msg discriminated union.
  */
 function createCmd() {
   return {
@@ -35,7 +35,7 @@ function createCmd() {
         commands[_key] = arguments[_key];
       }
 
-      return commands.flat();
+      return commands.filter(Boolean).flat();
     },
     ofSub: function ofSub(sub) {
       return [sub];
@@ -150,4 +150,4 @@ function createCmd() {
     }
   };
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["createCmd","none","ofMsg","msg","dispatch","batch","commands","flat","ofSub","sub","ofFunc","either","task","ofSuccess","ofError","args","bind","result","ex","perform","fallback","attempt","ofPromise","then","defaultFallbackHandler"],"sources":["../src/Cmd.ts"],"sourcesContent":["/**\n * Type of the dispatch function.\n */\ntype Dispatch<TMsg> = (msg: TMsg) => void;\n\ntype FallbackHandler = (error?: Error) => void;\ntype Sub<TMsg> = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler) => void;\n\n/**\n * Type of a command.\n */\ntype Cmd<TMsg> = Sub<TMsg> [];\n\n/**\n * Contains functions to create commands.\n * @template TMsg Type of the Message discriminated union.\n */\ninterface Command<TMsg> {\n    /**\n     * Represents an empty command.\n     */\n    none: [],\n    /**\n     * Creates a command out of a specific message.\n     * @param {TMsg} msg The specific message.\n     */\n    ofMsg: (msg: TMsg) => Cmd<TMsg>,\n    /**\n     * Aggregates multiple commands.\n     * @param {Cmd<TMsg> []} commands Array of commands.\n     */\n    batch: (...commands: Cmd<TMsg> []) => Cmd<TMsg>,\n    /**\n     * Command to call the subscriber.\n     * @param {Sub<TMsg>} sub The subscriber function.\n     */\n    ofSub: (sub: Sub<TMsg>) => Cmd<TMsg>,\n    /**\n     * Provides functionalities to create commands from simple functions.\n     */\n    ofFunc: {\n        /**\n        * Creates a command out of a simple function and maps the result.\n        * @param task The function to call.\n        * @param ofSuccess Creates the message to dispatch after a successful call of the task.\n        * @param ofError Creates the message to dispatch when an error occurred.\n        * @param args The parameters of the task.\n        */\n        either: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n        /**\n        * Creates a command out of a simple function and ignores the error case.\n        * @param task The function to call.\n        * @param ofSuccess Creates the message to dispatch after a successful call of the task.\n        * @param args The parameters of the task.\n        */\n        perform: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n        /**\n        * Creates a command out of a simple function and ignores the success case.\n        * @param task The function to call.\n        * @param ofError Creates the message to dispatch when an error occurred.\n        * @param args The parameters of the task.\n        */\n        attempt: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n    },\n    /**\n     * Provides functionalities to create commands from async functions.\n     */\n    ofPromise: {\n        /**\n        * Creates a command out of an async function and maps the result.\n        * @param task The async function to call.\n        * @param ofSuccess Creates the message to dispatch when the promise is resolved.\n        * @param ofError Creates the message to dispatch when the promise is rejected.\n        * @param args The parameters of the task.\n        */\n        either: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n        /**\n        * Creates a command out of an async function and ignores the error case.\n        * @param task The async function to call.\n        * @param ofSuccess Creates the message to dispatch when the promise is resolved.\n        * @param args The parameters of the task.\n        */\n        perform: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n        /**\n        * Creates a command out of an async function and ignores the success case.\n        * @param task The async function to call.\n        * @param ofError Creates the message to dispatch when the promise is rejected.\n        * @param args The parameters of the task.\n        */\n        attempt: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMsg, ...args: TArgs) => Cmd<TMsg>,\n    },\n}\n\n/**\n * Creates a typed instance of the Command class.\n * @template TMsg The type of the Msg discriminated union.\n */\nfunction createCmd<TMsg> (): Command<TMsg> {\n    return {\n        none: [],\n        ofMsg (msg: TMsg): Cmd<TMsg> {\n            return [dispatch => dispatch(msg)];\n        },\n        batch (...commands: Cmd<TMsg> []): Cmd<TMsg> {\n            return commands.flat();\n        },\n        ofSub (sub: Sub<TMsg>): Cmd<TMsg> {\n            return [sub];\n        },\n        ofFunc: {\n            either<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const bind = (dispatch: Dispatch<TMsg>): void => {\n                    try {\n                        const result = task(...args);\n\n                        dispatch(ofSuccess(result));\n                    } catch (ex: unknown) {\n                        dispatch(ofError(ex as Error));\n                    }\n                };\n\n                return [bind];\n            },\n            perform<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const bind = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler): void => {\n                    try {\n                        const result = task(...args);\n\n                        dispatch(ofSuccess(result));\n                    } catch (ex: unknown) {\n                        if (fallback) {\n                            fallback(ex as Error);\n                        }\n                    }\n                };\n\n                return [bind];\n            },\n            attempt<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const bind = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler): void => {\n                    try {\n                        task(...args);\n\n                        if (fallback) {\n                            fallback();\n                        }\n                    } catch (ex: unknown) {\n                        dispatch(ofError(ex as Error));\n                    }\n                };\n\n                return [bind];\n            },\n        },\n        ofPromise: {\n            either<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ofError: (error: Error) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const bind = (dispatch: Dispatch<TMsg>): void => {\n                    task(...args).then(result => dispatch(ofSuccess(result)))\n                        .catch((ex: Error) => dispatch(ofError(ex)));\n                };\n\n                return [bind];\n            },\n            perform<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const defaultFallbackHandler = (): void => {\n                    // blank\n                };\n\n                const bind = (dispatch: Dispatch<TMsg>, fallback: FallbackHandler = defaultFallbackHandler): void => {\n                    task(...args).then(result => dispatch(ofSuccess(result)))\n                        .catch(fallback);\n                };\n\n                return [bind];\n            },\n            attempt<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMsg, ...args: TArgs): Cmd<TMsg> {\n                const bind = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler): void => {\n                    task(...args).then(() => {\n                        if (fallback) {\n                            fallback();\n                        }\n                    })\n                        .catch((ex: Error) => dispatch(ofError(ex)));\n                };\n\n                return [bind];\n            },\n        },\n    };\n}\n\nexport type {\n    Dispatch,\n    Cmd,\n};\n\nexport {\n    createCmd,\n};"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["createCmd","none","ofMsg","msg","dispatch","batch","commands","filter","Boolean","flat","ofSub","sub","ofFunc","either","task","ofSuccess","ofError","args","bind","result","ex","perform","fallback","attempt","ofPromise","then","defaultFallbackHandler"],"sources":["../src/Cmd.ts"],"sourcesContent":["/**\n * Type of the dispatch function.\n */\ntype Dispatch<TMessage> = (msg: TMessage) => void;\n\ntype FallbackHandler = (error?: Error) => void;\ntype Sub<TMsg> = (dispatch: Dispatch<TMsg>, fallback?: FallbackHandler) => void;\n\n/**\n * Type of a command.\n */\ntype Cmd<TMessage> = Sub<TMessage> [];\n\n/**\n * Contains functions to create commands.\n * @template TMessage Type of the Message discriminated union.\n */\ninterface Command<TMessage> {\n    /**\n     * Represents an empty command.\n     * @deprecated Do return nothing (`undefined`) instead.\n     */\n    none: [],\n    /**\n     * Creates a command out of a specific message.\n     * @param {TMessage} msg The specific message.\n     */\n    ofMsg: (msg: TMessage) => Cmd<TMessage>,\n    /**\n     * Aggregates multiple commands.\n     * @param {Cmd<TMessage> []} commands Array of commands.\n     */\n    batch: (...commands: (Cmd<TMessage> | undefined | null) []) => Cmd<TMessage>,\n    /**\n     * Command to call the subscriber.\n     * @param {Sub<TMessage>} sub The subscriber function.\n     */\n    ofSub: (sub: Sub<TMessage>) => Cmd<TMessage>,\n    /**\n     * Provides functionalities to create commands from simple functions.\n     */\n    ofFunc: {\n        /**\n        * Creates a command out of a simple function and maps the result.\n        * @param task The function to call.\n        * @param ofSuccess Creates the message to dispatch after a successful call of the task.\n        * @param ofError Creates the message to dispatch when an error occurred.\n        * @param args The parameters of the task.\n        */\n        either: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n        /**\n        * Creates a command out of a simple function and ignores the error case.\n        * @param task The function to call.\n        * @param ofSuccess Creates the message to dispatch after a successful call of the task.\n        * @param args The parameters of the task.\n        */\n        perform: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n        /**\n        * Creates a command out of a simple function and ignores the success case.\n        * @param task The function to call.\n        * @param ofError Creates the message to dispatch when an error occurred.\n        * @param args The parameters of the task.\n        */\n        attempt: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n    },\n    /**\n     * Provides functionalities to create commands from async functions.\n     */\n    ofPromise: {\n        /**\n        * Creates a command out of an async function and maps the result.\n        * @param task The async function to call.\n        * @param ofSuccess Creates the message to dispatch when the promise is resolved.\n        * @param ofError Creates the message to dispatch when the promise is rejected.\n        * @param args The parameters of the task.\n        */\n        either: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n        /**\n        * Creates a command out of an async function and ignores the error case.\n        * @param task The async function to call.\n        * @param ofSuccess Creates the message to dispatch when the promise is resolved.\n        * @param args The parameters of the task.\n        */\n        perform: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n        /**\n        * Creates a command out of an async function and ignores the success case.\n        * @param task The async function to call.\n        * @param ofError Creates the message to dispatch when the promise is rejected.\n        * @param args The parameters of the task.\n        */\n        attempt: <TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMessage, ...args: TArgs) => Cmd<TMessage>,\n    },\n}\n\n/**\n * Creates a typed instance of the Command class.\n * @template TMessage The type of the Msg discriminated union.\n */\nfunction createCmd<TMessage> (): Command<TMessage> {\n    return {\n        none: [],\n        ofMsg (msg: TMessage): Cmd<TMessage> {\n            return [dispatch => dispatch(msg)];\n        },\n        batch (...commands: (Cmd<TMessage> | undefined | null) []): Cmd<TMessage> {\n            return (commands.filter(Boolean) as Cmd<TMessage> []).flat();\n        },\n        ofSub (sub: Sub<TMessage>): Cmd<TMessage> {\n            return [sub];\n        },\n        ofFunc: {\n            either<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const bind = (dispatch: Dispatch<TMessage>): void => {\n                    try {\n                        const result = task(...args);\n\n                        dispatch(ofSuccess(result));\n                    } catch (ex: unknown) {\n                        dispatch(ofError(ex as Error));\n                    }\n                };\n\n                return [bind];\n            },\n            perform<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const bind = (dispatch: Dispatch<TMessage>, fallback?: FallbackHandler): void => {\n                    try {\n                        const result = task(...args);\n\n                        dispatch(ofSuccess(result));\n                    } catch (ex: unknown) {\n                        if (fallback) {\n                            fallback(ex as Error);\n                        }\n                    }\n                };\n\n                return [bind];\n            },\n            attempt<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => TReturn, ofError: (error: Error) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const bind = (dispatch: Dispatch<TMessage>, fallback?: FallbackHandler): void => {\n                    try {\n                        task(...args);\n\n                        if (fallback) {\n                            fallback();\n                        }\n                    } catch (ex: unknown) {\n                        dispatch(ofError(ex as Error));\n                    }\n                };\n\n                return [bind];\n            },\n        },\n        ofPromise: {\n            either<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ofError: (error: Error) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const bind = (dispatch: Dispatch<TMessage>): void => {\n                    task(...args).then(result => dispatch(ofSuccess(result)))\n                        .catch((ex: Error) => dispatch(ofError(ex)));\n                };\n\n                return [bind];\n            },\n            perform<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofSuccess: (result: TReturn) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const defaultFallbackHandler = (): void => {\n                    // blank\n                };\n\n                const bind = (dispatch: Dispatch<TMessage>, fallback: FallbackHandler = defaultFallbackHandler): void => {\n                    task(...args).then(result => dispatch(ofSuccess(result)))\n                        .catch(fallback);\n                };\n\n                return [bind];\n            },\n            attempt<TArgs extends unknown [], TReturn>(task: (...args: TArgs) => Promise<TReturn>, ofError: (error: Error) => TMessage, ...args: TArgs): Cmd<TMessage> {\n                const bind = (dispatch: Dispatch<TMessage>, fallback?: FallbackHandler): void => {\n                    task(...args).then(() => {\n                        if (fallback) {\n                            fallback();\n                        }\n                    })\n                        .catch((ex: Error) => dispatch(ofError(ex)));\n                };\n\n                return [bind];\n            },\n        },\n    };\n}\n\nexport type {\n    Dispatch,\n    Cmd,\n};\n\nexport {\n    createCmd,\n};"],"mappings":"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"}

package/dist/Common.d.ts

@@ -0,0 +1,6 @@
+import { Cmd, Dispatch } from "./Cmd";
+import { MessageBase } from "./Types";
+declare function logMessage<TMessage extends MessageBase>(name: string, msg: TMessage): void;
+declare function modelHasChanged<TModel>(currentModel: TModel, model: Partial<TModel>): boolean;
+declare function execCmd<TMessage>(cmd: Cmd<TMessage>, dispatch: Dispatch<TMessage>): void;
+export { logMessage, modelHasChanged, execCmd, };

package/dist/Common.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.execCmd = execCmd;
+exports.logMessage = logMessage;
+exports.modelHasChanged = modelHasChanged;
+
+var _Init = require("./Init");
+
+function logMessage(name, msg) {
+  var _Services$logger, _Services$logger2, _Services$dispatchMid;
+
+  (_Services$logger = _Init.Services.logger) === null || _Services$logger === void 0 ? void 0 : _Services$logger.info("Elm", "message from", name, msg.name);
+  (_Services$logger2 = _Init.Services.logger) === null || _Services$logger2 === void 0 ? void 0 : _Services$logger2.debug("Elm", "message from", name, msg);
+  (_Services$dispatchMid = _Init.Services.dispatchMiddleware) === null || _Services$dispatchMid === void 0 ? void 0 : _Services$dispatchMid.call(_Init.Services, msg);
+}
+
+function modelHasChanged(currentModel, model) {
+  return !Object.is(model, currentModel) && Object.getOwnPropertyNames(model).length > 0;
+}
+
+function execCmd(cmd, dispatch) {
+  cmd.forEach(function (call) {
+    try {
+      call(dispatch);
+    } catch (ex) {
+      var _Services$logger3;
+
+      (_Services$logger3 = _Init.Services.logger) === null || _Services$logger3 === void 0 ? void 0 : _Services$logger3.error(ex);
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/ElmComponent.d.ts

@@ -1,17 +1,17 @@
-import { InitFunction, UpdateFunction } from "./Types";
-import { Message } from "./Init";
 import React from "react";
+import { Message } from "./Init";
+import { InitFunction, UpdateFunction } from "./Types";
 /**
- * Abstract class for a react class component using the elmish pattern.
+ * Abstract class for a react class component using the Elmish pattern.
  * @export
  * @abstract
  * @class ElmComponent
  * @extends {Component<TProps, TModel>}
  * @template TModel The type of the model.
- * @template TMsg The type of the messages.
+ * @template TMessage The type of the messages.
  * @template TProps The type of the props.
  */
-declare abstract class ElmComponent<TModel, TMsg extends Message, TProps> extends React.Component<TProps> {
+declare abstract class ElmComponent<TModel, TMessage extends Message, TProps> extends React.Component<TProps> {
     private initCmd;
     private readonly componentName;
     private readonly buffer;
@@ -25,7 +25,7 @@ declare abstract class ElmComponent<TModel, TMsg extends Message, TProps> extend
      * @param name The name of the component.
      * @memberof ElmComponent
      */
-    constructor(props: TProps, init: InitFunction<TProps, TModel, TMsg>, name: string);
+    constructor(props: TProps, init: InitFunction<TProps, TModel, TMessage>, name: string);
     /**
      * Is called when the component is loaded.
      * When implementing this method, the base implementation has to be called.
@@ -38,7 +38,6 @@ declare abstract class ElmComponent<TModel, TMsg extends Message, TProps> extend
      * @memberof ElmComponent
      */
     componentWillUnmount(): void;
-    private execCmd;
     /**
      * Returns the current model.
      * @readonly
@@ -48,19 +47,19 @@ declare abstract class ElmComponent<TModel, TMsg extends Message, TProps> extend
     get model(): Readonly<TModel>;
     /**
      * Dispatches a message.
-     * @param {TMsg} msg The message to dispatch.
+     * @param {TMessage} msg The message to dispatch.
      * @memberof ElmComponent
      */
-    readonly dispatch: (msg: TMsg) => void;
+    readonly dispatch: (msg: TMessage) => void;
     /**
      * Function to modify the model based on a message.
      * @param {TModel} model The current model.
-     * @param {TMsg} msg The message to process.
+     * @param {TMessage} msg The message to process.
      * @param {TProps} props The props of the component.
      * @returns The new model (can also be an empty object {}) and an optional new message to dispatch.
      * @abstract
      * @memberof ElmComponent
      */
-    abstract update: UpdateFunction<TProps, TModel, TMsg>;
+    abstract update: UpdateFunction<TProps, TModel, TMessage>;
 }
 export { ElmComponent, };

package/dist/ElmComponent.js

@@ -7,12 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ElmComponent = void 0;
 
+var _react = _interopRequireDefault(require("react"));
+
+var _Common = require("./Common");
+
 var _Init = require("./Init");
 
 var _fakeOptions = require("./Testing/fakeOptions");
 
-var _react = _interopRequireDefault(require("react"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -54,13 +56,13 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
 /**
- * Abstract class for a react class component using the elmish pattern.
+ * Abstract class for a react class component using the Elmish pattern.
  * @export
  * @abstract
  * @class ElmComponent
  * @extends {Component<TProps, TModel>}
  * @template TModel The type of the model.
- * @template TMsg The type of the messages.
+ * @template TMessage The type of the messages.
  * @template TProps The type of the props.
  */
 var ElmComponent = /*#__PURE__*/function (_React$Component) {
@@ -95,10 +97,6 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
     _defineProperty(_assertThisInitialized(_this), "currentModel", void 0);
 
     _defineProperty(_assertThisInitialized(_this), "dispatch", function (msg) {
-      var modelHasChanged = function modelHasChanged(model) {
-        return model !== _this.currentModel && Object.getOwnPropertyNames(model).length > 0;
-      };
-
       if (_this.reentered) {
         _this.buffer.push(msg);
       } else {
@@ -107,14 +105,7 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
         var modified = false;
 
         while (nextMsg) {
-          var _Services$logger, _Services$logger2;
-
-          (_Services$logger = _Init.Services.logger) === null || _Services$logger === void 0 ? void 0 : _Services$logger.info("Elm", "message from", _this.componentName, nextMsg.name);
-          (_Services$logger2 = _Init.Services.logger) === null || _Services$logger2 === void 0 ? void 0 : _Services$logger2.debug("Elm", "message from", _this.componentName, nextMsg);
-
-          if (_Init.Services.dispatchMiddleware) {
-            _Init.Services.dispatchMiddleware(nextMsg);
-          }
+          (0, _Common.logMessage)(_this.componentName, nextMsg);
 
           try {
             var _this$update = _this.update(_this.currentModel, nextMsg, _this.props),
@@ -122,18 +113,18 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
                 model = _this$update2[0],
                 cmd = _this$update2[1];
 
-            if (modelHasChanged(model)) {
+            if ((0, _Common.modelHasChanged)(_this.currentModel, model)) {
               _this.currentModel = _objectSpread(_objectSpread({}, _this.currentModel), model);
               modified = true;
             }
 
             if (cmd) {
-              _this.execCmd(cmd);
+              (0, _Common.execCmd)(cmd, _this.dispatch);
             }
           } catch (ex) {
-            var _Services$logger3;
+            var _Services$logger;
 
-            (_Services$logger3 = _Init.Services.logger) === null || _Services$logger3 === void 0 ? void 0 : _Services$logger3.error(ex);
+            (_Services$logger = _Init.Services.logger) === null || _Services$logger === void 0 ? void 0 : _Services$logger.error(ex);
           }
 
           nextMsg = _this.buffer.shift();
@@ -142,9 +133,9 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
         _this.reentered = false;
 
         if (_this.mounted && modified) {
-          var _Services$logger4;
+          var _Services$logger2;
 
-          (_Services$logger4 = _Init.Services.logger) === null || _Services$logger4 === void 0 ? void 0 : _Services$logger4.debug("Elm", "update model for", _this.componentName, _this.currentModel);
+          (_Services$logger2 = _Init.Services.logger) === null || _Services$logger2 === void 0 ? void 0 : _Services$logger2.debug("Elm", "update model for", _this.componentName, _this.currentModel);
 
           _this.forceUpdate();
         }
@@ -182,7 +173,7 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
       this.mounted = true;
 
       if (this.initCmd) {
-        this.execCmd(this.initCmd);
+        (0, _Common.execCmd)(this.initCmd, this.dispatch);
         this.initCmd = null;
       }
     }
@@ -197,21 +188,6 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
     value: function componentWillUnmount() {
       this.mounted = false;
     }
-  }, {
-    key: "execCmd",
-    value: function execCmd(cmd) {
-      var _this2 = this;
-
-      cmd.forEach(function (call) {
-        try {
-          call(_this2.dispatch);
-        } catch (ex) {
-          var _Services$logger5;
-
-          (_Services$logger5 = _Init.Services.logger) === null || _Services$logger5 === void 0 ? void 0 : _Services$logger5.error(ex);
-        }
-      });
-    }
     /**
      * Returns the current model.
      * @readonly
@@ -226,7 +202,7 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
     }
     /**
      * Dispatches a message.
-     * @param {TMsg} msg The message to dispatch.
+     * @param {TMessage} msg The message to dispatch.
      * @memberof ElmComponent
      */
 
@@ -236,4 +212,4 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
 }(_react["default"].Component);
 
 exports.ElmComponent = ElmComponent;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ElmComponent","props","init","name","msg","modelHasChanged","model","currentModel","Object","getOwnPropertyNames","length","reentered","buffer","push","nextMsg","modified","Services","logger","info","componentName","debug","dispatchMiddleware","update","cmd","execCmd","ex","error","shift","mounted","forceUpdate","fakeOptions","getFakeOptionsOnce","dispatch","initCmd","forEach","call","React","Component"],"sources":["../src/ElmComponent.ts"],"sourcesContent":["import { InitFunction, Nullable, UpdateFunction } from \"./Types\";\nimport { Message, Services } from \"./Init\";\nimport { Cmd } from \"./Cmd\";\nimport { getFakeOptionsOnce } from \"./Testing/fakeOptions\";\nimport React from \"react\";\n\n/**\n * Abstract class for a react class component using the elmish pattern.\n * @export\n * @abstract\n * @class ElmComponent\n * @extends {Component<TProps, TModel>}\n * @template TModel The type of the model.\n * @template TMsg The type of the messages.\n * @template TProps The type of the props.\n */\nabstract class ElmComponent<TModel, TMsg extends Message, TProps> extends React.Component<TProps> {\n    private initCmd: Nullable<Cmd<TMsg>> | undefined;\n    private readonly componentName: string;\n    private readonly buffer: TMsg [] = [];\n    private reentered = false;\n    private mounted = false;\n    private currentModel: TModel;\n\n    /**\n     * Creates an instance of ElmComponent.\n     * @param {TProps} props The props for the component.\n     * @param {() => TModel} init The initializer function.\n     * @param name The name of the component.\n     * @memberof ElmComponent\n     */\n    public constructor (props: TProps, init: InitFunction<TProps, TModel, TMsg>, name: string) {\n        super(props);\n\n        const fakeOptions = getFakeOptionsOnce();\n\n        if (fakeOptions?.dispatch) {\n            this.dispatch = fakeOptions.dispatch;\n        }\n\n        const [model, cmd] = fakeOptions?.model ? [fakeOptions.model as TModel] : init(this.props);\n\n        this.componentName = name;\n        this.currentModel = model;\n        this.initCmd = cmd;\n    }\n\n    /**\n     * Is called when the component is loaded.\n     * When implementing this method, the base implementation has to be called.\n     * @memberof ElmComponent\n     */\n    public componentDidMount (): void {\n        this.mounted = true;\n\n        if (this.initCmd) {\n            this.execCmd(this.initCmd);\n            this.initCmd = null;\n        }\n    }\n\n    /**\n     * Is called before unloading the component.\n     * When implementing this method, the base implementation has to be called.\n     * @memberof ElmComponent\n     */\n    public componentWillUnmount (): void {\n        this.mounted = false;\n    }\n\n    private execCmd (cmd: Cmd<TMsg>): void {\n        cmd.forEach(call => {\n            try {\n                call(this.dispatch);\n            } catch (ex: unknown) {\n                Services.logger?.error(ex);\n            }\n        });\n    }\n\n    /**\n     * Returns the current model.\n     * @readonly\n     * @type {Readonly<TModel>}\n     * @memberof ElmComponent\n     */\n    public get model (): Readonly<TModel> {\n        return this.currentModel;\n    }\n\n    /**\n     * Dispatches a message.\n     * @param {TMsg} msg The message to dispatch.\n     * @memberof ElmComponent\n     */\n    public readonly dispatch = (msg: TMsg): void => {\n        const modelHasChanged = (model: Partial<TModel>): boolean => model !== this.currentModel && Object.getOwnPropertyNames(model).length > 0;\n\n        if (this.reentered) {\n            this.buffer.push(msg);\n        } else {\n            this.reentered = true;\n\n            let nextMsg: TMsg | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                Services.logger?.info(\"Elm\", \"message from\", this.componentName, nextMsg.name);\n                Services.logger?.debug(\"Elm\", \"message from\", this.componentName, nextMsg);\n\n                if (Services.dispatchMiddleware) {\n                    Services.dispatchMiddleware(nextMsg);\n                }\n\n                try {\n                    const [model, cmd] = this.update(this.currentModel, nextMsg, this.props);\n\n                    if (modelHasChanged(model)) {\n                        this.currentModel = { ...this.currentModel, ...model };\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        this.execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    Services.logger?.error(ex);\n                }\n\n                nextMsg = this.buffer.shift();\n            }\n            this.reentered = false;\n\n            if (this.mounted && modified) {\n                Services.logger?.debug(\"Elm\", \"update model for\", this.componentName, this.currentModel);\n                this.forceUpdate();\n            }\n        }\n    };\n\n    /**\n     * Function to modify the model based on a message.\n     * @param {TModel} model The current model.\n     * @param {TMsg} msg The message to process.\n     * @param {TProps} props The props of the component.\n     * @returns The new model (can also be an empty object {}) and an optional new message to dispatch.\n     * @abstract\n     * @memberof ElmComponent\n     */\n    public abstract update: UpdateFunction<TProps, TModel, TMsg>;\n}\n\nexport {\n    ElmComponent,\n};"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ElmComponent","props","init","name","msg","reentered","buffer","push","nextMsg","modified","logMessage","componentName","update","currentModel","model","cmd","modelHasChanged","execCmd","dispatch","ex","Services","logger","error","shift","mounted","debug","forceUpdate","fakeOptions","getFakeOptionsOnce","initCmd","React","Component"],"sources":["../src/ElmComponent.ts"],"sourcesContent":["import React from \"react\";\nimport { Cmd } from \"./Cmd\";\nimport { execCmd, logMessage, modelHasChanged } from \"./Common\";\nimport { Message, Services } from \"./Init\";\nimport { getFakeOptionsOnce } from \"./Testing/fakeOptions\";\nimport { InitFunction, Nullable, UpdateFunction } from \"./Types\";\n\n/**\n * Abstract class for a react class component using the Elmish pattern.\n * @export\n * @abstract\n * @class ElmComponent\n * @extends {Component<TProps, TModel>}\n * @template TModel The type of the model.\n * @template TMessage The type of the messages.\n * @template TProps The type of the props.\n */\nabstract class ElmComponent<TModel, TMessage extends Message, TProps> extends React.Component<TProps> {\n    private initCmd: Nullable<Cmd<TMessage>> | undefined;\n    private readonly componentName: string;\n    private readonly buffer: TMessage [] = [];\n    private reentered = false;\n    private mounted = false;\n    private currentModel: TModel;\n\n    /**\n     * Creates an instance of ElmComponent.\n     * @param {TProps} props The props for the component.\n     * @param {() => TModel} init The initializer function.\n     * @param name The name of the component.\n     * @memberof ElmComponent\n     */\n    public constructor (props: TProps, init: InitFunction<TProps, TModel, TMessage>, name: string) {\n        super(props);\n\n        const fakeOptions = getFakeOptionsOnce();\n\n        if (fakeOptions?.dispatch) {\n            this.dispatch = fakeOptions.dispatch;\n        }\n\n        const [model, cmd] = fakeOptions?.model ? [fakeOptions.model as TModel] : init(this.props);\n\n        this.componentName = name;\n        this.currentModel = model;\n        this.initCmd = cmd;\n    }\n\n    /**\n     * Is called when the component is loaded.\n     * When implementing this method, the base implementation has to be called.\n     * @memberof ElmComponent\n     */\n    public componentDidMount (): void {\n        this.mounted = true;\n\n        if (this.initCmd) {\n            execCmd(this.initCmd, this.dispatch);\n            this.initCmd = null;\n        }\n    }\n\n    /**\n     * Is called before unloading the component.\n     * When implementing this method, the base implementation has to be called.\n     * @memberof ElmComponent\n     */\n    public componentWillUnmount (): void {\n        this.mounted = false;\n    }\n\n    /**\n     * Returns the current model.\n     * @readonly\n     * @type {Readonly<TModel>}\n     * @memberof ElmComponent\n     */\n    public get model (): Readonly<TModel> {\n        return this.currentModel;\n    }\n\n    /**\n     * Dispatches a message.\n     * @param {TMessage} msg The message to dispatch.\n     * @memberof ElmComponent\n     */\n    public readonly dispatch = (msg: TMessage): void => {\n        if (this.reentered) {\n            this.buffer.push(msg);\n        } else {\n            this.reentered = true;\n\n            let nextMsg: TMessage | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                logMessage(this.componentName, nextMsg);\n\n                try {\n                    const [model, cmd] = this.update(this.currentModel, nextMsg, this.props);\n\n                    if (modelHasChanged(this.currentModel, model)) {\n                        this.currentModel = { ...this.currentModel, ...model };\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd, this.dispatch);\n                    }\n                } catch (ex: unknown) {\n                    Services.logger?.error(ex);\n                }\n\n                nextMsg = this.buffer.shift();\n            }\n            this.reentered = false;\n\n            if (this.mounted && modified) {\n                Services.logger?.debug(\"Elm\", \"update model for\", this.componentName, this.currentModel);\n                this.forceUpdate();\n            }\n        }\n    };\n\n    /**\n     * Function to modify the model based on a message.\n     * @param {TModel} model The current model.\n     * @param {TMessage} msg The message to process.\n     * @param {TProps} props The props of the component.\n     * @returns The new model (can also be an empty object {}) and an optional new message to dispatch.\n     * @abstract\n     * @memberof ElmComponent\n     */\n    public abstract update: UpdateFunction<TProps, TModel, TMessage>;\n}\n\nexport {\n    ElmComponent,\n};"],"mappings":"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"}