@matter/tools 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/building/graph.js

@@ -0,0 +1,192 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import mapWorkspaces from "@npmcli/map-workspaces";
+import colors from "ansi-colors";
+import { JsonNotFoundError, Package } from "../util/package.js";
+import { Progress } from "../util/progress.js";
+import { InternalBuildError } from "./error.js";
+import { BUILD_INFO_LOCATION, Project } from "./project.js";
+class Graph {
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+  get(name) {
+    const node = this.nodes.find((node2) => node2.pkg.name === name);
+    if (node === void 0) {
+      throw new Error(`Cannot locate package "${name}"`);
+    }
+    return node;
+  }
+  static async load(pkg = Package.workspace) {
+    const nodeMap = await this.#loadNodes(pkg.workspace);
+    return await this.#createGraph(Object.values(nodeMap));
+  }
+  static async forProject(path) {
+    let workspace;
+    try {
+      workspace = Package.workspaceFor(path);
+    } catch (e) {
+      if (e instanceof JsonNotFoundError) {
+        return;
+      }
+      throw e;
+    }
+    const nodeMap = await this.#loadNodes(workspace);
+    const rootPkg = new Package({ path });
+    const rootNode = nodeMap[rootPkg.json.name];
+    if (!rootNode) {
+      return;
+    }
+    const nodes = /* @__PURE__ */ new Set();
+    function addNode(node) {
+      if (nodes.has(node)) {
+        return;
+      }
+      nodes.add(node);
+      for (const dependency of node.dependencies) {
+        addNode(dependency);
+      }
+    }
+    addNode(rootNode);
+    return await this.#createGraph([...nodes]);
+  }
+  // TODO - parallelization will be trivial except need to update Progress
+  // to support display of multiple simultaneous tasks
+  async build(builder, showSkipped = true) {
+    const toBuild = new Set(this.nodes);
+    for (const node of this.nodes) {
+      await builder.configure(node.project);
+    }
+    while (toBuild.size) {
+      let node;
+      nodes: for (node of toBuild) {
+        for (const dep of node.dependencies) {
+          if (dep.isDirty) {
+            continue nodes;
+          }
+        }
+        break;
+      }
+      if (!node) {
+        throw new Error("Internal logic error: No unbuilt project has fully built dependencies");
+      }
+      if (node.isDirty || builder.unconditional) {
+        await builder.build(node.project);
+        node.info.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      } else if (showSkipped) {
+        new Progress().skip("Up to date", node.pkg);
+      }
+      toBuild.delete(node);
+    }
+  }
+  display() {
+    for (const node of this.nodes) {
+      const progress = node.pkg.start("Node");
+      progress.info("path", node.pkg.path);
+      progress.info("modified", formatTime(node.modifyTime));
+      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();
+    }
+  }
+  static async #createGraph(nodes) {
+    const graph = new Graph(nodes);
+    await Promise.all(
+      graph.nodes.map(async (node) => {
+        if (node.pkg.hasFile(BUILD_INFO_LOCATION)) {
+          node.info = await node.pkg.readJson(BUILD_INFO_LOCATION);
+        }
+        node.modifyTime = await node.pkg.lastModified("package.json", "src", "test");
+        return node;
+      })
+    );
+    const stack = Array();
+    function findCircular(node) {
+      if (stack.indexOf(node) !== -1) {
+        stack.push(node);
+        throw new InternalBuildError(`Circular dependency: ${stack.map(formatDep).join(" \u25B8 ")}`);
+      }
+      stack.push(node);
+      for (const dep of node.dependencies) {
+        findCircular(dep);
+      }
+      stack.pop();
+    }
+    for (const node of graph.nodes) {
+      findCircular(node);
+    }
+    return graph;
+  }
+  static async #loadNodes(workspace) {
+    const workspaces = await mapWorkspaces({ pkg: workspace.json, cwd: workspace.path });
+    const nodeMap = {};
+    const allDeps = {};
+    for (const path of workspaces.values()) {
+      const pkg = new Package({ path });
+      allDeps[pkg.json.name] = pkg.dependencies;
+      nodeMap[pkg.json.name] = {
+        pkg,
+        project: new Project(pkg),
+        dependencies: [],
+        info: {},
+        modifyTime: 0,
+        get buildTime() {
+          return this.info.timestamp ? new Date(this.info.timestamp).getTime() : 0;
+        },
+        get isDirty() {
+          return this.modifyTime > this.buildTime || !!this.dependencies.find(
+            (dep) => dep.isDirty || dep.buildTime > this.buildTime && (dep.info.apiSha === void 0 || dep.info.apiSha !== this.info.dependencyApiShas?.[dep.pkg.name])
+          );
+        },
+        // This version of dirty should only be used after building all dependencies.  If this project is
+        // unmodified and the SHA of the type definitions of the target project is also unmodified then we do
+        // not need to build
+        get prebuildDirty() {
+          if (this.modifyTime > this.buildTime) {
+            return true;
+          }
+          const depShas = this.info.dependencyApiShas;
+          if (typeof depShas !== "object") {
+            return this.isDirty;
+          }
+          for (const dep of this.dependencies) {
+            const depSha = depShas[dep.pkg.name];
+            if (depSha === void 0 || depSha !== dep.info.apiSha) {
+              return true;
+            }
+          }
+          return false;
+        }
+      };
+    }
+    for (const name in allDeps) {
+      for (const dep of allDeps[name]) {
+        const depNode = nodeMap[dep];
+        if (depNode && depNode !== nodeMap[name]) {
+          nodeMap[name].dependencies.push(depNode);
+        }
+      }
+    }
+    return nodeMap;
+  }
+}
+function formatTime(time) {
+  if (!time) {
+    return colors.dim.red("never");
+  }
+  if (typeof time === "string") {
+    time = new Date(time).getTime();
+  }
+  return new Date(time - (/* @__PURE__ */ new Date()).getTimezoneOffset()).toISOString().split(".")[0].replace("T", " ");
+}
+function formatDep(node) {
+  return node.pkg.name.replace(/^@(?:project-chip|matter\.js)\//, "");
+}
+export {
+  Graph
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/building/graph.ts"],
  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport mapWorkspaces from \"@npmcli/map-workspaces\";\nimport colors from \"ansi-colors\";\nimport { JsonNotFoundError, Package } from \"../util/package.js\";\nimport { Progress } from \"../util/progress.js\";\nimport { Builder } from \"./builder.js\";\nimport { InternalBuildError } from \"./error.js\";\nimport { BUILD_INFO_LOCATION, BuildInformation, Project } from \"./project.js\";\n\n/**\n * Graph of dependencies for workspace packages.\n *\n * We use this information to determine which packages are \"dirty\" and need rebuild.  In the future we can also use for\n * parallel build, only tricky part there is showing status.\n */\nexport class Graph {\n    protected constructor(readonly nodes: Graph.Node[]) {}\n\n    get(name: string) {\n        const node = this.nodes.find(node => node.pkg.name === name);\n        if (node === undefined) {\n            throw new Error(`Cannot locate package \"${name}\"`);\n        }\n        return node;\n    }\n\n    static async load(pkg = Package.workspace) {\n        const nodeMap = await this.#loadNodes(pkg.workspace);\n        return await this.#createGraph(Object.values(nodeMap));\n    }\n\n    static async forProject(path: string): Promise<Graph | undefined> {\n        let workspace;\n        try {\n            workspace = Package.workspaceFor(path);\n        } catch (e) {\n            if (e instanceof JsonNotFoundError) {\n                // Project is not in a workspace\n                return;\n            }\n            throw e;\n        }\n\n        const nodeMap = await this.#loadNodes(workspace);\n\n        const rootPkg = new Package({ path: path });\n        const rootNode = nodeMap[rootPkg.json.name];\n        if (!rootNode) {\n            // Project resides under a workspace but is not part of the workspace\n            return;\n        }\n\n        const nodes = new Set<Graph.Node>();\n        function addNode(node: Graph.Node) {\n            if (nodes.has(node)) {\n                return;\n            }\n            nodes.add(node);\n            for (const dependency of node.dependencies) {\n                addNode(dependency);\n            }\n        }\n\n        addNode(rootNode);\n\n        return await this.#createGraph([...nodes]);\n    }\n\n    // TODO - parallelization will be trivial except need to update Progress\n    // to support display of multiple simultaneous tasks\n    async build(builder: Builder, showSkipped = true) {\n        const toBuild = new Set(this.nodes);\n\n        // We configure each build before building so that any generated files are in place before we initiate the build\n        for (const node of this.nodes) {\n            await builder.configure(node.project);\n        }\n\n        while (toBuild.size) {\n            let node;\n\n            nodes: for (node of toBuild) {\n                for (const dep of node.dependencies) {\n                    if (dep.isDirty) {\n                        continue nodes;\n                    }\n                }\n                break;\n            }\n\n            if (!node) {\n                throw new Error(\"Internal logic error: No unbuilt project has fully built dependencies\");\n            }\n\n            if (node.isDirty || builder.unconditional) {\n                await builder.build(node.project);\n                node.info.timestamp = new Date().toISOString();\n            } else if (showSkipped) {\n                new Progress().skip(\"Up to date\", node.pkg);\n            }\n\n            toBuild.delete(node);\n        }\n    }\n\n    display() {\n        for (const node of this.nodes) {\n            const progress = node.pkg.start(\"Node\");\n            progress.info(\"path\", node.pkg.path);\n            progress.info(\"modified\", formatTime(node.modifyTime));\n            progress.info(\"built\", formatTime(node.info.timestamp ?? 0));\n            progress.info(\"dirty\", node.isDirty ? colors.dim.red(\"yes\") : colors.dim.green(\"no\"));\n            progress.info(\"dependencies\", node.dependencies.map(formatDep).join(\", \"));\n            progress.shutdown();\n        }\n    }\n\n    static async #createGraph(nodes: Graph.Node[]) {\n        const graph = new Graph(nodes);\n\n        await Promise.all(\n            graph.nodes.map(async node => {\n                if (node.pkg.hasFile(BUILD_INFO_LOCATION)) {\n                    node.info = await node.pkg.readJson(BUILD_INFO_LOCATION);\n                }\n\n                node.modifyTime = await node.pkg.lastModified(\"package.json\", \"src\", \"test\");\n\n                return node;\n            }),\n        );\n\n        const stack = Array<Graph.Node>();\n        function findCircular(node: Graph.Node) {\n            if (stack.indexOf(node) !== -1) {\n                stack.push(node);\n                throw new InternalBuildError(`Circular dependency: ${stack.map(formatDep).join(\" \u25B8 \")}`);\n            }\n            stack.push(node);\n            for (const dep of node.dependencies) {\n                findCircular(dep);\n            }\n            stack.pop();\n        }\n        for (const node of graph.nodes) {\n            findCircular(node);\n        }\n\n        return graph;\n    }\n\n    static async #loadNodes(workspace: Package) {\n        const workspaces = await mapWorkspaces({ pkg: workspace.json, cwd: workspace.path });\n\n        const nodeMap = {} as Record<string, Graph.Node>;\n        const allDeps = {} as Record<string, string[]>;\n        for (const path of workspaces.values()) {\n            const pkg = new Package({ path: path });\n            allDeps[pkg.json.name] = pkg.dependencies;\n            nodeMap[pkg.json.name] = {\n                pkg,\n                project: new Project(pkg),\n                dependencies: [],\n                info: {},\n                modifyTime: 0,\n\n                get buildTime() {\n                    return this.info.timestamp ? new Date(this.info.timestamp).getTime() : 0;\n                },\n\n                get isDirty() {\n                    return (\n                        this.modifyTime > this.buildTime ||\n                        !!this.dependencies.find(\n                            dep =>\n                                dep.isDirty ||\n                                (dep.buildTime > this.buildTime &&\n                                    (dep.info.apiSha === undefined ||\n                                        dep.info.apiSha !== this.info.dependencyApiShas?.[dep.pkg.name])),\n                        )\n                    );\n                },\n\n                // This version of dirty should only be used after building all dependencies.  If this project is\n                // unmodified and the SHA of the type definitions of the target project is also unmodified then we do\n                // not need to build\n                get prebuildDirty() {\n                    if (this.modifyTime > this.buildTime) {\n                        return true;\n                    }\n                    const depShas = this.info.dependencyApiShas;\n                    if (typeof depShas !== \"object\") {\n                        return this.isDirty;\n                    }\n                    for (const dep of this.dependencies) {\n                        const depSha = depShas[dep.pkg.name];\n                        if (depSha === undefined || depSha !== dep.info.apiSha) {\n                            return true;\n                        }\n                    }\n                    return false;\n                },\n            };\n        }\n\n        for (const name in allDeps) {\n            for (const dep of allDeps[name]) {\n                const depNode = nodeMap[dep];\n\n                // Note -- allow nodes to reference themselves, seems to be necessary on tools for use of tsc\n                if (depNode && depNode !== nodeMap[name]) {\n                    nodeMap[name].dependencies.push(depNode);\n                }\n            }\n        }\n\n        return nodeMap;\n    }\n}\n\nexport namespace Graph {\n    export interface Node {\n        pkg: Package;\n        project: Project;\n        dependencies: Node[];\n        buildTime: number;\n        info: BuildInformation;\n        modifyTime: number;\n        isDirty: boolean;\n        prebuildDirty: boolean;\n    }\n}\n\nfunction formatTime(time: number | string) {\n    if (!time) {\n        return colors.dim.red(\"never\");\n    }\n    if (typeof time === \"string\") {\n        time = new Date(time).getTime();\n    }\n    return new Date(time - new Date().getTimezoneOffset()).toISOString().split(\".\")[0].replace(\"T\", \" \");\n}\n\nfunction formatDep(node: Graph.Node) {\n    return node.pkg.name.replace(/^@(?:project-chip|matter\\.js)\\//, \"\");\n}\n"],
  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,OAAO,mBAAmB;AAC1B,OAAO,YAAY;AACnB,SAAS,mBAAmB,eAAe;AAC3C,SAAS,gBAAgB;AAEzB,SAAS,0BAA0B;AACnC,SAAS,qBAAuC,eAAe;AAQxD,MAAM,MAAM;AAAA,EACL,YAAqB,OAAqB;AAArB;AAAA,EAAsB;AAAA,EAErD,IAAI,MAAc;AACd,UAAM,OAAO,KAAK,MAAM,KAAK,CAAAA,UAAQA,MAAK,IAAI,SAAS,IAAI;AAC3D,QAAI,SAAS,QAAW;AACpB,YAAM,IAAI,MAAM,0BAA0B,IAAI,GAAG;AAAA,IACrD;AACA,WAAO;AAAA,EACX;AAAA,EAEA,aAAa,KAAK,MAAM,QAAQ,WAAW;AACvC,UAAM,UAAU,MAAM,KAAK,WAAW,IAAI,SAAS;AACnD,WAAO,MAAM,KAAK,aAAa,OAAO,OAAO,OAAO,CAAC;AAAA,EACzD;AAAA,EAEA,aAAa,WAAW,MAA0C;AAC9D,QAAI;AACJ,QAAI;AACA,kBAAY,QAAQ,aAAa,IAAI;AAAA,IACzC,SAAS,GAAG;AACR,UAAI,aAAa,mBAAmB;AAEhC;AAAA,MACJ;AACA,YAAM;AAAA,IACV;AAEA,UAAM,UAAU,MAAM,KAAK,WAAW,SAAS;AAE/C,UAAM,UAAU,IAAI,QAAQ,EAAE,KAAW,CAAC;AAC1C,UAAM,WAAW,QAAQ,QAAQ,KAAK,IAAI;AAC1C,QAAI,CAAC,UAAU;AAEX;AAAA,IACJ;AAEA,UAAM,QAAQ,oBAAI,IAAgB;AAClC,aAAS,QAAQ,MAAkB;AAC/B,UAAI,MAAM,IAAI,IAAI,GAAG;AACjB;AAAA,MACJ;AACA,YAAM,IAAI,IAAI;AACd,iBAAW,cAAc,KAAK,cAAc;AACxC,gBAAQ,UAAU;AAAA,MACtB;AAAA,IACJ;AAEA,YAAQ,QAAQ;AAEhB,WAAO,MAAM,KAAK,aAAa,CAAC,GAAG,KAAK,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA,EAIA,MAAM,MAAM,SAAkB,cAAc,MAAM;AAC9C,UAAM,UAAU,IAAI,IAAI,KAAK,KAAK;AAGlC,eAAW,QAAQ,KAAK,OAAO;AAC3B,YAAM,QAAQ,UAAU,KAAK,OAAO;AAAA,IACxC;AAEA,WAAO,QAAQ,MAAM;AACjB,UAAI;AAEJ,YAAO,MAAK,QAAQ,SAAS;AACzB,mBAAW,OAAO,KAAK,cAAc;AACjC,cAAI,IAAI,SAAS;AACb,qBAAS;AAAA,UACb;AAAA,QACJ;AACA;AAAA,MACJ;AAEA,UAAI,CAAC,MAAM;AACP,cAAM,IAAI,MAAM,uEAAuE;AAAA,MAC3F;AAEA,UAAI,KAAK,WAAW,QAAQ,eAAe;AACvC,cAAM,QAAQ,MAAM,KAAK,OAAO;AAChC,aAAK,KAAK,aAAY,oBAAI,KAAK,GAAE,YAAY;AAAA,MACjD,WAAW,aAAa;AACpB,YAAI,SAAS,EAAE,KAAK,cAAc,KAAK,GAAG;AAAA,MAC9C;AAEA,cAAQ,OAAO,IAAI;AAAA,IACvB;AAAA,EACJ;AAAA,EAEA,UAAU;AACN,eAAW,QAAQ,KAAK,OAAO;AAC3B,YAAM,WAAW,KAAK,IAAI,MAAM,MAAM;AACtC,eAAS,KAAK,QAAQ,KAAK,IAAI,IAAI;AACnC,eAAS,KAAK,YAAY,WAAW,KAAK,UAAU,CAAC;AACrD,eAAS,KAAK,SAAS,WAAW,KAAK,KAAK,aAAa,CAAC,CAAC;AAC3D,eAAS,KAAK,SAAS,KAAK,UAAU,OAAO,IAAI,IAAI,KAAK,IAAI,OAAO,IAAI,MAAM,IAAI,CAAC;AACpF,eAAS,KAAK,gBAAgB,KAAK,aAAa,IAAI,SAAS,EAAE,KAAK,IAAI,CAAC;AACzE,eAAS,SAAS;AAAA,IACtB;AAAA,EACJ;AAAA,EAEA,aAAa,aAAa,OAAqB;AAC3C,UAAM,QAAQ,IAAI,MAAM,KAAK;AAE7B,UAAM,QAAQ;AAAA,MACV,MAAM,MAAM,IAAI,OAAM,SAAQ;AAC1B,YAAI,KAAK,IAAI,QAAQ,mBAAmB,GAAG;AACvC,eAAK,OAAO,MAAM,KAAK,IAAI,SAAS,mBAAmB;AAAA,QAC3D;AAEA,aAAK,aAAa,MAAM,KAAK,IAAI,aAAa,gBAAgB,OAAO,MAAM;AAE3E,eAAO;AAAA,MACX,CAAC;AAAA,IACL;AAEA,UAAM,QAAQ,MAAkB;AAChC,aAAS,aAAa,MAAkB;AACpC,UAAI,MAAM,QAAQ,IAAI,MAAM,IAAI;AAC5B,cAAM,KAAK,IAAI;AACf,cAAM,IAAI,mBAAmB,wBAAwB,MAAM,IAAI,SAAS,EAAE,KAAK,UAAK,CAAC,EAAE;AAAA,MAC3F;AACA,YAAM,KAAK,IAAI;AACf,iBAAW,OAAO,KAAK,cAAc;AACjC,qBAAa,GAAG;AAAA,MACpB;AACA,YAAM,IAAI;AAAA,IACd;AACA,eAAW,QAAQ,MAAM,OAAO;AAC5B,mBAAa,IAAI;AAAA,IACrB;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,aAAa,WAAW,WAAoB;AACxC,UAAM,aAAa,MAAM,cAAc,EAAE,KAAK,UAAU,MAAM,KAAK,UAAU,KAAK,CAAC;AAEnF,UAAM,UAAU,CAAC;AACjB,UAAM,UAAU,CAAC;AACjB,eAAW,QAAQ,WAAW,OAAO,GAAG;AACpC,YAAM,MAAM,IAAI,QAAQ,EAAE,KAAW,CAAC;AACtC,cAAQ,IAAI,KAAK,IAAI,IAAI,IAAI;AAC7B,cAAQ,IAAI,KAAK,IAAI,IAAI;AAAA,QACrB;AAAA,QACA,SAAS,IAAI,QAAQ,GAAG;AAAA,QACxB,cAAc,CAAC;AAAA,QACf,MAAM,CAAC;AAAA,QACP,YAAY;AAAA,QAEZ,IAAI,YAAY;AACZ,iBAAO,KAAK,KAAK,YAAY,IAAI,KAAK,KAAK,KAAK,SAAS,EAAE,QAAQ,IAAI;AAAA,QAC3E;AAAA,QAEA,IAAI,UAAU;AACV,iBACI,KAAK,aAAa,KAAK,aACvB,CAAC,CAAC,KAAK,aAAa;AAAA,YAChB,SACI,IAAI,WACH,IAAI,YAAY,KAAK,cACjB,IAAI,KAAK,WAAW,UACjB,IAAI,KAAK,WAAW,KAAK,KAAK,oBAAoB,IAAI,IAAI,IAAI;AAAA,UAC9E;AAAA,QAER;AAAA;AAAA;AAAA;AAAA,QAKA,IAAI,gBAAgB;AAChB,cAAI,KAAK,aAAa,KAAK,WAAW;AAClC,mBAAO;AAAA,UACX;AACA,gBAAM,UAAU,KAAK,KAAK;AAC1B,cAAI,OAAO,YAAY,UAAU;AAC7B,mBAAO,KAAK;AAAA,UAChB;AACA,qBAAW,OAAO,KAAK,cAAc;AACjC,kBAAM,SAAS,QAAQ,IAAI,IAAI,IAAI;AACnC,gBAAI,WAAW,UAAa,WAAW,IAAI,KAAK,QAAQ;AACpD,qBAAO;AAAA,YACX;AAAA,UACJ;AACA,iBAAO;AAAA,QACX;AAAA,MACJ;AAAA,IACJ;AAEA,eAAW,QAAQ,SAAS;AACxB,iBAAW,OAAO,QAAQ,IAAI,GAAG;AAC7B,cAAM,UAAU,QAAQ,GAAG;AAG3B,YAAI,WAAW,YAAY,QAAQ,IAAI,GAAG;AACtC,kBAAQ,IAAI,EAAE,aAAa,KAAK,OAAO;AAAA,QAC3C;AAAA,MACJ;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AACJ;AAeA,SAAS,WAAW,MAAuB;AACvC,MAAI,CAAC,MAAM;AACP,WAAO,OAAO,IAAI,IAAI,OAAO;AAAA,EACjC;AACA,MAAI,OAAO,SAAS,UAAU;AAC1B,WAAO,IAAI,KAAK,IAAI,EAAE,QAAQ;AAAA,EAClC;AACA,SAAO,IAAI,KAAK,QAAO,oBAAI,KAAK,GAAE,kBAAkB,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,EAAE,QAAQ,KAAK,GAAG;AACvG;AAEA,SAAS,UAAU,MAAkB;AACjC,SAAO,KAAK,IAAI,KAAK,QAAQ,mCAAmC,EAAE;AACtE;",
  "names": ["node"]
}


