@webority-technologies/mobile-ui 0.0.1

package/lib/module/components/Tooltip/Tooltip.js

@@ -0,0 +1,405 @@
+"use strict";
+
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Animated, Dimensions, Easing, Modal, Pressable, StyleSheet, Text, View } from 'react-native';
+import { createAnimatedValue, useTheme } from "../../theme/index.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+const DEFAULT_TOOLTIP_GAP = 8;
+const DEFAULT_SCREEN_PADDING = 8;
+const DEFAULT_PRESS_AUTO_HIDE_MS = 4000;
+const DEFAULT_ARROW_HALF_WIDTH = 4; // half of 8px arrow base
+const DEFAULT_ARROW_HEIGHT = 6;
+const DEFAULT_ARROW_CORNER_PADDING = 12;
+const DEFAULT_MAX_WIDTH = 240;
+const DEFAULT_LINE_HEIGHT = 18;
+const Tooltip = props => {
+  const {
+    content,
+    children,
+    placement = 'auto',
+    trigger = 'longPress',
+    visible: controlledVisible,
+    onVisibleChange,
+    hideOnContentPress = true,
+    maxWidth,
+    showArrow = true,
+    accessibilityLabel,
+    style,
+    containerStyle,
+    arrowStyle: arrowStyleOverride,
+    messageStyle,
+    testID
+  } = props;
+  const theme = useTheme();
+  const styles = useMemo(() => buildStyles(theme), [theme]);
+  const tooltipTokens = theme.components.tooltip;
+  const TOOLTIP_GAP = tooltipTokens?.gap ?? DEFAULT_TOOLTIP_GAP;
+  const SCREEN_PADDING = tooltipTokens?.screenPadding ?? DEFAULT_SCREEN_PADDING;
+  const PRESS_AUTO_HIDE_MS = tooltipTokens?.pressAutoHideMs ?? DEFAULT_PRESS_AUTO_HIDE_MS;
+  const ARROW_HALF_WIDTH = tooltipTokens?.arrowHalfWidth ?? DEFAULT_ARROW_HALF_WIDTH;
+  const ARROW_HEIGHT = tooltipTokens?.arrowHeight ?? DEFAULT_ARROW_HEIGHT;
+  const ARROW_CORNER_PADDING = tooltipTokens?.arrowCornerPadding ?? DEFAULT_ARROW_CORNER_PADDING;
+  const MESSAGE_LINE_HEIGHT = tooltipTokens?.lineHeight ?? DEFAULT_LINE_HEIGHT;
+  const resolvedMaxWidth = maxWidth ?? tooltipTokens?.maxWidth ?? DEFAULT_MAX_WIDTH;
+  const enableScaleAnimation = tooltipTokens?.enableScaleAnimation ?? false;
+  const exitDurationMs = tooltipTokens?.exitDurationMs ?? 150;
+  const isControlled = trigger === 'manual' || typeof controlledVisible === 'boolean';
+  const [internalVisible, setInternalVisible] = useState(false);
+  const visible = isControlled ? Boolean(controlledVisible) : internalVisible;
+  const [anchor, setAnchor] = useState(null);
+  const [size, setSize] = useState({
+    width: 0,
+    height: 0
+  });
+  const wrapperRef = useRef(null);
+  const scale = useRef(createAnimatedValue(visible ? 1 : enableScaleAnimation ? 0.85 : 1)).current;
+  const opacity = useRef(createAnimatedValue(visible ? 1 : 0)).current;
+  const autoHideTimer = useRef(null);
+  const didMount = useRef(false);
+  const setVisible = useCallback(next => {
+    if (!isControlled) {
+      setInternalVisible(next);
+    }
+    onVisibleChange?.(next);
+  }, [isControlled, onVisibleChange]);
+  const measureAnchor = useCallback(() => {
+    if (!wrapperRef.current) {
+      return;
+    }
+    wrapperRef.current.measureInWindow((x, y, width, height) => {
+      setAnchor({
+        x,
+        y,
+        width,
+        height
+      });
+    });
+  }, []);
+  const handleTrigger = useCallback(_event => {
+    measureAnchor();
+    setVisible(true);
+  }, [measureAnchor, setVisible]);
+  const handleHide = useCallback(() => {
+    setVisible(false);
+  }, [setVisible]);
+
+  // Animations + auto-hide
+  // biome-ignore lint/correctness/useExhaustiveDependencies: entry/exit is driven by `visible` alone; `handleHide`/`measureAnchor` are re-created per render and declaring them would re-run the mount branch and re-arm the auto-hide timer continuously
+  useEffect(() => {
+    // On first mount, skip the entry animation if we're already visible
+    // (avoids native-driver bootstrap issues during render).
+    if (!didMount.current) {
+      didMount.current = true;
+      if (visible) {
+        measureAnchor();
+        if (trigger === 'press') {
+          if (autoHideTimer.current) {
+            clearTimeout(autoHideTimer.current);
+          }
+          autoHideTimer.current = setTimeout(() => {
+            handleHide();
+          }, PRESS_AUTO_HIDE_MS);
+        }
+      }
+      return () => {
+        if (autoHideTimer.current) {
+          clearTimeout(autoHideTimer.current);
+          autoHideTimer.current = null;
+        }
+      };
+    }
+    let anim;
+    if (visible) {
+      measureAnchor();
+      const enterAnims = [Animated.timing(opacity, {
+        toValue: 1,
+        duration: theme.motion.duration.fast,
+        useNativeDriver: true
+      })];
+      if (enableScaleAnimation) {
+        enterAnims.push(Animated.spring(scale, {
+          toValue: 1,
+          damping: theme.motion.spring.snappy.damping,
+          stiffness: theme.motion.spring.snappy.stiffness,
+          mass: theme.motion.spring.snappy.mass,
+          useNativeDriver: true
+        }));
+      }
+      anim = Animated.parallel(enterAnims);
+      anim.start();
+      if (trigger === 'press') {
+        if (autoHideTimer.current) {
+          clearTimeout(autoHideTimer.current);
+        }
+        autoHideTimer.current = setTimeout(() => {
+          handleHide();
+        }, PRESS_AUTO_HIDE_MS);
+      }
+    } else {
+      const exitAnims = [Animated.timing(opacity, {
+        toValue: 0,
+        duration: exitDurationMs,
+        easing: Easing.bezier(...theme.motion.easing.accelerate),
+        useNativeDriver: true
+      })];
+      if (enableScaleAnimation) {
+        exitAnims.push(Animated.timing(scale, {
+          toValue: 0.85,
+          duration: exitDurationMs,
+          easing: Easing.bezier(...theme.motion.easing.accelerate),
+          useNativeDriver: true
+        }));
+      }
+      anim = Animated.parallel(exitAnims);
+      anim.start();
+      if (autoHideTimer.current) {
+        clearTimeout(autoHideTimer.current);
+        autoHideTimer.current = null;
+      }
+    }
+    return () => {
+      anim?.stop();
+      if (autoHideTimer.current) {
+        clearTimeout(autoHideTimer.current);
+        autoHideTimer.current = null;
+      }
+    };
+  }, [visible]);
+  const handleContentLayout = e => {
+    const {
+      width,
+      height
+    } = e.nativeEvent.layout;
+    if (width !== size.width || height !== size.height) {
+      setSize({
+        width,
+        height
+      });
+    }
+  };
+  const position = useMemo(() => {
+    const screen = Dimensions.get('window');
+    if (!anchor) {
+      // Fallback before measurement: render off-screen-ish at top-left, will reposition on layout.
+      return {
+        top: SCREEN_PADDING,
+        left: SCREEN_PADDING,
+        placement: 'bottom',
+        arrowOffset: 0
+      };
+    }
+    const tooltipWidth = size.width || Math.min(resolvedMaxWidth, screen.width - SCREEN_PADDING * 2);
+    const tooltipHeight = size.height || 0;
+
+    // Choose placement.
+    let resolved;
+    if (placement === 'auto') {
+      const space = {
+        top: anchor.y,
+        bottom: screen.height - (anchor.y + anchor.height),
+        left: anchor.x,
+        right: screen.width - (anchor.x + anchor.width)
+      };
+      const max = Math.max(space.top, space.bottom, space.left, space.right);
+      if (max === space.bottom) {
+        resolved = 'bottom';
+      } else if (max === space.top) {
+        resolved = 'top';
+      } else if (max === space.right) {
+        resolved = 'right';
+      } else {
+        resolved = 'left';
+      }
+    } else {
+      resolved = placement;
+    }
+    let top = 0;
+    let left = 0;
+    if (resolved === 'top') {
+      top = anchor.y - tooltipHeight - TOOLTIP_GAP;
+      left = anchor.x + anchor.width / 2 - tooltipWidth / 2;
+    } else if (resolved === 'bottom') {
+      top = anchor.y + anchor.height + TOOLTIP_GAP;
+      left = anchor.x + anchor.width / 2 - tooltipWidth / 2;
+    } else if (resolved === 'left') {
+      top = anchor.y + anchor.height / 2 - tooltipHeight / 2;
+      left = anchor.x - tooltipWidth - TOOLTIP_GAP;
+    } else {
+      top = anchor.y + anchor.height / 2 - tooltipHeight / 2;
+      left = anchor.x + anchor.width + TOOLTIP_GAP;
+    }
+
+    // Clamp to screen.
+    left = Math.max(SCREEN_PADDING, Math.min(left, screen.width - tooltipWidth - SCREEN_PADDING));
+    top = Math.max(SCREEN_PADDING, Math.min(top, screen.height - tooltipHeight - SCREEN_PADDING));
+
+    // Compute arrow offset along the card's trigger-facing edge so the caret stays
+    // pointing at the trigger even after the card is clamped to the viewport.
+    let arrowOffset = 0;
+    if (resolved === 'top' || resolved === 'bottom') {
+      const triggerCenterX = anchor.x + anchor.width / 2;
+      const desired = triggerCenterX - left; // x-offset from card's left edge
+      const min = ARROW_CORNER_PADDING;
+      const max = Math.max(min, tooltipWidth - ARROW_CORNER_PADDING);
+      arrowOffset = Math.max(min, Math.min(desired, max));
+    } else {
+      const triggerCenterY = anchor.y + anchor.height / 2;
+      const desired = triggerCenterY - top;
+      const min = ARROW_CORNER_PADDING;
+      const max = Math.max(min, tooltipHeight - ARROW_CORNER_PADDING);
+      arrowOffset = Math.max(min, Math.min(desired, max));
+    }
+    return {
+      top,
+      left,
+      placement: resolved,
+      arrowOffset
+    };
+  }, [anchor, size, placement, resolvedMaxWidth, SCREEN_PADDING, TOOLTIP_GAP, ARROW_CORNER_PADDING]);
+
+  // Build the cloned trigger.
+  const triggerProps = {};
+  if (trigger === 'longPress') {
+    triggerProps.onLongPress = handleTrigger;
+    triggerProps.accessibilityHint = 'Long press for more info';
+  } else if (trigger === 'press') {
+    const childOnPress = children.props.onPress;
+    triggerProps.onPress = e => {
+      childOnPress?.(e);
+      handleTrigger(e);
+    };
+  }
+  const clonedChild = /*#__PURE__*/React.cloneElement(children, triggerProps);
+  const a11yLabel = accessibilityLabel ?? (typeof content === 'string' ? content : 'Tooltip');
+
+  // Arrow style: a CSS-triangle implemented via 0-width view with transparent
+  // borders. We rotate the base (placement='top' = arrow on bottom-edge pointing
+  // down) into the four cardinal orientations.
+  const arrowStyle = useMemo(() => {
+    if (!showArrow) {
+      return null;
+    }
+    const arrowColor = theme.colors.background.inverse;
+    const base = {
+      position: 'absolute',
+      width: 0,
+      height: 0,
+      backgroundColor: 'transparent',
+      borderStyle: 'solid',
+      borderLeftWidth: ARROW_HALF_WIDTH,
+      borderRightWidth: ARROW_HALF_WIDTH,
+      borderBottomWidth: ARROW_HEIGHT,
+      borderTopWidth: 0,
+      borderLeftColor: 'transparent',
+      borderRightColor: 'transparent',
+      borderTopColor: 'transparent',
+      borderBottomColor: arrowColor
+    };
+    if (position.placement === 'top') {
+      // Card is above trigger; arrow on bottom edge, pointing down.
+      return {
+        ...base,
+        bottom: -ARROW_HEIGHT,
+        left: position.arrowOffset - ARROW_HALF_WIDTH,
+        transform: [{
+          rotate: '180deg'
+        }]
+      };
+    }
+    if (position.placement === 'bottom') {
+      // Card below trigger; arrow on top edge, pointing up.
+      return {
+        ...base,
+        top: -ARROW_HEIGHT,
+        left: position.arrowOffset - ARROW_HALF_WIDTH
+      };
+    }
+    if (position.placement === 'left') {
+      // Card left of trigger; arrow on right edge, pointing right.
+      return {
+        ...base,
+        right: -ARROW_HEIGHT,
+        top: position.arrowOffset - ARROW_HALF_WIDTH,
+        transform: [{
+          rotate: '90deg'
+        }]
+      };
+    }
+    // 'right': card right of trigger; arrow on left edge, pointing left.
+    return {
+      ...base,
+      left: -ARROW_HEIGHT,
+      top: position.arrowOffset - ARROW_HALF_WIDTH,
+      transform: [{
+        rotate: '-90deg'
+      }]
+    };
+  }, [showArrow, position, theme, ARROW_HALF_WIDTH, ARROW_HEIGHT]);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(View, {
+      ref: wrapperRef,
+      collapsable: false,
+      onLayout: measureAnchor,
+      testID: testID,
+      children: clonedChild
+    }), /*#__PURE__*/_jsx(Modal, {
+      visible: visible,
+      transparent: true,
+      statusBarTranslucent: true,
+      presentationStyle: "overFullScreen",
+      animationType: "none",
+      onRequestClose: handleHide,
+      children: /*#__PURE__*/_jsx(Pressable, {
+        style: StyleSheet.absoluteFill,
+        onPress: hideOnContentPress ? handleHide : undefined,
+        accessibilityLabel: "Close tooltip",
+        accessibilityRole: "button",
+        children: visible ? /*#__PURE__*/_jsxs(Animated.View, {
+          accessibilityRole: 'tooltip',
+          accessibilityLiveRegion: "polite",
+          accessibilityLabel: a11yLabel,
+          onLayout: handleContentLayout,
+          style: [{
+            position: 'absolute',
+            top: position.top,
+            left: position.left,
+            maxWidth: resolvedMaxWidth,
+            opacity,
+            transform: [{
+              scale
+            }]
+          }, style, containerStyle],
+          children: [/*#__PURE__*/_jsx(View, {
+            style: [styles.tooltip, {
+              backgroundColor: theme.colors.background.inverse,
+              borderRadius: theme.radius.md,
+              paddingHorizontal: theme.spacing.md,
+              paddingVertical: theme.spacing.sm,
+              ...theme.shadows.lg,
+              shadowColor: theme.shadows.lg.shadowColor
+            }],
+            children: typeof content === 'string' ? /*#__PURE__*/_jsx(Text, {
+              style: [{
+                color: theme.colors.text.inverse,
+                fontSize: theme.typography.fontSize.sm,
+                lineHeight: MESSAGE_LINE_HEIGHT
+              }, messageStyle],
+              children: content
+            }) : content
+          }), arrowStyle ? /*#__PURE__*/_jsx(View, {
+            style: [arrowStyle, arrowStyleOverride],
+            pointerEvents: "none"
+          }) : null]
+        }) : null
+      })
+    })]
+  });
+};
+const buildStyles = _theme => StyleSheet.create({
+  tooltip: {
+    overflow: 'hidden'
+  }
+});
+export { Tooltip };
+export default Tooltip;
+//# sourceMappingURL=Tooltip.js.map

