@webority-technologies/mobile 0.0.1

package/lib/module/auth/authStore.js

@@ -0,0 +1,100 @@
+"use strict";
+
+import * as Keychain from 'react-native-keychain';
+import { Logger } from "../logger/index.js";
+
+/**
+ * Token data persisted in the keychain.
+ */
+
+/**
+ * Store token with expiry.
+ */
+export const storeToken = async (key, token, expiry) => {
+  Logger.info(`Storing token for key: ${key}, token: ${token}, expiry: ${expiry}`);
+  try {
+    const data = JSON.stringify({
+      token,
+      expiry
+    });
+    await Keychain.setInternetCredentials(key, 'token', data, {
+      service: key
+    }); // Ensure service matches
+    Logger.info(`Token stored successfully for key: ${key}`);
+  } catch (error) {
+    Logger.error(`Error storing token for key: ${key}`, error);
+  }
+};
+
+/**
+ * Parse token data from credentials.
+ */
+const parseTokenData = credentials => {
+  if (!credentials) {
+    return null;
+  }
+  const {
+    password
+  } = credentials;
+  try {
+    const parsed = JSON.parse(password);
+    if (parsed && typeof parsed === 'object' && 'token' in parsed && 'expiry' in parsed && typeof parsed.token === 'string' && typeof parsed.expiry === 'string') {
+      return parsed;
+    }
+    return null;
+  } catch (error) {
+    Logger.error('Failed to parse token data', error);
+    return null;
+  }
+};
+
+/**
+ * Retrieve token and check if expired.
+ */
+export const getToken = async key => {
+  Logger.info(`Retrieving token for key: ${key}`);
+  try {
+    const credentials = await Keychain.getInternetCredentials(key, {
+      service: key
+    }); // Ensure service matches
+    const parsedData = parseTokenData(credentials);
+    Logger.info(`Parsed token data for key: ${key}:`, parsedData);
+    if (!parsedData) {
+      Logger.warn(`Invalid or no token data found for key: ${key}`);
+      return null;
+    }
+    const {
+      token,
+      expiry
+    } = parsedData;
+    Logger.info(`Token retrieved for key: ${key}, token: ${token}, expiry: ${expiry}`);
+    return {
+      token,
+      expiry
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('Key permanently invalidated')) {
+      Logger.error(`Key permanently invalidated for key: ${key}. Clearing the invalidated key.`);
+      await removeToken(key); // Clear the invalidated key
+      return null;
+    }
+    Logger.error(`Error retrieving token for key: ${key}`, error);
+    return null;
+  }
+};
+
+/**
+ * Remove token by key.
+ */
+export const removeToken = async key => {
+  try {
+    await Keychain.resetInternetCredentials({
+      service: key
+    });
+    Logger.info(`Token removed successfully for key: ${key}`);
+  } catch (error) {
+    Logger.error(`Failed to remove token for key: ${key}`, error);
+  }
+};
+//# sourceMappingURL=authStore.js.map

package/lib/module/auth/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { storeToken, getToken, removeToken } from "./authStore.js";
+export { decodeJWT, isJWTExpired, getJWTExpiry } from "./jwt.js";
+//# sourceMappingURL=index.js.map

package/lib/module/auth/jwt.js

@@ -0,0 +1,78 @@
+"use strict";
+
+import { Logger } from "../logger/index.js";
+
+/**
+ * Standard claims plus arbitrary keys.
+ * `sub`, `exp`, `iat`, `nbf` follow RFC 7519 conventions.
+ */
+
+const base64UrlToBase64 = input => {
+  const padded = input + '='.repeat((4 - input.length % 4) % 4);
+  return padded.replace(/-/g, '+').replace(/_/g, '/');
+};
+const decodeBase64 = input => {
+  // RN runtimes expose `atob` (Hermes 0.71+); fall back to a Buffer-based decode otherwise.
+  if (typeof atob === 'function') {
+    return atob(input);
+  }
+  /* eslint-disable @typescript-eslint/no-require-imports */
+  const {
+    Buffer
+  } = require('buffer');
+  /* eslint-enable */
+  return Buffer.from(input, 'base64').toString('utf-8');
+};
+const utf8FromBinary = binary => {
+  // Convert percent-encoded UTF-8 sequence so multi-byte chars survive.
+  try {
+    return decodeURIComponent(binary.split('').map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')).join(''));
+  } catch {
+    return binary;
+  }
+};
+
+/**
+ * Decode a JWT's payload claims. Does **not** verify the signature.
+ *
+ * @returns claims object on success, `null` if the token is malformed.
+ */
+export const decodeJWT = token => {
+  if (!token || typeof token !== 'string') return null;
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    Logger.warn('[jwt] decodeJWT: token is not a valid JWT (expected 3 segments)');
+    return null;
+  }
+  try {
+    const payload = parts[1];
+    const json = utf8FromBinary(decodeBase64(base64UrlToBase64(payload)));
+    return JSON.parse(json);
+  } catch (error) {
+    Logger.warn('[jwt] decodeJWT failed to parse payload', error);
+    return null;
+  }
+};
+
+/**
+ * Returns true when the token is expired (or unparseable / missing `exp`).
+ *
+ * @param token JWT string
+ * @param leewaySeconds amount of clock-skew tolerance to apply (default 30s)
+ */
+export const isJWTExpired = (token, leewaySeconds = 30) => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') return true;
+  const nowSeconds = Math.floor(Date.now() / 1000);
+  return claims.exp <= nowSeconds + leewaySeconds;
+};
+
+/**
+ * Returns the token's expiry as a Date, or `null` when no `exp` claim exists.
+ */
+export const getJWTExpiry = token => {
+  const claims = decodeJWT(token);
+  if (!claims || typeof claims.exp !== 'number') return null;
+  return new Date(claims.exp * 1000);
+};
+//# sourceMappingURL=jwt.js.map

