chore: fix tests and back to acorn

Author: ovflowd

npm-shrinkwrap.json

@@ -47,7 +47,7 @@
     "@orama/orama": "^3.1.16",
     "@orama/react-components": "^0.8.1",
     "@rollup/plugin-virtual": "^3.0.2",
-    "oxc-parser": "^0.101.0",
+    "acorn": "^8.15.0",
     "commander": "^14.0.2",
     "dedent": "^1.7.0",
     "eslint-plugin-react-x": "^2.3.12",

package.json

@@ -1,7 +1,10 @@
 import { readdir } from 'node:fs/promises';
+import { cpus } from 'node:os';
 import { basename, extname, join } from 'node:path';
 import { describe, it } from 'node:test';
 
+import WorkerPool from '../../../threading/index.mjs';
+import createParallelWorker from '../../../threading/parallel.mjs';
 import astJs from '../../ast-js/index.mjs';
 import apiLinks from '../index.mjs';
 
@@ -16,8 +19,16 @@ describe('api links', () => {
   describe('should work correctly for all fixtures', () => {
     sourceFiles.forEach(sourceFile => {
       it(`${basename(sourceFile)}`, async t => {
+        const pool = new WorkerPool('../chunk-worker.mjs', cpus().length);
+
+        const worker = createParallelWorker('ast-js', pool, {
+          threads: 1,
+          chunkSize: 10,
+        });
+
         const astJsResult = await astJs.generate(undefined, {
           input: [sourceFile],
+          worker,
         });
 
         const actualOutput = await apiLinks.generate(astJsResult, {

src/generators/api-links/__tests__/fixtures.test.mjs

@@ -84,12 +84,7 @@ export default async function bundleCode(codeMap, { server = false } = {}) {
     resolve: {
       // Alias react imports to preact/compat for smaller bundle sizes.
       // Explicit jsx-runtime aliases are required for the automatic JSX transform.
-      alias: {
-        react: 'preact/compat',
-        'react-dom': 'preact/compat',
-        'react/jsx-runtime': 'preact/jsx-runtime',
-        'react/jsx-dev-runtime': 'preact/jsx-dev-runtime',
-      },
+      alias: { react: 'preact/compat' },
 
       // Tell the bundler where to find node_modules.
       // This ensures packages are found when running doc-kit from external directories

src/generators/web/utils/bundle.mjs

@@ -6,6 +6,8 @@ import console from '../../transports/console.mjs';
 
 describe('console', () => {
   it('should print debug messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -33,6 +35,8 @@ describe('console', () => {
   });
 
   it('should print info messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
     const fn = t.mock.method(process.stdout, 'write');
 
@@ -59,6 +63,8 @@ describe('console', () => {
   });
 
   it('should print error messages ', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -86,6 +92,8 @@ describe('console', () => {
   });
 
   it('should print fatal messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -113,6 +121,8 @@ describe('console', () => {
   });
 
   it('should print messages with file', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -151,6 +161,8 @@ describe('console', () => {
   });
 
   it('should print child logger name', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');

src/logger/__tests__/transports/console.test.mjs

@@ -6,6 +6,8 @@ import github from '../../transports/github.mjs';
 
 describe('github', () => {
   it('should print debug messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -31,6 +33,8 @@ describe('github', () => {
   });
 
   it('should print info messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
     const fn = t.mock.method(process.stdout, 'write');
 
@@ -55,6 +59,8 @@ describe('github', () => {
   });
 
   it('should print error messages ', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -80,6 +86,8 @@ describe('github', () => {
   });
 
   it('should print fatal messages', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -105,6 +113,8 @@ describe('github', () => {
   });
 
   it('should print messages with file', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
 
     const fn = t.mock.method(process.stdout, 'write');
@@ -139,6 +149,8 @@ describe('github', () => {
   });
 
   it('should print child logger name', t => {
+    process.env.FORCE_COLOR = '1';
+
     t.mock.timers.enable({ apis: ['Date'] });
     const fn = t.mock.method(process.stdout, 'write');
 

src/logger/__tests__/transports/github.test.mjs

@@ -1,6 +1,6 @@
 'use strict';
 
-import { parseSync } from 'oxc-parser';
+import * as acorn from 'acorn';
 
 /**
  * Creates a Javascript source parser for a given source file
@@ -23,15 +23,13 @@ const createParser = () => {
       );
     }
 
-    const result = parseSync(resolvedSourceFile.path, resolvedSourceFile.value);
+    const res = acorn.parse(resolvedSourceFile.value, {
+      allowReturnOutsideFunction: true,
+      ecmaVersion: 'latest',
+      locations: true,
+    });
 
-    if (result.errors.length > 0) {
-      throw new Error(
-        `Failed to parse ${resolvedSourceFile.path}: ${result.errors[0].message}`
-      );
-    }
-
-    return { ...result.program, path: resolvedSourceFile.path };
+    return { ...res, path: resolvedSourceFile.path };
   };
 
   /**

src/parsers/javascript.mjs

@@ -0,0 +1,90 @@
+import { deepStrictEqual, ok, strictEqual } from 'node:assert';
+import { describe, it } from 'node:test';
+
+import WorkerPool from '../index.mjs';
+
+describe('WorkerPool', () => {
+  // Use relative path from WorkerPool's location (src/threading/)
+  const workerPath = './chunk-worker.mjs';
+
+  it('should create a worker pool with specified thread count', () => {
+    const pool = new WorkerPool(workerPath, 4);
+
+    strictEqual(pool.threads, 4);
+    strictEqual(pool.getActiveThreadCount(), 0);
+  });
+
+  it('should initialize with zero active threads', () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    strictEqual(pool.getActiveThreadCount(), 0);
+  });
+
+  it('should change active thread count atomically', () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    pool.changeActiveThreadCount(1);
+    strictEqual(pool.getActiveThreadCount(), 1);
+
+    pool.changeActiveThreadCount(2);
+    strictEqual(pool.getActiveThreadCount(), 3);
+
+    pool.changeActiveThreadCount(-1);
+    strictEqual(pool.getActiveThreadCount(), 2);
+  });
+
+  it('should queue tasks when thread limit is reached', async () => {
+    const pool = new WorkerPool(workerPath, 1);
+
+    const task1 = pool.run({
+      generatorName: 'ast-js',
+      fullInput: [],
+      itemIndices: [],
+      options: {},
+    });
+
+    const task2 = pool.run({
+      generatorName: 'ast-js',
+      fullInput: [],
+      itemIndices: [],
+      options: {},
+    });
+
+    const results = await Promise.all([task1, task2]);
+
+    ok(Array.isArray(results));
+    strictEqual(results.length, 2);
+  });
+
+  it('should run multiple tasks in parallel with runAll', async () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const tasks = [
+      {
+        generatorName: 'ast-js',
+        fullInput: [],
+        itemIndices: [],
+        options: {},
+      },
+      {
+        generatorName: 'ast-js',
+        fullInput: [],
+        itemIndices: [],
+        options: {},
+      },
+    ];
+
+    const results = await pool.runAll(tasks);
+
+    ok(Array.isArray(results));
+    strictEqual(results.length, 2);
+  });
+
+  it('should handle empty task array', async () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const results = await pool.runAll([]);
+
+    deepStrictEqual(results, []);
+  });
+});

src/threading/__tests__/WorkerPool.test.mjs

@@ -0,0 +1,85 @@
+import { deepStrictEqual, ok, strictEqual } from 'node:assert';
+import { describe, it } from 'node:test';
+
+import WorkerPool from '../index.mjs';
+import createParallelWorker from '../parallel.mjs';
+
+describe('createParallelWorker', () => {
+  // Use relative path from WorkerPool's location (src/threading/)
+  const workerPath = './chunk-worker.mjs';
+
+  it('should create a ParallelWorker with map method', () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const worker = createParallelWorker('metadata', pool, { threads: 2 });
+
+    ok(worker);
+    strictEqual(typeof worker.map, 'function');
+  });
+
+  it('should use main thread for single-threaded execution', async () => {
+    const pool = new WorkerPool(workerPath, 1);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 1 });
+    const items = [];
+    const results = await worker.map(items, items, {});
+
+    ok(Array.isArray(results));
+    strictEqual(results.length, 0);
+  });
+
+  it('should use main thread for small item counts', async () => {
+    const pool = new WorkerPool(workerPath, 4);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 4 });
+    const items = [];
+    const results = await worker.map(items, items, {});
+
+    ok(Array.isArray(results));
+    strictEqual(results.length, 0);
+  });
+
+  it('should chunk items for parallel processing', async () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 2 });
+    const items = [];
+
+    const results = await worker.map(items, items, {});
+
+    strictEqual(results.length, 0);
+    ok(Array.isArray(results));
+  });
+
+  it('should pass extra options to worker', async () => {
+    const pool = new WorkerPool(workerPath, 1);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 1 });
+    const extra = { gitRef: 'main', customOption: 'value' };
+    const items = [];
+
+    const results = await worker.map(items, items, extra);
+
+    ok(Array.isArray(results));
+  });
+
+  it('should serialize and deserialize data correctly', async () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 2 });
+    const items = [];
+
+    const results = await worker.map(items, items, {});
+
+    ok(Array.isArray(results));
+  });
+
+  it('should handle empty items array', async () => {
+    const pool = new WorkerPool(workerPath, 2);
+
+    const worker = createParallelWorker('ast-js', pool, { threads: 2 });
+    const results = await worker.map([], [], {});
+
+    deepStrictEqual(results, []);
+  });
+});