@umituz/react-native-settings 4.17.27 → 4.17.31

package/src/presentation/screens/components/sections/SupportSettingsSection.tsx

@@ -0,0 +1,84 @@
+import React from "react";
+import { useLocalization } from "@umituz/react-native-localization";
+import { SupportSection } from "../../../../domains/feedback/presentation/components/SupportSection";
+import { FAQSection } from "../../../../domains/faqs/presentation/components/FAQSection";
+import { SettingsSection } from "../../../components/SettingsSection";
+import { SettingItem } from "../../../components/SettingItem";
+
+interface SupportSettingsSectionProps {
+    features: any;
+    normalizedConfig: any;
+}
+
+export const SupportSettingsSection: React.FC<SupportSettingsSectionProps> = ({
+    features,
+    normalizedConfig,
+}) => {
+    const { t } = useLocalization();
+
+    if (!(features.feedback || features.rating || features.faqs)) return null;
+
+    return (
+        <SettingsSection title={t("settings.support.title")}>
+            {(features.feedback || features.rating) && (
+                <SupportSection
+                    renderSection={(props: any) => <>{props.children}</>}
+                    renderItem={(props: any) => <SettingItem {...props} />}
+                    feedbackConfig={{
+                        enabled: features.feedback,
+                        config: {
+                            ...normalizedConfig.feedback.config,
+                            title: normalizedConfig.feedback.config?.title || t("settings.feedback.title"),
+                            description: normalizedConfig.feedback.config?.description || t("settings.feedback.description"),
+                        }
+                    }}
+                    ratingConfig={{
+                        enabled: features.rating,
+                        config: {
+                            ...normalizedConfig.rating.config,
+                            title: normalizedConfig.rating.config?.title || t("settings.rating.title"),
+                            description: normalizedConfig.rating.config?.description || t("settings.rating.description"),
+                        }
+                    }}
+                    feedbackModalTexts={{
+                        title: t("settings.feedback.modal.title"),
+                        ratingLabel: t("settings.feedback.modal.ratingLabel"),
+                        descriptionPlaceholder: t("settings.feedback.modal.descriptionPlaceholder"),
+                        submitButton: t("settings.feedback.modal.submitButton"),
+                        submittingButton: t("settings.feedback.modal.submittingButton"),
+                        feedbackTypes: [
+                            { type: 'general', label: t("settings.feedback.types.general") },
+                            { type: 'bug_report', label: t("settings.feedback.types.bugReport") },
+                            { type: 'feature_request', label: t("settings.feedback.types.featureRequest") },
+                            { type: 'improvement', label: t("settings.feedback.types.improvement") },
+                            { type: 'other', label: t("settings.feedback.types.other") },
+                        ],
+                        defaultTitle: (type) => {
+                            const titles: Record<string, string> = {
+                                general: t("settings.feedback.types.general"),
+                                bug_report: t("settings.feedback.types.bugReport"),
+                                feature_request: t("settings.feedback.types.featureRequest"),
+                                improvement: t("settings.feedback.types.improvement"),
+                                other: t("settings.feedback.types.other"),
+                            };
+                            return titles[type] || type;
+                        },
+                    }}
+                />
+            )}
+
+            {features.faqs && (
+                <FAQSection
+                    renderSection={(props: any) => <>{props.children}</>}
+                    renderItem={(props: any) => <SettingItem {...props} />}
+                    config={{
+                        enabled: features.faqs,
+                        ...normalizedConfig.faqs.config,
+                        title: normalizedConfig.faqs.config?.title || t("settings.faqs.title"),
+                        description: normalizedConfig.faqs.config?.description || t("settings.faqs.description"),
+                    }}
+                />
+            )}
+        </SettingsSection>
+    );
+};

package/src/presentation/screens/hooks/useFeatureDetection.ts

@@ -6,20 +6,6 @@
 import { useMemo } from "react";
 import type { NormalizedConfig } from "../utils/normalizeConfig";
 
