Files
reverse-engineering-anything/src/domain/webModuleImports.test.ts
T
ShuaixinHuangandShuaixinHuang 34f7d2131c fix(javascript): preserve loader conditions across application evidence (#12023)
* fix(javascript): honor loader semantics for BOM hashbangs

* fix(javascript): retain conditional BOM hashbang imports

* fix(javascript): share conditional hashbang recovery

* fix(javascript): recover suffix-only source imports

* fix(javascript): retain conditional CommonJS hashbang imports

* fix(javascript): preserve conditional hashbang dependency evidence

* fix(javascript): preserve ambiguous dotfile and worker evidence

* fix(javascript): qualify semantic evidence with source loader conditions

* fix(javascript): qualify all source-backed application evidence

* test(javascript): identify imports by their projected kind

---------

Co-authored-by: ShuaixinHuang <197200901+ShuaixinHuang@users.noreply.github.com>
2026-11-18 09:42:46 -05:00

245 lines
8.3 KiB
TypeScript

import { describe, expect, it } from "vitest";
import {
collectWebModuleImports,
matchCapturedModules,
} from "./webModuleImports.js";
import { exportedWebScriptSchema } from "./webScriptExport.js";
describe("native module syntax observations", () => {
it("collects native imports and re-exports, preserving empty strings and computed unknowns", () => {
const source =
'import ""; import x from "./x.js"; export * from "./all.js"; export {x} from "pkg"; import(`./literal.js`); import(`./${name}.js`); import(expr);';
const result = collectWebModuleImports(source, "main.js");
expect(result.state).toBe("parsed");
expect(result.imports.map((item) => [item.kind, item.specifier])).toEqual([
["static-import", ""],
["static-import", "./x.js"],
["re-export", "./all.js"],
["re-export", "pkg"],
["dynamic-import", "./literal.js"],
["dynamic-import", null],
["dynamic-import", null],
]);
for (const item of result.imports)
expect(source.slice(item.start.offset, item.end.offset)).toBe(
item.expression,
);
});
it("excludes whole type declarations and retains inline type dependency syntax", () => {
const result = collectWebModuleImports(
'import type {T} from "types"; import {type X} from "also-types"; export type {T} from "export-types"; export {type Y} from "only-types"; import {type T, value} from "mixed"; __webpack_require__.e(4); __vitePreload(() => 1, ["chunk.js"]);',
"main.ts",
);
expect(result.imports.map((item) => item.specifier)).toEqual([
"also-types",
"only-types",
"mixed",
]);
expect(result.diagnostics).toContainEqual(
expect.stringMatching(
/compiler options.*unavailable.*type.only.*side.effect/iu,
),
);
});
it("keeps JavaScript relational imports distinct from TypeScript import types", () => {
const source = 'const order = left < import("./dep.js") > (right);';
const javascript = collectWebModuleImports(source, "main.js");
expect(javascript.diagnostics).toEqual([]);
expect(javascript.imports).toEqual([
expect.objectContaining({
kind: "dynamic-import",
specifier: "./dep.js",
expression: '"./dep.js"',
}),
]);
expect(collectWebModuleImports(source, "main.ts").imports).toEqual([]);
});
it("uses UTF-16 source locations after astral characters", () => {
const source = 'const emoji = "😀";\nimport "./x.js";';
const item = collectWebModuleImports(source, "main.js").imports[0];
expect(item?.start).toEqual({
offset: source.indexOf('"./x.js"'),
line: 2,
column: 7,
});
});
it.each([
['"./dep.js" as const', "./dep.js"],
['"./dep.js" satisfies string', "./dep.js"],
['"./dep.js"!', "./dep.js"],
["`./dep.js` as const", "./dep.js"],
["`./${name}.js` as const", null],
] as const)(
"retains exact import identity through erased syntax: %s",
(expression, specifier) => {
const source = `import(${expression});`;
const result = collectWebModuleImports(source, "main.ts");
expect(result.state).toBe("parsed");
expect(result.diagnostics).toEqual([]);
expect(result.imports).toEqual([
{
kind: "dynamic-import",
specifier,
expression,
start: { offset: 7, line: 1, column: 7 },
end: {
offset: 7 + expression.length,
line: 1,
column: 7 + expression.length,
},
},
]);
},
);
it("reports unparseable input without asserting an empty complete graph", () => {
const result = collectWebModuleImports(
'import "./ok.js"; function {',
"main.js",
);
expect(result).toMatchObject({ state: "unparseable", imports: [] });
expect(result.diagnostics.length).toBeGreaterThan(0);
});
});
describe("deep native module syntax", () => {
it("retains imports and their locations after a parser-admitted deep property chain", () => {
const source = `const value = root${".next".repeat(12_000)};\nimport "./last.js";\nexport * from "./reexport.js";\nimport("./lazy.js");`;
const result = collectWebModuleImports(source, "main.js");
expect(result.state).toBe("parsed");
expect(result.diagnostics).toEqual([]);
expect(
result.imports.map(({ kind, specifier }) => [kind, specifier]),
).toEqual([
["static-import", "./last.js"],
["re-export", "./reexport.js"],
["dynamic-import", "./lazy.js"],
]);
for (const item of result.imports)
expect(source.slice(item.start.offset, item.end.offset)).toBe(
item.expression,
);
expect(result.imports[0]?.start).toEqual({
offset: source.indexOf('"./last.js"'),
line: 2,
column: 7,
});
});
});
const script = (
url: string,
kind: "page-script" | "scenario-response",
sha256 = "a".repeat(64),
) =>
exportedWebScriptSchema.parse({
url,
source:
kind === "page-script"
? {
kind,
script_key: "script1",
frame_id: null,
is_module: true,
language: "JavaScript",
source_map_url: null,
}
: {
kind,
transaction_id: "txn",
request_sequence: 1,
response_sequence: 2,
status: 200,
},
content: {
state: "exported",
relative_path: "modules/a.js",
layout: "isolated",
layout_reason: "fixture",
sha256,
bytes: 1,
media_type: "text/javascript",
redacted: false,
representation:
kind === "page-script"
? "debugger-source-utf8"
: "browser-decoded-response-bytes",
},
});
describe("captured module candidates", () => {
it("keeps query versions separate and response fragment matching weaker", () => {
const scripts = [
script("https://app.test/a.js?v=1#one", "page-script"),
script("https://app.test/a.js?v=1#two", "page-script"),
script("https://app.test/a.js?v=1", "scenario-response"),
script("https://app.test/a.js?v=2", "scenario-response"),
];
expect(
matchCapturedModules("https://app.test/a.js?v=1#one", scripts).map(
(item) => [item.script_index, item.match],
),
).toEqual([
[0, "exact-reported-url"],
[2, "response-url-without-fragment"],
]);
});
it("preserves every captured version at the same URL and never picks one", () => {
const url = "https://app.test/a.js";
const candidates = matchCapturedModules(url, [
script(url, "scenario-response"),
script(url, "scenario-response", "b".repeat(64)),
]);
expect(candidates).toHaveLength(2);
expect(
matchCapturedModules(
"https://app.test/lazy.js",
candidates.map((item) => item.script),
),
).toEqual([]);
});
it("retains exact non-URL identities without matching response fragments", () => {
const scripts = [
script("relative/module.js#part", "page-script"),
script("relative/module.js#part", "scenario-response"),
script("relative/module.js", "scenario-response"),
];
expect(
matchCapturedModules("relative/module.js#part", scripts).map((item) => [
item.script_index,
item.match,
]),
).toEqual([
[0, "exact-reported-url"],
[1, "exact-reported-url"],
]);
});
});
it.each(["main.mjs", "main.js", "view.jsx"])(
"retains original expression offsets for a BOM-prefixed hashbang in %s",
(path) => {
const source =
'\uFEFF#!/usr/bin/env node\r\nconst face = "😀"; import "./dep.mjs"; import(`./${part}.mjs`);';
const result = collectWebModuleImports(source, path);
expect(result.state).toBe("parsed");
expect(result.diagnostics).toEqual(
path === "main.js"
? [expect.stringContaining("package loader mode is unknown")]
: [],
);
expect(result.imports.map(({ expression }) => expression)).toEqual([
'"./dep.mjs"',
"`./${part}.mjs`",
]);
for (const item of result.imports) {
expect(item.start.offset).toBe(source.indexOf(item.expression));
expect(source.slice(item.start.offset, item.end.offset)).toBe(
item.expression,
);
expect(item.start.line).toBe(2);
expect(item.start.column).toBe(
source.split("\r\n")[1]!.indexOf(item.expression),
);
}
},
);