@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/utils/fileWalk.test.js

@@ -1,252 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { collectFiles, walkDir, walkSourceFiles } from "./fileWalk.js";
-/** Materialize a file tree under a fresh temp dir. Keys are relative paths;
- * a value of `null` creates an (empty) directory instead of a file. */
-function makeTree(files) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "filewalk-"));
-    for (const [rel, content] of Object.entries(files)) {
-        const abs = path.join(root, rel);
-        if (content === null) {
-            fs.mkdirSync(abs, { recursive: true });
-        }
-        else {
-            fs.mkdirSync(path.dirname(abs), { recursive: true });
-            fs.writeFileSync(abs, content);
-        }
-    }
-    return root;
-}
-/** Sort + make paths relative to root for stable comparison. */
-function rel(root, abs) {
-    return abs.map((p) => path.relative(root, p).replace(/\\/g, "/")).sort();
-}
-// `chmod 000` only makes a directory unreadable where the OS enforces the
-// permission bits: not on Windows, and not for root (which bypasses them). Skip
-// the best-effort-on-unreadable-dir tests where the setup can't actually fail a
-// readdir, rather than let them false-fail. `it`/`it.skip` chosen at load time.
-const permsEnforced = process.platform !== "win32" &&
-    (typeof process.getuid !== "function" || process.getuid() !== 0);
-const itIfPerms = permsEnforced ? it : it.skip;
-/** Collect the absolute file paths a walkDir generator yields. */
-function walkPaths(root, opts) {
-    const seen = [];
-    for (const [, full] of walkDir(root, opts))
-        seen.push(full);
-    return seen;
-}
-describe("walkDir", () => {
-    it("yields every file depth-first as [entry, absolute path]", () => {
-        const root = makeTree({
-            "a.txt": "a",
-            "sub/b.txt": "b",
-            "sub/deep/c.txt": "c",
-        });
-        const seen = [];
-        for (const [entry, full] of walkDir(root)) {
-            expect(entry.isFile()).toBe(true);
-            expect(path.isAbsolute(full)).toBe(true);
-            seen.push(full);
-        }
-        expect(rel(root, seen)).toEqual(["a.txt", "sub/b.txt", "sub/deep/c.txt"]);
-    });
-    it("yields only files, never directory entries", () => {
-        const root = makeTree({ "sub/b.txt": "b", emptydir: null });
-        const names = [...walkDir(root)].map(([entry]) => entry.name);
-        expect(names).toEqual(["b.txt"]);
-    });
-    it("honors maxDepth = 0 (root files only, no descent)", () => {
-        const root = makeTree({ "a.txt": "a", "sub/b.txt": "b" });
-        expect(rel(root, walkPaths(root, { maxDepth: 0 }))).toEqual(["a.txt"]);
-    });
-    it("honors maxDepth = 1 (root + one level down)", () => {
-        const root = makeTree({
-            "a.txt": "a",
-            "sub/b.txt": "b",
-            "sub/deep/c.txt": "c",
-        });
-        expect(rel(root, walkPaths(root, { maxDepth: 1 }))).toEqual([
-            "a.txt",
-            "sub/b.txt",
-        ]);
-    });
-    it("skips directories for which shouldSkipDir returns true", () => {
-        const root = makeTree({
-            "keep/a.txt": "a",
-            "node_modules/x.txt": "x",
-        });
-        const out = walkPaths(root, {
-            shouldSkipDir: (entry) => entry.name === "node_modules",
-        });
-        expect(rel(root, out)).toEqual(["keep/a.txt"]);
-    });
-    it("passes the directory's absolute path to shouldSkipDir", () => {
-        const root = makeTree({ "sub/a.txt": "a" });
-        [
-            ...walkDir(root, {
-                shouldSkipDir: (entry, full) => {
-                    expect(path.isAbsolute(full)).toBe(true);
-                    expect(path.basename(full)).toBe(entry.name);
-                    return false;
-                },
-            }),
-        ];
-    });
-    it("stops immediately when the consumer breaks (no further reads)", () => {
-        const root = makeTree({
-            "1.txt": "",
-            "2.txt": "",
-            "3.txt": "",
-            "sub/4.txt": "",
-        });
-        const seen = [];
-        for (const [, full] of walkDir(root)) {
-            seen.push(full);
-            break; // stop after the very first file
-        }
-        expect(seen.length).toBe(1);
-    });
-    it("yields all files when the consumer never breaks", () => {
-        const root = makeTree({ "1.txt": "", "2.txt": "" });
-        expect(walkPaths(root).length).toBe(2);
-    });
-    itIfPerms("is best-effort: an unreadable subdirectory is skipped, not fatal", () => {
-        const root = makeTree({ "a.txt": "a", "bad/b.txt": "b", "c.txt": "c" });
-        const badDir = path.join(root, "bad");
-        fs.chmodSync(badDir, 0o000);
-        try {
-            // Should not throw despite `bad` being unreadable, and should skip its
-            // contents while still visiting siblings.
-            expect(rel(root, walkPaths(root))).toEqual(["a.txt", "c.txt"]);
-        }
-        finally {
-            fs.chmodSync(badDir, 0o755);
-        }
-    });
-    it("does not throw when the root itself is unreadable/missing", () => {
-        expect(() => walkPaths(path.join(os.tmpdir(), "filewalk-does-not-exist-xyz"))).not.toThrow();
-    });
-});
-describe("walkSourceFiles (characterization — existing contract)", () => {
-    it("collects only files matching one of the extensions, as absolute paths", () => {
-        const root = makeTree({
-            "a.ts": "",
-            "b.tsx": "",
-            "c.js": "",
-            "d.py": "",
-            "sub/e.ts": "",
-        });
-        const out = walkSourceFiles(root, {
-            extensions: [".ts", ".tsx"],
-            skipDirs: new Set(),
-        });
-        expect(out.every((p) => path.isAbsolute(p))).toBe(true);
-        expect(rel(root, out)).toEqual(["a.ts", "b.tsx", "sub/e.ts"]);
-    });
-    it("skips directories named in skipDirs (matched on basename)", () => {
-        const root = makeTree({
-            "a.ts": "",
-            "node_modules/x.ts": "",
-            "src/b.ts": "",
-        });
-        const out = walkSourceFiles(root, {
-            extensions: [".ts"],
-            skipDirs: new Set(["node_modules"]),
-        });
-        expect(rel(root, out)).toEqual(["a.ts", "src/b.ts"]);
-    });
-    it("stops at exactly `limit` files when the cap is hit", () => {
-        const root = makeTree({
-            "a.ts": "",
-            "b.ts": "",
-            "c.ts": "",
-            "d.ts": "",
-        });
-        const out = walkSourceFiles(root, {
-            extensions: [".ts"],
-            skipDirs: new Set(),
-            limit: 2,
-        });
-        expect(out.length).toBe(2);
-    });
-    it("returns all matches when under the limit", () => {
-        const root = makeTree({ "a.ts": "", "b.ts": "" });
-        const out = walkSourceFiles(root, {
-            extensions: [".ts"],
-            skipDirs: new Set(),
-            limit: 100,
-        });
-        expect(out.length).toBe(2);
-    });
-    it("does NOT skip dotfile directories by default", () => {
-        const root = makeTree({ ".hidden/a.ts": "", "b.ts": "" });
-        const out = walkSourceFiles(root, {
-            extensions: [".ts"],
-            skipDirs: new Set(),
-        });
-        expect(rel(root, out)).toEqual([".hidden/a.ts", "b.ts"]);
-    });
-    itIfPerms("is best-effort on unreadable directories", () => {
-        const root = makeTree({ "a.ts": "", "bad/b.ts": "" });
-        const badDir = path.join(root, "bad");
-        fs.chmodSync(badDir, 0o000);
-        try {
-            const out = walkSourceFiles(root, {
-                extensions: [".ts"],
-                skipDirs: new Set(),
-            });
-            expect(rel(root, out)).toEqual(["a.ts"]);
-        }
-        finally {
-            fs.chmodSync(badDir, 0o755);
-        }
-    });
-});
-describe("collectFiles", () => {
-    it("collects files matching the predicate as absolute paths", () => {
-        const root = makeTree({ "a.dart": "", "b.txt": "", "sub/c.dart": "" });
-        const out = collectFiles(root, {
-            match: (entry) => entry.name.endsWith(".dart"),
-        });
-        expect(out.every((p) => path.isAbsolute(p))).toBe(true);
-        expect(rel(root, out)).toEqual(["a.dart", "sub/c.dart"]);
-    });
-    it("passes the absolute path to the matcher", () => {
-        const root = makeTree({ "keep/x.ts": "", "modules/y/index.ts": "" });
-        const out = collectFiles(root, {
-            match: (_entry, full) => full.includes(`${path.sep}modules${path.sep}`),
-        });
-        expect(rel(root, out)).toEqual(["modules/y/index.ts"]);
-    });
-    it("returns exactly `limit` files when the cap is hit", () => {
-        const root = makeTree({ "a.ts": "", "b.ts": "", "c.ts": "" });
-        const out = collectFiles(root, {
-            match: (entry) => entry.name.endsWith(".ts"),
-            limit: 2,
-        });
-        expect(out.length).toBe(2);
-    });
-    it("returns nothing for `limit: 0` (does not collect a single file)", () => {
-        const root = makeTree({ "a.ts": "", "b.ts": "" });
-        const out = collectFiles(root, {
-            match: () => true,
-            limit: 0,
-        });
-        expect(out).toEqual([]);
-    });
-    it("forwards maxDepth and shouldSkipDir to the walk", () => {
-        const root = makeTree({
-            "a.ts": "",
-            "skip/b.ts": "",
-            "sub/deep/c.ts": "",
-        });
-        const out = collectFiles(root, {
-            match: (entry) => entry.name.endsWith(".ts"),
-            maxDepth: 1,
-            shouldSkipDir: (entry) => entry.name === "skip",
-        });
-        // maxDepth: 1 excludes sub/deep/c.ts; shouldSkipDir excludes skip/b.ts.
-        expect(rel(root, out)).toEqual(["a.ts"]);
-    });
-});