package/dist/esm/building/graph.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/building/graph.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,OAAO,mBAAmB;AAC1B,OAAO,YAAY;AACnB,SAAS,mBAAmB,eAAe;AAC3C,SAAS,gBAAgB;AAEzB,SAAS,0BAA0B;AACnC,SAAS,qBAAuC,eAAe;AAQxD,MAAM,MAAM;AAAA,EACL,YAAqB,OAAqB;AAArB;AAAA,EAAsB;AAAA,EAErD,IAAI,MAAc;AACd,UAAM,OAAO,KAAK,MAAM,KAAK,CAAAA,UAAQA,MAAK,IAAI,SAAS,IAAI;AAC3D,QAAI,SAAS,QAAW;AACpB,YAAM,IAAI,MAAM,0BAA0B,IAAI,GAAG;AAAA,IACrD;AACA,WAAO;AAAA,EACX;AAAA,EAEA,aAAa,KAAK,MAAM,QAAQ,WAAW;AACvC,UAAM,UAAU,MAAM,KAAK,WAAW,IAAI,SAAS;AACnD,WAAO,MAAM,KAAK,aAAa,OAAO,OAAO,OAAO,CAAC;AAAA,EACzD;AAAA,EAEA,aAAa,WAAW,MAA0C;AAC9D,QAAI;AACJ,QAAI;AACA,kBAAY,QAAQ,aAAa,IAAI;AAAA,IACzC,SAAS,GAAG;AACR,UAAI,aAAa,mBAAmB;AAEhC;AAAA,MACJ;AACA,YAAM;AAAA,IACV;AAEA,UAAM,UAAU,MAAM,KAAK,WAAW,SAAS;AAE/C,UAAM,UAAU,IAAI,QAAQ,EAAE,KAAW,CAAC;AAC1C,UAAM,WAAW,QAAQ,QAAQ,KAAK,IAAI;AAC1C,QAAI,CAAC,UAAU;AAEX;AAAA,IACJ;AAEA,UAAM,QAAQ,oBAAI,IAAgB;AAClC,aAAS,QAAQ,MAAkB;AAC/B,UAAI,MAAM,IAAI,IAAI,GAAG;AACjB;AAAA,MACJ;AACA,YAAM,IAAI,IAAI;AACd,iBAAW,cAAc,KAAK,cAAc;AACxC,gBAAQ,UAAU;AAAA,MACtB;AAAA,IACJ;AAEA,YAAQ,QAAQ;AAEhB,WAAO,MAAM,KAAK,aAAa,CAAC,GAAG,KAAK,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA,EAIA,MAAM,MAAM,SAAkB,cAAc,MAAM;AAC9C,UAAM,UAAU,IAAI,IAAI,KAAK,KAAK;AAGlC,eAAW,QAAQ,KAAK,OAAO;AAC3B,YAAM,QAAQ,UAAU,KAAK,OAAO;AAAA,IACxC;AAEA,WAAO,QAAQ,MAAM;AACjB,UAAI;AAEJ,YAAO,MAAK,QAAQ,SAAS;AACzB,mBAAW,OAAO,KAAK,cAAc;AACjC,cAAI,IAAI,SAAS;AACb,qBAAS;AAAA,UACb;AAAA,QACJ;AACA;AAAA,MACJ;AAEA,UAAI,CAAC,MAAM;AACP,cAAM,IAAI,MAAM,uEAAuE;AAAA,MAC3F;AAEA,UAAI,KAAK,WAAW,QAAQ,eAAe;AACvC,cAAM,QAAQ,MAAM,KAAK,OAAO;AAChC,aAAK,KAAK,aAAY,oBAAI,KAAK,GAAE,YAAY;AAAA,MACjD,WAAW,aAAa;AACpB,YAAI,SAAS,EAAE,KAAK,cAAc,KAAK,GAAG;AAAA,MAC9C;AAEA,cAAQ,OAAO,IAAI;AAAA,IACvB;AAAA,EACJ;AAAA,EAEA,UAAU;AACN,eAAW,QAAQ,KAAK,OAAO;AAC3B,YAAM,WAAW,KAAK,IAAI,MAAM,MAAM;AACtC,eAAS,KAAK,QAAQ,KAAK,IAAI,IAAI;AACnC,eAAS,KAAK,YAAY,WAAW,KAAK,UAAU,CAAC;AACrD,eAAS,KAAK,SAAS,WAAW,KAAK,KAAK,aAAa,CAAC,CAAC;AAC3D,eAAS,KAAK,SAAS,KAAK,UAAU,OAAO,IAAI,IAAI,KAAK,IAAI,OAAO,IAAI,MAAM,IAAI,CAAC;AACpF,eAAS,KAAK,gBAAgB,KAAK,aAAa,IAAI,SAAS,EAAE,KAAK,IAAI,CAAC;AACzE,eAAS,SAAS;AAAA,IACtB;AAAA,EACJ;AAAA,EAEA,aAAa,aAAa,OAAqB;AAC3C,UAAM,QAAQ,IAAI,MAAM,KAAK;AAE7B,UAAM,QAAQ;AAAA,MACV,MAAM,MAAM,IAAI,OAAM,SAAQ;AAC1B,YAAI,KAAK,IAAI,QAAQ,mBAAmB,GAAG;AACvC,eAAK,OAAO,MAAM,KAAK,IAAI,SAAS,mBAAmB;AAAA,QAC3D;AAEA,aAAK,aAAa,MAAM,KAAK,IAAI,aAAa,gBAAgB,OAAO,MAAM;AAE3E,eAAO;AAAA,MACX,CAAC;AAAA,IACL;AAEA,UAAM,QAAQ,MAAkB;AAChC,aAAS,aAAa,MAAkB;AACpC,UAAI,MAAM,QAAQ,IAAI,MAAM,IAAI;AAC5B,cAAM,KAAK,IAAI;AACf,cAAM,IAAI,mBAAmB,wBAAwB,MAAM,IAAI,SAAS,EAAE,KAAK,UAAK,CAAC,EAAE;AAAA,MAC3F;AACA,YAAM,KAAK,IAAI;AACf,iBAAW,OAAO,KAAK,cAAc;AACjC,qBAAa,GAAG;AAAA,MACpB;AACA,YAAM,IAAI;AAAA,IACd;AACA,eAAW,QAAQ,MAAM,OAAO;AAC5B,mBAAa,IAAI;AAAA,IACrB;AAEA,WAAO;AAAA,EACX;AAAA,EAEA,aAAa,WAAW,WAAoB;AACxC,UAAM,aAAa,MAAM,cAAc,EAAE,KAAK,UAAU,MAAM,KAAK,UAAU,KAAK,CAAC;AAEnF,UAAM,UAAU,CAAC;AACjB,UAAM,UAAU,CAAC;AACjB,eAAW,QAAQ,WAAW,OAAO,GAAG;AACpC,YAAM,MAAM,IAAI,QAAQ,EAAE,KAAW,CAAC;AACtC,cAAQ,IAAI,KAAK,IAAI,IAAI,IAAI;AAC7B,cAAQ,IAAI,KAAK,IAAI,IAAI;AAAA,QACrB;AAAA,QACA,SAAS,IAAI,QAAQ,GAAG;AAAA,QACxB,cAAc,CAAC;AAAA,QACf,MAAM,CAAC;AAAA,QACP,YAAY;AAAA,QAEZ,IAAI,YAAY;AACZ,iBAAO,KAAK,KAAK,YAAY,IAAI,KAAK,KAAK,KAAK,SAAS,EAAE,QAAQ,IAAI;AAAA,QAC3E;AAAA,QAEA,IAAI,UAAU;AACV,iBACI,KAAK,aAAa,KAAK,aACvB,CAAC,CAAC,KAAK,aAAa;AAAA,YAChB,SACI,IAAI,WACH,IAAI,YAAY,KAAK,cACjB,IAAI,KAAK,WAAW,UACjB,IAAI,KAAK,WAAW,KAAK,KAAK,oBAAoB,IAAI,IAAI,IAAI;AAAA,UAC9E;AAAA,QAER;AAAA;AAAA;AAAA;AAAA,QAKA,IAAI,gBAAgB;AAChB,cAAI,KAAK,aAAa,KAAK,WAAW;AAClC,mBAAO;AAAA,UACX;AACA,gBAAM,UAAU,KAAK,KAAK;AAC1B,cAAI,OAAO,YAAY,UAAU;AAC7B,mBAAO,KAAK;AAAA,UAChB;AACA,qBAAW,OAAO,KAAK,cAAc;AACjC,kBAAM,SAAS,QAAQ,IAAI,IAAI,IAAI;AACnC,gBAAI,WAAW,UAAa,WAAW,IAAI,KAAK,QAAQ;AACpD,qBAAO;AAAA,YACX;AAAA,UACJ;AACA,iBAAO;AAAA,QACX;AAAA,MACJ;AAAA,IACJ;AAEA,eAAW,QAAQ,SAAS;AACxB,iBAAW,OAAO,QAAQ,IAAI,GAAG;AAC7B,cAAM,UAAU,QAAQ,GAAG;AAG3B,YAAI,WAAW,YAAY,QAAQ,IAAI,GAAG;AACtC,kBAAQ,IAAI,EAAE,aAAa,KAAK,OAAO;AAAA,QAC3C;AAAA,MACJ;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AACJ;AAeA,SAAS,WAAW,MAAuB;AACvC,MAAI,CAAC,MAAM;AACP,WAAO,OAAO,IAAI,IAAI,OAAO;AAAA,EACjC;AACA,MAAI,OAAO,SAAS,UAAU;AAC1B,WAAO,IAAI,KAAK,IAAI,EAAE,QAAQ;AAAA,EAClC;AACA,SAAO,IAAI,KAAK,QAAO,oBAAI,KAAK,GAAE,kBAAkB,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,EAAE,QAAQ,KAAK,GAAG;AACvG;AAEA,SAAS,UAAU,MAAkB;AACjC,SAAO,KAAK,IAAI,KAAK,QAAQ,mCAAmC,EAAE;AACtE;",
+  "names": ["node"]
+}

