@moontra/moonui-pro 3.1.1 → 3.2.1

package/dist/index.d.ts

@@ -147,15 +147,16 @@ interface AuthContextType extends AuthState {
     clearAuth: () => void;
 }
 /**
- * MoonUI Auth Provider - Centralized authentication state
- * This provider ensures only ONE API call is made for all components
+ * MoonUI Auth Provider - Simplified Authentication
+ * 1. Check embedded license token (from PostInstall)
+ * 2. Check localhost CLI auth server (development only)
+ * 3. No production API calls from browser
  */
 declare function MoonUIAuthProvider({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 /**
  * Hook to use auth context
- * Falls back to direct API call if context is not available
  */
 declare function useMoonUIAuth(): AuthContextType;
 

package/dist/index.mjs

@@ -2165,24 +2165,6 @@ function MoonUIAuthProvider({ children }) {
     isAdmin: false
   });
   const isMounted = useRef(true);
-  const readValidationFromCookie = () => {
-    if (typeof document === "undefined")
-      return null;
-    try {
-      const cookies = document.cookie.split(";");
-      const statusCookie = cookies.find(
-        (c2) => c2.trim().startsWith("moonui_pro_status=")
-      );
-      if (statusCookie) {
-        const value2 = statusCookie.split("=")[1];
-        const decoded = decodeURIComponent(value2);
-        return JSON.parse(decoded);
-      }
-    } catch (error) {
-      console.error("[MoonUI Auth] Error reading cookie:", error);
-    }
-    return null;
-  };
   const validateAuth = async (forceRefresh2 = false) => {
     const now = Date.now();
     if (!forceRefresh2 && now - lastFetchTime < FETCH_COOLDOWN) {
@@ -2193,79 +2175,34 @@ function MoonUIAuthProvider({ children }) {
       console.log("[MoonUI Auth] Using ongoing request");
       return authPromise;
     }
-    const licenseToken = readLicenseTokenClient();
-    if (licenseToken && licenseToken.hasProAccess) {
-      console.log("[MoonUI Auth] Using embedded license token - Pro access granted");
-      const tokenState = {
-        isLoading: false,
-        hasProAccess: true,
-        isAuthenticated: true,
-        subscriptionPlan: licenseToken.plan === "lifetime" ? "lifetime" : "free",
-        subscription: {
-          status: "active",
-          plan: licenseToken.plan === "lifetime" ? "lifetime" : "free"
-        },
-        isAdmin: false
-      };
-      setState(tokenState);
-      return tokenState;
-    }
-    if (!forceRefresh2) {
-      const cached = readValidationFromCookie();
-      if (cached && cached.valid) {
-        const age = now - cached.timestamp;
-        const maxAge = AUTH_CONFIG.cache.serverCacheDuration;
-        if (age < maxAge) {
-          console.log("[MoonUI Auth] Using cookie cache");
-          const cachedState2 = {
+    authPromise = (async () => {
+      try {
+        lastFetchTime = now;
+        const licenseToken = readLicenseTokenClient();
+        if (licenseToken && licenseToken.hasProAccess) {
+          console.log("[MoonUI Auth] Using embedded license token - Pro access granted");
+          const tokenState = {
             isLoading: false,
-            hasProAccess: cached.hasProAccess,
-            isAuthenticated: cached.valid,
-            subscriptionPlan: cached.hasProAccess ? "lifetime" : "free",
+            hasProAccess: true,
+            isAuthenticated: true,
+            subscriptionPlan: licenseToken.plan === "lifetime" ? "lifetime" : "free",
             subscription: {
-              status: cached.hasProAccess ? "active" : "inactive",
-              plan: cached.hasProAccess ? "lifetime" : "free"
+              status: "active",
+              plan: licenseToken.plan === "lifetime" ? "lifetime" : "free"
             },
             isAdmin: false
           };
-          setState(cachedState2);
-          return cachedState2;
-        }
-      }
-    }
-    authPromise = (async () => {
-      try {
-        lastFetchTime = now;
-        let isProduction = false;
-        let isDevelopment = true;
-        let environmentInfo = {};
-        try {
-          const envResponse = await fetch("/api/environment", {
-            method: "GET",
-            cache: "no-store"
-          });
-          if (envResponse.ok) {
-            environmentInfo = await envResponse.json();
-            isProduction = environmentInfo.isProduction;
-            isDevelopment = environmentInfo.isDevelopment;
-            console.log("[MoonUI Auth] Runtime Environment Detection:", {
-              ...environmentInfo.debug,
-              environment: environmentInfo.environment,
-              isProduction,
-              isDevelopment
-            });
-          } else {
-            console.warn("[MoonUI Auth] Failed to fetch environment info, falling back to development mode");
+          if (isMounted.current) {
+            setState(tokenState);
           }
-        } catch (error) {
-          console.warn("[MoonUI Auth] Error fetching environment info:", error);
+          authPromise = null;
+          return tokenState;
         }
-        if (isDevelopment) {
-          let response;
-          const authServerUrl = typeof window !== "undefined" ? process.env.NEXT_PUBLIC_MOONUI_AUTH_SERVER || "http://localhost:7878" : "http://localhost:7878";
+        const isLocalhost = typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1");
+        if (isLocalhost) {
           try {
-            console.log("[MoonUI Auth] Development mode - checking CLI auth server at:", authServerUrl);
-            response = await fetch(`${authServerUrl}/validate`, {
+            console.log("[MoonUI Auth] Development mode - checking CLI auth server");
+            const response = await fetch("http://localhost:7878/validate", {
               method: "GET",
               headers: {
                 "X-Component": "MoonUIAuthProvider",
@@ -2274,7 +2211,7 @@ function MoonUIAuthProvider({ children }) {
               credentials: "include"
             });
             if (response && response.ok) {
-              console.log("[MoonUI Auth] Using CLI auth server");
+              console.log("[MoonUI Auth] CLI auth server available");
               const data = await response.json();
               if (data.valid && data.hasProAccess) {
                 saveLicenseTokenClient({
@@ -2302,79 +2239,12 @@ function MoonUIAuthProvider({ children }) {
               }
               authPromise = null;
               return newState;
-            } else {
-              throw new Error("Auth server not available");
             }
           } catch (error) {
-            console.log('[MoonUI Auth] Auth server not available in development. Run "moonui dev" to enable Pro features.');
-          }
-        }
-        if (isProduction) {
-          const licenseKey = environmentInfo.hasLicenseKey ? process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY || process.env.MOONUI_LICENSE_KEY || process.env.VITE_MOONUI_LICENSE_KEY || process.env.REACT_APP_MOONUI_LICENSE_KEY || "check-server" : null;
-          if (licenseKey) {
-            console.log("[MoonUI Auth] Production mode - validating license key...");
-            try {
-              const currentDomain = typeof window !== "undefined" ? window.location.hostname : process.env.VERCEL_URL || process.env.NEXT_PUBLIC_VERCEL_URL || "";
-              const apiUrl = "https://moonui.dev/api/v1/license/validate";
-              const validationResponse = await fetch(apiUrl, {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                  licenseKey,
-                  domain: currentDomain
-                })
-              });
-              if (validationResponse.ok) {
-                const validationData = await validationResponse.json();
-                if (validationData.valid && validationData.hasProAccess) {
-                  console.log("[MoonUI Auth] License key validated successfully");
-                  saveLicenseTokenClient({
-                    valid: true,
-                    hasProAccess: validationData.hasProAccess,
-                    plan: validationData.plan || "lifetime",
-                    expiresAt: validationData.expiresAt || Date.now() + 30 * 24 * 60 * 60 * 1e3,
-                    domain: currentDomain || "production",
-                    timestamp: Date.now()
-                  });
-                  const newState = {
-                    isLoading: false,
-                    hasProAccess: validationData.hasProAccess,
-                    isAuthenticated: true,
-                    subscriptionPlan: validationData.plan === "lifetime" ? "lifetime" : "free",
-                    subscription: {
-                      status: validationData.hasProAccess ? "active" : "inactive",
-                      plan: validationData.plan === "lifetime" ? "lifetime" : "free"
-                    },
-                    isAdmin: false
-                  };
-                  if (typeof document !== "undefined" && validationData.cacheDuration) {
-                    const cacheData = {
-                      valid: true,
-                      hasProAccess: validationData.hasProAccess,
-                      timestamp: Date.now()
-                    };
-                    document.cookie = `moonui_pro_status=${encodeURIComponent(
-                      JSON.stringify(cacheData)
-                    )}; max-age=${Math.floor(validationData.cacheDuration / 1e3)}; path=/; SameSite=Strict`;
-                  }
-                  if (isMounted.current) {
-                    setState(newState);
-                  }
-                  authPromise = null;
-                  return newState;
-                } else {
-                  console.warn("[MoonUI Auth] License key validation failed:", validationData.error || "Invalid license");
-                }
-              } else {
-                console.error("[MoonUI Auth] License validation request failed:", validationResponse.status);
-              }
-            } catch (error) {
-              console.error("[MoonUI Auth] License validation error:", error);
-            }
+            console.log('[MoonUI Auth] CLI auth server not available. Run "moonui dev" to enable Pro features.');
           }
         }
+        console.log("[MoonUI Auth] No authentication available - using free plan");
         const freeState = {
           isLoading: false,
           hasProAccess: false,
@@ -2407,9 +2277,8 @@ function MoonUIAuthProvider({ children }) {
         if (isMounted.current) {
           setState(errorState);
         }
-        return errorState;
-      } finally {
         authPromise = null;
+        return errorState;
       }
     })();
     return authPromise;
@@ -2427,8 +2296,6 @@ function MoonUIAuthProvider({ children }) {
   };
   const clearAuth2 = () => {
     console.log("[MoonUI Auth] Clearing auth");
-    document.cookie = "moonui_pro_status=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";
-    document.cookie = "moonui_auth_token=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT";
     setState({
       isLoading: false,
       hasProAccess: false,
@@ -2453,7 +2320,7 @@ function MoonUIAuthProvider({ children }) {
 function useMoonUIAuth() {
   const context = useContext(AuthContext);
   if (!context) {
-    console.warn("[MoonUI Auth] No AuthProvider found, components will make individual API calls");
+    console.warn("[MoonUI Auth] No AuthProvider found, using free plan");
     return {
       isLoading: false,
       hasProAccess: false,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "3.1.1",
+    "version": "3.2.1",
     "description": "Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components",
     "type": "module",
     "main": "dist/index.mjs",

package/scripts/postinstall.cjs

@@ -50,10 +50,31 @@ function encryptToken(token, key) {
 // Validate license with MoonUI API
 async function validateLicense(licenseKey) {
   return new Promise((resolve, reject) => {
+    // Determine the domain
+    let domain = 'unknown';
+
+    // Check for Vercel deployment
+    if (process.env.VERCEL_URL) {
+      domain = process.env.VERCEL_URL.replace(/^https?:\/\//, '');
+    } else if (process.env.VERCEL_PROJECT_PRODUCTION_URL) {
+      domain = process.env.VERCEL_PROJECT_PRODUCTION_URL.replace(/^https?:\/\//, '');
+    } else if (process.env.NEXT_PUBLIC_VERCEL_URL) {
+      domain = process.env.NEXT_PUBLIC_VERCEL_URL.replace(/^https?:\/\//, '');
+    } else if (process.env.DEPLOY_URL) {
+      domain = process.env.DEPLOY_URL.replace(/^https?:\/\//, '');
+    }
+
+    // For moonui.dev site, use special validation
+    const isMoonUISite = domain.includes('moonui.dev') ||
+                         domain.includes('moonui-git') ||
+                         domain.includes('moonui-') ||
+                         process.env.MOONUI_SITE === 'true';
+
     const postData = JSON.stringify({
       licenseKey,
-      domain: process.env.VERCEL_URL || process.env.DEPLOY_URL || 'unknown',
-      environment: 'production'
+      domain: isMoonUISite ? 'moonui.dev' : domain,
+      environment: 'production',
+      isMoonUISite
     });
 
     const options = {
@@ -142,6 +163,24 @@ async function main() {
 
     console.log('[MoonUI Pro] Production environment detected, checking license...');
 
+    // Special case: moonui.dev site itself always has Pro access
+    const vercelUrl = process.env.VERCEL_URL || process.env.VERCEL_PROJECT_PRODUCTION_URL || '';
+    if (vercelUrl.includes('moonui.dev') || vercelUrl.includes('moonui-git') ||
+        process.env.MOONUI_SITE === 'true') {
+      console.log('[MoonUI Pro] MoonUI site detected - granting Pro access');
+      const token = {
+        valid: true,
+        hasProAccess: true,
+        plan: 'lifetime',
+        expiresAt: Date.now() + CACHE_DURATION,
+        domain: 'moonui.dev',
+        timestamp: Date.now()
+      };
+      saveLicenseToken(token);
+      console.log('[MoonUI Pro] ✓ Pro features enabled for moonui.dev');
+      return;
+    }
+
     // Check for license key in environment variables
     const licenseKey = process.env.MOONUI_LICENSE_KEY ||
                       process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY ||