@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/components/styles/shadow.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = shadow;
+const react_native_1 = require("react-native");
+const SHADOW_COLOR = '#000000';
+const SHADOW_OPACITY = 0.24;
+const MD3_SHADOW_OPACITY = 0.3;
+const MD3_SHADOW_COLOR = '#000000';
+function shadow(elevation = 0, isV3 = false) {
+    return isV3 ? v3Shadow(elevation) : v2Shadow(elevation);
+}
+function v2Shadow(elevation = 0) {
+    if (elevation instanceof react_native_1.Animated.Value) {
+        const inputRange = [0, 1, 2, 3, 8, 24];
+        if (react_native_1.Platform.OS === 'ios') {
+            return {
+                shadowColor: SHADOW_COLOR,
+                shadowOffset: {
+                    width: 0,
+                    height: elevation.interpolate({
+                        inputRange,
+                        outputRange: [0, 0.5, 0.75, 2, 7, 23],
+                    }),
+                },
+                shadowOpacity: elevation.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [0, SHADOW_OPACITY],
+                    extrapolate: 'clamp',
+                }),
+                shadowRadius: elevation.interpolate({
+                    inputRange,
+                    outputRange: [0, 0.75, 1.5, 3, 8, 24],
+                }),
+            };
+        }
+        return {
+            elevation: elevation.interpolate({
+                inputRange,
+                outputRange: [0, 1, 2, 3, 8, 24],
+            }),
+        };
+    }
+    if (elevation === 0) {
+        return {};
+    }
+    let height;
+    let radius;
+    switch (elevation) {
+        case 1:
+            height = 0.5;
+            radius = 0.75;
+            break;
+        case 2:
+            height = 0.75;
+            radius = 1.5;
+            break;
+        default:
+            height = elevation - 1;
+            radius = elevation;
+    }
+    if (react_native_1.Platform.OS === 'ios') {
+        return {
+            shadowColor: SHADOW_COLOR,
+            shadowOffset: {
+                width: 0,
+                height,
+            },
+            shadowOpacity: SHADOW_OPACITY,
+            shadowRadius: radius,
+        };
+    }
+    return {
+        elevation: elevation,
+    };
+}
+function v3Shadow(elevation = 0) {
+    const inputRange = [0, 1, 2, 3, 4, 5];
+    const shadowHeight = [0, 1, 2, 4, 6, 8];
+    const shadowRadius = [0, 3, 6, 8, 10, 12];
+    if (elevation instanceof react_native_1.Animated.Value) {
+        if (react_native_1.Platform.OS === 'ios') {
+            return {
+                shadowColor: MD3_SHADOW_COLOR,
+                shadowOffset: {
+                    width: 0,
+                    height: elevation.interpolate({
+                        inputRange,
+                        outputRange: shadowHeight,
+                    }),
+                },
+                shadowOpacity: elevation.interpolate({
+                    inputRange: [0, 1],
+                    outputRange: [0, MD3_SHADOW_OPACITY],
+                    extrapolate: 'clamp',
+                }),
+                shadowRadius: elevation.interpolate({
+                    inputRange,
+                    outputRange: shadowRadius,
+                }),
+            };
+        }
+        return {
+            elevation: elevation.interpolate({
+                inputRange,
+                outputRange: [0, 1, 2, 3, 4, 5],
+            }),
+        };
+    }
+    if (react_native_1.Platform.OS === 'ios') {
+        return {
+            shadowColor: MD3_SHADOW_COLOR,
+            shadowOpacity: elevation ? MD3_SHADOW_OPACITY : 0,
+            shadowOffset: {
+                width: 0,
+                height: shadowHeight[elevation] || 0,
+            },
+            shadowRadius: shadowRadius[elevation] || 0,
+        };
+    }
+    return {
+        elevation: elevation || 0,
+    };
+}

package/src/ui/components/theming.d.ts