-// Optional notification service
-let notificationService: {
-  hasPermissions?: () => Promise<boolean>;
-  requestPermissions?: () => Promise<void>;
-} | null = null;
-try {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const module = require("@umituz/react-native-notifications");
-  if (module?.notificationService && typeof module.notificationService === 'object') {
-    notificationService = module.notificationService;
-  }
-} catch {
-  // Package not available
-}
 
 /**
  * Check if navigation screen exists
@@ -75,8 +61,7 @@ export function useFeatureDetection(
       faqs,
     } = normalizedConfig;
 
-    const notificationServiceAvailable =
-      options?.notificationServiceAvailable ?? notificationService !== null;
+    const notificationServiceAvailable = !!options?.notificationServiceAvailable;
 
     return {
       appearance:

package/src/presentation/screens/types/FeatureConfig.ts

@@ -149,22 +149,29 @@ export interface UserProfileConfig {
   accountSettingsRoute?: string;
 }
 
+/**
+ * Subscription Settings Item Config
+ * Simplified config for settings list item display
+ */
+export interface SubscriptionSettingsItemConfig {
+  title: string;
+  description?: string;
+  isPremium: boolean;
+  statusLabel: string;
+  icon?: string;
+  onPress?: () => void;
+}
+
 /**
  * Subscription Settings Configuration
- * App must provide all data via sectionConfig (no internal fetch)
+ * App must provide all data via props (no internal fetch)
  */
 export interface SubscriptionConfig {
   /** Show subscription section */
   enabled?: FeatureVisibility;
-  /** Custom subscription title */
-  title?: string;
-  /** Custom subscription description */
-  description?: string;
-  /** Custom icon name (Ionicons) */
-  icon?: string;
-  /** Custom section title for grouping */
-  sectionTitle?: string;
-  /** Section configuration (app provides all data) */
+  /** Settings item configuration (for settings list display) */
+  settingsItem?: SubscriptionSettingsItemConfig;
+  /** Detail section configuration (for detail screen) */
   sectionConfig?: {
     statusType: "active" | "expired" | "none";
     isPremium: boolean;
@@ -248,3 +255,21 @@ export interface RatingConfig {
   /** Custom handler for rating action (e.g. open store review) */
   onRate?: () => void;
 }
+
+/**
+ * Cloud Sync Settings Configuration
+ */
+export interface CloudSyncConfig {
+  /** Enable cloud sync feature */
+  enabled?: FeatureVisibility;
+  /** Custom title for the sync section */
+  title?: string;
+  /** Custom description for the sync toggle */
+  description?: string;
+  /** Custom icon name (Ionicons) */
+  icon?: string;
+  /** Custom section title for grouping */
+  sectionTitle?: string;
+  /** Firestore collection name */
+  collectionName?: string;
+}

package/src/presentation/screens/types/SettingsConfig.ts

@@ -16,6 +16,7 @@ import type {
   FeedbackConfig,
   RatingConfig,
   FAQConfig,
+  CloudSyncConfig,
 } from "./FeatureConfig";
 
 /**
@@ -115,6 +116,12 @@ export interface SettingsConfig {
    */
   faqs?: FeatureVisibility | FAQConfig;
 
+  /**
+   * Cloud sync settings configuration
+   * @default false
+   */
+  cloudSync?: FeatureVisibility | CloudSyncConfig;
+
   /**
    * Custom empty state text when no settings are available
    */

package/src/presentation/screens/types/index.ts

@@ -13,6 +13,7 @@ export type {
   DisclaimerConfig,
   UserProfileConfig,
   SubscriptionConfig,
+  SubscriptionSettingsItemConfig,
   FeedbackConfig,
   RatingConfig,
   FAQConfig,

package/src/domains/appearance/infrastructure/services/appearanceService.ts

@@ -1,301 +0,0 @@
-/**
- * Appearance Service
- *
- * Business logic for appearance management
- * Single Responsibility: Business logic only, no presentation logic
- */
-
-import { AppearanceStorage } from "../storage/appearanceStorage";
-import { useAppearanceStore } from "../stores/appearanceStore";
-import {
-  useTheme,
-  useDesignSystemTheme,
-  type ThemeMode,
-  type CustomThemeColors,
-} from "@umituz/react-native-design-system";
-import { getSystemTheme } from "./systemThemeDetection";
-import { validateAppearanceSettings } from "./validation";
-import type { AppearanceSettings } from "../../types";
-
-export class AppearanceService {
-  private readonly DEFAULT_THEME_MODE: ThemeMode = "light"; // Use system preference as default
-  private _isInitialized = false;
-  private initPromise: Promise<void> | null = null;
-
-  /**
-   * Initialize appearance settings
-   * Business logic: Coordinate initialization process
-   */
-  async initialize(): Promise<void> {
-    // Prevent multiple initializations
-    if (this._isInitialized || this.initPromise) {
-      return this.initPromise || Promise.resolve();
-    }
-
-    this.initPromise = this._performInitialization();
-    return this.initPromise;
-  }
-
-  private async _performInitialization(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Initializing appearance settings");
-      }
-
-      const savedSettings = await AppearanceStorage.getSettings();
-
-      if (savedSettings) {
-        // Load saved settings
-        useAppearanceStore.getState().setSettings(savedSettings);
-        useAppearanceStore.getState().setInitialized(true);
-
-        // Sync with design system theme
-        await this.syncWithDesignSystem(savedSettings);
-      } else {
-        // Use system theme as default, fallback to light
-        const systemTheme = getSystemTheme();
-        const defaultSettings: AppearanceSettings = {
-          themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-        };
-
-        useAppearanceStore.getState().setSettings(defaultSettings);
-        useAppearanceStore.getState().setInitialized(true);
-
-        // Sync with design system theme
-        await this.syncWithDesignSystem(defaultSettings);
-      }
-
-      this._isInitialized = true;
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Initialization failed:", error);
-      }
-
-      // Fallback to system theme or light mode on error
-      const systemTheme = getSystemTheme();
-      const fallbackSettings: AppearanceSettings = {
-        themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-      };
-
-      useAppearanceStore.getState().setSettings(fallbackSettings);
-      useAppearanceStore.getState().setInitialized(true);
-
-      await this.syncWithDesignSystem(fallbackSettings);
-      this._isInitialized = true;
-    } finally {
-      this.initPromise = null;
-    }
-  }
-
-  /**
-   * Get current theme mode
-   * Business logic: Provide theme mode data
-   */
-  getThemeMode(): ThemeMode {
-    return useAppearanceStore.getState().settings.themeMode;
-  }
-
-  /**
-   * Set theme mode
-   * Business logic: Validate and apply theme mode
-   */
-  async setThemeMode(mode: ThemeMode): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Setting theme mode:", mode);
-      }
-
-      // Validate theme mode
-      if (!mode || (mode !== 'light' && mode !== 'dark')) {
-        throw new Error(`Invalid theme mode: ${mode}`);
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        themeMode: mode,
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateThemeMode(mode);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design system
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to set theme mode:", errorMessage);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Toggle theme mode
-   * Business logic: Toggle between light and dark
-   */
-  async toggleTheme(): Promise<void> {
-    try {
-      const currentMode = this.getThemeMode();
-      const newMode: ThemeMode = 
-        currentMode === "light" ? "dark" : "light";
-      
-      await this.setThemeMode(newMode);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to toggle theme:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Get custom colors
-   * Business logic: Provide custom colors data
-   */
-  getCustomColors(): CustomThemeColors | undefined {
-    return useAppearanceStore.getState().settings.customColors;
-  }
-
-  /**
-   * Set custom colors
-   * Business logic: Validate and apply custom colors
-   */
-  async setCustomColors(colors: CustomThemeColors): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Setting custom colors:", colors);
-      }
-
-      // Validate custom colors
-      const validation = validateAppearanceSettings({ customColors: colors });
-      if (!validation.isValid) {
-        throw new Error(`Invalid custom colors: ${validation.errors.join(', ')}`);
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        customColors: {
-          ...currentSettings.customColors,
-          ...colors,
-        },
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateCustomColors(newSettings.customColors);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design system
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to set custom colors:", errorMessage);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Reset custom colors to defaults
-   * Business logic: Reset custom colors
-   */
-  async resetCustomColors(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Resetting custom colors");
-      }
-
-      const currentSettings = useAppearanceStore.getState().settings;
-      const newSettings: AppearanceSettings = {
-        ...currentSettings,
-        customColors: undefined,
-      };
-
-      // Update store
-      useAppearanceStore.getState().updateCustomColors(undefined);
-
-      // Persist to storage
-      await AppearanceStorage.setSettings(newSettings);
-
-      // Sync with design System
-      await this.syncWithDesignSystem(newSettings);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to reset custom colors:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Reset all appearance settings
-   * Business logic: Reset all settings
-   */
-  async reset(): Promise<void> {
-    try {
-      if (__DEV__) {
-        console.log("[AppearanceService] Resetting all appearance settings");
-      }
-
-      // Clear storage
-      await AppearanceStorage.clear();
-
-      // Reset store to defaults
-      useAppearanceStore.getState().resetState();
-
-      // Reset design system theme to system preference
-      const systemTheme = getSystemTheme();
-      const defaultSettings: AppearanceSettings = {
-        themeMode: systemTheme || this.DEFAULT_THEME_MODE,
-      };
-
-      await this.syncWithDesignSystem(defaultSettings);
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to reset appearance:", error);
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Check if appearance is initialized
-   * Business logic: Provide initialization status
-   */
-  isInitialized(): boolean {
-    return useAppearanceStore.getState().isInitialized;
-  }
-
-  /**
-   * Sync appearance settings with design system
-   * Private helper method
-   */
-  private async syncWithDesignSystem(settings: AppearanceSettings): Promise<void> {
-    try {
-      // Sync theme mode
-      useTheme.getState().setThemeMode(settings.themeMode);
-      useDesignSystemTheme.getState().setThemeMode(settings.themeMode);
-
-      // Sync custom colors
-      useDesignSystemTheme.getState().setCustomColors(settings.customColors);
-
-      if (__DEV__) {
-        console.log("[AppearanceService] Synced with design system:", settings);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[AppearanceService] Failed to sync with design system:", error);
-      }
-      throw error;
-    }
-  }
-}
-
-export const appearanceService = new AppearanceService();

package/src/domains/appearance/infrastructure/storage/appearanceStorage.ts

@@ -1,120 +0,0 @@
-/**
- * Appearance Storage Service
- *
- * Handles persistence of appearance settings using AsyncStorage
- * Single Responsibility: Pure storage operations only
- */
-
-import { storageRepository, unwrap } from "@umituz/react-native-storage";
-import type { ThemeMode } from "@umituz/react-native-design-system";
-import type { AppearanceSettings } from "../../types";
-
-const STORAGE_KEYS = {
-  APPEARANCE_SETTINGS: "@appearance_settings",
-} as const;
-
-const DEFAULT_SETTINGS: AppearanceSettings = {
-  themeMode: "dark",
-};
-
-export class AppearanceStorage {
-  /**
-   * Get saved appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async getSettings(): Promise<AppearanceSettings | null> {
-    try {
-      const result = await storageRepository.getItem<AppearanceSettings>(
-        STORAGE_KEYS.APPEARANCE_SETTINGS,
-        DEFAULT_SETTINGS,
-      );
-      const data = unwrap(result, DEFAULT_SETTINGS);
-      return data;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async setSettings(settings: AppearanceSettings): Promise<void> {
-    const result = await storageRepository.setItem(
-      STORAGE_KEYS.APPEARANCE_SETTINGS,
-      settings,
-    );
-    if (!result.success) {
-      throw new Error("Failed to save appearance settings");
-    }
-  }
-
-  /**
-   * Get saved theme mode
-   * Pure storage operation - no business logic
-   */
-  static async getThemeMode(): Promise<ThemeMode | null> {
-    try {
-      const settings = await this.getSettings();
-      return settings?.themeMode || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save theme mode
-   * Pure storage operation - no business logic
-   */
-  static async setThemeMode(themeMode: ThemeMode): Promise<void> {
-    const currentSettings = (await this.getSettings()) || {
-      themeMode: "dark",
-    };
-    await this.setSettings({
-      ...currentSettings,
-      themeMode,
-    });
-  }
-
-  /**
-   * Get custom theme colors
-   * Pure storage operation - no business logic
-   */
-  static async getCustomColors() {
-    try {
-      const settings = await this.getSettings();
-      return settings?.customColors || null;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Save custom theme colors
-   * Pure storage operation - no business logic
-   */
-  static async setCustomColors(
-    customColors: AppearanceSettings["customColors"],
-  ): Promise<void> {
-    const currentSettings = (await this.getSettings()) || {
-      themeMode: "dark",
-    };
-    await this.setSettings({
-      ...currentSettings,
-      customColors,
-    });
-  }
-
-  /**
-   * Clear all appearance settings
-   * Pure storage operation - no business logic
-   */
-  static async clear(): Promise<void> {
-    const result = await storageRepository.removeItem(
-      STORAGE_KEYS.APPEARANCE_SETTINGS,
-    );
-    if (!result.success) {
-      throw new Error("Failed to clear appearance settings");
-    }
-  }
-}