package/lib/module/components/Tooltip/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { default, Tooltip } from "./Tooltip.js";
+//# sourceMappingURL=index.js.map

package/lib/module/components/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+export { Accordion, AccordionGroup } from "./Accordion/index.js";
+export { AnimatePresence } from "./AnimatePresence/index.js";
+export { AppBar } from "./AppBar/index.js";
+export { AsyncBlock } from "./AsyncBlock/index.js";
+export { Autocomplete } from "./Autocomplete/index.js";
+export { Avatar, AvatarGroup } from "./Avatar/index.js";
+export { Badge } from "./Badge/index.js";
+export { Banner } from "./Banner/index.js";
+export { BottomNavigation } from "./BottomNavigation/index.js";
+export { BottomSheet, useBottomSheet } from "./BottomSheet/index.js";
+export { Box, Row, Spacer, Stack } from "./Box/index.js";
+export { Button } from "./Button/index.js";
+export { Card } from "./Card/index.js";
+export { Carousel } from "./Carousel/index.js";
+export { Checkbox } from "./Checkbox/index.js";
+export { Chip } from "./Chip/index.js";
+export { ChoiceGroup } from "./ChoiceGroup/index.js";
+export { Confetti } from "./Confetti/index.js";
+export { DatePicker } from "./DatePicker/index.js";
+export { DateRangePicker } from "./DateRangePicker/index.js";
+export { Descriptions } from "./Descriptions/index.js";
+export { Dialog } from "./Dialog/index.js";
+export { Divider } from "./Divider/index.js";
+export { Drawer } from "./Drawer/index.js";
+export { EmptyState } from "./EmptyState/index.js";
+export { FilePicker, formatFileSize } from "./FilePicker/index.js";
+export { FloatingActionButton, FloatingActionButtonGroup } from "./FloatingActionButton/index.js";
+export { ForceUpdateDialog } from "./ForceUpdateDialog/index.js";
+export { FormField } from "./FormField/index.js";
+export { IconButton } from "./IconButton/index.js";
+export { ImageGallery } from "./ImageGallery/index.js";
+export { InlineSelect } from "./InlineSelect/index.js";
+export { Input } from "./Input/index.js";
+export { KeyboardAwareScrollView } from "./KeyboardAwareScrollView/index.js";
+export { KeyboardToolbar } from "./KeyboardToolbar/index.js";
+export { ListItem } from "./ListItem/index.js";
+export { MODAL_DISMISS_GRACE_MS, Modal } from "./Modal/index.js";
+export { NumberInput } from "./NumberInput/index.js";
+export { OTPInput } from "./OTPInput/index.js";
+export { DEFAULT_CALLING_CODES, formatE164, PhoneNumberInput } from "./PhoneNumberInput/index.js";
+export { PickerTrigger } from "./PickerTrigger/index.js";
+export { ProgressBar } from "./ProgressBar/index.js";
+export { Radio, RadioDot, RadioGroup } from "./Radio/index.js";
+export { Rating } from "./Rating/index.js";
+export { Repeater } from "./Repeater/index.js";
+export { SearchBar } from "./SearchBar/index.js";
+export { SegmentedControl } from "./SegmentedControl/index.js";
+export { Select } from "./Select/index.js";
+export { Skeleton, SkeletonCircle, SkeletonClockProvider, SkeletonContent, SkeletonList, SkeletonProvider, SkeletonSkip, SkeletonText, useReduceMotion, useSkeletonClock, useSkeletonDefaults } from "./Skeleton/index.js";
+export { Slider } from "./Slider/index.js";
+export { SlideToConfirm } from "./SlideToConfirm/index.js";
+export { Spinner } from "./Spinner/index.js";
+export { Stepper } from "./Stepper/index.js";
+export { Swipeable } from "./Swipeable/index.js";
+export { Switch } from "./Switch/index.js";
+export { Tabs } from "./Tabs/index.js";
+export { TagInput } from "./TagInput/index.js";
+export { Text } from "./Text/index.js";
+export { Timeline } from "./Timeline/index.js";
+export { TimePicker } from "./TimePicker/index.js";
+export { Toast, ToastProvider, toast, useToast } from "./Toast/index.js";
+export { Tooltip } from "./Tooltip/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/form/FormContext.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import React, { createContext, useContext } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+const FormContext = /*#__PURE__*/createContext(null);
+/**
+ * Provides a {@link useForm} instance to descendants so `<FormField name>`,
+ * {@link useField} and {@link useFieldArray} can bind by name.
+ */
+export const Form = ({
+  form,
+  children
+}) => /*#__PURE__*/_jsx(FormContext.Provider, {
+  value: form,
+  children: children
+});
+Form.displayName = 'Form';
+
+/** Read the surrounding form. Throws if there is no `<Form>` ancestor. */
+export function useFormContext() {
+  const ctx = useContext(FormContext);
+  if (!ctx) {
+    throw new Error('useFormContext / useField / <FormField name> must be rendered inside a <Form> from @webority-technologies/mobile-ui.');
+  }
+  return ctx;
+}
+
+/** Read the surrounding form, or null when there is no `<Form>` ancestor. */
+export function useOptionalFormContext() {
+  return useContext(FormContext);
+}
+//# sourceMappingURL=FormContext.js.map

