@proteinjs/reflection-build 1.4.7 → 1.4.9

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.4.9](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection-build@1.4.8...@proteinjs/reflection-build@1.4.9) (2026-07-23)
+
+
+### Bug Fixes
+
+* demote the vendored typescript-parser from installable package — its own manifest+lock resurrected typescript 3.9.10 on every fresh install ([d620104](https://github.com/proteinjs/reflection/commit/d62010437759c9991aaa72373fb58325610440c4))
+* parser handles tuple-typed destructured params under modern TypeScript; unify parser runtime ([6aac8b8](https://github.com/proteinjs/reflection/commit/6aac8b864cf41a14e6aaa6c5dded8b3e8fee611b))
+* tuple-params parser test uses the parser's file-based API — no typescript import in the test ([d022d44](https://github.com/proteinjs/reflection/commit/d022d44b7219316e5be705ee2727c9ba73103cdf))
+
+
+
+
+
 ## [1.4.7](https://github.com/proteinjs/reflection/compare/@proteinjs/reflection-build@1.4.6...@proteinjs/reflection-build@1.4.7) (2026-05-21)
 
 

package/dist/modules/typescript-parser/node-parser/function-parser.js

@@ -70,7 +70,8 @@ function parseMethodParams(node) {
                 boundParam.typeReference = parse_utilities_1.getNodeType(cur.type);
             }
             else if (cur.type && typescript_1.isTupleTypeNode(cur.type)) {
-                types = cur.type.elementTypes.map(type => parse_utilities_1.getNodeType(type));
+                // TS 4.0 renamed TupleTypeNode.elementTypes -> elements.
+                types = cur.type.elements.map(type => parse_utilities_1.getNodeType(type));
             }
             boundParam.parameters = elements.map((bindingElement, index) => new ParameterDeclaration_1.ParameterDeclaration(bindingElement.getText(), types[index], bindingElement.getStart(), bindingElement.getEnd()));
             params.push(boundParam);

package/dist/test/ParseTupleParams.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/ParseTupleParams.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = __importStar(require("fs"));
+var os = __importStar(require("os"));
+var path = __importStar(require("path"));
+// Test the SHIPPED parser (the compiled JS that `cp -r modules/ dist/modules/` publishes) through
+// its FILE-based API, so the parser creates the SourceFile with ITS OWN typescript module. The
+// test must not import typescript itself: if the test's copy and the parser's copy ever resolve
+// differently (hoisting varies by environment), SyntaxKind numbers diverge and every node
+// mis-dispatches — that exact cross-instance skew made this suite fail in CI only.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+var TypescriptParser = require('../modules/typescript-parser/TypescriptParser').TypescriptParser;
+/**
+ * A class method with an array-destructured, tuple-typed parameter — e.g.
+ * `moveMouse(client: Client, [x, y]: [number, number])` — crashed the parser with
+ * "Cannot read properties of undefined (reading 'map')": the vendored typescript-parser predates
+ * TS 4.0's rename of TupleTypeNode.elementTypes to elements.
+ */
+var TUPLE_PARAM_SOURCE = "\nexport class CursorDriver {\n  private cursor = { x: 0, y: 0 };\n\n  async moveMouse(client: unknown, [x, y]: [number, number]): Promise<void> {\n    this.cursor = { x, y };\n  }\n}\n";
+test('parses array-destructured tuple-typed method params', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var dir, filePath, file, classDeclaration, moveMouse, boundParam;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                dir = fs.mkdtempSync(path.join(os.tmpdir(), 'parse-tuple-params-'));
+                filePath = path.join(dir, 'tuple-params.ts');
+                fs.writeFileSync(filePath, TUPLE_PARAM_SOURCE);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 3, 4]);
+                return [4 /*yield*/, new TypescriptParser().parseFile(filePath, dir)];
+            case 2:
+                file = _a.sent();
+                classDeclaration = file.declarations.find(function (d) { return d.name === 'CursorDriver'; });
+                expect(classDeclaration).toBeTruthy();
+                moveMouse = classDeclaration.methods.find(function (m) { return m.name === 'moveMouse'; });
+                expect(moveMouse).toBeTruthy();
+                boundParam = moveMouse.parameters[moveMouse.parameters.length - 1];
+                expect(boundParam.parameters.map(function (p) { return p.name; })).toEqual(['x', 'y']);
+                expect(boundParam.parameters.map(function (p) { return p.type; })).toEqual(['number', 'number']);
+                return [3 /*break*/, 4];
+            case 3:
+                fs.rmdirSync(dir, { recursive: true });
+                return [7 /*endfinally*/];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); });
+//# sourceMappingURL=ParseTupleParams.test.js.map

