@moontra/moonui-pro 3.0.0 → 3.1.1

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?: "pro" | "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "admin" | null | undefined;
+    variant?: "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "pro" | "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?: "pro" | "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | null | undefined;
+    variant?: "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | "pro" | 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

@@ -2115,33 +2115,39 @@ var AUTH_CONFIG = {
   }
 };
 
-// src/lib/client-token-verifier.ts
-function verifyBuildToken() {
+// src/lib/license-token-client.ts
+function readLicenseTokenClient() {
   try {
-    const token = process.env.MOONUI_BUILD_TOKEN;
-    if (!token) {
-      console.log("[MoonUI] No build token found");
+    if (typeof window === "undefined" || !window.localStorage) {
       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");
+    const storedToken = localStorage.getItem("moonui_license_token");
+    if (!storedToken) {
+      return null;
+    }
+    const token = JSON.parse(storedToken);
+    if (token.expiresAt < Date.now()) {
+      console.log("[MoonUI] Client license token expired");
+      localStorage.removeItem("moonui_license_token");
       return null;
     }
-    return payload;
+    return token;
   } catch (error) {
-    console.error("[MoonUI] Error verifying build token:", error);
+    console.error("[MoonUI] Error reading client license token:", error);
     return null;
   }
 }
+function saveLicenseTokenClient(token) {
+  try {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return;
+    }
+    localStorage.setItem("moonui_license_token", JSON.stringify(token));
+    console.log("[MoonUI] License token cached in browser");
+  } catch (error) {
+    console.error("[MoonUI] Error saving client license token:", error);
+  }
+}
 var AuthContext = createContext(void 0);
 var authPromise = null;
 var lastFetchTime = 0;
@@ -2187,17 +2193,17 @@ 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 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: buildToken.plan === "lifetime" ? "lifetime" : "free",
+        subscriptionPlan: licenseToken.plan === "lifetime" ? "lifetime" : "free",
         subscription: {
           status: "active",
-          plan: buildToken.plan === "lifetime" ? "lifetime" : "free"
+          plan: licenseToken.plan === "lifetime" ? "lifetime" : "free"
         },
         isAdmin: false
       };
@@ -2270,6 +2276,16 @@ function MoonUIAuthProvider({ children }) {
             if (response && response.ok) {
               console.log("[MoonUI Auth] Using CLI auth server");
               const data = await response.json();
+              if (data.valid && data.hasProAccess) {
+                saveLicenseTokenClient({
+                  valid: true,
+                  hasProAccess: data.hasProAccess,
+                  plan: data.plan || "lifetime",
+                  expiresAt: data.expiresAt || Date.now() + 30 * 24 * 60 * 60 * 1e3,
+                  domain: "localhost",
+                  timestamp: Date.now()
+                });
+              }
               const newState = {
                 isLoading: false,
                 hasProAccess: data.hasProAccess || false,
@@ -2314,6 +2330,14 @@ function MoonUIAuthProvider({ children }) {
                 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,

package/dist/server.d.ts

@@ -100,4 +100,29 @@ type AuthConfig = typeof AUTH_CONFIG;
 type CacheConfig = typeof AUTH_CONFIG.cache;
 type SecurityConfig = typeof AUTH_CONFIG.security;
 
-export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };
+/**
+ * License Token Reader
+ * Reads and decrypts the license token created by postinstall script
+ */
+interface LicenseToken {
+    valid: boolean;
+    hasProAccess: boolean;
+    plan: string;
+    expiresAt: number;
+    domain: string;
+    timestamp: number;
+}
+/**
+ * Read license token from file system (for server-side)
+ */
+declare function readLicenseTokenServer(): LicenseToken | null;
+/**
+ * Read license token (server-side only)
+ */
+declare function readLicenseToken(): LicenseToken | null;
+/**
+ * Check if Pro features are enabled from license token
+ */
+declare function hasProAccessFromToken(): boolean;
+
+export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, hasProAccessFromToken, performServerValidation, readLicenseToken, readLicenseTokenServer, setValidationInCookies, validateWithMoonUIServer };

package/dist/server.mjs

@@ -1,4 +1,5 @@
-import crypto from 'crypto';
+import * as crypto from 'crypto';
+import crypto__default from 'crypto';
 
 /**
  * @moontra/moonui-pro v2.0.9
@@ -3026,14 +3027,14 @@ var AUTH_CONFIG = {
 };
 var ENCRYPTION_KEY = process.env.MOONUI_ENCRYPTION_KEY || "moonui-pro-default-key-change-in-production";
 function encryptData(data) {
-  const cipher = crypto.createCipher("aes-256-cbc", ENCRYPTION_KEY);
+  const cipher = crypto__default.createCipher("aes-256-cbc", ENCRYPTION_KEY);
   let encrypted = cipher.update(JSON.stringify(data), "utf8", "hex");
   encrypted += cipher.final("hex");
   return encrypted;
 }
 function decryptData(encryptedData) {
   try {
-    const decipher = crypto.createDecipher("aes-256-cbc", ENCRYPTION_KEY);
+    const decipher = crypto__default.createDecipher("aes-256-cbc", ENCRYPTION_KEY);
     let decrypted = decipher.update(encryptedData, "hex", "utf8");
     decrypted += decipher.final("utf8");
     return JSON.parse(decrypted);
@@ -3050,7 +3051,7 @@ async function generateServerDeviceFingerprint() {
     headersList.get("accept-encoding") || "unknown",
     headersList.get("x-forwarded-for") || headersList.get("x-real-ip") || "unknown"
   ];
-  const fingerprint = crypto.createHash("sha256").update(components.join("|")).digest("hex");
+  const fingerprint = crypto__default.createHash("sha256").update(components.join("|")).digest("hex");
   return fingerprint;
 }
 async function validateWithMoonUIServer(token, deviceId) {
@@ -3147,6 +3148,74 @@ async function performServerValidation() {
   }
   return { ...result, cached: false };
 }
+function decryptToken(encryptedData, key) {
+  try {
+    const algorithm = "aes-256-gcm";
+    const salt = Buffer.from(encryptedData.salt, "hex");
+    const derivedKey = crypto.pbkdf2Sync(key, salt, 1e5, 32, "sha256");
+    const iv = Buffer.from(encryptedData.iv, "hex");
+    const authTag = Buffer.from(encryptedData.authTag, "hex");
+    const decipher = crypto.createDecipheriv(algorithm, derivedKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encryptedData.encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return JSON.parse(decrypted);
+  } catch (error) {
+    console.error("[MoonUI] Failed to decrypt license token:", error);
+    return null;
+  }
+}
+function readLicenseTokenServer() {
+  try {
+    if (typeof window !== "undefined") {
+      return null;
+    }
+    const fs = __require("fs");
+    const path = __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")
+    ];
+    let encryptedData = null;
+    let foundPath = null;
+    for (const filePath of possiblePaths) {
+      if (fs.existsSync(filePath)) {
+        foundPath = filePath;
+        const fileContent = fs.readFileSync(filePath, "utf8");
+        encryptedData = JSON.parse(fileContent);
+        break;
+      }
+    }
+    if (!encryptedData || !foundPath) {
+      console.log("[MoonUI] No license file found");
+      return null;
+    }
+    const decryptionKey = process.env.MOONUI_LICENSE_KEY || process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY || "default-key";
+    const token = decryptToken(encryptedData, decryptionKey);
+    if (!token) {
+      console.log("[MoonUI] Failed to decrypt license token");
+      return null;
+    }
+    if (token.expiresAt < Date.now()) {
+      console.log("[MoonUI] License token expired, re-validation required");
+      return null;
+    }
+    console.log("[MoonUI] License token loaded successfully from:", foundPath);
+    return token;
+  } catch (error) {
+    console.error("[MoonUI] Error reading license token:", error);
+    return null;
+  }
+}
+function readLicenseToken() {
+  return readLicenseTokenServer();
+}
+function hasProAccessFromToken() {
+  const token = readLicenseToken();
+  return token ? token.hasProAccess : false;
+}
 
 // src/server.ts
 if (typeof window !== "undefined") {
@@ -3155,4 +3224,4 @@ if (typeof window !== "undefined") {
   );
 }
 
-export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };
+export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, hasProAccessFromToken, performServerValidation, readLicenseToken, readLicenseTokenServer, setValidationInCookies, validateWithMoonUIServer };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "3.0.0",
+    "version": "3.1.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",
@@ -51,6 +51,7 @@
         "test:watch": "jest --watch",
         "test:coverage": "jest --coverage",
         "prepublishOnly": "npm run clean && npm run build",
+        "postinstall": "node scripts/postinstall.cjs",
         "pub": "npm version patch && npm run build && npm publish",
         "pub:minor": "npm version minor && npm run build && npm publish",
         "pub:major": "npm version major && npm run build && npm publish"

package/scripts/postinstall.cjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * MoonUI Pro PostInstall Script
+ * Automatically validates license in production environments during npm install
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const https = require('https');
+
+// Configuration
+const LICENSE_FILE = '.moonui-license';
+const API_URL = 'https://moonui.dev/api/v1/license/validate';
+const CACHE_DURATION = 30 * 24 * 60 * 60 * 1000; // 30 days in milliseconds
+
+// Detect if we're in production environment
+function isProduction() {
+  return (
+    process.env.NODE_ENV === 'production' ||
+    process.env.VERCEL === '1' ||
+    process.env.NETLIFY === 'true' ||
+    process.env.CI === 'true' ||
+    process.env.MOONUI_AUTH_TOKEN // Special token for CI/CD
+  );
+}
+
+// Encrypt token for storage
+function encryptToken(token, key) {
+  const algorithm = 'aes-256-gcm';
+  const salt = crypto.randomBytes(16);
+  const derivedKey = crypto.pbkdf2Sync(key, salt, 100000, 32, 'sha256');
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(algorithm, derivedKey, iv);
+
+  let encrypted = cipher.update(JSON.stringify(token), 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag();
+
+  return {
+    encrypted,
+    salt: salt.toString('hex'),
+    iv: iv.toString('hex'),
+    authTag: authTag.toString('hex')
+  };
+}
+
+// Validate license with MoonUI API
+async function validateLicense(licenseKey) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify({
+      licenseKey,
+      domain: process.env.VERCEL_URL || process.env.DEPLOY_URL || 'unknown',
+      environment: 'production'
+    });
+
+    const options = {
+      hostname: 'moonui.dev',
+      port: 443,
+      path: '/api/v1/license/validate',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData),
+        'X-PostInstall': 'true',
+        'X-Environment': process.env.VERCEL ? 'vercel' : process.env.NETLIFY ? 'netlify' : 'unknown'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const result = JSON.parse(data);
+          if (res.statusCode === 200 && result.valid) {
+            resolve(result);
+          } else {
+            reject(new Error(result.error || 'License validation failed'));
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+// Save license token to file
+function saveLicenseToken(token) {
+  try {
+    // Find the project root (where package.json is)
+    let projectRoot = process.cwd();
+    let attempts = 0;
+
+    while (attempts < 10) {
+      if (fs.existsSync(path.join(projectRoot, 'package.json'))) {
+        break;
+      }
+      projectRoot = path.dirname(projectRoot);
+      attempts++;
+    }
+
+    const licenseFilePath = path.join(projectRoot, LICENSE_FILE);
+
+    // Encrypt token with a deterministic key based on environment
+    const encryptionKey = process.env.MOONUI_LICENSE_KEY || 'default-key';
+    const encryptedData = encryptToken(token, encryptionKey);
+
+    // Save to file
+    fs.writeFileSync(licenseFilePath, JSON.stringify(encryptedData, null, 2));
+
+    console.log('[MoonUI Pro] ✓ License token saved successfully');
+    return true;
+  } catch (error) {
+    console.error('[MoonUI Pro] Failed to save license token:', error.message);
+    return false;
+  }
+}
+
+// Main postinstall logic
+async function main() {
+  try {
+    // Only run in production environments
+    if (!isProduction()) {
+      console.log('[MoonUI Pro] Development environment detected, skipping license validation');
+      return;
+    }
+
+    console.log('[MoonUI Pro] Production environment detected, checking license...');
+
+    // Check for license key in environment variables
+    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) {
+      console.log('[MoonUI Pro] No license key found in environment variables');
+      console.log('[MoonUI Pro] Set MOONUI_LICENSE_KEY to enable Pro features');
+      return;
+    }
+
+    console.log('[MoonUI Pro] Validating license key...');
+
+    // Validate license with API
+    const validationResult = await validateLicense(licenseKey);
+
+    if (validationResult.valid && validationResult.hasProAccess) {
+      // Create token with validation result and expiry
+      const token = {
+        valid: true,
+        hasProAccess: validationResult.hasProAccess,
+        plan: validationResult.plan,
+        expiresAt: Date.now() + CACHE_DURATION,
+        domain: validationResult.domain,
+        timestamp: Date.now()
+      };
+
+      // Save encrypted token
+      saveLicenseToken(token);
+
+      console.log('[MoonUI Pro] ✓ License validated successfully');
+      console.log('[MoonUI Pro] ✓ Pro features enabled');
+    } else {
+      console.log('[MoonUI Pro] License validation failed');
+      console.log('[MoonUI Pro] Pro features will be disabled');
+    }
+  } catch (error) {
+    console.error('[MoonUI Pro] Error during postinstall:', error.message);
+    console.log('[MoonUI Pro] Continuing with Free plan');
+
+    // Don't fail the install process
+    process.exit(0);
+  }
+}
+
+// Run if called directly (not imported)
+if (require.main === module) {
+  main().catch(error => {
+    console.error('[MoonUI Pro] Unexpected error:', error);
+    process.exit(0); // Don't fail npm install
+  });
+}
+
+module.exports = { validateLicense, saveLicenseToken, isProduction };

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

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,117 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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 };