nuclie 1.0.0

package/dist/plugins/compat/deferred.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+/**
+ * Nuclie Compress Plugin (nuclie-compress)
+ * Mocks compression-webpack-plugin using a simple status message.
+ * In a real V1, this would actually gzip/brotli the assets in `dist`.
+ */
+export function nuclieCompress(options = {}) {
+    return {
+        name: 'nuclie-compress',
+        async buildEnd() {
+            // Nuclie v1 - Placeholder for Asset Compression
+            // Real implementation would iterate dist/ and gzip
+            // console.log('[nuclie-compress] Compression enabled (Placeholder)');
+        }
+    };
+}
+/**
+ * Nuclie CSS Extract Plugin (nuclie-css-extract)
+ * Mocks mini-css-extract-plugin.
+ * Nuclie extracts CSS by default, so this is mostly a no-op compatibility shim.
+ */
+export function nuclieCssExtract(options = {}) {
+    return {
+        name: 'nuclie-css-extract',
+        // No-op
+    };
+}

package/dist/plugins/compat/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @nuclie/rollup-compat - Plugin Compatibility Layer
+ *
+ * This module provides adapters to use Rollup/Vite plugins within Nuclie.
+ */
+export { rollupAdapter } from './rollup.js';
+export { nuclieBabel, nuclieTerser, nuclieJson, nuclieYaml, nuclieMdx, nuclieSvgr, TierA } from './tier-a.js';
+export { webpackLoaderAdapter } from './webpack.js';
+export * from './tier-b.js';
+export * from './tier-c.js';
+export * from './deferred.js';

package/dist/plugins/compat/index.js

@@ -0,0 +1,11 @@
+/**
+ * @nuclie/rollup-compat - Plugin Compatibility Layer
+ *
+ * This module provides adapters to use Rollup/Vite plugins within Nuclie.
+ */
+export { rollupAdapter } from './rollup.js';
+export { nuclieBabel, nuclieTerser, nuclieJson, nuclieYaml, nuclieMdx, nuclieSvgr, TierA } from './tier-a.js';
+export { webpackLoaderAdapter } from './webpack.js';
+export * from './tier-b.js'; // nuclieCopy, nuclieHtml
+export * from './tier-c.js'; // nuclieReact, nuclieVue, nuclieSvelte
+export * from './deferred.js'; // nuclieCompress, nuclieCssExtract

package/dist/plugins/compat/rollup.d.ts

@@ -0,0 +1,19 @@
+import { Plugin } from '../index.js';
+interface RollupPlugin {
+    name: string;
+    resolveId?: (source: string, importer?: string, options?: any) => Promise<any> | any;
+    load?: (id: string) => Promise<any> | any;
+    transform?: (code: string, id: string) => Promise<any> | any;
+    renderChunk?: (code: string, chunk: any, options?: any) => Promise<any> | any;
+    buildStart?: (options?: any) => Promise<void> | void;
+    buildEnd?: (err?: any) => Promise<void> | void;
+    [key: string]: any;
+}
+/**
+ * Adapter to use Rollup plugins within Nuclie
+ * @param plugin The Rollup plugin instance
+ * @returns A Nuclie-compatible plugin
+ */
+export declare function rollupAdapter(plugin: RollupPlugin): Plugin;
+export declare const createRollupAdapter: typeof rollupAdapter;
+export {};

package/dist/plugins/compat/rollup.js

@@ -0,0 +1,76 @@
+/**
+ * Adapter to use Rollup plugins within Nuclie
+ * @param plugin The Rollup plugin instance
+ * @returns A Nuclie-compatible plugin
+ */
+export function rollupAdapter(plugin) {
+    return {
+        name: plugin.name,
+        async resolveId(source, importer) {
+            if (!plugin.resolveId)
+                return undefined;
+            const ctx = {
+                meta: {},
+                resolve: async () => null
+            };
+            const res = await plugin.resolveId.call(ctx, source, importer);
+            if (!res)
+                return undefined;
+            if (typeof res === 'string')
+                return res;
+            if (typeof res === 'object' && res.id)
+                return res.id;
+            return undefined;
+        },
+        async load(id) {
+            if (!plugin.load)
+                return undefined;
+            const ctx = { meta: {} };
+            const res = await plugin.load.call(ctx, id);
+            if (!res)
+                return undefined;
+            if (typeof res === 'string')
+                return res;
+            if (typeof res === 'object' && res.code)
+                return res.code;
+            return undefined;
+        },
+        async transform(code, id) {
+            if (!plugin.transform)
+                return undefined;
+            const ctx = { meta: {} };
+            const res = await plugin.transform.call(ctx, code, id);
+            if (!res)
+                return undefined;
+            if (typeof res === 'string')
+                return res;
+            if (typeof res === 'object' && res.code)
+                return { code: res.code, map: res.map };
+            return undefined;
+        },
+        async renderChunk(code, chunk) {
+            if (!plugin.renderChunk)
+                return undefined;
+            const ctx = { meta: {} };
+            const res = await plugin.renderChunk.call(ctx, code, chunk);
+            if (!res)
+                return undefined;
+            if (typeof res === 'string')
+                return res;
+            if (typeof res === 'object' && res.code)
+                return { code: res.code, map: res.map };
+            return undefined;
+        },
+        async buildStart() {
+            if (plugin.buildStart) {
+                await plugin.buildStart();
+            }
+        },
+        async buildEnd() {
+            if (plugin.buildEnd) {
+                await plugin.buildEnd();
+            }
+        }
+    };
+}
+export const createRollupAdapter = rollupAdapter;