package/dist/esm/building/project.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Hash } from "crypto";
+import { Format } from "esbuild";
+import { Package } from "../util/package.js";
+import { Progress } from "../util/progress.js";
+export declare const BUILD_INFO_LOCATION = "build/info.json";
+export interface BuildInformation {
+    /**
+     * Time of last build.  Compared to source files to determine whether build is dirty.
+     */
+    timestamp?: string;
+    /**
+     * API signature.  Used by dependents to determine whether they need to rebuild after we do.
+     */
+    apiSha?: string;
+    /**
+     * API signature of each dependency.  Compared to apiSha of each dependency during dirty detection.
+     */
+    dependencyApiShas?: Record<string, string>;
+}
+export declare class Project {
+    #private;
+    pkg: Package;
+    constructor(source?: Package | string);
+    buildSource(format: Format): Promise<void>;
+    buildTests(format: Format): Promise<void>;
+    clean(): Promise<void>;
+    /**
+     * Installs declaration files into specified directory.  Also computes SHA-1 hash for all files that we use to
+     * detect "public API changes".
+     *
+     * Note we use cp to traverse filesystem, detect changes, locate source maps and compute API SHA.  A little
+     * convoluted but works.  When you correct for a node 20/windows bug.
+     */
+    installDeclarationFormats(formats: Iterable<string>, apiSha?: Hash): Promise<void>;
+    get hasDeclarations(): boolean;
+    installDeclarations(apiSha?: Hash): Promise<void>;
+    recordBuildInfo(info: BuildInformation): Promise<void>;
+    configure(progress: Progress): Promise<Project.Config | undefined>;
+}
+export declare namespace Project {
+    interface Context {
+        project: Project;
+        progress: Progress;
+    }
+    interface Config {
+        startup?: (context: Context) => Promise<void>;
+        before?: (context: Context) => Promise<void>;
+        after?: (context: Context) => Promise<void>;
+    }
+}
+//# sourceMappingURL=project.d.ts.map