@@ -0,0 +1,7 @@
+import type { InternalTheme } from './types';
+/**
+ * Adapter to convert services theming to react-native-paper's InternalTheme format
+ */
+export declare const useInternalTheme: (themeOverrides?: (Partial<InternalTheme> & {
+    dark?: boolean;
+}) | "light" | "dark") => InternalTheme;

package/src/ui/components/theming.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInternalTheme = void 0;
+const styles_1 = require("../styles");
+/**
+ * Adapter to convert services theming to react-native-paper's InternalTheme format
+ */
+const useInternalTheme = (themeOverrides) => {
+    // Handle string theme prop (for compatibility with services theme system)
+    let theme = 'light';
+    if (typeof themeOverrides === 'string') {
+        theme = themeOverrides;
+    }
+    else if (themeOverrides && typeof themeOverrides === 'object' && themeOverrides.dark) {
+        theme = 'dark';
+    }
+    const colors = (0, styles_1.useThemeColors)(theme);
+    const themeObj = (0, styles_1.getTheme)(theme);
+    // Create InternalTheme compatible object
+    const internalTheme = {
+        version: 3,
+        isV3: true,
+        dark: theme === 'dark',
+        mode: 'adaptive',
+        roundness: 10,
+        animation: {
+            scale: 1,
+        },
+        colors: {
+            primary: colors.primary,
+            primaryContainer: `${colors.primary}20`,
+            secondary: colors.secondaryText,
+            secondaryContainer: `${colors.secondaryText}20`,
+            tertiary: colors.primary,
+            tertiaryContainer: `${colors.primary}20`,
+            surface: colors.background,
+            surfaceVariant: colors.inputBackground,
+            surfaceDisabled: `${colors.secondaryText}40`,
+            background: colors.background,
+            error: colors.error,
+            errorContainer: `${colors.error}20`,
+            onPrimary: '#FFFFFF',
+            onPrimaryContainer: colors.primary,
+            onSecondary: '#FFFFFF',
+            onSecondaryContainer: colors.secondaryText,
+            onTertiary: '#FFFFFF',
+            onTertiaryContainer: colors.primary,
+            onSurface: colors.text,
+            onSurfaceVariant: colors.secondaryText,
+            onSurfaceDisabled: `${colors.secondaryText}60`,
+            onError: '#FFFFFF',
+            onErrorContainer: colors.error,
+            onBackground: colors.text,
+            outline: colors.border,
+            outlineVariant: `${colors.border}80`,
+            inverseSurface: theme === 'dark' ? '#FFFFFF' : '#000000',
+            inverseOnSurface: theme === 'dark' ? '#000000' : '#FFFFFF',
+            inversePrimary: colors.primary,
+            shadow: '#000000',
+            scrim: '#000000',
+            backdrop: '#00000080',
+            elevation: {
+                level0: 'transparent',
+                level1: theme === 'dark' ? '#1E1E1E' : '#F5F5F5',
+                level2: theme === 'dark' ? '#2A2A2A' : '#EEEEEE',
+                level3: theme === 'dark' ? '#363636' : '#E0E0E0',
+                level4: theme === 'dark' ? '#404040' : '#D5D5D5',
+                level5: theme === 'dark' ? '#4A4A4A' : '#CCCCCC',
+            },
+        },
+        fonts: {
+            displayLarge: themeObj.fonts.title,
+            displayMedium: themeObj.fonts.title,
+            displaySmall: themeObj.fonts.title,
+            headlineLarge: themeObj.fonts.title,
+            headlineMedium: themeObj.fonts.title,
+            headlineSmall: themeObj.fonts.title,
+            titleLarge: themeObj.fonts.title,
+            titleMedium: themeObj.fonts.title,
+            titleSmall: themeObj.fonts.title,
+            labelLarge: themeObj.fonts.label,
+            labelMedium: themeObj.fonts.label,
+            labelSmall: themeObj.fonts.label,
+            bodyLarge: themeObj.fonts.body,
+            bodyMedium: themeObj.fonts.body,
+            bodySmall: themeObj.fonts.body,
+            default: {
+                fontFamily: themeObj.fonts.body.fontFamily || undefined,
+                fontWeight: themeObj.fonts.body.fontWeight || 'normal',
+                letterSpacing: 0,
+            },
+        },
+    };
+    // Merge with overrides if provided (only if it's an object, not a string)
+    if (themeOverrides && typeof themeOverrides === 'object') {
+        return {
+            ...internalTheme,
+            ...themeOverrides,
+            colors: {
+                ...internalTheme.colors,
+                ...(themeOverrides.colors || {}),
+            },
+            fonts: {
+                ...internalTheme.fonts,
+                ...(themeOverrides.fonts || {}),
+            },
+        };
+    }
+    return internalTheme;
+};
+exports.useInternalTheme = useInternalTheme;

