@nocios/crudify-ui 2.0.0 → 3.0.0

package/dist/chunk-GY5F6KOF.mjs

@@ -1,701 +0,0 @@
-import {
-  tokenManager
-} from "./chunk-M7V4UGCN.mjs";
-
-// src/providers/CrudifyDataProvider.tsx
-import { createContext, useContext, useEffect, useState, useCallback } from "react";
-
-// src/components/CrudifyLogin/utils/cookies.ts
-var getCookie = (name) => {
-  const match = document.cookie.match(new RegExp("(^|;)\\s*" + name + "=([^;]+)"));
-  return match ? match[2] : null;
-};
-
-// src/core/ConfigurationManager.ts
-var _ConfigurationManager = class _ConfigurationManager {
-  constructor() {
-    this.resolvedConfig = null;
-    this.configError = null;
-  }
-  /**
-   * Singleton pattern to ensure consistent configuration across the app
-   */
-  static getInstance() {
-    if (!_ConfigurationManager.instance) {
-      _ConfigurationManager.instance = new _ConfigurationManager();
-    }
-    return _ConfigurationManager.instance;
-  }
-  /**
-   * Reset the singleton instance (useful for testing)
-   */
-  static resetInstance() {
-    _ConfigurationManager.instance = null;
-  }
-  /**
-   * Resolve configuration from all sources with proper priority
-   */
-  resolveConfig(propsConfig = {}) {
-    console.log("\u{1F50D} ConfigurationManager - resolveConfig called with props:", propsConfig);
-    if (this.resolvedConfig && this.isConfigStillValid(propsConfig)) {
-      console.log("\u{1F50D} ConfigurationManager - Using cached config");
-      return this.resolvedConfig;
-    }
-    try {
-      this.configError = null;
-      const envConfig = this.getEnvConfig();
-      const cookieConfig = this.getCookieConfig();
-      console.log("\u{1F50D} ConfigurationManager - envConfig:", envConfig);
-      console.log("\u{1F50D} ConfigurationManager - cookieConfig:", cookieConfig);
-      const configSource = {
-        env: "default",
-        publicApiKey: "default",
-        loginActions: "default",
-        appName: "default",
-        logo: "default",
-        colors: "default"
-      };
-      const env = this.resolveValue("env", propsConfig.env, envConfig.env, cookieConfig.env, "prod", configSource);
-      const publicApiKey = this.resolveValue(
-        "publicApiKey",
-        propsConfig.publicApiKey,
-        envConfig.publicApiKey,
-        cookieConfig.publicApiKey,
-        void 0,
-        configSource
-      );
-      const loginActions = this.resolveValue(
-        "loginActions",
-        propsConfig.loginActions,
-        envConfig.loginActions,
-        cookieConfig.loginActions,
-        [],
-        configSource
-      );
-      const appName = this.resolveValue(
-        "appName",
-        propsConfig.appName,
-        envConfig.appName,
-        cookieConfig.appName,
-        "Crudify App",
-        configSource
-      );
-      const logo = this.resolveValue("logo", propsConfig.logo, envConfig.logo, cookieConfig.logo, "", configSource);
-      const colors = this.resolveValue("colors", propsConfig.colors, envConfig.colors, cookieConfig.colors, {}, configSource);
-      console.log("\u{1F50D} ConfigurationManager - Resolved values:");
-      console.log("  - publicApiKey:", publicApiKey, "from:", configSource.publicApiKey);
-      console.log("  - env:", env, "from:", configSource.env);
-      console.log("  - loginActions:", loginActions, "from:", configSource.loginActions);
-      if (!publicApiKey) {
-        throw new Error(
-          "publicApiKey es requerido. Proporci\xF3nalo v\xEDa:\n1. Props: <CrudifyDataProvider publicApiKey={...} />\n2. Variable de entorno: VITE_TEST_PUBLIC_API_KEY\n3. Cookie: publicApiKey"
-        );
-      }
-      this.resolvedConfig = {
-        env,
-        publicApiKey,
-        loginActions,
-        appName,
-        logo,
-        colors,
-        configSource,
-        rawConfig: {
-          props: propsConfig,
-          env: envConfig,
-          cookies: cookieConfig
-        }
-      };
-      return this.resolvedConfig;
-    } catch (error) {
-      this.configError = error instanceof Error ? error.message : "Error de configuraci\xF3n desconocido";
-      console.error("ConfigurationManager - Error de configuraci\xF3n:", this.configError);
-      this.resolvedConfig = {
-        env: "prod",
-        publicApiKey: "",
-        loginActions: [],
-        appName: "Crudify App",
-        logo: "",
-        colors: {},
-        configSource: {
-          env: "default",
-          publicApiKey: "default",
-          loginActions: "default",
-          appName: "default",
-          logo: "default",
-          colors: "default"
-        },
-        rawConfig: {
-          props: propsConfig,
-          env: {},
-          cookies: {},
-          error: this.configError
-        }
-      };
-      return this.resolvedConfig;
-    }
-  }
-  /**
-   * Check if current configuration is still valid for the given props
-   */
-  isConfigStillValid(propsConfig) {
-    if (!this.resolvedConfig) return false;
-    const currentProps = this.resolvedConfig.rawConfig.props;
-    return JSON.stringify(currentProps) === JSON.stringify(propsConfig);
-  }
-  /**
-   * Resolve a single config value with priority and source tracking
-   */
-  resolveValue(key, propsValue, envValue, cookieValue, defaultValue, configSource) {
-    if (propsValue !== void 0) {
-      configSource[key] = "props";
-      return propsValue;
-    }
-    if (envValue !== void 0) {
-      configSource[key] = "env";
-      return envValue;
-    }
-    if (cookieValue !== void 0) {
-      configSource[key] = "cookies";
-      return cookieValue;
-    }
-    configSource[key] = "default";
-    return defaultValue;
-  }
-  /**
-   * Obtener configuración de variables de entorno
-   */
-  getEnvConfig() {
-    const config = {};
-    try {
-      if (typeof import.meta !== "undefined" && import.meta.env) {
-        const vitEnv = import.meta.env;
-        const env = vitEnv.VITE_TEST_ENV;
-        if (env && ["dev", "stg", "prod"].includes(env)) {
-          config.env = env;
-        }
-        const publicApiKey = vitEnv.VITE_TEST_PUBLIC_API_KEY;
-        if (publicApiKey) {
-          config.publicApiKey = publicApiKey;
-        }
-        const loginActions = vitEnv.VITE_TEST_LOGIN_ACTIONS;
-        if (loginActions) {
-          config.loginActions = loginActions.split(",").map((action) => action.trim()).filter(Boolean);
-        }
-        const appName = vitEnv.VITE_TEST_APP_NAME;
-        if (appName) {
-          config.appName = appName;
-        }
-        const logo = vitEnv.VITE_TEST_LOGO;
-        if (logo) {
-          config.logo = logo;
-        }
-        const colors = vitEnv.VITE_TEST_COLORS;
-        if (colors) {
-          try {
-            config.colors = JSON.parse(colors);
-          } catch (error) {
-            console.warn("ConfigurationManager - Error al parsear colors desde env:", error);
-          }
-        }
-      }
-      if (typeof globalThis !== "undefined" && globalThis.process?.env) {
-        const processEnv = globalThis.process.env;
-        const env = processEnv.VITE_TEST_ENV;
-        if (env && ["dev", "stg", "prod"].includes(env) && !config.env) {
-          config.env = env;
-        }
-        const publicApiKey = processEnv.VITE_TEST_PUBLIC_API_KEY;
-        if (publicApiKey && !config.publicApiKey) {
-          config.publicApiKey = publicApiKey;
-        }
-        const loginActions = processEnv.VITE_TEST_LOGIN_ACTIONS;
-        if (loginActions && !config.loginActions) {
-          config.loginActions = loginActions.split(",").map((action) => action.trim()).filter(Boolean);
-        }
-        const appName = processEnv.VITE_TEST_APP_NAME;
-        if (appName && !config.appName) {
-          config.appName = appName;
-        }
-        const logo = processEnv.VITE_TEST_LOGO;
-        if (logo && !config.logo) {
-          config.logo = logo;
-        }
-        const colors = processEnv.VITE_TEST_COLORS;
-        if (colors && !config.colors) {
-          try {
-            config.colors = JSON.parse(colors);
-          } catch (error) {
-            console.warn("ConfigurationManager - Error al parsear colors desde process.env:", error);
-          }
-        }
-      }
-    } catch (error) {
-      console.warn("ConfigurationManager - Variables de entorno no disponibles:", error);
-    }
-    return config;
-  }
-  /**
-   * Obtener configuración de cookies (soporte multi-tenant)
-   */
-  getCookieConfig() {
-    const config = {};
-    try {
-      const env = getCookie("environment");
-      if (env && ["dev", "stg", "prod"].includes(env)) {
-        config.env = env;
-      }
-      const publicApiKey = getCookie("publicApiKey");
-      if (publicApiKey) {
-        config.publicApiKey = publicApiKey;
-      }
-      const appName = getCookie("appName");
-      if (appName) {
-        config.appName = decodeURIComponent(appName);
-      }
-      const loginActions = getCookie("loginActions");
-      if (loginActions) {
-        const decodedActions = decodeURIComponent(loginActions);
-        config.loginActions = decodedActions.split(",").map((action) => action.trim()).filter(Boolean);
-      }
-      const logo = getCookie("logo");
-      if (logo) {
-        config.logo = decodeURIComponent(logo);
-      }
-      const colors = getCookie("colors");
-      if (colors) {
-        try {
-          const decodedColors = decodeURIComponent(colors);
-          config.colors = JSON.parse(decodedColors);
-        } catch (error) {
-          console.warn("ConfigurationManager - Error al parsear colors desde cookie:", error);
-        }
-      }
-    } catch (error) {
-      console.warn("ConfigurationManager - Error leyendo cookies:", error);
-    }
-    return config;
-  }
-  /**
-   * Get the current resolved configuration
-   */
-  getConfig() {
-    return this.resolvedConfig;
-  }
-  /**
-   * Get any configuration errors
-   */
-  getConfigError() {
-    return this.configError;
-  }
-  /**
-   * Check if configuration is valid (no errors and has required fields)
-   */
-  isConfigured() {
-    return this.resolvedConfig !== null && this.configError === null && !!this.resolvedConfig.publicApiKey;
-  }
-  /**
-   * Clear the current configuration (useful for testing or reconfiguration)
-   */
-  clearConfig() {
-    this.resolvedConfig = null;
-    this.configError = null;
-  }
-};
-_ConfigurationManager.instance = null;
-var ConfigurationManager = _ConfigurationManager;
-var configurationManager = ConfigurationManager.getInstance();
-
-// src/core/CrudifyInitializer.ts
-import crudify from "@nocios/crudify-browser";
-var _CrudifyInitializer = class _CrudifyInitializer {
-  constructor() {
-    this.state = {
-      isInitialized: false,
-      isInitializing: false,
-      initializationError: null,
-      config: null,
-      initializationPromise: null
-    };
-  }
-  /**
-   * Singleton pattern to ensure global initialization coordination
-   */
-  static getInstance() {
-    if (!_CrudifyInitializer.instance) {
-      _CrudifyInitializer.instance = new _CrudifyInitializer();
-    }
-    return _CrudifyInitializer.instance;
-  }
-  /**
-   * Reset the singleton instance (useful for testing)
-   */
-  static resetInstance() {
-    _CrudifyInitializer.instance = null;
-  }
-  /**
-   * Inicializar crudify con la configuración dada
-   * Este método es idempotente y thread-safe
-   */
-  async initialize(config) {
-    if (this.state.isInitialized && this.isConfigurationSame(config)) {
-      return;
-    }
-    if (this.state.isInitializing && this.state.initializationPromise) {
-      await this.state.initializationPromise;
-      return;
-    }
-    if (this.state.isInitialized && !this.isConfigurationSame(config)) {
-      this.reset();
-    }
-    this.state.isInitializing = true;
-    this.state.initializationError = null;
-    this.state.initializationPromise = this.performInitialization(config);
-    try {
-      await this.state.initializationPromise;
-      this.state.isInitialized = true;
-      this.state.config = { ...config };
-    } catch (error) {
-      this.state.initializationError = error instanceof Error ? error.message : "Error de inicializaci\xF3n desconocido";
-      console.error("CrudifyInitializer - Inicializaci\xF3n fall\xF3:", this.state.initializationError);
-      throw error;
-    } finally {
-      this.state.isInitializing = false;
-      this.state.initializationPromise = null;
-    }
-  }
-  /**
-   * Realizar el proceso de inicialización actual
-   */
-  async performInitialization(config) {
-    if (!config.publicApiKey) {
-      throw new Error("publicApiKey es requerido para la inicializaci\xF3n de crudify");
-    }
-    try {
-      const environment = config.env || "prod";
-      await crudify.config(environment);
-      await crudify.init(config.publicApiKey, "none");
-      await this.verifyInitialization();
-    } catch (error) {
-      throw new Error(
-        `Inicializaci\xF3n de Crudify fall\xF3: ${error instanceof Error ? error.message : "Error desconocido"}. Por favor revisa tu configuraci\xF3n (env: ${config.env || "prod"}, publicApiKey: ${config.publicApiKey ? "proporcionado" : "faltante"})`
-      );
-    }
-  }
-  /**
-   * Verificar que crudify esté correctamente inicializado revisando métodos principales
-   */
-  async verifyInitialization() {
-    const requiredMethods = ["readItems", "readItem", "createItem", "updateItem", "deleteItem", "login", "transaction"];
-    const missingMethods = [];
-    for (const method of requiredMethods) {
-      if (typeof crudify[method] !== "function") {
-        missingMethods.push(method);
-      }
-    }
-    if (missingMethods.length > 0) {
-      throw new Error(
-        `Inicializaci\xF3n de Crudify incompleta. M\xE9todos faltantes: ${missingMethods.join(", ")}. Esto usualmente indica un problema de configuraci\xF3n o red.`
-      );
-    }
-  }
-  /**
-   * Verificar si la configuración dada es la misma que la actual
-   */
-  isConfigurationSame(config) {
-    if (!this.state.config) return false;
-    return this.state.config.env === config.env && this.state.config.publicApiKey === config.publicApiKey;
-  }
-  /**
-   * Resetear el estado de inicialización (útil para testing o cambios de configuración)
-   */
-  reset() {
-    this.state = {
-      isInitialized: false,
-      isInitializing: false,
-      initializationError: null,
-      config: null,
-      initializationPromise: null
-    };
-  }
-  /**
-   * Obtener el estado actual de inicialización
-   */
-  getStatus() {
-    return {
-      isInitialized: this.state.isInitialized,
-      isInitializing: this.state.isInitializing,
-      initializationError: this.state.initializationError,
-      config: this.state.config
-    };
-  }
-  /**
-   * Verificar si crudify está listo para usar
-   */
-  isReady() {
-    return this.state.isInitialized && !this.state.initializationError;
-  }
-  /**
-   * Obtener el error de inicialización actual, si existe
-   */
-  getError() {
-    return this.state.initializationError;
-  }
-  /**
-   * Forzar re-inicialización (útil cuando la configuración cambia)
-   */
-  async reinitialize(config) {
-    this.reset();
-    await this.initialize(config);
-  }
-  /**
-   * Verificar si la inicialización está actualmente en progreso
-   */
-  isInitializing() {
-    return this.state.isInitializing;
-  }
-  /**
-   * Esperar a que cualquier inicialización en curso se complete
-   */
-  async waitForInitialization() {
-    if (this.state.initializationPromise) {
-      await this.state.initializationPromise;
-    }
-  }
-};
-_CrudifyInitializer.instance = null;
-var CrudifyInitializer = _CrudifyInitializer;
-var crudifyInitializer = CrudifyInitializer.getInstance();
-
-// src/providers/CrudifyDataProvider.tsx
-import { jsx } from "react/jsx-runtime";
-var CrudifyDataContext = createContext(null);
-var CrudifyDataProvider = ({
-  children,
-  env,
-  publicApiKey,
-  loginActions,
-  appName,
-  logo,
-  colors
-}) => {
-  console.log("\u{1F50D} CrudifyDataProvider - Received props:", {
-    env,
-    publicApiKey,
-    loginActions,
-    appName,
-    logo,
-    colors
-  });
-  const [config, setConfig] = useState(null);
-  const [isConfigured, setIsConfigured] = useState(false);
-  const [configError, setConfigError] = useState(null);
-  const [isInitialized, setIsInitialized] = useState(false);
-  const [isInitializing, setIsInitializing] = useState(false);
-  const [initializationError, setInitializationError] = useState(null);
-  const [isAuthenticated, setIsAuthenticated] = useState(false);
-  const [token, setTokenState] = useState(null);
-  const [user, setUser] = useState(null);
-  const [tokenExpiration, setTokenExpiration] = useState(null);
-  const initializeConfiguration = useCallback(() => {
-    try {
-      const propsConfig = {
-        env,
-        publicApiKey,
-        loginActions,
-        appName,
-        logo,
-        colors
-      };
-      const resolvedConfig = configurationManager.resolveConfig(propsConfig);
-      const error = configurationManager.getConfigError();
-      setConfig(resolvedConfig);
-      setConfigError(error);
-      setIsConfigured(configurationManager.isConfigured());
-      return resolvedConfig;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Error en inicializaci\xF3n de configuraci\xF3n";
-      console.error("CrudifyDataProvider - Error de configuraci\xF3n:", errorMessage);
-      setConfigError(errorMessage);
-      setIsConfigured(false);
-      return null;
-    }
-  }, [env, publicApiKey, loginActions, appName, logo, colors]);
-  const initializeCrudify = useCallback(async (resolvedConfig) => {
-    if (!resolvedConfig || !resolvedConfig.publicApiKey) {
-      setInitializationError("No se puede inicializar crudify sin configuraci\xF3n v\xE1lida");
-      return;
-    }
-    try {
-      setIsInitializing(true);
-      setInitializationError(null);
-      await crudifyInitializer.initialize({
-        env: resolvedConfig.env,
-        publicApiKey: resolvedConfig.publicApiKey,
-        loginActions: resolvedConfig.loginActions,
-        appName: resolvedConfig.appName,
-        logo: resolvedConfig.logo,
-        colors: resolvedConfig.colors
-      });
-      setIsInitialized(true);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Error en inicializaci\xF3n de Crudify";
-      console.error("CrudifyDataProvider - Error de inicializaci\xF3n:", errorMessage);
-      setInitializationError(errorMessage);
-      setIsInitialized(false);
-    } finally {
-      setIsInitializing(false);
-    }
-  }, []);
-  const updateAuthenticationState = useCallback(() => {
-    try {
-      const currentToken = tokenManager.getToken();
-      const parsedUser = tokenManager.parseToken();
-      const expiration = tokenManager.getTokenExpiration();
-      const authenticated = tokenManager.isAuthenticated();
-      setTokenState(currentToken);
-      setUser(parsedUser);
-      setTokenExpiration(expiration);
-      setIsAuthenticated(authenticated);
-    } catch (error) {
-      console.error("CrudifyDataProvider - Error actualizando estado de autenticaci\xF3n:", error);
-    }
-  }, []);
-  const setToken = useCallback((newToken) => {
-    tokenManager.setToken(newToken);
-    if (newToken) {
-      const parsedUser = tokenManager.parseToken(newToken);
-      const expiration = tokenManager.getTokenExpiration();
-      const authenticated = tokenManager.isTokenValid(newToken);
-      setTokenState(newToken);
-      setUser(parsedUser);
-      setTokenExpiration(expiration);
-      setIsAuthenticated(authenticated);
-    } else {
-      setTokenState(null);
-      setUser(null);
-      setTokenExpiration(null);
-      setIsAuthenticated(false);
-    }
-  }, []);
-  const logout = useCallback(() => {
-    tokenManager.clearToken();
-    setTokenState(null);
-    setUser(null);
-    setTokenExpiration(null);
-    setIsAuthenticated(false);
-  }, []);
-  const refreshConfig = useCallback(() => {
-    configurationManager.clearConfig();
-    const newConfig = initializeConfiguration();
-    if (newConfig && newConfig.publicApiKey) {
-      initializeCrudify(newConfig);
-    }
-  }, [initializeConfiguration, initializeCrudify]);
-  const reinitialize = useCallback(async () => {
-    if (!config || !config.publicApiKey) {
-      console.warn("CrudifyDataProvider - No se puede reinicializar sin configuraci\xF3n v\xE1lida");
-      return;
-    }
-    crudifyInitializer.reset();
-    await initializeCrudify(config);
-  }, [config, initializeCrudify]);
-  const getDebugInfo = useCallback(() => {
-    return {
-      provider: {
-        isConfigured,
-        configError,
-        isInitialized,
-        isInitializing,
-        initializationError,
-        isAuthenticated
-      },
-      configuration: {
-        config: config ? {
-          env: config.env,
-          publicApiKey: `${config.publicApiKey.substring(0, 8)}...`,
-          appName: config.appName,
-          loginActionsCount: config.loginActions.length,
-          hasLogo: !!config.logo,
-          colorsCount: Object.keys(config.colors).length
-        } : null,
-        sources: config?.configSource || null,
-        rawConfig: config?.rawConfig || null
-      },
-      authentication: {
-        hasToken: !!token,
-        tokenLength: token?.length || 0,
-        userEmail: user?.email || null,
-        userId: user?.sub || null,
-        expiration: tokenExpiration?.toISOString() || null,
-        minutesUntilExpiry: tokenManager.getTimeUntilExpiration()
-      },
-      tokenManager: tokenManager.getDebugInfo(),
-      crudifyInitializer: crudifyInitializer.getStatus()
-    };
-  }, [
-    isConfigured,
-    configError,
-    isInitialized,
-    isInitializing,
-    initializationError,
-    isAuthenticated,
-    config,
-    token,
-    user,
-    tokenExpiration
-  ]);
-  useEffect(() => {
-    const resolvedConfig = initializeConfiguration();
-    updateAuthenticationState();
-    if (resolvedConfig && resolvedConfig.publicApiKey) {
-      initializeCrudify(resolvedConfig);
-    }
-    return () => {
-      tokenManager.cleanup();
-    };
-  }, []);
-  useEffect(() => {
-    updateAuthenticationState();
-  }, []);
-  const contextValue = {
-    // Configuración
-    config,
-    isConfigured,
-    configError,
-    configSource: config ? JSON.stringify(config.configSource) : "none",
-    // Inicialización
-    isInitialized,
-    isInitializing,
-    initializationError,
-    // Autenticación
-    isAuthenticated,
-    token,
-    user,
-    tokenExpiration,
-    // Acciones
-    setToken,
-    logout,
-    refreshConfig,
-    reinitialize,
-    // Debug
-    getDebugInfo
-  };
-  return /* @__PURE__ */ jsx(CrudifyDataContext.Provider, { value: contextValue, children });
-};
-var useCrudifyDataContext = () => {
-  const context = useContext(CrudifyDataContext);
-  if (!context) {
-    throw new Error(
-      "useCrudifyDataContext must be used within a CrudifyDataProvider. Make sure to wrap your app with <CrudifyDataProvider>."
-    );
-  }
-  return context;
-};
-
-export {
-  getCookie,
-  configurationManager,
-  crudifyInitializer,
-  CrudifyDataProvider,
-  useCrudifyDataContext
-};