package/dist/plugins/compat/tier-a.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Tier-A Plugin Wrappers for Nuclie
+ *
+ * These are pre-configured wrappers for popular Rollup plugins.
+ * Users can import these directly or use the rollupAdapter for custom plugins.
+ *
+ * Usage:
+ * ```typescript
+ * import { nuclieBabel, nuclieTerser } from 'nuclie/plugins/compat/tier-a';
+ *
+ * export default {
+ *   plugins: [
+ *     nuclieBabel({ presets: ['@babel/preset-react'] }),
+ *     nuclieTerser()
+ *   ]
+ * }
+ * ```
+ */
+import { Plugin } from '../index.js';
+/**
+ * Babel plugin wrapper
+ * Requires: npm install @rollup/plugin-babel @babel/core
+ */
+export declare function nuclieBabel(options?: any): Plugin;
+/**
+ * Terser (minification) plugin wrapper
+ * Requires: npm install @rollup/plugin-terser
+ */
+export declare function nuclieTerser(options?: any): Plugin;
+/**
+ * JSON plugin wrapper
+ * Requires: npm install @rollup/plugin-json
+ */
+export declare function nuclieJson(options?: any): Plugin;
+/**
+ * YAML plugin wrapper
+ * Requires: npm install @rollup/plugin-yaml
+ */
+export declare function nuclieYaml(options?: any): Plugin;
+/**
+ * MDX plugin wrapper
+ * Requires: npm install @mdx-js/rollup
+ */
+export declare function nuclieMdx(options?: any): Plugin;
+/**
+ * SVGR plugin wrapper (SVG to React components)
+ * Requires: npm install rollup-plugin-svgr
+ */
+export declare function nuclieSvgr(options?: any): Plugin;
+/**
+ * Export all Tier-A plugins
+ */
+export declare const TierA: {
+    babel: typeof nuclieBabel;
+    terser: typeof nuclieTerser;
+    json: typeof nuclieJson;
+    yaml: typeof nuclieYaml;
+    mdx: typeof nuclieMdx;
+    svgr: typeof nuclieSvgr;
+};

package/dist/plugins/compat/tier-a.js

