react-elmish 2.2.0 → 3.2.0

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":";;;;;;;;;AAAA;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;IACsBA,Y;;;;;AAQlB;AACJ;AACA;AACA;AACA;AACA;AACA;AACI,wBAAoBC,KAApB,EAAmCC,IAAnC,EAA2FC,IAA3F,EAAyG;AAAA;;AAAA;;AACrG,8BAAMF,KAAN;;AADqG,6DAZtE,EAYsE;;AAAA,gEAXrF,KAWqF;;AAAA,8DAVvF,KAUuF;;AAAA,+DA0D9E,UAACG,GAAD,EAAqB;AAC5C,UAAMC,eAAe,GAAG,SAAlBA,eAAkB,CAACC,KAAD;AAAA,eAAqCA,KAAK,KAAK,MAAKC,YAAf,IAA+BC,MAAM,CAACC,mBAAP,CAA2BH,KAA3B,EAAkCI,MAAlC,GAA2C,CAA/G;AAAA,OAAxB;;AAEA,UAAIC,wBAAJ,EAAwB;AACpB,sCAAmBP,GAAnB;AACH;;AAED,UAAI,MAAKQ,SAAT,EAAoB;AAChB,cAAKC,MAAL,CAAYC,IAAZ,CAAiBV,GAAjB;AACH,OAFD,MAEO;AACH,cAAKQ,SAAL,GAAiB,IAAjB;AAEA,YAAIG,OAAyB,GAAGX,GAAhC;AACA,YAAIY,QAAQ,GAAG,KAAf;;AAEA,eAAOD,OAAP,EAAgB;AACZE,wGAAeC,IAAf,CAAoB,KAApB,EAA2B,cAA3B,EAA2C,MAAKC,aAAhD,EAA+DJ,OAAO,CAACZ,IAAvE;AACAc,wGAAeG,KAAf,CAAqB,KAArB,EAA4B,cAA5B,EAA4C,MAAKD,aAAjD,EAAgEJ,OAAhE;;AAEA,cAAI;AACA,+BAAqB,MAAKM,MAAL,CAAY,MAAKd,YAAjB,EAA+BQ,OAA/B,EAAwC,MAAKd,KAA7C,CAArB;AAAA;AAAA,gBAAOK,OAAP;AAAA,gBAAcgB,GAAd;;AAEA,gBAAIjB,eAAe,CAACC,OAAD,CAAnB,EAA4B;AACxB,oBAAKC,YAAL,mCAAyB,MAAKA,YAA9B,GAA+CD,OAA/C;AACAU,cAAAA,QAAQ,GAAG,IAAX;AACH;;AAED,gBAAIM,GAAJ,EAAS;AACL,oBAAKC,OAAL,CAAaD,GAAb;AACH;AACJ,WAXD,CAWE,OAAOE,EAAP,EAAoB;AAClBP,0GAAeQ,KAAf,CAAqBD,EAArB;AACH;;AAEDT,UAAAA,OAAO,GAAG,MAAKF,MAAL,CAAYa,KAAZ,EAAV;AACH;;AACD,cAAKd,SAAL,GAAiB,KAAjB;;AAEA,YAAI,MAAKe,OAAL,IAAgBX,QAApB,EAA8B;AAC1BC,wGAAeG,KAAf,CAAqB,KAArB,EAA4B,kBAA5B,EAAgD,MAAKD,aAArD,EAAoE,MAAKZ,YAAzE;;AACA,gBAAKqB,WAAL;AACH;AACJ;AACJ,KArGwG;;AAGrG,gBAAqB1B,IAAI,CAAC,MAAKD,KAAN,CAAzB;AAAA;AAAA,QAAOK,MAAP;AAAA,QAAcgB,IAAd;;AAEA,UAAKH,aAAL,GAAqBhB,IAArB;AACA,UAAKI,YAAL,GAAoBD,MAApB;AACA,UAAKuB,OAAL,GAAeP,IAAf;AAPqG;AAQxG;AAED;AACJ;AACA;AACA;AACA;;;;;WACI,6BAAkC;AAC9B,WAAKK,OAAL,GAAe,IAAf;;AAEA,UAAI,KAAKE,OAAT,EAAkB;AACd,aAAKN,OAAL,CAAa,KAAKM,OAAlB;AACA,aAAKA,OAAL,GAAe,IAAf;AACH;AACJ;AAED;AACJ;AACA;AACA;AACA;;;;WACI,gCAAqC;AACjC,WAAKF,OAAL,GAAe,KAAf;AACH;;;WAED,iBAAiBL,GAAjB,EAAuC;AAAA;;AACnCA,MAAAA,GAAG,CAACQ,OAAJ,CAAY,UAAAC,IAAI,EAAI;AAChB,YAAI;AACAA,UAAAA,IAAI,CAAC,MAAI,CAACC,QAAN,CAAJ;AACH,SAFD,CAEE,OAAOR,EAAP,EAAoB;AAClBP,wGAAeQ,KAAf,CAAqBD,EAArB;AACH;AACJ,OAND;AAOH;AAED;AACJ;AACA;AACA;AACA;AACA;;;;SACI,eAAsC;AAClC,aAAO,KAAKjB,YAAZ;AACH;AAED;AACJ;AACA;AACA;AACA;;AA8CI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;EA9HiF0B,kBAAMC,S","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/ElmUtilities.d.ts

