@clicktap/state 0.1.1 → 0.1.3

package/index.js

@@ -0,0 +1,729 @@
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import { createMachine, interpret, sendTo } from 'xstate';
+import { assign } from '@xstate/immer';
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, cloneElement } from 'react';
+import cookie from 'cookie';
+import crypto from 'crypto';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function request(url, options) {
+  return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var response;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetch(url, options);
+
+          case 2:
+            response = _context.sent;
+
+            if (!(response.status === 200)) {
+              _context.next = 5;
+              break;
+            }
+
+            return _context.abrupt("return", response.json());
+
+          case 5:
+            return _context.abrupt("return", Promise.resolve({
+              message: response.statusText,
+              success: false
+            }));
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+}
+
+var authMachine =
+/** @xstate-layout N4IgpgJg5mDOIC5QEMCuAXAFgOjVsAdugJYDGyJBUAxBAPYFjbEEBudA1k3jj4SeUpQELdoOIMA2gAYAujNmJQABzqxiJBkpAAPRAEZ9Adn3YAbABYATAGYr1gKwWLDoxYA0IAJ6JbATmwADkCXPyszK0CzPyijAF84zx5cDEx+MgoWGjAAJxy6HOxlABsKADMCgFsUrBq0ogyhETY6cSk5BW1VdU0CbT0EfWkncysHYelba0DXTx8EBzNTCxDXPzMbaTCjQISk1OxUAj4G8SpaBiZRTm4Do5OBTKpmsUz2+TkutQ0JPqRdRAAWkMAUiNkCxjMO02+gsNjmvkCVmw+hsRnRjiM0hMexAyXuqXSZ2yeQKRVK6AqOWq+OOhNOT2E1zaBAUnX+3R+Wn+A2R0RsmwhRjMUKsRgcSIRCCR2Fs6MCYSmDn0wVxyRyYDKGtgmCyF0YzBaXDq2A1WrguuezLerI6nw5316-UQRhi2BiQ2kk2VkylUSCfnB9iWwSxYrVBzN2stJPyhRK5SqJqjFqyL1aNrZ9pUjt+zoQFn0Zmw0gs6Ks0n0gZMMSlwOx2ELTj80jMTisYvCEdqxToUBgEAA8hhqAAZQcAcQAkgA5dk5np5nm+KElsyBcWWQzhMZSizSQLYVzbhyB8F+Pz6bs4Xv9yBTghjyeDgCqABV5yBOU7l9KjDYghmQJhgVPwHArKw6yrYswKWf8HE2cYJWvbBbwHB9qB0WB0AobgynQXIAAozC9L0AEpqGSND71tRQHUXblQAGKJkVdZwqwlMIokCKCjGwYUYThf8SLRCwEkSEACDoCA4G0HgvgYv4mKBIs+LBIUoUCQT4W8IFIgsRtFmMMskMvKwUIeRosgUrklIBQZKwA1soWccJXU2PwpVEktjBmdcIhiZwUIJfAGSEGyf2UhBAQM0N1gPJYoVbHYoJCHyTCiLYYnXcMJPVTVo2s+jbPzawAkMSZwmxBUJX0KUxUPOV3LYy8tjEvKDmoocMAipcopsAJTzRNY0VhWEpVcaQSy0sVxjGFs0RQrqH16xj7MMOFGxWRYBXBRYeN0hA3XsINnBCfcLyvcSgA */
+createMachine({
+  context: {
+    // id: '',
+    user: null,
+    accessToken: '',
+    refreshToken: '',
+
+    /**
+     * If unauthenticating fails, we need a way to ignore the refresh token on subsequent access token refresh.
+     * This would be set to true done/error of unauthenticate service, and false on done of authenticate service
+     */
+    ignoreRefreshToken: false,
+    endpoints: {
+      login: '',
+      logout: '',
+      refresh: '',
+      ssrRefresh: ''
+    }
+  },
+  predictableActionArguments: true,
+  id: 'auth',
+  initial: 'refreshing',
+  states: {
+    authenticating: {
+      invoke: {
+        src: 'authenticate',
+        onDone: [{
+          actions: 'setUserContext',
+          target: 'loggedIn'
+        }],
+        onError: [{
+          target: 'loggedOut'
+        }]
+      }
+    },
+    unauthenticating: {
+      invoke: {
+        src: 'unauthenticate',
+        onDone: [{
+          actions: 'unsetUserContext',
+          target: 'loggedOut'
+        }],
+        onError: [{
+          actions: ['unsetUserContext', 'setIgnoreRefreshToken'],
+          target: 'loggedOut'
+        }]
+      }
+    },
+    refreshing: {
+      invoke: {
+        src: 'refreshAccessToken',
+        onDone: [{
+          actions: ['unsetRefreshToken', 'setAccessToken'],
+          target: 'loggedIn'
+        }],
+        onError: [{
+          actions: 'unsetRefreshToken',
+          target: 'unauthenticating'
+        }]
+      }
+    },
+    loggedOut: {
+      on: {
+        LOGIN: {
+          target: 'authenticating'
+        }
+      }
+    },
+    loggedIn: {
+      after: {
+        '60000': {
+          cond: function cond() {
+            return typeof window !== 'undefined';
+          },
+          target: 'refreshing'
+        }
+      },
+      // entry: ['unsetUserContext'],
+      on: {
+        LOGOUT: {
+          target: 'unauthenticating'
+        }
+      }
+    }
+  }
+}, {
+  actions: {
+    // setAccessToken: assign<UserContext, RefreshTokenEvent>((context, event) => {
+    //   context.accessToken = event.accessToken;
+    // }),
+    setUserContext: assign(function (context, event) {
+      // event.type - done.invoke.auth.authenticating:invocation[0]
+      if (event.data.type !== 'AUTHENTICATE_SUCCESS') return; // context.user = event.data.user;
+
+      context.accessToken = event.data.accessToken;
+      context.ignoreRefreshToken = false;
+    }),
+    unsetUserContext: assign(function (context) {
+      var endpoints = context.endpoints;
+      Object.assign(context, authMachine.initialState.context);
+      context.endpoints = endpoints; // maintain endpoints passed through DI when machine created
+      // context = authMachine.initialState.context;
+    }),
+    setAccessToken: assign(function (context, event) {
+      if (event.data.type !== 'REFRESH_TOKEN_SUCCESS') return; // is this really necessary?
+
+      context.accessToken = event.data.accessToken;
+      context.ignoreRefreshToken = false;
+    }),
+    unsetRefreshToken: assign(function (context, event) {
+      if (event.data.type !== 'REFRESH_TOKEN_SUCCESS') return; // is this really necessary?
+
+      context.refreshToken = '';
+    }),
+    setIgnoreRefreshToken: assign(function (context) {
+      context.ignoreRefreshToken = true;
+    })
+  },
+  services: {
+    refreshAccessToken: function refreshAccessToken(context) {
+      return function () {
+        return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+          var response, data, _data;
+
+          return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+            while (1) {
+              switch (_context2.prev = _context2.next) {
+                case 0:
+                  if (!(typeof window === 'undefined')) {
+                    _context2.next = 18;
+                    break;
+                  }
+
+                  if (!(context.refreshToken === '')) {
+                    _context2.next = 3;
+                    break;
+                  }
+
+                  throw new Error('Unauthorized.');
+
+                case 3:
+                  _context2.prev = 3;
+                  _context2.next = 6;
+                  return request(context.endpoints.ssrRefresh, {
+                    method: 'POST',
+                    mode: 'cors',
+                    credentials: 'include',
+                    headers: {
+                      Cookie: "refresh_token=".concat(context.refreshToken),
+                      'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                      grant_type: 'refresh_token' // client_id: 'default',
+                      // client_secret: 'Password123!',
+                      // scope: 'default',
+
+                    }).toString()
+                  });
+
+                case 6:
+                  response = _context2.sent;
+                  data = response;
+
+                  if (!(typeof data.accessToken === 'undefined')) {
+                    _context2.next = 10;
+                    break;
+                  }
+
+                  throw new Error('Unauthorized.');
+
+                case 10:
+                  return _context2.abrupt("return", {
+                    type: 'REFRESH_TOKEN_SUCCESS',
+                    accessToken: data.accessToken
+                  });
+
+                case 13:
+                  _context2.prev = 13;
+                  _context2.t0 = _context2["catch"](3);
+                  throw new Error('Could not complete refresh request (server)');
+
+                case 16:
+                  _context2.next = 25;
+                  break;
+
+                case 18:
+                  _context2.next = 20;
+                  return request(context.endpoints.refresh, {
+                    method: 'POST',
+                    mode: 'cors',
+                    credentials: 'include',
+                    headers: {
+                      'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                      grant_type: 'refresh_token' // client_id: 'default',
+                      // client_secret: 'Password123!',
+                      // scope: 'default',
+
+                    }).toString()
+                  });
+
+                case 20:
+                  response = _context2.sent;
+                  _data = response;
+
+                  if (!(typeof _data.accessToken === 'undefined')) {
+                    _context2.next = 24;
+                    break;
+                  }
+
+                  throw new Error('Unauthorized.');
+
+                case 24:
+                  return _context2.abrupt("return", {
+                    type: 'REFRESH_TOKEN_SUCCESS',
+                    accessToken: _data.accessToken
+                  });
+
+                case 25:
+                case "end":
+                  return _context2.stop();
+              }
+            }
+          }, _callee2, null, [[3, 13]]);
+        }));
+      };
+    },
+    authenticate: function authenticate(context, event) {
+      return function () {
+        return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+          var _a, _b, e, response, data;
+
+          return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+            while (1) {
+              switch (_context3.prev = _context3.next) {
+                case 0:
+                  e = event; // workaround to typescript not allowing casting in parameter
+
+                  if (!(e.type !== 'LOGIN')) {
+                    _context3.next = 3;
+                    break;
+                  }
+
+                  throw new Error("Authenticate can only be called for \"LOGIN\" event type. Event caller: ".concat(String(e.type)));
+
+                case 3:
+                  _context3.next = 5;
+                  return request(context.endpoints.login, {
+                    method: 'POST',
+                    mode: 'cors',
+                    credentials: 'include',
+                    headers: {
+                      'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                      username: e.username,
+                      password: e.password // grant_type: 'password',
+                      // client_id: 'default',
+                      // client_secret: 'Password123!',
+                      // scope: 'default',
+
+                    }).toString()
+                  });
+
+                case 5:
+                  response = _context3.sent;
+
+                  /** @todo do we need to handle different status codes here...like what if the service is down? */
+                  data = response;
+
+                  if (!(typeof data.accessToken === 'undefined')) {
+                    _context3.next = 9;
+                    break;
+                  }
+
+                  throw new Error((_b = (_a = data.message) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'Sign in failed. Please try again.');
+
+                case 9:
+                  return _context3.abrupt("return", {
+                    type: 'AUTHENTICATE_SUCCESS',
+                    // user: data.user,
+                    accessToken: data.accessToken
+                  });
+
+                case 10:
+                case "end":
+                  return _context3.stop();
+              }
+            }
+          }, _callee3);
+        }));
+      };
+    },
+    unauthenticate: function unauthenticate(context) {
+      return function () {
+        return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+          return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+            while (1) {
+              switch (_context4.prev = _context4.next) {
+                case 0:
+                  _context4.next = 2;
+                  return fetch(context.endpoints.logout, {
+                    method: 'POST',
+                    mode: 'cors',
+                    credentials: 'include' // headers: {
+                    //   'Access-Control-Allow-Origin': 'https://middleware-clicktap.local-rmgmedia.com',
+                    //   'Access-Control-Allow-Credentials': 'true',
+                    // },
+
+                  });
+
+                case 2:
+                  return _context4.abrupt("return", {
+                    type: 'UNAUTHENTICATE'
+                  });
+
+                case 3:
+                case "end":
+                  return _context4.stop();
+              }
+            }
+          }, _callee4);
+        }));
+      };
+    }
+  } // doesn't make sense in the case where you have an access token that is about to expire
+  // and the loggedIn state won't fire another refresh for 15 min
+  //
+  // guards: {
+  //   checkIfLoggedIn: (context, _event) => {
+  //     if (context.user) return true;
+  //   },
+  // },
+
+});
+
+// import type { NextPageContext } from 'next';
+// import { useRouter } from 'next/router';
+
+var AuthContext = /*#__PURE__*/createContext({});
+var useAuth = function useAuth() {
+  // console.log('useAuth');
+  // console.log(useContext(AuthContext).getSnapshot().context);
+  return useContext(AuthContext);
+};
+var useUser = function useUser() {
+  return useContext(AuthContext).getSnapshot().context.user;
+};
+/**
+ * this will run on the server side as part of app.getInitialProps
+ * @todo is it possible to share state from client to server? headers? cookies?
+ */
+
+var getAuth = function getAuth(context, options // eslint-disable-next-line @typescript-eslint/require-await
+) {
+  return __awaiter(void 0, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _a, authContext, cookies, authContextWithRefresh;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            authContext = Object.assign(Object.assign({}, authMachine.initialState.context), {
+              endpoints: Object.assign({}, options.endpoints)
+            });
+
+            if (!(typeof window !== 'undefined')) {
+              _context.next = 4;
+              break;
+            }
+
+            // eslint-disable-next-line no-console
+            console.warn('App.getInitialProps::getAuth should not be run on the frontend. You are probably missing getServerSideProps in your page.');
+            return _context.abrupt("return", interpret(authMachine.withContext(authContext), {
+              devTools: options.devTools
+            }).start());
+
+          case 4:
+            cookies = cookie.parse(((_a = context === null || context === void 0 ? void 0 : context.req) === null || _a === void 0 ? void 0 : _a.headers) && context.req.headers.cookie ? context.req.headers.cookie : '');
+            authContextWithRefresh = Object.assign(authContext, {
+              refreshToken: cookies['refresh_token']
+            });
+
+            if (!(typeof cookies['refresh_token'] !== 'undefined')) {
+              _context.next = 8;
+              break;
+            }
+
+            return _context.abrupt("return", interpret(authMachine.withContext(authContextWithRefresh), {
+              devTools: options.devTools
+            }).start());
+
+          case 8:
+            return _context.abrupt("return", interpret(authMachine.withContext(authContext), {
+              devTools: options.devTools
+            }).start());
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+};
+function AuthProvider(_ref) {
+  var children = _ref.children,
+      service = _ref.service;
+  // console.log('AuthProvider::state');
+  // console.log(state.context);
+  // let authService = interpret(authMachine, { devTools: options.devTools }).start(state);
+  // console.log('AuthProvider::authService');
+  // console.log(authService.getSnapshot().context);
+  return jsx(AuthContext.Provider, Object.assign({
+    value: service
+  }, {
+    children: children
+  }));
+}
+
+var timerMachine =
+/** @xstate-layout N4IgpgJg5mDOIC5QBcCWBbMAnAdABwEMBXWSAYgCUBRAZQFUBZKgfQBUBJJigbQAYBdRKDwB7WKjQiAdkJAAPRAFoAjADYATDmUBOXQA5tAZmV69AFgDsq1QBoQAT0SHehnAFYAvh7tpMuLERSUqhSUGQcAMIA0nyCSCCi4pIy8QoIJqo4qnoWbnaOCGZmmaq8Zbyqyi5uym6qXj4Y2DgBQSFhAAoAgnQ0LBxcsbKJEqjSsmlVbjimFmZ6agZmbsbq+U4u7g0gvs2twaFkQ-EjyRNObrxZOXkOiGbKFjjq5WbqFurFvNpmXt4gUhEEDgsl2WGGYlG41SSnUVS0um0BmMpks1nW6Tcmk8-zB+GIpAgEKSYxSoDSvAxn142zx+3axKhZPkiEpdwQhjmW1xTVwAGMROg8AAbMDISCMs4whBsgpuOp-DxAA */
+createMachine({
+  id: 'timer',
+  initial: 'running',
+  context: {
+    elapsed: 0,
+    duration: 3000,
+    interval: 100,
+    intervalId: null
+  },
+  states: {
+    paused: {
+      on: {
+        // START_TIMER: {
+        //   target: 'running',
+        //   cond: (context) => context.elapsed < context.duration,
+        // },
+        RESUME_TIMER: {
+          target: 'running',
+          cond: function cond(context) {
+            return context.elapsed < context.duration;
+          }
+        }
+      }
+    },
+    running: {
+      invoke: {
+        src: function src(context) {
+          return function (send) {
+            // eslint-disable-next-line no-console
+            // console.log('context.interval: ', context.interval);
+            var interval = setInterval(function () {
+              send('TICK');
+            }, context.interval);
+            return function () {
+              clearInterval(interval);
+            };
+          };
+        }
+      },
+      always: [{
+        target: 'completed',
+        cond: function cond(context) {
+          return context.elapsed >= context.duration;
+        }
+      }],
+      on: {
+        TICK: {
+          actions: assign(function (context, event) {
+            if (event.type !== 'TICK') return;
+            context.elapsed += context.interval; // eslint-disable-next-line no-console
+            // console.log(
+            //   'elapsed: %d | interval: %d',
+            //   context.elapsed,
+            //   context.interval
+            // );
+          })
+        },
+        PAUSE_TIMER: {
+          target: 'paused'
+        }
+      }
+    },
+    completed: {
+      type: 'final'
+    }
+  }
+});
+
+var toastMachine =
+/** @xstate-layout N4IgpgJg5mDOIC5QBcD2BDWyB0BLCANmAMQCCAIuQPoCSAKgKICyA2gAwC6ioADqrLmS5UAO24gAHogCMAZgCs2AGzS2SgBxKA7AE4lO2ToAsAGhABPRAFoj6gL52zaTDnQBjIQDcSEUWDwinqgA1v5CALZgAE7sXEggfAJCouJSCEpsOspaOQay0kqyAExKZpYIReps2LY6mmxG+kUKWkYOThhY2O5eJBTU9Myx4omCwmLxabKF2NKN8kpFbPls8gpl1vLqykXyasaNhdJFWu0gzl09uN7EAErMAPIAagy0jKycI-xjKZOIi9sDPI9EZgYV1LItBsEIYlNg9NIdGxKki1jkzhdXB5riQAMoMOi0cgAGQYw3io2SE1AaTkWS0RQOSKWEK0c2hzWkNUWJy0Skah1sGM6WN6dwYuIAqkxXnQaDLbuTeN8qakZPIuXylhktAppgUitDilpsJpQeo9KsVOoCsKXN1sTcAAqkSX4qhyhVKhIq8ZqirSbaZeTyLRbVnqVqyaHSaQm45mtirKo6Eo6O2XCAQXAiKDEfGEmgksmfCm+340xC2bCh3XGrTLfR8+TQqxFJbYTIoow6HStBshjOuLM5vMFqikADCcpe3spfr+MKMmsZbDmFvU6jBRtW8I3IcMBT7Q+wUTA4VQnlH+YJRNJc-L1MkiHURiKps0DIWKhyIZjehqfc1h0I8GyUE8zwvK9cxvQkpxnEs4mVJIF0rBBU1kWZVw1WtgSMUwLHVIxsEqIxjVDIF5CFM4RFQCA4HETEvhQitnwQKxYxNOoDFjbQ2RtfRW1kfJO1THjA1sVRZBPfAiGYn4nzSKx9D3cS+MDI9-zhWot2A0C1BPK5vHk1VF1kIwuOZPICmKYEtMAuoDxAptlkMkdcxM1C2MMYjKhKXUlH5DUimkVsijImsxMMcLpjDUMIPPS9R081i0i3OE10afI42XcKW0ImFgRrYE5FBWx1F2cyHAcIA */
+createMachine({
+  context: {
+    items: [],
+    order: 'desc',
+    duration: 0,
+    activeItem: null
+  },
+  predictableActionArguments: true,
+  id: 'toast',
+  initial: 'idle',
+  states: {
+    idle: {
+      on: {
+        ADD_ITEM: {
+          target: 'adding'
+        }
+      }
+    },
+    active: {
+      invoke: {
+        id: 'timer',
+        src: timerMachine,
+        onDone: {
+          target: 'removing',
+          cond: 'itemHasTimeout'
+        },
+        data: Object.assign(timerMachine.context, {
+          duration: function duration(context) {
+            var _a; // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return
+
+
+            return (_a = context.items[context.items.length - 1].duration) !== null && _a !== void 0 ? _a : context.duration;
+          }
+        })
+      },
+      on: {
+        ADD_ITEM: {
+          // actions: sendTo('timer', 'PAUSE_TIMER'),
+          target: 'adding'
+        },
+        REMOVE_ITEM: {
+          target: 'removing'
+        },
+        SET_IDLE: {
+          target: 'idle'
+        },
+        RESUME_TIMER: {
+          actions: sendTo('timer', 'RESUME_TIMER') // cond: (context) => context.duration > 0,
+
+        },
+        PAUSE_TIMER: {
+          actions: sendTo('timer', 'PAUSE_TIMER') // cond: (context) => context.duration > 0,
+
+        }
+      } // after: {
+      //   ITEM_TIMEOUT: {
+      //     target: 'removing',
+      //     cond: 'itemHasTimeout',
+      //   },
+      // },
+
+    },
+    adding: {
+      entry: ['addItem'],
+      on: {
+        SET_IDLE: {
+          target: 'idle'
+        },
+        SET_ACTIVE: {
+          target: 'active'
+        }
+      }
+    },
+    removing: {
+      entry: 'removeItem',
+      on: {
+        SET_IDLE: {
+          target: 'idle'
+        },
+        SET_ACTIVE: {
+          target: 'active'
+        }
+      }
+    }
+  }
+}, {
+  actions: {
+    addItem: assign(function (context, event) {
+      var _a, _b;
+
+      if (event.type !== 'ADD_ITEM') return;
+      var id = "notification-".concat(crypto.randomBytes(16).toString('hex'));
+      var duration = (_a = event.duration) !== null && _a !== void 0 ? _a : context.duration; // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+
+      var notification = /*#__PURE__*/cloneElement(event.item, Object.assign({
+        duration: duration,
+        id: id,
+        key: (_b = event.item.key) !== null && _b !== void 0 ? _b : id
+      }, event.item.props));
+      var item = {
+        duration: duration,
+        id: id,
+        element: notification
+      };
+
+      if (context.order === 'desc') {
+        context.items.push(item);
+      } else {
+        context.items.unshift(item);
+      }
+
+      context.activeItem = id;
+    }),
+    removeItem: assign(function (context, event) {
+      if (event.type !== 'REMOVE_ITEM' && event.type !== 'xstate.after(ITEM_TIMEOUT)#toast.active' && event.type !== 'done.invoke.timer') return;
+
+      if (context.order === 'desc') {
+        context.items.pop();
+        context.activeItem = context.items.length > 0 ? context.items[context.items.length - 1].id : null;
+      } else {
+        context.items.shift();
+        context.activeItem = context.items.length > 0 ? context.items[0].id : null;
+      }
+    }) // startTimer: sendTo('timer', { type: 'START' }),
+
+  },
+  delays: {
+    ITEM_TIMEOUT: function ITEM_TIMEOUT(context) {
+      var _a; // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+
+
+      return (// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        (_a = context.items[context.items.length - 1].duration) !== null && _a !== void 0 ? _a : context.duration
+      );
+    }
+  },
+  guards: {
+    itemHasTimeout: function itemHasTimeout(context) {
+      return (// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        context.items[context.items.length - 1].duration > 0 || context.duration > 0
+      );
+    }
+  }
+});
+
+var ToastContext = /*#__PURE__*/createContext({});
+var useToast = function useToast() {
+  return useContext(ToastContext);
+};
+function ToastProvider(_ref) {
+  var children = _ref.children,
+      service = _ref.service;
+  // const toastService = interpret(toastMachine, {
+  //   devTools: options.devTools,
+  // }).start(state);
+  // toastService.subscribe((s) => {
+  //   setState(s);
+  // });
+  return jsx(ToastContext.Provider, Object.assign({
+    value: service
+  }, {
+    children: children
+  }));
+}
+
+export { AuthContext, AuthProvider, ToastContext, ToastProvider, authMachine, getAuth, timerMachine, toastMachine, useAuth, useToast, useUser };