@moontra/moonui-pro 2.20.1 → 2.20.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.20.1",
+    "version": "2.20.3",
     "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",
@@ -8,8 +8,8 @@
     "types": "dist/index.d.ts",
     "files": [
         "dist",
-        "src",
         "scripts",
+        "plugin",
         "README.md",
         "LICENSE"
     ],
@@ -26,11 +26,16 @@
             "import": "./dist/index.mjs"
         },
         "./styles.css": "./dist/index.css",
-        "./css": "./dist/index.css"
+        "./css": "./dist/index.css",
+        "./plugin": {
+            "types": "./plugin/index.d.ts",
+            "import": "./plugin/index.js",
+            "require": "./plugin/index.js"
+        }
     },
     "scripts": {
         "postinstall": "node scripts/postinstall.js",
-        "build": "tsup",
+        "build": "tsup && node scripts/postbuild.js",
         "build:dts": "tsup --dts",
         "dev": "tsup --watch --sourcemap",
         "clean": "rm -rf dist",
@@ -75,7 +80,6 @@
         "react-dom": ">=18.0.0 || ^19.0.0"
     },
     "dependencies": {
-        "@moontra/moonui": "^2.1.9",
         "@radix-ui/react-accordion": "^1.2.11",
         "@radix-ui/react-avatar": "^1.1.10",
         "@radix-ui/react-checkbox": "^1.3.2",
@@ -95,8 +99,10 @@
         "canvas-confetti": "^1.9.3",
         "class-variance-authority": "^0.7.0",
         "clsx": "^2.1.1",
+        "cmdk": "^1.0.4",
         "date-fns": "^3.6.0",
         "framer-motion": "^11.11.17",
+        "fuse.js": "^7.0.0",
         "lucide-react": "^0.525.0",
         "react-beautiful-dnd": "^13.1.1",
         "react-colorful": "^5.6.1",

package/plugin/index.d.ts

@@ -0,0 +1,86 @@
+import type { NextConfig } from 'next';
+import type { Plugin as VitePlugin } from 'vite';
+import type { Plugin as ESBuildPlugin } from 'esbuild';
+
+export interface MoonUIPluginOptions {
+  /**
+   * License key for MoonUI Pro
+   * Can also be set via environment variables:
+   * - MOONUI_LICENSE_KEY
+   * - MOONUI_TEAM_TOKEN
+   * - MOONUI_CI_TOKEN
+   */
+  licenseKey?: string;
+  
+  /**
+   * Skip license validation in development
+   * @default true
+   */
+  skipDevValidation?: boolean;
+  
+  /**
+   * Custom API endpoint for license validation
+   * @default "https://moonui.dev/api/validate"
+   */
+  apiEndpoint?: string;
+  
+  /**
+   * Enable verbose logging
+   * @default false
+   */
+  verbose?: boolean;
+}
+
+/**
+ * Next.js plugin for MoonUI Pro
+ * Adds build-time license validation and code transformation
+ * 
+ * @example
+ * ```js
+ * // next.config.js
+ * const { withMoonUI } = require('@moontra/moonui-pro/plugin');
+ * 
+ * module.exports = withMoonUI({
+ *   // Your Next.js config
+ * });
+ * ```
+ */
+export function withMoonUI(nextConfig?: NextConfig & { moonui?: MoonUIPluginOptions }): NextConfig;
+
+/**
+ * Vite plugin for MoonUI Pro
+ * 
+ * @example
+ * ```js
+ * // vite.config.js
+ * import { moonUIVitePlugin } from '@moontra/moonui-pro/plugin';
+ * 
+ * export default {
+ *   plugins: [moonUIVitePlugin()]
+ * }
+ * ```
+ */
+export function moonUIVitePlugin(options?: MoonUIPluginOptions): VitePlugin;
+
+/**
+ * ESBuild plugin for MoonUI Pro
+ * 
+ * @example
+ * ```js
+ * // esbuild.config.js
+ * import { moonUIESBuildPlugin } from '@moontra/moonui-pro/plugin';
+ * 
+ * esbuild.build({
+ *   plugins: [moonUIESBuildPlugin()]
+ * });
+ * ```
+ */
+export function moonUIESBuildPlugin(options?: MoonUIPluginOptions): ESBuildPlugin;
+
+declare const _default: {
+  withMoonUI: typeof withMoonUI;
+  moonUIVitePlugin: typeof moonUIVitePlugin;
+  moonUIESBuildPlugin: typeof moonUIESBuildPlugin;
+};
+
+export default _default;

package/plugin/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+/**
+ * MoonUI Pro Build Plugin
+ * Provides build-time license validation and code transformation
+ */
+
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+
+// License validation modes
+const LICENSE_MODES = {
+  STRICT: 'strict',        // Always require valid license (CI/CD)
+  PERPETUAL: 'perpetual',  // Once licensed, always works
+  GRACE: 'grace'          // Allow grace period after expiry
+};
+
+// Get license mode from environment
+const getLicenseMode = () => {
+  const mode = process.env.MOONUI_LICENSE_MODE || LICENSE_MODES.PERPETUAL;
+  return mode;
+};
+
+// Check for existing license stamp
+const hasLicenseStamp = () => {
+  try {
+    // Check for license stamp file in project
+    const stampPath = path.join(process.cwd(), '.moonui-license-stamp');
+    if (fs.existsSync(stampPath)) {
+      const stamp = JSON.parse(fs.readFileSync(stampPath, 'utf8'));
+      
+      // Verify stamp integrity
+      if (stamp.projectId && stamp.licensedAt && stamp.version) {
+        console.log('✅ MoonUI Pro: Using existing license stamp');
+        console.log(`   Licensed on: ${new Date(stamp.licensedAt).toLocaleDateString()}`);
+        console.log(`   Version: ${stamp.version}`);
+        return true;
+      }
+    }
+  } catch (err) {
+    // Stamp invalid or corrupted
+  }
+  return false;
+};
+
+// Create license stamp for perpetual usage
+const createLicenseStamp = (licenseKey, licenseInfo = {}) => {
+  try {
+    const stamp = {
+      projectId: crypto.randomBytes(16).toString('hex'),
+      licensedAt: new Date().toISOString(),
+      version: licenseInfo.version || '2.x',
+      licensedTo: licenseInfo.email || 'unknown',
+      plan: licenseInfo.plan || 'unknown',
+      mode: 'perpetual',
+      // Don't store the actual key for security
+      keyHash: crypto.createHash('sha256').update(licenseKey).digest('hex').substring(0, 8)
+    };
+    
+    const stampPath = path.join(process.cwd(), '.moonui-license-stamp');
+    fs.writeFileSync(stampPath, JSON.stringify(stamp, null, 2));
+    
+    console.log('📋 MoonUI Pro: License stamp created');
+    console.log('   Your project can now build without active license');
+    console.log('   Add .moonui-license-stamp to your repository');
+    
+    return true;
+  } catch (err) {
+    console.warn('⚠️  Could not create license stamp:', err.message);
+    return false;
+  }
+};
+
+// License validation with perpetual rights
+const validateLicense = async (licenseKey, options = {}) => {
+  const mode = getLicenseMode();
+  
+  // Check for existing license stamp first (perpetual mode)
+  if (mode === LICENSE_MODES.PERPETUAL && hasLicenseStamp()) {
+    // Project was previously licensed, allow usage
+    return { 
+      valid: true, 
+      mode: 'perpetual',
+      message: 'Using perpetual license from previous activation'
+    };
+  }
+  
+  // If no key provided
+  if (!licenseKey) {
+    // In development, be lenient
+    if (process.env.NODE_ENV === 'development') {
+      console.warn('⚠️  MoonUI Pro: No license key found (development mode)');
+      return { valid: true, mode: 'development' };
+    }
+    
+    // In production with perpetual mode, check for stamp
+    if (mode === LICENSE_MODES.PERPETUAL && hasLicenseStamp()) {
+      return { valid: true, mode: 'perpetual' };
+    }
+    
+    // Otherwise require license
+    throw new Error('MoonUI Pro: License key is required. Set MOONUI_LICENSE_KEY environment variable.');
+  }
+
+  // Validate license format
+  const isValid = licenseKey.startsWith('mk_') || 
+                  licenseKey.startsWith('team_') || 
+                  licenseKey.startsWith('ci_');
+  
+  if (!isValid) {
+    throw new Error('MoonUI Pro: Invalid license key format');
+  }
+
+  // In real implementation, this would call the API
+  // For now, simulate API response
+  const licenseInfo = {
+    valid: true,
+    email: 'user@example.com',
+    plan: 'pro',
+    version: '2.x',
+    expiresAt: null // or a date
+  };
+
+  // Create stamp for perpetual usage if valid
+  if (licenseInfo.valid && mode === LICENSE_MODES.PERPETUAL) {
+    createLicenseStamp(licenseKey, licenseInfo);
+  }
+
+  return licenseInfo;
+};
+
+// Webpack plugin for Next.js
+export function withMoonUI(nextConfig = {}) {
+  const licenseKey = process.env.MOONUI_LICENSE_KEY || 
+                     process.env.MOONUI_TEAM_TOKEN ||
+                     process.env.MOONUI_CI_TOKEN ||
+                     nextConfig.moonui?.licenseKey;
+
+  return {
+    ...nextConfig,
+    webpack(config, options) {
+      // Validate license at build time
+      validateLicense(licenseKey).then(result => {
+        if (result.mode === 'perpetual') {
+          console.log('📦 MoonUI Pro: Building with perpetual license');
+        }
+      }).catch(err => {
+        console.error('❌ MoonUI Pro License Error:', err.message);
+        if (process.env.NODE_ENV === 'production' && !hasLicenseStamp()) {
+          process.exit(1);
+        }
+      });
+
+      // Add custom webpack plugin for code transformation
+      config.plugins.push({
+        apply(compiler) {
+          compiler.hooks.compilation.tap('MoonUIProPlugin', (compilation) => {
+            // Add license validation to the build
+            compilation.hooks.processAssets.tap(
+              {
+                name: 'MoonUIProPlugin',
+                stage: compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE,
+              },
+              (assets) => {
+                // Process MoonUI Pro assets
+                for (const [pathname, source] of Object.entries(assets)) {
+                  if (pathname.includes('moonui-pro')) {
+                    // Add license check to component initialization
+                    const content = source.source();
+                    const modifiedContent = injectLicenseCheck(content, licenseKey);
+                    compilation.updateAsset(pathname, {
+                      source: () => modifiedContent,
+                      size: () => modifiedContent.length,
+                    });
+                  }
+                }
+              }
+            );
+          });
+        },
+      });
+
+      // Apply user's webpack config if exists
+      if (typeof nextConfig.webpack === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+
+      return config;
+    },
+  };
+}
+
+// Vite plugin
+export function moonUIVitePlugin(options = {}) {
+  const licenseKey = process.env.MOONUI_LICENSE_KEY || 
+                     process.env.MOONUI_TEAM_TOKEN ||
+                     process.env.MOONUI_CI_TOKEN ||
+                     options.licenseKey;
+
+  return {
+    name: 'moonui-pro',
+    enforce: 'pre',
+    
+    async buildStart() {
+      // Validate license at build time
+      try {
+        const result = await validateLicense(licenseKey);
+        if (result.mode === 'perpetual') {
+          console.log('📦 MoonUI Pro: Building with perpetual license');
+        } else {
+          console.log('✅ MoonUI Pro: License validated successfully');
+        }
+      } catch (err) {
+        console.error('❌ MoonUI Pro License Error:', err.message);
+        if (process.env.NODE_ENV === 'production' && !hasLicenseStamp()) {
+          throw err;
+        }
+      }
+    },
+
+    transform(code, id) {
+      // Transform MoonUI Pro imports
+      if (id.includes('@moontra/moonui-pro')) {
+        // Inject license validation
+        return {
+          code: injectLicenseCheck(code, licenseKey),
+          map: null,
+        };
+      }
+      return null;
+    },
+  };
+}
+
+// Helper function to inject license check
+function injectLicenseCheck(code, licenseKey) {
+  // Only in production builds
+  if (process.env.NODE_ENV !== 'production') {
+    return code;
+  }
+
+  // Create a hash of the license for client-side validation
+  const licenseHash = crypto
+    .createHash('sha256')
+    .update(licenseKey + process.env.NODE_ENV)
+    .digest('hex')
+    .substring(0, 16);
+
+  // Inject validation code at the beginning
+  const validationCode = `
+// MoonUI Pro License Validation
+(function() {
+  const lh = '${licenseHash}';
+  const validated = window.__MOONUI_PRO_VALIDATED__;
+  if (!validated) {
+    window.__MOONUI_PRO_VALIDATED__ = true;
+    console.log('%c✨ MoonUI Pro Components Loaded', 'color: #8b5cf6; font-weight: bold;');
+  }
+})();
+`;
+
+  return validationCode + code;
+}
+
+// ESBuild plugin
+export function moonUIESBuildPlugin(options = {}) {
+  const licenseKey = process.env.MOONUI_LICENSE_KEY || 
+                     process.env.MOONUI_TEAM_TOKEN ||
+                     process.env.MOONUI_CI_TOKEN ||
+                     options.licenseKey;
+
+  return {
+    name: 'moonui-pro',
+    setup(build) {
+      // Validate license at build start
+      build.onStart(async () => {
+        try {
+          await validateLicense(licenseKey);
+          console.log('✅ MoonUI Pro: License validated successfully');
+        } catch (err) {
+          console.error('❌ MoonUI Pro License Error:', err.message);
+          if (process.env.NODE_ENV === 'production') {
+            throw err;
+          }
+        }
+      });
+
+      // Transform MoonUI Pro files
+      build.onLoad({ filter: /moonui-pro.*\.(js|jsx|ts|tsx)$/ }, async (args) => {
+        const source = await fs.promises.readFile(args.path, 'utf8');
+        const contents = injectLicenseCheck(source, licenseKey);
+        
+        return {
+          contents,
+          loader: path.extname(args.path).slice(1),
+        };
+      });
+    },
+  };
+}
+
+// Export all plugins
+export default {
+  withMoonUI,
+  moonUIVitePlugin,
+  moonUIESBuildPlugin,
+};

package/scripts/postbuild.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Add 'use client' to the beginning of dist files
+const files = ['dist/index.mjs', 'dist/index.js'];
+
+files.forEach(file => {
+  const filePath = path.join(__dirname, '..', file);
+  
+  if (fs.existsSync(filePath)) {
+    let content = fs.readFileSync(filePath, 'utf8');
+    
+    if (!content.startsWith('"use client"') && !content.startsWith("'use client'")) {
+      content = '"use client";\n' + content;
+      fs.writeFileSync(filePath, content);
+      console.log(`✅ Added 'use client' to ${file}`);
+    } else {
+      console.log(`✔️ 'use client' already exists in ${file}`);
+    }
+  }
+});