package/src/ui/components/types.d.ts

@@ -0,0 +1,80 @@
+import type { TextStyle } from 'react-native';
+export type ThemeProp = Partial<InternalTheme> | 'light' | 'dark';
+export type MD3Elevation = 0 | 1 | 2 | 3 | 4 | 5;
+export type InternalTheme = {
+    version: 3;
+    isV3: true;
+    dark: boolean;
+    mode?: 'adaptive' | 'exact';
+    roundness: number;
+    animation: {
+        scale: number;
+        defaultAnimationDuration?: number;
+    };
+    colors: {
+        primary: string;
+        primaryContainer: string;
+        secondary: string;
+        secondaryContainer: string;
+        tertiary: string;
+        tertiaryContainer: string;
+        surface: string;
+        surfaceVariant: string;
+        surfaceDisabled: string;
+        background: string;
+        error: string;
+        errorContainer: string;
+        onPrimary: string;
+        onPrimaryContainer: string;
+        onSecondary: string;
+        onSecondaryContainer: string;
+        onTertiary: string;
+        onTertiaryContainer: string;
+        onSurface: string;
+        onSurfaceVariant: string;
+        onSurfaceDisabled: string;
+        onError: string;
+        onErrorContainer: string;
+        onBackground: string;
+        outline: string;
+        outlineVariant: string;
+        inverseSurface: string;
+        inverseOnSurface: string;
+        inversePrimary: string;
+        shadow: string;
+        scrim: string;
+        backdrop: string;
+        elevation: {
+            level0: string;
+            level1: string;
+            level2: string;
+            level3: string;
+            level4: string;
+            level5: string;
+        };
+        text?: string;
+        disabled?: string;
+        placeholder?: string;
+    };
+    fonts: {
+        displayLarge: TextStyle;
+        displayMedium: TextStyle;
+        displaySmall: TextStyle;
+        headlineLarge: TextStyle;
+        headlineMedium: TextStyle;
+        headlineSmall: TextStyle;
+        titleLarge: TextStyle;
+        titleMedium: TextStyle;
+        titleSmall: TextStyle;
+        labelLarge: TextStyle;
+        labelMedium: TextStyle;
+        labelSmall: TextStyle;
+        bodyLarge: TextStyle;
+        bodyMedium: TextStyle;
+        bodySmall: TextStyle;
+        default: TextStyle;
+        regular?: TextStyle;
+    };
+};
+export type $Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type $RemoveChildren<T extends React.ComponentType<any>> = $Omit<React.ComponentPropsWithoutRef<T>, 'children'>;

package/src/ui/components/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/ui/components/utils/forwardRef.d.ts

