@moontra/moonui-pro 2.20.1 → 2.20.3

package/scripts/postinstall.js

@@ -155,22 +155,99 @@ const validateAuth = async (token) => {
 };
 
 const checkEnvironmentAuth = () => {
-  // Check for auth token in environment variables
+  // Check for different types of auth tokens in environment variables
+  const teamToken = process.env.MOONUI_TEAM_TOKEN;
+  const ciToken = process.env.MOONUI_CI_TOKEN;
   const envToken = process.env.MOONUI_AUTH_TOKEN || process.env.MOONUI_ACCESS_TOKEN;
+  const licenseKey = process.env.MOONUI_LICENSE_KEY;
+  
+  if (teamToken) {
+    log('👥 Found team token in environment variables', colors.blue);
+    return { token: teamToken, type: 'team' };
+  }
+  
+  if (ciToken) {
+    log('🤖 Found CI token in environment variables', colors.blue);
+    return { token: ciToken, type: 'ci' };
+  }
+  
+  if (licenseKey) {
+    log('🔐 Found license key in environment variables', colors.blue);
+    return { token: licenseKey, type: 'license' };
+  }
   
   if (envToken) {
     log('🔑 Found auth token in environment variables', colors.blue);
-    return envToken;
+    return { token: envToken, type: 'personal' };
   }
   
   return null;
 };
 
