@nextsparkjs/core 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/bin/wizard/validators/index.ts

@@ -0,0 +1,111 @@
+/**
+ * Validators Index
+ *
+ * Post-generation validation for NextSpark wizard.
+ * Validates the generated theme structure, TypeScript compilation, and i18n completeness.
+ */
+
+import type { WizardConfig } from '../types.js'
+import { validateTypeScript } from './typescript.js'
+import { validateRequiredFiles } from './files.js'
+import { validateI18n } from './i18n.js'
+
+/**
+ * Represents a validation error that must be fixed
+ */
+export interface ValidationError {
+  /** Category of the error (typescript, files, i18n, etc.) */
+  type: string
+  /** Human-readable error message */
+  message: string
+  /** Optional file path related to the error */
+  file?: string
+}
+
+/**
+ * Represents a validation warning that should be reviewed
+ */
+export interface ValidationWarning {
+  /** Category of the warning */
+  type: string
+  /** Human-readable warning message */
+  message: string
+}
+
+/**
+ * Result of the validation process
+ */
+export interface ValidationResult {
+  /** Whether validation passed with no errors */
+  valid: boolean
+  /** List of errors that must be fixed */
+  errors: ValidationError[]
+  /** List of warnings that should be reviewed */
+  warnings: ValidationWarning[]
+}
+
+/**
+ * Validate the generated theme structure and content
+ *
+ * Runs all validation checks:
+ * 1. File structure validation - checks required directories and files
+ * 2. TypeScript validation - runs tsc --noEmit to check for type errors
+ * 3. i18n validation - verifies translation completeness
+ *
+ * @param themePath - Absolute path to the generated theme directory
+ * @param config - Wizard configuration used during generation
+ * @returns ValidationResult with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = await validateGeneratedTheme(
+ *   '/path/to/contents/themes/my-app',
+ *   wizardConfig
+ * )
+ *
+ * if (!result.valid) {
+ *   console.error('Validation failed:', result.errors)
+ * }
+ * ```
+ */
+export async function validateGeneratedTheme(
+  themePath: string,
+  config: WizardConfig
+): Promise<ValidationResult> {
+  const allErrors: ValidationError[] = []
+  const allWarnings: ValidationWarning[] = []
+
+  // 1. Validate file structure first (fast check)
+  const filesResult = await validateRequiredFiles(themePath, config)
+  allErrors.push(...filesResult.errors)
+  allWarnings.push(...filesResult.warnings)
+
+  // 2. Validate i18n completeness
+  const i18nResult = await validateI18n(themePath, config)
+  allErrors.push(...i18nResult.errors)
+  allWarnings.push(...i18nResult.warnings)
+
+  // 3. Validate TypeScript (slower, run last)
+  // Only run if no critical file structure errors
+  const hasCriticalFileErrors = filesResult.errors.some(
+    e => e.message.includes('Theme directory not found') ||
+         e.message.includes('Required directory missing')
+  )
+
+  if (!hasCriticalFileErrors) {
+    const tsResult = await validateTypeScript(themePath)
+    allErrors.push(...tsResult.errors)
+    allWarnings.push(...tsResult.warnings)
+  }
+
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors,
+    warnings: allWarnings,
+  }
+}
+
+// Re-export individual validators for granular usage
+export { validateTypeScript } from './typescript.js'
+export { validateRequiredFiles } from './files.js'
+export { validateI18n } from './i18n.js'

package/dist/bin/wizard/validators/typescript.ts