package/lib/module/components/Accordion/Accordion.js

@@ -0,0 +1,251 @@
+"use strict";
+
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { Animated, Easing, LayoutAnimation, Pressable, StyleSheet, Text, View } from 'react-native';
+import { useTheme } from "../../theme/index.js";
+import { triggerHaptic } from "../../utils/hapticUtils.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const AccordionGroupContext = /*#__PURE__*/createContext(null);
+const useAccordionGroup = () => useContext(AccordionGroupContext);
+const AccordionGroup = ({
+  children,
+  allowMultiple = false,
+  defaultExpandedKeys,
+  expandedKeys: expandedKeysProp,
+  onChange,
+  style,
+  testID
+}) => {
+  const isControlled = expandedKeysProp !== undefined;
+  const [internalKeys, setInternalKeys] = useState(defaultExpandedKeys ?? []);
+  const keys = isControlled ? expandedKeysProp : internalKeys;
+  const setKeys = useCallback(next => {
+    if (!isControlled) setInternalKeys(next);
+    onChange?.(next);
+  }, [isControlled, onChange]);
+  const toggle = useCallback(id => {
+    const isOpen = keys.includes(id);
+    let next;
+    if (isOpen) {
+      next = keys.filter(k => k !== id);
+    } else if (allowMultiple) {
+      next = [...keys, id];
+    } else {
+      next = [id];
+    }
+    setKeys(next);
+  }, [keys, allowMultiple, setKeys]);
+  const isExpanded = useCallback(id => keys.includes(id), [keys]);
+  const ctx = useMemo(() => ({
+    isExpanded,
+    toggle,
+    allowMultiple
+  }), [isExpanded, toggle, allowMultiple]);
+  return /*#__PURE__*/_jsx(AccordionGroupContext.Provider, {
+    value: ctx,
+    children: /*#__PURE__*/_jsx(View, {
+      style: style,
+      testID: testID,
+      children: children
+    })
+  });
+};
+AccordionGroup.displayName = 'AccordionGroup';
+const Chevron = ({
+  rotate,
+  color
+}) => /*#__PURE__*/_jsx(Animated.Text, {
+  style: [chevronStyles.icon, {
+    color,
+    transform: [{
+      rotate
+    }]
+  }],
+  accessible: false,
+  children: '▾'
+});
+const chevronStyles = StyleSheet.create({
+  icon: {
+    fontSize: 14,
+    lineHeight: 14,
+    includeFontPadding: false
+  }
+});
+const Accordion = props => {
+  const {
+    title,
+    children,
+    id,
+    expanded: expandedProp,
+    defaultExpanded = false,
+    onChange,
+    icon,
+    disabled = false,
+    variant = 'plain',
+    accessibilityLabel,
+    style,
+    headerStyle,
+    contentStyle,
+    testID
+  } = props;
+  const theme = useTheme();
+  const styles = useMemo(() => buildStyles(theme), [theme]);
+  const group = useAccordionGroup();
+  const isControlled = expandedProp !== undefined;
+  const [internalExpanded, setInternalExpanded] = useState(defaultExpanded);
+  const groupExpanded = group && id ? group.isExpanded(id) : null;
+  const expanded = groupExpanded !== null ? groupExpanded : isControlled ? !!expandedProp : internalExpanded;
+  const [measuredHeight, setMeasuredHeight] = useState(null);
+  const heightAnim = useRef(new Animated.Value(expanded ? 1 : 0)).current;
+  const opacityAnim = useRef(new Animated.Value(expanded ? 1 : 0)).current;
+  const rotateAnim = useRef(new Animated.Value(expanded ? 1 : 0)).current;
+  const lastExpandedRef = useRef(expanded);
+  useEffect(() => {
+    // Skip animation when state matches the previous value (e.g. on mount).
+    if (lastExpandedRef.current === expanded) return;
+    lastExpandedRef.current = expanded;
+    Animated.parallel([Animated.timing(heightAnim, {
+      toValue: expanded ? 1 : 0,
+      duration: theme.motion.duration.normal,
+      easing: Easing.bezier(...theme.motion.easing.standard),
+      useNativeDriver: false
+    }),
+    // Opacity & rotate run alongside the height interpolation (which must
+    // use the JS driver). Driving them on JS too keeps everything in lockstep
+    // with no driver-mixing warnings, and is fine for two small properties.
+    Animated.timing(opacityAnim, {
+      toValue: expanded ? 1 : 0,
+      duration: theme.motion.duration.normal,
+      easing: Easing.bezier(...theme.motion.easing.standard),
+      useNativeDriver: false
+    }), Animated.timing(rotateAnim, {
+      toValue: expanded ? 1 : 0,
+      duration: theme.motion.duration.normal,
+      easing: Easing.bezier(...theme.motion.easing.standard),
+      useNativeDriver: false
+    })]).start();
+  }, [expanded, heightAnim, opacityAnim, rotateAnim, theme.motion]);
+  const onContentLayout = useCallback(e => {
+    const h = e.nativeEvent.layout.height;
+    if (h > 0 && h !== measuredHeight) setMeasuredHeight(h);
+  }, [measuredHeight]);
+  const handlePress = useCallback(() => {
+    if (disabled) return;
+    triggerHaptic('selection');
+    if (group && id) {
+      group.toggle(id);
+      onChange?.(!expanded);
+      return;
+    }
+    if (!isControlled) setInternalExpanded(!expanded);
+    onChange?.(!expanded);
+  }, [disabled, group, id, expanded, isControlled, onChange]);
+  const rotate = rotateAnim.interpolate({
+    inputRange: [0, 1],
+    outputRange: ['0deg', '180deg']
+  });
+  const animatedHeight = measuredHeight === null ? undefined : heightAnim.interpolate({
+    inputRange: [0, 1],
+    outputRange: [0, measuredHeight]
+  });
+  const cardStyle = variant === 'card' ? [styles.card, theme.shadows.sm, {
+    backgroundColor: theme.colors.background.elevated,
+    borderRadius: theme.radius.md
+  }] : null;
+  return /*#__PURE__*/_jsxs(View, {
+    style: [cardStyle, style],
+    testID: testID,
+    children: [/*#__PURE__*/_jsxs(Pressable, {
+      onPress: handlePress,
+      disabled: disabled,
+      accessibilityRole: "button",
+      accessibilityLabel: accessibilityLabel ?? title,
+      accessibilityState: {
+        expanded,
+        disabled
+      },
+      style: ({
+        pressed
+      }) => [styles.header, headerStyle, {
+        opacity: disabled ? 0.55 : pressed ? 0.85 : 1
+      }],
+      children: [icon ? /*#__PURE__*/_jsx(View, {
+        style: styles.iconLeft,
+        children: icon
+      }) : null, /*#__PURE__*/_jsx(Text, {
+        style: [styles.title, {
+          color: disabled ? theme.colors.text.disabled : theme.colors.text.primary,
+          fontSize: theme.typography.fontSize.base,
+          fontWeight: theme.typography.fontWeight.semibold
+        }],
+        numberOfLines: 2,
+        children: title
+      }), /*#__PURE__*/_jsx(Chevron, {
+        rotate: rotate,
+        color: disabled ? theme.colors.text.disabled : theme.colors.text.secondary
+      })]
+    }), measuredHeight === null ? /*#__PURE__*/_jsx(View, {
+      style: styles.measurer,
+      pointerEvents: "none",
+      onLayout: onContentLayout,
+      children: /*#__PURE__*/_jsx(View, {
+        style: [styles.content, contentStyle],
+        children: children
+      })
+    }) : null, /*#__PURE__*/_jsx(Animated.View, {
+      style: [styles.contentWrapper, measuredHeight === null ? {
+        height: 0,
+        opacity: 0
+      } : {
+        height: animatedHeight,
+        opacity: opacityAnim
+      }]
+      // Re-measure if children change size by listening to layout of inner
+      ,
+      children: /*#__PURE__*/_jsx(View, {
+        onLayout: onContentLayout,
+        style: [styles.content, contentStyle],
+        children: children
+      })
+    })]
+  });
+};
+Accordion.displayName = 'Accordion';
+
+// Suppress unused warnings on platforms that don't support LayoutAnimation
+void LayoutAnimation;
+const buildStyles = theme => StyleSheet.create({
+  card: {
+    paddingHorizontal: theme.spacing.md,
+    paddingVertical: 4,
+    marginVertical: theme.spacing.xs
+  },
+  header: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    paddingVertical: theme.spacing.sm
+  },
+  iconLeft: {
+    marginRight: theme.spacing.sm
+  },
+  title: {
+    flex: 1
+  },
+  contentWrapper: {
+    overflow: 'hidden'
+  },
+  content: {
+    paddingBottom: theme.spacing.sm
+  },
+  measurer: {
+    position: 'absolute',
+    opacity: 0,
+    left: 0,
+    right: 0,
+    top: 0,
+    zIndex: -1
+  }
+});
+export { Accordion, AccordionGroup };
+export default Accordion;
+//# sourceMappingURL=Accordion.js.map

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

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