@@ -0,0 +1,11 @@
+import type { ForwardRefRenderFunction, PropsWithoutRef, RefAttributes, ForwardRefExoticComponent } from 'react';
+export type ForwardRefComponent<T, P = {}> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
+/**
+ * TypeScript generated a large union of props from `ViewProps` in
+ * `d.ts` files when using `React.forwardRef`. To prevent this
+ * `ForwardRefComponent` was created and exported. Use this
+ * `forwardRef` instead of `React.forwardRef` so you don't have to
+ * import `ForwardRefComponent`.
+ * More info: https://github.com/callstack/react-native-paper/pull/3603
+ */
+export declare const forwardRef: <T, P = {}>(render: ForwardRefRenderFunction<T, PropsWithoutRef<P>>) => ForwardRefComponent<T, P>;

package/src/ui/components/utils/forwardRef.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardRef = void 0;
+const React = __importStar(require("react"));
+/**
+ * TypeScript generated a large union of props from `ViewProps` in
+ * `d.ts` files when using `React.forwardRef`. To prevent this
+ * `ForwardRefComponent` was created and exported. Use this
+ * `forwardRef` instead of `React.forwardRef` so you don't have to
+ * import `ForwardRefComponent`.
+ * More info: https://github.com/callstack/react-native-paper/pull/3603
+ */
+exports.forwardRef = React.forwardRef;

package/src/ui/components/utils/hasTouchHandler.d.ts

@@ -0,0 +1,5 @@
+import type { GestureResponderEvent } from 'react-native';
+declare const touchableEvents: readonly ["onPress", "onLongPress", "onPressIn", "onPressOut"];
+type TouchableEventObject = Partial<Record<(typeof touchableEvents)[number], (event: GestureResponderEvent) => void>>;
+export default function hasTouchHandler(touchableEventObject: TouchableEventObject): boolean;
+export {};

package/src/ui/components/utils/hasTouchHandler.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hasTouchHandler;
+const touchableEvents = [
+    'onPress',
+    'onLongPress',
+    'onPressIn',
+    'onPressOut',
+];
+function hasTouchHandler(touchableEventObject) {
+    return touchableEvents.some((event) => {
+        return Boolean(touchableEventObject[event]);
+    });
+}

package/src/ui/components/utils/roundLayoutSize.d.ts

@@ -0,0 +1 @@
+export declare const roundLayoutSize: (size: number) => number;

package/src/ui/components/utils/roundLayoutSize.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundLayoutSize = void 0;
+const roundLayoutSize = (size) => Math.round(size * 1000) / 1000;
+exports.roundLayoutSize = roundLayoutSize;

package/src/ui/components/utils/splitStyles.d.ts

@@ -0,0 +1,19 @@
+import type { ViewStyle } from 'react-native';
+type FiltersArray = readonly ((style: keyof ViewStyle) => boolean)[];
+type MappedTuple<Tuple extends FiltersArray> = {
+    [Index in keyof Tuple]: ViewStyle;
+} & {
+    length: Tuple['length'];
+};
+/**
+ * Utility function to extract styles in separate objects
+ *
+ * @param styles The style object you want to filter
+ * @param filters The filters by which you want to split the styles
+ * @returns An array of filtered style objects:
+ * - The first style object contains the properties that didn't match any filter
+ * - After that there will be a style object for each filter you passed in the same order as the matching filters
+ * - A style property will exist in a single style object, the first filter it matched
+ */
+export declare function splitStyles<Tuple extends FiltersArray>(styles: ViewStyle, ...filters: Tuple): [ViewStyle, ...MappedTuple<Tuple>];
+export {};