+// Check for perpetual license stamp
+const checkLicenseStamp = () => {
+  try {
+    const stampPath = path.join(process.cwd(), '.moonui-license-stamp');
+    if (fs.existsSync(stampPath)) {
+      const stamp = JSON.parse(fs.readFileSync(stampPath, 'utf8'));
+      
+      if (stamp.projectId && stamp.licensedAt && stamp.version) {
+        log('📋 Using perpetual license stamp', colors.green);
+        log(`   Licensed on: ${new Date(stamp.licensedAt).toLocaleDateString()}`, colors.blue);
+        log(`   Version: ${stamp.version}`, colors.blue);
+        log(`   Mode: Perpetual (no active license required)`, colors.green);
+        log('', '');
+        log('ℹ️  Your project has perpetual usage rights', colors.cyan);
+        log('   Updates require active license', colors.gray);
+        return true;
+      }
+    }
+  } catch (error) {
+    // Invalid stamp
+  }
+  return false;
+};
+
+// Create license stamp for perpetual usage
+const createLicenseStamp = (authInfo) => {
+  try {
+    const stamp = {
+      projectId: crypto.randomBytes(16).toString('hex'),
+      licensedAt: new Date().toISOString(),
+      version: process.env.npm_package_version || '2.x',
+      licensedTo: authInfo.user?.email || 'unknown',
+      plan: authInfo.user?.plan || 'unknown',
+      mode: 'perpetual',
+      installedComponents: []
+    };
+    
+    const stampPath = path.join(process.cwd(), '.moonui-license-stamp');
+    fs.writeFileSync(stampPath, JSON.stringify(stamp, null, 2), 'utf8');
+    
+    log('', '');
+    log('📋 License stamp created!', colors.green + colors.bright);
+    log('   Your project now has perpetual usage rights', colors.green);
+    log('   You can build without active license', colors.blue);
+    log('   Commit .moonui-license-stamp to your repository', colors.yellow);
+    
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
 const main = async () => {
   log('', ''); // Empty line
   log('🌙 MoonUI Pro Installation', colors.cyan + colors.bright);
   log('═'.repeat(50), colors.gray);
   
+  // Check for perpetual license stamp first
+  if (checkLicenseStamp()) {
+    log('✅ Installation complete with perpetual license', colors.green);
+    log('═'.repeat(50), colors.gray);
+    return;
+  }
+  
   // Check for development bypass
   if (process.env.MOONUI_DEV_MODE === 'true' || process.env.MOONUI_SKIP_AUTH === 'true') {
     log('🔧 Development Mode Enabled', colors.yellow + colors.bright);
@@ -197,35 +274,108 @@ const main = async () => {
     return;
   }
   
-  // Check if this is a CI environment
-  const isCI = process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS;
+  // Check for environment-based authentication first
+  const envAuth = checkEnvironmentAuth();
   
-  if (isCI) {
-    log('🤖 CI Environment detected', colors.blue);
+  if (envAuth) {
+    // Handle different token types
+    if (envAuth.type === 'team') {
+      log('🏢 Team License Mode', colors.blue + colors.bright);
+      log('   Multiple developers can use this token', colors.blue);
+      log('   No device restrictions applied', colors.gray);
+      
+      // Validate team token
+      log('🔍 Validating team license...', colors.blue);
+      const validation = await validateAuth(envAuth.token);
+      
+      if (validation.valid) {
+        log('✅ Team authentication successful!', colors.green);
+        log(`   Team: ${validation.team?.name || 'N/A'}`, colors.blue);
+        log(`   Seats: ${validation.team?.seats || 'N/A'}`, colors.blue);
+        
+        // Create perpetual license stamp for team
+        createLicenseStamp({ user: { email: 'team', plan: 'team' }, ...validation });
+        return;
+      } else {
+        log('❌ Team authentication failed!', colors.red);
+        log(`   Error: ${validation.message}`, colors.red);
+        process.exit(1);
+      }
+    }
     
-    const envToken = checkEnvironmentAuth();
-    if (!envToken) {
-      log('⚠️  No auth token found in CI environment', colors.yellow);
-      log('   Set MOONUI_AUTH_TOKEN environment variable for CI builds', colors.gray);
-      log('   Get your token by running: moonui whoami --token', colors.gray);
-      return;
+    if (envAuth.type === 'ci' || process.env.CI) {
+      log('🤖 CI/CD Mode', colors.blue + colors.bright);
+      log('   Running in continuous integration environment', colors.blue);
+      
+      // Validate CI token
+      log('🔍 Validating CI token...', colors.blue);
+      const validation = await validateAuth(envAuth.token);
+      
+      if (validation.valid) {
+        log('✅ CI authentication successful!', colors.green);
+        log(`   Environment: ${process.env.CI_NAME || 'CI'}`, colors.blue);
+        return;
+      } else {
+        log('❌ CI authentication failed!', colors.red);
+        log(`   Error: ${validation.message}`, colors.red);
+        process.exit(1);
+      }
     }
     
-    // Validate CI auth
-    log('🔍 Validating CI authentication...', colors.blue);
-    const validation = await validateAuth(envToken);
+    if (envAuth.type === 'license') {
+      log('🔐 License Key Mode', colors.blue + colors.bright);
+      log('   Project-based licensing', colors.blue);
+      
+      // Validate license key
+      log('🔍 Validating license key...', colors.blue);
+      const validation = await validateAuth(envAuth.token);
+      
+      if (validation.valid) {
+        log('✅ License validation successful!', colors.green);
+        log(`   Project: ${validation.project?.name || 'N/A'}`, colors.blue);
+        log(`   Valid until: ${validation.expiresAt || 'Lifetime'}`, colors.blue);
+        return;
+      } else {
+        log('❌ License validation failed!', colors.red);
+        log(`   Error: ${validation.message}`, colors.red);
+        process.exit(1);
+      }
+    }
     
-    if (validation.valid) {
-      log('✅ CI Authentication successful!', colors.green);
-      log(`   Plan: ${validation.user?.plan || 'N/A'}`, colors.blue);
-      return;
-    } else {
-      log('❌ CI Authentication failed!', colors.red);
-      log(`   Error: ${validation.message}`, colors.red);
-      process.exit(1);
+    // Personal token with existing flow
+    if (envAuth.type === 'personal') {
+      log('👤 Personal License Mode', colors.blue + colors.bright);
+      log('   Single developer license', colors.blue);
+      
+      const validation = await validateAuth(envAuth.token);
+      
+      if (validation.valid) {
+        log('✅ Personal authentication successful!', colors.green);
+        log(`   User: ${validation.user?.email || 'N/A'}`, colors.blue);
+        return;
+      } else {
+        log('❌ Personal authentication failed!', colors.red);
+        log(`   Error: ${validation.message}`, colors.red);
+        process.exit(1);
+      }
     }
   }
   
+  // Check if this is a CI environment without token
+  const isCI = process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS;
+  
+  if (isCI && !envAuth) {
+    log('⚠️  CI Environment detected but no auth token found', colors.yellow);
+    log('', '');
+    log('📋 Please set one of the following environment variables:', colors.blue);
+    log('   MOONUI_CI_TOKEN     - For CI/CD pipelines', colors.blue);
+    log('   MOONUI_TEAM_TOKEN   - For team licenses', colors.blue);
+    log('   MOONUI_LICENSE_KEY  - For project licenses', colors.blue);
+    log('', '');
+    log('📖 Documentation: https://moonui.dev/docs/ci-setup', colors.gray);
+    return;
+  }
+  
   // Regular installation - check for existing auth
   const authConfig = getAuthConfig();
   
@@ -273,6 +423,9 @@ const main = async () => {
     log(`   Plan: ${validation.user?.plan || authConfig.user?.plan}`, colors.blue);
     log(`   Account: ${authConfig.user?.email || 'N/A'}`, colors.blue);
     
+    // Create perpetual license stamp
+    createLicenseStamp(authConfig);
+    
     if (validation.expiresAt) {
       const expiryDate = new Date(validation.expiresAt);
       const daysLeft = Math.ceil((expiryDate - new Date()) / (1000 * 60 * 60 * 24));

package/src/__tests__/use-intersection-observer.test.tsx

@@ -1,216 +0,0 @@
-import { renderHook, act } from '@testing-library/react';
-import { useIntersectionObserver } from '../use-intersection-observer';
-
-// Mock IntersectionObserver
-const mockIntersectionObserver = jest.fn();
-mockIntersectionObserver.mockImplementation((callback, options) => {
-  return {
-    observe: jest.fn(),
-    unobserve: jest.fn(),
-    disconnect: jest.fn(),
-  };
-});
-
-beforeAll(() => {
-  global.IntersectionObserver = mockIntersectionObserver;
-});
-
-describe('useIntersectionObserver', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should return ref and isIntersecting state', () => {
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    expect(result.current.ref).toBeDefined();
-    expect(result.current.isIntersecting).toBe(false);
-    expect(typeof result.current.ref).toBe('function');
-  });
-
-  it('should create IntersectionObserver with default options', () => {
-    renderHook(() => useIntersectionObserver());
-    
-    expect(mockIntersectionObserver).toHaveBeenCalledWith(
-      expect.any(Function),
-      {
-        threshold: 0,
-        root: null,
-        rootMargin: '0%',
-      }
-    );
-  });
-
-  it('should create IntersectionObserver with custom options', () => {
-    const options = {
-      threshold: 0.5,
-      root: document.body,
-      rootMargin: '10px',
-    };
-    
-    renderHook(() => useIntersectionObserver(options));
-    
-    expect(mockIntersectionObserver).toHaveBeenCalledWith(
-      expect.any(Function),
-      options
-    );
-  });
-
-  it('should observe element when ref is set', () => {
-    const mockObserve = jest.fn();
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: mockObserve,
-      unobserve: jest.fn(),
-      disconnect: jest.fn(),
-    }));
-
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    const mockElement = document.createElement('div');
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    expect(mockObserve).toHaveBeenCalledWith(mockElement);
-  });
-
-  it('should call onChange when intersection state changes', () => {
-    const mockOnChange = jest.fn();
-    let observerCallback: any;
-    
-    mockIntersectionObserver.mockImplementation((callback) => {
-      observerCallback = callback;
-      return {
-        observe: jest.fn(),
-        unobserve: jest.fn(),
-        disconnect: jest.fn(),
-      };
-    });
-
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ onChange: mockOnChange })
-    );
-    
-    const mockElement = document.createElement('div');
-    const mockEntry = {
-      isIntersecting: true,
-      target: mockElement,
-    };
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    act(() => {
-      observerCallback([mockEntry]);
-    });
-    
-    expect(mockOnChange).toHaveBeenCalledWith(true, mockEntry);
-  });
-
-  it('should freeze state when freezeOnceVisible is true', () => {
-    let observerCallback: any;
-    
-    mockIntersectionObserver.mockImplementation((callback) => {
-      observerCallback = callback;
-      return {
-        observe: jest.fn(),
-        unobserve: jest.fn(),
-        disconnect: jest.fn(),
-      };
-    });
-
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ freezeOnceVisible: true })
-    );
-    
-    const mockElement = document.createElement('div');
-    const mockEntry = {
-      isIntersecting: true,
-      target: mockElement,
-    };
-    
-    act(() => {
-      result.current.ref(mockElement);
-    });
-    
-    // First intersection - should update
-    act(() => {
-      observerCallback([mockEntry]);
-    });
-    
-    expect(result.current.isIntersecting).toBe(true);
-    
-    // Second intersection with false - should not update (frozen)
-    act(() => {
-      observerCallback([{ ...mockEntry, isIntersecting: false }]);
-    });
-    
-    expect(result.current.isIntersecting).toBe(true);
-  });
-
-  it('should disconnect observer on unmount', () => {
-    const mockDisconnect = jest.fn();
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: jest.fn(),
-      unobserve: jest.fn(),
-      disconnect: mockDisconnect,
-    }));
-
-    const { unmount } = renderHook(() => useIntersectionObserver());
-    
-    unmount();
-    
-    expect(mockDisconnect).toHaveBeenCalled();
-  });
-
-  it('should handle initialIsIntersecting option', () => {
-    const { result } = renderHook(() => 
-      useIntersectionObserver({ initialIsIntersecting: true })
-    );
-    
-    expect(result.current.isIntersecting).toBe(true);
-  });
-
-  it('should not create observer when IntersectionObserver is not supported', () => {
-    // Temporarily remove IntersectionObserver
-    const originalIntersectionObserver = global.IntersectionObserver;
-    (global as any).IntersectionObserver = undefined;
-    
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    expect(result.current.ref).toBeDefined();
-    expect(result.current.isIntersecting).toBe(false);
-    
-    // Restore IntersectionObserver
-    global.IntersectionObserver = originalIntersectionObserver;
-  });
-
-  it('should handle multiple elements with useMultipleIntersectionObserver', () => {
-    // This would be a separate hook, but we can test the concept
-    const mockObserve = jest.fn();
-    const mockUnobserve = jest.fn();
-    
-    mockIntersectionObserver.mockImplementation(() => ({
-      observe: mockObserve,
-      unobserve: mockUnobserve,
-      disconnect: jest.fn(),
-    }));
-
-    const { result } = renderHook(() => useIntersectionObserver());
-    
-    const element1 = document.createElement('div');
-    const element2 = document.createElement('div');
-    
-    act(() => {
-      result.current.ref(element1);
-    });
-    
-    act(() => {
-      result.current.ref(element2);
-    });
-    
-    expect(mockObserve).toHaveBeenCalledWith(element2);
-  });
-});

