nuclie 1.0.0

package/dist/plugins/core/linker.js

@@ -0,0 +1,51 @@
+import { canonicalHash } from '../../core/engine/hash.js';
+/**
+ * Internal Linker Plugin
+ *
+ * Rewrites import/require specifiers using the DependencyGraph's specifierMap.
+ * This runs after all other transformations to ensure final code uses Nuclie module IDs.
+ */
+export function createLinkerPlugin() {
+    return {
+        manifest: {
+            name: 'nuclie:linker',
+            version: '1.0.0',
+            engineVersion: '1.0.0',
+            type: 'js',
+            hooks: ['transformModule'],
+            permissions: { fs: 'none' }
+        },
+        id: canonicalHash('nuclie:linker'),
+        async runHook(hook, input, context) {
+            if (hook !== 'transformModule')
+                return input;
+            // We need the graph to do linking
+            const graph = context?.graph;
+            if (!graph)
+                return input;
+            // Find the node for this file
+            // Note: input.path is absolute
+            const node = Array.from(graph.nodes.values()).find((n) => n.path === input.path);
+            if (!node || !node.specifierMap)
+                return input;
+            let code = input.code;
+            // Basic speculative replacement for performance
+            // In a production world, we'd use a proper AST walker or a regex that guards against comments
+            // For now, let's use a regex that matches require("specifier") or from "specifier"
+            for (const [specifier, targetId] of Object.entries(node.specifierMap)) {
+                // Escape regex special chars
+                const escaped = specifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // Replace in require()
+                const requireRegex = new RegExp(`require\\s*\\(\\s*['"]${escaped}['"]\\s*\\)`, 'g');
+                code = code.replace(requireRegex, `require(${JSON.stringify(targetId)})`);
+                // Replace in import ... from "..."
+                const importRegex = new RegExp(`from\\s*['"]${escaped}['"]`, 'g');
+                code = code.replace(importRegex, `from ${JSON.stringify(targetId)}`);
+                // Replace in import("...")
+                const dynamicImportRegex = new RegExp(`import\\s*\\(\\s*['"]${escaped}['"]\\s*\\)`, 'g');
+                code = code.replace(dynamicImportRegex, `import(${JSON.stringify(targetId)})`);
+            }
+            return { ...input, code };
+        }
+    };
+}

package/dist/plugins/css/bootstrap.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'esbuild';
+export interface BootstrapConfig {
+    version?: string;
+    useCDN?: boolean;
+    includeIcons?: boolean;
+    autoprefixer?: boolean;
+    purgeUnused?: boolean;
+}
+/**
+ * Bootstrap Plugin for esbuild
+ * Supports CDN injection, local node_modules, autoprefixer, and SCSS purge
+ */
+export declare function bootstrapPlugin(config?: BootstrapConfig): Plugin;
+/**
+ * Inject Bootstrap CDN links into HTML
+ */
+export declare function injectBootstrapCDN(html: string, config?: BootstrapConfig): string;
+/**
+ * Auto-detect Bootstrap usage in project
+ */
+export declare function detectBootstrapUsage(root: string): Promise<boolean>;
+/**
+ * Get Bootstrap configuration from project
+ */
+export declare function getBootstrapConfig(root: string): Promise<BootstrapConfig>;

package/dist/plugins/css/bootstrap.js