package/dist/test/ParseTupleParams.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParseTupleParams.test.js","sourceRoot":"","sources":["../../test/ParseTupleParams.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qCAAyB;AACzB,qCAAyB;AACzB,yCAA6B;AAC7B,kGAAkG;AAClG,+FAA+F;AAC/F,gGAAgG;AAChG,0FAA0F;AAC1F,mFAAmF;AACnF,8DAA8D;AACtD,IAAA,gBAAgB,GAAK,OAAO,CAAC,+CAA+C,CAAC,iBAA7D,CAA8D;AAEtF;;;;;GAKG;AACH,IAAM,kBAAkB,GAAG,2LAQ1B,CAAC;AAEF,IAAI,CAAC,qDAAqD,EAAE;;;;;gBACpD,GAAG,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,qBAAqB,CAAC,CAAC,CAAC;gBACpE,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,CAAC;gBACnD,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAC;;;;gBAEhC,qBAAM,IAAI,gBAAgB,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAA;;gBAA5D,IAAI,GAAG,SAAqD;gBAE5D,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,UAAC,CAAoB,IAAK,OAAA,CAAC,CAAC,IAAI,KAAK,cAAc,EAAzB,CAAyB,CAAC,CAAC;gBACrG,MAAM,CAAC,gBAAgB,CAAC,CAAC,UAAU,EAAE,CAAC;gBAChC,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,UAAC,CAAmB,IAAK,OAAA,CAAC,CAAC,IAAI,KAAK,WAAW,EAAtB,CAAsB,CAAC,CAAC;gBACjG,MAAM,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,CAAC;gBAEzB,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBACzE,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,UAAC,CAAmB,IAAK,OAAA,CAAC,CAAC,IAAI,EAAN,CAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;gBACvF,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,UAAC,CAAoB,IAAK,OAAA,CAAC,CAAC,IAAI,EAAN,CAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;;;gBAElG,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;KAE1C,CAAC,CAAC"}

package/modules/typescript-parser/node-parser/function-parser.js

@@ -70,7 +70,8 @@ function parseMethodParams(node) {
                 boundParam.typeReference = parse_utilities_1.getNodeType(cur.type);
             }
             else if (cur.type && typescript_1.isTupleTypeNode(cur.type)) {
-                types = cur.type.elementTypes.map(type => parse_utilities_1.getNodeType(type));
+                // TS 4.0 renamed TupleTypeNode.elementTypes -> elements.
+                types = cur.type.elements.map(type => parse_utilities_1.getNodeType(type));
             }
             boundParam.parameters = elements.map((bindingElement, index) => new ParameterDeclaration_1.ParameterDeclaration(bindingElement.getText(), types[index], bindingElement.getStart(), bindingElement.getEnd()));
             params.push(boundParam);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteinjs/reflection-build",
-  "version": "1.4.7",
+  "version": "1.4.9",
   "description": "Build system for reflection",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,14 +31,16 @@
     "@dagrejs/graphlib": "2.1.4",
     "@proteinjs/reflection": "^1.1.11",
     "@proteinjs/util": "^1.6.0",
-    "@proteinjs/util-node": "^1.8.1",
+    "@proteinjs/util-node": "^1.9.0",
     "globby": "11.0.1",
     "gulp": "4.0.2",
     "gulp-shell": "0.8.0",
