@moontra/moonui-pro 3.4.3 → 3.4.5

package/dist/next-config-plugin.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Next.js Config Plugin for MoonUI Pro
+ * Automatically resolves and injects license token at build time
+ *
+ * Usage in next.config.js:
+ *
+ * ```js
+ * const { withMoonUIProToken } = require('@moontra/moonui-pro/next-config');
+ *
+ * const nextConfig = {
+ *   // your config
+ * };
+ *
+ * module.exports = withMoonUIProToken(nextConfig);
+ * ```
+ */
+interface NextConfig {
+    env?: Record<string, string>;
+    [key: string]: any;
+}
+/**
+ * Next.js config wrapper that auto-resolves MoonUI Pro token
+ */
+declare function withMoonUIProToken(nextConfig?: NextConfig): NextConfig;
+/**
+ * Async version for webpack plugins (advanced usage)
+ */
+declare function resolveTokenAsync(): Promise<string | null>;
+
+export { withMoonUIProToken as default, resolveTokenAsync, withMoonUIProToken };

package/dist/next-config-plugin.mjs

@@ -0,0 +1,202 @@
+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/next-config-plugin.ts
+function withMoonUIProToken(nextConfig = {}) {
+  console.log("[MoonUI Next.js Plugin] === INITIALIZING ===");
+  let token = resolveTokenSync();
+  if (token) {
+    console.log("[MoonUI Next.js Plugin] \u2713 Existing token found");
+  } else {
+    const licenseKey = getLicenseKeyFromEnv();
+    if (licenseKey) {
+      console.log("[MoonUI Next.js Plugin] License key found, will attempt runtime generation...");
+      console.log("[MoonUI Next.js Plugin] \u2139 Token will be generated on first use (runtime fallback)");
+    } else {
+      console.log("[MoonUI Next.js Plugin] No license key found in environment");
+      console.log("[MoonUI Next.js Plugin] Set MOONUI_LICENSE_KEY to enable Pro features");
+    }
+  }
+  const enhancedConfig = {
+    ...nextConfig,
+    env: {
+      ...nextConfig.env,
+      NEXT_PUBLIC_MOONUI_PRO_TOKEN: token || ""
+    }
+  };
+  if (token) {
+    console.log("[MoonUI Next.js Plugin] \u2713 Token injected into NEXT_PUBLIC_MOONUI_PRO_TOKEN");
+  } else {
+    console.log("[MoonUI Next.js Plugin] Running without Pro token (will use runtime fallback)");
+  }
+  console.log("[MoonUI Next.js Plugin] === INITIALIZATION COMPLETE ===");
+  return enhancedConfig;
+}
+async function resolveTokenAsync() {
+  const syncToken = resolveTokenSync();
+  if (syncToken) {
+    return syncToken;
+  }
+  const licenseKey = getLicenseKeyFromEnv();
+  if (!licenseKey) {
+    return null;
+  }
+  console.log("[MoonUI Next.js Plugin] Generating token asynchronously...");
+  const result = await generateTokenIfMissing({ silent: false });
+  if (result.success && result.token) {
+    const tokenString = JSON.stringify(result.token);
+    return Buffer.from(tokenString).toString("base64");
+  }
+  return null;
+}
+var next_config_plugin_default = withMoonUIProToken;
+
+export { next_config_plugin_default as default, resolveTokenAsync, withMoonUIProToken };

package/dist/server.d.ts