package/build/utils/frontendIntegration.test.d.ts

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

package/build/utils/frontendIntegration.test.js

@@ -1,229 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { execFileSync } from "child_process";
-import { checkFrontendFileIntegration } from "./frontendIntegration.js";
-/** Creates a temp git repo, writes the given files, and stages them so
- * `git grep` (which only searches tracked files by default) can find them. */
-function makeFixtureRepo(files) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "frontend-integration-"));
-    execFileSync("git", ["init", "-q"], { cwd: dir });
-    for (const [relPath, content] of Object.entries(files)) {
-        const abs = path.join(dir, relPath);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, content);
-    }
-    execFileSync("git", ["add", "-A"], { cwd: dir });
-    return dir;
-}
-/** Same as makeFixtureRepo but NOT a git repo, to exercise the manual-walk
- * fallback (`git grep` fails outright when the directory isn't a repo). */
-function makeNonGitFixture(files) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "frontend-integration-nogit-"));
-    for (const [relPath, content] of Object.entries(files)) {
-        const abs = path.join(dir, relPath);
-        fs.mkdirSync(path.dirname(abs), { recursive: true });
-        fs.writeFileSync(abs, content);
-    }
-    return dir;
-}
-describe("checkFrontendFileIntegration", () => {
-    it("marks a component imported by a production file as integrated, listing the importer", () => {
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/components/Bar.tsx": `import { Foo } from './Foo';\nexport function Bar() { return Foo(); }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.reason).toBe("imported");
-        expect(result.importers).toEqual(["src/components/Bar.tsx"]);
-    });
-    it("marks a component imported ONLY by test files as unintegrated", () => {
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/components/Foo.test.tsx": `import { Foo } from './Foo';\ntest('renders', () => Foo());\n`,
-            "src/components/__tests__/Foo.spec.tsx": `import { Foo } from './Foo';\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(false);
-        expect(result.reason).toBe("no-importers");
-        expect(result.importers).toEqual([]);
-    });
-    it("short-circuits route/entrypoint files as integrated without grepping", () => {
-        const repo = makeFixtureRepo({
-            "src/pages/Dashboard.tsx": `export default function Dashboard() { return null; }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/pages/Dashboard.tsx"]);
-        expect(result).toEqual({
-            file: "src/pages/Dashboard.tsx",
-            integrated: true,
-            importers: [],
-            reason: "route-or-entrypoint",
-        });
-    });
-    it("counts a re-export barrel as an importer", () => {
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/components/index.ts": `export { Foo } from './Foo';\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.importers).toEqual(["src/components/index.ts"]);
-    });
-    it("counts an oversized single-line bundle referencing the module path as an importer, unread", () => {
-        // A minified >512KB one-line file. Node never opens candidates — git
-        // grep -l only returns the path — so file size cannot cause a large
-        // allocation or blow the subprocess buffer.
-        const hugeBundle = `var m=require("./components/Foo");` + "a".repeat(600 * 1024);
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/vendor/bundle.js": hugeBundle,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.importers).toEqual(["src/vendor/bundle.js"]);
-    });
-    it("resolves importers of an oversized changed file (the changed file is never read)", () => {
-        const hugeComponent = `export function Foo() { return null; }\n// ` + "b".repeat(600 * 1024) + `\n`;
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": hugeComponent,
-            "src/components/Bar.tsx": `import Foo from './Foo';\nexport function Bar() { return Foo(); }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.reason).toBe("imported");
-        expect(result.importers).toEqual(["src/components/Bar.tsx"]);
-    });
-    it("catches multiline imports (the from-line carries the path signature)", () => {
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/components/Bar.tsx": `import {\n  Foo,\n} from "./Foo";\nexport function Bar() { return Foo(); }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.importers).toEqual(["src/components/Bar.tsx"]);
-    });
-    it("does not count bare-name mentions (comments, strings) as importers", () => {
-        // The precision property of the path-signature design: a dead component
-        // whose NAME appears in prose elsewhere must still read as unintegrated.
-        const repo = makeFixtureRepo({
-            "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            "src/components/Other.tsx": `// TODO: consolidate with Foo someday\nconst label = "Foo";\nexport function Other() { return label; }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-        expect(result.integrated).toBe(false);
-        expect(result.reason).toBe("no-importers");
-        expect(result.importers).toEqual([]);
-    });
-    it("does not short-circuit components under a generic top-level app/ monorepo dir", () => {
-        // Regression: appsmith's repo root is `app/` — matching it as a framework
-        // route dir made the check inert for the whole repo (eval 28618761653).
-        const repo = makeFixtureRepo({
-            "app/client/src/components/Orphan.tsx": `export function Orphan() { return null; }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["app/client/src/components/Orphan.tsx"]);
-        expect(result.integrated).toBe(false);
-        expect(result.reason).toBe("no-importers");
-    });
-    it("still short-circuits Next.js App Router route files via their basenames", () => {
-        const repo = makeFixtureRepo({
-            "src/app/dashboard/page.tsx": `export default function Dashboard() { return null; }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/app/dashboard/page.tsx"]);
-        expect(result.integrated).toBe(true);
-        expect(result.reason).toBe("route-or-entrypoint");
-    });
-    it("fails open (scan-error, integrated: true) when the changed file does not exist on disk", () => {
-        const repo = makeFixtureRepo({
-            "src/components/Bar.tsx": `export function Bar() { return null; }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Deleted.tsx"]);
-        expect(result).toEqual({
-            file: "src/components/Deleted.tsx",
-            integrated: true,
-            importers: [],
-            reason: "scan-error",
-        });
-    });
-    it("finds an importer of a .d.ts declaration file", () => {
-        // Regression: path.extname("Foo.d.ts") is ".ts", so a naive basename/ext
-        // split would build a signature for "Foo.d" instead of "Foo" and never
-        // match a real `from "./Foo"` import.
-        const repo = makeFixtureRepo({
-            "src/components/Foo.d.ts": `export declare function Foo(): null;\n`,
-            "src/components/Bar.tsx": `import { Foo } from './Foo';\nexport function Bar() { return Foo(); }\n`,
-        });
-        const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.d.ts"]);
-        expect(result.integrated).toBe(true);
-        expect(result.reason).toBe("imported");
-        expect(result.importers).toEqual(["src/components/Bar.tsx"]);
-    });
-    describe("basename short-circuit precision", () => {
-        it("does NOT short-circuit a folder-per-component index.tsx as a route/entrypoint", () => {
-            // Regression: matching "index"/"main"/"app" basenames anywhere in the
-            // tree (not just at the root or src/) would short-circuit the common
-            // React folder-per-component convention (Button/index.tsx) as always
-            // integrated, defeating the check for exactly the files it targets.
-            const repo = makeFixtureRepo({
-                "src/components/Button/index.tsx": `export function Button() { return null; }\n`,
-            });
-            const [result] = checkFrontendFileIntegration(repo, ["src/components/Button/index.tsx"]);
-            expect(result.integrated).toBe(false);
-            expect(result.reason).toBe("no-importers");
-        });
-        it("still short-circuits a root-level src/index.tsx entrypoint", () => {
-            const repo = makeFixtureRepo({
-                "src/index.tsx": `export default function App() { return null; }\n`,
-            });
-            const [result] = checkFrontendFileIntegration(repo, ["src/index.tsx"]);
-            expect(result).toEqual({
-                file: "src/index.tsx",
-                integrated: true,
-                importers: [],
-                reason: "route-or-entrypoint",
-            });
-        });
-        it("does NOT short-circuit a page.tsx outside an app/ segment", () => {
-            // "page"/"layout" are App Router-specific; outside an app/ segment they
-            // are ordinary component filenames with no framework meaning.
-            const repo = makeFixtureRepo({
-                "src/components/page.tsx": `export function Page() { return null; }\n`,
-            });
-            const [result] = checkFrontendFileIntegration(repo, ["src/components/page.tsx"]);
-            expect(result.integrated).toBe(false);
-            expect(result.reason).toBe("no-importers");
-        });
-    });
-    describe("manual-walk fallback (non-git repos)", () => {
-        it("falls back to a manual walk and finds an importer when the directory isn't a git repo", () => {
-            const repo = makeNonGitFixture({
-                "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-                "src/components/Bar.tsx": `import { Foo } from './Foo';\nexport function Bar() { return Foo(); }\n`,
-            });
-            const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-            expect(result.integrated).toBe(true);
-            expect(result.reason).toBe("imported");
-            expect(result.importers).toEqual(["src/components/Bar.tsx"]);
-        });
-        it("fails open (scan-error) when the fallback walk is truncated before finding an importer", () => {
-            // Regression: the module doc promises fail-open on any scan error/
-            // uncertainty, but a truncated manual walk used to just return its
-            // partial (empty) result set, reporting a confident "no-importers"
-            // even though an importer could exist past the file cap.
-            const files = {
-                "src/components/Foo.tsx": `export function Foo() { return null; }\n`,
-            };
-            for (let i = 0; i < 3005; i++) {
-                files[`src/generated/File${i}.tsx`] = `export const noop${i} = 0;\n`;
-            }
-            const repo = makeNonGitFixture(files);
-            const [result] = checkFrontendFileIntegration(repo, ["src/components/Foo.tsx"]);
-            expect(result).toEqual({
-                file: "src/components/Foo.tsx",
-                integrated: true,
-                importers: [],
-                reason: "scan-error",
-            });
-        });
-    });
-});

package/build/utils/frontendSelectors.test.d.ts

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

package/build/utils/frontendSelectors.test.js

@@ -1,118 +0,0 @@
-import { describe, it, expect } from "@jest/globals";
-import { extractChangedSelectors } from "./frontendSelectors.js";
-describe("extractChangedSelectors", () => {
-    it("captures both the old (removed) and new (added) value of a renamed data-testid", () => {
-        const diff = [
-            "@@ -175,7 +175,7 @@",
-            '-        dataTestId="confirmation-modal-confirm-button"',
-            '+        dataTestId="confirmation-modal-primary-button"',
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        // dataTestId isn't a data-* attribute, but both are distinctive kebab class-ish tokens
-        expect(sel).toEqual(expect.arrayContaining([
-            "confirmation-modal-confirm-button",
-            "confirmation-modal-primary-button",
-        ]));
-    });
-    it("captures data-testid attribute values", () => {
-        const diff = '+  <input data-testid="members-search-field" />\n-  <input data-testid="members-search-input" />';
-        const sel = extractChangedSelectors(diff);
-        expect(sel).toEqual(expect.arrayContaining(["members-search-field", "members-search-input"]));
-    });
-    it("captures CSS class rename with BEM `--` and multi-segment kebab", () => {
-        const diff = [
-            '-  <div className="t--table-filter-columns-dropdown">',
-            '+  <div className="t--tbl-filter-column-select">',
-            '+  <button className="ads-button--primary">',
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        expect(sel).toEqual(expect.arrayContaining([
-            "t--table-filter-columns-dropdown",
-            "t--tbl-filter-column-select",
-            "ads-button--primary",
-        ]));
-    });
-    it("captures the BEM base prefix of a dynamically-composed modifier class", () => {
-        const diff = [
-            "-        className={clsx(ButtonClassName, className)}",
-            "+        className={clsx(ButtonClassName, kind && `ads-button--${kind}`, className)}",
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        // no concrete `ads-button--primary` literal exists in the diff — capture the base prefix
-        expect(sel).toContain("ads-button--");
-    });
-    it("captures the BEM base from string-concatenation too, but leaves STATIC modifiers to the kebab pass", () => {
-        const concat = extractChangedSelectors('+  const cls = "ads-button--" + kind;');
-        expect(concat).toContain("ads-button--");
-        // a fully static modifier is captured whole (not as a bare `foo-bar--` prefix)
-        const staticMod = extractChangedSelectors('+  <div className="t--tbl-filter-column-select" />');
-        expect(staticMod).toContain("t--tbl-filter-column-select");
-        expect(staticMod).not.toContain("t--tbl-filter-column-select--");
-    });
-    it("captures getByTestId arguments", () => {
-        const diff = "+  const btn = page.getByTestId('workflow-settings-modal');";
-        expect(extractChangedSelectors(diff)).toContain("workflow-settings-modal");
-    });
-    it("drops single-hyphen styling utilities and short/generic tokens", () => {
-        const diff = [
-            '+  <div className="flex-start space-between text-align" />',
-            '+  const gap = "sans-serif";',
-        ].join("\n");
-        expect(extractChangedSelectors(diff)).toEqual([]);
-    });
-    it("drops multi-hyphen utility / design-token classes (numeric scale + utility roots)", () => {
-        const diff = [
-            '-  <div className="text-gray-500 bg-blue-600 flex-row-reverse" />',
-            '+  <div className="text-gray-600 bg-blue-700 grid-cols-3" />',
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        for (const util of ["text-gray-500", "text-gray-600", "bg-blue-600", "bg-blue-700", "flex-row-reverse", "grid-cols-3"]) {
-            expect(sel).not.toContain(util);
-        }
-    });
-    it("keeps semantic multi-hyphen identifiers and BEM classes (not utility)", () => {
-        const diff = [
-            '+  <div className="confirmation-modal-confirm-button user-profile-header" />',
-            '+  <div className="t--tbl-filter-column-select" />',
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        expect(sel).toEqual(expect.arrayContaining([
-            "confirmation-modal-confirm-button",
-            "user-profile-header",
-            "t--tbl-filter-column-select",
-        ]));
-    });
-    it("ignores context (unchanged) lines and file headers", () => {
-        const diff = [
-            "--- a/src/Component.tsx",
-            "+++ b/src/Component.tsx",
-            '   <div className="t--unchanged-context-selector" />', // context line (leading space)
-            '+  <div className="t--added-real-selector" />',
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        expect(sel).toContain("t--added-real-selector");
-        expect(sel).not.toContain("t--unchanged-context-selector");
-        expect(sel).not.toContain("Component"); // +++/--- headers ignored
-    });
-    it("does not leak a partial prefix from an interpolated template-literal attribute value", () => {
-        const diff = [
-            "+  <input data-testid={`members-search-${id}`} />",
-            "+  <button data-testid={`confirmation-modal-${kind}`} />",
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        expect(sel).not.toContain("members-search-");
-        expect(sel).not.toContain("confirmation-modal-");
-    });
-    it("does not capture non-literal expression attribute values (data-testid={someVar})", () => {
-        const diff = [
-            "+  <div data-testid={someVariableName} />",
-            "+  <div data-testid={'members-search-field'} />",
-        ].join("\n");
-        const sel = extractChangedSelectors(diff);
-        expect(sel).not.toContain("someVariableName"); // variable name, not a literal
-        expect(sel).toContain("members-search-field"); // quoted literal still captured
-    });
-    it("returns [] for an empty diff", () => {
-        expect(extractChangedSelectors("")).toEqual([]);
-    });
-});

package/build/utils/gitStaging.test.d.ts

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