@@ -0,0 +1,133 @@
+/**
+ * TypeScript Validator
+ *
+ * Validates TypeScript compilation for the generated theme.
+ */
+
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import path from 'path'
+import fs from 'fs-extra'
+import type { ValidationError, ValidationWarning } from './index.js'
+
+const execAsync = promisify(exec)
+
+/**
+ * Parse TypeScript compiler output to extract errors
+ */
+function parseTypeScriptErrors(output: string, themePath: string): ValidationError[] {
+  const errors: ValidationError[] = []
+  const lines = output.split('\n')
+
+  for (const line of lines) {
+    // Match TypeScript error format: file(line,col): error TSxxxx: message
+    const match = line.match(/^(.+)\((\d+),(\d+)\):\s*error\s+(TS\d+):\s*(.+)$/)
+    if (match) {
+      const [, file, lineNum, col, code, message] = match
+      errors.push({
+        type: 'typescript',
+        message: `${code}: ${message} (line ${lineNum}, col ${col})`,
+        file: file.replace(themePath, '').replace(/^[/\\]/, ''),
+      })
+      continue
+    }
+
+    // Match alternative format: file:line:col - error TSxxxx: message
+    const altMatch = line.match(/^(.+):(\d+):(\d+)\s*-\s*error\s+(TS\d+):\s*(.+)$/)
+    if (altMatch) {
+      const [, file, lineNum, col, code, message] = altMatch
+      errors.push({
+        type: 'typescript',
+        message: `${code}: ${message} (line ${lineNum}, col ${col})`,
+        file: file.replace(themePath, '').replace(/^[/\\]/, ''),
+      })
+    }
+  }
+
+  return errors
+}
+
+/**
+ * Validate TypeScript compilation for the generated theme
+ *
+ * Runs `tsc --noEmit` to check for type errors without generating output files.
+ *
+ * @param themePath - Absolute path to the theme directory
+ * @returns Object containing errors and warnings from compilation
+ */
+export async function validateTypeScript(
+  themePath: string
+): Promise<{ errors: ValidationError[]; warnings: ValidationWarning[] }> {
+  const errors: ValidationError[] = []
+  const warnings: ValidationWarning[] = []
+
+  // Check if tsconfig.json exists in project root or theme
+  const projectRoot = process.cwd()
+  const projectTsConfig = path.join(projectRoot, 'tsconfig.json')
+  const themeTsConfig = path.join(themePath, 'tsconfig.json')
+
+  let tsConfigPath: string | null = null
+  if (await fs.pathExists(themeTsConfig)) {
+    tsConfigPath = themeTsConfig
+  } else if (await fs.pathExists(projectTsConfig)) {
+    tsConfigPath = projectTsConfig
+  }
+
+  if (!tsConfigPath) {
+    warnings.push({
+      type: 'typescript',
+      message: 'No tsconfig.json found. TypeScript validation skipped.',
+    })
+    return { errors, warnings }
+  }
+
+  try {
+    // Run tsc --noEmit to check for type errors
+    const tscPath = path.join(projectRoot, 'node_modules', '.bin', 'tsc')
+    const useLocalTsc = await fs.pathExists(tscPath)
+
+    const command = useLocalTsc
+      ? `"${tscPath}" --noEmit --project "${tsConfigPath}"`
+      : `npx tsc --noEmit --project "${tsConfigPath}"`
+
+    await execAsync(command, {
+      cwd: projectRoot,
+      timeout: 120000, // 2 minute timeout
+    })
+
+    // If we get here, compilation succeeded
+  } catch (error: unknown) {
+    // TypeScript exits with non-zero on errors
+    if (error && typeof error === 'object' && 'stdout' in error) {
+      const execError = error as { stdout?: string; stderr?: string; code?: number }
+      const output = execError.stdout || execError.stderr || ''
+
+      // Parse errors from output
+      const parsedErrors = parseTypeScriptErrors(output, themePath)
+      if (parsedErrors.length > 0) {
+        errors.push(...parsedErrors)
+      } else if (output.trim()) {
+        // If we couldn't parse but there's output, add generic error
+        errors.push({
+          type: 'typescript',
+          message: `TypeScript compilation failed: ${output.slice(0, 500)}`,
+        })
+      }
+    } else if (error instanceof Error) {
+      // Handle execution errors (e.g., tsc not found)
+      if (error.message.includes('ENOENT') || error.message.includes('not found')) {
+        warnings.push({
+          type: 'typescript',
+          message: 'TypeScript compiler not found. Run "npm install" first.',
+        })
+      } else {
+        errors.push({
+          type: 'typescript',
+          message: `TypeScript validation failed: ${error.message}`,
+        })
+      }
+    }
+  }
+
+  return { errors, warnings }
+}

