@stakekit/widget 0.0.2 → 0.0.3

package/dist/package/index.package.js

@@ -125,7 +125,7 @@ i18n.use(initReactI18next).use(LanguageDetector).init({
 
 // src/App.tsx
 import ReactDOM from "react-dom/client";
-import { useEffect as useEffect10 } from "react";
+import { useEffect as useEffect11 } from "react";
 import { Navigate, Route, Routes } from "react-router-dom";
 
 // src/hooks/use-color-scheme.ts
@@ -3278,12 +3278,192 @@ var ReviewPage = () => {
 import { useTranslation as useTranslation10 } from "react-i18next";
 
 // src/pages/steps/use-steps.ts
-import { useEffect as useEffect8 } from "react";
+import { useEffect as useEffect9 } from "react";
 import { useNavigate as useNavigate5 } from "react-router-dom";
 
 // src/pages/steps/use-steps-machine.ts
 import { EitherAsync as EitherAsync5, Left as Left4, Right as Right4 } from "purify-ts";
-import useStateMachine, { t } from "@cassiozen/usestatemachine";
+
+// node_modules/@cassiozen/usestatemachine/dist/usestatemachine.esm.js
+import { useRef as useRef4, useReducer as useReducer2, useEffect as useEffect8 } from "react";
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+var $$t = /* @__PURE__ */ Symbol("$$t");
+var A;
+(function(A2) {
+  var Get;
+  /* @__PURE__ */ (function(Get2) {
+  })(Get = A2.Get || (A2.Get = {}));
+  A2.test = function(_o) {
+  };
+  A2.areEqual = function(_debug) {
+    return void 0;
+  };
+})(A || (A = {}));
+var R = {
+  get: function get(r, k) {
+    return r[k];
+  },
+  concat: function concat(r1, r2) {
+    return _extends({}, r1, r2);
+  },
+  fromMaybe: function fromMaybe(r) {
+    return r != null ? r : {};
+  },
+  keys: function keys(r) {
+    return Object.keys(r);
+  }
+};
+var useConstant = function useConstant2(compute) {
+  var ref = useRef4(null);
+  if (ref.current === null)
+    ref.current = compute();
+  return ref.current;
+};
+var assertNever = function assertNever2(_value) {
+  throw new Error("Invariant: assertNever was called");
+};
+var useStateMachineImpl = function useStateMachineImpl2(definition) {
+  var _useReducer = useReducer2(createReducer(definition), createInitialState(definition)), state = _useReducer[0], dispatch = _useReducer[1];
+  var send = useConstant(function() {
+    return function(sendable) {
+      return dispatch({
+        type: "SEND",
+        sendable
+      });
+    };
+  });
+  var setContext = function setContext2(updater) {
+    dispatch({
+      type: "SET_CONTEXT",
+      updater
+    });
+    return {
+      send
+    };
+  };
+  useEffect8(function() {
+    var entry = R.get(definition.states, state.value).effect;
+    var exit = entry == null ? void 0 : entry({
+      send,
+      setContext,
+      event: state.event,
+      context: state.context
+    });
+    return typeof exit === "function" ? function() {
+      return exit == null ? void 0 : exit({
+        send,
+        setContext,
+        event: state.event,
+        context: state.context
+      });
+    } : void 0;
+  }, [state.value, state.event]);
+  return [state, send];
+};
+var createInitialState = function createInitialState2(definition) {
+  var nextEvents = R.keys(R.concat(R.fromMaybe(R.get(definition.states, definition.initial).on), R.fromMaybe(definition.on)));
+  return {
+    value: definition.initial,
+    context: definition.context,
+    event: {
+      type: "$$initial"
+    },
+    nextEvents,
+    nextEventsT: nextEvents
+  };
+};
+var createReducer = function createReducer2(definition) {
+  var log = createLogger(definition);
+  return function(machineState, internalEvent) {
+    if (internalEvent.type === "SET_CONTEXT") {
+      var nextContext = internalEvent.updater(machineState.context);
+      log("Context update", ["Previous Context", machineState.context], ["Next Context", nextContext]);
+      return _extends({}, machineState, {
+        context: nextContext
+      });
+    }
+    if (internalEvent.type === "SEND") {
+      var _R$get;
+      var sendable = internalEvent.sendable;
+      var event = typeof sendable === "string" ? {
+        type: sendable
+      } : sendable;
+      var context = machineState.context;
+      var stateNode = R.get(definition.states, machineState.value);
+      var resolvedTransition = (_R$get = R.get(R.fromMaybe(stateNode.on), event.type)) != null ? _R$get : R.get(R.fromMaybe(definition.on), event.type);
+      if (!resolvedTransition) {
+        log(`Current state doesn't listen to event type "` + event.type + '".', ["Current State", machineState], ["Event", event]);
+        return machineState;
+      }
+      var _ref = function() {
+        if (typeof resolvedTransition === "string")
+          return [resolvedTransition];
+        if (resolvedTransition.guard === void 0)
+          return [resolvedTransition.target];
+        if (resolvedTransition.guard({
+          context,
+          event
+        }))
+          return [resolvedTransition.target];
+        return [resolvedTransition.target, true];
+      }(), nextStateValue = _ref[0], _ref$ = _ref[1], didGuardDeny = _ref$ === void 0 ? false : _ref$;
+      if (didGuardDeny) {
+        log('Transition from "' + machineState.value + '" to "' + nextStateValue + '" denied by guard', ["Event", event], ["Context", context]);
+        return machineState;
+      }
+      log('Transition from "' + machineState.value + '" to "' + nextStateValue + '"', ["Event", event]);
+      var resolvedStateNode = R.get(definition.states, nextStateValue);
+      var nextEvents = R.keys(R.concat(R.fromMaybe(resolvedStateNode.on), R.fromMaybe(definition.on)));
+      return {
+        value: nextStateValue,
+        context,
+        event,
+        nextEvents,
+        nextEventsT: nextEvents
+      };
+    }
+    return assertNever();
+  };
+};
+var defaultConsole = console;
+var createLogger = function createLogger2(definition) {
+  return function(groupLabel) {
+    if (!definition.verbose)
+      return;
+    var console2 = definition.console || defaultConsole;
+    if (true) {
+      console2.groupCollapsed == null ? void 0 : console2.groupCollapsed("%cuseStateMachine", "color: #888; font-weight: lighter;", groupLabel);
+      for (var _len = arguments.length, nested = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        nested[_key - 1] = arguments[_key];
+      }
+      nested.forEach(function(message) {
+        console2.log(message[0], message[1]);
+      });
+      console2.groupEnd == null ? void 0 : console2.groupEnd();
+    }
+  };
+};
+var useStateMachine = useStateMachineImpl;
+var t = function t2() {
+  var _ref2;
+  return _ref2 = {}, _ref2[$$t] = void 0, _ref2;
+};
+var usestatemachine_esm_default = useStateMachine;
+
+// src/pages/steps/use-steps-machine.ts
 import {
   stakeGetStakeSession,
   transactionConstruct as transactionConstruct2,
@@ -3294,7 +3474,7 @@ var tt = t;
 var useStepsMachine = () => {
   const { gasModeValue } = useAppState();
   const { sendTransaction } = useSKWallet();
-  return useStateMachine({
+  return usestatemachine_esm_default({
     initial: "idle",
     schema: {
       context: tt(),
@@ -3429,19 +3609,19 @@ var useSteps = () => {
   const navigate = useNavigate5();
   const [machine, send] = useStepsMachine();
   const id2 = stakeSession.map((val) => val.id).extractNullable();
-  useEffect8(() => {
+  useEffect9(() => {
     if (!id2)
       return;
     send({ type: "START", id: id2 });
   }, [id2, send]);
-  useEffect8(() => {
+  useEffect9(() => {
     return () => {
       const timeoutId = machine.context.txCheckTimeoutId;
       if (timeoutId)
         clearTimeout(timeoutId);
     };
   }, [machine.context.txCheckTimeoutId]);
-  useEffect8(() => {
+  useEffect9(() => {
     if (machine.value === "done") {
       navigate("/complete", { state: { urls: machine.context.urls } });
     }
@@ -3727,14 +3907,13 @@ var StepsPage = () => {
 };
 
 // src/hooks/use-webview-connect-machine.ts
-import useStateMachine2, { t as t2 } from "@cassiozen/usestatemachine";
 import { useAccount as useAccount2, useConnect } from "wagmi";
 import { InjectedConnector } from "@wagmi/connectors/injected";
-var tt2 = t2;
+var tt2 = t;
 var useWebViewConnectMachine = () => {
   const { isConnected } = useAccount2();
   const { connectors, connect } = useConnect();
-  return useStateMachine2({
+  return usestatemachine_esm_default({
     schema: { context: tt2() },
     initial: "connect",
     context: { timeoutId: null },
@@ -3772,7 +3951,7 @@ var useWebViewConnectMachine = () => {
 };
 
 // src/hooks/use-location-transition-animation/index.ts
-import { useCallback as useCallback4, useEffect as useEffect9, useState as useState7 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect10, useState as useState7 } from "react";
 import { useLocation as useLocation3 } from "react-router-dom";
 
 // src/hooks/use-location-transition-animation/style.css.ts
@@ -3788,7 +3967,7 @@ var useLocationTransitionAnimation = () => {
   const location = useLocation3();
   const [displayLocation, setDisplayLocation] = useState7(location);
   const [transitionStage, setTransitionStage] = useState7("fadeIn");
-  useEffect9(() => {
+  useEffect10(() => {
     if (location !== displayLocation)
       setTransitionStage("fadeOut");
   }, [location, displayLocation]);
@@ -4433,7 +4612,7 @@ var Widget = () => {
   const { selectedStake, stakeAmount } = useAppState();
   const isDetailsComplete = selectedStake.chain(() => stakeAmount.map((a) => !a.isZero() && !a.isNaN())).extractNullable();
   const [, send] = useWebViewConnectMachine();
-  useEffect10(() => {
+  useEffect11(() => {
     if (isConnected || isConnecting)
       return;
     send("CONNECT");