react-elmish 3.0.0 → 3.1.0

package/README.md

@@ -25,7 +25,7 @@ An elmish component basically consists of the following parts:
 First import everything from `react-elmish` and declare the **Message** discriminated union type:
 
 ```ts
-import { Cmd, createCmd, UpdateReturnType, UpdateMap } from "react-elmish";
+import { Cmd, createCmd, InitResult, UpdateReturnType, UpdateMap } from "react-elmish";
 
 export type Message =
     | { name: "increment" }
@@ -57,21 +57,14 @@ export interface Props {
 }
 ```
 
-Now we create a `cmd` object for our messages type:
-
-```ts
-const cmd = createCmd<Message>();
-```
-
 To create the initial model we need an **init** function:
 
 ```ts
-export function init (props: Props): [Model, Cmd<Message>] {
+export function init (props: Props): InitResult {
     return [
         {
             value: props.initialValue,
-        },
-        cmd.none
+        }
     ];
 };
 ```
@@ -251,75 +244,19 @@ You can also use **Symbols** for the message type instead of strings:
     ...
     ```
 
-## Setup
+## Dispatch commands in the update map or update function
 
-**react-elmish** works without a setup. But if you want to use logging or some middleware, you can setup **react-elmish** at the start of your program.
+In addition to modifying the model, you can dispatch new commands here.
 
-```ts
-import * as Elm from "react-elmish";
+To do so, you have to create a `cmd` object:
 
-const myLogger = {
-    debug(...args: unknown []) {
-        console.debug(...args);
-    },
-    info(...args: unknown []) {
-        console.info(...args);
-    },
-    error(...args: unknown []) {
-        console.error(...args);
-    },
-}
+```ts
+import { createCmd } from "react-elmish";
 
-Elm.init({
-    logger: myLogger,
-    errorMiddleware: error => Toast.error(error.message),
-    dispatchMiddleware: msg => console.log(msg),
-});
+const cmd = createCmd<Message>();
 ```
 