-    "jsesc": "^3.0.1"
+    "jsesc": "^3.0.1",
+    "lodash": "^4.17.10",
+    "tslib": "^1.9.3"
   },
   "devDependencies": {
-    "@proteinjs/reflection-build-test-a": "^0.0.20",
+    "@proteinjs/reflection-build-test-a": "^0.0.21",
     "@types/graphlib": "2.1.6",
     "@types/gulp": "4.0.16",
     "@types/jest": "29.5.6",
@@ -53,5 +55,5 @@
     "ts-jest": "29.1.1",
     "typescript": "5.2.2"
   },
-  "gitHead": "d5bd462153bc8ec9abd1ac03ed38e2540dba7b48"
+  "gitHead": "dd11bf2e88a24c4f09a880e8bf9e44b8c94479ea"
 }

package/test/ParseTupleParams.test.ts

@@ -0,0 +1,46 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+// Test the SHIPPED parser (the compiled JS that `cp -r modules/ dist/modules/` publishes) through
+// its FILE-based API, so the parser creates the SourceFile with ITS OWN typescript module. The
+// test must not import typescript itself: if the test's copy and the parser's copy ever resolve
+// differently (hoisting varies by environment), SyntaxKind numbers diverge and every node
+// mis-dispatches — that exact cross-instance skew made this suite fail in CI only.
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { TypescriptParser } = require('../modules/typescript-parser/TypescriptParser');
+
+/**
+ * A class method with an array-destructured, tuple-typed parameter — e.g.
+ * `moveMouse(client: Client, [x, y]: [number, number])` — crashed the parser with
+ * "Cannot read properties of undefined (reading 'map')": the vendored typescript-parser predates
+ * TS 4.0's rename of TupleTypeNode.elementTypes to elements.
+ */
+const TUPLE_PARAM_SOURCE = `
+export class CursorDriver {
+  private cursor = { x: 0, y: 0 };
+
+  async moveMouse(client: unknown, [x, y]: [number, number]): Promise<void> {
+    this.cursor = { x, y };
+  }
+}
+`;
+
+test('parses array-destructured tuple-typed method params', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'parse-tuple-params-'));
+  const filePath = path.join(dir, 'tuple-params.ts');
+  fs.writeFileSync(filePath, TUPLE_PARAM_SOURCE);
+  try {
+    const file = await new TypescriptParser().parseFile(filePath, dir);
+
+    const classDeclaration = file.declarations.find((d: { name?: string }) => d.name === 'CursorDriver');
+    expect(classDeclaration).toBeTruthy();
+    const moveMouse = classDeclaration.methods.find((m: { name: string }) => m.name === 'moveMouse');
+    expect(moveMouse).toBeTruthy();
+    // The tuple-bound parameter parses into an array-bound declaration carrying both elements.
+    const boundParam = moveMouse.parameters[moveMouse.parameters.length - 1];
+    expect(boundParam.parameters.map((p: { name: string }) => p.name)).toEqual(['x', 'y']);
+    expect(boundParam.parameters.map((p: { type?: string }) => p.type)).toEqual(['number', 'number']);
+  } finally {
+    fs.rmdirSync(dir, { recursive: true });
+  }
+});

package/test/examples/source-repository/a/node_modules/.package-lock.json

