@lowlighter/toolbox 1.0.1

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@lowlighter/toolbox",
+  "version": "1.0.1",
+  "type": "module",
+  "exports": {
+    "./clone": {
+      "types": "./clone.d.ts",
+      "import": "./clone.js",
+      "default": "./clone.js"
+    },
+    "./scripts/download-lambda-chromium": {
+      "types": "./scripts/download_lambda_chromium.d.ts",
+      "import": "./scripts/download_lambda_chromium.js",
+      "default": "./scripts/download_lambda_chromium.js"
+    },
+    "./scripts/code-quality": {
+      "types": "./scripts/code_quality.d.ts",
+      "import": "./scripts/code_quality.js",
+      "default": "./scripts/code_quality.js"
+    },
+    "./scripts/highlight-coverage": {
+      "types": "./scripts/highlight_coverage.d.ts",
+      "import": "./scripts/highlight_coverage.js",
+      "default": "./scripts/highlight_coverage.js"
+    },
+    "./env": {
+      "types": "./env.d.ts",
+      "import": "./env.js",
+      "default": "./env.js"
+    },
+    "./evaluate": {
+      "types": "./evaluate.d.ts",
+      "import": "./evaluate.js",
+      "default": "./evaluate.js"
+    },
+    "./events": {
+      "types": "./events.d.ts",
+      "import": "./events.js",
+      "default": "./events.js"
+    },
+    "./filesystem": {
+      "types": "./filesystem.d.ts",
+      "import": "./filesystem.js",
+      "default": "./filesystem.js"
+    },
+    "./format": {
+      "types": "./format.d.ts",
+      "import": "./format.js",
+      "default": "./format.js"
+    },
+    "./identicon": {
+      "types": "./identicon.d.ts",
+      "import": "./identicon.js",
+      "default": "./identicon.js"
+    },
+    "./imgb64": {
+      "types": "./imgb64.d.ts",
+      "import": "./imgb64.js",
+      "default": "./imgb64.js"
+    },
+    "./noop": {
+      "types": "./noop.d.ts",
+      "import": "./noop.js",
+      "default": "./noop.js"
+    },
+    "./permissions": {
+      "types": "./permissions.d.ts",
+      "import": "./permissions.js",
+      "default": "./permissions.js"
+    },
+    "./pluralize": {
+      "types": "./pluralize.d.ts",
+      "import": "./pluralize.js",
+      "default": "./pluralize.js"
+    },
+    "./promises": {
+      "types": "./promises.d.ts",
+      "import": "./promises.js",
+      "default": "./promises.js"
+    },
+    "./scripts/publish/npm": {
+      "types": "./scripts/publish/npm.d.ts",
+      "import": "./scripts/publish/npm.js",
+      "default": "./scripts/publish/npm.js"
+    },
+    "./scripts/publish/x": {
+      "types": "./scripts/publish/x.d.ts",
+      "import": "./scripts/publish/x.js",
+      "default": "./scripts/publish/x.js"
+    },
+    "./resolve": {
+      "types": "./resolve.d.ts",
+      "import": "./resolve.js",
+      "default": "./resolve.js"
+    },
+    "./timezone": {
+      "types": "./timezone.d.ts",
+      "import": "./timezone.js",
+      "default": "./timezone.js"
+    }
+  },
+  "dependencies": {
+    "@jsr/std__cli": "^1.0.28",
+    "@jsr/std__encoding": "^1.0.10",
+    "@jsr/std__fmt": "^1.0.10",
+    "@jsr/std__fs": "^1.0.23",
+    "@jsr/std__jsonc": "^1.0.2",
+    "@jsr/std__path": "^1.1.4",
+    "@jsr/std__streams": "^1.0.17",
+    "@jsr/std__tar": "^0.1.10",
+    "highlight.js": "^11",
+    "@lowlighter/typing": "^4.1.0",
+    "@lowlighter/run": "^3.4.0",
+    "@lowlighter/git": "^1.0.0"
+  }
+}