@@ -27,3 +27,6 @@ export interface ErrorMessage {
     name: "error";
     error: Error;
 }
+export declare const errorMsg: {
+    error: (error: Error) => ErrorMessage;
+};

package/dist/ElmUtilities.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.handleError = void 0;
+exports.handleError = exports.errorMsg = void 0;
 
 var _Init = require("./Init");
 
@@ -23,4 +23,13 @@ var handleError = function handleError(error) {
 };
 
 exports.handleError = handleError;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9FbG1VdGlsaXRpZXMudHMiXSwibmFtZXMiOlsiaGFuZGxlRXJyb3IiLCJlcnJvciIsImVycm9yTWlkZGxld2FyZSIsIkxvZ2dlclNlcnZpY2UiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7QUFHQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDTyxJQUFNQSxXQUFXLEdBQUcsU0FBZEEsV0FBYyxDQUFlQyxLQUFmLEVBQWdFO0FBQ3ZGLE1BQUlDLHFCQUFKLEVBQXFCO0FBQ2pCLCtCQUFnQkQsS0FBaEI7QUFDSDs7QUFDREUsZ0dBQWVGLEtBQWYsQ0FBcUJBLEtBQXJCO0FBRUEsU0FBTyxDQUFDLEVBQUQsQ0FBUDtBQUNILENBUE0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBlcnJvck1pZGRsZXdhcmUsIExvZ2dlclNlcnZpY2UgfSBmcm9tIFwiLi9Jbml0XCI7XG5pbXBvcnQgeyBVcGRhdGVSZXR1cm5UeXBlIH0gZnJvbSBcIi4vRWxtQ29tcG9uZW50XCI7XG5cbi8qKlxuICogSGFuZGxlcyBhbiBlcnJvci5cbiAqIExvZ3MgdGhlIGVycm9yIGlmIGEgTG9nZ2VyIHdhcyBzcGVjaWZpZWQuXG4gKiBDYWxscyB0aGUgZXJyb3IgaGFuZGxpbmcgbWlkZGxld2FyZSBpZiBzcGVjaWZpZWQuXG4gKiBAcGFyYW0ge0Vycm9yfSBlcnJvciBUaGUgZXJyb3IuXG4gKi9cbmV4cG9ydCBjb25zdCBoYW5kbGVFcnJvciA9IDxUTW9kZWwsIFRNc2c+KGVycm9yOiBFcnJvcik6IFVwZGF0ZVJldHVyblR5cGU8VE1vZGVsLCBUTXNnPiA9PiB7XG4gICAgaWYgKGVycm9yTWlkZGxld2FyZSkge1xuICAgICAgICBlcnJvck1pZGRsZXdhcmUoZXJyb3IpO1xuICAgIH1cbiAgICBMb2dnZXJTZXJ2aWNlPy5lcnJvcihlcnJvcik7XG5cbiAgICByZXR1cm4gW3t9XTtcbn07XG5cbmV4cG9ydCB0eXBlIE51bGxhYmxlPFQ+ID0gVCB8IG51bGw7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWVzc2FnZUJhc2Uge1xuICAgIG5hbWU6IHN0cmluZyB8IHN5bWJvbCxcbn1cblxuLyoqXG4gKiBDcmVhdGVzIGEgTXNnU291cmNlIHR5cGUuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTXNnU291cmNlPFQgZXh0ZW5kcyBzdHJpbmc+IHtcbiAgICBzb3VyY2U6IFQsXG59XG5cbi8qKlxuICogVHlwZSBmb3IgbWFwcGluZyBtZXNzYWdlcyB0byBmdW5jdGlvbnMuXG4gKiBVc2UgdGhpcyB0eXBlIHRvIGNyZWF0ZSB5b3VyIHVwZGF0ZSBsb2dpYyBmb3IgdGhlIHVzZUVsbWlzaE1hcCBob29rLlxuICovXG5leHBvcnQgdHlwZSBVcGRhdGVNYXA8VFByb3BzLCBUTW9kZWwsIFRNc2cgZXh0ZW5kcyBNZXNzYWdlQmFzZT4gPSB7XG4gICAgW00gaW4gVE1zZyBhcyBNW1wibmFtZVwiXV06IChtc2c6IE0sIG1vZGVsOiBUTW9kZWwsIHByb3BzOiBUUHJvcHMpID0+IFVwZGF0ZVJldHVyblR5cGU8VE1vZGVsLCBUTXNnPjtcbn07XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXJyb3JNZXNzYWdlIHtcbiAgICBuYW1lOiBcImVycm9yXCIsXG4gICAgZXJyb3I6IEVycm9yLFxufSJdfQ==
