@matter/tools 0.12.4-alpha.0-20250211-56b2c53a0 → 0.12.4-alpha.0-20250213-1187f81eb

package/src/building/cycles.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { readFile } from "fs/promises";
+import { Package } from "../util/package.js";
+import { Progress } from "../util/progress.js";
+
+// @ts-expect-error we don't have types for detective-typescript
+import detective from "detective-typescript";
+import { dirname, relative, resolve } from "path";
+import { std } from "../ansi-text/std.js";
+import { ansi } from "../ansi-text/text-builder.js";
+
+export async function reportCycles(pkg: Package, progress: Progress) {
+    const cycles = await progress.run(pkg.name, () => identifyCycles(pkg, progress));
+    if (cycles) {
+        printCycles(pkg, cycles);
+    }
+}
+
+async function identifyCycles(pkg: Package, progress: Progress) {
+    const deps = {} as Record<string, string[]>;
+    for (const filename of await pkg.glob("{src,test}/**/*.ts")) {
+        const contents = await readFile(filename, "utf-8");
+        const fileDeps = detective(contents, {
+            skipTypeImports: true,
+            skipAsyncImports: true,
+        });
+        deps[filename] = resolveDeps(pkg, filename, fileDeps);
+    }
+
+    const cycles = [] as string[][];
+    for (const filename in deps) {
+        visit(filename, []);
+    }
+
+    function visit(filename: string, breadcrumb: string[]) {
+        progress.refresh();
+        const fileDeps = deps[filename] ?? deps[filename.replace(/\.js$/, ".ts")];
+        if (fileDeps === undefined) {
+            return;
+        }
+
+        const previousIndex = breadcrumb.indexOf(filename);
+        if (previousIndex !== -1) {
+            const newCycle = breadcrumb.slice(previousIndex);
+            for (const cycle of cycles) {
+                const filenameOffset = cycle.indexOf(filename);
+                if (cycle.length !== newCycle.length) {
+                    continue;
+                }
+                if (filenameOffset === -1) {
+                    continue;
+                }
+
+                let i = 0;
+                for (i = 0; i < newCycle.length; i++) {
+                    if (newCycle[i] !== cycle[(filenameOffset + i) % newCycle.length]) {
+                        break;
+                    }
+                }
+
+                if (i === newCycle.length) {
+                    return;
+                }
+            }
+            cycles.push(newCycle);
+            return;
+        }
+
+        breadcrumb = [...breadcrumb, filename];
+        for (const dep of fileDeps) {
+            visit(dep, breadcrumb);
+        }
+    }
+
+    return cycles.length ? cycles : undefined;
+}
+
+function printCycles(pkg: Package, cycles: string[][]) {
+    std.out(ansi.red("Cycles detected:"), "\n");
+    const src = pkg.resolve("src");
+    for (const cycle of cycles) {
+        std.out("  ", cycle.map(name => ansi.bright.blue(relative(src, name))).join(" → "), " ↩\n");
+    }
+}
+
+function resolveDeps(pkg: Package, sourceFilename: string, deps: string[]) {
+    const dir = dirname(sourceFilename);
+    const aliases = pkg.importAliases;
+    const resolved = Array<string>();
+
+    for (let dep of deps) {
+        let base = dir;
+        if (dep.startsWith("#")) {
+            dep = aliases.rewrite(dep);
+            base = pkg.path;
+        }
+        if (dep.startsWith("./")) {
+            resolved.push(resolve(base, dep));
+        }
+    }
+
+    return resolved;
+}

package/src/building/graph.ts

@@ -134,7 +134,7 @@ export class Graph {
             progress.info("built", formatTime(node.info.timestamp ?? 0));
             progress.info("dirty", node.isDirty ? colors.dim.red("yes") : colors.dim.green("no"));
             progress.info("dependencies", node.dependencies.map(formatDep).join(", "));
-            progress.shutdown();
+            progress.close();
         }
     }
 

package/src/building/project-builder.ts

@@ -67,12 +67,12 @@ export class ProjectBuilder {
         try {
             await this.#doBuild(project, progress);
         } catch (e: any) {
-            progress.shutdown();
+            progress.close();
             process.stderr.write(`${e.stack ?? e.message}\n\n`);
             process.exit(1);
         }
 
-        progress.shutdown();
+        progress.close();
     }
 
     async #doBuild(project: Project, progress: Progress) {

package/src/util/bootstrap.mjs