package/permissions.d.ts

@@ -0,0 +1 @@
+/** Compute deno permissions flag from a `Deno.PermissionOptions`-like object. */ export declare function flags(permissions: Deno.PermissionOptions | boolean | null): string;

package/permissions.js

@@ -0,0 +1,31 @@
+/** Compute deno permissions flag from a `Deno.PermissionOptions`-like object. */ export function flags(permissions) {
+  const flags = [];
+  if (permissions === true || permissions === "inherit") flags.push("--allow-all");
+  if (typeof permissions === "object" && permissions) {
+    for (const type of [
+      "env",
+      "ffi",
+      "import",
+      "net",
+      "read",
+      "run",
+      "sys",
+      "write"
+    ]){
+      if (permissions[type] === true || permissions[type] === "inherit") {
+        flags.push(`--allow-${type}`);
+        continue;
+      }
+      if (permissions[type] === false) {
+        flags.push(`--deny-${type}`);
+        continue;
+      }
+      if (Array.isArray(permissions[type])) {
+        flags.push(`--allow-${type}=${permissions[type].map(String).join(",")}`);
+        continue;
+      }
+    }
+  }
+  return flags.join(" ");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/pluralize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the plural form of a common English noun, preserving its casing.
+ *
+ * Intended for deriving SQL table names from singular schema names, so it only
+ * handles the regular cases and a handful of everyday irregulars.
+ */ export declare function pluralize(noun: string): string;

package/pluralize.js

@@ -0,0 +1,44 @@
+// Singular → plural rules, tried top to bottom; first match wins. Covers the
+// regular cases plus the few irregulars common in data models.
+const rules = [
+  [
+    /(pe)(?:rson|ople)$/i,
+    "$1ople"
+  ],
+  [
+    /(child)(?:ren)?$/i,
+    "$1ren"
+  ],
+  [
+    /(?<!hu)(m)[ae]n$/i,
+    "$1en"
+  ],
+  [
+    /([^aeiouy])y$/i,
+    "$1ies"
+  ],
+  [
+    /([aeiou]z)$/i,
+    "$1zes"
+  ],
+  [
+    /(s|x|z|ch|sh)$/i,
+    "$1es"
+  ],
+  [
+    /$/i,
+    "s"
+  ]
+];
+/**
+ * Returns the plural form of a common English noun, preserving its casing.
+ *
+ * Intended for deriving SQL table names from singular schema names, so it only
+ * handles the regular cases and a handful of everyday irregulars.
+ */ export function pluralize(noun) {
+  if (!noun) return noun;
+  const [regex, replacement] = rules.find(([regex])=>regex.test(noun));
+  const plural = noun.replace(regex, replacement);
+  return noun === noun.toUpperCase() ? plural.toUpperCase() : plural;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/promises.d.ts

@@ -0,0 +1 @@
+/** Returns the current state of a promise. */ export declare function state(promise: Promise<unknown>): Promise<"pending" | "fulfilled" | "rejected">;

package/promises.js

@@ -0,0 +1,12 @@
+/** Returns the current state of a promise. */ export async function state(promise) {
+  const check = new Promise((resolve)=>setTimeout(resolve, 0));
+  try {
+    return await Promise.race([
+      promise.then((_)=>"fulfilled").catch((_)=>"rejected"),
+      check.then((_)=>"pending")
+    ]);
+  } finally{
+    await check;
+  }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC9wcm9taXNlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUmV0dXJucyB0aGUgY3VycmVudCBzdGF0ZSBvZiBhIHByb21pc2UuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc3RhdGUocHJvbWlzZTogUHJvbWlzZTx1bmtub3duPik6IFByb21pc2U8XCJwZW5kaW5nXCIgfCBcImZ1bGZpbGxlZFwiIHwgXCJyZWplY3RlZFwiPiB7XG4gIGNvbnN0IGNoZWNrID0gbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUpID0+IHNldFRpbWVvdXQocmVzb2x2ZSwgMCkpXG4gIHRyeSB7XG4gICAgcmV0dXJuIGF3YWl0IFByb21pc2UucmFjZShbcHJvbWlzZS50aGVuKChfKSA9PiBcImZ1bGZpbGxlZFwiIGFzIGNvbnN0KS5jYXRjaCgoXykgPT4gXCJyZWplY3RlZFwiIGFzIGNvbnN0KSwgY2hlY2sudGhlbigoXykgPT4gXCJwZW5kaW5nXCIgYXMgY29uc3QpXSlcbiAgfSBmaW5hbGx5IHtcbiAgICBhd2FpdCBjaGVja1xuICB9XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsNENBQTRDLEdBQzVDLE9BQU8sZUFBZSxNQUFNLE9BQXlCO0VBQ25ELE1BQU0sUUFBUSxJQUFJLFFBQWMsQ0FBQyxVQUFZLFdBQVcsU0FBUztFQUNqRSxJQUFJO0lBQ0YsT0FBTyxNQUFNLFFBQVEsSUFBSSxDQUFDO01BQUMsUUFBUSxJQUFJLENBQUMsQ0FBQyxJQUFNLGFBQXNCLEtBQUssQ0FBQyxDQUFDLElBQU07TUFBc0IsTUFBTSxJQUFJLENBQUMsQ0FBQyxJQUFNO0tBQW9CO0VBQ2hKLFNBQVU7SUFDUixNQUFNO0VBQ1I7QUFDRiJ9

package/resolve.d.ts

@@ -0,0 +1,5 @@
+/** Options for {@linkcode resolve} */ export type ResolveOptions = {
+  /** Base URL (defaults to current working directory). */ base?: string | ImportMeta;
+  /** Entrypoint (defaults to "mod.ts"). */ entrypoint?: string;
+};
+/** Resolve a module specifier in a similar way to `import.meta.resolve`. */ export declare function resolve(specifier: string, {}?: ResolveOptions): string;

package/resolve.js

@@ -0,0 +1,18 @@
+// Imports
+import { dirname, fromFileUrl, isAbsolute, join, toFileUrl } from "@std/path";
+import { normalize } from "@std/path/posix/normalize";
+import { cwd } from "./filesystem.js";
+/** Resolve a module specifier in a similar way to `import.meta.resolve`. */ export function resolve(specifier, { base, entrypoint = "mod.ts" } = {}) {
+  if ([
+    "./",
+    "../",
+    "/"
+  ].some((prefix)=>specifier.startsWith(prefix))) {
+    if (specifier.endsWith("/")) specifier += entrypoint;
+    if (typeof base === "object") base = new URL(base.url).protocol === "file:" ? dirname(fromFileUrl(base.url)) : undefined;
+    base ??= cwd();
+    return toFileUrl(normalize(isAbsolute(specifier) ? specifier : join(base, specifier))).href;
+  }
+  return import.meta.resolve(specifier);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC9yZXNvbHZlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIEltcG9ydHNcbmltcG9ydCB7IGRpcm5hbWUsIGZyb21GaWxlVXJsLCBpc0Fic29sdXRlLCBqb2luLCB0b0ZpbGVVcmwgfSBmcm9tIFwiQHN0ZC9wYXRoXCJcbmltcG9ydCB7IG5vcm1hbGl6ZSB9IGZyb20gXCJAc3RkL3BhdGgvcG9zaXgvbm9ybWFsaXplXCJcbmltcG9ydCB7IGN3ZCB9IGZyb20gXCIuL2ZpbGVzeXN0ZW0uanNcIlxuXG4vKiogT3B0aW9ucyBmb3Ige0BsaW5rY29kZSByZXNvbHZlfSAqL1xuZXhwb3J0IHR5cGUgUmVzb2x2ZU9wdGlvbnMgPSB7XG4gIC8qKiBCYXNlIFVSTCAoZGVmYXVsdHMgdG8gY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSkuICovXG4gIGJhc2U/OiBzdHJpbmcgfCBJbXBvcnRNZXRhXG4gIC8qKiBFbnRyeXBvaW50IChkZWZhdWx0cyB0byBcIm1vZC50c1wiKS4gKi9cbiAgZW50cnlwb2ludD86IHN0cmluZ1xufVxuXG4vKiogUmVzb2x2ZSBhIG1vZHVsZSBzcGVjaWZpZXIgaW4gYSBzaW1pbGFyIHdheSB0byBgaW1wb3J0Lm1ldGEucmVzb2x2ZWAuICovXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZShzcGVjaWZpZXI6IHN0cmluZywgeyBiYXNlLCBlbnRyeXBvaW50ID0gXCJtb2QudHNcIiB9OiBSZXNvbHZlT3B0aW9ucyA9IHt9KTogc3RyaW5nIHtcbiAgaWYgKFtcIi4vXCIsIFwiLi4vXCIsIFwiL1wiXS5zb21lKChwcmVmaXgpID0+IHNwZWNpZmllci5zdGFydHNXaXRoKHByZWZpeCkpKSB7XG4gICAgaWYgKHNwZWNpZmllci5lbmRzV2l0aChcIi9cIikpXG4gICAgICBzcGVjaWZpZXIgKz0gZW50cnlwb2ludFxuICAgIGlmICh0eXBlb2YgYmFzZSA9PT0gXCJvYmplY3RcIilcbiAgICAgIGJhc2UgPSAobmV3IFVSTChiYXNlLnVybCkucHJvdG9jb2wgPT09IFwiZmlsZTpcIikgPyBkaXJuYW1lKGZyb21GaWxlVXJsKGJhc2UudXJsKSkgOiB1bmRlZmluZWRcbiAgICBiYXNlID8/PSBjd2QoKVxuICAgIHJldHVybiB0b0ZpbGVVcmwobm9ybWFsaXplKGlzQWJzb2x1dGUoc3BlY2lmaWVyKSA/IHNwZWNpZmllciA6IGpvaW4oYmFzZSwgc3BlY2lmaWVyKSkpLmhyZWZcbiAgfVxuICByZXR1cm4gaW1wb3J0Lm1ldGEucmVzb2x2ZShzcGVjaWZpZXIpXG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLFNBQVMsT0FBTyxFQUFFLFdBQVcsRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFNBQVMsUUFBUSxZQUFXO0FBQzdFLFNBQVMsU0FBUyxRQUFRLDRCQUEyQjtBQUNyRCxTQUFTLEdBQUcsUUFBUSxrQkFBaUI7QUFVckMsMEVBQTBFLEdBQzFFLE9BQU8sU0FBUyxRQUFRLFNBQWlCLEVBQUUsRUFBRSxJQUFJLEVBQUUsYUFBYSxRQUFRLEVBQWtCLEdBQUcsQ0FBQyxDQUFDO0VBQzdGLElBQUk7SUFBQztJQUFNO0lBQU87R0FBSSxDQUFDLElBQUksQ0FBQyxDQUFDLFNBQVcsVUFBVSxVQUFVLENBQUMsVUFBVTtJQUNyRSxJQUFJLFVBQVUsUUFBUSxDQUFDLE1BQ3JCLGFBQWE7SUFDZixJQUFJLE9BQU8sU0FBUyxVQUNsQixPQUFPLEFBQUMsSUFBSSxJQUFJLEtBQUssR0FBRyxFQUFFLFFBQVEsS0FBSyxVQUFXLFFBQVEsWUFBWSxLQUFLLEdBQUcsS0FBSztJQUNyRixTQUFTO0lBQ1QsT0FBTyxVQUFVLFVBQVUsV0FBVyxhQUFhLFlBQVksS0FBSyxNQUFNLGFBQWEsSUFBSTtFQUM3RjtFQUNBLE9BQU8sWUFBWSxPQUFPLENBQUM7QUFDN0IifQ==

package/scripts/code_quality.js

@@ -0,0 +1,210 @@
+// deno-lint-ignore-file no-console
+import { parseArgs } from "@std/cli";
+import { cyan, gray, green, red, stripAnsiCode, yellow } from "@std/fmt/colors";
+import { basename, join } from "@std/path";
+import { exists } from "@std/fs";
+const decoder = new TextDecoder();
+const args = parseArgs(Deno.args, {
+  string: [
+    "cwd",
+    "reporter",
+    "_"
+  ],
+  boolean: [
+    "dev",
+    "doc",
+    "help"
+  ],
+  default: {
+    reporter: "dot",
+    coverage: 80
+  }
+});
+if (args.cwd) Deno.chdir(args.cwd);
+if (args.help) {
+  console.error(`Usage: deno run -A jsr:@libs/toolbox/code-quality <file_test.ts>...`);
+  console.error(``);
+  console.error(`Options:`);
+  console.error(`  --cwd=DIR        Change working directory before running tests (use $INIT_CWD in deno task)`);
+  console.error(`  --dev            Only run deno test and deno coverage`);
+  console.error(`  --doc            Run documentation checks (default: false)`);
+  console.error(`  --reporter=TYPE  Test reporter type (default: dot)`);
+  console.error(`  --coverage=NUM   Minimum coverage threshold percentage (default: 80, set to 0 to disable)`);
+  console.error(`  --help           Show this help message`);
+  console.error(``);
+  Deno.exit(2);
+}
+let success = true;
+for (const mod_path of args._){
+  if (!mod_path.endsWith("_test.ts")) continue;
+  const mod_test = join(Deno.cwd(), mod_path);
+  const mod = mod_test.replace(/_test\.ts$/, ".ts");
+  console.error(cyan("─".repeat(80)));
+  console.error(cyan(`${mod}`));
+  console.error(cyan("─".repeat(80)));
+  if (!await exists(mod_test)) {
+    console.error(red(`✗ File not found: ${mod_test}`));
+    success = false;
+    continue;
+  }
+  // deno check
+  if (args.dev) console.error(gray(`∅ deno check`));
+  else {
+    const check = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "check",
+        "--quiet",
+        mod,
+        mod_test
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+    success &&= check.success;
+    console.error((check.success ? green : red)(`${check.success ? "✓" : "✗"} deno check`));
+  }
+  // deno lint
+  if (args.dev) console.error(gray(`∅ deno lint`));
+  else {
+    const lint = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "lint",
+        "--quiet",
+        mod,
+        mod_test
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+    success &&= lint.success;
+    console.error((lint.success ? green : red)(`${lint.success ? "✓" : "✗"} deno lint`));
+  }
+  // deno fmt
+  if (args.dev) console.error(gray(`∅ deno fmt --check`));
+  else {
+    const fmt = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "fmt",
+        "--quiet",
+        "--check",
+        mod,
+        mod_test
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+    success &&= fmt.success;
+    console.error((fmt.success ? green : red)(`${fmt.success ? "✓" : "✗"} deno fmt --check`));
+  }
+  // deno test
+  const test = await new Deno.Command(Deno.execPath(), {
+    args: [
+      "test",
+      "--no-check",
+      "--clean",
+      "--coverage",
+      "--coverage-raw-data-only",
+      "--seed=0",
+      `--reporter=${args.reporter}`,
+      "--sanitize-ops",
+      "--sanitize-resources",
+      "--trace-leaks",
+      "--allow-all",
+      mod_test
+    ],
+    stdout: "inherit",
+    stderr: "inherit"
+  }).output();
+  success &&= test.success;
+  console.error((test.success ? green : red)(`${test.success ? "✓" : "✗"} deno test`));
+  // deno coverage
+  if (test.success) {
+    const parsed = Number.parseFloat(`${args.coverage}`);
+    const threshold = Number.isFinite(parsed) ? parsed : 80;
+    const coverage = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "coverage",
+        `--include=${mod}`
+      ],
+      stdout: "piped",
+      stderr: "inherit"
+    }).output();
+    const result = stripAnsiCode(decoder.decode(coverage.stdout)).trim().match(/^\|\s*All files\s*\|\s*(?<branch>\d+(?:\.\d+)?)\s*\|\s*(?<func>\d+(?:\.\d+)?)\s*\|\s*(?<line>\d+(?:\.\d+)?)\s*\|$/m)?.groups ?? {};
+    const branch = Number.parseFloat(result.branch) || 0;
+    const func = Number.parseFloat(result.func) || 0;
+    const line = Number.parseFloat(result.line) || 0;
+    const pass = line >= threshold && branch >= threshold && func >= threshold;
+    console.error((branch === 100 && func === 100 && line === 100 ? green : pass ? yellow : red)(`${pass ? "✓" : "✗"} deno coverage --threshold=${threshold}%`));
+    console.error((branch === 100 ? green : branch >= threshold ? yellow : red)(`  ├─ branch: ${branch.toFixed(1)}%`));
+    console.error((func === 100 ? green : func >= threshold ? yellow : red)(`  ├─ function: ${func.toFixed(1)}%`));
+    console.error((line === 100 ? green : line >= threshold ? yellow : red)(`  └─ line: ${line.toFixed(1)}%`));
+    if (branch < 100 || func < 100 || line < 100) await new Deno.Command(Deno.execPath(), {
+      args: [
+        "coverage",
+        "--detailed",
+        `--include=${mod}`
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+  }
+  // Documentation checks
+  if (args.doc) {
+    console.error(gray("┄".repeat(80)));
+    // deno doc
+    if (basename(mod) === "mod.ts") {
+      const doc = await new Deno.Command(Deno.execPath(), {
+        args: [
+          "doc",
+          "--quiet",
+          "--lint",
+          mod
+        ],
+        stdout: "inherit",
+        stderr: "inherit"
+      }).output();
+      success &&= doc.success;
+      console.error((doc.success ? green : red)(`${doc.success ? "✓" : "✗"} deno doc --lint`));
+    } else {
+      console.error(gray(`∅ deno doc --lint`));
+    }
+    // deno check --doc
+    const check = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "check",
+        "--quiet",
+        "--doc-only",
+        mod,
+        mod_test
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+    success &&= check.success;
+    console.error((check.success ? green : red)(`${check.success ? "✓" : "✗"} deno check --doc`));
+    // deno test --doc
+    const test = await new Deno.Command(Deno.execPath(), {
+      args: [
+        "test",
+        "--no-check",
+        "--seed=0",
+        `--reporter=${args.reporter}`,
+        "--doc",
+        mod
+      ],
+      stdout: "inherit",
+      stderr: "inherit"
+    }).output();
+    success &&= test.success;
+    console.error((test.success ? green : red)(`${test.success ? "✓" : "✗"} deno test --doc`));
+  }
+}
+if (success) {
+  console.error(green("─".repeat(80)));
+  console.error(green(`✓ Success`));
+} else {
+  console.error(red("─".repeat(80)));
+  console.error(red(`✗ Failure`));
+  Deno.exit(1);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/scripts/code_quality.ts"],"sourcesContent":["// deno-lint-ignore-file no-console\nimport { parseArgs } from \"@std/cli\"\nimport { cyan, gray, green, red, stripAnsiCode, yellow } from \"@std/fmt/colors\"\nimport { basename, join } from \"@std/path\"\nimport { exists } from \"@std/fs\"\n\nconst decoder = new TextDecoder()\nconst args = parseArgs(Deno.args, { string: [\"cwd\", \"reporter\", \"_\"], boolean: [\"dev\", \"doc\", \"help\"], default: { reporter: \"dot\", coverage: 80 } })\nif (args.cwd)\n  Deno.chdir(args.cwd)\nif (args.help) {\n  console.error(`Usage: deno run -A jsr:@libs/toolbox/code-quality <file_test.ts>...`)\n  console.error(``)\n  console.error(`Options:`)\n  console.error(`  --cwd=DIR        Change working directory before running tests (use $INIT_CWD in deno task)`)\n  console.error(`  --dev            Only run deno test and deno coverage`)\n  console.error(`  --doc            Run documentation checks (default: false)`)\n  console.error(`  --reporter=TYPE  Test reporter type (default: dot)`)\n  console.error(`  --coverage=NUM   Minimum coverage threshold percentage (default: 80, set to 0 to disable)`)\n  console.error(`  --help           Show this help message`)\n  console.error(``)\n  Deno.exit(2)\n}\n\nlet success = true\nfor (const mod_path of args._) {\n  if (!mod_path.endsWith(\"_test.ts\"))\n    continue\n  const mod_test = join(Deno.cwd(), mod_path)\n  const mod = mod_test.replace(/_test\\.ts$/, \".ts\")\n  console.error(cyan(\"─\".repeat(80)))\n  console.error(cyan(`${mod}`))\n  console.error(cyan(\"─\".repeat(80)))\n  if (!await exists(mod_test)) {\n    console.error(red(`✗ File not found: ${mod_test}`))\n    success = false\n    continue\n  }\n\n  // deno check\n  if (args.dev)\n    console.error(gray(`∅ deno check`))\n  else {\n    const check = await new Deno.Command(Deno.execPath(), { args: [\"check\", \"--quiet\", mod, mod_test], stdout: \"inherit\", stderr: \"inherit\" }).output()\n    success &&= check.success\n    console.error((check.success ? green : red)(`${check.success ? \"✓\" : \"✗\"} deno check`))\n  }\n  // deno lint\n  if (args.dev)\n    console.error(gray(`∅ deno lint`))\n  else {\n    const lint = await new Deno.Command(Deno.execPath(), { args: [\"lint\", \"--quiet\", mod, mod_test], stdout: \"inherit\", stderr: \"inherit\" }).output()\n    success &&= lint.success\n    console.error((lint.success ? green : red)(`${lint.success ? \"✓\" : \"✗\"} deno lint`))\n  }\n  // deno fmt\n  if (args.dev)\n    console.error(gray(`∅ deno fmt --check`))\n  else {\n    const fmt = await new Deno.Command(Deno.execPath(), { args: [\"fmt\", \"--quiet\", \"--check\", mod, mod_test], stdout: \"inherit\", stderr: \"inherit\" }).output()\n    success &&= fmt.success\n    console.error((fmt.success ? green : red)(`${fmt.success ? \"✓\" : \"✗\"} deno fmt --check`))\n  }\n  // deno test\n  const test = await new Deno.Command(Deno.execPath(), {\n    args: [\"test\", \"--no-check\", \"--clean\", \"--coverage\", \"--coverage-raw-data-only\", \"--seed=0\", `--reporter=${args.reporter}`, \"--sanitize-ops\", \"--sanitize-resources\", \"--trace-leaks\", \"--allow-all\", mod_test],\n    stdout: \"inherit\",\n    stderr: \"inherit\",\n  }).output()\n  success &&= test.success\n  console.error((test.success ? green : red)(`${test.success ? \"✓\" : \"✗\"} deno test`))\n  // deno coverage\n  if (test.success) {\n    const parsed = Number.parseFloat(`${args.coverage}`)\n    const threshold = Number.isFinite(parsed) ? parsed : 80\n    const coverage = await new Deno.Command(Deno.execPath(), { args: [\"coverage\", `--include=${mod}`], stdout: \"piped\", stderr: \"inherit\" }).output()\n    const result = stripAnsiCode(decoder.decode(coverage.stdout)).trim().match(/^\\|\\s*All files\\s*\\|\\s*(?<branch>\\d+(?:\\.\\d+)?)\\s*\\|\\s*(?<func>\\d+(?:\\.\\d+)?)\\s*\\|\\s*(?<line>\\d+(?:\\.\\d+)?)\\s*\\|$/m)?.groups ?? {}\n    const branch = Number.parseFloat(result.branch) || 0\n    const func = Number.parseFloat(result.func) || 0\n    const line = Number.parseFloat(result.line) || 0\n    const pass = line >= threshold && branch >= threshold && func >= threshold\n    console.error((branch === 100 && func === 100 && line === 100 ? green : pass ? yellow : red)(`${pass ? \"✓\" : \"✗\"} deno coverage --threshold=${threshold}%`))\n    console.error((branch === 100 ? green : branch >= threshold ? yellow : red)(`  ├─ branch: ${branch.toFixed(1)}%`))\n    console.error((func === 100 ? green : func >= threshold ? yellow : red)(`  ├─ function: ${func.toFixed(1)}%`))\n    console.error((line === 100 ? green : line >= threshold ? yellow : red)(`  └─ line: ${line.toFixed(1)}%`))\n    if ((branch < 100) || (func < 100) || (line < 100))\n      await new Deno.Command(Deno.execPath(), { args: [\"coverage\", \"--detailed\", `--include=${mod}`], stdout: \"inherit\", stderr: \"inherit\" }).output()\n  }\n\n  // Documentation checks\n  if (args.doc) {\n    console.error(gray(\"┄\".repeat(80)))\n    // deno doc\n    if (basename(mod) === \"mod.ts\") {\n      const doc = await new Deno.Command(Deno.execPath(), { args: [\"doc\", \"--quiet\", \"--lint\", mod], stdout: \"inherit\", stderr: \"inherit\" }).output()\n      success &&= doc.success\n      console.error((doc.success ? green : red)(`${doc.success ? \"✓\" : \"✗\"} deno doc --lint`))\n    } else {\n      console.error(gray(`∅ deno doc --lint`))\n    }\n    // deno check --doc\n    const check = await new Deno.Command(Deno.execPath(), { args: [\"check\", \"--quiet\", \"--doc-only\", mod, mod_test], stdout: \"inherit\", stderr: \"inherit\" }).output()\n    success &&= check.success\n    console.error((check.success ? green : red)(`${check.success ? \"✓\" : \"✗\"} deno check --doc`))\n    // deno test --doc\n    const test = await new Deno.Command(Deno.execPath(), { args: [\"test\", \"--no-check\", \"--seed=0\", `--reporter=${args.reporter}`, \"--doc\", mod], stdout: \"inherit\", stderr: \"inherit\" }).output()\n    success &&= test.success\n    console.error((test.success ? green : red)(`${test.success ? \"✓\" : \"✗\"} deno test --doc`))\n  }\n}\n\nif (success) {\n  console.error(green(\"─\".repeat(80)))\n  console.error(green(`✓ Success`))\n} else {\n  console.error(red(\"─\".repeat(80)))\n  console.error(red(`✗ Failure`))\n  Deno.exit(1)\n}\n"],"names":[],"mappings":"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"}

package/scripts/download_lambda_chromium.d.ts

@@ -0,0 +1,10 @@
+/** Chromium download options. */ export type ChromiumOptions = {
+  /** Chromium version. Default is `141.0.0`. */ version?: string;
+  /** Path to save Chromium binary. Default is `/tmp/chromium`. */ path?: string;
+  /** System architecture. Default is current architecture. */ arch?: typeof Deno.build.arch;
+  /** Download URL. */ url?: string;
+  /** Force download even if file exists. */ force?: boolean;
+  /** Set environment variables for `FONTCONFIG_PATH` and `LD_LIBRARY_PATH` (requires --allow-env). Default is `true`. */ env?: boolean;
+  /** Enable debugging. */ debug?: boolean;
+};
+/** Download Chromium binary for AWS Lambda environment. */ export declare function chromium({}?: ChromiumOptions): Promise<string>;