+var errorMsg = {
+  error: function error(_error) {
+    return {
+      name: "error",
+      error: _error
+    };
+  }
+};
+exports.errorMsg = errorMsg;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9FbG1VdGlsaXRpZXMudHMiXSwibmFtZXMiOlsiaGFuZGxlRXJyb3IiLCJlcnJvciIsImVycm9yTWlkZGxld2FyZSIsIkxvZ2dlclNlcnZpY2UiLCJlcnJvck1zZyIsIm5hbWUiXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFBQTs7QUFHQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDTyxJQUFNQSxXQUFXLEdBQUcsU0FBZEEsV0FBYyxDQUFlQyxLQUFmLEVBQWdFO0FBQ3ZGLE1BQUlDLHFCQUFKLEVBQXFCO0FBQ2pCLCtCQUFnQkQsS0FBaEI7QUFDSDs7QUFDREUsZ0dBQWVGLEtBQWYsQ0FBcUJBLEtBQXJCO0FBRUEsU0FBTyxDQUFDLEVBQUQsQ0FBUDtBQUNILENBUE07OztBQW1DQSxJQUFNRyxRQUFRLEdBQUc7QUFDcEJILEVBQUFBLEtBQUssRUFBRSxlQUFDQSxNQUFEO0FBQUEsV0FBaUM7QUFBRUksTUFBQUEsSUFBSSxFQUFFLE9BQVI7QUFBaUJKLE1BQUFBLEtBQUssRUFBTEE7QUFBakIsS0FBakM7QUFBQTtBQURhLENBQWpCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZXJyb3JNaWRkbGV3YXJlLCBMb2dnZXJTZXJ2aWNlIH0gZnJvbSBcIi4vSW5pdFwiO1xuaW1wb3J0IHsgVXBkYXRlUmV0dXJuVHlwZSB9IGZyb20gXCIuL0VsbUNvbXBvbmVudFwiO1xuXG4vKipcbiAqIEhhbmRsZXMgYW4gZXJyb3IuXG4gKiBMb2dzIHRoZSBlcnJvciBpZiBhIExvZ2dlciB3YXMgc3BlY2lmaWVkLlxuICogQ2FsbHMgdGhlIGVycm9yIGhhbmRsaW5nIG1pZGRsZXdhcmUgaWYgc3BlY2lmaWVkLlxuICogQHBhcmFtIHtFcnJvcn0gZXJyb3IgVGhlIGVycm9yLlxuICovXG5leHBvcnQgY29uc3QgaGFuZGxlRXJyb3IgPSA8VE1vZGVsLCBUTXNnPihlcnJvcjogRXJyb3IpOiBVcGRhdGVSZXR1cm5UeXBlPFRNb2RlbCwgVE1zZz4gPT4ge1xuICAgIGlmIChlcnJvck1pZGRsZXdhcmUpIHtcbiAgICAgICAgZXJyb3JNaWRkbGV3YXJlKGVycm9yKTtcbiAgICB9XG4gICAgTG9nZ2VyU2VydmljZT8uZXJyb3IoZXJyb3IpO1xuXG4gICAgcmV0dXJuIFt7fV07XG59O1xuXG5leHBvcnQgdHlwZSBOdWxsYWJsZTxUPiA9IFQgfCBudWxsO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1lc3NhZ2VCYXNlIHtcbiAgICBuYW1lOiBzdHJpbmcgfCBzeW1ib2wsXG59XG5cbi8qKlxuICogQ3JlYXRlcyBhIE1zZ1NvdXJjZSB0eXBlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIE1zZ1NvdXJjZTxUIGV4dGVuZHMgc3RyaW5nPiB7XG4gICAgc291cmNlOiBULFxufVxuXG4vKipcbiAqIFR5cGUgZm9yIG1hcHBpbmcgbWVzc2FnZXMgdG8gZnVuY3Rpb25zLlxuICogVXNlIHRoaXMgdHlwZSB0byBjcmVhdGUgeW91ciB1cGRhdGUgbG9naWMgZm9yIHRoZSB1c2VFbG1pc2hNYXAgaG9vay5cbiAqL1xuZXhwb3J0IHR5cGUgVXBkYXRlTWFwPFRQcm9wcywgVE1vZGVsLCBUTXNnIGV4dGVuZHMgTWVzc2FnZUJhc2U+ID0ge1xuICAgIFtNIGluIFRNc2cgYXMgTVtcIm5hbWVcIl1dOiAobXNnOiBNLCBtb2RlbDogVE1vZGVsLCBwcm9wczogVFByb3BzKSA9PiBVcGRhdGVSZXR1cm5UeXBlPFRNb2RlbCwgVE1zZz47XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIEVycm9yTWVzc2FnZSB7XG4gICAgbmFtZTogXCJlcnJvclwiLFxuICAgIGVycm9yOiBFcnJvcixcbn1cblxuZXhwb3J0IGNvbnN0IGVycm9yTXNnID0ge1xuICAgIGVycm9yOiAoZXJyb3I6IEVycm9yKTogRXJyb3JNZXNzYWdlID0+ICh7IG5hbWU6IFwiZXJyb3JcIiwgZXJyb3IgfSksXG59OyJdfQ==

