react-elmish 4.2.0-beta.5 → 4.3.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)];
     ...
     ```
 
@@ -922,10 +949,54 @@ const update = getUpdateFn(updateMap);
 const [model, cmd] = update(msg, model, props);
 ```
 
-## Migration from v1.x to v2.x
+### UI Tests
+
+To test UI components with a fake model you can use `renderWithModel` from the Testing namespace. The first parameter is a function to render your component (e.g. with **@testing-library/react**). The second parameter is the fake model or an options object, where you can also pass a fake `dispatch` function.
+
+```tsx
+import { renderWithModel } from "react-elmish/dist/Testing";
+import { fireEvent, render, screen } from "@testing-library/react";
+
+it("renders the correct value", () => {
+    // arrange
+    const model: Model = { value: "It works" };
+
+    // act
+    renderWithModel(() => render(<TestComponent />), model);
+
+    // assert
+    expect(screen.getByText("It works")).not.toBeNull();
+});
+
+it("dispatches the correct message", async () => {
+    // arrange
+    const model: Model = { value: "" };
+    const mockDispatch = jest.fn();
+
+    renderWithModel(
+        () => render(<TestComponent />),
+        {
+            model,
+            dispatch: mockDispatch
+        }
+    );
+
+    // act
+    fireEvent.click(screen.getByText("Click"));
+
+    // assert
+    expect(mockDispatch).toHaveBeenCalledWith({ name: "click" });
+});
+```
+
+This works for function components using the `useElmish` hook and class components.
+
+## 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 {
@@ -933,7 +1004,7 @@ const [model, cmd] = update(msg, model, props);
     }
     ```
 
-## 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.
 
@@ -946,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/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.
@@ -48,19 +48,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,11 +7,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ElmComponent = void 0;
 
-var _Init = require("./Init");
+var _react = _interopRequireDefault(require("react"));
 
-var _fakeInitResult = require("./Testing/fakeInitResult");
+var _Init = require("./Init");
 
-var _react = _interopRequireDefault(require("react"));
+var _fakeOptions = require("./Testing/fakeOptions");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
@@ -54,13 +54,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) {
@@ -153,7 +153,7 @@ var ElmComponent = /*#__PURE__*/function (_React$Component) {
 
     _defineProperty(_assertThisInitialized(_this), "update", void 0);
 
-    var fakeOptions = (0, _fakeInitResult.getFakeOptionsOnce)();
+    var fakeOptions = (0, _fakeOptions.getFakeOptionsOnce)();
 
     if (fakeOptions !== null && fakeOptions !== void 0 && fakeOptions.dispatch) {
       _this.dispatch = fakeOptions.dispatch;
@@ -226,7 +226,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 +236,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/fakeInitResult\";\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","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 React from \"react\";\nimport { Cmd } from \"./Cmd\";\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            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<TMessage>): 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 {TMessage} msg The message to dispatch.\n     * @memberof ElmComponent\n     */\n    public readonly dispatch = (msg: TMessage): 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: TMessage | 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 {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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"}

package/dist/ErrorHandling.d.ts

@@ -28,6 +28,6 @@ declare function errorHandler<TModel, TMessage>(): {
  * Calls the error handling middleware if specified.
  * @param {Error} error The error.
  */
-declare function handleError<TModel, TMsg>(error: Error): UpdateReturnType<TModel, TMsg>;
+declare function handleError<TModel, TMessage>(error: Error): UpdateReturnType<TModel, TMessage>;
 export type { ErrorMessage };
 export { errorMsg, errorHandler, handleError, };

package/dist/ErrorHandling.js

@@ -55,4 +55,4 @@ function handleError(error) {
   (_Services$logger = _Init.Services.logger) === null || _Services$logger === void 0 ? void 0 : _Services$logger.error(error);
   return [{}];
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/Init.d.ts

@@ -9,11 +9,28 @@ interface Message {
 declare type ErrorMiddlewareFunc = (error: Error) => void;
 declare type DispatchMiddlewareFunc = (msg: Message) => void;
 interface ElmOptions {
+    /**
+     * The logger to use for logging called messages and updated models.
+     * @type {Logger}
+     */
     logger?: Logger;
+    /**
+     * Middleware to call when error messages are handled by the `handleError` function.
+     * @type {ErrorMiddlewareFunc}
+     */
     errorMiddleware?: ErrorMiddlewareFunc;
+    /**
+     * Middleware to call for every processed message.
+     * @type {DispatchMiddlewareFunc}
+     */
     dispatchMiddleware?: DispatchMiddlewareFunc;
 }
 declare const Services: ElmOptions;
+/**
+ * This initializes the Elmish module.
+ * You only need to call this function if you want to set some of the options.
+ * @param {ElmOptions} options
+ */
 declare function init(options: ElmOptions): void;
 export type { Logger, Message, ErrorMiddlewareFunc, DispatchMiddlewareFunc, ElmOptions, };
 export { Services, init, };

package/dist/Init.js

@@ -10,6 +10,12 @@ var Services = {
   errorMiddleware: undefined,
   dispatchMiddleware: undefined
 };
+/**
+ * This initializes the Elmish module.
+ * You only need to call this function if you want to set some of the options.
+ * @param {ElmOptions} options
+ */
+
 exports.Services = Services;
 
 function init(options) {
@@ -17,4 +23,4 @@ function init(options) {
   Services.errorMiddleware = options.errorMiddleware;
   Services.dispatchMiddleware = options.dispatchMiddleware;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJTZXJ2aWNlcyIsImxvZ2dlciIsInVuZGVmaW5lZCIsImVycm9yTWlkZGxld2FyZSIsImRpc3BhdGNoTWlkZGxld2FyZSIsImluaXQiLCJvcHRpb25zIl0sInNvdXJjZXMiOlsiLi4vc3JjL0luaXQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW50ZXJmYWNlIExvZ2dlciB7XG4gICAgZGVidWc6ICguLi5hcmdzOiB1bmtub3duIFtdKSA9PiB2b2lkLFxuICAgIGluZm86ICguLi5hcmdzOiB1bmtub3duIFtdKSA9PiB2b2lkLFxuICAgIGVycm9yOiAoLi4uYXJnczogdW5rbm93biBbXSkgPT4gdm9pZCxcbn1cblxuaW50ZXJmYWNlIE1lc3NhZ2Uge1xuICAgIG5hbWU6IHN0cmluZyB8IHN5bWJvbCxcbn1cblxudHlwZSBFcnJvck1pZGRsZXdhcmVGdW5jID0gKGVycm9yOiBFcnJvcikgPT4gdm9pZDtcbnR5cGUgRGlzcGF0Y2hNaWRkbGV3YXJlRnVuYyA9IChtc2c6IE1lc3NhZ2UpID0+IHZvaWQ7XG5cbmludGVyZmFjZSBFbG1PcHRpb25zIHtcbiAgICBsb2dnZXI/OiBMb2dnZXIsXG4gICAgZXJyb3JNaWRkbGV3YXJlPzogRXJyb3JNaWRkbGV3YXJlRnVuYyxcbiAgICBkaXNwYXRjaE1pZGRsZXdhcmU/OiBEaXNwYXRjaE1pZGRsZXdhcmVGdW5jLFxufVxuXG5jb25zdCBTZXJ2aWNlczogRWxtT3B0aW9ucyA9IHtcbiAgICBsb2dnZXI6IHVuZGVmaW5lZCxcbiAgICBlcnJvck1pZGRsZXdhcmU6IHVuZGVmaW5lZCxcbiAgICBkaXNwYXRjaE1pZGRsZXdhcmU6IHVuZGVmaW5lZCxcbn07XG5cbmZ1bmN0aW9uIGluaXQgKG9wdGlvbnM6IEVsbU9wdGlvbnMpOiB2b2lkIHtcbiAgICBTZXJ2aWNlcy5sb2dnZXIgPSBvcHRpb25zLmxvZ2dlcjtcbiAgICBTZXJ2aWNlcy5lcnJvck1pZGRsZXdhcmUgPSBvcHRpb25zLmVycm9yTWlkZGxld2FyZTtcbiAgICBTZXJ2aWNlcy5kaXNwYXRjaE1pZGRsZXdhcmUgPSBvcHRpb25zLmRpc3BhdGNoTWlkZGxld2FyZTtcbn1cblxuZXhwb3J0IHR5cGUge1xuICAgIExvZ2dlcixcbiAgICBNZXNzYWdlLFxuICAgIEVycm9yTWlkZGxld2FyZUZ1bmMsXG4gICAgRGlzcGF0Y2hNaWRkbGV3YXJlRnVuYyxcbiAgICBFbG1PcHRpb25zLFxufTtcblxuZXhwb3J0IHtcbiAgICBTZXJ2aWNlcyxcbiAgICBpbml0LFxufTsiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFtQkEsSUFBTUEsUUFBb0IsR0FBRztFQUN6QkMsTUFBTSxFQUFFQyxTQURpQjtFQUV6QkMsZUFBZSxFQUFFRCxTQUZRO0VBR3pCRSxrQkFBa0IsRUFBRUY7QUFISyxDQUE3Qjs7O0FBTUEsU0FBU0csSUFBVCxDQUFlQyxPQUFmLEVBQTBDO0VBQ3RDTixRQUFRLENBQUNDLE1BQVQsR0FBa0JLLE9BQU8sQ0FBQ0wsTUFBMUI7RUFDQUQsUUFBUSxDQUFDRyxlQUFULEdBQTJCRyxPQUFPLENBQUNILGVBQW5DO0VBQ0FILFFBQVEsQ0FBQ0ksa0JBQVQsR0FBOEJFLE9BQU8sQ0FBQ0Ysa0JBQXRDO0FBQ0gifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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