@@ -118,6 +118,7 @@ interface LicenseToken {
 declare function readLicenseTokenServer(): LicenseToken | null;
 /**
  * Read license token (server-side only)
+ * With runtime fallback if token not found
  */
 declare function readLicenseToken(): LicenseToken | null;
 /**

package/dist/server.mjs

@@ -1,3 +1,5 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import * as crypto from 'crypto';
 import crypto__default from 'crypto';
 
@@ -20,9 +22,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -39,6 +48,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/next/dist/compiled/@edge-runtime/cookies/index.js
 var require_cookies = __commonJS({
@@ -47,7 +57,7 @@ var require_cookies = __commonJS({
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
     var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export = (target, all) => {
+    var __export2 = (target, all) => {
       for (var name in all)
         __defProp2(target, name, { get: all[name], enumerable: true });
     };
@@ -59,16 +69,16 @@ var require_cookies = __commonJS({
       }
       return to;
     };
-    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var src_exports = {};
-    __export(src_exports, {
+    __export2(src_exports, {
       RequestCookies: () => RequestCookies,
       ResponseCookies: () => ResponseCookies,
       parseCookie: () => parseCookie,
       parseSetCookie: () => parseSetCookie,
       stringifyCookie: () => stringifyCookie
     });
-    module.exports = __toCommonJS(src_exports);
+    module.exports = __toCommonJS2(src_exports);
     function stringifyCookie(c) {
       var _a;
       const attrs = [
@@ -113,7 +123,7 @@ var require_cookies = __commonJS({
         expires,
         httponly,
         maxage,
-        path,
+        path: path2,
         samesite,
         secure,
         partitioned,
@@ -131,7 +141,7 @@ var require_cookies = __commonJS({
         ...expires && { expires: new Date(expires) },
         ...httponly && { httpOnly: true },
         ...typeof maxage === "string" && { maxAge: Number(maxage) },
-        path,
+        path: path2,
         ...samesite && { sameSite: parseSameSite(samesite) },
         ...secure && { secure: true },
         ...priority && { priority: parsePriority(priority) },
@@ -2960,6 +2970,152 @@ var require_headers3 = __commonJS({
   }
 });
 
+// src/lib/license-token-generator.ts
+var license_token_generator_exports = {};
+__export(license_token_generator_exports, {
+  generateTokenIfMissing: () => generateTokenIfMissing,
+  getLicenseKeyFromEnv: () => getLicenseKeyFromEnv,
+  resolveTokenSync: () => resolveTokenSync
+});
+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;
+}
+var init_license_token_generator = __esm({
+  "src/lib/license-token-generator.ts"() {
+  }
+});
+
 // src/lib/server-auth.ts
 var import_headers = __toESM(require_headers3(), 1);
 
@@ -3184,27 +3340,27 @@ function readLicenseTokenServer() {
         console.error("[MoonUI] Failed to parse MOONUI_PRO_TOKEN:", envError);
       }
     }
-    const fs = __require("fs");
-    const path = __require("path");
+    const fs2 = __require("fs");
+    const path2 = __require("path");
     const possiblePaths = [
-      path.join(process.cwd(), ".moonui-license"),
-      path.join(process.cwd(), "..", ".moonui-license"),
-      path.join(process.cwd(), "..", "..", ".moonui-license"),
-      path.join(__dirname, "..", "..", "..", "..", ".moonui-license")
+      path2.join(process.cwd(), ".moonui-license"),
+      path2.join(process.cwd(), "..", ".moonui-license"),
+      path2.join(process.cwd(), "..", "..", ".moonui-license"),
+      path2.join(__dirname, "..", "..", "..", "..", ".moonui-license")
     ];
     if (process.env.VERCEL_ARTIFACTS_PATH) {
-      possiblePaths.push(path.join(process.env.VERCEL_ARTIFACTS_PATH, ".moonui-license"));
+      possiblePaths.push(path2.join(process.env.VERCEL_ARTIFACTS_PATH, ".moonui-license"));
     }
     if (process.env.NETLIFY_BUILD_BASE) {
-      possiblePaths.push(path.join(process.env.NETLIFY_BUILD_BASE, ".moonui-license"));
+      possiblePaths.push(path2.join(process.env.NETLIFY_BUILD_BASE, ".moonui-license"));
     }
     possiblePaths.push("/tmp/.moonui-license");
     let encryptedData = null;
     let foundPath = null;
     for (const filePath of possiblePaths) {
-      if (fs.existsSync(filePath)) {
+      if (fs2.existsSync(filePath)) {
         foundPath = filePath;
-        const fileContent = fs.readFileSync(filePath, "utf8");
+        const fileContent = fs2.readFileSync(filePath, "utf8");
         encryptedData = JSON.parse(fileContent);
         break;
       }
@@ -3230,8 +3386,51 @@ function readLicenseTokenServer() {
     return null;
   }
 }
+async function generateTokenAtRuntime() {
+  try {
+    if (typeof window !== "undefined") {
+      return null;
+    }
+    console.log("[MoonUI] Runtime fallback: Attempting to generate token...");
+    const { generateTokenIfMissing: generateTokenIfMissing2 } = (init_license_token_generator(), __toCommonJS(license_token_generator_exports));
+    const result = await generateTokenIfMissing2({ silent: false });
+    if (result.success && result.token) {
+      console.log("[MoonUI] \u2713 Token generated at runtime");
+      return result.token;
+    } else {
+      console.log("[MoonUI] \u2717 Runtime token generation failed:", result.error);
+      return null;
+    }
+  } catch (error) {
+    console.error("[MoonUI] Runtime fallback error:", error.message);
+    return null;
+  }
+}
+var runtimeToken = void 0;
+var runtimeTokenAttempted = false;
 function readLicenseToken() {
-  return readLicenseTokenServer();
+  const token = readLicenseTokenServer();
+  if (token) {
+    return token;
+  }
+  if (runtimeTokenAttempted) {
+    return runtimeToken || null;
+  }
+  if (typeof window === "undefined") {
+    console.log("[MoonUI] Token not found, scheduling runtime generation...");
+    generateTokenAtRuntime().then((token2) => {
+      runtimeToken = token2;
+      runtimeTokenAttempted = true;
+      if (token2) {
+        console.log("[MoonUI] \u2713 Runtime token generation completed");
+      }
+    }).catch((error) => {
+      console.error("[MoonUI] Runtime token generation failed:", error);
+      runtimeTokenAttempted = true;
+      runtimeToken = null;
+    });
+  }
+  return null;
 }
 function hasProAccessFromToken() {
   const token = readLicenseToken();

package/dist/vite-plugin.d.ts

@@ -0,0 +1,38 @@
+import { Plugin } from 'vite';
+
+/**
+ * Vite Plugin for MoonUI Pro
+ * Automatically resolves and injects license token at build time
+ *
+ * Usage in vite.config.ts:
+ *
+ * ```ts
+ * import { moonUIProPlugin } from '@moontra/moonui-pro/vite';
+ * import { defineConfig } from 'vite';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     moonUIProPlugin(),
+ *   ],
+ * });
+ * ```
+ */
+
+interface MoonUIProPluginOptions {
+    /**
+     * Suppress console logs
+     * @default false
+     */
+    silent?: boolean;
+    /**
+     * Force token regeneration even if exists
+     * @default false
+     */
+    forceRegenerate?: boolean;
+}
+/**
+ * Vite plugin for MoonUI Pro license token management
+ */
+declare function moonUIProPlugin(options?: MoonUIProPluginOptions): Plugin;
+
+export { moonUIProPlugin as default, moonUIProPlugin };

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.3",
+    "version": "3.4.5",
     "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
+};