@@ -0,0 +1,132 @@
+/**
+ * Tier-A Plugin Wrappers for Nuclie
+ *
+ * These are pre-configured wrappers for popular Rollup plugins.
+ * Users can import these directly or use the rollupAdapter for custom plugins.
+ *
+ * Usage:
+ * ```typescript
+ * import { nuclieBabel, nuclieTerser } from 'nuclie/plugins/compat/tier-a';
+ *
+ * export default {
+ *   plugins: [
+ *     nuclieBabel({ presets: ['@babel/preset-react'] }),
+ *     nuclieTerser()
+ *   ]
+ * }
+ * ```
+ */
+import { rollupAdapter } from './rollup.js';
+function createStub(name) {
+    return {
+        name,
+        async transform(code) {
+            return code;
+        }
+    };
+}
+/**
+ * Babel plugin wrapper
+ * Requires: npm install @rollup/plugin-babel @babel/core
+ */
+export function nuclieBabel(options = {}) {
+    try {
+        // Dynamic import to avoid hard dependency
+        const babel = require('@rollup/plugin-babel');
+        return rollupAdapter(babel.default ? babel.default(options) : babel(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/babel] @rollup/plugin-babel not found. Install with: npm install @rollup/plugin-babel @babel/core');
+        return createStub('nuclie-babel-stub');
+    }
+}
+/**
+ * Terser (minification) plugin wrapper
+ * Requires: npm install @rollup/plugin-terser
+ */
+export function nuclieTerser(options = {}) {
+    try {
+        const terser = require('@rollup/plugin-terser');
+        return rollupAdapter(terser.default ? terser.default(options) : terser(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/terser] @rollup/plugin-terser not found. Install with: npm install @rollup/plugin-terser');
+        return createStub('nuclie-terser-stub');
+    }
+}
+/**
+ * JSON plugin wrapper
+ * Requires: npm install @rollup/plugin-json
+ */
+export function nuclieJson(options = {}) {
+    try {
+        const json = require('@rollup/plugin-json');
+        return rollupAdapter(json.default ? json.default(options) : json(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/json] @rollup/plugin-json not found. Install with: npm install @rollup/plugin-json');
+        // Provide basic fallback
+        return {
+            name: 'nuclie-json-fallback',
+            async transform(code, id) {
+                if (id.endsWith('.json')) {
+                    return `export default ${code}`;
+                }
+                return undefined;
+            }
+        };
+    }
+}
+/**
+ * YAML plugin wrapper
+ * Requires: npm install @rollup/plugin-yaml
+ */
+export function nuclieYaml(options = {}) {
+    try {
+        const yaml = require('@rollup/plugin-yaml');
+        return rollupAdapter(yaml.default ? yaml.default(options) : yaml(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/yaml] @rollup/plugin-yaml not found. Install with: npm install @rollup/plugin-yaml');
+        return createStub('nuclie-yaml-stub');
+    }
+}
+/**
+ * MDX plugin wrapper
+ * Requires: npm install @mdx-js/rollup
+ */
+export function nuclieMdx(options = {}) {
+    try {
+        const mdx = require('@mdx-js/rollup');
+        return rollupAdapter(mdx.default ? mdx.default(options) : mdx(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/mdx] @mdx-js/rollup not found. Install with: npm install @mdx-js/rollup');
+        return createStub('nuclie-mdx-stub');
+    }
+}
+/**
+ * SVGR plugin wrapper (SVG to React components)
+ * Requires: npm install rollup-plugin-svgr
+ */
+export function nuclieSvgr(options = {}) {
+    try {
+        const svgr = require('rollup-plugin-svgr');
+        return rollupAdapter(svgr.default ? svgr.default(options) : svgr(options));
+    }
+    catch (e) {
+        console.warn('[@nuclie/svgr] rollup-plugin-svgr not found. Install with: npm install rollup-plugin-svgr');
+        return createStub('nuclie-svgr-stub');
+    }
+}
+/**
+ * Export all Tier-A plugins
+ */
+export const TierA = {
+    babel: nuclieBabel,
+    terser: nuclieTerser,
+    json: nuclieJson,
+    yaml: nuclieYaml,
+    mdx: nuclieMdx,
+    svgr: nuclieSvgr
+};

package/dist/plugins/compat/tier-b.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from '../index.js';
+/**
+ * NUCLIE TIER B PLUGINS (IO / ASSETS)
+ *
+ * Includes:
+ * - nuclieCopy (copy-webpack-plugin)
+ * - nuclieHtml (html-webpack-plugin)
+ */
+export interface CopyTarget {
+    src: string;
+    dest: string;
+}
+export interface CopyOptions {
+    targets: CopyTarget[];
+    verbose?: boolean;
+}
+/**
+ * Copy Plugin (nuclie-copy)
+ * Copies files or directories from src to dest at build end.
+ */
+export declare function nuclieCopy(options: CopyOptions): Plugin;
+export interface HtmlOptions {
+    title?: string;
+    filename?: string;
+    template?: string;
+    inject?: boolean;
+    templateParameters?: Record<string, string>;
+}
+/**
+ * HTML Plugin (nuclie-html)
+ * Generates an index.html file in the output directory.
+ * Advanced: Supports variable interpolation (e.g., %PUBLIC_URL%, %TITLE%)
+ */
+export declare function nuclieHtml(options?: HtmlOptions): Plugin;

package/dist/plugins/compat/tier-b.js

@@ -0,0 +1,90 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Copy Plugin (nuclie-copy)
+ * Copies files or directories from src to dest at build end.
+ */
+export function nuclieCopy(options) {
+    return {
+        name: 'nuclie-copy',
+        async buildEnd() {
+            if (!options.targets || options.targets.length === 0)
+                return;
+            for (const target of options.targets) {
+                try {
+                    // Resolve paths (naive resolution relative to CWD if not absolute)
+                    const srcPath = path.isAbsolute(target.src) ? target.src : path.resolve(process.cwd(), target.src);
+                    const destPath = path.isAbsolute(target.dest) ? target.dest : path.resolve(process.cwd(), 'dist', target.dest);
+                    await fs.cp(srcPath, destPath, { recursive: true, force: true });
+                    if (options.verbose) {
+                        console.log(`[nuclie-copy] Copied ${target.src} -> ${target.dest}`);
+                    }
+                }
+                catch (e) {
+                    console.warn(`[nuclie-copy] Failed to copy ${target.src}: ${e.message}`);
+                }
+            }
+        }
+    };
+}
+/**
+ * HTML Plugin (nuclie-html)
+ * Generates an index.html file in the output directory.
+ * Advanced: Supports variable interpolation (e.g., %PUBLIC_URL%, %TITLE%)
+ */
+export function nuclieHtml(options = {}) {
+    return {
+        name: 'nuclie-html',
+        stability: 'stable',
+        async buildEnd() {
+            const filename = options.filename || 'index.html';
+            const title = options.title || 'Nuclie App';
+            const destPath = path.resolve(process.cwd(), 'dist', filename);
+            let content = '';
+            if (options.template) {
+                try {
+                    const templatePath = path.resolve(process.cwd(), options.template);
+                    content = await fs.readFile(templatePath, 'utf-8');
+                }
+                catch (e) {
+                    console.warn(`[nuclie-html] Template not found: ${options.template}`);
+                    content = getDefaultHtml(title);
+                }
+            }
+            else {
+                content = getDefaultHtml(title);
+            }
+            // Advanced: Template Interpolation
+            const data = {
+                PUBLIC_URL: '.',
+                TITLE: title,
+                ...options.templateParameters
+            };
+            // Replace %VAR% patterns
+            Object.entries(data).forEach(([key, value]) => {
+                content = content.replace(new RegExp(`%${key}%`, 'g'), value);
+            });
+            try {
+                await fs.mkdir(path.dirname(destPath), { recursive: true });
+                await fs.writeFile(destPath, content);
+            }
+            catch (e) {
+                console.error(`[nuclie-html] Failed to generate HTML: ${e.message}`);
+            }
+        }
+    };
+}
+function getDefaultHtml(title) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+</head>
+<body>
+    <div id="root"></div>
+    <script type="module" src="/index.js"></script>
+</body>
+</html>`;
+}

package/dist/plugins/compat/tier-c.d.ts

@@ -0,0 +1,48 @@
+import { Plugin } from '../index.js';
+/**
+ * NUCLIE TIER C PLUGINS (Graph-Aware / HMR)
+ *
+ * Since Nuclie v1.0 handles HMR natively via UniversalTransformer for React, Vue, and Svelte,
+ * these plugins act as compatibility wrappers or configuration providers.
+ *
+ * They ensure that if a user migrates from Vite, they can map existing plugins to these
+ * without breaking the build, while Nuclie's core engine handles the heavy lifting.
+ */
+interface ReactOptions {
+    include?: string | RegExp | (string | RegExp)[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    fastRefresh?: boolean;
+    babel?: any;
+}
+/**
+ * Nuclie React Plugin
+ * Compatible with @vitejs/plugin-react
+ */
+export declare function nuclieReact(options?: ReactOptions): Plugin;
+interface VueOptions {
+    include?: string | RegExp | (string | RegExp)[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    isProduction?: boolean;
+}
+/**
+ * Nuclie Vue Plugin
+ * Compatible with @vitejs/plugin-vue
+ */
+export declare function nuclieVue(options?: VueOptions): Plugin;
+interface SvelteOptions {
+    include?: string | RegExp | (string | RegExp)[];
+    exclude?: string | RegExp | (string | RegExp)[];
+    preprocess?: any;
+}
+/**
+ * Nuclie Svelte Plugin
+ * Compatible with @sveltejs/vite-plugin-svelte
+ */
+export declare function nuclieSvelte(options?: SvelteOptions): Plugin;
+/**
+ * Compatibility aliases
+ */
+export declare const nuclieReactRefresh: typeof nuclieReact;
+export declare const nuclieVueHmr: typeof nuclieVue;
+export declare const nuclieSvelteHmr: typeof nuclieSvelte;
+export {};

package/dist/plugins/compat/tier-c.js

@@ -0,0 +1,49 @@
+/**
+ * Nuclie React Plugin
+ * Compatible with @vitejs/plugin-react
+ */
+export function nuclieReact(options = {}) {
+    return {
+        name: 'nuclie-react',
+        setup(api) {
+            // In the future, we can push options to the UniversalTransformer via API
+            // For now, we log that React support is active.
+        },
+        buildStart() {
+            // Validate environment
+            if (process.env.NODE_ENV === 'development' && options.fastRefresh !== false) {
+                // UniversalTransformer handles this automatically
+            }
+        }
+    };
+}
+/**
+ * Nuclie Vue Plugin
+ * Compatible with @vitejs/plugin-vue
+ */
+export function nuclieVue(options = {}) {
+    return {
+        name: 'nuclie-vue',
+        setup() {
+            // Vue support is built-in
+        }
+    };
+}
+/**
+ * Nuclie Svelte Plugin
+ * Compatible with @sveltejs/vite-plugin-svelte
+ */
+export function nuclieSvelte(options = {}) {
+    return {
+        name: 'nuclie-svelte',
+        setup() {
+            // Svelte support is built-in
+        }
+    };
+}
+/**
+ * Compatibility aliases
+ */
+export const nuclieReactRefresh = nuclieReact;
+export const nuclieVueHmr = nuclieVue;
+export const nuclieSvelteHmr = nuclieSvelte;

package/dist/plugins/compat/webpack.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from '../index.js';
+export interface WebpackLoaderContext {
+    resourcePath: string;
+    rootContext: string;
+    context: string;
+    async: () => (err: Error | null, content?: string | Buffer, map?: any, meta?: any) => void;
+    callback: (err: Error | null, content?: string | Buffer, map?: any, meta?: any) => void;
+    cacheable: (flag?: boolean) => void;
+    emitFile: (name: string, content: string | Buffer, sourceMap?: any) => void;
+    addDependency: (file: string) => void;
+    fs: any;
+    query: any;
+    [key: string]: any;
+}
+export type WebpackLoader = (this: WebpackLoaderContext, content: string | Buffer, map?: any, meta?: any) => void | undefined | string | Buffer | Promise<string | Buffer | void | undefined>;
+export interface WebpackAdapterOptions {
+    name?: string;
+    test: RegExp;
+    loader: WebpackLoader;
+    options?: any;
+}
+/**
+ * Adapter to use Webpack Loaders within Nuclie
+ * Maps Webpack's loader API to Nuclie's transform hook.
+ */
+export declare function webpackLoaderAdapter(opts: WebpackAdapterOptions): Plugin;

package/dist/plugins/compat/webpack.js

@@ -0,0 +1,77 @@
+import path from 'path';
+import fs from 'fs/promises';
+/**
+ * Adapter to use Webpack Loaders within Nuclie
+ * Maps Webpack's loader API to Nuclie's transform hook.
+ */
+export function webpackLoaderAdapter(opts) {
+    const name = opts.name || 'webpack-loader-compat';
+    return {
+        name: name,
+        async transform(code, id) {
+            // Only apply if ID matches test
+            if (!opts.test.test(id))
+                return undefined;
+            return new Promise((resolve, reject) => {
+                let isAsync = false;
+                let isDone = false;
+                const context = {
+                    resourcePath: id,
+                    rootContext: process.cwd(),
+                    context: path.dirname(id),
+                    query: opts.options || {},
+                    fs: fs,
+                    // Cacheable is a no-op in Nuclie (we handle caching at graph level)
+                    cacheable: () => { },
+                    // Dependency tracking
+                    addDependency: (file) => {
+                        // TODO: Hook into Nuclie's graph dependency tracking
+                        // context.meta.watchFiles.add(file);
+                    },
+                    emitFile: (name, content) => {
+                        // TODO: Hook into Nuclie's asset emission
+                    },
+                    async: () => {
+                        isAsync = true;
+                        return (err, result, map) => {
+                            if (isDone)
+                                return;
+                            isDone = true;
+                            if (err)
+                                reject(err);
+                            else
+                                resolve(result ? (typeof result === 'string' ? result : result.toString()) : undefined);
+                        };
+                    },
+                    callback: (err, result, map) => {
+                        if (isDone)
+                            return;
+                        isDone = true;
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(result ? (typeof result === 'string' ? result : result.toString()) : undefined);
+                    }
+                };
+                // Execute Loader
+                try {
+                    const result = opts.loader.call(context, code, undefined);
+                    if (!isAsync && !isDone) {
+                        isDone = true;
+                        if (result !== undefined) {
+                            resolve(typeof result === 'string' ? result : result ? result.toString() : code);
+                        }
+                        else {
+                            // If loader validates but returns undefined (and didn't call async), 
+                            // it means no change or side-effect. We return undefined to let other plugins handle it or keep as is.
+                            resolve(code);
+                        }
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }
+    };
+}

package/dist/plugins/core/linker.d.ts

@@ -0,0 +1,8 @@
+import { NucliePlugin } from '../../core/plugins/types.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 declare function createLinkerPlugin(): NucliePlugin;