@@ -73,7 +73,14 @@ async function bootstrap() {
         await new Promise(resolve => {
             const proc = spawn(
                 esbuild,
-                ["src/**/*.ts", "--outdir=dist/esm", "--format=esm", "--log-level=warning", "--sourcemap=inline"],
+                [
+                    "src/**/*.ts",
+                    "--outdir=dist/esm",
+                    "--format=esm",
+                    "--log-level=warning",
+                    "--sourcemap=inline",
+                    "--target=es2022",
+                ],
                 options,
             );
 

package/src/util/import-aliases.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Parses package.json "imports" fields and rewrites local imports according to the import definitions.
+ */
+export class ImportAliases {
+    #parent?: ImportAliases;
+    #direct: Record<string, string> = {};
+    #wildcard = Array<WildcardAlias>();
+
+    constructor(localAliases?: Record<string, string>, parent?: ImportAliases) {
+        for (const path in localAliases) {
+            const resolvesTo = localAliases[path];
+
+            let wildcardAt = path.indexOf("*");
+            if (wildcardAt === -1) {
+                this.#direct[path] = resolvesTo;
+                continue;
+            }
+
+            const inputPrefix = path.substring(0, wildcardAt);
+            const inputSuffix = path.substring(wildcardAt + 1);
+
+            wildcardAt = resolvesTo.indexOf("*");
+            if (wildcardAt === -1) {
+                this.#wildcard.push({
+                    inputPrefix,
+                    inputSuffix,
+                    includeGlob: false,
+                    outputPrefix: resolvesTo,
+                    outputSuffix: "",
+                });
+            } else {
+                this.#wildcard.push({
+                    inputPrefix,
+                    inputSuffix,
+                    includeGlob: true,
+                    outputPrefix: resolvesTo.substring(0, wildcardAt),
+                    outputSuffix: resolvesTo.substring(wildcardAt + 1),
+                });
+            }
+        }
+        this.#parent = parent;
+    }
+
+    rewrite(path: string): string {
+        if (path.startsWith("#")) {
+            const direct = this.#direct[path];
+            if (direct) {
+                return direct;
+            }
+            for (const alias of this.#wildcard) {
+                if (path.startsWith(alias.inputPrefix) && path.endsWith(alias.inputSuffix)) {
+                    if (alias.includeGlob) {
+                        return (
+                            alias.outputPrefix +
+                            path.substring(alias.inputPrefix.length, path.length - alias.inputSuffix.length) +
+                            alias.outputSuffix
+                        );
+                    }
+                    return alias.outputPrefix;
+                }
+            }
+        }
+        return this.#parent?.rewrite(path) ?? path;
+    }
+}
+
+interface WildcardAlias {
+    inputPrefix: string;
+    inputSuffix: string;
+    includeGlob: boolean;
+    outputPrefix: string;
+    outputSuffix: string;
+}

package/src/util/package.ts

@@ -10,6 +10,7 @@ import { dirname, join, relative, resolve } from "path";
 import { ignoreError, ignoreErrorSync } from "./errors.js";
 import { isFile, maybeReadJsonSync, maybeStatSync } from "./file.js";
 import { globSync } from "./glob.js";
+import { ImportAliases } from "./import-aliases.js";
 import { Progress } from "./progress.js";
 import { toolsPath } from "./tools-path.cjs";
 
@@ -53,7 +54,7 @@ export class Package {
     hasTests: boolean;
     hasConfig: boolean;
     isLibrary: boolean;
-    #aliases?: Record<string, string>;
+    #importAliases?: ImportAliases;
 
     constructor({
         path = ".",
@@ -314,7 +315,11 @@ export class Package {
                 if (existsSync(join(path, "package.json"))) {
                     result = new Package({ path });
                 } else {
-                    result = find(dirname(path));
+                    const parentDir = dirname(path);
+                    if (parentDir === path) {
+                        return null;
+                    }
+                    result = find(parentDir);
                 }
                 packageForPath[path] = result;
             }
@@ -334,17 +339,17 @@ export class Package {
         throw new Error(`Cannot find package.json for "${path}"`);
     }
 
-    get aliases(): Record<string, string> {
-        if (this.#aliases !== undefined) {
-            return this.#aliases;
+    get importAliases(): ImportAliases {
+        if (this.#importAliases !== undefined) {
+            return this.#importAliases;
         }
 
-        this.#aliases = {
-            ...Package.maybeForPath(dirname(this.path))?.aliases,
-            ...this.json.imports,
-        };
+        this.#importAliases = new ImportAliases(
+            this.json.imports,
+            Package.maybeForPath(dirname(this.path))?.importAliases,
+        );
 
-        return this.#aliases;
+        return this.#importAliases;
     }
 
     get modules() {

package/src/util/progress.ts

@@ -155,7 +155,7 @@ export class Progress {
         std.out.write(`    ${ansi.yellow("Warning:")} ${text}\n`);
     }
 
-    shutdown() {
+    close() {
         if (this.#refreshInterval) {
             clearInterval(this.#refreshInterval);
             this.#refreshInterval = undefined;
@@ -163,6 +163,10 @@ export class Progress {
         writeStatus("");
     }
 
+    [Symbol.dispose]() {
+        this.close();
+    }
+
     refresh() {
         if (this.#updateSpinner()) {
             this.#writeOngoing();

package/src/versioning/cli.ts

@@ -48,5 +48,5 @@ export async function main(argv = process.argv) {
         await progress.run(`Tagging version ${progress.emphasize(versioner.version)}`, () => versioner.tag());
     }
 
-    progress.shutdown();
+    progress.close();
 }