@ykdz/template 0.0.41 → 0.0.42

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/scripts/run-rust-tests.ts

@@ -0,0 +1,100 @@
+import { spawn } from "node:child_process";
+
+const testSummary =
+  /^test result: (?:ok|FAILED)\. (\d+) passed; (\d+) failed; \d+ ignored;/u;
+const ansiEscape = new RegExp(
+  `${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`,
+  "gu",
+);
+const zeroTestDiagnostic =
+  "Cargo 未执行任何业务测试用例；请检查测试内容与 ignored 标记";
+type InterruptSignal = "SIGINT" | "SIGTERM";
+
+let executedTests = 0;
+let stdoutRemainder = "";
+let stderrRemainder = "";
+let interruptedBy: InterruptSignal | undefined;
+
+function countSummaryLine(line: string): void {
+  const match = testSummary.exec(line.replace(ansiEscape, ""));
+  if (match !== null) {
+    executedTests += Number(match[1]) + Number(match[2]);
+  }
+}
+
+function forwardSignal(signal: InterruptSignal): void {
+  if (cargo.exitCode === null && cargo.signalCode === null) {
+    interruptedBy = signal;
+    try {
+      if (process.platform !== "win32" && cargo.pid !== undefined) {
+        process.kill(-cargo.pid, signal);
+      } else {
+        cargo.kill(signal);
+      }
+    } catch {
+      cargo.kill(signal);
+    }
+  }
+}
+
+function forwardInterrupt(): void {
+  forwardSignal("SIGINT");
+}
+
+function forwardTerminate(): void {
+  forwardSignal("SIGTERM");
+}
+
+function consumeOutput(
+  chunk: Buffer,
+  stream: NodeJS.WriteStream,
+  remainder: string,
+  saveRemainder: (value: string) => void,
+): void {
+  stream.write(chunk);
+  const lines = `${remainder}${chunk.toString("utf8")}`.split(/\r?\n/u);
+  const lastLine = lines.pop();
+  for (const line of lines) countSummaryLine(line);
+  saveRemainder(lastLine ?? "");
+}
+
+const cargo = spawn("cargo", ["test", "--workspace"], {
+  stdio: ["inherit", "pipe", "pipe"],
+  detached: process.platform !== "win32",
+});
+
+process.on("SIGINT", forwardInterrupt);
+process.on("SIGTERM", forwardTerminate);
+
+cargo.stdout.on("data", (chunk: Buffer) =>
+  consumeOutput(chunk, process.stdout, stdoutRemainder, (value) => {
+    stdoutRemainder = value;
+  }),
+);
+cargo.stderr.on("data", (chunk: Buffer) =>
+  consumeOutput(chunk, process.stderr, stderrRemainder, (value) => {
+    stderrRemainder = value;
+  }),
+);
+cargo.once("error", (error) => {
+  process.stderr.write(`无法启动 Cargo 测试：${error.message}\n`);
+  process.exitCode = 1;
+});
+cargo.once("close", (code, signal) => {
+  process.off("SIGINT", forwardInterrupt);
+  process.off("SIGTERM", forwardTerminate);
+  countSummaryLine(stdoutRemainder);
+  countSummaryLine(stderrRemainder);
+
+  if (interruptedBy !== undefined) {
+    process.exitCode = interruptedBy === "SIGINT" ? 130 : 143;
+  } else if (code !== null && code !== 0) {
+    process.exitCode = code;
+  } else if (signal !== null) {
+    process.exitCode =
+      signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1;
+  } else if (executedTests === 0) {
+    process.stderr.write(`${zeroTestDiagnostic}\n`);
+    process.exitCode = 1;
+  }
+});

package/node_modules/@ykdz/template-builtin-presets/templates/foundation/scripts/run-turbo-boundaries.ts

@@ -0,0 +1,74 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+type InterruptSignal = "SIGINT" | "SIGTERM";
+
+function exitStatus(
+  code: number | null,
+  signal: NodeJS.Signals | null,
+  interruptedBy: InterruptSignal | undefined,
+  spawnFailed: boolean,
+): number {
+  if (interruptedBy !== undefined) {
+    return interruptedBy === "SIGINT" ? 130 : 143;
+  }
+  if (spawnFailed) return 1;
+  if (code !== null) return code;
+  if (signal === "SIGINT") return 130;
+  if (signal === "SIGTERM") return 143;
+  return 1;
+}
+
+export async function runTurboBoundaries(cwd = process.cwd()): Promise<number> {
+  const turbo = spawn("pnpm", ["exec", "turbo", "boundaries", "--no-color"], {
+    cwd,
+    stdio: "inherit",
+    detached: process.platform !== "win32",
+  });
+  let interruptedBy: InterruptSignal | undefined;
+  let spawnFailed = false;
+
+  const forwardSignal = (signal: InterruptSignal): void => {
+    if (turbo.exitCode !== null || turbo.signalCode !== null) return;
+
+    interruptedBy ??= signal;
+    if (turbo.pid === undefined) return;
+    try {
+      if (process.platform !== "win32") {
+        process.kill(-turbo.pid, signal);
+      } else {
+        turbo.kill(signal);
+      }
+    } catch {
+      turbo.kill(signal);
+    }
+  };
+  const forwardInterrupt = (): void => forwardSignal("SIGINT");
+  const forwardTerminate = (): void => forwardSignal("SIGTERM");
+
+  process.on("SIGINT", forwardInterrupt);
+  process.on("SIGTERM", forwardTerminate);
+
+  return await new Promise<number>((resolveStatus) => {
+    turbo.once("spawn", () => {
+      if (interruptedBy !== undefined) forwardSignal(interruptedBy);
+    });
+    turbo.once("error", (error) => {
+      spawnFailed = true;
+      process.stderr.write(`无法运行 Turbo boundaries：${error.message}\n`);
+    });
+    turbo.once("close", (code, signal) => {
+      process.off("SIGINT", forwardInterrupt);
+      process.off("SIGTERM", forwardTerminate);
+      resolveStatus(exitStatus(code, signal, interruptedBy, spawnFailed));
+    });
+  });
+}
+
+if (
+  process.argv[1] !== undefined &&
+  import.meta.url === pathToFileURL(resolve(process.argv[1])).href
+) {
+  process.exitCode = await runTurboBoundaries();
+}