package/src/__tests__/use-local-storage.test.tsx

@@ -1,174 +0,0 @@
-import { renderHook, act } from '@testing-library/react'
-import { useLocalStorage } from '../use-local-storage'
-
-// Mock localStorage
-const mockLocalStorage = (() => {
-  let store: Record<string, string> = {}
-
-  return {
-    getItem: jest.fn((key: string) => store[key] || null),
-    setItem: jest.fn((key: string, value: string) => {
-      store[key] = value
-    }),
-    removeItem: jest.fn((key: string) => {
-      delete store[key]
-    }),
-    clear: jest.fn(() => {
-      store = {}
-    }),
-    get length() {
-      return Object.keys(store).length
-    },
-    key: jest.fn((index: number) => Object.keys(store)[index] || null),
-  }
-})()
-
-Object.defineProperty(window, 'localStorage', {
-  value: mockLocalStorage,
-})
-
-describe('useLocalStorage', () => {
-  beforeEach(() => {
-    mockLocalStorage.clear()
-    jest.clearAllMocks()
-  })
-
-  it('returns initial value when localStorage is empty', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    expect(result.current[0]).toBe('initial')
-    expect(mockLocalStorage.getItem).toHaveBeenCalledWith('test-key')
-  })
-
-  it('returns stored value from localStorage', () => {
-    mockLocalStorage.setItem('test-key', JSON.stringify('stored-value'))
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    expect(result.current[0]).toBe('stored-value')
-  })
-
-  it('stores value in localStorage when setValue is called', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1]('new-value')
-    })
-    
-    expect(result.current[0]).toBe('new-value')
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify('new-value'))
-  })
-
-  it('handles function updates', () => {
-    const { result } = renderHook(() => useLocalStorage('test-key', 10))
-    
-    act(() => {
-      result.current[1]((prev) => (prev ?? 0) + 5)
-    })
-    
-    expect(result.current[0]).toBe(15)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('test-key', JSON.stringify(15))
-  })
-
-  it('handles complex objects', () => {
-    const initialObject = { name: 'test', count: 0 }
-    const { result } = renderHook(() => useLocalStorage('object-key', initialObject))
-    
-    const newObject = { name: 'updated', count: 5 }
-    
-    act(() => {
-      result.current[1](newObject)
-    })
-    
-    expect(result.current[0]).toEqual(newObject)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('object-key', JSON.stringify(newObject))
-  })
-
-  it('handles localStorage errors gracefully', () => {
-    mockLocalStorage.setItem.mockImplementation(() => {
-      throw new Error('Storage quota exceeded')
-    })
-    
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1]('new-value')
-    })
-    
-    // Should still update the state even if localStorage fails
-    expect(result.current[0]).toBe('new-value')
-    expect(consoleSpy).toHaveBeenCalled()
-    
-    consoleSpy.mockRestore()
-  })
-
-  it('handles malformed JSON in localStorage', () => {
-    mockLocalStorage.getItem.mockReturnValue('invalid-json{')
-    
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation()
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    // Should fall back to initial value when JSON parsing fails
-    expect(result.current[0]).toBe('initial')
-    expect(consoleSpy).toHaveBeenCalled()
-    
-    consoleSpy.mockRestore()
-  })
-
-  it('removes item from localStorage when value is undefined', () => {
-    mockLocalStorage.setItem('test-key', JSON.stringify('stored-value'))
-    
-    const { result } = renderHook(() => useLocalStorage('test-key', 'initial'))
-    
-    act(() => {
-      result.current[1](undefined)
-    })
-    
-    expect(result.current[0]).toBeUndefined()
-    expect(mockLocalStorage.removeItem).toHaveBeenCalledWith('test-key')
-  })
-
-  it('handles boolean values correctly', () => {
-    const { result } = renderHook(() => useLocalStorage('bool-key', false))
-    
-    act(() => {
-      result.current[1](true)
-    })
-    
-    expect(result.current[0]).toBe(true)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('bool-key', JSON.stringify(true))
-  })
-
-  it('handles null values correctly', () => {
-    const { result } = renderHook(() => useLocalStorage<string | null>('null-key', null))
-    
-    act(() => {
-      result.current[1]('not-null')
-    })
-    
-    expect(result.current[0]).toBe('not-null')
-    
-    act(() => {
-      result.current[1](null)
-    })
-    
-    expect(result.current[0]).toBe(null)
-    expect(mockLocalStorage.setItem).toHaveBeenCalledWith('null-key', JSON.stringify(null))
-  })
-
-  it('maintains state consistency across multiple hook instances with same key', () => {
-    const { result: result1 } = renderHook(() => useLocalStorage('shared-key', 'initial'))
-    const { result: result2 } = renderHook(() => useLocalStorage('shared-key', 'initial'))
-    
-    act(() => {
-      result1.current[1]('updated')
-    })
-    
-    // Both instances should have the same value
-    expect(result1.current[0]).toBe('updated')
-    expect(result2.current[0]).toBe('updated')
-  })
-})