@pisell/private-materials 3.0.95 → 3.0.97

package/es/components/eftposPay/store/index.d.ts

@@ -0,0 +1,239 @@
+import React, { ReactNode } from 'react';
+import { DeviceStatusType, StatusType, ModeType } from '../const';
+import { ThunkDispatch } from './useThunkReducer';
+export declare enum EActionTypes {
+    UPDATE_INIT = "UPDATE_INIT",
+    UPDATE_CUSTOM = "UPDATE_CUSTOM",
+    UPDATE_KEY = "UPDATE_KEY",
+    UPDATE_STEP = "UPDATE_STEP",
+    UPDATE_STEP_KEY = "UPDATE_STEP_KEY",
+    UPDATE_DEVICE = "UPDATE_DEVICE",
+    UPDATE_NEXT_STEP = "UPDATE_NEXT_STEP",
+    UPDATE_STATUS = "UPDATE_STATUS",
+    UPDATE_TITLE = "UPDATE_TITLE",
+    UPDATE_LOADING = "UPDATE_LOADING",
+    UPDATE_COMPONENT = "UPDATE_COMPONENT",
+    UPDATE_STEPS = "UPDATE_STEPS",
+    UPDATE_WARN = "UPDATE_WARN",
+    UPDATE_STEP_CURRENT_ITEM_CUSTOM = "UPDATE_STEP_CURRENT_ITEM_CUSTOM",
+    UPDATE_STEP_ITEM_CUSTOM = "UPDATE_STEP_ITEM_CUSTOM",
+    UPDATE_STEP_ITEM = "UPDATE_STEP_ITEM",
+    BACKUP_PRODUCTION = "BACKUP_PRODUCTION",
+    BACKUP_FREE = "BACKUP_FREE"
+}
+export declare type State = {
+    mode: ModeType;
+    /** 厂商 */
+    eftpos: DeviceStatusType;
+    /** 用于重置页面特指 =》全部步骤 */
+    key: number;
+    /** 当前执行到哪一步了 */
+    step: number;
+    /** 标题 */
+    title: string;
+    /** step : 常规步骤页面 ,unset 自定义页面 */
+    type: 'step' | 'unset';
+    render: boolean;
+    /** 上面  unset 自定义页面,这里需要指定到具体页面 */
+    component: string;
+    lastComponent?: string;
+    /** 页面状态 */
+    status: StatusType;
+    /** 警告文案 */
+    warn: ReactNode;
+    steps: {
+        /** 用于重置当前步骤 */
+        key: number;
+        title?: ReactNode;
+        text?: ReactNode;
+        warn?: ReactNode;
+        tip?: ReactNode;
+        success?: ReactNode;
+        fail?: ReactNode;
+        loading?: ReactNode;
+        /** 步骤状态 */
+        status: StatusType;
+        custom?: {
+            /**  厂商自定义 */
+            [key: string]: unknown;
+        };
+    }[];
+    device?: {
+        [key: string]: unknown;
+    };
+    custom?: {
+        [key: string]: unknown;
+    };
+    manual?: {
+        title: string;
+        text: string;
+    };
+    backup?: Omit<State, 'backup'>;
+};
+export declare type Action = {
+    type: EActionTypes;
+    payload: Partial<State>;
+};
+export declare const updateKey: (key: number) => {
+    type: EActionTypes;
+    payload: {
+        key: number;
+    };
+};
+export declare const updateDevice: (payload: {
+    device: State['device'];
+}) => {
+    type: EActionTypes;
+    payload: {
+        device: State['device'];
+    };
+};
+export declare const updateStepKey: () => {
+    type: EActionTypes;
+    payload: {};
+};
+export declare const updateNextStep: (warn?: string) => {
+    type: EActionTypes;
+    payload: {
+        warn: string;
+    } | {
+        warn?: undefined;
+    };
+};
+export declare const updateStep: (payload: {
+    step: number;
+    warn?: ReactNode;
+}) => {
+    type: EActionTypes;
+    payload: {
+        step: number;
+        warn?: ReactNode;
+    };
+};
+export declare const updateCustom: (payload: {
+    [key: string]: unknown;
+}) => {
+    type: EActionTypes;
+    payload: {
+        [key: string]: unknown;
+    };
+};
+export declare const updateStatus: (status: 'loading' | 'warn' | 'fail' | 'success' | 'question') => {
+    type: EActionTypes;
+    payload: {
+        status: "loading" | "success" | "warn" | "fail" | "question";
+    };
+};
+export declare const updateWarn: (warn: ReactNode) => {
+    type: EActionTypes;
+    payload: {
+        warn: React.ReactNode;
+    };
+};
+export declare const updateComponent: (component: string, render?: boolean) => {
+    type: EActionTypes;
+    payload: {
+        readonly component: string;
+        readonly type: "unset";
+        readonly render: boolean;
+    } | {
+        readonly type: "step";
+        readonly render: boolean;
+        readonly component?: undefined;
+    };
+};
+export declare const updateSteps: (steps: State['steps']) => {
+    type: EActionTypes;
+    payload: {
+        steps: {
+            /** 用于重置当前步骤 */
+            key: number;
+            title?: ReactNode;
+            text?: ReactNode;
+            warn?: ReactNode;
+            tip?: ReactNode;
+            success?: ReactNode;
+            fail?: ReactNode;
+            loading?: ReactNode;
+            /** 步骤状态 */
+            status: StatusType;
+            custom?: {
+                [key: string]: unknown;
+            } | undefined;
+        }[];
+    };
+};
+export declare const updateState: (payload: Partial<State>) => {
+    type: EActionTypes;
+    payload: Partial<State>;
+};
+export declare const updateCurrentCustomStemItem: (payload: NonNullable<Partial<State['steps'][number]['custom']>>) => {
+    type: EActionTypes;
+    payload: Partial<{
+        [key: string]: unknown;
+    }>;
+};
+export declare const updateCustomStemItem: (payload: NonNullable<Partial<State['steps'][number]['custom']>>) => {
+    type: EActionTypes;
+    payload: Partial<{
+        [key: string]: unknown;
+    }>;
+};
+export declare const updateCurrentStemItem: (payload: any) => {
+    type: EActionTypes;
+    payload: any;
+};
+export declare const backUpProduction: (payload: Partial<State>) => {
+    type: EActionTypes;
+    payload: Partial<State>;
+};
+export declare const backUpFree: (payload: Partial<State>) => {
+    type: EActionTypes;
+    payload: {
+        mode?: "refund" | "pay" | "query" | undefined;
+        eftpos?: "payo" | "tyro" | "windcave" | "stripe" | "eftpos" | undefined;
+        key?: number | undefined;
+        step?: number | undefined;
+        title?: string | undefined;
+        type?: "unset" | "step" | undefined;
+        render?: boolean | undefined;
+        component?: string | undefined;
+        lastComponent?: string | undefined;
+        status?: "loading" | "success" | "warn" | "fail" | "pedding" | "resove" | "reject" | "question" | undefined;
+        warn?: ReactNode;
+        steps?: {
+            /** 用于重置当前步骤 */
+            key: number;
+            title?: ReactNode;
+            text?: ReactNode;
+            warn?: ReactNode;
+            tip?: ReactNode;
+            success?: ReactNode;
+            fail?: ReactNode;
+            loading?: ReactNode;
+            /** 步骤状态 */
+            status: StatusType;
+            custom?: {
+                [key: string]: unknown;
+            } | undefined;
+        }[] | undefined;
+        device?: {
+            [key: string]: unknown;
+        } | undefined;
+        custom?: {
+            [key: string]: unknown;
+        } | undefined;
+        manual?: {
+            title: string;
+            text: string;
+        } | undefined;
+        backup?: Omit<State, "backup"> | undefined;
+    };
+};
+export declare function reducers(state: State, action: Action): State;
+export declare const Provider: ({ children, state: providerState, }: {
+    children: ReactNode;
+    state?: State | undefined;
+}) => React.JSX.Element;
+export declare function useContextData(): State;
+export declare function useDispatch(): ThunkDispatch<State, Action>;

