@moontra/moonui-pro 2.37.18 → 3.0.0

package/dist/index.d.ts

@@ -376,7 +376,7 @@ declare const MoonUIAvatarFallbackPro: React$1.ForwardRefExoticComponent<Omit<Av
  * Dark ve light modda uyumlu, erişilebilir ve çeşitli varyantlar sunar.
  */
 declare const moonUIBadgeVariantsPro: (props?: ({
-    variant?: "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "pro" | "admin" | null | undefined;
+    variant?: "pro" | "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "admin" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
     radius?: "default" | "none" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -4367,7 +4367,7 @@ declare const statusVariants: (props?: ({
 declare const badgeVariants: (props?: ({
     size?: "sm" | "md" | "lg" | "xl" | "2xl" | "xs" | "3xl" | null | undefined;
     position?: "top-left" | "top-right" | "bottom-left" | "bottom-right" | null | undefined;
-    variant?: "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | "pro" | null | undefined;
+    variant?: "pro" | "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const iconBadgeMap: {
     crown: React$1.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & React$1.RefAttributes<SVGSVGElement>>;

package/dist/index.mjs

@@ -2114,6 +2114,34 @@ var AUTH_CONFIG = {
     session: "x-moonui-session-id"
   }
 };
+
+// src/lib/client-token-verifier.ts
+function verifyBuildToken() {
+  try {
+    const token = process.env.MOONUI_BUILD_TOKEN;
+    if (!token) {
+      console.log("[MoonUI] No build token found");
+      return null;
+    }
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const payload = {
+      licenseKey: decoded.licenseKey || "validated",
+      domain: decoded.domain || window.location.hostname,
+      timestamp: decoded.timestamp || Date.now(),
+      expiresAt: decoded.expiresAt || Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      hasProAccess: decoded.hasProAccess !== false,
+      plan: decoded.plan || "pro"
+    };
+    if (payload.expiresAt < Date.now()) {
+      console.warn("[MoonUI] Build token expired, rebuild required");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying build token:", error);
+    return null;
+  }
+}
 var AuthContext = createContext(void 0);
 var authPromise = null;
 var lastFetchTime = 0;
@@ -2159,6 +2187,23 @@ function MoonUIAuthProvider({ children }) {
       console.log("[MoonUI Auth] Using ongoing request");
       return authPromise;
     }
+    const buildToken = verifyBuildToken();
+    if (buildToken && buildToken.hasProAccess) {
+      console.log("[MoonUI Auth] Using build-time token - Pro access granted");
+      const tokenState = {
+        isLoading: false,
+        hasProAccess: true,
+        isAuthenticated: true,
+        subscriptionPlan: buildToken.plan === "lifetime" ? "lifetime" : "free",
+        subscription: {
+          status: "active",
+          plan: buildToken.plan === "lifetime" ? "lifetime" : "free"
+        },
+        isAdmin: false
+      };
+      setState(tokenState);
+      return tokenState;
+    }
     if (!forceRefresh2) {
       const cached = readValidationFromCookie();
       if (cached && cached.valid) {

package/dist/lib/build-time-validator.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Build-time license validation and token generation
+ * This runs during build process, not in browser
+ */
+interface TokenPayload {
+    licenseKey: string;
+    domain: string;
+    timestamp: number;
+    expiresAt: number;
+    hasProAccess: boolean;
+    plan: string;
+}
+/**
+ * Validate license key at build time
+ * Makes server-side request to avoid CORS
+ */
+declare function validateLicenseAtBuildTime(licenseKey: string | undefined, domain?: string): Promise<string | null>;
+/**
+ * Verify and decrypt token on client-side
+ */
+declare function verifyAndDecryptToken(token: string): TokenPayload | null;
+/**
+ * Generate a webpack DefinePlugin config with the token
+ */
+declare function generateWebpackDefineConfig(token: string | null): {
+    'process.env.MOONUI_BUILD_TOKEN': string;
+    'process.env.MOONUI_BUILD_TIME': string;
+};
+
+export { generateWebpackDefineConfig, validateLicenseAtBuildTime, verifyAndDecryptToken };

package/dist/lib/build-time-validator.mjs

@@ -0,0 +1,117 @@
+import crypto from 'crypto';
+
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+
+var ENCRYPTION_KEY = "moonui-pro-2024-encryption-key-v1";
+var SIGNING_KEY = "moonui-pro-2024-signing-key-v1";
+async function validateLicenseAtBuildTime(licenseKey, domain) {
+  if (!licenseKey) {
+    console.log("[MoonUI Build] No license key provided");
+    return null;
+  }
+  try {
+    console.log("[MoonUI Build] Validating license key...");
+    const validationDomain = domain || process.env.VERCEL_URL || process.env.NEXT_PUBLIC_VERCEL_URL || process.env.DEPLOY_URL || "localhost";
+    const response = await fetch("https://moonui.dev/api/v1/license/validate", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Build-Time-Validation": "true",
+        "User-Agent": "MoonUI-Build-Validator/1.0"
+      },
+      body: JSON.stringify({
+        licenseKey,
+        domain: validationDomain
+      })
+    });
+    if (!response.ok) {
+      console.error("[MoonUI Build] License validation failed:", response.status);
+      return null;
+    }
+    const data = await response.json();
+    if (!data.valid || !data.hasProAccess) {
+      console.error("[MoonUI Build] Invalid license or no Pro access");
+      return null;
+    }
+    console.log("[MoonUI Build] License validated successfully");
+    const payload = {
+      licenseKey: licenseKey.substring(0, 8) + "...",
+      // Only store partial key
+      domain: validationDomain,
+      timestamp: Date.now(),
+      expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      // 7 days
+      hasProAccess: data.hasProAccess,
+      plan: data.plan || "pro"
+    };
+    const token = encryptAndSignToken(payload);
+    return token;
+  } catch (error) {
+    console.error("[MoonUI Build] Error validating license:", error);
+    return null;
+  }
+}
+function encryptAndSignToken(payload) {
+  const payloadString = JSON.stringify(payload);
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(
+    "aes-256-gcm",
+    crypto.scryptSync(ENCRYPTION_KEY, "salt", 32),
+    iv
+  );
+  let encrypted = cipher.update(payloadString, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  const hmac = crypto.createHmac("sha256", SIGNING_KEY);
+  hmac.update(encrypted);
+  const signature = hmac.digest("hex");
+  const token = Buffer.from(JSON.stringify({
+    encrypted,
+    authTag: authTag.toString("hex"),
+    signature,
+    iv: iv.toString("hex")
+  })).toString("base64");
+  return token;
+}
+function verifyAndDecryptToken(token) {
+  try {
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const hmac = crypto.createHmac("sha256", SIGNING_KEY);
+    hmac.update(decoded.encrypted);
+    const expectedSignature = hmac.digest("hex");
+    if (decoded.signature !== expectedSignature) {
+      console.error("[MoonUI] Invalid token signature");
+      return null;
+    }
+    const decipher = crypto.createDecipheriv(
+      "aes-256-gcm",
+      crypto.scryptSync(ENCRYPTION_KEY, "salt", 32),
+      Buffer.from(decoded.iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(decoded.authTag, "hex"));
+    let decrypted = decipher.update(decoded.encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    const payload = JSON.parse(decrypted);
+    if (payload.expiresAt < Date.now()) {
+      console.error("[MoonUI] Token expired");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying token:", error);
+    return null;
+  }
+}
+function generateWebpackDefineConfig(token) {
+  return {
+    "process.env.MOONUI_BUILD_TOKEN": JSON.stringify(token),
+    "process.env.MOONUI_BUILD_TIME": JSON.stringify(Date.now())
+  };
+}
+
+export { generateWebpackDefineConfig, validateLicenseAtBuildTime, verifyAndDecryptToken };

package/dist/lib/client-token-verifier.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Client-side token verification
+ * This runs in the browser and verifies the build-time generated token
+ */
+interface TokenPayload {
+    licenseKey: string;
+    domain: string;
+    timestamp: number;
+    expiresAt: number;
+    hasProAccess: boolean;
+    plan: string;
+}
+/**
+ * Simple client-side token verification
+ * Note: Real decryption happens server-side, this is just a basic check
+ */
+declare function verifyBuildToken(): TokenPayload | null;
+/**
+ * Check if Pro features are enabled
+ */
+declare function hasProAccess(): boolean;
+/**
+ * Get subscription plan from token
+ */
+declare function getSubscriptionPlan(): string;
+
+export { getSubscriptionPlan, hasProAccess, verifyBuildToken };

package/dist/lib/client-token-verifier.mjs

@@ -0,0 +1,44 @@
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+
+// src/lib/client-token-verifier.ts
+function verifyBuildToken() {
+  try {
+    const token = process.env.MOONUI_BUILD_TOKEN;
+    if (!token) {
+      console.log("[MoonUI] No build token found");
+      return null;
+    }
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const payload = {
+      licenseKey: decoded.licenseKey || "validated",
+      domain: decoded.domain || window.location.hostname,
+      timestamp: decoded.timestamp || Date.now(),
+      expiresAt: decoded.expiresAt || Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      hasProAccess: decoded.hasProAccess !== false,
+      plan: decoded.plan || "pro"
+    };
+    if (payload.expiresAt < Date.now()) {
+      console.warn("[MoonUI] Build token expired, rebuild required");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying build token:", error);
+    return null;
+  }
+}
+function hasProAccess() {
+  const token = verifyBuildToken();
+  return token ? token.hasProAccess : false;
+}
+function getSubscriptionPlan() {
+  const token = verifyBuildToken();
+  return token ? token.plan : "free";
+}
+
+export { getSubscriptionPlan, hasProAccess, verifyBuildToken };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.37.18",
+    "version": "3.0.0",
     "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/plugin/next.js

@@ -0,0 +1,83 @@
+/**
+ * MoonUI Pro Next.js Plugin
+ * Automatically validates license at build time and injects token
+ */
+
+const { validateLicenseAtBuildTime, generateWebpackDefineConfig } = require('../dist/build-time-validator');
+const webpack = require('webpack');
+
+// Cache the token to avoid multiple validations
+let cachedToken = null;
+let isValidating = false;
+
+module.exports = function withMoonUI(nextConfig = {}) {
+  return {
+    ...nextConfig,
+    webpack: (config, options) => {
+      // Only run in production builds
+      if (!options.dev && !isValidating) {
+        isValidating = true;
+
+        // Get license key from environment
+        const licenseKey = process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY ||
+                         process.env.MOONUI_LICENSE_KEY ||
+                         process.env.MOONUI_PRO_LICENSE;
+
+        if (licenseKey) {
+          console.log('[MoonUI] Starting build-time license validation...');
+
+          // Validate license and generate token
+          const tokenPromise = validateLicenseAtBuildTime(licenseKey)
+            .then(token => {
+              if (token) {
+                cachedToken = token;
+                console.log('[MoonUI] License validated successfully, token generated');
+
+                // Add DefinePlugin to inject token
+                const defineConfig = generateWebpackDefineConfig(token);
+                config.plugins.push(
+                  new webpack.DefinePlugin(defineConfig)
+                );
+              } else {
+                console.warn('[MoonUI] License validation failed, Pro features disabled');
+              }
+            })
+            .catch(error => {
+              console.error('[MoonUI] Error during license validation:', error);
+            })
+            .finally(() => {
+              isValidating = false;
+            });
+
+          // Make build wait for validation
+          if (options.isServer) {
+            config.plugins.push({
+              apply: (compiler) => {
+                compiler.hooks.beforeCompile.tapPromise('MoonUILicensePlugin', async () => {
+                  await tokenPromise;
+                });
+              }
+            });
+          }
+        } else {
+          console.log('[MoonUI] No license key found, Pro features disabled');
+          console.log('[MoonUI] Set NEXT_PUBLIC_MOONUI_LICENSE_KEY to enable Pro features');
+        }
+      }
+
+      // Call user's webpack config if exists
+      if (typeof nextConfig.webpack === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+
+      return config;
+    },
+
+    // Preserve other Next.js configurations
+    env: {
+      ...nextConfig.env,
+      // Add build info
+      MOONUI_BUILD_VERSION: require('../package.json').version,
+    },
+  };
+};

package/plugin/vite.js

@@ -0,0 +1,76 @@
+/**
+ * MoonUI Pro Vite Plugin
+ * Automatically validates license at build time and injects token
+ */
+
+const { validateLicenseAtBuildTime } = require('../dist/build-time-validator');
+
+let cachedToken = null;
+
+module.exports = function moonuiVitePlugin() {
+  return {
+    name: 'moonui-license-validator',
+
+    async config(config, { command }) {
+      // Only run in production builds
+      if (command === 'build') {
+        // Get license key from environment
+        const licenseKey = process.env.VITE_MOONUI_LICENSE_KEY ||
+                         process.env.MOONUI_LICENSE_KEY ||
+                         process.env.MOONUI_PRO_LICENSE;
+
+        if (licenseKey) {
+          console.log('[MoonUI] Starting build-time license validation...');
+
+          try {
+            // Validate license and generate token
+            const token = await validateLicenseAtBuildTime(licenseKey);
+
+            if (token) {
+              cachedToken = token;
+              console.log('[MoonUI] License validated successfully, token generated');
+
+              // Add token to define config
+              return {
+                define: {
+                  ...config.define,
+                  'process.env.MOONUI_BUILD_TOKEN': JSON.stringify(token),
+                  'process.env.MOONUI_BUILD_TIME': JSON.stringify(Date.now()),
+                }
+              };
+            } else {
+              console.warn('[MoonUI] License validation failed, Pro features disabled');
+            }
+          } catch (error) {
+            console.error('[MoonUI] Error during license validation:', error);
+          }
+        } else {
+          console.log('[MoonUI] No license key found, Pro features disabled');
+          console.log('[MoonUI] Set VITE_MOONUI_LICENSE_KEY to enable Pro features');
+        }
+      }
+
+      return {};
+    },
+
+    // Transform hook to inject token for development
+    transform(code, id) {
+      if (id.includes('moonui-pro') && cachedToken) {
+        // Inject token into moonui-pro modules during development
+        return {
+          code: `
+            if (!process.env.MOONUI_BUILD_TOKEN) {
+              process.env.MOONUI_BUILD_TOKEN = ${JSON.stringify(cachedToken)};
+            }
+            ${code}
+          `,
+          map: null
+        };
+      }
+      return null;
+    }
+  };
+};
+
+// ES module export for Vite
+module.exports.default = module.exports;