@moontra/moonui-pro 3.4.2 → 3.4.4

package/dist/vite-plugin.mjs

@@ -0,0 +1,221 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+function findExistingToken() {
+  if (typeof window !== "undefined") {
+    return null;
+  }
+  const possiblePaths = [
+    path.join(process.cwd(), ".moonui-license-token"),
+    path.join(process.cwd(), "..", ".moonui-license-token"),
+    path.join(process.cwd(), "..", "..", ".moonui-license-token")
+  ];
+  if (process.env.VERCEL_ARTIFACTS_PATH) {
+    possiblePaths.push(path.join(process.env.VERCEL_ARTIFACTS_PATH, ".moonui-license-token"));
+  }
+  if (process.env.NETLIFY_BUILD_BASE) {
+    possiblePaths.push(path.join(process.env.NETLIFY_BUILD_BASE, ".moonui-license-token"));
+  }
+  possiblePaths.push("/tmp/.moonui-license-token");
+  for (const filePath of possiblePaths) {
+    if (fs.existsSync(filePath)) {
+      try {
+        return fs.readFileSync(filePath, "utf8");
+      } catch (err) {
+        console.error(`[MoonUI Token Generator] Failed to read token from ${filePath}:`, err);
+      }
+    }
+  }
+  return null;
+}
+async function generateTokenIfMissing(options = {}) {
+  const { silent = false, forceRegenerate = false } = options;
+  try {
+    if (!forceRegenerate && process.env.MOONUI_PRO_TOKEN) {
+      if (!silent) {
+        console.log("[MoonUI Token Generator] Token found in environment variable");
+      }
+      return {
+        success: true,
+        token: JSON.parse(Buffer.from(process.env.MOONUI_PRO_TOKEN, "base64").toString("utf8")),
+        cached: true
+      };
+    }
+    if (!forceRegenerate) {
+      const existingToken = findExistingToken();
+      if (existingToken) {
+        if (!silent) {
+          console.log("[MoonUI Token Generator] Token file already exists");
+        }
+        return {
+          success: true,
+          token: JSON.parse(Buffer.from(existingToken, "base64").toString("utf8")),
+          cached: true
+        };
+      }
+    }
+    const licenseKey = process.env.MOONUI_LICENSE_KEY || process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY || process.env.VITE_MOONUI_LICENSE_KEY || process.env.REACT_APP_MOONUI_LICENSE_KEY;
+    if (!licenseKey) {
+      if (!silent) {
+        console.log("[MoonUI Token Generator] No license key found in environment variables");
+      }
+      return {
+        success: false,
+        error: "No license key found"
+      };
+    }
+    const postInstallPath = path.join(__dirname, "../../scripts/postinstall.cjs");
+    if (!fs.existsSync(postInstallPath)) {
+      if (!silent) {
+        console.error("[MoonUI Token Generator] PostInstall script not found at:", postInstallPath);
+      }
+      return {
+        success: false,
+        error: "PostInstall script not found"
+      };
+    }
+    const postInstall = __require(postInstallPath);
+    if (!silent) {
+      console.log("[MoonUI Token Generator] Validating license key and generating token...");
+    }
+    const result = await postInstall.validateAndCreateToken(licenseKey, { silent });
+    if (result.success && result.token) {
+      const saveSuccess = postInstall.saveLicenseToken(result.token);
+      if (saveSuccess) {
+        if (!silent) {
+          console.log("[MoonUI Token Generator] \u2713 Token generated and saved successfully");
+        }
+        return {
+          success: true,
+          token: result.token
+        };
+      } else {
+        if (!silent) {
+          console.log("[MoonUI Token Generator] \u26A0 Token generated but failed to save");
+        }
+        return {
+          success: false,
+          error: "Failed to save token"
+        };
+      }
+    } else {
+      if (!silent) {
+        console.log("[MoonUI Token Generator] \u2717 License validation failed:", result.error);
+      }
+      return {
+        success: false,
+        error: result.error || "License validation failed"
+      };
+    }
+  } catch (error) {
+    if (!silent) {
+      console.error("[MoonUI Token Generator] Error:", error.message);
+    }
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+function resolveTokenSync() {
+  try {
+    if (process.env.MOONUI_PRO_TOKEN) {
+      return process.env.MOONUI_PRO_TOKEN;
+    }
+    const existingToken = findExistingToken();
+    if (existingToken) {
+      return existingToken;
+    }
+    return null;
+  } catch (error) {
+    console.error("[MoonUI Token Generator] Error resolving token:", error);
+    return null;
+  }
+}
+function getLicenseKeyFromEnv() {
+  return process.env.MOONUI_LICENSE_KEY || process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY || process.env.VITE_MOONUI_LICENSE_KEY || process.env.REACT_APP_MOONUI_LICENSE_KEY || null;
+}
+
+// src/vite-plugin.ts
+function moonUIProPlugin(options = {}) {
+  const { silent = false, forceRegenerate = false } = options;
+  let token = null;
+  let tokenResolved = false;
+  return {
+    name: "moonui-pro-license",
+    enforce: "pre",
+    async buildStart() {
+      if (tokenResolved && !forceRegenerate) {
+        return;
+      }
+      if (!silent) {
+        console.log("[MoonUI Vite Plugin] === INITIALIZING ===");
+      }
+      token = resolveTokenSync();
+      if (token) {
+        if (!silent) {
+          console.log("[MoonUI Vite Plugin] \u2713 Existing token found");
+        }
+        tokenResolved = true;
+        return;
+      }
+      const licenseKey = getLicenseKeyFromEnv();
+      if (licenseKey) {
+        if (!silent) {
+          console.log("[MoonUI Vite Plugin] License key found, generating token...");
+        }
+        const result = await generateTokenIfMissing({ silent, forceRegenerate });
+        if (result.success && result.token) {
+          const tokenString = JSON.stringify(result.token);
+          token = Buffer.from(tokenString).toString("base64");
+          if (!silent) {
+            console.log("[MoonUI Vite Plugin] \u2713 Token generated successfully");
+          }
+        } else {
+          if (!silent) {
+            console.log("[MoonUI Vite Plugin] \u26A0 Token generation failed:", result.error);
+          }
+        }
+      } else {
+        if (!silent) {
+          console.log("[MoonUI Vite Plugin] No license key found in environment");
+          console.log("[MoonUI Vite Plugin] Set MOONUI_LICENSE_KEY to enable Pro features");
+        }
+      }
+      tokenResolved = true;
+      if (!silent) {
+        if (token) {
+          console.log("[MoonUI Vite Plugin] \u2713 Token will be injected into environment");
+        } else {
+          console.log("[MoonUI Vite Plugin] Running without Pro features");
+        }
+        console.log("[MoonUI Vite Plugin] === INITIALIZATION COMPLETE ===");
+      }
+    },
+    config(config) {
+      return {
+        define: {
+          ...config.define,
+          "import.meta.env.VITE_MOONUI_PRO_TOKEN": JSON.stringify(token || ""),
+          "process.env.VITE_MOONUI_PRO_TOKEN": JSON.stringify(token || "")
+        }
+      };
+    }
+  };
+}
+var vite_plugin_default = moonUIProPlugin;
+
+export { vite_plugin_default as default, moonUIProPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "3.4.2",
+    "version": "3.4.4",
     "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",
@@ -39,6 +39,21 @@
             "types": "./plugin/index.d.ts",
             "import": "./plugin/index.js",
             "require": "./plugin/index.js"
+        },
+        "./next-config": {
+            "types": "./dist/next-config-plugin.d.ts",
+            "import": "./dist/next-config-plugin.mjs",
+            "require": "./dist/next-config-plugin.mjs",
+            "default": "./dist/next-config-plugin.mjs"
+        },
+        "./vite": {
+            "types": "./dist/vite-plugin.d.ts",
+            "import": "./dist/vite-plugin.mjs",
+            "require": "./dist/vite-plugin.mjs",
+            "default": "./dist/vite-plugin.mjs"
+        },
+        "./scripts/postinstall": {
+            "require": "./scripts/postinstall.cjs"
         }
     },
     "scripts": {

package/scripts/postinstall.cjs

@@ -259,6 +259,64 @@ function saveLicenseToken(token) {
   }
 }
 
+/**
+ * Validates license key and creates token if valid
+ * @param {string} licenseKey - The license key to validate
+ * @param {object} options - Optional configuration
+ * @param {boolean} options.silent - Suppress console logs
+ * @returns {Promise<{success: boolean, token?: object, error?: string}>}
+ */
+async function validateAndCreateToken(licenseKey, options = {}) {
+  const silent = options.silent || false;
+
+  try {
+    if (!silent) {
+      console.log('[MoonUI Pro] Validating license key...');
+    }
+
+    // Validate license with API
+    const validationResult = await validateLicense(licenseKey);
+
+    if (!silent) {
+      console.log('[MoonUI Pro] Validation result:', JSON.stringify(validationResult, null, 2));
+    }
+
+    if (validationResult && validationResult.valid && validationResult.hasProAccess) {
+      if (!silent) {
+        console.log('[MoonUI Pro] ✓ License is valid and has Pro access');
+      }
+
+      // Create token with validation result and expiry
+      const token = {
+        valid: true,
+        hasProAccess: validationResult.hasProAccess,
+        plan: validationResult.plan || 'pro',
+        expiresAt: Date.now() + CACHE_DURATION,
+        timestamp: Date.now()
+      };
+
+      if (!silent) {
+        console.log('[MoonUI Pro] Creating token:', JSON.stringify(token, null, 2));
+      }
+
+      return {
+        success: true,
+        token
+      };
+    } else {
+      return {
+        success: false,
+        error: 'License validation failed or no Pro access'
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
 // Main postinstall logic
 async function main() {
   console.log('[MoonUI Pro] === POSTINSTALL SCRIPT STARTED ===');
@@ -283,9 +341,6 @@ async function main() {
 
     console.log('[MoonUI Pro] Production environment detected, checking license...');
 
-    // Remove the bypass - moonui.dev should also use license key like everyone else
-    // This prevents security vulnerability where users can set VERCEL_URL=moonui.dev
-
     // Check for license key in environment variables
     const licenseKey = process.env.MOONUI_LICENSE_KEY ||
                       process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY ||
@@ -298,30 +353,12 @@ async function main() {
       return;
     }
 
-    console.log('[MoonUI Pro] Validating license key...');
-
-    // Validate license with API
-    const validationResult = await validateLicense(licenseKey);
-
-    // Debug: Log the full validation result
-    console.log('[MoonUI Pro] Validation result:', JSON.stringify(validationResult, null, 2));
-
-    if (validationResult && validationResult.valid && validationResult.hasProAccess) {
-      console.log('[MoonUI Pro] ✓ License is valid and has Pro access');
-
-      // Create token with validation result and expiry
-      const token = {
-        valid: true,
-        hasProAccess: validationResult.hasProAccess,
-        plan: validationResult.plan || 'pro',
-        expiresAt: Date.now() + CACHE_DURATION,
-        timestamp: Date.now()
-      };
-
-      console.log('[MoonUI Pro] Creating token:', JSON.stringify(token, null, 2));
+    // Use the new validateAndCreateToken function
+    const result = await validateAndCreateToken(licenseKey);
 
+    if (result.success && result.token) {
       // Save encrypted token
-      const saveResult = saveLicenseToken(token);
+      const saveResult = saveLicenseToken(result.token);
 
       if (saveResult) {
         console.log('[MoonUI Pro] ✓ License validated successfully');
@@ -331,11 +368,7 @@ async function main() {
       }
     } else {
       console.log('[MoonUI Pro] License validation failed or no Pro access');
-      console.log('[MoonUI Pro] Validation result:', {
-        valid: validationResult?.valid || false,
-        hasProAccess: validationResult?.hasProAccess || false,
-        plan: validationResult?.plan || 'none'
-      });
+      console.log('[MoonUI Pro] Error:', result.error);
       console.log('[MoonUI Pro] Pro features will be disabled');
     }
   } catch (error) {
@@ -365,4 +398,9 @@ if (require.main === module) {
   console.log('[MoonUI Pro] PostInstall script loaded as module');
 }
 
-module.exports = { validateLicense, saveLicenseToken, isProduction };
+module.exports = {
+  validateLicense,
+  saveLicenseToken,
+  validateAndCreateToken,
+  isProduction
+};