-The error middleware function is called by the `handleError` function (see [Error handling](#error-handling)).
-
-The dispatch middleware function is called whenever a Message is dispatched.
-
-## Error handling
-
-You can handle errors easily with the following pattern.
-
-1. Add an error message:
-
-    ```ts
-    import { ErrorMessage, errorMsg, handleError } from "react-elmish";
-
-    export type Message =
-        | ...
-        | ErrorMessage;
-    ```
-
-1. Optionally add the convenient function to the **Msg** object:
-
-    ```ts
-    export const Msg = {
-        ...
-        ...errorMsg,
-    }
-    ```
-
-1. Handle the error message in the **update** function:
-
-    ```ts
-    ...
-    case "error":
-        return handleError(msg.error);
-    ...
-    ```
-
-The **handleError** function then calls your error handling middleware.
-
-## Dispatch commands in the update map or update function
-
-In addition to modifying the model, you can dispatch new commands here.
-
-To do so, you can call one of the functions in the `cmd` object:
+Then you can call one of the functions of that object:
 
 | Function | Description |
 |---|---|
@@ -332,6 +269,7 @@ To do so, you can call one of the functions in the `cmd` object:
 | `cmd.ofPromise.either` | Calls an async function and maps the result into a message. |
 | `cmd.ofPromise.attempt` | Like `either` but ignores the success case. |
 | `cmd.ofPromise.perform` | Like `either` but ignores the error case. |
+| `cmd.ofSub` | Use this function to trigger a command in a subscription. |
 
 ### Dispatch a message
 
@@ -348,6 +286,8 @@ export const Msg = {
     printLastMessage: (message: string): Message => ({ name: "printLastMessage", message }),
     ...
 }
+
+const cmd = createCmd<Message>();
 ```
 
 In the **update** function you can dispatch that message like this:
@@ -408,6 +348,170 @@ case "error":
 ...
 ```
 
+### Dispatch a command from `init`
+
+The same way as in the `update` map or function, you can also dispatch an initial command in the `init` function:
+
+```ts
+export function init (props: Props): InitResult {
+    return [
+        {
+            value: props.initialValue,
+        },
+        cmd.ofMsg(Msg.loadData())
+    ];
+};
+```
+
+## Subscriptions
+
+### Working with external sources of events
+
+If you want to use external sources of events (e.g. a timer), you can use a `subscription`. With this those events can be processed by our `update` handler.
+
+Let's define a `Model` and a `Message`:
+
+```ts
+type Message =
+    | { name: "timer", date: Date };
+
+interface Model {
+    date: Date,
+}
+
+const Msg = {
+    timer: (date: Date): Message => ({ name: "timer", date }),
+};
+```
+
+Now we define the `init` function and the `update` object:
+
+```ts
+const cmd = createCmd<Message>();
+
+function init (props: Props): InitResult<Model, Message> {
+    return [{
+        date: new Date(),
+    }];
+}
+
+const update: UpdateMap<Props, Model, Message> = {
+    timer ({ date }) {
+        return [{ date }];
+    },
+};
+```
+
+Then we write our `subscription` function:
+
+```ts
+function subscription (model: Model): SubscriptionResult<Message> {
+    const sub = (dispatch: Dispatch<Message>): void => {
+        setInterval(() => dispatch(Msg.timer(new Date())), 1000) as unknown as number;
+    }
+
+    return [cmd.ofSub(sub)];
+}
+```
+
+This function gets the initialized model as parameter and returns a command.
+
+In the function component we call `useElmish` and pass the subscription to it:
+
+```ts
+const [{ date }] = useElmish({ name: "Subscriptions", props, init, update, subscription })
+```
+
+You can define and aggregate multiple subscriptions with a call to `cmd.batch(...)`.
+
+### Cleanup subscriptions
+
+In the solution above `setInterval` will trigger events even if the component is removed from the DOM. To cleanup subscriptions, we can return a `destructor` function from the subscription the same as in the `useEffect` hook.
+
+Let's rewrite our `subscription` function:
+
+```ts
+function subscription (model: Model): SubscriptionResult<Message> {
+    let timer: NodeJS.Timer;
+
+    const sub = (dispatch: Dispatch<Message>): void => {
+        timer = setInterval(() => dispatch(Msg.timer(new Date())), 1000);
+    }
+
+    const destructor = () => {
+        clearInterval(timer1);
+    }
+
+    return [cmd.ofSub(sub), destructor];
+}
+```
+
+Here we save the return value of `setInterval` and clear that interval in the returned `destructor` function.
+
+## Setup
+
+**react-elmish** works without a setup. But if you want to use logging or some middleware, you can setup **react-elmish** at the start of your program.
+
+```ts
+import { init } from "react-elmish";
+
+const myLogger = {
+    debug(...args: unknown []) {
+        console.debug(...args);
+    },
+    info(...args: unknown []) {
+        console.info(...args);
+    },
+    error(...args: unknown []) {
+        console.error(...args);
+    },
+}
+
+init({
+    logger: myLogger,
+    errorMiddleware: error => Toast.error(error.message),
+    dispatchMiddleware: msg => myLogger.debug(msg),
+});
+```
+
+The error middleware function is called by the `handleError` function (see [Error handling](#error-handling)).
+
+The dispatch middleware function is called whenever a Message is dispatched.
+
+## Error handling
+
+You can handle errors easily with the following pattern.
+
+1. Add an error message:
+
+    ```ts
+    import { ErrorMessage, errorMsg, handleError } from "react-elmish";
+
+    export type Message =
+        | ...
+        | ErrorMessage;
+    ```
+
+1. Optionally add the convenient function to the **Msg** object:
+
+    ```ts
+    export const Msg = {
+        ...
+        ...errorMsg,
+    }
+    ```
+
+1. Handle the error message in the **update** function:
+
+    ```ts
+    ...
+    case "error":
+        return handleError(msg.error);
+    ...
+    ```
+
+The **handleError** function then calls your error handling middleware.
+
 ## React life cycle management
 
 If you want to use `componentDidMount` or `componentWillUnmount` in a class component, don't forget to call the base class implementation of it as the **ElmComponent** is using them internally.

package/dist/Cmd.d.ts

@@ -28,6 +28,11 @@ declare class Command<TMsg> {
      * @param {Cmd<TMsg> []} commands Array of commands.
      */
     batch(...commands: Cmd<TMsg>[]): Cmd<TMsg>;
+    /**
+     * Command to call the subscriber.
+     * @param {Sub<TMsg>} sub The subscriber function.
+     */
+    ofSub(sub: Sub<TMsg>): Cmd<TMsg>;
     /**
      * Provides functionalities to create commands from simple functions.
      */

package/dist/Cmd.js

@@ -213,6 +213,17 @@ var Command = /*#__PURE__*/function () {
 
       return commands.flat();
     }
+    /**
+     * Command to call the subscriber.
+     * @param {Sub<TMsg>} sub The subscriber function.
+     */
+    // eslint-disable-next-line class-methods-use-this
+
+  }, {
+    key: "ofSub",
+    value: function ofSub(sub) {
+      return [sub];
+    }
     /**
      * Provides functionalities to create commands from simple functions.
      */
@@ -231,4 +242,4 @@ var Command = /*#__PURE__*/function () {
 function createCmd() {
   return new Command();
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Cmd.ts"],"names":["Command","either","task","ofSuccess","ofError","args","bind","dispatch","result","ex","perform","fallback","attempt","then","defaultFallbackHandler","msg","commands","flat","createCmd"],"mappings":"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","sourcesContent":["/**\n * Type of the dispatch function.\n */\nexport type 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 */\nexport type Cmd<TMsg> = Sub<TMsg> [];\n\n/**\n * Class to create commands.\n * @class Command\n * @template TMsg Type of the Msg discriminated union.\n */\nclass Command<TMsg> {\n    /**\n     * Represents an empty command.\n     */\n    public none = [];\n\n    /**\n     * Creates a command out of a specific message.\n     * @param {TMsg} msg The specific message.\n     */\n    // eslint-disable-next-line class-methods-use-this\n    public ofMsg (msg: TMsg): Cmd<TMsg> {\n        return [dispatch => dispatch(msg)];\n    }\n\n    /**\n     * Aggregates multiple commands.\n     * @param {Cmd<TMsg> []} commands Array of commands.\n     */\n    // eslint-disable-next-line class-methods-use-this\n    public batch (...commands: Cmd<TMsg> []): Cmd<TMsg> {\n        return commands.flat();\n    }\n\n    /**\n     * Provides functionalities to create commands from simple functions.\n     */\n    public 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            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\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            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\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            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\n    /**\n     * Provides functionalities to create commands from async functions.\n     */\n    public 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            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\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            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\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            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/**\n * Creates a typed instance of the Command class.\n * @template TMsg The type of the Msg discriminated union.\n * @see Command\n */\nexport function createCmd<TMsg> (): Command<TMsg> {\n    return new Command<TMsg>();\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/Cmd.ts"],"names":["Command","either","task","ofSuccess","ofError","args","bind","dispatch","result","ex","perform","fallback","attempt","then","defaultFallbackHandler","msg","commands","flat","sub","createCmd"],"mappings":"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","sourcesContent":["/**\n * Type of the dispatch function.\n */\nexport type 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 */\nexport type Cmd<TMsg> = Sub<TMsg> [];\n\n/**\n * Class to create commands.\n * @class Command\n * @template TMsg Type of the Msg discriminated union.\n */\nclass Command<TMsg> {\n    /**\n     * Represents an empty command.\n     */\n    public none = [];\n\n    /**\n     * Creates a command out of a specific message.\n     * @param {TMsg} msg The specific message.\n     */\n    // eslint-disable-next-line class-methods-use-this\n    public ofMsg (msg: TMsg): Cmd<TMsg> {\n        return [dispatch => dispatch(msg)];\n    }\n\n    /**\n     * Aggregates multiple commands.\n     * @param {Cmd<TMsg> []} commands Array of commands.\n     */\n    // eslint-disable-next-line class-methods-use-this\n    public batch (...commands: Cmd<TMsg> []): Cmd<TMsg> {\n        return commands.flat();\n    }\n\n    /**\n     * Command to call the subscriber.\n     * @param {Sub<TMsg>} sub The subscriber function.\n     */\n    // eslint-disable-next-line class-methods-use-this\n    public ofSub (sub: Sub<TMsg>): Cmd<TMsg> {\n        return [sub];\n    }\n\n    /**\n     * Provides functionalities to create commands from simple functions.\n     */\n    public 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            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\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            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\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            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\n    /**\n     * Provides functionalities to create commands from async functions.\n     */\n    public 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            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\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            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\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            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/**\n * Creates a typed instance of the Command class.\n * @template TMsg The type of the Msg discriminated union.\n * @see Command\n */\nexport function createCmd<TMsg> (): Command<TMsg> {\n    return new Command<TMsg>();\n}"]}

package/dist/ElmComponent.d.ts

@@ -25,7 +25,7 @@ export declare abstract class ElmComponent<TModel, TMsg extends Message, TProps>
      * @param name The name of the component.
      * @memberof ElmComponent
      */
-    constructor(props: TProps, init: (arg: TProps) => [TModel, Cmd<TMsg> | undefined], name: string);
+    constructor(props: TProps, init: InitFunction<TProps, TModel, TMsg>, name: string);
     /**
      * Is called when the component is loaded.
      * When implementing this method, the base implementation has to be called.
@@ -63,8 +63,10 @@ export declare abstract class ElmComponent<TModel, TMsg extends Message, TProps>
      */
     abstract update: UpdateFunction<TProps, TModel, TMsg>;
 }
-export declare type UpdateFunction<TProps, TModel, TMsg> = (model: TModel, msg: TMsg, props: TProps) => UpdateReturnType<TModel, TMsg>;
+export declare type InitResult<TModel, TMessage> = [TModel, Cmd<TMessage>?];
+export declare type InitFunction<TProps, TModel, TMessage> = (props: TProps) => InitResult<TModel, TMessage>;
 /**
  * Type for the return value of the update function.
  */
 export declare type UpdateReturnType<TModel, TMsg> = [Partial<TModel>, Cmd<TMsg>?];
+export declare type UpdateFunction<TProps, TModel, TMsg> = (model: TModel, msg: TMsg, props: TProps) => UpdateReturnType<TModel, TMsg>;

package/dist/ElmComponent.js

@@ -222,4 +222,4 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
 }(_react["default"].Component);
 
 exports.ElmComponent = ElmComponent;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ElmComponent.ts"],"names":["ElmComponent","props","init","name","msg","modelHasChanged","model","currentModel","Object","getOwnPropertyNames","length","dispatchMiddleware","reentered","buffer","push","nextMsg","modified","LoggerService","info","componentName","debug","update","cmd","execCmd","ex","error","shift","mounted","forceUpdate","initCmd","forEach","call","dispatch","React","Component"],"mappings":"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","sourcesContent":["import { dispatchMiddleware, LoggerService, Message } from \"./Init\";\nimport { Cmd } from \"./Cmd\";\nimport { Nullable } from \"./ElmUtilities\";\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 */\nexport abstract 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: (arg: TProps) => [TModel, Cmd<TMsg> | undefined], name: string) {\n        super(props);\n\n        const [model, cmd] = 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                LoggerService?.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 (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\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                LoggerService?.info(\"Elm\", \"message from\", this.componentName, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", this.componentName, nextMsg);\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                    LoggerService?.error(ex);\n                }\n\n                nextMsg = this.buffer.shift();\n            }\n            this.reentered = false;\n\n            if (this.mounted && modified) {\n                LoggerService?.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 type UpdateFunction<TProps, TModel, TMsg> = (model: TModel, msg: TMsg, props: TProps) => UpdateReturnType<TModel, TMsg>;\n\n/**\n * Type for the return value of the update function.\n */\nexport type UpdateReturnType<TModel, TMsg> = [Partial<TModel>, Cmd<TMsg>?];"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ElmComponent.ts"],"names":["ElmComponent","props","init","name","msg","modelHasChanged","model","currentModel","Object","getOwnPropertyNames","length","dispatchMiddleware","reentered","buffer","push","nextMsg","modified","LoggerService","info","componentName","debug","update","cmd","execCmd","ex","error","shift","mounted","forceUpdate","initCmd","forEach","call","dispatch","React","Component"],"mappings":"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","sourcesContent":["import { dispatchMiddleware, LoggerService, Message } from \"./Init\";\nimport { Cmd } from \"./Cmd\";\nimport { Nullable } from \"./ElmUtilities\";\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 */\nexport abstract 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 [model, cmd] = 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                LoggerService?.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 (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\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                LoggerService?.info(\"Elm\", \"message from\", this.componentName, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", this.componentName, nextMsg);\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                    LoggerService?.error(ex);\n                }\n\n                nextMsg = this.buffer.shift();\n            }\n            this.reentered = false;\n\n            if (this.mounted && modified) {\n                LoggerService?.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 type InitResult<TModel, TMessage> = [TModel, Cmd<TMessage>?];\n\nexport type InitFunction<TProps, TModel, TMessage> = (props: TProps) => InitResult<TModel, TMessage>;\n\n/**\n * Type for the return value of the update function.\n */\nexport type UpdateReturnType<TModel, TMsg> = [Partial<TModel>, Cmd<TMsg>?];\n\nexport type UpdateFunction<TProps, TModel, TMsg> = (model: TModel, msg: TMsg, props: TProps) => UpdateReturnType<TModel, TMsg>;"]}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Cmd, createCmd, Dispatch } from "./Cmd";
-import { ElmComponent, UpdateReturnType } from "./ElmComponent";
-import { ErrorMessage, handleError, MsgSource, UpdateMap } from "./ElmUtilities";
+import { ElmComponent, InitResult, UpdateReturnType } from "./ElmComponent";
+import { ErrorMessage, errorMsg, handleError, MsgSource, UpdateMap } from "./ElmUtilities";
 import { init, Logger, Message } from "./Init";
-import { useElmish } from "./useElmish";
-export type { Logger, Message, Cmd, Dispatch, UpdateReturnType, MsgSource, UpdateMap, ErrorMessage, };
-export { init, createCmd, ElmComponent, handleError, useElmish, };
+import { SubscriptionResult, useElmish } from "./useElmish";
+export type { Logger, Message, Cmd, Dispatch, InitResult, UpdateReturnType, SubscriptionResult, MsgSource, UpdateMap, ErrorMessage, };
+export { init, createCmd, ElmComponent, errorMsg, handleError, useElmish, };

package/dist/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "createCmd", {
     return _Cmd.createCmd;
   }
 });
+Object.defineProperty(exports, "errorMsg", {
+  enumerable: true,
+  get: function get() {
+    return _ElmUtilities.errorMsg;
+  }
+});
 Object.defineProperty(exports, "handleError", {
   enumerable: true,
   get: function get() {
@@ -43,4 +49,4 @@ var _ElmUtilities = require("./ElmUtilities");
 var _Init = require("./Init");
 
 var _useElmish = require("./useElmish");
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENtZCwgY3JlYXRlQ21kLCBEaXNwYXRjaCB9IGZyb20gXCIuL0NtZFwiO1xuaW1wb3J0IHsgRWxtQ29tcG9uZW50LCBVcGRhdGVSZXR1cm5UeXBlIH0gZnJvbSBcIi4vRWxtQ29tcG9uZW50XCI7XG5pbXBvcnQgeyBFcnJvck1lc3NhZ2UsIGhhbmRsZUVycm9yLCBNc2dTb3VyY2UsIFVwZGF0ZU1hcCB9IGZyb20gXCIuL0VsbVV0aWxpdGllc1wiO1xuaW1wb3J0IHsgaW5pdCwgTG9nZ2VyLCBNZXNzYWdlIH0gZnJvbSBcIi4vSW5pdFwiO1xuaW1wb3J0IHsgdXNlRWxtaXNoIH0gZnJvbSBcIi4vdXNlRWxtaXNoXCI7XG5cbmV4cG9ydCB0eXBlIHtcbiAgICBMb2dnZXIsXG4gICAgTWVzc2FnZSxcbiAgICBDbWQsXG4gICAgRGlzcGF0Y2gsXG4gICAgVXBkYXRlUmV0dXJuVHlwZSxcbiAgICBNc2dTb3VyY2UsXG4gICAgVXBkYXRlTWFwLFxuICAgIEVycm9yTWVzc2FnZSxcbn07XG5cbmV4cG9ydCB7XG4gICAgaW5pdCxcbiAgICBjcmVhdGVDbWQsXG4gICAgRWxtQ29tcG9uZW50LFxuICAgIGhhbmRsZUVycm9yLFxuICAgIHVzZUVsbWlzaCxcbn07Il19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENtZCwgY3JlYXRlQ21kLCBEaXNwYXRjaCB9IGZyb20gXCIuL0NtZFwiO1xuaW1wb3J0IHsgRWxtQ29tcG9uZW50LCBJbml0UmVzdWx0LCBVcGRhdGVSZXR1cm5UeXBlIH0gZnJvbSBcIi4vRWxtQ29tcG9uZW50XCI7XG5pbXBvcnQgeyBFcnJvck1lc3NhZ2UsIGVycm9yTXNnLCBoYW5kbGVFcnJvciwgTXNnU291cmNlLCBVcGRhdGVNYXAgfSBmcm9tIFwiLi9FbG1VdGlsaXRpZXNcIjtcbmltcG9ydCB7IGluaXQsIExvZ2dlciwgTWVzc2FnZSB9IGZyb20gXCIuL0luaXRcIjtcbmltcG9ydCB7IFN1YnNjcmlwdGlvblJlc3VsdCwgdXNlRWxtaXNoIH0gZnJvbSBcIi4vdXNlRWxtaXNoXCI7XG5cbmV4cG9ydCB0eXBlIHtcbiAgICBMb2dnZXIsXG4gICAgTWVzc2FnZSxcbiAgICBDbWQsXG4gICAgRGlzcGF0Y2gsXG4gICAgSW5pdFJlc3VsdCxcbiAgICBVcGRhdGVSZXR1cm5UeXBlLFxuICAgIFN1YnNjcmlwdGlvblJlc3VsdCxcbiAgICBNc2dTb3VyY2UsXG4gICAgVXBkYXRlTWFwLFxuICAgIEVycm9yTWVzc2FnZSxcbn07XG5cbmV4cG9ydCB7XG4gICAgaW5pdCxcbiAgICBjcmVhdGVDbWQsXG4gICAgRWxtQ29tcG9uZW50LFxuICAgIGVycm9yTXNnLFxuICAgIGhhbmRsZUVycm9yLFxuICAgIHVzZUVsbWlzaCxcbn07Il19

package/dist/legacy/useElmish.d.ts

@@ -1,6 +1,6 @@
-import { Cmd, Dispatch } from "../Cmd";
+import { Dispatch } from "../Cmd";
+import { InitFunction, UpdateFunction } from "../ElmComponent";
 import { MessageBase } from "../ElmUtilities";
-import { UpdateFunction } from "../ElmComponent";
 /**
  * Hook to use the Elm architecture pattern in a function component.
  * @param props The props of the component.
@@ -12,4 +12,4 @@ import { UpdateFunction } from "../ElmComponent";
  * const [model, dispatch] = useElmish(props, init, update, "MyComponent");
  * @deprecated Use `useElmish` with an options object instead.
  */
-export declare function useElmish<TProps, TModel, TMsg extends MessageBase>(props: TProps, init: (props: TProps) => [TModel, Cmd<TMsg>], update: UpdateFunction<TProps, TModel, TMsg>, name: string): [TModel, Dispatch<TMsg>];
+export declare function useElmish<TProps, TModel, TMsg extends MessageBase>(props: TProps, init: InitFunction<TProps, TModel, TMsg>, update: UpdateFunction<TProps, TModel, TMsg>, name: string): [TModel, Dispatch<TMsg>];

package/dist/legacy/useElmish.js

@@ -124,9 +124,12 @@ function useElmish(props, init, update, name) {
 
     initializedModel = initModel;
     setModel(initializedModel);
-    execCmd(initCmd);
+
+    if (initCmd) {
+      execCmd(initCmd);
+    }
   }
 
   return [initializedModel, dispatch];
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/legacy/useElmish.ts"],"names":["useElmish","props","init","update","name","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","newModel","shift","prevModel","initModel","initCmd"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"../Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"../Init\";\nimport { MessageBase, Nullable } from \"../ElmUtilities\";\nimport { useCallback, useState } from \"react\";\nimport { UpdateFunction } from \"../ElmComponent\";\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param props The props of the component.\n * @param init Function to initialize the model.\n * @param update The update function.\n * @param name The name of the component.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmish(props, init, update, \"MyComponent\");\n * @deprecated Use `useElmish` with an options object instead.\n */\nexport function useElmish<TProps, TModel, TMsg extends MessageBase> (props: TProps, init: (props: TProps) => [TModel, Cmd<TMsg>], update: UpdateFunction<TProps, TModel, TMsg>, name: string): [TModel, Dispatch<TMsg>] {\n    let reentered = false;\n    const buffer: TMsg [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMsg>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMsg): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMsg | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = update({ ...initializedModel, ...currentModel }, nextMsg, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        execCmd(initCmd);\n    }\n\n    return [initializedModel, dispatch];\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/legacy/useElmish.ts"],"names":["useElmish","props","init","update","name","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","newModel","shift","prevModel","initModel","initCmd"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"../Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"../Init\";\nimport { InitFunction, UpdateFunction } from \"../ElmComponent\";\nimport { MessageBase, Nullable } from \"../ElmUtilities\";\nimport { useCallback, useState } from \"react\";\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param props The props of the component.\n * @param init Function to initialize the model.\n * @param update The update function.\n * @param name The name of the component.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmish(props, init, update, \"MyComponent\");\n * @deprecated Use `useElmish` with an options object instead.\n */\nexport function useElmish<TProps, TModel, TMsg extends MessageBase> (props: TProps, init: InitFunction<TProps, TModel, TMsg>, update: UpdateFunction<TProps, TModel, TMsg>, name: string): [TModel, Dispatch<TMsg>] {\n    let reentered = false;\n    const buffer: TMsg [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMsg>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMsg): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMsg | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = update({ ...initializedModel, ...currentModel }, nextMsg, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        if (initCmd) {\n            execCmd(initCmd);\n        }\n    }\n\n    return [initializedModel, dispatch];\n}"]}

package/dist/legacy/useElmishMap.d.ts

@@ -1,5 +1,6 @@
-import { Cmd, Dispatch } from "../Cmd";
+import { Dispatch } from "../Cmd";
 import { MessageBase, UpdateMap } from "../ElmUtilities";
+import { InitFunction } from "../ElmComponent";
 /**
  * Hook to use the Elm architecture pattern in a function component.
  * @param props The props of the component.
@@ -11,4 +12,4 @@ import { MessageBase, UpdateMap } from "../ElmUtilities";
  * const [model, dispatch] = useElmishMap(props, init, updateMap, "MyComponent");
  * @deprecated Use `useElmish` with an options object instead.
  */
-export declare function useElmishMap<TProps, TModel, TMessage extends MessageBase>(props: TProps, init: (props: TProps) => [TModel, Cmd<TMessage>], updateMap: UpdateMap<TProps, TModel, TMessage>, name: string): [TModel, Dispatch<TMessage>];
+export declare function useElmishMap<TProps, TModel, TMessage extends MessageBase>(props: TProps, init: InitFunction<TProps, TModel, TMessage>, updateMap: UpdateMap<TProps, TModel, TMessage>, name: string): [TModel, Dispatch<TMessage>];

package/dist/legacy/useElmishMap.js

@@ -126,9 +126,12 @@ function useElmishMap(props, init, updateMap, name) {
 
     initializedModel = initModel;
     setModel(initializedModel);
-    execCmd(initCmd);
+
+    if (initCmd) {
+      execCmd(initCmd);
+    }
   }
 
   return [initializedModel, dispatch];
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/legacy/useElmishMap.ts"],"names":["useElmishMap","props","init","updateMap","name","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","newModel","shift","prevModel","initModel","initCmd"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"../Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"../Init\";\nimport { MessageBase, Nullable, UpdateMap } from \"../ElmUtilities\";\nimport { useCallback, useState } from \"react\";\nimport { callUpdateMap } from \"../useElmish\";\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param props The props of the component.\n * @param init Function to initialize the model.\n * @param updateMap The update map object.\n * @param name The name of the component.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmishMap(props, init, updateMap, \"MyComponent\");\n * @deprecated Use `useElmish` with an options object instead.\n */\nexport function useElmishMap<TProps, TModel, TMessage extends MessageBase> (props: TProps, init: (props: TProps) => [TModel, Cmd<TMessage>], updateMap: UpdateMap<TProps, TModel, TMessage>, name: string): [TModel, Dispatch<TMessage>] {\n    let reentered = false;\n    const buffer: TMessage [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMessage>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMessage): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMessage | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = callUpdateMap(updateMap, nextMsg, { ...initializedModel, ...currentModel }, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        execCmd(initCmd);\n    }\n\n    return [initializedModel, dispatch];\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/legacy/useElmishMap.ts"],"names":["useElmishMap","props","init","updateMap","name","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","newModel","shift","prevModel","initModel","initCmd"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"../Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"../Init\";\nimport { MessageBase, Nullable, UpdateMap } from \"../ElmUtilities\";\nimport { useCallback, useState } from \"react\";\nimport { callUpdateMap } from \"../useElmish\";\nimport { InitFunction } from \"../ElmComponent\";\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param props The props of the component.\n * @param init Function to initialize the model.\n * @param updateMap The update map object.\n * @param name The name of the component.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmishMap(props, init, updateMap, \"MyComponent\");\n * @deprecated Use `useElmish` with an options object instead.\n */\nexport function useElmishMap<TProps, TModel, TMessage extends MessageBase> (props: TProps, init: InitFunction<TProps, TModel, TMessage>, updateMap: UpdateMap<TProps, TModel, TMessage>, name: string): [TModel, Dispatch<TMessage>] {\n    let reentered = false;\n    const buffer: TMessage [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMessage>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMessage): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMessage | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = callUpdateMap(updateMap, nextMsg, { ...initializedModel, ...currentModel }, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        if (initCmd) {\n            execCmd(initCmd);\n        }\n    }\n\n    return [initializedModel, dispatch];\n}"]}

