unified-video-framework 1.0.0

package/packages/web/src/react/WebPlayerView.tsx

@@ -0,0 +1,177 @@
+// @ts-nocheck
+import React, { useEffect, useRef } from 'react';
+import type { CSSProperties } from 'react';
+import type { VideoSource, SubtitleTrack, VideoMetadata, PlayerConfig } from '@unified-video/core';
+import { WebPlayer } from '../WebPlayer';
+
+export type WebPlayerViewProps = {
+  // Player config
+  autoPlay?: boolean;
+  muted?: boolean;
+  enableAdaptiveBitrate?: boolean;
+  debug?: boolean;
+  freeDuration?: number;
+  // Paywall
+  paywall?: import('@unified-video/core').PaywallConfig;
+  paywallConfigUrl?: string; // optional endpoint returning PaywallConfig JSON
+
+  // Source config
+  url: string;
+  type?: 'mp4' | 'hls' | 'dash' | 'webm' | 'auto';
+  subtitles?: SubtitleTrack[];
+  metadata?: VideoMetadata;
+
+  // Optional Google Cast sender SDK loader
+  cast?: boolean;
+
+  // Styling
+  className?: string;
+  style?: CSSProperties;
+  // Dynamic theming: pass a single accent color string or an object with fields
+  // { accent, accent2, iconColor, textPrimary, textSecondary }
+  playerTheme?: string | { accent?: string; accent2?: string; iconColor?: string; textPrimary?: string; textSecondary?: string };
+
+  // Callbacks
+  onReady?: (player: WebPlayer) => void;
+  onError?: (error: unknown) => void;
+};
+
+export const WebPlayerView: React.FC<WebPlayerViewProps> = (props) => {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const playerRef = useRef<WebPlayer | null>(null);
+
+  // Checkout return bridge: forward rental=success/cancel with session_id/order_id back to opener and close
+  useEffect(() => {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const popup = (params.get('popup') || '').toLowerCase() === '1';
+      const status = (params.get('rental') || '').toLowerCase();
+      const orderId = params.get('order_id') || '';
+      const sessionId = params.get('session_id') || '';
+      if (popup && (status === 'success' || status === 'cancel')) {
+        try { window.opener?.postMessage({ type: 'uvfCheckout', status, orderId, sessionId }, '*'); } catch (_) {}
+        try { window.close(); } catch (_) {}
+      }
+    } catch (_) {}
+  }, []);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function boot() {
+      if (!containerRef.current) return;
+
+      const player = new WebPlayer();
+      playerRef.current = player;
+
+      // Optionally load Google Cast sender SDK
+      if (props.cast) {
+        try {
+          const existing = document.querySelector('script[data-cast-sdk="1"]');
+          if (!existing) {
+            const s = document.createElement('script');
+            s.src = 'https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1';
+            s.async = true;
+            s.setAttribute('data-cast-sdk', '1');
+            document.head.appendChild(s);
+          }
+        } catch (_) {
+          // ignore load issues in SSR or restricted environments
+        }
+      }
+
+      // Resolve paywall config: inline or fetched
+      let paywallCfg = props.paywall as any;
+      if (!paywallCfg && props.paywallConfigUrl) {
+        try {
+          const resp = await fetch(props.paywallConfigUrl);
+          if (resp.ok) paywallCfg = await resp.json();
+        } catch(_) {}
+      }
+
+      const config: PlayerConfig = {
+        autoPlay: props.autoPlay ?? false,
+        muted: props.muted ?? false,
+        enableAdaptiveBitrate: props.enableAdaptiveBitrate ?? true,
+        debug: props.debug ?? false,
+        freeDuration: props.freeDuration,
+        paywall: paywallCfg
+      };
+
+      try {
+        await player.initialize(containerRef.current, config);
+
+        // Apply theme before loading source (so poster and UI show themed styles)
+        try {
+          if (props.playerTheme && (player as any).setTheme) {
+            (player as any).setTheme(props.playerTheme as any);
+          }
+        } catch (_) {}
+
+        const source: VideoSource = {
+          url: props.url,
+          type: props.type ?? 'auto',
+          subtitles: props.subtitles,
+          metadata: props.metadata,
+        };
+
+        await player.load(source);
+        if (!cancelled) props.onReady?.(player);
+      } catch (err) {
+        if (!cancelled) props.onError?.(err);
+      }
+    }
+
+    void boot();
+
+    return () => {
+      cancelled = true;
+      if (playerRef.current) {
+        playerRef.current.destroy().catch(() => {});
+        playerRef.current = null;
+      }
+    };
+  }, [
+    props.autoPlay,
+    props.muted,
+    props.enableAdaptiveBitrate,
+    props.debug,
+    props.url,
+    props.type,
+    JSON.stringify(props.subtitles),
+    JSON.stringify(props.metadata),
+    props.cast,
+    props.freeDuration,
+  ])
+
+  // Update free preview duration at runtime without full re-init
+  useEffect(() => {
+    const p = playerRef.current as any;
+    if (p && typeof p.setFreeDuration === 'function' && typeof props.freeDuration !== 'undefined') {
+      try { p.setFreeDuration(props.freeDuration as number); } catch(_) {}
+    }
+  }, [props.freeDuration]);
+
+  // Update paywall config at runtime if prop changes
+  useEffect(() => {
+    const p = playerRef.current as any;
+    if (p && typeof p.setPaywallConfig === 'function' && props.paywall) {
+      try { p.setPaywallConfig(props.paywall as any); } catch(_) {}
+    }
+  }, [JSON.stringify(props.paywall)]);
+
+  // Respond to theme updates without reinitializing the player
+  useEffect(() => {
+    const p = playerRef.current as any;
+    try {
+      if (p && typeof p.setTheme === 'function') {
+        p.setTheme(props.playerTheme as any);
+      }
+    } catch (_) {}
+  }, [JSON.stringify(props.playerTheme)]);
+
+  return <div ref={containerRef} className={props.className} style={props.style} />;
+};
+
+export default WebPlayerView;
+

