@richapps/ong 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,6 +1,7 @@
 import { createServer, build } from 'vite';
 import { resolveWorkspace } from './workspace.js';
 import { createViteConfig } from './config.js';
+import { prebundleLibs } from './prebundle.js';
 import { banner, printBuildStats, printHelp, error } from './log.js';
 function parseArgs(argv) {
     const args = argv.slice(2);
@@ -37,9 +38,16 @@ function parseArgs(argv) {
         else if (arg === '--watch' || arg === '-w') {
             result.watch = true;
         }
+        else if (arg === '--prebundle-libs') {
+            result.prebundleLibs = true;
+        }
         else if (arg === '--help' || arg === '-h') {
             return { command: 'help' };
         }
+        else if (!arg.startsWith('-') && !result.project) {
+            // Treat bare positional arg as project (e.g. "ong serve apps/editor")
+            result.project = arg;
+        }
     }
     return result;
 }
@@ -64,7 +72,10 @@ async function main() {
     };
     const buildOpts = resolveWorkspace(cwd, resolveOpts);
     banner(args.command, buildOpts.projectName, buildOpts.configName);
-    const viteConfig = createViteConfig(buildOpts);
+    let viteConfig = createViteConfig(buildOpts);
+    if (args.prebundleLibs && args.command === 'serve') {
+        viteConfig = await prebundleLibs(viteConfig, buildOpts);
+    }
     if (args.command === 'serve') {
         const server = await createServer(viteConfig);
         await server.listen();

package/dist/config.d.ts

@@ -1,5 +1,10 @@
-import type { InlineConfig } from 'vite';
+import type { InlineConfig, Alias } from 'vite';
 import type { ResolvedBuildOptions } from './workspace.js';
+/**
+ * Reads tsconfig paths and converts them to Vite resolve aliases.
+ * Follows tsconfig "extends" chain to find paths from base configs.
+ */
+export declare function resolveTsconfigPaths(tsconfig: string, workspaceRoot: string): Alias[];
 /**
  * Creates a Vite InlineConfig from resolved Angular build options.
  */

package/dist/config.js

@@ -1,6 +1,67 @@
 import { resolve } from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
 import { angular } from '@oxc-angular/vite';
 import { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';
+/**
+ * Reads tsconfig paths and converts them to Vite resolve aliases.
+ * Follows tsconfig "extends" chain to find paths from base configs.
+ */
+export function resolveTsconfigPaths(tsconfig, workspaceRoot) {
+    const aliases = [];
+    try {
+        let configPath = tsconfig;
+        let paths;
+        let baseUrl = '.';
+        // Walk the extends chain to find paths
+        while (configPath && !paths) {
+            if (!existsSync(configPath))
+                break;
+            const raw = readFileSync(configPath, 'utf-8');
+            // Strip comments (single-line // and multi-line /* */)
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const config = JSON.parse(stripped);
+            const compilerOptions = config.compilerOptions ?? {};
+            if (compilerOptions.paths) {
+                paths = compilerOptions.paths;
+                baseUrl = compilerOptions.baseUrl ?? '.';
+            }
+            if (config.extends) {
+                configPath = resolve(configPath, '..', config.extends);
+                // Add .json if not present
+                if (!configPath.endsWith('.json'))
+                    configPath += '.json';
+            }
+            else {
+                break;
+            }
+        }
+        if (!paths)
+            return aliases;
+        const baseDir = resolve(workspaceRoot, baseUrl);
+        for (const [pattern, targets] of Object.entries(paths)) {
+            if (!targets.length)
+                continue;
+            const target = targets[0];
+            if (pattern.endsWith('/*')) {
+                // Wildcard mapping: "@scope/lib/*" -> "libs/lib/src/*"
+                const prefix = pattern.slice(0, -2);
+                const targetDir = resolve(baseDir, target.slice(0, -2));
+                aliases.push({ find: new RegExp(`^${escapeRegex(prefix)}/(.*)`), replacement: `${targetDir}/$1` });
+            }
+            else {
+                // Exact mapping: "@scope/lib" -> "libs/lib/src/index.ts"
+                aliases.push({ find: pattern, replacement: resolve(baseDir, target) });
+            }
+        }
+    }
+    catch {
+        // Ignore tsconfig parse errors — fall back to no aliases
+    }
+    return aliases;
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 /**
  * Creates a Vite InlineConfig from resolved Angular build options.
  */
@@ -29,8 +90,8 @@ export function createViteConfig(opts) {
     const cssPreprocessorOptions = {};
     if (opts.stylePreprocessorOptions.includePaths.length) {
         const paths = opts.stylePreprocessorOptions.includePaths;
-        cssPreprocessorOptions.scss = { includePaths: paths };
-        cssPreprocessorOptions.sass = { includePaths: paths };
+        cssPreprocessorOptions.scss = { api: 'modern-compiler', loadPaths: paths };
+        cssPreprocessorOptions.sass = { api: 'modern-compiler', loadPaths: paths };
         cssPreprocessorOptions.less = { paths };
     }
     return {
@@ -53,6 +114,7 @@ export function createViteConfig(opts) {
         ...(Object.keys(opts.define).length ? { define: opts.define } : {}),
         resolve: {
             preserveSymlinks: opts.preserveSymlinks,
+            alias: resolveTsconfigPaths(opts.tsconfig, workspaceRoot),
         },
         css: Object.keys(cssPreprocessorOptions).length
             ? { preprocessorOptions: cssPreprocessorOptions }
@@ -84,6 +146,9 @@ export function createViteConfig(opts) {
             open: opts.serve.open,
             host: opts.serve.host ?? false,
             watch: opts.poll ? { usePolling: true, interval: opts.poll } : undefined,
+            fs: {
+                allow: [workspaceRoot],
+            },
         },
     };
 }

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export { resolveWorkspace, detectWorkspace } from './workspace.js';
 export type { ResolvedBuildOptions, ResolveOptions, AssetConfig } from './workspace.js';
 export { createViteConfig } from './config.js';
 export { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';
+export { prebundleLibs } from './prebundle.js';

package/dist/index.js

@@ -10,3 +10,4 @@
 export { resolveWorkspace, detectWorkspace } from './workspace.js';
 export { createViteConfig } from './config.js';
 export { htmlInjectPlugin, assetCopyPlugin } from './plugins.js';
+export { prebundleLibs } from './prebundle.js';

package/dist/log.js

@@ -80,6 +80,7 @@ export function printHelp() {
     -o, --open                  Open browser on start
         --host <host>           Dev server host
     -w, --watch                 Rebuild on file changes (build mode)
+        --prebundle-libs            Pre-bundle local libs to resolve circular deps
 
   ${c.bold}Workspace support:${c.reset}
     angular.json                Standard Angular CLI workspace

package/dist/plugins.js

@@ -43,17 +43,16 @@ export function htmlInjectPlugin(opts) {
                 }
                 // Inject polyfills before the entry point
                 if (opts.polyfills.length) {
-                    const tags = opts.polyfills
+                    const imports = opts.polyfills
                         .map(p => {
-                        // Bare specifiers (e.g. "zone.js") become imports, paths become src refs
-                        if (p.startsWith('.') || p.startsWith('/')) {
-                            const ref = '/' + relative(viteRoot, resolve(opts.workspaceRoot, p));
-                            return `  <script type="module" src="${ref}"${crossOriginAttr}></script>`;
-                        }
-                        return `  <script type="module">import '${p}';</script>`;
+                        // Check if it's a file path (relative to workspace root or absolute)
+                        const resolved = resolve(opts.workspaceRoot, p);
+                        const isFile = p.startsWith('.') || p.startsWith('/') || existsSync(resolved);
+                        // Use absolute path for file imports so Vite can resolve them regardless of root
+                        return isFile ? `import '${resolved}';` : `import '${p}';`;
                     })
                         .join('\n');
-                    result = result.replace('</body>', `${tags}\n</body>`);
+                    result = result.replace('</body>', `  <script type="module">\n${imports}\n</script>\n</body>`);
                 }
                 // Inject entry point if not already present
                 const hasEntry = html.includes(`src="${browserRelative}"`) ||

package/dist/prebundle.d.ts

@@ -0,0 +1,8 @@
+import { type InlineConfig } from 'vite';
+import type { ResolvedBuildOptions } from './workspace.js';
+/**
+ * Pre-bundles local workspace libraries using rolldown + OXC.
+ * This resolves circular dependencies within libs by bundling each
+ * into a single ESM file before the Vite dev server starts.
+ */
+export declare function prebundleLibs(viteConfig: InlineConfig, opts: ResolvedBuildOptions): Promise<InlineConfig>;

package/dist/prebundle.js

@@ -0,0 +1,113 @@
+import { join } from 'node:path';
+import { mkdirSync, rmSync } from 'node:fs';
+import { build } from 'vite';
+import { angular } from '@oxc-angular/vite';
+import { resolveTsconfigPaths } from './config.js';
+import { c } from './log.js';
+/**
+ * Pre-bundles local workspace libraries using rolldown + OXC.
+ * This resolves circular dependencies within libs by bundling each
+ * into a single ESM file before the Vite dev server starts.
+ */
+export async function prebundleLibs(viteConfig, opts) {
+    const aliases = resolveTsconfigPaths(opts.tsconfig, opts.workspaceRoot);
+    // Find aliases pointing to local workspace files (not node_modules)
+    const localLibs = [];
+    for (const alias of aliases) {
+        // Only handle exact-match aliases (string find), not wildcards (RegExp)
+        if (typeof alias.find !== 'string')
+            continue;
+        const target = alias.replacement;
+        // Must be inside workspace and not in node_modules
+        if (!target.startsWith(opts.workspaceRoot))
+            continue;
+        if (target.includes('node_modules'))
+            continue;
+        localLibs.push({
+            find: alias.find,
+            entry: target,
+            fileName: alias.find.replace(/[@/]/g, '_').replace(/^_+/, ''),
+        });
+    }
+    if (localLibs.length === 0)
+        return viteConfig;
+    const start = Date.now();
+    console.log(`  ${c.cyan}Pre-bundling ${localLibs.length} local lib${localLibs.length > 1 ? 's' : ''}...${c.reset}`);
+    // Output inside workspace node_modules so Vite can resolve bare imports
+    const tempDir = join(opts.workspaceRoot, 'node_modules', '.ong-prebundle');
+    rmSync(tempDir, { recursive: true, force: true });
+    mkdirSync(tempDir, { recursive: true });
+    // Bundle each lib in parallel
+    const results = await Promise.allSettled(localLibs.map(lib => bundleLib(lib, tempDir, aliases, opts, viteConfig)));
+    // Collect successfully bundled libs
+    const bundled = new Map();
+    results.forEach((result, i) => {
+        if (result.status === 'fulfilled') {
+            bundled.set(localLibs[i].find, join(tempDir, `${localLibs[i].fileName}.mjs`));
+        }
+        else {
+            console.log(`  ${c.yellow}Warning: failed to pre-bundle ${localLibs[i].find}${c.reset}`);
+            console.log(`  ${c.dim}${result.reason?.message ?? result.reason}${c.reset}`);
+        }
+    });
+    if (bundled.size === 0)
+        return viteConfig;
+    const duration = Date.now() - start;
+    const names = [...bundled.keys()].join(', ');
+    console.log(`  ${c.green}Pre-bundled in ${duration}ms:${c.reset} ${c.dim}${names}${c.reset}`);
+    console.log();
+    // Rewrite aliases: bundled libs point to the temp output
+    const newAliases = aliases.map(alias => {
+        if (typeof alias.find === 'string' && bundled.has(alias.find)) {
+            return { find: alias.find, replacement: bundled.get(alias.find) };
+        }
+        return alias;
+    });
+    return {
+        ...viteConfig,
+        resolve: {
+            ...(viteConfig.resolve ?? {}),
+            alias: newAliases,
+        },
+    };
+}
+async function bundleLib(lib, outDir, allAliases, opts, parentConfig) {
+    await build({
+        configFile: false,
+        root: opts.workspaceRoot,
+        logLevel: 'warn',
+        plugins: [
+            ...angular({
+                tsconfig: opts.tsconfig,
+                sourceMap: opts.sourceMap,
+                workspaceRoot: opts.workspaceRoot,
+            }),
+        ],
+        resolve: {
+            // All tsconfig aliases so inter-lib imports resolve
+            alias: allAliases,
+        },
+        // Pass through same CSS config for SCSS/Less resolution
+        css: parentConfig.css,
+        build: {
+            lib: {
+                entry: lib.entry,
+                formats: ['es'],
+                fileName: lib.fileName,
+            },
+            outDir,
+            emptyOutDir: false,
+            sourcemap: opts.sourceMap,
+            minify: false,
+            rollupOptions: {
+                external: (id) => {
+                    // Bundle relative/absolute imports (internal to the lib)
+                    if (id.startsWith('.') || id.startsWith('/'))
+                        return false;
+                    // Externalize everything else (npm packages, other local lib aliases)
+                    return true;
+                },
+            },
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@richapps/ong",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Angular CLI powered by Vite + OXC — blazing fast drop-in replacement for ng serve/build",
   "keywords": [
     "angular",