package/es/components/eftposPay/store/index.js

@@ -0,0 +1,304 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(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 _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectDestructuringEmpty(obj) { if (obj == null) throw new TypeError("Cannot destructure " + obj); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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 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) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable no-case-declarations */
+import React, { createContext, useContext } from 'react';
+import { StatusEnum, ModeEnum, PayRouteEnum } from "../const";
+import { cloneDeep } from "../helper";
+import useThunkReducer from "./useThunkReducer";
+export var EActionTypes;
+(function (EActionTypes) {
+  EActionTypes["UPDATE_INIT"] = "UPDATE_INIT";
+  EActionTypes["UPDATE_CUSTOM"] = "UPDATE_CUSTOM";
+  EActionTypes["UPDATE_KEY"] = "UPDATE_KEY";
+  EActionTypes["UPDATE_STEP"] = "UPDATE_STEP";
+  EActionTypes["UPDATE_STEP_KEY"] = "UPDATE_STEP_KEY";
+  EActionTypes["UPDATE_DEVICE"] = "UPDATE_DEVICE";
+  EActionTypes["UPDATE_NEXT_STEP"] = "UPDATE_NEXT_STEP";
+  EActionTypes["UPDATE_STATUS"] = "UPDATE_STATUS";
+  EActionTypes["UPDATE_TITLE"] = "UPDATE_TITLE";
+  EActionTypes["UPDATE_LOADING"] = "UPDATE_LOADING";
+  EActionTypes["UPDATE_COMPONENT"] = "UPDATE_COMPONENT";
+  EActionTypes["UPDATE_STEPS"] = "UPDATE_STEPS";
+  EActionTypes["UPDATE_WARN"] = "UPDATE_WARN";
+  EActionTypes["UPDATE_STEP_CURRENT_ITEM_CUSTOM"] = "UPDATE_STEP_CURRENT_ITEM_CUSTOM";
+  EActionTypes["UPDATE_STEP_ITEM_CUSTOM"] = "UPDATE_STEP_ITEM_CUSTOM";
+  EActionTypes["UPDATE_STEP_ITEM"] = "UPDATE_STEP_ITEM";
+  EActionTypes["BACKUP_PRODUCTION"] = "BACKUP_PRODUCTION";
+  EActionTypes["BACKUP_FREE"] = "BACKUP_FREE";
+})(EActionTypes || (EActionTypes = {}));
+export var updateKey = function updateKey(key) {
+  return {
+    type: EActionTypes.UPDATE_KEY,
+    payload: {
+      key: key
+    }
+  };
+};
+export var updateDevice = function updateDevice(payload) {
+  return {
+    type: EActionTypes.UPDATE_DEVICE,
+    payload: payload
+  };
+};
+export var updateStepKey = function updateStepKey() {
+  return {
+    type: EActionTypes.UPDATE_STEP_KEY,
+    payload: {}
+  };
+};
+export var updateNextStep = function updateNextStep(warn) {
+  return {
+    type: EActionTypes.UPDATE_NEXT_STEP,
+    payload: warn ? {
+      warn: warn
+    } : {}
+  };
+};
+export var updateStep = function updateStep(payload) {
+  return {
+    type: EActionTypes.UPDATE_STEP,
+    payload: payload
+  };
+};
+export var updateCustom = function updateCustom(payload) {
+  return {
+    type: EActionTypes.UPDATE_CUSTOM,
+    payload: payload
+  };
+};
+export var updateStatus = function updateStatus(status) {
+  return {
+    type: EActionTypes.UPDATE_LOADING,
+    payload: {
+      status: status
+    }
+  };
+};
+export var updateWarn = function updateWarn(warn) {
+  return {
+    type: EActionTypes.UPDATE_WARN,
+    payload: {
+      warn: warn
+    }
+  };
+};
+export var updateComponent = function updateComponent(component, render) {
+  return {
+    type: EActionTypes.UPDATE_COMPONENT,
+    payload: component ? {
+      component: component,
+      type: 'unset',
+      render: typeof render === 'boolean' ? render : false
+    } : {
+      type: 'step',
+      render: typeof render === 'boolean' ? render : true
+    }
+  };
+};
+export var updateSteps = function updateSteps(steps) {
+  return {
+    type: EActionTypes.UPDATE_STEPS,
+    payload: {
+      steps: steps
+    }
+  };
+};
+export var updateState = function updateState(payload) {
+  return {
+    type: EActionTypes.UPDATE_INIT,
+    payload: payload
+  };
+};
+export var updateCurrentCustomStemItem = function updateCurrentCustomStemItem(payload) {
+  return {
+    type: EActionTypes.UPDATE_STEP_CURRENT_ITEM_CUSTOM,
+    payload: payload
+  };
+};
+export var updateCustomStemItem = function updateCustomStemItem(payload) {
+  return {
+    type: EActionTypes.UPDATE_STEP_ITEM_CUSTOM,
+    payload: payload
+  };
+};
+export var updateCurrentStemItem = function updateCurrentStemItem(payload) {
+  return {
+    type: EActionTypes.UPDATE_STEP_ITEM,
+    payload: payload
+  };
+};
+export var backUpProduction = function backUpProduction(payload) {
+  return {
+    type: EActionTypes.BACKUP_PRODUCTION,
+    payload: payload
+  };
+};
+export var backUpFree = function backUpFree(payload) {
+  return {
+    type: EActionTypes.BACKUP_FREE,
+    payload: _objectSpread({}, payload)
+  };
+};
+var initialState = {
+  mode: ModeEnum.Pay,
+  eftpos: '',
+  key: 0,
+  step: 0,
+  type: PayRouteEnum.Step,
+  title: 'Processing ...',
+  component: '',
+  status: StatusEnum.Loading,
+  steps: [],
+  warn: '',
+  render: true
+};
+var StateContext = /*#__PURE__*/createContext(undefined);
+var DispatchContext = /*#__PURE__*/createContext(undefined);
+export function reducers(state, action) {
+  switch (action.type) {
+    case EActionTypes.UPDATE_INIT:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_NEXT_STEP:
+      // eslint-disable-next-line no-case-declarations
+      var currentStep = state.step + 1;
+      if (state.step === state.steps.length - 1) {
+        state.steps[state.steps.length - 1].status = 'success';
+        return _objectSpread(_objectSpread({}, state), {}, {
+          status: 'success',
+          steps: _toConsumableArray(state.steps)
+        });
+      }
+      state.steps[state.step].status = 'success';
+      return _objectSpread(_objectSpread({}, state), {}, {
+        warn: action.payload.warn || '',
+        steps: _toConsumableArray(state.steps),
+        status: state.steps[currentStep].status,
+        step: currentStep
+      });
+    case EActionTypes.UPDATE_KEY:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_STEP:
+      if (state.type === 'unset') {
+        return state;
+      }
+      var _ref = action.payload,
+        step = _ref.step;
+      state.steps.forEach(function (s, index) {
+        if (index < step) {
+          s.status = 'success';
+        }
+      });
+      var current = step < state.steps.length - 1 ? step : state.steps.length - 1;
+      console.log('current ', current);
+      return _objectSpread(_objectSpread({}, state), {
+        step: current,
+        warn: action.payload.warn || '',
+        status: state.steps[current].status,
+        steps: _toConsumableArray(state.steps)
+      });
+    case EActionTypes.UPDATE_LOADING:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_COMPONENT:
+      return _objectSpread(_objectSpread(_objectSpread({}, state), action.payload), {}, {
+        lastComponent: state.component
+      });
+    case EActionTypes.UPDATE_STEPS:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_STEP_ITEM:
+      state.steps[state.step] = _objectSpread(_objectSpread({}, state.steps[state.step]), action.payload);
+      return _objectSpread(_objectSpread({}, state), {}, {
+        steps: _toConsumableArray(state.steps)
+      });
+    case EActionTypes.UPDATE_WARN:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_STEP_CURRENT_ITEM_CUSTOM:
+      if (state.steps[state.step].custom) {
+        state.steps[state.step].custom = _objectSpread(_objectSpread({}, state.steps[state.step].custom), action.payload);
+      } else {
+        state.steps[state.step].custom = _objectSpread({}, action.payload);
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        steps: _toConsumableArray(state.steps)
+      });
+    case EActionTypes.UPDATE_STEP_ITEM_CUSTOM:
+      var index = action.payload.step;
+      var custom = action.payload.custom;
+      if (state.steps[index].custom) {
+        state.steps[index].custom = _objectSpread(_objectSpread({}, state.steps[index].custom), custom);
+      } else {
+        state.steps[index].custom = _objectSpread({}, custom);
+      }
+      return _objectSpread(_objectSpread({}, state), {}, {
+        steps: _toConsumableArray(state.steps)
+      });
+    case EActionTypes.UPDATE_STEP_KEY:
+      state.steps[state.step].key = Date.now();
+      return _objectSpread(_objectSpread({}, state), {}, {
+        steps: _toConsumableArray(state.steps)
+      });
+    case EActionTypes.UPDATE_DEVICE:
+      return _objectSpread(_objectSpread({}, state), action.payload);
+    case EActionTypes.UPDATE_CUSTOM:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        custom: state.custom ? _objectSpread(_objectSpread({}, state.custom), action.payload) : _objectSpread({}, action.payload)
+        // ,
+      });
+
+    case EActionTypes.BACKUP_PRODUCTION:
+      return _objectSpread(_objectSpread({}, state), {}, {
+        backup: cloneDeep(state)
+      });
+    case EActionTypes.BACKUP_FREE:
+      if (!state.backup) {
+        return state;
+      }
+      var s = Object.assign({}, (_objectDestructuringEmpty(state.backup), state.backup));
+      return _objectSpread(_objectSpread({}, s), action.payload);
+    default:
+      {
+        throw new Error("Unhandled action type: ".concat(action.type));
+      }
+  }
+}
+export var Provider = function Provider(_ref2) {
+  var children = _ref2.children,
+    providerState = _ref2.state;
+  var _useThunkReducer = useThunkReducer(reducers, providerState || initialState),
+    _useThunkReducer2 = _slicedToArray(_useThunkReducer, 2),
+    state = _useThunkReducer2[0],
+    dispatch = _useThunkReducer2[1];
+  return /*#__PURE__*/React.createElement(StateContext.Provider, {
+    value: state
+  }, /*#__PURE__*/React.createElement(DispatchContext.Provider, {
+    value: dispatch
+  }, children));
+};
+export function useContextData() {
+  var context = useContext(StateContext);
+  if (context === undefined) {
+    throw new Error('useState must be used within a Provider');
+  }
+  return context;
+}
+export function useDispatch() {
+  var context = useContext(DispatchContext);
+  if (context === undefined) {
+    throw new Error('useDispatch must be used within a Provider');
+  }
+  return context;
+}