package/packages/web/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "composite": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../core" }
+  ]
+}

package/packages/web/webpack.config.js

@@ -0,0 +1,45 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  entry: './src/index.ts',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'unified-video-web.js',
+    library: {
+      name: 'UnifiedVideoWeb',
+      type: 'umd'
+    },
+    globalObject: 'this'
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/
+      }
+    ]
+  },
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js'],
+    alias: {
+      '@unified-video/core': path.resolve(__dirname, '../core/src')
+    }
+  },
+  externals: {
+    'hls.js': {
+      commonjs: 'hls.js',
+      commonjs2: 'hls.js',
+      amd: 'hls.js',
+      root: 'Hls'
+    },
+    'dashjs': {
+      commonjs: 'dashjs',
+      commonjs2: 'dashjs',
+      amd: 'dashjs',
+      root: 'dashjs'
+    }
+  },
+  devtool: 'source-map'
+};

package/server.js

@@ -0,0 +1,131 @@
+// Simple HTTP server for local development
+// This server properly handles CORS and MIME types for video streaming
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+
+const PORT = 3000;
+const HOST = 'localhost';
+
+// MIME type mappings
+const mimeTypes = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.m3u8': 'application/x-mpegURL',
+    '.ts': 'video/MP2T',
+    '.mpd': 'application/dash+xml',
+    '.woff': 'application/font-woff',
+    '.ttf': 'application/font-ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'application/font-otf',
+    '.wasm': 'application/wasm'
+};
+
+const server = http.createServer((req, res) => {
+    console.log(`${req.method} ${req.url}`);
+
+    // Parse URL
+    const parsedUrl = url.parse(req.url);
+    
+    // Extract pathname
+    let pathname = `.${parsedUrl.pathname}`;
+    
+    // Default to index.html for root
+    if (pathname === './') {
+        pathname = './apps/demo/demo.html';
+    }
+    
+    // Resolve full path
+    const filePath = path.resolve(pathname);
+    
+    // Security check - ensure we're not serving files outside the project directory
+    const projectDir = path.resolve('./');
+    if (!filePath.startsWith(projectDir)) {
+        res.statusCode = 403;
+        res.end('Forbidden');
+        return;
+    }
+    
+    // Check if file exists
+    fs.exists(filePath, (exist) => {
+        if (!exist) {
+            // File not found
+            res.statusCode = 404;
+            res.end(`File ${pathname} not found!`);
+            return;
+        }
+
+        // If directory, try to serve index.html
+        if (fs.statSync(filePath).isDirectory()) {
+            const indexPath = path.join(filePath, 'index.html');
+            if (fs.existsSync(indexPath)) {
+                serveFile(indexPath, res);
+            } else {
+                res.statusCode = 403;
+                res.end('Directory listing not allowed');
+            }
+            return;
+        }
+
+        // Serve the file
+        serveFile(filePath, res);
+    });
+});
+
+function serveFile(filePath, res) {
+    // Read file
+    fs.readFile(filePath, (err, data) => {
+        if (err) {
+            res.statusCode = 500;
+            res.end(`Error getting the file: ${err}.`);
+        } else {
+            // Set proper headers
+            const ext = path.parse(filePath).ext;
+            const mimeType = mimeTypes[ext] || 'application/octet-stream';
+            
+            // Add CORS headers for development
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Range');
+            
+            // Set content type
+            res.setHeader('Content-Type', mimeType);
+            
+            // Enable byte-range requests for video streaming
+            if (mimeType.startsWith('video/') || mimeType.startsWith('audio/')) {
+                res.setHeader('Accept-Ranges', 'bytes');
+            }
+            
+            // Send the file
+            res.statusCode = 200;
+            res.end(data);
+        }
+    });
+}
+
+server.listen(PORT, HOST, () => {
+    console.log(`
+╔════════════════════════════════════════════════════════╗
+║                                                        ║
+║     Unified Video Framework - Development Server      ║
+║                                                        ║
+╚════════════════════════════════════════════════════════╝
+
+Server running at: http://${HOST}:${PORT}
+Demo page: http://${HOST}:${PORT}/apps/demo/demo.html
+
+Press Ctrl+C to stop the server
+`);
+});