package/dist/esm/building/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/building/project.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAoB,MAAM,EAAE,MAAM,SAAS,CAAC;AAMnD,OAAO,EAAe,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE/C,eAAO,MAAM,mBAAmB,oBAAoB,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C;AAED,qBAAa,OAAO;;IAChB,GAAG,EAAE,OAAO,CAAC;gBAID,MAAM,GAAE,OAAO,GAAG,MAAY;IAYpC,WAAW,CAAC,MAAM,EAAE,MAAM;IAK1B,UAAU,CAAC,MAAM,EAAE,MAAM;IA2BzB,KAAK;IAMX;;;;;;OAMG;IACG,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,IAAI;IAsFxE,IAAI,eAAe,YAElB;IAEK,mBAAmB,CAAC,MAAM,CAAC,EAAE,IAAI;IAYjC,eAAe,CAAC,IAAI,EAAE,gBAAgB;IAMtC,SAAS,CAAC,QAAQ,EAAE,QAAQ;CA8FrC;AAED,yBAAiB,OAAO,CAAC;IACrB,UAAiB,OAAO;QACpB,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,QAAQ,CAAC;KACtB;IAED,UAAiB,MAAM;QACnB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7C,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KAC/C;CACJ"}

package/dist/esm/building/project.js

@@ -0,0 +1,219 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { build as esbuild } from "esbuild";
+import { cp, mkdir, readFile, rm, stat, symlink, writeFile } from "fs/promises";
+import { glob } from "glob";
+import { platform } from "os";
+import { dirname, join, relative } from "path";
+import { ignoreError } from "../util/errors.js";
+import { CONFIG_PATH, Package } from "../util/package.js";
+const BUILD_INFO_LOCATION = "build/info.json";
+class Project {
+  pkg;
+  #config;
+  #configured;
+  constructor(source = ".") {
+    if (typeof source === "string") {
+      this.pkg = new Package({ path: source });
+    } else {
+      this.pkg = source;
+    }
+    if (!this.pkg.hasSrc) {
+      throw new Error(`Found package ${this.pkg.json.name} but no src directory is present`);
+    }
+  }
+  async buildSource(format) {
+    await this.#build(format, "src", `dist/${format}`);
+    await this.#configureFormat("dist", format, true);
+  }
+  async buildTests(format) {
+    if (this.pkg.hasDirectory("test")) {
+      await this.#build(format, "test", `build/${format}/test`);
+    }
+    const src = `dist/${format}`;
+    const dest = `build/${format}/src`;
+    try {
+      const destPath = this.pkg.resolve(dest);
+      await mkdir(dirname(destPath), { recursive: true });
+      await ignoreError("EEXIST", async () => await symlink(this.pkg.resolve(src), destPath));
+    } catch (e) {
+      if (e.code === "EPERM" && platform() === "win32") {
+        await cp(this.pkg.resolve(src), this.pkg.resolve(dest), {
+          recursive: true,
+          force: true
+        });
+      } else {
+        throw e;
+      }
+    }
+    await this.#configureFormat("build", format, false);
+  }
+  async clean() {
+    for (const dir of ["build", "dist"]) {
+      await rm(this.pkg.resolve(dir), { recursive: true, force: true });
+    }
+  }
+  /**
+   * Installs declaration files into specified directory.  Also computes SHA-1 hash for all files that we use to
+   * detect "public API changes".
+   *
+   * Note we use cp to traverse filesystem, detect changes, locate source maps and compute API SHA.  A little
+   * convoluted but works.  When you correct for a node 20/windows bug.
+   */
+  async installDeclarationFormats(formats, apiSha) {
+    const srcMaps = Array();
+    let firstPass = true;
+    const src = this.pkg.resolve("build/types/src");
+    for (const format of formats) {
+      await cp(src, this.pkg.resolve(`dist/${format}`), {
+        recursive: true,
+        force: true,
+        filter: async (source, destination) => {
+          const sourceStat = await stat(source);
+          if (!sourceStat.isFile()) {
+            return true;
+          }
+          const destinationMtime = (await ignoreError("ENOENT", () => stat(destination)))?.mtimeMs;
+          if (destinationMtime !== void 0) {
+            const sourceMtime = sourceStat.mtimeMs;
+            if (destinationMtime >= sourceMtime) {
+              return false;
+            }
+          }
+          if (source.endsWith(".d.ts.map")) {
+            if (firstPass) {
+              if (source.startsWith("\\\\?\\")) {
+                source = source.slice(4);
+              }
+              srcMaps.push(source);
+            }
+            return false;
+          }
+          if (apiSha) {
+            apiSha.update(await readFile(source));
+          }
+          return true;
+        }
+      });
+      firstPass = false;
+    }
+    for (const filename of srcMaps) {
+      let map = await readFile(filename);
+      let pos = map.indexOf('"sources":["../');
+      if (pos === -1) {
+        throw new Error(
+          `Could not find sources position in declaration map ${filename}, format may have changed`
+        );
+      }
+      pos += 12;
+      map = map.copyWithin(pos, pos + 3).subarray(0, map.length - 3);
+      const pathRelativeToDest = relative(src, filename);
+      for (const format of formats) {
+        await writeFile(join(join(this.pkg.resolve(`dist/${format}`), pathRelativeToDest)), map);
+      }
+    }
+  }
+  get hasDeclarations() {
+    return this.pkg.hasDirectory("build/types");
+  }
+  async installDeclarations(apiSha) {
+    await mkdir(this.pkg.resolve("dist"), { recursive: true });
+    const formats = /* @__PURE__ */ new Set();
+    if (this.pkg.supportsEsm) {
+      formats.add("esm");
+    }
+    if (this.pkg.supportsCjs) {
+      formats.add("cjs");
+    }
+    await this.installDeclarationFormats(formats, apiSha);
+  }
+  async recordBuildInfo(info) {
+    await mkdir(this.pkg.resolve("build"), { recursive: true });
+    info.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    await writeFile(this.pkg.resolve(BUILD_INFO_LOCATION), JSON.stringify(info, void 0, 4));
+  }
+  async configure(progress) {
+    if (this.#configured) {
+      return this.#config;
+    }
+    if (!this.pkg.hasConfig) {
+      return {};
+    }
+    const configPath = this.pkg.resolve(CONFIG_PATH);
+    const outfile = configPath.replace(/\\/g, "/").replace("/src/", "/build/").replace(/\.ts$/, ".js");
+    await esbuild({
+      entryPoints: [configPath],
+      outfile,
+      sourcemap: true
+    });
+    this.#config = await import(`file://${outfile}`);
+    this.#configured = true;
+    if (this.#config?.startup) {
+      await this.#config?.startup({
+        project: this,
+        progress
+      });
+    }
+    return this.#config;
+  }
+  async #build(format, indir, outdir) {
+    const entryPoints = await this.#targetsOf(indir, outdir, "ts", "js");
+    const configPath = this.pkg.resolve(CONFIG_PATH);
+    for (const entry of entryPoints) {
+      if (entry.in === configPath) {
+        continue;
+      }
+      entry.out = entry.out.replace(/\.[jt]s$/, "");
+    }
+    await esbuild({
+      entryPoints,
+      outdir: this.pkg.path,
+      format,
+      sourcemap: true,
+      sourcesContent: false,
+      absWorkingDir: dirname(this.pkg.resolve(indir)),
+      // This is necessary to downlevel "using"
+      target: "es2022",
+      logOverride: {
+        "direct-eval": "silent"
+      }
+    });
+    for (const entry of await this.#targetsOf(indir, outdir, "cjs", "mjs", "d.cts", "d.mts")) {
+      await cp(entry.in, entry.out);
+    }
+  }
+  async #configureFormat(dir, format, isDist) {
+    let { imports } = this.pkg.json;
+    if (isDist && typeof imports === "object") {
+      imports = { ...imports };
+      for (const key in imports) {
+        const value = imports[key];
+        if (typeof value === "string") {
+          imports[key] = value.replace(/^\.\/src\//, "./");
+        }
+      }
+    }
+    const path = this.pkg.resolve(`${dir}/${format}/package.json`);
+    const json = {
+      type: format === "cjs" ? "commonjs" : "module",
+      imports
+    };
+    await writeFile(path, JSON.stringify(json, void 0, 4));
+  }
+  async #targetsOf(indir, outdir, ...extensions) {
+    indir = this.pkg.resolve(indir).replace(/\\/g, "/");
+    outdir = this.pkg.resolve(outdir).replace(/\\/g, "/");
+    return (await glob(extensions.map((ext) => `${indir}/**/*.${ext}`))).map((file) => ({
+      in: file,
+      out: `${outdir}/${file.slice(indir.length + 1)}`
+    }));
+  }
+}
+export {
+  BUILD_INFO_LOCATION,
+  Project
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/building/project.ts"],
  "sourcesContent": ["/**\n * @license\n * Copyright 2022-2024 Matter.js Authors\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { Hash } from \"crypto\";\nimport { build as esbuild, Format } from \"esbuild\";\nimport { cp, mkdir, readFile, rm, stat, symlink, writeFile } from \"fs/promises\";\nimport { glob } from \"glob\";\nimport { platform } from \"os\";\nimport { dirname, join, relative } from \"path\";\nimport { ignoreError } from \"../util/errors.js\";\nimport { CONFIG_PATH, Package } from \"../util/package.js\";\nimport { Progress } from \"../util/progress.js\";\n\nexport const BUILD_INFO_LOCATION = \"build/info.json\";\n\nexport interface BuildInformation {\n    /**\n     * Time of last build.  Compared to source files to determine whether build is dirty.\n     */\n    timestamp?: string;\n\n    /**\n     * API signature.  Used by dependents to determine whether they need to rebuild after we do.\n     */\n    apiSha?: string;\n\n    /**\n     * API signature of each dependency.  Compared to apiSha of each dependency during dirty detection.\n     */\n    dependencyApiShas?: Record<string, string>;\n}\n\nexport class Project {\n    pkg: Package;\n    #config?: Project.Config;\n    #configured?: boolean;\n\n    constructor(source: Package | string = \".\") {\n        if (typeof source === \"string\") {\n            this.pkg = new Package({ path: source });\n        } else {\n            this.pkg = source;\n        }\n\n        if (!this.pkg.hasSrc) {\n            throw new Error(`Found package ${this.pkg.json.name} but no src directory is present`);\n        }\n    }\n\n    async buildSource(format: Format) {\n        await this.#build(format, \"src\", `dist/${format}`);\n        await this.#configureFormat(\"dist\", format, true);\n    }\n\n    async buildTests(format: Format) {\n        if (this.pkg.hasDirectory(\"test\")) {\n            await this.#build(format, \"test\", `build/${format}/test`);\n        }\n\n        const src = `dist/${format}`;\n        const dest = `build/${format}/src`;\n\n        try {\n            const destPath = this.pkg.resolve(dest);\n            await mkdir(dirname(destPath), { recursive: true });\n            await ignoreError(\"EEXIST\", async () => await symlink(this.pkg.resolve(src), destPath));\n        } catch (e) {\n            if ((e as any).code === \"EPERM\" && platform() === \"win32\") {\n                // If developer mode is not enabled, we can't create a symlink\n                // on Windows.  Copy instead\n                await cp(this.pkg.resolve(src), this.pkg.resolve(dest), {\n                    recursive: true,\n                    force: true,\n                });\n            } else {\n                throw e;\n            }\n        }\n        await this.#configureFormat(\"build\", format, false);\n    }\n\n    async clean() {\n        for (const dir of [\"build\", \"dist\"]) {\n            await rm(this.pkg.resolve(dir), { recursive: true, force: true });\n        }\n    }\n\n    /**\n     * Installs declaration files into specified directory.  Also computes SHA-1 hash for all files that we use to\n     * detect \"public API changes\".\n     *\n     * Note we use cp to traverse filesystem, detect changes, locate source maps and compute API SHA.  A little\n     * convoluted but works.  When you correct for a node 20/windows bug.\n     */\n    async installDeclarationFormats(formats: Iterable<string>, apiSha?: Hash) {\n        const srcMaps = Array<string>();\n        let firstPass = true;\n\n        const src = this.pkg.resolve(\"build/types/src\");\n\n        for (const format of formats) {\n            await cp(src, this.pkg.resolve(`dist/${format}`), {\n                recursive: true,\n                force: true,\n\n                filter: async (source, destination) => {\n                    const sourceStat = await stat(source);\n                    if (!sourceStat.isFile()) {\n                        return true;\n                    }\n\n                    // Ignore files that are unchanged\n                    const destinationMtime = (await ignoreError(\"ENOENT\", () => stat(destination)))?.mtimeMs;\n                    if (destinationMtime !== undefined) {\n                        const sourceMtime = sourceStat.mtimeMs;\n                        if (destinationMtime >= sourceMtime) {\n                            return false;\n                        }\n                    }\n\n                    // We process source maps below\n                    if (source.endsWith(\".d.ts.map\")) {\n                        if (firstPass) {\n                            if (source.startsWith(\"\\\\\\\\?\\\\\")) {\n                                // Node 20 prefixes the path with above on Windows and relative() can't handle it;\n                                // just strip off\n                                source = source.slice(4);\n                            }\n                            srcMaps.push(source);\n                        }\n                        return false;\n                    }\n\n                    // Update hash if provided\n                    if (apiSha) {\n                        apiSha.update(await readFile(source));\n                    }\n\n                    return true;\n                },\n            });\n\n            // Only need to collect source maps and update hash on first pass\n            firstPass = false;\n        }\n\n        // If you specify --sourceRoot, tsc just sticks whatever the string is directly into the file.  Not very useful\n        // unless you have no hierarchy or use absolute paths...\n        //\n        // We distribute types for src one level higher than we generate them (dist/esm vs build/types/src) so the paths\n        // end up incorrect.\n        //\n        // So...  Rewrite the paths in all source maps under src/.  Do this directly on buffer for marginal performance\n        // win.\n        for (const filename of srcMaps) {\n            // Load map as binary\n            let map = await readFile(filename);\n\n            // Find key text\n            let pos = map.indexOf('\"sources\":[\"../');\n            if (pos === -1) {\n                throw new Error(\n                    `Could not find sources position in declaration map ${filename}, format may have changed`,\n                );\n            }\n\n            // move to ../\n            pos += 12;\n\n            // Shift everything left by three\n            map = map.copyWithin(pos, pos + 3).subarray(0, map.length - 3);\n\n            // Write to new locations\n            const pathRelativeToDest = relative(src, filename);\n            for (const format of formats) {\n                await writeFile(join(join(this.pkg.resolve(`dist/${format}`), pathRelativeToDest)), map);\n            }\n        }\n    }\n\n    get hasDeclarations() {\n        return this.pkg.hasDirectory(\"build/types\");\n    }\n\n    async installDeclarations(apiSha?: Hash) {\n        await mkdir(this.pkg.resolve(\"dist\"), { recursive: true });\n        const formats = new Set<string>();\n        if (this.pkg.supportsEsm) {\n            formats.add(\"esm\");\n        }\n        if (this.pkg.supportsCjs) {\n            formats.add(\"cjs\");\n        }\n        await this.installDeclarationFormats(formats, apiSha);\n    }\n\n    async recordBuildInfo(info: BuildInformation) {\n        await mkdir(this.pkg.resolve(\"build\"), { recursive: true });\n        info.timestamp = new Date().toISOString();\n        await writeFile(this.pkg.resolve(BUILD_INFO_LOCATION), JSON.stringify(info, undefined, 4));\n    }\n\n    async configure(progress: Progress) {\n        if (this.#configured) {\n            return this.#config;\n        }\n\n        if (!this.pkg.hasConfig) {\n            return {};\n        }\n\n        const configPath = this.pkg.resolve(CONFIG_PATH);\n\n        const outfile = configPath.replace(/\\\\/g, \"/\").replace(\"/src/\", \"/build/\").replace(/\\.ts$/, \".js\");\n        await esbuild({\n            entryPoints: [configPath],\n            outfile,\n            sourcemap: true,\n        });\n\n        this.#config = (await import(`file://${outfile}`)) as Project.Config | undefined;\n        this.#configured = true;\n\n        if (this.#config?.startup) {\n            await this.#config?.startup({\n                project: this,\n                progress,\n            });\n        }\n\n        return this.#config;\n    }\n\n    async #build(format: Format, indir: string, outdir: string) {\n        const entryPoints = await this.#targetsOf(indir, outdir, \"ts\", \"js\");\n\n        const configPath = this.pkg.resolve(CONFIG_PATH);\n        for (const entry of entryPoints) {\n            if (entry.in === configPath) {\n                continue;\n            }\n            entry.out = entry.out.replace(/\\.[jt]s$/, \"\");\n        }\n\n        await esbuild({\n            entryPoints,\n            outdir: this.pkg.path,\n            format,\n            sourcemap: true,\n            sourcesContent: false,\n            absWorkingDir: dirname(this.pkg.resolve(indir)),\n\n            // This is necessary to downlevel \"using\"\n            target: \"es2022\",\n\n            logOverride: {\n                \"direct-eval\": \"silent\",\n            },\n        });\n\n        for (const entry of await this.#targetsOf(indir, outdir, \"cjs\", \"mjs\", \"d.cts\", \"d.mts\")) {\n            await cp(entry.in, entry.out);\n        }\n    }\n\n    async #configureFormat(dir: string, format: Format, isDist: boolean) {\n        // Build import map\n        let { imports } = this.pkg.json;\n        if (isDist && typeof imports === \"object\") {\n            imports = { ...imports };\n            for (const key in imports) {\n                const value = imports[key];\n                if (typeof value === \"string\") {\n                    imports[key] = value.replace(/^\\.\\/src\\//, \"./\");\n                }\n            }\n        }\n\n        // Write package.json\n        const path = this.pkg.resolve(`${dir}/${format}/package.json`);\n        const json: Record<string, unknown> = {\n            type: format === \"cjs\" ? \"commonjs\" : \"module\",\n            imports,\n        };\n        await writeFile(path, JSON.stringify(json, undefined, 4));\n    }\n\n    async #targetsOf(indir: string, outdir: string, ...extensions: string[]) {\n        indir = this.pkg.resolve(indir).replace(/\\\\/g, \"/\");\n        outdir = this.pkg.resolve(outdir).replace(/\\\\/g, \"/\");\n\n        return (await glob(extensions.map(ext => `${indir}/**/*.${ext}`))).map(file => ({\n            in: file,\n            out: `${outdir}/${file.slice(indir.length + 1)}`,\n        }));\n    }\n}\n\nexport namespace Project {\n    export interface Context {\n        project: Project;\n        progress: Progress;\n    }\n\n    export interface Config {\n        startup?: (context: Context) => Promise<void>;\n        before?: (context: Context) => Promise<void>;\n        after?: (context: Context) => Promise<void>;\n    }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/esm/building/project.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/building/project.ts"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/building/tsconfig.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Graph } from "./graph.js";
+/**
+ * Unfortunately typescript's "project references" are redundant with package.json dependencies.  We don't use them for
+ * build but there are still some advantages to maintaining them so we just ensure they're in sync during workspace
+ * builds.
+ *
+ * One discussion on the topic: https://github.com/microsoft/TypeScript/issues/25376
+ */
+export declare function syncAllTsconfigs(graph: Graph): Promise<void>;
+export declare function syncPackageTsconfigs(graph: Graph, node: Graph.Node): Promise<void>;
+//# sourceMappingURL=tsconfig.d.ts.map

package/dist/esm/building/tsconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsconfig.d.ts","sourceRoot":"","sources":["../../../src/building/tsconfig.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,KAAK,iBAelD;AAMD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,iBAGxE"}