package/dist/Testing/index.js

@@ -8,7 +8,7 @@ exports.getOfMsgParams = getOfMsgParams;
 exports.getUpdateFn = getUpdateFn;
 exports.runSingleOfPromiseCmd = runSingleOfPromiseCmd;
 
-var _useElmishMap = require("../useElmishMap");
+var _useElmish = require("../useElmish");
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
@@ -142,7 +142,7 @@ function _execCmd() {
 
 function getUpdateFn(updateMap) {
   return function (msg, model, props) {
-    return (0, _useElmishMap.callUpdateMap)(updateMap, msg, model, props);
+    return (0, _useElmish.callUpdateMap)(updateMap, msg, model, props);
   };
 }
-//# 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/index.d.ts

@@ -1,8 +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";
-import { useElmishMap } from "./useElmishMap";
-export type { Logger, Message, Cmd, Dispatch, UpdateReturnType, MsgSource, UpdateMap, ErrorMessage, };
-export { init, createCmd, ElmComponent, handleError, useElmish, useElmishMap, };
+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() {
@@ -33,12 +39,6 @@ Object.defineProperty(exports, "useElmish", {
     return _useElmish.useElmish;
   }
 });
-Object.defineProperty(exports, "useElmishMap", {
-  enumerable: true,
-  get: function get() {
-    return _useElmishMap.useElmishMap;
-  }
-});
 
 var _Cmd = require("./Cmd");
 
@@ -49,6 +49,4 @@ var _ElmUtilities = require("./ElmUtilities");
 var _Init = require("./Init");
 
 var _useElmish = require("./useElmish");
-
-var _useElmishMap = require("./useElmishMap");
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENtZCwgY3JlYXRlQ21kLCBEaXNwYXRjaCB9IGZyb20gXCIuL0NtZFwiO1xuaW1wb3J0IHsgRWxtQ29tcG9uZW50LCBVcGRhdGVSZXR1cm5UeXBlIH0gZnJvbSBcIi4vRWxtQ29tcG9uZW50XCI7XG5pbXBvcnQgeyBFcnJvck1lc3NhZ2UsIGhhbmRsZUVycm9yLCBNc2dTb3VyY2UsIFVwZGF0ZU1hcCB9IGZyb20gXCIuL0VsbVV0aWxpdGllc1wiO1xuaW1wb3J0IHsgaW5pdCwgTG9nZ2VyLCBNZXNzYWdlIH0gZnJvbSBcIi4vSW5pdFwiO1xuaW1wb3J0IHsgdXNlRWxtaXNoIH0gZnJvbSBcIi4vdXNlRWxtaXNoXCI7XG5pbXBvcnQgeyB1c2VFbG1pc2hNYXAgfSBmcm9tIFwiLi91c2VFbG1pc2hNYXBcIjtcblxuZXhwb3J0IHR5cGUge1xuICAgIExvZ2dlcixcbiAgICBNZXNzYWdlLFxuICAgIENtZCxcbiAgICBEaXNwYXRjaCxcbiAgICBVcGRhdGVSZXR1cm5UeXBlLFxuICAgIE1zZ1NvdXJjZSxcbiAgICBVcGRhdGVNYXAsXG4gICAgRXJyb3JNZXNzYWdlLFxufTtcblxuZXhwb3J0IHtcbiAgICBpbml0LFxuICAgIGNyZWF0ZUNtZCxcbiAgICBFbG1Db21wb25lbnQsXG4gICAgaGFuZGxlRXJyb3IsXG4gICAgdXNlRWxtaXNoLFxuICAgIHVzZUVsbWlzaE1hcCxcbn07Il19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENtZCwgY3JlYXRlQ21kLCBEaXNwYXRjaCB9IGZyb20gXCIuL0NtZFwiO1xuaW1wb3J0IHsgRWxtQ29tcG9uZW50LCBJbml0UmVzdWx0LCBVcGRhdGVSZXR1cm5UeXBlIH0gZnJvbSBcIi4vRWxtQ29tcG9uZW50XCI7XG5pbXBvcnQgeyBFcnJvck1lc3NhZ2UsIGVycm9yTXNnLCBoYW5kbGVFcnJvciwgTXNnU291cmNlLCBVcGRhdGVNYXAgfSBmcm9tIFwiLi9FbG1VdGlsaXRpZXNcIjtcbmltcG9ydCB7IGluaXQsIExvZ2dlciwgTWVzc2FnZSB9IGZyb20gXCIuL0luaXRcIjtcbmltcG9ydCB7IFN1YnNjcmlwdGlvblJlc3VsdCwgdXNlRWxtaXNoIH0gZnJvbSBcIi4vdXNlRWxtaXNoXCI7XG5cbmV4cG9ydCB0eXBlIHtcbiAgICBMb2dnZXIsXG4gICAgTWVzc2FnZSxcbiAgICBDbWQsXG4gICAgRGlzcGF0Y2gsXG4gICAgSW5pdFJlc3VsdCxcbiAgICBVcGRhdGVSZXR1cm5UeXBlLFxuICAgIFN1YnNjcmlwdGlvblJlc3VsdCxcbiAgICBNc2dTb3VyY2UsXG4gICAgVXBkYXRlTWFwLFxuICAgIEVycm9yTWVzc2FnZSxcbn07XG5cbmV4cG9ydCB7XG4gICAgaW5pdCxcbiAgICBjcmVhdGVDbWQsXG4gICAgRWxtQ29tcG9uZW50LFxuICAgIGVycm9yTXNnLFxuICAgIGhhbmRsZUVycm9yLFxuICAgIHVzZUVsbWlzaCxcbn07Il19

package/dist/legacy/useElmish.d.ts

@@ -0,0 +1,15 @@
+import { Dispatch } from "../Cmd";
+import { InitFunction, UpdateFunction } from "../ElmComponent";
+import { MessageBase } from "../ElmUtilities";
+/**
+ * Hook to use the Elm architecture pattern in a function component.
+ * @param props The props of the component.
+ * @param init Function to initialize the model.
+ * @param update The update function.
+ * @param name The name of the component.
+ * @returns A tuple containing the current model and the dispatcher.
+ * @example
+ * 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: InitFunction<TProps, TModel, TMsg>, update: UpdateFunction<TProps, TModel, TMsg>, name: string): [TModel, Dispatch<TMsg>];

package/dist/legacy/useElmish.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useElmish = useElmish;
+
+var _Init = require("../Init");
+
+var _react = require("react");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/**
+ * Hook to use the Elm architecture pattern in a function component.
+ * @param props The props of the component.
+ * @param init Function to initialize the model.
+ * @param update The update function.
+ * @param name The name of the component.
+ * @returns A tuple containing the current model and the dispatcher.
+ * @example
+ * const [model, dispatch] = useElmish(props, init, update, "MyComponent");
+ * @deprecated Use `useElmish` with an options object instead.
+ */
+function useElmish(props, init, update, name) {
+  var reentered = false;
+  var buffer = [];
+  var currentModel = {};
+
+  var _useState = (0, _react.useState)(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      model = _useState2[0],
+      setModel = _useState2[1];
+
+  var initializedModel = model;
+  var execCmd = (0, _react.useCallback)(function (cmd) {
+    cmd.forEach(function (call) {
+      try {
+        call(dispatch);
+      } catch (ex) {
+        _Init.LoggerService === null || _Init.LoggerService === void 0 ? void 0 : _Init.LoggerService.error(ex);
+      }
+    });
+  }, []);
+  var dispatch = (0, _react.useCallback)(function (msg) {
+    if (!initializedModel) {
+      return;
+    }
+
+    var modelHasChanged = function modelHasChanged(updatedModel) {
+      return updatedModel !== initializedModel && Object.getOwnPropertyNames(updatedModel).length > 0;
+    };
+
+    if (_Init.dispatchMiddleware) {
+      (0, _Init.dispatchMiddleware)(msg);
+    }
+
+    if (reentered) {
+      buffer.push(msg);
+    } else {
+      reentered = true;
+      var nextMsg = msg;
+      var modified = false;
+
+      while (nextMsg) {
+        _Init.LoggerService === null || _Init.LoggerService === void 0 ? void 0 : _Init.LoggerService.info("Elm", "message from", name, nextMsg.name);
+        _Init.LoggerService === null || _Init.LoggerService === void 0 ? void 0 : _Init.LoggerService.debug("Elm", "message from", name, nextMsg);
+
+        try {
+          var _update = update(_objectSpread(_objectSpread({}, initializedModel), currentModel), nextMsg, props),
+              _update2 = _slicedToArray(_update, 2),
+              newModel = _update2[0],
+              cmd = _update2[1];
+
+          if (modelHasChanged(newModel)) {
+            currentModel = _objectSpread(_objectSpread({}, currentModel), newModel);
+            modified = true;
+          }
+
+          if (cmd) {
+            execCmd(cmd);
+          }
+        } catch (ex) {
+          _Init.LoggerService === null || _Init.LoggerService === void 0 ? void 0 : _Init.LoggerService.error(ex);
+        }
+
+        nextMsg = buffer.shift();
+      }
+
+      reentered = false;
+
+      if (modified) {
+        setModel(function (prevModel) {
+          var updatedModel = _objectSpread(_objectSpread({}, prevModel), currentModel);
+
+          _Init.LoggerService === null || _Init.LoggerService === void 0 ? void 0 : _Init.LoggerService.debug("Elm", "update model for", name, updatedModel);
+          return updatedModel;
+        });
+      }
+    }
+  }, []);
+
+  if (!initializedModel) {
+    var _init = init(props),
+        _init2 = _slicedToArray(_init, 2),
+        initModel = _init2[0],
+        initCmd = _init2[1];
+
+    initializedModel = initModel;
+    setModel(initializedModel);
+
+    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 { 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

@@ -0,0 +1,15 @@
+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.
+ * @param init Function to initialize the model.
+ * @param updateMap The update map object.
+ * @param name The name of the component.
+ * @returns A tuple containing the current model and the dispatcher.
+ * @example
+ * 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: InitFunction<TProps, TModel, TMessage>, updateMap: UpdateMap<TProps, TModel, TMessage>, name: string): [TModel, Dispatch<TMessage>];