cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/javascript/import-target.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Import-target resolver for JavaScript.
+ *
+ * Delegates to the TypeScript `resolveTsTarget` standard-strategy resolver
+ * with `language: SupportedLanguages.JavaScript` so the resolver tries
+ * `.js` / `.jsx` extensions in addition to (or instead of) `.ts` / `.tsx`.
+ *
+ * The `TsResolveContext.language` flag already exists in `import-target.ts`
+ * and the resolver (`resolveImportPath`) already branches on it — this
+ * adapter just wires the right value in.
+ *
+ * CJS `require()` calls reference the same module-path strings as ESM
+ * `import` statements, so the resolver handles them uniformly without any
+ * CJS-specific logic here.
+ *
+ * No `tsconfig.json` path-alias support (JavaScript projects don't use
+ * `tsconfig.json` compilerOptions.paths in general). Projects that DO use
+ * tsconfig-based aliases alongside JavaScript can still resolve via the
+ * standard extension-suffix fallback; the alias branch is a no-op when
+ * `tsconfigPaths` is null.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeJsResolveImportTarget = makeJsResolveImportTarget;
+const index_js_1 = require("../../../../../shared/index.js");
+const import_target_js_1 = require("../typescript/import-target.js");
+/**
+ * Build a memoized `resolveImportTarget` adapter for JavaScript.
+ * Caches the derived arrays and per-pass resolve cache across
+ * `resolveImportTarget` calls within a single workspace pass.
+ */
+function makeJsResolveImportTarget() {
+    let cached = null;
+    return (targetRaw, fromFile, allFilePaths) => {
+        if (cached === null || cached.key !== allFilePaths) {
+            const allFileList = Array.from(allFilePaths);
+            cached = {
+                key: allFilePaths,
+                allFilePaths: new Set(allFilePaths),
+                allFileList,
+                normalizedFileList: allFileList.map((f) => f.toLowerCase()),
+                resolveCache: new Map(),
+            };
+        }
+        const ws = {
+            fromFile,
+            language: index_js_1.SupportedLanguages.JavaScript,
+            allFilePaths: cached.allFilePaths,
+            allFileList: cached.allFileList,
+            normalizedFileList: cached.normalizedFileList,
+            resolveCache: cached.resolveCache,
+            tsconfigPaths: null,
+        };
+        return (0, import_target_js_1.resolveTsTarget)(targetRaw, ws);
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/javascript/index.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * JavaScript scope-resolution hooks (RFC #909 Ring 3, issue #928).
+ *
+ * Public API barrel. Consumers should import from this file rather
+ * than the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`          — JS scope query string + lazy parser/query
+ *                           singletons (`getJsParser`, `getJsScopeQuery`)
+ *   - `captures.ts`       — `emitJsScopeCaptures` — runs the JS scope query,
+ *                           synthesizes CJS require() imports and JSDoc-
+ *                           derived type bindings, delegates arity synthesis
+ *                           and destructuring/instanceof passes to shared
+ *                           or TypeScript utilities
+ *   - `interpret.ts`      — `interpretJsImport` / `interpretJsTypeBinding`
+ *                           (delegate to TypeScript interpreters — same
+ *                           capture-marker vocabulary)
+ *   - `simple-hooks.ts`   — `jsBindingScopeFor` (var hoisting),
+ *                           `jsImportOwningScope`, `jsReceiverBinding`
+ *                           (all delegate to TypeScript counterparts)
+ *   - `merge-bindings.ts` — `jsMergeBindings` (LEGB via typescriptMergeBindings)
+ *   - `arity.ts`          — `jsArityCompatibility` (delegates to TS function)
+ *   - `import-target.ts`  — `makeJsResolveImportTarget` (memoized adapter)
+ *   - `scope-resolver.ts` — `javascriptScopeResolver` wiring object
+ *
+ * ## Known limitations
+ *
+ *   1. **JSDoc coverage** — `@param {T} name`, `@returns {T}` / `@return {T}`,
+ *      and `@type {T}` on variable declarations are synthesized. `@typedef`
+ *      is not yet synthesized (tracked in #1646).
+ *   2. **CJS chained destructuring** — `const { X: { Y } } = require(...)`
+ *      (nested destructuring) emits only the outer `X` binding; `Y` is not
+ *      resolved.
+ *   3. **Dynamic require** — `require(computedPath)` is skipped (non-literal
+ *      argument — cannot statically resolve the target).
+ *   4. **CommonJS `require()` in TypeScript** — `require()` decomposition is a
+ *      JavaScript-emitter concern, so a `.ts` file's `const m = require('./m')`
+ *      is not decomposed into an import. The EXPORT side of a `.ts` CommonJS
+ *      module is now declared (shared with the JS emitter), but an importer
+ *      written in TypeScript still cannot resolve through it.
+ *   5. **`.cjs` module-level `this`** — the CommonJS/ESM gate consults the file
+ *      extension where it can, but `provider.labelOverride` receives no file
+ *      path, so a `.cjs` file whose only export is a module-level `this.X = fn`
+ *      is not labelled. It now emits nothing rather than an ownerless `Method`.
+ *   6. **Calling a renamed default-export binding** — `module.exports = fn` IS
+ *      indexed (#2723, named after the file), but resolving a CALL through a
+ *      renamed local binding (`const renamed = require('./mod'); renamed()`)
+ *      needs the finalize layer to treat a called namespace binding as the
+ *      target module's default export. `const mod = require('./mod'); mod()`
+ *      happens to resolve because the names coincide.
+ *   7. **Anonymous ESM default** — `export default function () {}` (no name)
+ *      is not indexed either. Same class as the CJS default above, different
+ *      construct; not addressed by #2723.
+ *
+ * ## CommonJS export forms (#2723)
+ *
+ * Each of these declares its name in the module scope, so importers resolve to
+ * it by name — `const { foo } = require('./m')` matches directly and a
+ * namespace `m.foo()` walks the module's defs:
+ *
+ *   - `exports.foo = function () {}` / `module.exports.foo = (a) => a`, in
+ *     every value form (function, async, arrow, async arrow, generator).
+ *   - `const e = exports; e.foo = fn` — an alias bound at module scope. The
+ *     receiver cannot be pinned in a query, so the member-assignment rules
+ *     match any identifier receiver and the emitters prune anything that is
+ *     not the exports object.
+ *   - `this.foo = fn` at MODULE level of a CommonJS file, where `this` is
+ *     `module.exports`. Gated on the file being CommonJS — in ESM top-level
+ *     `this` is undefined and the same line exports nothing.
+ *   - `exports.foo = lib.imported` / `exports.foo = importedName` — forwarded
+ *     as a re-export (`reexport-alias`), so callers reach the ORIGINAL
+ *     definition. A plain import binding would not do: it is private to its
+ *     module, exactly as in ESM.
+ *   - `module.exports = fn` — the whole module is the callable, so it is named
+ *     after the file (`index.js` takes its parent directory). A named function
+ *     expression keeps its own name. `exports = fn` is NOT indexed: rebinding
+ *     `exports` exports nothing in CommonJS, it only breaks the alias.
+ *
+ * Two deliberate non-cases. `exports.foo = localFn`, where the value is a
+ * locally declared function, needs nothing — the module scope already binds
+ * `localFn` and importers already resolve through it. And a CJS export whose
+ * name the module ALSO declares lexically is suppressed rather than declared
+ * twice: two declarations of one name are ambiguous, and the resolver would
+ * drop the intra-module edge entirely.
+ *
+ * Callable members assigned through a receiver are Methods with an owner edge
+ * rather than free functions: `Foo.prototype.bar = fn` and `this.bar = fn`
+ * inside a constructor. Ownership resolves to what the file declares, so an
+ * owner it cannot see (`External.prototype.x = fn`) claims no edge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsReceiverBinding = exports.jsImportOwningScope = exports.jsBindingScopeFor = exports.makeJsResolveImportTarget = exports.jsArityCompatibility = exports.jsMergeBindings = exports.interpretJsTypeBinding = exports.interpretJsImport = exports.emitJsScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitJsScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitJsScopeCaptures; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretJsImport", { enumerable: true, get: function () { return interpret_js_1.interpretJsImport; } });
+Object.defineProperty(exports, "interpretJsTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretJsTypeBinding; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "jsMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.jsMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "jsArityCompatibility", { enumerable: true, get: function () { return arity_js_1.jsArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "makeJsResolveImportTarget", { enumerable: true, get: function () { return import_target_js_1.makeJsResolveImportTarget; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "jsBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.jsBindingScopeFor; } });
+Object.defineProperty(exports, "jsImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.jsImportOwningScope; } });
+Object.defineProperty(exports, "jsReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.jsReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/javascript/interpret.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Capture-match → semantic-shape interpreters for JavaScript.
+ *
+ * `interpretJsImport` delegates to `interpretTsImport` for all cases
+ * because `emitJsScopeCaptures` synthesizes the same
+ * `@import.kind/name/alias/source` markers for both ESM and CJS imports.
+ *
+ * The `@import.kind` values emitted for CJS by `captures.ts`:
+ *
+ *   - `'named'`       : `const { X } = require('./m')`     → named import
+ *   - `'named-alias'` : `const { X: Y } = require('./m')` → aliased import
+ *   - `'namespace'`   : `const X = require('./m')`         → namespace import
+ *   - `'side-effect'` : `require('./m')` bare expression   → side-effect
+ *
+ * These match the kinds `interpretTsImport` already handles for ESM
+ * (`import { X }`, `import { X as Y }`, `import * as X`, `import './m'`),
+ * so no new branch is needed here.
+ *
+ * `interpretJsTypeBinding` handles the JS-only `@type-binding.class-field`
+ * tag before delegating to `interpretTsTypeBinding`.  The class-field tag
+ * is emitted by `synthesizeConstructorFieldBindings` and should produce
+ * `source = 'annotation'` — the same strength as an explicit type
+ * annotation. Remapping it to `@type-binding.annotation` achieves this
+ * without adding a JS-specific branch to the shared TS interpreter
+ * (DoD.md §2.2).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretJsImport = interpretJsImport;
+exports.interpretJsTypeBinding = interpretJsTypeBinding;
+const interpret_js_1 = require("../typescript/interpret.js");
+function interpretJsImport(captures) {
+    return (0, interpret_js_1.interpretTsImport)(captures);
+}
+function interpretJsTypeBinding(captures) {
+    // @type-binding.class-field is a JS-only tag emitted by
+    // synthesizeConstructorFieldBindings. Remap it to the standard
+    // @type-binding.annotation tag so interpretTsTypeBinding assigns
+    // source = 'annotation' without a JS-specific branch in shared code.
+    if (captures['@type-binding.class-field'] !== undefined) {
+        const { '@type-binding.class-field': classField, ...rest } = captures;
+        return (0, interpret_js_1.interpretTsTypeBinding)({ ...rest, '@type-binding.annotation': classField });
+    }
+    return (0, interpret_js_1.interpretTsTypeBinding)(captures);
+}

package/dist/core/code/engine/core/ingestion/languages/javascript/merge-bindings.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Binding-merge precedence for JavaScript.
+ *
+ * JavaScript has no TypeScript declaration-merging (no `interface + class`
+ * coexisting in the same scope, no `namespace + class` dual-space declarations).
+ * However, `typescriptMergeBindings` handles these by falling back to
+ * `['value']` for any `NodeLabel` not explicitly mapped to multiple spaces —
+ * which is what every JavaScript declaration produces. The result is pure
+ * LEGB precedence without any cross-space logic, which is exactly what
+ * JavaScript needs.
+ *
+ * Reuse rather than reimplementing to keep the single source of truth for
+ * the tier (local 0 / import-namespace-reexport 1 / wildcard 2) ordering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsMergeBindings = jsMergeBindings;
+const merge_bindings_js_1 = require("../typescript/merge-bindings.js");
+function jsMergeBindings(bindings) {
+    return (0, merge_bindings_js_1.typescriptMergeBindings)(bindings);
+}