package/lib/module/form/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export { Form, useFormContext, useOptionalFormContext } from "./FormContext.js";
+export { deletePath, getPath, setPath } from "./path.js";
+
+// Validation rule presets (the dependency-free Yup replacement):
+//   import { rules } from '@webority-technologies/mobile-ui';
+//   validate: { email: [rules.required(), rules.email()] }
+// import-then-export instead of `export * as` — consumer apps compile this
+// library from source via Metro, and their babel preset does not transform
+// export-namespace-from syntax outside the app root.
+import * as rules from "./rules.js";
+export { useField, useFieldArray } from "./useField.js";
+export { useForm } from "./useForm.js";
+export { rules };
+//# sourceMappingURL=index.js.map

package/lib/module/form/path.js

@@ -0,0 +1,84 @@
+"use strict";
+
+/**
+ * Immutable get/set/delete for dot- and bracket-notation field paths
+ * ("address.city", "phones[0]", "items[2].qty"). Lets a single flat `name`
+ * string address nested values and array items, so the form engine can treat
+ * every field uniformly regardless of how deep it lives in the value tree.
+ */
+
+const tokenize = path => {
+  const tokens = [];
+  const re = /[^.[\]]+/g;
+  let m;
+  while ((m = re.exec(path)) !== null) {
+    const raw = m[0];
+    tokens.push(/^\d+$/.test(raw) ? Number(raw) : raw);
+  }
+  return tokens;
+};
+export const getPath = (obj, path) => {
+  const tokens = tokenize(path);
+  let cur = obj;
+  for (const t of tokens) {
+    if (cur == null || typeof cur !== 'object') {
+      return undefined;
+    }
+    cur = cur[t];
+  }
+  return cur;
+};
+export const setPath = (obj, path, value) => {
+  const tokens = tokenize(path);
+  if (tokens.length === 0) {
+    return obj;
+  }
+  const root = Array.isArray(obj) ? [...obj] : {
+    ...obj
+  };
+  let cur = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const t = tokens[i];
+    const next = tokens[i + 1];
+    const child = cur[t];
+    // Clone the existing branch so we never mutate the previous value tree;
+    // create the right container shape when the branch is missing.
+    const cloned = child != null && typeof child === 'object' ? Array.isArray(child) ? [...child] : {
+      ...child
+    } : typeof next === 'number' ? [] : {};
+    cur[t] = cloned;
+    cur = cloned;
+  }
+  cur[tokens[tokens.length - 1]] = value;
+  return root;
+};
+export const deletePath = (obj, path) => {
+  const tokens = tokenize(path);
+  if (tokens.length === 0) {
+    return obj;
+  }
+  const root = Array.isArray(obj) ? [...obj] : {
+    ...obj
+  };
+  let cur = root;
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const t = tokens[i];
+    const child = cur[t];
+    if (child == null || typeof child !== 'object') {
+      return root;
+    }
+    const cloned = Array.isArray(child) ? [...child] : {
+      ...child
+    };
+    cur[t] = cloned;
+    cur = cloned;
+  }
+  const last = tokens[tokens.length - 1];
+  if (Array.isArray(cur) && typeof last === 'number') {
+    cur.splice(last, 1);
+  } else {
+    delete cur[last];
+  }
+  return root;
+};
+//# sourceMappingURL=path.js.map