package/src/ui/components/utils/splitStyles.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitStyles = splitStyles;
+/**
+ * Utility function to extract styles in separate objects
+ *
+ * @param styles The style object you want to filter
+ * @param filters The filters by which you want to split the styles
+ * @returns An array of filtered style objects:
+ * - The first style object contains the properties that didn't match any filter
+ * - After that there will be a style object for each filter you passed in the same order as the matching filters
+ * - A style property will exist in a single style object, the first filter it matched
+ */
+function splitStyles(styles, ...filters) {
+    if (process.env.NODE_ENV !== 'production' && filters.length === 0) {
+        console.error('No filters were passed when calling splitStyles');
+    }
+    // `Object.entries` will be used to iterate over the styles and `Object.fromEntries` will be called before returning
+    // Entries which match the given filters will be temporarily stored in `newStyles`
+    const newStyles = filters.map(() => []);
+    // Entries which match no filter
+    const rest = [];
+    // Iterate every style property
+    outer: for (const item of Object.entries(styles)) {
+        // Check each filter
+        for (let i = 0; i < filters.length; i++) {
+            // Check if filter matches
+            if (filters[i](item[0])) {
+                newStyles[i].push(item); // Push to temporary filtered entries array
+                continue outer; // Skip to checking next style property
+            }
+        }
+        // Adds to rest styles if not filtered
+        rest.push(item);
+    }
+    // Put unmatched styles in the beginning
+    newStyles.unshift(rest);
+    // Convert arrays of entries into objects
+    return newStyles.map((styles) => Object.fromEntries(styles));
+}

package/src/ui/constants/iconColors.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Icon color helpers and semantic mappings
+ * Provides easy access to icon colors from the theme system
+ */
+/**
+ * Get icon colors for a specific theme
+ */
+export declare const getIconColors: (theme: "light" | "dark") => {
+    text: string;
+    background: string;
+    inputBackground: string;
+    tint: string;
+    icon: string;
+    tabIconDefault: string;
+    tabIconSelected: string;
+    card: string;
+    border: string;
+    secondaryText: string;
+    avatarBackground: string;
+    avatarText: string;
+    sidebarBackground: string;
+    sidebarItemActiveBackground: string;
+    sidebarItemActiveText: string;
+    sidebarIconHome: string;
+    sidebarIconPersonalInfo: string;
+    sidebarIconSecurity: string;
+    sidebarIconPassword: string;
+    sidebarIconDevices: string;
+    sidebarIconData: string;
+    sidebarIconSharing: string;
+    sidebarIconFamily: string;
+    sidebarIconPayments: string;
+    sidebarIconStorage: string;
+    iconHome: string;
+    iconPrimary: string;
+    iconPersonalInfo: string;
+    iconSuccess: string;
+    iconSecurity: string;
+    iconData: string;
+    iconPurple: string;
+    iconSharing: string;
+    iconRed: string;
+    iconPayments: string;
+    iconGold: string;
+    iconStorage: string;
+    iconOrange: string;
+} | {
+    text: string;
+    background: string;
+    inputBackground: string;
+    tint: string;
+    icon: string;
+    tabIconDefault: string;
+    tabIconSelected: string;
+    card: string;
+    border: string;
+    secondaryText: string;
+    avatarBackground: string;
+    avatarText: string;
+    sidebarBackground: string;
+    sidebarItemActiveBackground: string;
+    sidebarItemActiveText: string;
+    sidebarIconHome: string;
+    sidebarIconPersonalInfo: string;
+    sidebarIconSecurity: string;
+    sidebarIconPassword: string;
+    sidebarIconDevices: string;
+    sidebarIconData: string;
+    sidebarIconSharing: string;
+    sidebarIconFamily: string;
+    sidebarIconPayments: string;
+    sidebarIconStorage: string;
+    iconHome: string;
+    iconPrimary: string;
+    iconPersonalInfo: string;
+    iconSuccess: string;
+    iconSecurity: string;
+    iconData: string;
+    iconPurple: string;
+    iconSharing: string;
+    iconRed: string;
+    iconPayments: string;
+    iconGold: string;
+    iconStorage: string;
+    iconOrange: string;
+};
+/**
+ * Semantic icon color mappings
+ * Maps common icon types to their appropriate theme colors
+ */
+export declare const IconColorMap: {
+    readonly profile: "iconPersonalInfo";
+    readonly personalInfo: "iconPersonalInfo";
+    readonly editProfile: "iconPersonalInfo";
+    readonly security: "iconSecurity";
+    readonly password: "iconSecurity";
+    readonly lock: "iconSecurity";
+    readonly shield: "iconSecurity";
+    readonly document: "iconSecurity";
+    readonly rules: "iconSecurity";
+    readonly file: "iconSecurity";
+    readonly premium: "iconPayments";
+    readonly star: "iconPayments";
+    readonly leaderboard: "iconPayments";
+    readonly trophy: "iconPayments";
+    readonly rewards: "iconPayments";
+    readonly gift: "iconStorage";
+    readonly notifications: "iconStorage";
+    readonly warning: "iconStorage";
+    readonly bell: "iconStorage";
+    readonly help: "iconPersonalInfo";
+    readonly faq: "iconPersonalInfo";
+    readonly question: "iconPersonalInfo";
+    readonly data: "iconData";
+    readonly privacy: "iconData";
+    readonly settings: "iconData";
+    readonly sharing: "iconSharing";
+    readonly social: "iconSharing";
+    readonly primary: "iconPrimary";
+    readonly home: "iconHome";
+};
+/**
+ * Get icon color by semantic name
+ */
+export declare const getIconColor: (semanticName: keyof typeof IconColorMap, theme?: "light" | "dark") => string;
+/**
+ * Helper to get icon color for common use cases
+ */
+export declare const useIconColor: (semanticName: keyof typeof IconColorMap, theme: "light" | "dark") => string;

