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

package/src/versioning/cli.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { Package } from "../util/package.js";
+import { Progress } from "../util/progress.js";
+import { Versioner } from "./versioner.js";
+
+export async function main(argv = process.argv) {
+    const args = await yargs(hideBin(argv))
+        .command("$0 [ver]", "Manipulate monorepo package versions.")
+        .option("prefix", { alias: "p", default: ".", type: "string", describe: "specify monorepo directory" })
+        .option("set", { alias: "s", type: "boolean", describe: "Sets the release version" })
+        .option("apply", { alias: "a", type: "boolean", describe: "Sets package versions to the release version" })
+        .option("tag", { alias: "t", type: "boolean", describe: "Adds git tag for release version" })
+        .wrap(Math.min(process.stdout.columns, 80))
+        .strict().argv;
+
+    const version = args.ver as string | undefined;
+    const pkg = new Package({ path: args.prefix });
+    const versioner = new Versioner(pkg, version);
+
+    const progress = new Progress();
+
+    progress.startup(`Release ${versioner.version}`, versioner.pkg);
+    if (args.set) {
+        await progress.run(`Set version to ${progress.emphasize(versioner.version)}`, () => versioner.set());
+    }
+
+    if (args.apply) {
+        await versioner.apply(progress);
+    }
+
+    if (args.tag) {
+        await progress.run(`Tagging version ${progress.emphasize(versioner.version)}`, () => versioner.tag());
+    }
+
+    progress.shutdown();
+}

package/src/versioning/versioner.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import colors from "ansi-colors";
+import { existsSync, readFileSync } from "fs";
+import { cp, writeFile } from "fs/promises";
+import { Graph } from "../building/graph.js";
+import { execute } from "../running/execute.js";
+import { Package } from "../util/package.js";
+import { Progress } from "../util/progress.js";
+
+const VERSION_FILE = "version.txt";
+
+export class Versioner {
+    #pkg: Package;
+    #version?: string;
+    #members = new Set<string>();
+
+    get pkg() {
+        return this.#pkg;
+    }
+
+    get version() {
+        return this.#version;
+    }
+
+    get appliedVersion() {
+        return this.#pkg.json.version;
+    }
+
+    constructor(pkg: Package, version?: string) {
+        this.#pkg = pkg.workspace;
+
+        if (version === undefined) {
+            version = this.#readVersion();
+        }
+
+        if (version && !version.match(/^(?:\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?|[a-z]+)$/)) {
+            throw new Error(`Version ${version} is invalid (must be semantic or single lowercase word)`);
+        }
+
+        this.#version = version;
+    }
+
+    async set() {
+        await writeFile(this.#versionFile, this.#definiteVersion);
+    }
+
+    async apply(progress?: Progress) {
+        const graph = await Graph.load(this.#pkg);
+        this.#members = new Set(graph.nodes.map(node => node.pkg.name));
+
+        for (const node of graph.nodes) {
+            const what = `Apply ${colors.bold(this.#definiteVersion)} to ${colors.bold(node.pkg.name)}`;
+            progress?.update(what);
+            if (this.#applyOne(node.pkg)) {
+                progress?.success(what);
+                await node.pkg.save();
+            } else {
+                progress?.success(`${what} (no change)`);
+            }
+            await cp(this.#pkg.resolve("LICENSE"), node.pkg.resolve("LICENSE"));
+        }
+    }
+
+    async tag() {
+        await execute("git", ["tag", "-f", `v${this.#definiteVersion}`]);
+    }
+
+    get #definiteVersion() {
+        if (this.#version === undefined) {
+            throw new Error(`No version supplied and ${this.#versionFile} does not exist`);
+        }
+        return this.#version;
+    }
+
+    get #versionFile() {
+        return this.#pkg.resolve(VERSION_FILE);
+    }
+
+    #readVersion() {
+        const versionFile = this.#versionFile;
+        if (!existsSync(versionFile)) {
+            return undefined;
+        }
+
+        const version = readFileSync(versionFile).toString().trim();
+        if (version.length === 0) {
+            throw new Error(`Version file ${versionFile} is empty`);
+        }
+
+        return version;
+    }
+
+    #applyOne(pkg: Package) {
+        const json = pkg.json;
+        let changed = false;
+
+        if (json.version !== this.#definiteVersion) {
+            json.version = this.#definiteVersion;
+            changed = true;
+        }
+
+        for (const key in json) {
+            if (key !== "dependencies" && !key.endsWith("Dependencies")) {
+                continue;
+            }
+
+            const deps = json[key];
+            if (typeof deps !== "object") {
+                continue;
+            }
+
+            if (this.#applyToDeps(deps)) {
+                changed = true;
+            }
+        }
+
+        return changed;
+    }
+
+    #applyToDeps(deps: Record<string, string>) {
+        let changed = false;
+        const version = this.#definiteVersion;
+        for (const key in deps) {
+            if (this.#members.has(key)) {
+                if (deps[key] === version) {
+                    continue;
+                }
+                deps[key] = this.#definiteVersion;
+                changed = true;
+            }
+        }
+        return changed;
+    }
+}