package/server.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Simple HTTP server for local development of Unified Video Framework
+Python 3 alternative to Node.js server
+"""
+
+import http.server
+import socketserver
+import os
+import sys
+from urllib.parse import urlparse
+
+PORT = 3000
+HOST = "localhost"
+
+class CORSRequestHandler(http.server.SimpleHTTPRequestHandler):
+    """HTTP request handler with CORS headers."""
+    
+    def end_headers(self):
+        """Add CORS headers to all responses."""
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type, Range')
+        
+        # Add proper MIME types for video files
+        if self.path.endswith('.m3u8'):
+            self.send_header('Content-Type', 'application/x-mpegURL')
+        elif self.path.endswith('.mpd'):
+            self.send_header('Content-Type', 'application/dash+xml')
+        elif self.path.endswith('.ts'):
+            self.send_header('Content-Type', 'video/MP2T')
+            
+        super().end_headers()
+    
+    def do_OPTIONS(self):
+        """Handle OPTIONS requests for CORS preflight."""
+        self.send_response(200)
+        self.end_headers()
+    
+    def do_GET(self):
+        """Handle GET requests."""
+        # Redirect root to demo page
+        if self.path == '/':
+            self.path = '/apps/demo/demo.html'
+        
+        # Log the request
+        print(f"GET {self.path}")
+        
+        # Serve the file
+        super().do_GET()
+
+def run_server():
+    """Start the development server."""
+    try:
+        # Change to the project directory
+        os.chdir(os.path.dirname(os.path.abspath(__file__)))
+        
+        # Create server
+        with socketserver.TCPServer((HOST, PORT), CORSRequestHandler) as httpd:
+            print(f"""
+╔════════════════════════════════════════════════════════╗
+║                                                        ║
+║     Unified Video Framework - Development Server      ║
+║                     (Python Version)                   ║
+║                                                        ║
+╚════════════════════════════════════════════════════════╝
+
+Server running at: http://{HOST}:{PORT}
+Demo page: http://{HOST}:{PORT}/apps/demo/demo.html
+
+Press Ctrl+C to stop the server
+""")
+            # Start serving
+            httpd.serve_forever()
+            
+    except KeyboardInterrupt:
+        print("\nServer stopped.")
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error starting server: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    run_server()

package/test-urls.ps1

@@ -0,0 +1,97 @@
+# Test all video URLs in the framework to ensure they're accessible
+
+Write-Host "Testing Video URLs in Unified Video Framework" -ForegroundColor Cyan
+Write-Host "=" * 50
+
+# Define all URLs to test
+$urls = @(
+    @{Name="Mux HLS Stream"; URL="https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8"; Type="HLS"},
+    @{Name="Unified Streaming HLS"; URL="https://demo.unified-streaming.com/k8s/features/stable/video/tears-of-steel/tears-of-steel.ism/.m3u8"; Type="HLS"},
+    @{Name="Akamai DASH BBB"; URL="https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd"; Type="DASH"},
+    @{Name="Akamai DASH Envivio"; URL="https://dash.akamaized.net/envivio/EnvivioDash3/manifest.mpd"; Type="DASH"},
+    @{Name="Google Shaka DASH"; URL="https://storage.googleapis.com/shaka-demo-assets/angel-one/dash.mpd"; Type="DASH"},
+    @{Name="Big Buck Bunny MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"; Type="MP4"},
+    @{Name="Elephants Dream MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4"; Type="MP4"},
+    @{Name="Sintel MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/Sintel.mp4"; Type="MP4"}
+)
+
+$results = @()
+
+foreach ($item in $urls) {
+    Write-Host "`nTesting: $($item.Name) [$($item.Type)]" -ForegroundColor Yellow
+    Write-Host "URL: $($item.URL)" -ForegroundColor Gray
+    
+    try {
+        $response = Invoke-WebRequest -Uri $item.URL -Method Head -TimeoutSec 10 -UseBasicParsing -ErrorAction Stop
+        $statusCode = $response.StatusCode
+        
+        if ($statusCode -eq 200) {
+            Write-Host "✓ SUCCESS: Status $statusCode" -ForegroundColor Green
+            $status = "Working"
+        } else {
+            Write-Host "⚠ WARNING: Status $statusCode" -ForegroundColor Yellow
+            $status = "Warning - Status $statusCode"
+        }
+    }
+    catch {
+        $errorMessage = $_.Exception.Message
+        
+        if ($errorMessage -like "*403*") {
+            Write-Host "✗ FORBIDDEN: Access denied (403)" -ForegroundColor Red
+            $status = "Broken - 403 Forbidden"
+        }
+        elseif ($errorMessage -like "*404*") {
+            Write-Host "✗ NOT FOUND: URL not found (404)" -ForegroundColor Red
+            $status = "Broken - 404 Not Found"
+        }
+        else {
+            # Some servers don't support HEAD requests, try GET with limited range
+            try {
+                $response2 = Invoke-WebRequest -Uri $item.URL -Method Get -Headers @{"Range"="bytes=0-1"} -TimeoutSec 10 -UseBasicParsing -ErrorAction Stop
+                Write-Host "✓ SUCCESS: Server responded (GET request)" -ForegroundColor Green
+                $status = "Working"
+            }
+            catch {
+                Write-Host "✗ ERROR: $($_.Exception.Message)" -ForegroundColor Red
+                $status = "Error - $($_.Exception.Message)"
+            }
+        }
+    }
+    
+    $results += [PSCustomObject]@{
+        Name = $item.Name
+        Type = $item.Type
+        URL = $item.URL
+        Status = $status
+    }
+}
+
+Write-Host "`n" + ("=" * 50) -ForegroundColor Cyan
+Write-Host "SUMMARY REPORT" -ForegroundColor Cyan
+Write-Host ("=" * 50) -ForegroundColor Cyan
+
+$working = $results | Where-Object { $_.Status -eq "Working" }
+$broken = $results | Where-Object { $_.Status -like "Broken*" }
+$errors = $results | Where-Object { $_.Status -like "Error*" -or $_.Status -like "Warning*" }
+
+Write-Host "`nWorking URLs: $($working.Count)/$($results.Count)" -ForegroundColor Green
+if ($broken.Count -gt 0) {
+    Write-Host "Broken URLs: $($broken.Count)" -ForegroundColor Red
+    $broken | ForEach-Object {
+        Write-Host "  - $($_.Name): $($_.Status)" -ForegroundColor Red
+    }
+}
+
+if ($errors.Count -gt 0) {
+    Write-Host "`nURLs with issues: $($errors.Count)" -ForegroundColor Yellow
+    $errors | ForEach-Object {
+        Write-Host "  - $($_.Name): $($_.Status)" -ForegroundColor Yellow
+    }
+}
+
+Write-Host "`nDetailed Results:" -ForegroundColor Cyan
+$results | Format-Table -AutoSize
+
+# Export results to JSON for reference
+$results | ConvertTo-Json -Depth 3 | Out-File "url-test-results.json"
+Write-Host "`nResults saved to url-test-results.json" -ForegroundColor Gray

package/test-video-urls.ps1

@@ -0,0 +1,87 @@
+# Test all video URLs in the framework to ensure they're accessible
+
+Write-Host "`nTesting Video URLs in Unified Video Framework`n" -ForegroundColor Cyan
+Write-Host ("=" * 60) -ForegroundColor Cyan
+
+# Define all URLs to test
+$urls = @(
+    @{Name="Mux HLS Stream"; URL="https://test-streams.mux.dev/x36xhzz/x36xhzz.m3u8"; Type="HLS"},
+    @{Name="Unified Streaming HLS"; URL="https://demo.unified-streaming.com/k8s/features/stable/video/tears-of-steel/tears-of-steel.ism/.m3u8"; Type="HLS"},
+    @{Name="Akamai DASH BBB"; URL="https://dash.akamaized.net/akamai/bbb_30fps/bbb_30fps.mpd"; Type="DASH"},
+    @{Name="Akamai DASH Envivio"; URL="https://dash.akamaized.net/envivio/EnvivioDash3/manifest.mpd"; Type="DASH"},
+    @{Name="Google Shaka DASH"; URL="https://storage.googleapis.com/shaka-demo-assets/angel-one/dash.mpd"; Type="DASH"},
+    @{Name="Big Buck Bunny MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"; Type="MP4"},
+    @{Name="Elephants Dream MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4"; Type="MP4"},
+    @{Name="Sintel MP4"; URL="https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/Sintel.mp4"; Type="MP4"}
+)
+
+$results = @()
+$workingCount = 0
+$brokenCount = 0
+
+foreach ($item in $urls) {
+    Write-Host "`nTesting: $($item.Name) [$($item.Type)]" -ForegroundColor Yellow
+    Write-Host "URL: $($item.URL)" -ForegroundColor Gray
+    
+    $status = "Unknown"
+    
+    try {
+        # Try a simple web request with a timeout
+        $response = Invoke-WebRequest -Uri $item.URL -Method Get -Headers @{"Range"="bytes=0-1"} -TimeoutSec 5 -UseBasicParsing -ErrorAction Stop
+        Write-Host "✓ SUCCESS: URL is accessible" -ForegroundColor Green
+        $status = "Working"
+        $workingCount++
+    }
+    catch {
+        $errorMsg = $_.Exception.Message
+        
+        if ($errorMsg -match "403") {
+            Write-Host "✗ FORBIDDEN: Access denied (403)" -ForegroundColor Red
+            $status = "403 Forbidden"
+            $brokenCount++
+        }
+        elseif ($errorMsg -match "404") {
+            Write-Host "✗ NOT FOUND: URL not found (404)" -ForegroundColor Red
+            $status = "404 Not Found"
+            $brokenCount++
+        }
+        else {
+            Write-Host "⚠ WARNING: Could not verify (may still work in browser)" -ForegroundColor Yellow
+            $status = "Uncertain"
+        }
+    }
+    
+    $results += [PSCustomObject]@{
+        Name = $item.Name
+        Type = $item.Type
+        Status = $status
+    }
+}
+
+Write-Host "`n" -NoNewline
+Write-Host ("=" * 60) -ForegroundColor Cyan
+Write-Host "SUMMARY REPORT" -ForegroundColor Cyan
+Write-Host ("=" * 60) -ForegroundColor Cyan
+
+Write-Host "`nTotal URLs tested: $($urls.Count)" -ForegroundColor White
+Write-Host "✓ Working: $workingCount" -ForegroundColor Green
+Write-Host "✗ Broken: $brokenCount" -ForegroundColor Red
+Write-Host "⚠ Uncertain: $($urls.Count - $workingCount - $brokenCount)" -ForegroundColor Yellow
+
+Write-Host "`nDetailed Results:" -ForegroundColor Cyan
+$results | Format-Table Name, Type, Status -AutoSize
+
+# Show which files use broken URLs if any found
+if ($brokenCount -gt 0) {
+    Write-Host "`n⚠ Action Required:" -ForegroundColor Red
+    Write-Host "Found $brokenCount broken URL(s) that need to be replaced in the framework." -ForegroundColor Red
+    
+    $brokenUrls = $results | Where-Object { $_.Status -match "403|404" }
+    foreach ($broken in $brokenUrls) {
+        Write-Host "`n  • $($broken.Name) ($($broken.Status))" -ForegroundColor Yellow
+        Write-Host "    Type: $($broken.Type)" -ForegroundColor Gray
+    }
+}
+else {
+    Write-Host "`n✓ All URLs are working correctly!" -ForegroundColor Green
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "composite": true,
+    "removeComments": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react"
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "build",
+    "*.config.js",
+    "*.config.ts"
+  ],
+  "references": [
+    { "path": "./packages/core" },
+    { "path": "./packages/web" },
+    { "path": "./packages/react-native" }
+  ]
+}