package/src/ui/constants/iconColors.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Icon color helpers and semantic mappings
+ * Provides easy access to icon colors from the theme system
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIconColor = exports.getIconColor = exports.IconColorMap = exports.getIconColors = void 0;
+const theme_1 = require("./theme");
+/**
+ * Get icon colors for a specific theme
+ */
+const getIconColors = (theme) => {
+    return theme_1.Colors[theme];
+};
+exports.getIconColors = getIconColors;
+/**
+ * Semantic icon color mappings
+ * Maps common icon types to their appropriate theme colors
+ */
+exports.IconColorMap = {
+    // Profile and personal information
+    profile: 'iconPersonalInfo',
+    personalInfo: 'iconPersonalInfo',
+    editProfile: 'iconPersonalInfo',
+    // Security and authentication
+    security: 'iconSecurity',
+    password: 'iconSecurity',
+    lock: 'iconSecurity',
+    shield: 'iconSecurity',
+    // Documents and rules
+    document: 'iconSecurity',
+    rules: 'iconSecurity',
+    file: 'iconSecurity',
+    // Premium and special features
+    premium: 'iconPayments',
+    star: 'iconPayments',
+    leaderboard: 'iconPayments',
+    trophy: 'iconPayments',
+    // Rewards and gifts
+    rewards: 'iconPayments',
+    gift: 'iconStorage',
+    // Notifications and warnings
+    notifications: 'iconStorage',
+    warning: 'iconStorage',
+    bell: 'iconStorage',
+    // Help and FAQ
+    help: 'iconPersonalInfo',
+    faq: 'iconPersonalInfo',
+    question: 'iconPersonalInfo',
+    // Data and privacy
+    data: 'iconData',
+    privacy: 'iconData',
+    settings: 'iconData',
+    // Sharing and social
+    sharing: 'iconSharing',
+    social: 'iconSharing',
+    // Primary actions
+    primary: 'iconPrimary',
+    home: 'iconHome',
+};
+/**
+ * Get icon color by semantic name
+ */
+const getIconColor = (semanticName, theme = 'light') => {
+    const colorKey = exports.IconColorMap[semanticName];
+    const colors = (0, exports.getIconColors)(theme);
+    return colors[colorKey];
+};
+exports.getIconColor = getIconColor;
+/**
+ * Helper to get icon color for common use cases
+ */
+const useIconColor = (semanticName, theme) => {
+    return (0, exports.getIconColor)(semanticName, theme);
+};
+exports.useIconColor = useIconColor;