package/lib/module/form/rules.js

@@ -0,0 +1,59 @@
+"use strict";
+
+/**
+ * Validation rule presets — the dependency-free replacement for Yup chains.
+ * Each factory returns a {@link ValidationRule}. Rules built on the project's
+ * `validators` module skip empty values (so `required()` owns emptiness and you
+ * don't get duplicate errors), and accept an optional custom message.
+ */
+
+import { isAadhaar, isAlphanumeric, isEmail, isGstin, isIfsc, isIndianMobile, isIndianPincode, isInteger, isNumeric, isPan, isPhone, isStrongPassword, isUrl } from '@webority-technologies/mobile-core';
+import { getPath } from "./path.js";
+const isEmptyValue = v => v == null || v === '' || Array.isArray(v) && v.length === 0;
+const fromPredicate = (predicate, defaultMsg) => message => value => isEmptyValue(value) || predicate(value) ? undefined : message ?? defaultMsg;
+export const required = (message = 'This field is required') => value => {
+  // A required boolean (e.g. "accept terms" checkbox) must be true.
+  if (typeof value === 'boolean') {
+    return value ? undefined : message;
+  }
+  return isEmptyValue(value) ? message : undefined;
+};
+export const email = fromPredicate(isEmail, 'Enter a valid email');
+export const mobile = fromPredicate(isIndianMobile, 'Enter a valid mobile number');
+export const phone = fromPredicate(isPhone, 'Enter a valid phone number');
+export const url = fromPredicate(isUrl, 'Enter a valid URL');
+export const numeric = fromPredicate(isNumeric, 'Enter a valid number');
+export const integer = fromPredicate(isInteger, 'Enter a whole number');
+export const alphanumeric = fromPredicate(isAlphanumeric, 'Use letters and numbers only');
+export const pincode = fromPredicate(isIndianPincode, 'Enter a valid 6-digit PIN code');
+export const pan = fromPredicate(isPan, 'Enter a valid PAN');
+export const gstin = fromPredicate(isGstin, 'Enter a valid GSTIN');
+export const aadhaar = fromPredicate(isAadhaar, 'Enter a valid Aadhaar number');
+export const ifsc = fromPredicate(isIfsc, 'Enter a valid IFSC code');
+export const minLength = (length, message) => value => isEmptyValue(value) || String(value).length >= length ? undefined : message ?? `Must be at least ${length} characters`;
+export const maxLength = (length, message) => value => value == null || String(value).length <= length ? undefined : message ?? `Must be at most ${length} characters`;
+export const min = (n, message) => value => isEmptyValue(value) || Number(value) >= n ? undefined : message ?? `Must be at least ${n}`;
+export const max = (n, message) => value => isEmptyValue(value) || Number(value) <= n ? undefined : message ?? `Must be at most ${n}`;
+export const pattern = (regex, message = 'Invalid format') => value => isEmptyValue(value) || regex.test(String(value)) ? undefined : message;
+export const oneOf = (allowed, message = 'Invalid selection') => value => isEmptyValue(value) || allowed.includes(value) ? undefined : message;
+
+/** Cross-field equality (e.g. confirm-password). `otherField` is a field path. */
+export const matches = (otherField, message = 'Values do not match') => (value, allValues) => value === getPath(allValues, otherField) ? undefined : message;
+export const strongPassword = (rules, message = 'Password is too weak') => value => isEmptyValue(value) || isStrongPassword(value, rules) ? undefined : message;
+
+/**
+ * Wrap any custom check. Return `true` (valid), `false` (invalid → default
+ * message), or a string (invalid → that message). Async is supported — return
+ * a Promise of the same.
+ */
+export const custom = (fn, message = 'Invalid value') => async (value, allValues) => {
+  const result = await fn(value, allValues);
+  if (result === true) {
+    return undefined;
+  }
+  if (result === false) {
+    return message;
+  }
+  return result;
+};
+//# sourceMappingURL=rules.js.map

package/lib/module/form/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map