@sincpro/mobile-ui 3.0.0 → 3.1.0

package/dist/views/Wizard/Wizard.context.js

@@ -1,92 +1,256 @@
-import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { ErrorBoundary } from "../../Feedback/index.js";
+import { Typography } from "../../Typography/index.js";
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
-import { ActivityIndicator, Text, View } from "react-native";
+import { ActivityIndicator, View } from "react-native";
+import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
 const WizardContext = createContext(null);
-export function WizardProvider({ children, initialStep, steps = [], onComplete, onCancel, isLoading = false, loadingMessage, }) {
-    const [currentStep, setCurrentStep] = useState(initialStep);
-    const [stepHistory, setStepHistory] = useState([initialStep]);
-    const goToStep = useCallback((step) => {
-        setStepHistory((prev) => [...prev, step]);
-        setCurrentStep(step);
-    }, []);
-    const back = useCallback(() => {
-        setStepHistory((prev) => {
-            if (prev.length <= 1)
-                return prev;
-            const newHistory = prev.slice(0, -1);
-            const previousStep = newHistory[newHistory.length - 1];
-            setCurrentStep(previousStep);
-            return newHistory;
-        });
-    }, []);
-    const next = useCallback(() => {
-        if (steps.length === 0)
-            return;
-        const currentIndex = steps.indexOf(currentStep);
-        if (currentIndex === -1 || currentIndex === steps.length - 1) {
-            onComplete?.();
-            return;
+export function WizardProvider(t0) {
+  const $ = _c(39);
+  const {
+    children,
+    initialStep,
+    steps: t1,
+    onComplete,
+    isLoading: t2,
+    loadingMessage
+  } = t0;
+  let t3;
+  if ($[0] !== t1) {
+    t3 = t1 === undefined ? [] : t1;
+    $[0] = t1;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  const steps = t3;
+  const isLoading = t2 === undefined ? false : t2;
+  const [currentStep, setCurrentStep] = useState(initialStep);
+  let t4;
+  if ($[2] !== initialStep) {
+    t4 = [initialStep];
+    $[2] = initialStep;
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  const [stepHistory, setStepHistory] = useState(t4);
+  let t5;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = step => {
+      setStepHistory(prev => [...prev, step]);
+      setCurrentStep(step);
+    };
+    $[4] = t5;
+  } else {
+    t5 = $[4];
+  }
+  const goToStep = t5;
+  let t6;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = () => {
+      setStepHistory(prev_0 => {
+        if (prev_0.length <= 1) {
+          return prev_0;
         }
-        const nextStep = steps[currentIndex + 1];
-        goToStep(nextStep);
-    }, [currentStep, steps, goToStep, onComplete]);
-    const reset = useCallback((step) => {
-        const targetStep = step ?? initialStep;
-        setCurrentStep(targetStep);
-        setStepHistory([targetStep]);
-    }, [initialStep]);
-    const canGoBack = useMemo(() => stepHistory.length > 1, [stepHistory.length]);
-    const canGoNext = useMemo(() => {
-        if (steps.length === 0)
-            return false;
-        const currentIndex = steps.indexOf(currentStep);
-        return currentIndex !== -1 && currentIndex < steps.length - 1;
-    }, [currentStep, steps]);
-    const currentStepIndex = useMemo(() => {
-        if (steps.length === 0)
-            return 0;
-        return steps.indexOf(currentStep);
-    }, [currentStep, steps]);
-    const progress = useMemo(() => {
-        if (steps.length === 0)
-            return 0;
-        return ((currentStepIndex + 1) / steps.length) * 100;
-    }, [currentStepIndex, steps.length]);
-    const value = useMemo(() => ({
-        currentStep,
-        stepHistory,
-        goToStep,
-        back,
-        next,
-        reset,
-        canGoBack,
-        canGoNext,
-        totalSteps: steps.length,
-        currentStepIndex,
-        progress,
-    }), [
-        currentStep,
-        stepHistory,
-        goToStep,
-        back,
-        next,
-        reset,
-        canGoBack,
-        canGoNext,
-        steps.length,
-        currentStepIndex,
-        progress,
-    ]);
-    if (isLoading) {
-        return (_jsx(ErrorBoundary, { children: _jsxs(View, { className: "flex-1", children: [_jsx(WizardContext.Provider, { value: value, children: children }), _jsx(View, { className: "absolute inset-0 bg-black/50 justify-center items-center", children: _jsxs(View, { className: "bg-bg-card rounded-xl p-6 min-w-[200px] items-center shadow-lg", children: [_jsx(ActivityIndicator, { className: "text-warning", size: "large" }), loadingMessage && (_jsx(Text, { className: "mt-4 text-base text-text-primary text-center", children: loadingMessage }))] }) })] }) }));
+        const newHistory = prev_0.slice(0, -1);
+        const previousStep = newHistory[newHistory.length - 1];
+        setCurrentStep(previousStep);
+        return newHistory;
+      });
+    };
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  const back = t6;
+  let t7;
+  if ($[6] !== currentStep || $[7] !== onComplete || $[8] !== steps) {
+    t7 = () => {
+      if (steps.length === 0) {
+        return;
+      }
+      const currentIndex = steps.indexOf(currentStep);
+      if (currentIndex === -1 || currentIndex === steps.length - 1) {
+        onComplete?.();
+        return;
+      }
+      const nextStep = steps[currentIndex + 1];
+      goToStep(nextStep);
+    };
+    $[6] = currentStep;
+    $[7] = onComplete;
+    $[8] = steps;
+    $[9] = t7;
+  } else {
+    t7 = $[9];
+  }
+  const next = t7;
+  let t8;
+  if ($[10] !== initialStep) {
+    t8 = step_0 => {
+      const targetStep = step_0 ?? initialStep;
+      setCurrentStep(targetStep);
+      setStepHistory([targetStep]);
+    };
+    $[10] = initialStep;
+    $[11] = t8;
+  } else {
+    t8 = $[11];
+  }
+  const reset = t8;
+  const canGoBack = stepHistory.length > 1;
+  let t9;
+  bb0: {
+    if (steps.length === 0) {
+      t9 = false;
+      break bb0;
+    }
+    const currentIndex_0 = steps.indexOf(currentStep);
+    t9 = currentIndex_0 !== -1 && currentIndex_0 < steps.length - 1;
+  }
+  const canGoNext = t9;
+  let t10;
+  bb1: {
+    if (steps.length === 0) {
+      t10 = 0;
+      break bb1;
+    }
+    let t11;
+    if ($[12] !== currentStep || $[13] !== steps) {
+      t11 = steps.indexOf(currentStep);
+      $[12] = currentStep;
+      $[13] = steps;
+      $[14] = t11;
+    } else {
+      t11 = $[14];
+    }
+    t10 = t11;
+  }
+  const currentStepIndex = t10;
+  let t11;
+  bb2: {
+    if (steps.length === 0) {
+      t11 = 0;
+      break bb2;
+    }
+    t11 = (currentStepIndex + 1) / steps.length * 100;
+  }
+  const progress = t11;
+  let t12;
+  if ($[15] !== canGoBack || $[16] !== canGoNext || $[17] !== currentStep || $[18] !== currentStepIndex || $[19] !== next || $[20] !== progress || $[21] !== reset || $[22] !== stepHistory || $[23] !== steps.length) {
+    t12 = {
+      currentStep,
+      stepHistory,
+      goToStep,
+      back,
+      next,
+      reset,
+      canGoBack,
+      canGoNext,
+      totalSteps: steps.length,
+      currentStepIndex,
+      progress
+    };
+    $[15] = canGoBack;
+    $[16] = canGoNext;
+    $[17] = currentStep;
+    $[18] = currentStepIndex;
+    $[19] = next;
+    $[20] = progress;
+    $[21] = reset;
+    $[22] = stepHistory;
+    $[23] = steps.length;
+    $[24] = t12;
+  } else {
+    t12 = $[24];
+  }
+  const value = t12;
+  if (isLoading) {
+    let t13;
+    if ($[25] !== children || $[26] !== value) {
+      t13 = _jsx(WizardContext.Provider, {
+        value: value,
+        children: children
+      });
+      $[25] = children;
+      $[26] = value;
+      $[27] = t13;
+    } else {
+      t13 = $[27];
     }
-    return (_jsx(ErrorBoundary, { children: _jsx(WizardContext.Provider, { value: value, children: children }) }));
+    let t14;
+    if ($[28] === Symbol.for("react.memo_cache_sentinel")) {
+      t14 = _jsx(ActivityIndicator, {
+        className: "text-warning",
+        size: "large"
+      });
+      $[28] = t14;
+    } else {
+      t14 = $[28];
+    }
+    let t15;
+    if ($[29] !== loadingMessage) {
+      t15 = loadingMessage && _jsx(Typography.Text, {
+        align: "center",
+        className: "mt-4",
+        children: loadingMessage
+      });
+      $[29] = loadingMessage;
+      $[30] = t15;
+    } else {
+      t15 = $[30];
+    }
+    let t16;
+    if ($[31] !== t15) {
+      t16 = _jsx(View, {
+        className: "absolute inset-0 bg-black/50 justify-center items-center",
+        children: _jsxs(View, {
+          className: "bg-bg-card rounded-xl p-6 min-w-[200px] items-center shadow-lg",
+          children: [t14, t15]
+        })
+      });
+      $[31] = t15;
+      $[32] = t16;
+    } else {
+      t16 = $[32];
+    }
+    let t17;
+    if ($[33] !== t13 || $[34] !== t16) {
+      t17 = _jsx(ErrorBoundary, {
+        children: _jsxs(View, {
+          className: "flex-1",
+          children: [t13, t16]
+        })
+      });
+      $[33] = t13;
+      $[34] = t16;
+      $[35] = t17;
+    } else {
+      t17 = $[35];
+    }
+    return t17;
+  }
+  let t13;
+  if ($[36] !== children || $[37] !== value) {
+    t13 = _jsx(ErrorBoundary, {
+      children: _jsx(WizardContext.Provider, {
+        value: value,
+        children: children
+      })
+    });
+    $[36] = children;
+    $[37] = value;
+    $[38] = t13;
+  } else {
+    t13 = $[38];
+  }
+  return t13;
 }
 export function useWizard() {
-    const context = useContext(WizardContext);
-    if (!context) {
-        throw new Error("useWizard must be used within WizardProvider");
-    }
-    return context;
+  const context = useContext(WizardContext);
+  if (!context) {
+    throw new Error("useWizard must be used within WizardProvider");
+  }
+  return context;
 }

package/dist/views/Wizard/Wizard.js

@@ -1,86 +1,279 @@
-import { jsx as _jsx, Fragment as _Fragment } from "nativewind/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
 import { useWizard, WizardProvider } from "./Wizard.context.js";
 import { useEffect } from "react";
 import { TouchableOpacity } from "react-native";
-const WizardRoot = (props) => {
-    return _jsx(WizardProvider, { ...props });
+import { jsx as _jsx, Fragment as _Fragment } from "nativewind/jsx-runtime";
+const WizardRoot = props => {
+  const $ = _c(2);
+  let t0;
+  if ($[0] !== props) {
+    t0 = _jsx(WizardProvider, {
+      ...props
+    });
+    $[0] = props;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
 };
-const WizardStep = ({ name, children, canEnter, onEnterFailed, onEnter, onExit, }) => {
-    const wizard = useWizard();
-    useEffect(() => {
-        if (wizard.currentStep === name) {
-            const checkAndEnter = async () => {
-                if (canEnter) {
-                    const allowed = await canEnter();
-                    if (!allowed) {
-                        onEnterFailed?.();
-                        wizard.back();
-                        return;
-                    }
-                }
-                await onEnter?.();
-            };
-            void checkAndEnter();
-        }
-        return () => {
-            if (wizard.currentStep === name) {
-                void onExit?.();
+const WizardStep = t0 => {
+  const $ = _c(15);
+  const {
+    name,
+    children,
+    canEnter,
+    onEnterFailed,
+    onEnter,
+    onExit
+  } = t0;
+  const wizard = useWizard();
+  let t1;
+  let t2;
+  if ($[0] !== canEnter || $[1] !== name || $[2] !== onEnter || $[3] !== onEnterFailed || $[4] !== onExit || $[5] !== wizard) {
+    t1 = () => {
+      if (wizard.currentStep === name) {
+        const checkAndEnter = async () => {
+          if (canEnter) {
+            const allowed = await canEnter();
+            if (!allowed) {
+              onEnterFailed?.();
+              wizard.back();
+              return;
             }
+          }
+          await onEnter?.();
         };
-    }, [wizard.currentStep, name, canEnter, onEnterFailed, onEnter, onExit, wizard]);
-    if (wizard.currentStep !== name) {
-        return null;
+        checkAndEnter();
+      }
+      return () => {
+        if (wizard.currentStep === name) {
+          onExit?.();
+        }
+      };
+    };
+    t2 = [wizard.currentStep, name, canEnter, onEnterFailed, onEnter, onExit, wizard];
+    $[0] = canEnter;
+    $[1] = name;
+    $[2] = onEnter;
+    $[3] = onEnterFailed;
+    $[4] = onExit;
+    $[5] = wizard;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t1 = $[6];
+    t2 = $[7];
+  }
+  useEffect(t1, t2);
+  if (wizard.currentStep !== name) {
+    return null;
+  }
+  if (typeof children === "function") {
+    let t3;
+    if ($[8] !== children || $[9] !== wizard) {
+      t3 = children(wizard);
+      $[8] = children;
+      $[9] = wizard;
+      $[10] = t3;
+    } else {
+      t3 = $[10];
     }
-    if (typeof children === "function") {
-        return _jsx(_Fragment, { children: children(wizard) });
+    let t4;
+    if ($[11] !== t3) {
+      t4 = _jsx(_Fragment, {
+        children: t3
+      });
+      $[11] = t3;
+      $[12] = t4;
+    } else {
+      t4 = $[12];
     }
-    return _jsx(_Fragment, { children: children });
+    return t4;
+  }
+  let t3;
+  if ($[13] !== children) {
+    t3 = _jsx(_Fragment, {
+      children: children
+    });
+    $[13] = children;
+    $[14] = t3;
+  } else {
+    t3 = $[14];
+  }
+  return t3;
 };
-const WizardGuard = ({ children, canEnter, onEnterFailed }) => {
-    const wizard = useWizard();
-    useEffect(() => {
-        const checkGuard = async () => {
-            if (canEnter) {
-                const allowed = await canEnter();
-                if (!allowed) {
-                    onEnterFailed?.();
-                    wizard.back();
-                }
-            }
-        };
-        void checkGuard();
-    }, [canEnter, onEnterFailed, wizard]);
-    return _jsx(_Fragment, { children: children });
+const WizardGuard = t0 => {
+  const $ = _c(7);
+  const {
+    children,
+    canEnter,
+    onEnterFailed
+  } = t0;
+  const wizard = useWizard();
+  let t1;
+  let t2;
+  if ($[0] !== canEnter || $[1] !== onEnterFailed || $[2] !== wizard) {
+    t1 = () => {
+      const checkGuard = async () => {
+        if (canEnter) {
+          const allowed = await canEnter();
+          if (!allowed) {
+            onEnterFailed?.();
+            wizard.back();
+          }
+        }
+      };
+      checkGuard();
+    };
+    t2 = [canEnter, onEnterFailed, wizard];
+    $[0] = canEnter;
+    $[1] = onEnterFailed;
+    $[2] = wizard;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[5] !== children) {
+    t3 = _jsx(_Fragment, {
+      children: children
+    });
+    $[5] = children;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
 };
-const WizardGo = ({ step, children, onPress }) => {
-    const wizard = useWizard();
-    const handlePress = () => {
-        onPress?.();
-        wizard.goToStep(step);
+const WizardGo = t0 => {
+  const $ = _c(12);
+  const {
+    step,
+    children,
+    onPress
+  } = t0;
+  const wizard = useWizard();
+  let t1;
+  if ($[0] !== onPress || $[1] !== step || $[2] !== wizard) {
+    t1 = () => {
+      onPress?.();
+      wizard.goToStep(step);
     };
-    if (typeof children === "function") {
-        return _jsx(_Fragment, { children: children(handlePress) });
+    $[0] = onPress;
+    $[1] = step;
+    $[2] = wizard;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const handlePress = t1;
+  if (typeof children === "function") {
+    const t2 = children;
+    let t3;
+    if ($[4] !== handlePress || $[5] !== t2) {
+      t3 = t2(handlePress);
+      $[4] = handlePress;
+      $[5] = t2;
+      $[6] = t3;
+    } else {
+      t3 = $[6];
+    }
+    let t4;
+    if ($[7] !== t3) {
+      t4 = _jsx(_Fragment, {
+        children: t3
+      });
+      $[7] = t3;
+      $[8] = t4;
+    } else {
+      t4 = $[8];
     }
-    return _jsx(TouchableOpacity, { onPress: handlePress, children: children });
+    return t4;
+  }
+  let t2;
+  if ($[9] !== children || $[10] !== handlePress) {
+    t2 = _jsx(TouchableOpacity, {
+      accessibilityRole: "button",
+      onPress: handlePress,
+      children: children
+    });
+    $[9] = children;
+    $[10] = handlePress;
+    $[11] = t2;
+  } else {
+    t2 = $[11];
+  }
+  return t2;
 };
-const WizardBack = ({ children, onPress }) => {
-    const wizard = useWizard();
-    const handlePress = () => {
-        onPress?.();
-        wizard.back();
+const WizardBack = t0 => {
+  const $ = _c(11);
+  const {
+    children,
+    onPress
+  } = t0;
+  const wizard = useWizard();
+  let t1;
+  if ($[0] !== onPress || $[1] !== wizard) {
+    t1 = () => {
+      onPress?.();
+      wizard.back();
     };
-    if (!children) {
-        return null;
+    $[0] = onPress;
+    $[1] = wizard;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const handlePress = t1;
+  if (!children) {
+    return null;
+  }
+  if (typeof children === "function") {
+    const t2 = children;
+    let t3;
+    if ($[3] !== handlePress || $[4] !== t2) {
+      t3 = t2(handlePress);
+      $[3] = handlePress;
+      $[4] = t2;
+      $[5] = t3;
+    } else {
+      t3 = $[5];
     }
-    if (typeof children === "function") {
-        return _jsx(_Fragment, { children: children(handlePress) });
+    let t4;
+    if ($[6] !== t3) {
+      t4 = _jsx(_Fragment, {
+        children: t3
+      });
+      $[6] = t3;
+      $[7] = t4;
+    } else {
+      t4 = $[7];
     }
-    return _jsx(TouchableOpacity, { onPress: handlePress, children: children });
+    return t4;
+  }
+  let t2;
+  if ($[8] !== children || $[9] !== handlePress) {
+    t2 = _jsx(TouchableOpacity, {
+      accessibilityRole: "button",
+      onPress: handlePress,
+      children: children
+    });
+    $[8] = children;
+    $[9] = handlePress;
+    $[10] = t2;
+  } else {
+    t2 = $[10];
+  }
+  return t2;
 };
 export const Wizard = {
-    Root: WizardRoot,
-    Step: WizardStep,
-    Guard: WizardGuard,
-    Go: WizardGo,
-    Back: WizardBack,
+  Root: WizardRoot,
+  Step: WizardStep,
+  Guard: WizardGuard,
+  Go: WizardGo,
+  Back: WizardBack
 };