package/dist/useElmish.d.ts

@@ -1,11 +1,14 @@
 import { Cmd, Dispatch } from "./Cmd";
+import { InitFunction, UpdateFunction, UpdateReturnType } from "./ElmComponent";
 import { MessageBase, UpdateMap } from "./ElmUtilities";
-import { UpdateFunction, UpdateReturnType } from "./ElmComponent";
+export declare type SubscriptionResult<TMessage> = [Cmd<TMessage>, (() => void)?];
+declare type Subscription<TModel, TMessage> = (model: TModel) => SubscriptionResult<TMessage>;
 interface UseElmishOptions<TProps, TModel, TMessage extends MessageBase> {
+    name: string;
     props: TProps;
-    init: (props: TProps) => [TModel, Cmd<TMessage>];
+    init: InitFunction<TProps, TModel, TMessage>;
     update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>;
-    name: string;
+    subscription?: Subscription<TModel, TMessage>;
 }
 /**
  * Hook to use the Elm architecture pattern in a function component.
@@ -14,7 +17,7 @@ interface UseElmishOptions<TProps, TModel, TMessage extends MessageBase> {
  * @example
  * const [model, dispatch] = useElmish({ props, init, update, name: "MyComponent" });
  */
-export declare function useElmish<TProps, TModel, TMessage extends MessageBase>({ props, init, update, name }: UseElmishOptions<TProps, TModel, TMessage>): [TModel, Dispatch<TMessage>];
+export declare function useElmish<TProps, TModel, TMessage extends MessageBase>({ name, props, init, update, subscription }: UseElmishOptions<TProps, TModel, TMessage>): [TModel, Dispatch<TMessage>];
 export declare function callUpdate<TProps, TModel, TMessage extends MessageBase>(update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage>;
 export declare function callUpdateMap<TProps, TModel, TMessage extends MessageBase>(updateMap: UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage>;
 export {};

package/dist/useElmish.js

@@ -37,10 +37,11 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
  * const [model, dispatch] = useElmish({ props, init, update, name: "MyComponent" });
  */
 function useElmish(_ref) {
-  var props = _ref.props,
+  var name = _ref.name,
+      props = _ref.props,
       init = _ref.init,
       update = _ref.update,
-      name = _ref.name;
+      subscription = _ref.subscription;
   var reentered = false;
   var buffer = [];
   var currentModel = {};
@@ -126,9 +127,26 @@ function useElmish(_ref) {
 
     initializedModel = initModel;
     setModel(initializedModel);
-    execCmd(initCmd);
+
+    if (initCmd) {
+      execCmd(initCmd);
+    }
   }
 
+  (0, _react.useEffect)(function () {
+    if (subscription) {
+      var _subscription = subscription(initializedModel),
+          _subscription2 = _slicedToArray(_subscription, 2),
+          subCmd = _subscription2[0],
+          destructor = _subscription2[1];
+
+      execCmd(subCmd);
+
+      if (destructor) {
+        return destructor;
+      }
+    }
+  }, []);
   return [initializedModel, dispatch];
 }
 
@@ -145,4 +163,4 @@ function callUpdateMap(updateMap, msg, model, props) {
   // @ts-expect-error -- We know that nextMsg fits
   return updateMap[msg.name](msg, model, props);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/useElmish.ts"],"names":["useElmish","props","init","update","name","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","callUpdate","newModel","shift","prevModel","initModel","initCmd","callUpdateMap","updateMap"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"./Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"./Init\";\nimport { MessageBase, Nullable, UpdateMap } from \"./ElmUtilities\";\nimport { UpdateFunction, UpdateReturnType } from \"./ElmComponent\";\nimport { useCallback, useState } from \"react\";\n\ninterface UseElmishOptions<TProps, TModel, TMessage extends MessageBase> {\n    props: TProps,\n    init: (props: TProps) => [TModel, Cmd<TMessage>],\n    update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>,\n    name: string,\n}\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param {UseElmishOptions} options The options passed the the hook.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmish({ props, init, update, name: \"MyComponent\" });\n */\nexport function useElmish<TProps, TModel, TMessage extends MessageBase> ({ props, init, update, name }: UseElmishOptions<TProps, TModel, TMessage>): [TModel, Dispatch<TMessage>] {\n    let reentered = false;\n    const buffer: TMessage [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMessage>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMessage): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMessage | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = callUpdate(update, nextMsg, { ...initializedModel, ...currentModel }, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        execCmd(initCmd);\n    }\n\n    return [initializedModel, dispatch];\n}\n\nexport function callUpdate<TProps, TModel, TMessage extends MessageBase> (update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage> {\n    if (typeof update === \"function\") {\n        return update(model, msg, props);\n    }\n\n    return callUpdateMap(update, msg, model, props);\n}\n\nexport function callUpdateMap<TProps, TModel, TMessage extends MessageBase> (updateMap: UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage> {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-expect-error -- We know that nextMsg fits\n    return updateMap[msg.name as TMessage[\"name\"]](msg, model, props);\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/useElmish.ts"],"names":["useElmish","name","props","init","update","subscription","reentered","buffer","currentModel","model","setModel","initializedModel","execCmd","cmd","forEach","call","dispatch","ex","LoggerService","error","msg","modelHasChanged","updatedModel","Object","getOwnPropertyNames","length","dispatchMiddleware","push","nextMsg","modified","info","debug","callUpdate","newModel","shift","prevModel","initModel","initCmd","subCmd","destructor","callUpdateMap","updateMap"],"mappings":"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","sourcesContent":["import { Cmd, Dispatch } from \"./Cmd\";\nimport { dispatchMiddleware, LoggerService } from \"./Init\";\nimport { InitFunction, UpdateFunction, UpdateReturnType } from \"./ElmComponent\";\nimport { MessageBase, Nullable, UpdateMap } from \"./ElmUtilities\";\nimport { useCallback, useEffect, useState } from \"react\";\n\nexport type SubscriptionResult<TMessage> = [Cmd<TMessage>, (() => void)?];\ntype Subscription<TModel, TMessage> = (model: TModel) => SubscriptionResult<TMessage>;\n\ninterface UseElmishOptions<TProps, TModel, TMessage extends MessageBase> {\n    name: string,\n    props: TProps,\n    init: InitFunction<TProps, TModel, TMessage>,\n    update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>,\n    subscription?: Subscription<TModel, TMessage>,\n}\n\n/**\n * Hook to use the Elm architecture pattern in a function component.\n * @param {UseElmishOptions} options The options passed the the hook.\n * @returns A tuple containing the current model and the dispatcher.\n * @example\n * const [model, dispatch] = useElmish({ props, init, update, name: \"MyComponent\" });\n */\nexport function useElmish<TProps, TModel, TMessage extends MessageBase> ({ name, props, init, update, subscription }: UseElmishOptions<TProps, TModel, TMessage>): [TModel, Dispatch<TMessage>] {\n    let reentered = false;\n    const buffer: TMessage [] = [];\n    let currentModel: Partial<TModel> = {};\n\n    const [model, setModel] = useState<Nullable<TModel>>(null);\n    let initializedModel = model;\n\n    const execCmd = useCallback((cmd: Cmd<TMessage>): void => {\n        cmd.forEach(call => {\n            try {\n                call(dispatch);\n            } catch (ex: unknown) {\n                LoggerService?.error(ex);\n            }\n        });\n    }, []);\n\n    const dispatch = useCallback((msg: TMessage): void => {\n        if (!initializedModel) {\n            return;\n        }\n\n        const modelHasChanged = (updatedModel: Partial<TModel>): boolean => updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;\n\n        if (dispatchMiddleware) {\n            dispatchMiddleware(msg);\n        }\n\n        if (reentered) {\n            buffer.push(msg);\n        } else {\n            reentered = true;\n\n            let nextMsg: TMessage | undefined = msg;\n            let modified = false;\n\n            while (nextMsg) {\n                LoggerService?.info(\"Elm\", \"message from\", name, nextMsg.name);\n                LoggerService?.debug(\"Elm\", \"message from\", name, nextMsg);\n\n                try {\n                    const [newModel, cmd] = callUpdate(update, nextMsg, { ...initializedModel, ...currentModel }, props);\n\n                    if (modelHasChanged(newModel)) {\n                        currentModel = { ...currentModel, ...newModel };\n\n                        modified = true;\n                    }\n\n                    if (cmd) {\n                        execCmd(cmd);\n                    }\n                } catch (ex: unknown) {\n                    LoggerService?.error(ex);\n                }\n\n                nextMsg = buffer.shift();\n            }\n            reentered = false;\n\n            if (modified) {\n                setModel(prevModel => {\n                    const updatedModel = { ...prevModel as TModel, ...currentModel };\n\n                    LoggerService?.debug(\"Elm\", \"update model for\", name, updatedModel);\n\n                    return updatedModel;\n                });\n            }\n        }\n    }, []);\n\n    if (!initializedModel) {\n        const [initModel, initCmd] = init(props);\n\n        initializedModel = initModel;\n        setModel(initializedModel);\n\n        if (initCmd) {\n            execCmd(initCmd);\n        }\n    }\n\n    useEffect(() => {\n        if (subscription) {\n            const [subCmd, destructor] = subscription(initializedModel as TModel);\n\n            execCmd(subCmd);\n\n            if (destructor) {\n                return destructor;\n            }\n        }\n    }, []);\n\n    return [initializedModel, dispatch];\n}\n\nexport function callUpdate<TProps, TModel, TMessage extends MessageBase> (update: UpdateFunction<TProps, TModel, TMessage> | UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage> {\n    if (typeof update === \"function\") {\n        return update(model, msg, props);\n    }\n\n    return callUpdateMap(update, msg, model, props);\n}\n\nexport function callUpdateMap<TProps, TModel, TMessage extends MessageBase> (updateMap: UpdateMap<TProps, TModel, TMessage>, msg: TMessage, model: TModel, props: TProps): UpdateReturnType<TModel, TMessage> {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-expect-error -- We know that nextMsg fits\n    return updateMap[msg.name as TMessage[\"name\"]](msg, model, props);\n}"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-elmish",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Elmish for React using Typescript",
   "author": "atheck",
   "license": "MIT",
@@ -14,7 +14,7 @@
     "@babel/preset-env": "7.16.11",
     "@babel/preset-react": "7.16.7",
     "@babel/preset-typescript": "7.16.7",
-    "@testing-library/react": "12.1.4",
+    "@testing-library/react": "13.0.0",
     "@types/jest": "27.4.1",
     "@types/react": "17.0.43",
     "eslint": "8.12.0",