package/es/components/eftposPay/store/useThunkReducer.d.ts

@@ -0,0 +1,9 @@
+import { Reducer } from 'react';
+export default function useThunkReducer<State, Action extends {
+    [P in keyof Action]: Action[P];
+}>(reducer: Reducer<State, Action>, initialArg: State, init?: (s: State) => State): [State, ThunkDispatch<State, Action>];
+export interface ThunkDispatch<State, Action> {
+    <TReturnType>(ThunkAction: ThunkAction<TReturnType, State, Action>): TReturnType;
+    (action: Action): void;
+}
+export declare type ThunkAction<TReturnType, State, Action> = (dispatch: ThunkDispatch<State, Action>, getState: () => State) => TReturnType;

package/es/components/eftposPay/store/useThunkReducer.js

@@ -0,0 +1,31 @@
+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 = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useRef, useState } from 'react';
+export default function useThunkReducer(reducer, initialArg, init) {
+  var _useState = useState(init ? init(initialArg) : initialArg),
+    _useState2 = _slicedToArray(_useState, 2),
+    hookState = _useState2[0],
+    setHookState = _useState2[1];
+  var state = useRef(hookState);
+  var getState = useCallback(function () {
+    return state.current;
+  }, [state]);
+  var setState = useCallback(function (newState) {
+    state.current = newState;
+    setHookState(newState);
+  }, [state, setHookState]);
+  var reduce = useCallback(function (action) {
+    return reducer(getState(), action);
+  }, [reducer, getState]);
+  var dispatch = useCallback(function (action) {
+    if (typeof action === 'function') {
+      return action(dispatch, getState);
+    }
+    setState(reduce(action));
+  }, [getState, setState, reduce]);
+  return [hookState, dispatch];
+}

package/es/components/eftposPay/windcave/action.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+declare const _default: ({ index, api, }: {
+    index: number;
+    api: {
+        [key: string]: (...agrn: unknown[]) => Promise<unknown>;
+    };
+}) => React.JSX.Element;
+export default _default;