@@ -0,0 +1,110 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Bootstrap Plugin for esbuild
+ * Supports CDN injection, local node_modules, autoprefixer, and SCSS purge
+ */
+export function bootstrapPlugin(config = {}) {
+    const { version = '5.3.2', useCDN = false, includeIcons = true, autoprefixer = true, purgeUnused = false } = config;
+    return {
+        name: 'bootstrap-plugin',
+        setup(build) {
+            // Intercept Bootstrap CSS imports
+            build.onResolve({ filter: /^bootstrap\/dist\/css\/bootstrap/ }, args => {
+                if (useCDN) {
+                    // Return external for CDN usage
+                    return { path: args.path, external: true };
+                }
+                // Resolve to local node_modules
+                return {
+                    path: require.resolve('bootstrap/dist/css/bootstrap.min.css', {
+                        paths: [args.resolveDir]
+                    })
+                };
+            });
+            // Intercept Bootstrap Icons imports
+            if (includeIcons) {
+                build.onResolve({ filter: /^bootstrap-icons/ }, args => {
+                    if (useCDN) {
+                        return { path: args.path, external: true };
+                    }
+                    return {
+                        path: require.resolve('bootstrap-icons/font/bootstrap-icons.css', {
+                            paths: [args.resolveDir]
+                        })
+                    };
+                });
+            }
+            // Intercept Bootstrap JS imports
+            build.onResolve({ filter: /^bootstrap$/ }, args => {
+                return {
+                    path: require.resolve('bootstrap/dist/js/bootstrap.bundle.min.js', {
+                        paths: [args.resolveDir]
+                    })
+                };
+            });
+            // Handle SCSS imports
+            build.onResolve({ filter: /^bootstrap\/scss/ }, args => {
+                return {
+                    path: require.resolve(args.path.replace('bootstrap/scss', 'bootstrap/scss'), {
+                        paths: [args.resolveDir]
+                    })
+                };
+            });
+        }
+    };
+}
+/**
+ * Inject Bootstrap CDN links into HTML
+ */
+export function injectBootstrapCDN(html, config = {}) {
+    const { version = '5.3.2', includeIcons = true } = config;
+    const cdnLinks = `
+    <!-- Bootstrap CSS -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@${version}/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
+    ${includeIcons ? `<!-- Bootstrap Icons -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.1/font/bootstrap-icons.css">` : ''}
+  `;
+    const jsLink = `
+    <!-- Bootstrap JS -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@${version}/dist/js/bootstrap.bundle.min.js" integrity="sha384-C6RzsynM9kWDrMNeT87bh95OGNyZPhcTNXj1NW7RuBCsyN/o0jlpcV8Qyq46cDfL" crossorigin="anonymous"></script>
+  `;
+    // Inject CSS in <head>
+    html = html.replace('</head>', `${cdnLinks}\n  </head>`);
+    // Inject JS before </body>
+    html = html.replace('</body>', `${jsLink}\n  </body>`);
+    return html;
+}
+/**
+ * Auto-detect Bootstrap usage in project
+ */
+export async function detectBootstrapUsage(root) {
+    try {
+        const pkgPath = path.join(root, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return !!(deps['bootstrap'] || deps['bootstrap-icons']);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Bootstrap configuration from project
+ */
+export async function getBootstrapConfig(root) {
+    const hasBootstrap = await detectBootstrapUsage(root);
+    if (!hasBootstrap) {
+        return { useCDN: true }; // Default to CDN if not installed
+    }
+    // Check if node_modules/bootstrap exists
+    const localPath = path.join(root, 'node_modules', 'bootstrap');
+    const hasLocal = await fs.access(localPath).then(() => true).catch(() => false);
+    return {
+        useCDN: !hasLocal,
+        includeIcons: true,
+        autoprefixer: true,
+        purgeUnused: false
+    };
+}

package/dist/plugins/css/bulma.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from 'esbuild';
+export interface BulmaConfig {
+    version?: string;
+    useCDN?: boolean;
+    includeExtensions?: boolean;
+}
+/**
+ * Bulma Plugin for esbuild
+ * Supports CDN injection and local node_modules
+ */
+export declare function bulmaPlugin(config?: BulmaConfig): Plugin;
+/**
+ * Inject Bulma CDN link into HTML
+ */
+export declare function injectBulmaCDN(html: string, config?: BulmaConfig): string;
+/**
+ * Auto-detect Bulma usage in project
+ */
+export declare function detectBulmaUsage(root: string): Promise<boolean>;
+/**
+ * Get Bulma configuration from project
+ */
+export declare function getBulmaConfig(root: string): Promise<BulmaConfig>;

package/dist/plugins/css/bulma.js

@@ -0,0 +1,75 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Bulma Plugin for esbuild
+ * Supports CDN injection and local node_modules
+ */
+export function bulmaPlugin(config = {}) {
+    const { version = '0.9.4', useCDN = false, includeExtensions = false } = config;
+    return {
+        name: 'bulma-plugin',
+        setup(build) {
+            // Intercept Bulma CSS imports
+            build.onResolve({ filter: /^bulma\/css\/bulma/ }, args => {
+                if (useCDN) {
+                    return { path: args.path, external: true };
+                }
+                return {
+                    path: require.resolve('bulma/css/bulma.min.css', {
+                        paths: [args.resolveDir]
+                    })
+                };
+            });
+            // Handle SASS imports
+            build.onResolve({ filter: /^bulma$/ }, args => {
+                return {
+                    path: require.resolve('bulma/bulma.sass', {
+                        paths: [args.resolveDir]
+                    })
+                };
+            });
+        }
+    };
+}
+/**
+ * Inject Bulma CDN link into HTML
+ */
+export function injectBulmaCDN(html, config = {}) {
+    const { version = '0.9.4' } = config;
+    const cdnLink = `
+    <!-- Bulma CSS -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bulma@${version}/css/bulma.min.css">
+  `;
+    // Inject CSS in <head>
+    return html.replace('</head>', `${cdnLink}\n  </head>`);
+}
+/**
+ * Auto-detect Bulma usage in project
+ */
+export async function detectBulmaUsage(root) {
+    try {
+        const pkgPath = path.join(root, 'package.json');
+        const content = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return !!deps['bulma'];
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Bulma configuration from project
+ */
+export async function getBulmaConfig(root) {
+    const hasBulma = await detectBulmaUsage(root);
+    if (!hasBulma) {
+        return { useCDN: true };
+    }
+    const localPath = path.join(root, 'node_modules', 'bulma');
+    const hasLocal = await fs.access(localPath).then(() => true).catch(() => false);
+    return {
+        useCDN: !hasLocal,
+        includeExtensions: false
+    };
+}

package/dist/plugins/css/css-modules.d.ts

@@ -0,0 +1,19 @@
+import { Plugin } from 'esbuild';
+export interface CSSModulesConfig {
+    generateScopedName?: string;
+    exportGlobals?: boolean;
+    generateTypings?: boolean;
+}
+/**
+ * CSS Modules Plugin for esbuild
+ * Transforms CSS files into scoped modules
+ */
+export declare function cssModulesPlugin(config?: CSSModulesConfig): Plugin;
+/**
+ * Auto-detect CSS Modules usage
+ */
+export declare function detectCSSModules(root: string): Promise<boolean>;
+/**
+ * Get CSS Modules configuration
+ */
+export declare function getCSSModulesConfig(root: string): Promise<CSSModulesConfig>;

package/dist/plugins/css/css-modules.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+/**
+ * CSS Modules Plugin for esbuild
+ * Transforms CSS files into scoped modules
+ */
+export function cssModulesPlugin(config = {}) {
+    const { generateScopedName = '[name]__[local]___[hash:base64:5]', exportGlobals = false, generateTypings = true } = config;
+    return {
+        name: 'css-modules-plugin',
+        setup(build) {
+            // Intercept .module.css files
+            build.onLoad({ filter: /\.module\.css$/ }, async (args) => {
+                const source = await fs.readFile(args.path, 'utf-8');
+                // Simple CSS Modules transformation
+                const classNames = {};
+                const cssLines = [];
+                // Parse CSS and generate scoped names
+                const classRegex = /\.([a-zA-Z_-][a-zA-Z0-9_-]*)/g;
+                let match;
+                while ((match = classRegex.exec(source)) !== null) {
+                    const originalName = match[1];
+                    if (!classNames[originalName]) {
+                        const hash = crypto.createHash('md5')
+                            .update(args.path + originalName)
+                            .digest('base64')
+                            .substring(0, 5)
+                            .replace(/[+/=]/g, '_');
+                        const fileName = path.basename(args.path, '.module.css');
+                        classNames[originalName] = `${fileName}__${originalName}___${hash}`;
+                    }
+                }
+                // Replace class names in CSS
+                let transformedCSS = source;
+                for (const [original, scoped] of Object.entries(classNames)) {
+                    transformedCSS = transformedCSS.replace(new RegExp(`\\.${original}\\b`, 'g'), `.${scoped}`);
+                }
+                // Generate TypeScript declarations if enabled
+                if (generateTypings) {
+                    const dtsPath = args.path + '.d.ts';
+                    const dtsContent = `declare const styles: {\n${Object.keys(classNames).map(name => `  ${name}: string;`).join('\n')}\n};\nexport default styles;\n`;
+                    await fs.writeFile(dtsPath, dtsContent);
+                }
+                // Return JavaScript module that exports class names
+                const jsContent = `
+          const styles = ${JSON.stringify(classNames)};
+          
+          // Inject CSS
+          if (typeof document !== 'undefined') {
+            const style = document.createElement('style');
+            style.textContent = ${JSON.stringify(transformedCSS)};
+            document.head.appendChild(style);
+          }
+          
+          export default styles;
+        `;
+                return {
+                    contents: jsContent,
+                    loader: 'js'
+                };
+            });
+        }
+    };
+}
+/**
+ * Auto-detect CSS Modules usage
+ */
+export async function detectCSSModules(root) {
+    try {
+        // Check for .module.css files
+        const srcPath = path.join(root, 'src');
+        const srcExists = await fs.access(srcPath).then(() => true).catch(() => false);
+        if (!srcExists)
+            return false;
+        const files = await fs.readdir(srcPath, { recursive: true });
+        return files.some((file) => typeof file === 'string' && file.endsWith('.module.css'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get CSS Modules configuration
+ */
+export async function getCSSModulesConfig(root) {
+    const hasModules = await detectCSSModules(root);
+    if (!hasModules) {
+        return {};
+    }
+    return {
+        generateScopedName: '[name]__[local]___[hash:base64:5]',
+        exportGlobals: false,
+        generateTypings: true
+    };
+}

package/dist/plugins/css/css-optimizer.d.ts

@@ -0,0 +1,43 @@
+export interface CSSOptimizationConfig {
+    splitCritical?: boolean;
+    criticalThreshold?: number;
+    purgeUnused?: boolean;
+    framework?: 'tailwind' | 'bootstrap' | 'bulma' | 'material' | 'none';
+}
+/**
+ * Split CSS into critical (above-fold) and async (below-fold)
+ */
+export declare function splitCSSBundle(css: string, config?: CSSOptimizationConfig): Promise<{
+    critical: string;
+    async: string;
+}>;
+/**
+ * Framework-aware CSS purging
+ * Removes unused CSS classes based on framework patterns
+ */
+export declare function purgeUnusedCSS(css: string, usedClasses: Set<string>, config?: CSSOptimizationConfig): Promise<string>;
+/**
+ * Compose source maps across preprocessors
+ */
+export interface SourceMapComposition {
+    version: number;
+    sources: string[];
+    mappings: string;
+    names: string[];
+}
+export declare function composeSourceMaps(maps: SourceMapComposition[]): Promise<SourceMapComposition>;
+/**
+ * Extract critical CSS for above-the-fold content
+ */
+export declare function extractCriticalCSS(html: string, css: string): Promise<string>;
+/**
+ * Analyze CSS bundle and provide optimization suggestions
+ */
+export interface CSSAnalysis {
+    totalSize: number;
+    ruleCount: number;
+    unusedRules: number;
+    duplicateRules: number;
+    suggestions: string[];
+}
+export declare function analyzeCSS(css: string, usedClasses: Set<string>): Promise<CSSAnalysis>;

package/dist/plugins/css/css-optimizer.js

@@ -0,0 +1,155 @@
+import { log } from '../../utils/logger.js';
+/**
+ * Split CSS into critical (above-fold) and async (below-fold)
+ */
+export async function splitCSSBundle(css, config = {}) {
+    const { criticalThreshold = 14000 } = config; // 14KB default
+    // Simple heuristic: first N bytes are critical
+    if (css.length <= criticalThreshold) {
+        return { critical: css, async: '' };
+    }
+    // Split at a rule boundary
+    const rules = css.split('}');
+    let critical = '';
+    let async = '';
+    let currentSize = 0;
+    for (const rule of rules) {
+        const ruleWithBrace = rule + '}';
+        if (currentSize + ruleWithBrace.length <= criticalThreshold) {
+            critical += ruleWithBrace;
+            currentSize += ruleWithBrace.length;
+        }
+        else {
+            async += ruleWithBrace;
+        }
+    }
+    return { critical, async };
+}
+/**
+ * Framework-aware CSS purging
+ * Removes unused CSS classes based on framework patterns
+ */
+export async function purgeUnusedCSS(css, usedClasses, config = {}) {
+    const { framework = 'none' } = config;
+    // Framework-specific class patterns to preserve
+    const preservePatterns = {
+        tailwind: [
+            /^(hover|focus|active|disabled|group-hover|peer-|dark):/,
+            /^(sm|md|lg|xl|2xl):/,
+        ],
+        bootstrap: [
+            /^(btn|nav|card|modal|dropdown|collapse|accordion)-/,
+            /^(show|active|disabled|fade|collapse)/,
+        ],
+        bulma: [
+            /^(is|has)-/,
+            /^(button|hero|section|column|box)/,
+        ],
+        material: [
+            /^(mdc|mat)-/,
+            /^(ripple|elevation|theme)/,
+        ],
+        none: [],
+    };
+    const patterns = preservePatterns[framework] || [];
+    // Parse CSS and remove unused rules
+    const rules = css.split('}').filter(rule => rule.trim());
+    const purgedRules = [];
+    for (const rule of rules) {
+        // Extract class name, handling escaped characters
+        const classMatch = rule.match(/\.([a-zA-Z0-9_\\:-]+)/);
+        if (!classMatch) {
+            purgedRules.push(rule + '}');
+            continue;
+        }
+        const className = classMatch[1];
+        // Remove escape characters for comparison
+        const normalizedClass = className.replace(/\\/g, '');
+        // Keep if used or matches preserve pattern
+        const shouldKeep = usedClasses.has(className) ||
+            usedClasses.has(normalizedClass) ||
+            patterns.some(pattern => pattern.test(normalizedClass));
+        if (shouldKeep) {
+            purgedRules.push(rule + '}');
+        }
+    }
+    const purgedCSS = purgedRules.join('\n');
+    const originalSize = css.length;
+    const purgedSize = purgedCSS.length;
+    const reduction = ((1 - purgedSize / originalSize) * 100).toFixed(1);
+    log.success(`CSS purged: ${originalSize}B → ${purgedSize}B (${reduction}% reduction)`);
+    return purgedCSS;
+}
+export async function composeSourceMaps(maps) {
+    // Simple source map composition
+    // In production, use a library like 'source-map' for proper composition
+    const composed = {
+        version: 3,
+        sources: [],
+        mappings: '',
+        names: [],
+    };
+    for (const map of maps) {
+        composed.sources.push(...map.sources);
+        composed.names.push(...map.names);
+        // Simplified: just concatenate mappings
+        composed.mappings += map.mappings;
+    }
+    return composed;
+}
+/**
+ * Extract critical CSS for above-the-fold content
+ */
+export async function extractCriticalCSS(html, css) {
+    // Extract classes used in HTML
+    const classRegex = /class="([^"]+)"/g;
+    const usedClasses = new Set();
+    let match;
+    while ((match = classRegex.exec(html)) !== null) {
+        const classes = match[1].split(/\s+/);
+        classes.forEach(cls => usedClasses.add(cls));
+    }
+    // Filter CSS to only include used classes
+    const rules = css.split('}').filter(rule => rule.trim());
+    const criticalRules = [];
+    for (const rule of rules) {
+        const classMatch = rule.match(/\.([a-zA-Z0-9_-]+)/);
+        if (classMatch && usedClasses.has(classMatch[1])) {
+            criticalRules.push(rule + '}');
+        }
+    }
+    return criticalRules.join('\n');
+}
+export async function analyzeCSS(css, usedClasses) {
+    const rules = css.split('}').filter(rule => rule.trim());
+    const ruleMap = new Map();
+    let unusedCount = 0;
+    for (const rule of rules) {
+        const classMatch = rule.match(/\.([a-zA-Z0-9_-]+)/);
+        if (classMatch) {
+            const className = classMatch[1];
+            ruleMap.set(rule, (ruleMap.get(rule) || 0) + 1);
+            if (!usedClasses.has(className)) {
+                unusedCount++;
+            }
+        }
+    }
+    const duplicateCount = Array.from(ruleMap.values()).filter(count => count > 1).length;
+    const suggestions = [];
+    if (unusedCount > 0) {
+        suggestions.push(`Remove ${unusedCount} unused CSS rules`);
+    }
+    if (duplicateCount > 0) {
+        suggestions.push(`Deduplicate ${duplicateCount} duplicate rules`);
+    }
+    if (css.length > 100000) {
+        suggestions.push('Consider code splitting for large CSS bundle');
+    }
+    return {
+        totalSize: css.length,
+        ruleCount: rules.length,
+        unusedRules: unusedCount,
+        duplicateRules: duplicateCount,
+        suggestions,
+    };
+}

package/dist/plugins/css/emotion.d.ts

@@ -0,0 +1,35 @@
+import { Plugin } from 'esbuild';
+export interface EmotionConfig {
+    ssr?: boolean;
+    cssProp?: boolean;
+    autoLabel?: boolean;
+    labelFormat?: string;
+}
+/**
+ * Emotion Plugin for esbuild
+ * Integrates @emotion/babel-plugin for css prop and optimization
+ */
+export declare function emotionPlugin(config?: EmotionConfig): Plugin;
+/**
+ * Get Babel plugin configuration for Emotion
+ */
+export declare function getEmotionBabelConfig(config?: EmotionConfig): {
+    presets?: (string | {
+        runtime: string;
+        importSource: string;
+    })[][] | undefined;
+    plugins: (string | {
+        sourceMap: boolean;
+        autoLabel: string;
+        labelFormat: string;
+        cssPropOptimization: boolean;
+    })[][];
+};
+/**
+ * Auto-detect Emotion usage
+ */
+export declare function detectEmotion(root: string): Promise<boolean>;
+/**
+ * Get Emotion configuration
+ */
+export declare function getEmotionConfig(root: string): Promise<EmotionConfig>;