package/test/testing/mocks/MockTimeTest.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+const FAKE_TIME = 36000000;
+
+describe("MockTime", () => {
+    beforeEach(() => MockTime.reset(FAKE_TIME));
+
+    describe("now", () => {
+        it("returns the fake date", () => {
+            const result = MockTime.now();
+
+            expect(result.getTime()).equal(FAKE_TIME);
+        });
+    });
+
+    describe("nowMs", () => {
+        it("returns the fake time", () => {
+            const result = MockTime.nowMs();
+
+            expect(result).equal(FAKE_TIME);
+        });
+    });
+
+    describe("advanceTime", () => {
+        it("advances the time by the duration specified", async () => {
+            await MockTime.advance(45);
+
+            expect(MockTime.nowMs()).equal(FAKE_TIME + 45);
+        });
+    });
+
+    describe("getPeriodicTimer", () => {
+        it("returns a periodic timer that will call a callback periodically", async () => {
+            let firedTime;
+
+            const result = MockTime.getPeriodicTimer("Test periodic", 30, () => (firedTime = MockTime.nowMs()));
+            expect(result.isRunning).equal(false);
+
+            result.start();
+
+            expect(result.isRunning).equal(true);
+            expect(firedTime).equal(undefined);
+
+            await MockTime.advance(45);
+
+            expect(firedTime).equal(FAKE_TIME + 30);
+
+            await MockTime.advance(20);
+
+            expect(firedTime).equal(FAKE_TIME + 60);
+
+            expect(result.isRunning).equal(true);
+
+            result.stop();
+            expect(result.isRunning).equal(false);
+        });
+
+        it("returns a periodic timer that can be stopped", async () => {
+            let firedTime;
+
+            const result = MockTime.getPeriodicTimer("Test periodic", 30, () => (firedTime = MockTime.nowMs()));
+            result.start();
+            result.stop();
+
+            expect(firedTime).equal(undefined);
+
+            await MockTime.advance(45);
+
+            expect(firedTime).equal(undefined);
+            expect(result.isRunning).equal(false);
+        });
+    });
+
+    describe("getTimer", () => {
+        it("returns a timer that will call a callback in the future", async () => {
+            let firedTime;
+
+            const result = MockTime.getTimer("Test", 30, () => (firedTime = MockTime.nowMs()));
+            expect(result.isRunning).equal(false);
+            result.start();
+            expect(result.isRunning).equal(true);
+
+            expect(firedTime).equal(undefined);
+
+            await MockTime.advance(45);
+
+            expect(firedTime).equal(FAKE_TIME + 30);
+            expect(result.isRunning).equal(false);
+        });
+
+        it("returns a timer that can be stopped", async () => {
+            let firedTime;
+
+            const result = MockTime.getTimer("Test", 30, () => (firedTime = MockTime.nowMs()));
+            expect(result.isRunning).equal(false);
+            result.start();
+            expect(result.isRunning).equal(true);
+            result.stop();
+            expect(result.isRunning).equal(false);
+
+            expect(firedTime).equal(undefined);
+
+            await MockTime.advance(45);
+
+            expect(firedTime).equal(undefined);
+            expect(result.isRunning).equal(false);
+        });
+    });
+});

package/test/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../tsc/tsconfig.test.json",
+    "compilerOptions": {
+        "types": [
+            "node",
+            "mocha",
+            "@matter/tools"
+        ]
+    },
+    "references": [
+        {
+            "path": "../src"
+        }
+    ]
+}

package/tsc/tsconfig.app.json

@@ -0,0 +1,7 @@
+// This configuration a standard baseline for all tests
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "noEmit": true,
+    }
+}

package/tsc/tsconfig.base.json

@@ -0,0 +1,41 @@
+// This configuration a standard baseline for all packages
+{
+    "compilerOptions": {
+        // Participate in workspace
+        "composite": true,
+
+        // Add compatibility with CommonJS modules
+        "esModuleInterop": true,
+
+        // Compile incrementally using tsbuildinfo state file
+        "incremental": true,
+
+        // Matter.js most likely won't work with older versions of ES
+        "target": "es2022",
+
+        // Generate modules as ES2020 or CommonJS
+        "module": "node16",
+
+        // Use node-style dependency resolution
+        "moduleResolution": "node16",
+
+        // Do not load globals from node_modules by default
+        "types": [],
+
+        // Preserve const enums with tsc (esbuild does this by default)
+        "preserveConstEnums": true,
+
+        // Emit source/declaration maps to align the behavior of esbuild setup.
+
+        "skipLibCheck": true,
+
+        // Enforce a subset of our code conventions
+        "forceConsistentCasingInFileNames": true,
+        "noImplicitAny": true,
+        "noImplicitOverride": true,
+        "noUnusedParameters": true,
+        "noUnusedLocals": true,
+        "strict": true,
+        "isolatedModules": true,
+    }
+}

package/tsc/tsconfig.lib.json

@@ -0,0 +1,12 @@
+// This configuration a standard baseline for all libraries
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "emitDeclarationOnly": true,
+        "sourceMap": true,
+        "declarationMap": true,
+
+        // TODO - switch to targeting types directly and get rid of rewrite
+        "outDir": "${configDir}/../build/types/src",
+    }
+}

package/tsc/tsconfig.test.json

@@ -0,0 +1,7 @@
+// This configuration a standard baseline for all tests
+{
+    "extends": "./tsconfig.base.json",
+    "compilerOptions": {
+        "noEmit": true,
+    }
+}

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+    "compilerOptions": { "composite": true },
+    "files": [],
+    "references": [{ "path": "src" }, { "path": "test" }]
+}