package/dist/components/devtools/scheduled-actions/actions-table.js

@@ -15,7 +15,7 @@ import { Button } from "../../ui/button";
 import { ChevronDownIcon, ChevronRightIcon } from "lucide-react";
 import { sel } from "../../../lib/test";
 function ActionsTable({ actions }) {
-  const t = useTranslations("dev.scheduledActions");
+  const t = useTranslations("devtools.scheduledActions");
   const [expandedRows, setExpandedRows] = useState(/* @__PURE__ */ new Set());
   const toggleRow = (id) => {
     setExpandedRows((prev) => {

package/dist/components/devtools/scheduled-actions/filters.js

@@ -11,7 +11,7 @@ import {
 } from "../../ui/select";
 import { sel } from "../../../lib/test";
 function Filters({ filters, onFiltersChange, registeredActionTypes }) {
-  const t = useTranslations("dev.scheduledActions");
+  const t = useTranslations("devtools.scheduledActions");
   const handleStatusChange = (value) => {
     onFiltersChange({
       ...filters,

package/dist/hooks/useContentTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useContentTranslation.d.ts","sourceRoot":"","sources":["../../src/hooks/useContentTranslation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,oBAAoB,GAAE,MAAM,EAAO;aA8C/E,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;;kBAuBlD,MAAM,KAAG,OAAO;+BAeH,MAAM,OAAO,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;EAiBlG;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM;aAKhD,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;EAenE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;mBAKrD,MAAM;yBAMA,MAAM;kBAMb,MAAM;wBAMA,MAAM,QAAQ,MAAM;qBAUvB,MAAM;uBAMJ,MAAM;aA5HhB,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;;EAuInE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM;yBAK7B,MAAM;yBAKN,MAAM;0BAKL,MAAM;;;sBAeV,MAAM;kBAKV,MAAM;mBAKL,MAAM;aApLZ,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;EA4LnE"}
+{"version":3,"file":"useContentTranslation.d.ts","sourceRoot":"","sources":["../../src/hooks/useContentTranslation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,oBAAoB,GAAE,MAAM,EAAO;aA0C/E,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;;kBAuBlD,MAAM,KAAG,OAAO;+BAeH,MAAM,OAAO,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;EAiBlG;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM;aAKhD,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;EAenE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;mBAKrD,MAAM;yBAMA,MAAM;kBAMb,MAAM;wBAMA,MAAM,QAAQ,MAAM;qBAUvB,MAAM;uBAMJ,MAAM;aA5HhB,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;;;EAuInE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM;yBAK7B,MAAM;yBAKN,MAAM;0BAKL,MAAM;;;sBAeV,MAAM;kBAKV,MAAM;mBAKL,MAAM;aApLZ,MAAM,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;;EA4LnE"}

package/dist/hooks/useContentTranslation.js

@@ -7,7 +7,6 @@ function useEntityTranslation(entityName, additionalNamespaces = []) {
   const validationT = useTranslations("validation");
   const settingsT = useTranslations("settings");
   const dashboardT = useTranslations("dashboard");
-  const tasksT = useTranslations("tasks");
   const authT = useTranslations("auth");
   const publicT = useTranslations("public");
   const adminT = useTranslations("admin");
@@ -22,9 +21,6 @@ function useEntityTranslation(entityName, additionalNamespaces = []) {
     if (additionalNamespaces.includes("dashboard")) {
       translations.dashboard = dashboardT;
     }
-    if (additionalNamespaces.includes("tasks")) {
-      translations.tasks = tasksT;
-    }
     if (additionalNamespaces.includes("auth")) {
       translations.auth = authT;
     }
@@ -35,7 +31,7 @@ function useEntityTranslation(entityName, additionalNamespaces = []) {
       translations.admin = adminT;
     }
     return translations;
-  }, [additionalNamespaces, validationT, settingsT, dashboardT, tasksT, authT, publicT, adminT]);
+  }, [additionalNamespaces, validationT, settingsT, dashboardT, authT, publicT, adminT]);
   return useMemo(() => ({
     // Entity-specific translations with fallback to common
     t: (key, values) => {

package/dist/hooks/useEnsureUserMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEnsureUserMetadata.d.ts","sourceRoot":"","sources":["../../src/hooks/useEnsureUserMetadata.ts"],"names":[],"mappings":"AAMA,wBAAgB,qBAAqB,SAwEpC"}
+{"version":3,"file":"useEnsureUserMetadata.d.ts","sourceRoot":"","sources":["../../src/hooks/useEnsureUserMetadata.ts"],"names":[],"mappings":"AAMA,wBAAgB,qBAAqB,SAuEpC"}

package/dist/hooks/useEnsureUserMetadata.js

@@ -29,7 +29,6 @@ function useEnsureUserMetadata() {
                     sidebarCollapsed: false
                   },
                   securityPreferences: {
-                    twoFactorEnabled: false,
                     loginAlertsEnabled: true
                   },
                   notificationsPreferences: {

package/dist/hooks/useEntityTranslations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEntityTranslations.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityTranslations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM;;aA0C1B,MAAM,aAAa,MAAM,KAAG,MAAM;0BAkBrB,MAAM,KAAG,OAAO;;;;EAuB1D;AAED;;GAEG;AACH,wBAAgB,wBAAwB;;;;;EAkCvC"}
+{"version":3,"file":"useEntityTranslations.d.ts","sourceRoot":"","sources":["../../src/hooks/useEntityTranslations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM;;aAwC1B,MAAM,aAAa,MAAM,KAAG,MAAM;0BAkBrB,MAAM,KAAG,OAAO;;;;EAuB1D;AAED;;GAEG;AACH,wBAAgB,wBAAwB;;;;;EAmCvC"}

package/dist/hooks/useEntityTranslations.js

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useState } from "react";
 import { useLocale } from "next-intl";
-import { translationRegistry } from "../lib/translations/registry";
+import { TranslationService } from "../lib/services/translation.service";
+import { loadMergedTranslations } from "../lib/translations/registry";
 import { useEnabledEntities } from "./useEnabledEntities";
 function useEntityTranslations(entityName) {
   const locale = useLocale();
@@ -17,11 +18,8 @@ function useEntityTranslations(entityName) {
         setError(`Entity ${entityName} not found`);
         return;
       }
-      const entityTranslations = await translationRegistry.getEntityTranslation(
-        entityName,
-        locale,
-        entity
-      );
+      const activeTheme = process.env.NEXT_PUBLIC_ACTIVE_THEME || "default";
+      const entityTranslations = await TranslationService.loadEntity(activeTheme, entityName, locale);
       setTranslations(entityTranslations);
     } catch (err) {
       console.error(`Error loading translations for entity ${entityName}:`, err);
@@ -74,11 +72,11 @@ function useAllEntityTranslations() {
   const [allTranslations, setAllTranslations] = useState({});
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
-  const loadAllTranslations = useCallback(async () => {
+  const loadAllTranslationsCallback = useCallback(async () => {
     try {
       setIsLoading(true);
       setError(null);
-      const translations = await translationRegistry.loadAllTranslations(locale, entities);
+      const translations = await loadMergedTranslations(locale);
       setAllTranslations(translations);
     } catch (err) {
       console.error("Error loading all entity translations:", err);
@@ -86,17 +84,17 @@ function useAllEntityTranslations() {
     } finally {
       setIsLoading(false);
     }
-  }, [locale, entities]);
+  }, [locale]);
   useEffect(() => {
     if (!entitiesLoading && entities.length > 0) {
-      loadAllTranslations();
+      loadAllTranslationsCallback();
     }
-  }, [loadAllTranslations, entitiesLoading, entities.length]);
+  }, [loadAllTranslationsCallback, entitiesLoading, entities.length]);
   return {
     translations: allTranslations,
     isLoading: isLoading || entitiesLoading,
     error,
-    reload: loadAllTranslations
+    reload: loadAllTranslationsCallback
   };
 }
 export {

package/dist/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AASA,QAAA,MAAM,gBAAgB;;;;;CAYrB,CAAC;AAGF,iBAAS,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+DrD;;AAYD,wBA4FG;AAGH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AASA,QAAA,MAAM,gBAAgB;;;;;CAYrB,CAAC;AAGF,iBAAS,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA+DrD;;AAYD,wBAyDG;AAGH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/i18n.js

@@ -86,48 +86,18 @@ var i18n_default = getRequestConfig(async () => {
     } catch {
       console.debug("[i18n] Headers not available, using fallback namespace strategy");
     }
-    let messages = {};
-    try {
-      messages = await loadMergedTranslations(locale);
-      console.log(`[i18n] \u2705 Loaded merged translations for ${locale} with ${Object.keys(messages).length} namespaces`);
-    } catch (importError) {
-      console.warn(`[i18n] Failed to load merged translations for ${locale}:`, importError);
-      try {
-        messages = await loadMergedTranslations("en");
-        console.log(`[i18n] \u2705 Fallback to English merged translations successful`);
-      } catch (fallbackError) {
-        console.error(`[i18n] Critical error - failed to load any messages:`, fallbackError);
-        messages = {};
-      }
-    }
+    const messages = await loadMergedTranslations(locale);
+    console.log(`[i18n] Loaded merged translations for ${locale} with ${Object.keys(messages).length} namespaces`);
     return {
       locale,
       messages
     };
   } catch (error) {
-    console.warn(`[i18n] \u26A0\uFE0F Failed to load translations for locale "${locale}", falling back to ${I18N_CONFIG.defaultLocale}`, error);
-    try {
-      const fallbackMessages = await loadMergedTranslations(I18N_CONFIG.defaultLocale);
-      console.log(`[i18n] \u2705 Fallback successful - loaded merged message set`);
-      return {
-        locale: I18N_CONFIG.defaultLocale,
-        messages: fallbackMessages
-      };
-    } catch (fallbackError) {
-      console.error("[i18n] \u274C Critical: Failed to load fallback messages:", fallbackError);
-      try {
-        const coreMessages = await loadMergedTranslations("en");
-        return {
-          locale: I18N_CONFIG.defaultLocale,
-          messages: coreMessages
-        };
-      } catch {
-        return {
-          locale: I18N_CONFIG.defaultLocale,
-          messages: {}
-        };
-      }
-    }
+    console.error(`[i18n] Failed to load translations for ${locale}:`, error);
+    return {
+      locale: I18N_CONFIG.defaultLocale,
+      messages: {}
+    };
   }
 });
 import { loadOptimizedTranslations } from "./lib/translations/i18n-integration";

package/dist/lib/config/app.config.js

@@ -18,7 +18,7 @@ const DEFAULT_APP_CONFIG = {
      * Supported locales for your project
      * Add/remove locales as needed
      */
-    supportedLocales: ["en", "es"],
+    supportedLocales: ["en", "es", "fr", "de", "it", "pt"],
     /**
      * Default fallback locale
      */

package/dist/lib/config/dashboard.config.d.ts

@@ -152,7 +152,6 @@ export declare const DEFAULT_DASHBOARD_CONFIG: {
                 icon: string;
                 order: number;
                 features: {
-                    twoFactorAuth: boolean;
                     sessionManagement: boolean;
                     loginHistory: boolean;
                     securityQuestions: boolean;

package/dist/lib/config/dashboard.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dashboard.config.d.ts","sourceRoot":"","sources":["../../../src/lib/config/dashboard.config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,eAAO,MAAM,wBAAwB;;QAKjC;;WAEG;;;;;;QAOH;;WAEG;;;;QAKH;;WAEG;;;;QAKH;;WAEG;;;;;;;;;;;;;;;;;;QAyBH;;WAEG;;;;QAKH;;;WAGG;;;;;QAMH;;;WAGG;;;;QAKH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmBH;;WAEG;;;;;QAMH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;;;QAaH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmHH;;WAEG;;;;;;;;;QAaH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BH;;WAEG;;;;;;;;;;;;;;;;;;;QAoBH;;;WAGG;;;;QAQH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiCH;;WAEG;;;;;;;;QAYH;;WAEG;;;;;;;;;;;QAYH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;;;QAaH;;;WAGG;;;;;;;;;;;QAYH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;IAYL;;OAEG;gCACyB,GAAG,WAAW,MAAM,GAAG,OAAO;IAK1D;;OAEG;kCAC2B,GAAG;;;;;IAWjC;;OAEG;iCAC0B,GAAG,WAAW,MAAM,GAAG,OAAO;CAI5D,CAAA;AAMD,MAAM,MAAM,eAAe,GAAG,OAAO,wBAAwB,CAAA;AAC7D,MAAM,MAAM,YAAY,GAAG,OAAO,wBAAwB,CAAC,MAAM,CAAA;AACjE,MAAM,MAAM,aAAa,GAAG,OAAO,wBAAwB,CAAC,OAAO,CAAA;AACnE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA;AACrE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA;AACrE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA"}
+{"version":3,"file":"dashboard.config.d.ts","sourceRoot":"","sources":["../../../src/lib/config/dashboard.config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,eAAO,MAAM,wBAAwB;;QAKjC;;WAEG;;;;;;QAOH;;WAEG;;;;QAKH;;WAEG;;;;QAKH;;WAEG;;;;;;;;;;;;;;;;;;QAyBH;;WAEG;;;;QAKH;;;WAGG;;;;;QAMH;;;WAGG;;;;QAKH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmBH;;WAEG;;;;;QAMH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;;;QAaH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkHH;;WAEG;;;;;;;;;QAaH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BH;;WAEG;;;;;;;;;;;;;;;;;;;QAoBH;;;WAGG;;;;QAQH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiCH;;WAEG;;;;;;;;QAYH;;WAEG;;;;;;;;;;;QAYH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;;;QAaH;;;WAGG;;;;;;;;;;;QAYH;;WAEG;;;;;;QAOH;;WAEG;;;;;;;IAYL;;OAEG;gCACyB,GAAG,WAAW,MAAM,GAAG,OAAO;IAK1D;;OAEG;kCAC2B,GAAG;;;;;IAWjC;;OAEG;iCAC0B,GAAG,WAAW,MAAM,GAAG,OAAO;CAI5D,CAAA;AAMD,MAAM,MAAM,eAAe,GAAG,OAAO,wBAAwB,CAAA;AAC7D,MAAM,MAAM,YAAY,GAAG,OAAO,wBAAwB,CAAC,MAAM,CAAA;AACjE,MAAM,MAAM,aAAa,GAAG,OAAO,wBAAwB,CAAC,OAAO,CAAA;AACnE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA;AACrE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA;AACrE,MAAM,MAAM,cAAc,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAA"}

package/dist/lib/config/dashboard.config.js

@@ -148,7 +148,6 @@ const DEFAULT_DASHBOARD_CONFIG = {
         icon: "shield",
         order: 2,
         features: {
-          twoFactorAuth: true,
           sessionManagement: true,
           loginHistory: true,
           securityQuestions: false

package/dist/lib/config/nextspark-types.d.ts

@@ -25,7 +25,7 @@ export interface NextSparkConfig {
     };
     /** Auth configuration */
     auth?: {
-        providers: ('email' | 'google' | 'github')[];
+        providers: ('email' | 'google')[];
         requireEmailVerification?: boolean;
     };
     /** App metadata */

package/dist/lib/config/nextspark-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nextspark-types.d.ts","sourceRoot":"","sources":["../../../src/lib/config/nextspark-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAA;IAEb,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAElB,oBAAoB;IACpB,QAAQ,CAAC,EAAE;QACT,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,UAAU,CAAC,EAAE,OAAO,CAAA;QACpB,MAAM,CAAC,EAAE,OAAO,CAAA;KACjB,CAAA;IAED,6BAA6B;IAC7B,QAAQ,CAAC,EAAE;QACT,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;QACzC,aAAa,CAAC,EAAE,OAAO,CAAA;KACxB,CAAA;IAED,yBAAyB;IACzB,IAAI,CAAC,EAAE;QACL,SAAS,EAAE,CAAC,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAA;QAC5C,wBAAwB,CAAC,EAAE,OAAO,CAAA;KACnC,CAAA;IAED,mBAAmB;IACnB,GAAG,CAAC,EAAE;QACJ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;CACF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAErE"}
+{"version":3,"file":"nextspark-types.d.ts","sourceRoot":"","sources":["../../../src/lib/config/nextspark-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAA;IAEb,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAElB,oBAAoB;IACpB,QAAQ,CAAC,EAAE;QACT,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,UAAU,CAAC,EAAE,OAAO,CAAA;QACpB,MAAM,CAAC,EAAE,OAAO,CAAA;KACjB,CAAA;IAED,6BAA6B;IAC7B,QAAQ,CAAC,EAAE;QACT,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;QACzC,aAAa,CAAC,EAAE,OAAO,CAAA;KACxB,CAAA;IAED,yBAAyB;IACzB,IAAI,CAAC,EAAE;QACL,SAAS,EAAE,CAAC,OAAO,GAAG,QAAQ,CAAC,EAAE,CAAA;QACjC,wBAAwB,CAAC,EAAE,OAAO,CAAA;KACnC,CAAA;IAED,mBAAmB;IACnB,GAAG,CAAC,EAAE;QACJ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;CACF;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAErE"}

package/dist/lib/i18n-utils.d.ts

@@ -1,4 +1,4 @@
-import { type SupportedLocale, type TranslationNamespace } from './config';
+import { type SupportedLocale } from './config';
 /**
  * Validates if a locale string is supported
  */
@@ -15,8 +15,4 @@ export declare function validateTranslationKey(messages: Record<string, unknown>
  * Development helper to detect missing translations
  */
 export declare function detectMissingTranslations(enMessages: Record<string, unknown>, esMessages: Record<string, unknown>, path?: string): string[];
-/**
- * Performance helper for lazy loading specific message namespaces
- */
-export declare function loadNamespaceMessages(locale: SupportedLocale, namespace: TranslationNamespace): Promise<any>;
 //# sourceMappingURL=i18n-utils.d.ts.map

package/dist/lib/i18n-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n-utils.d.ts","sourceRoot":"","sources":["../../src/lib/i18n-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEvF;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,eAAe,CAEvE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,eAAe,CAGrE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,OAAO,CAaT;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,IAAI,GAAE,MAAW,GAChB,MAAM,EAAE,CAuBV;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,eAAe,EACvB,SAAS,EAAE,oBAAoB,gBAmBhC"}
+{"version":3,"file":"i18n-utils.d.ts","sourceRoot":"","sources":["../../src/lib/i18n-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,UAAU,CAAA;AAE5D;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,eAAe,CAEvE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,eAAe,CAGrE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,OAAO,CAaT;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,IAAI,GAAE,MAAW,GAChB,MAAM,EAAE,CAuBV"}

package/dist/lib/i18n-utils.js

@@ -39,28 +39,9 @@ function detectMissingTranslations(enMessages, esMessages, path = "") {
   checkMessages(enMessages, esMessages, path);
   return missing;
 }
-async function loadNamespaceMessages(locale, namespace) {
-  try {
-    const messages = await import(`../messages/${locale}/${namespace}.json`);
-    return messages.default;
-  } catch (error) {
-    console.error(`Failed to load ${namespace} messages for ${locale}:`, error);
-    if (locale !== I18N_CONFIG.defaultLocale) {
-      try {
-        const fallbackMessages = await import(`../messages/${I18N_CONFIG.defaultLocale}/${namespace}.json`);
-        return fallbackMessages.default;
-      } catch (fallbackError) {
-        console.error(`Failed to load fallback messages for ${namespace}:`, fallbackError);
-        return {};
-      }
-    }
-    return {};
-  }
-}
 export {
   detectMissingTranslations,
   getSafeLocale,
   isValidLocale,
-  loadNamespaceMessages,
   validateTranslationKey
 };

package/dist/lib/namespace-loader.d.ts

@@ -8,6 +8,7 @@ import { type SupportedLocale, type TranslationNamespace } from './config';
 import type { NamespaceData, NamespacesMap } from '../messages/types';
 /**
  * Load a single namespace with caching
+ * Uses registry-based loading: primary locale -> fallback locale -> empty object
  */
 export declare function loadNamespace(locale: SupportedLocale, namespace: TranslationNamespace): Promise<NamespaceData>;
 /**

package/dist/lib/namespace-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"namespace-loader.d.ts","sourceRoot":"","sources":["../../src/lib/namespace-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAe,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEvF,OAAO,KAAK,EAAkB,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAwCrF;;GAEG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EACvB,SAAS,EAAE,oBAAoB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAyCxB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,oBAAoB,EAAE,GACjC,OAAO,CAAC,aAAa,CAAC,CAaxB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAsB1E;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,eAAe,EACvB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAgBxB;AA2BD;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,eAAe,iBAWtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,SAElC;AAED;;GAEG;AACH,wBAAgB,aAAa;;;EAK5B"}
+{"version":3,"file":"namespace-loader.d.ts","sourceRoot":"","sources":["../../src/lib/namespace-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAe,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAEvF,OAAO,KAAK,EAAkB,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAwCrF;;;GAGG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,eAAe,EACvB,SAAS,EAAE,oBAAoB,GAC9B,OAAO,CAAC,aAAa,CAAC,CAsCxB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,oBAAoB,EAAE,GACjC,OAAO,CAAC,aAAa,CAAC,CAaxB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAsB1E;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,eAAe,EACvB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,aAAa,CAAC,CAgBxB;AA2BD;;GAEG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE,eAAe,iBAWtE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,SAElC;AAED;;GAEG;AACH,wBAAgB,aAAa;;;EAK5B"}

package/dist/lib/namespace-loader.js

@@ -36,23 +36,21 @@ async function loadNamespace(locale, namespace) {
     const namespaceData = messages.default;
     loadedNamespaces.set(cacheKey, namespaceData);
     return namespaceData;
-  } catch (error) {
-    console.error(`Failed to load ${namespace} for ${locale}:`, error);
+  } catch {
     const fallbackLocale = I18N_CONFIG.defaultLocale;
     if (locale !== fallbackLocale) {
       const fallbackCacheKey = getCacheKey(fallbackLocale, namespace);
-      if (!loadedNamespaces.has(fallbackCacheKey)) {
-        try {
-          const fallbackMessages = await import(`../messages/${fallbackLocale}/${namespace}.json`);
-          const fallbackData = fallbackMessages.default;
-          loadedNamespaces.set(fallbackCacheKey, fallbackData);
-          return fallbackData;
-        } catch (fallbackError) {
-          console.error(`Failed to load fallback ${namespace}:`, fallbackError);
-          return {};
-        }
+      if (loadedNamespaces.has(fallbackCacheKey)) {
+        return loadedNamespaces.get(fallbackCacheKey);
+      }
+      try {
+        const fallbackMessages = await import(`../messages/${fallbackLocale}/${namespace}.json`);
+        const fallbackData = fallbackMessages.default;
+        loadedNamespaces.set(fallbackCacheKey, fallbackData);
+        return fallbackData;
+      } catch {
+        console.warn(`[namespace-loader] Namespace ${namespace} not available for ${locale} or ${fallbackLocale}`);
       }
-      return loadedNamespaces.get(fallbackCacheKey) || {};
     }
     return {};
   }
@@ -94,15 +92,13 @@ async function loadAllNamespaces(locale) {
   try {
     const messages = await import(`../messages/${locale}/index.ts`);
     return messages.default;
-  } catch (error) {
-    console.error(`Failed to load all messages for ${locale}:`, error);
+  } catch {
     if (locale !== I18N_CONFIG.defaultLocale) {
       try {
         const fallbackMessages = await import(`../messages/${I18N_CONFIG.defaultLocale}/index.ts`);
         return fallbackMessages.default;
-      } catch (fallbackError) {
-        console.error("Failed to load fallback messages:", fallbackError);
-        return {};
+      } catch {
+        console.warn(`[namespace-loader] All namespaces not available for ${locale} or ${I18N_CONFIG.defaultLocale}`);
       }
     }
     return {};