@@ -1,18 +1,18 @@
 {
   "name": "@proteinjs/reflection-build-test-a",
-  "version": "0.0.20",
+  "version": "0.0.21",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "../b": {
       "name": "@proteinjs/reflection-build-test-b",
-      "version": "0.0.20",
+      "version": "0.0.21",
       "license": "ISC",
       "dependencies": {
         "@dagrejs/graphlib": "2.1.4",
         "@proteinjs/reflection": "^1.1.11",
         "@proteinjs/util": "^1.6.0",
-        "@proteinjs/util-node": "^1.8.1",
+        "@proteinjs/util-node": "^1.9.0",
         "globby": "11.0.1",
         "gulp": "4.0.2",
         "gulp-shell": "0.8.0",
@@ -1102,9 +1102,9 @@
       }
     },
     "node_modules/@proteinjs/util-node": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/@proteinjs/util-node/-/util-node-1.8.1.tgz",
-      "integrity": "sha512-F4BEBmroyTuRjQGYkJQhs2JoTg6VUIeEveMZbHzV5mG8jIyF2zbIF+qQCJ0cV2pdQg2PLhi61VlstTwJrEIKdQ==",
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@proteinjs/util-node/-/util-node-1.9.0.tgz",
+      "integrity": "sha512-kn9zzmm7tUmlZiiJxGjkekhwsNprUzZM2r5rWZYgDD/BWdGCTA1QCfKEhmjCHLJutR1J+i4NmWcSfuYdyt+hjw==",
       "license": "ISC",
       "dependencies": {
         "@dagrejs/graphlib": "2.1.4",

package/test/examples/source-repository/a/node_modules/@proteinjs/util-node/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.9.0](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.8.1...@proteinjs/util-node@1.9.0) (2026-06-24)
+
+
+### Features
+
+* symlink-workspace links each package's transitive workspace-dep closure ([55a7c25](https://github.com/proteinjs/util/commit/55a7c2541f500bec4e12bb05454acadd6b4c4b66))
+
+
+
+
+
 ## [1.8.1](https://github.com/proteinjs/util/compare/@proteinjs/util-node@1.8.0...@proteinjs/util-node@1.8.1) (2026-04-14)
 
 

package/test/examples/source-repository/a/node_modules/@proteinjs/util-node/dist/src/PackageUtil.d.ts

@@ -101,9 +101,52 @@ export declare class PackageUtil {
     static getWorkspaceMetadata(workspacePath: string): Promise<WorkspaceMetadata>;
     /**
      * Symlink the dependencies of `localPackage` to other local packages in the workspace.
+     *
+     * This links the package's full TRANSITIVE closure of workspace dependencies,
+     * not just its directly-declared ones. A package's `package.json` only lists
+     * its direct deps, but those deps pull in workspace packages of their own
+     * (e.g. `flow-server` declares `@n3xah/space-server`, which itself depends on
+     * `@n3xah/space-common`). Node resolves a transitive dep like `space-common`
+     * out of the consumer's own `node_modules` first, so if we only symlinked
+     * direct deps, npm would satisfy `space-common` with a stale registry copy
+     * that lags the live workspace source — causing schema/version drift. By
+     * linking the whole closure, every workspace package a package can reach at
+     * runtime resolves to the live source tree.
+     *
      * @param localPackage package to symlink the dependencies of
      * @param localPackageMap `LocalPackageMap` of the workspace
-     * @param logger optionally provide a logger to capture this method's logging
      */
     static symlinkDependencies(localPackage: LocalPackage, localPackageMap: LocalPackageMap): Promise<void>;
+    /**
+     * Compute the transitive closure of workspace dependencies for `localPackage`.
+     *
+     * Reuses `getPackageDependencyGraph`, which already crawls `dependencies` and
+     * `devDependencies` (transitively, across the whole workspace) and adds an
+     * edge `consumer -> dependency` for each. So the workspace deps reachable from
+     * a package are exactly the nodes reachable by following `successors` from its
+     * node. We do a cycle-safe traversal (a `visited` set), since the dependency
+     * graph can contain cycles. The package itself is excluded from the result.
+     *
+     * Only names present in `localPackageMap` are returned — i.e. packages that
+     * actually live in the workspace and can be symlinked (the graph already
+     * filters to file:/relative/workspace deps in `addDependencies`, but we filter
+     * again here so the result is exactly the set of linkable packages).
+     *
+     * @returns workspace package names this package transitively depends on
+     */
+    private static getTransitiveWorkspaceDependencies;
+    /**
+     * Symlink a single workspace package into `nodeModulesPath`, and create
+     * `node_modules/.bin/<name>` shims for any `bin` it declares.
+     *
+     * This is the per-dependency linking logic used by `symlinkDependencies` for
+     * each package in the transitive closure. The caller is responsible for
+     * deciding WHICH packages to link; this method just links the one named.
+     *
+     * @param dependencyPackageName name of the workspace package to link
+     * @param nodeModulesPath absolute path to the consumer's `node_modules`
+     * @param packageDir absolute path to the consumer package's directory (cwd for `ln`)
+     * @param localPackageMap `LocalPackageMap` of the workspace
+     */
+    private static symlinkPackage;
 }