@lowlighter/toolbox 1.0.1

package/scripts/download_lambda_chromium.js

@@ -0,0 +1,133 @@
+// Imports
+// deno-lint-ignore-file no-console no-external-import
+import { brotliDecompressSync } from "node:zlib";
+import { ensureDir, exists } from "@std/fs";
+import { basename, dirname, join, resolve } from "@std/path";
+import { UntarStream } from "@std/tar";
+import { toArrayBuffer } from "@std/streams";
+import { parseArgs } from "@std/cli";
+/** Locks. */ const locks = new Map();
+/** Download Chromium binary for AWS Lambda environment. */ export function chromium({ version = "141.0.0", path = "/tmp/chromium", arch = Deno.build.arch, force = false, env = true, debug = false } = {}) {
+  // Install browser
+  path = resolve(path);
+  if (!locks.has(path)) {
+    locks.set(path, // deno-lint-ignore no-async-promise-executor
+    new Promise(async (resolve, reject)=>{
+      try {
+        if (!await exists(path) || force) {
+          const url = `https://github.com/Sparticuz/chromium/releases/download/v${version}/chromium-v${version}-pack.${{
+            x86_64: "x64",
+            aarch64: "arm64"
+          }[arch] ?? "unknown"}.tar`;
+          if (debug) console.debug(`Downloading Chromium v${version} from ${url}`);
+          const response = await fetch(url);
+          if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Failed to download Chromium: ${response.status} ${url}`);
+          }
+          await extract(response.body, {
+            path: dirname(path),
+            debug
+          });
+        }
+        resolve(path);
+      } catch (error) {
+        reject(error);
+      }
+    }));
+  }
+  // Set environment variables
+  if (env) {
+    if (!Deno.env.get("FONTCONFIG_PATH")) {
+      Deno.env.set("FONTCONFIG_PATH", join(dirname(path), "fonts"));
+      if (debug) console.debug(`Set FONTCONFIG_PATH to ${Deno.env.get("FONTCONFIG_PATH")}`);
+    }
+    if (!Deno.env.get("LD_LIBRARY_PATH")?.includes(join(dirname(path), "al2023"))) {
+      Deno.env.set("LD_LIBRARY_PATH", [
+        join(dirname(path), "al2023"),
+        Deno.env.get("LD_LIBRARY_PATH")
+      ].join(":"));
+      if (debug) console.debug(`Set LD_LIBRARY_PATH to ${Deno.env.get("LD_LIBRARY_PATH")}`);
+    }
+  }
+  return locks.get(path);
+}
+/** Extract tar stream. */ async function extract(stream, { path, debug }) {
+  for await (const entry of stream.pipeThrough(new UntarStream())){
+    if (!entry.readable) continue;
+    let name = basename(entry.path);
+    let buffer = await toArrayBuffer(entry.readable);
+    if (name.endsWith(".br")) {
+      name = basename(name, ".br");
+      buffer = brotliDecompressSync(buffer, {
+        chunkSize: 2 ** 21
+      });
+    }
+    if (name.endsWith(".tar")) {
+      name = basename(name, ".tar");
+      await extract(ReadableStream.from([
+        new Uint8Array(buffer)
+      ]), {
+        path: name === "swiftshader" ? path : join(path, name),
+        debug
+      });
+      continue;
+    }
+    name = join(path, name);
+    await ensureDir(dirname(name));
+    await Deno.writeFile(name, new Uint8Array(buffer));
+    await Deno.chmod(name, 0o700);
+    if (debug) console.debug(`Extracted ${name}`);
+  }
+}
+if (import.meta.main) {
+  const args = parseArgs(Deno.args, {
+    string: [
+      "version",
+      "path",
+      "arch"
+    ],
+    boolean: [
+      "env",
+      "force",
+      "debug",
+      "help"
+    ],
+    alias: {
+      v: "version",
+      p: "path",
+      a: "arch",
+      e: "env",
+      f: "force",
+      d: "debug",
+      h: "help"
+    }
+  });
+  if (args.help) {
+    console.log(`Downloads Chromium binary for AWS Lambda environment.
+
+Usage:
+  deno run jsr:@libs/toolbox/download-lambda-chromium [options]
+
+Options:
+  -v, --version       Chromium version. Default is 141.0.0
+  -p, --path          Path to save Chromium binary. Default is /tmp/chromium
+  -a, --arch          System architecture. Default is current architecture
+  -e, --env           Set environment variables for FONTCONFIG_PATH and LD_LIBRARY_PATH (requires --allow-env). Default is true
+  -f, --force         Force download even if file exists
+  -d, --debug         Enable debug logging
+  -h, --help          Show this help message
+`);
+    Deno.exit(2);
+  }
+  const path = await chromium({
+    version: args.version,
+    path: args.path,
+    arch: args.arch,
+    env: args.env,
+    force: args.force,
+    debug: args.debug
+  });
+  console.log(path);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/scripts/download_lambda_chromium.ts"],"sourcesContent":["// Imports\n// deno-lint-ignore-file no-console no-external-import\nimport type { Buffer } from \"node:buffer\"\nimport { brotliDecompressSync } from \"node:zlib\"\nimport { ensureDir, exists } from \"@std/fs\"\nimport { basename, dirname, join, resolve } from \"@std/path\"\nimport { UntarStream } from \"@std/tar\"\nimport { toArrayBuffer } from \"@std/streams\"\nimport { parseArgs } from \"@std/cli\"\n\n/** Locks. */\nconst locks = new Map<string, Promise<string>>()\n\n/** Chromium download options. */\nexport type ChromiumOptions = {\n  /** Chromium version. Default is `141.0.0`. */\n  version?: string\n  /** Path to save Chromium binary. Default is `/tmp/chromium`. */\n  path?: string\n  /** System architecture. Default is current architecture. */\n  arch?: typeof Deno.build.arch\n  /** Download URL. */\n  url?: string\n  /** Force download even if file exists. */\n  force?: boolean\n  /** Set environment variables for `FONTCONFIG_PATH` and `LD_LIBRARY_PATH` (requires --allow-env). Default is `true`. */\n  env?: boolean\n  /** Enable debugging. */\n  debug?: boolean\n}\n\n/** Download Chromium binary for AWS Lambda environment. */\nexport function chromium({ version = \"141.0.0\", path = \"/tmp/chromium\", arch = Deno.build.arch, force = false, env = true, debug = false }: ChromiumOptions = {}): Promise<string> {\n  // Install browser\n  path = resolve(path)\n  if (!locks.has(path)) {\n    locks.set(\n      path,\n      // deno-lint-ignore no-async-promise-executor\n      new Promise<string>(async (resolve, reject) => {\n        try {\n          if ((!await exists(path)) || force) {\n            const url = `https://github.com/Sparticuz/chromium/releases/download/v${version}/chromium-v${version}-pack.${{ x86_64: \"x64\", aarch64: \"arm64\" }[arch] ?? \"unknown\"}.tar`\n            if (debug)\n              console.debug(`Downloading Chromium v${version} from ${url}`)\n            const response = await fetch(url)\n            if (!response.ok) {\n              await response.body?.cancel()\n              throw new Error(`Failed to download Chromium: ${response.status} ${url}`)\n            }\n            await extract(response.body!, { path: dirname(path), debug })\n          }\n          resolve(path)\n        } catch (error) {\n          reject(error)\n        }\n      }),\n    )\n  }\n  // Set environment variables\n  if (env) {\n    if (!Deno.env.get(\"FONTCONFIG_PATH\")) {\n      Deno.env.set(\"FONTCONFIG_PATH\", join(dirname(path), \"fonts\"))\n      if (debug)\n        console.debug(`Set FONTCONFIG_PATH to ${Deno.env.get(\"FONTCONFIG_PATH\")}`)\n    }\n    if (!Deno.env.get(\"LD_LIBRARY_PATH\")?.includes(join(dirname(path), \"al2023\"))) {\n      Deno.env.set(\"LD_LIBRARY_PATH\", [join(dirname(path), \"al2023\"), Deno.env.get(\"LD_LIBRARY_PATH\")].join(\":\"))\n      if (debug)\n        console.debug(`Set LD_LIBRARY_PATH to ${Deno.env.get(\"LD_LIBRARY_PATH\")}`)\n    }\n  }\n\n  return locks.get(path)!\n}\n\n/** Extract tar stream. */\nasync function extract(stream: ReadableStream<Uint8Array<ArrayBuffer>>, { path, debug }: { path: string; debug?: boolean }) {\n  for await (const entry of stream.pipeThrough(new UntarStream())) {\n    if (!entry.readable)\n      continue\n    let name = basename(entry.path)\n    let buffer = await toArrayBuffer(entry.readable) as ArrayBuffer | Buffer<ArrayBufferLike>\n    if (name.endsWith(\".br\")) {\n      name = basename(name, \".br\")\n      buffer = brotliDecompressSync(buffer, { chunkSize: 2 ** 21 })\n    }\n    if (name.endsWith(\".tar\")) {\n      name = basename(name, \".tar\")\n      await extract(ReadableStream.from([new Uint8Array(buffer)]), { path: name === \"swiftshader\" ? path : join(path, name), debug })\n      continue\n    }\n    name = join(path, name)\n    await ensureDir(dirname(name))\n    await Deno.writeFile(name, new Uint8Array(buffer))\n    await Deno.chmod(name, 0o700)\n    if (debug)\n      console.debug(`Extracted ${name}`)\n  }\n}\n\nif (import.meta.main) {\n  const args = parseArgs(Deno.args, { string: [\"version\", \"path\", \"arch\"], boolean: [\"env\", \"force\", \"debug\", \"help\"], alias: { v: \"version\", p: \"path\", a: \"arch\", e: \"env\", f: \"force\", d: \"debug\", h: \"help\" } })\n  if (args.help) {\n    console.log(`Downloads Chromium binary for AWS Lambda environment.\n\nUsage:\n  deno run jsr:@libs/toolbox/download-lambda-chromium [options]\n\nOptions:\n  -v, --version       Chromium version. Default is 141.0.0\n  -p, --path          Path to save Chromium binary. Default is /tmp/chromium\n  -a, --arch          System architecture. Default is current architecture\n  -e, --env           Set environment variables for FONTCONFIG_PATH and LD_LIBRARY_PATH (requires --allow-env). Default is true\n  -f, --force         Force download even if file exists\n  -d, --debug         Enable debug logging\n  -h, --help          Show this help message\n`)\n    Deno.exit(2)\n  }\n  const path = await chromium({ version: args.version, path: args.path, arch: args.arch as typeof Deno.build.arch, env: args.env, force: args.force, debug: args.debug })\n  console.log(path)\n}\n"],"names":[],"mappings":"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"}

package/scripts/highlight_coverage.js

@@ -0,0 +1,62 @@
+// deno-lint-ignore-file no-console
+import { parseArgs } from "@std/cli";
+import { gray, green } from "@std/fmt/colors";
+import { expandGlob } from "@std/fs";
+// deno-lint-ignore no-import-prefix
+const { default: hljs } = await import("highlight.js");
+const args = parseArgs(Deno.args, {
+  string: [
+    "root",
+    "language"
+  ],
+  boolean: [
+    "help"
+  ],
+  default: {
+    root: "coverage",
+    language: "ts"
+  }
+});
+if (args.help) {
+  console.error(`Usage: deno run --allow-read --allow-write jsr:@libs/toolbox/scripts/highlight-coverage`);
+  console.error(``);
+  console.error(`Enhances HTML coverage reports generated by "deno coverage --html" with matcha.css styling and highlight.js syntax highlighting.`);
+  console.error(``);
+  console.error(`Options:`);
+  console.error(`  --root=DIR       Root directory to search for html coverage reports (default: coverage)`);
+  console.error(`  --language=LANG  Language used for syntax highlighting (default: ts)`);
+  console.error(`  --help           Show this help message`);
+  console.error(``);
+  Deno.exit(2);
+}
+const stylesheets = [
+  "@root",
+  "@syntax-highlighting",
+  "@istanbul-coverage"
+].map((name)=>`<link rel='stylesheet' href='https://matcha.mizu.sh/styles/${name}/mod.css'>`).join("");
+const entities = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&amp;": "&"
+};
+for await (const { path } of expandGlob("**/*.html", {
+  root: args.root
+})){
+  let html = await Deno.readTextFile(path);
+  if (!/<title>Coverage report/.test(html)) {
+    console.error(gray(`∅ ${path}`));
+    continue;
+  }
+  if (!html.includes("matcha.mizu.sh")) html = html.replace("</head>", `${stylesheets}</head>`);
+  html = html.replace(/<pre class='prettyprint'>([\s\S]*?)<\/pre>/g, (_, code)=>{
+    const text = Object.entries(entities).reduce((text, [entity, character])=>text.replaceAll(entity, character), code.replace(/<[^>]*>/g, ""));
+    return `<pre class='prettyprint hljs' data-highlighted='true'>${hljs.highlight(text, {
+      language: args.language
+    }).value}</pre>`;
+  });
+  await Deno.writeTextFile(path, html);
+  console.error(green(`✓ ${path}`));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/scripts/publish/_utils.js

@@ -0,0 +1,95 @@
+// Imports
+import { expandGlob } from "@std/fs";
+import { dirname, resolve } from "@std/path";
+import * as JSONC from "@std/jsonc/parse";
+/**
+ * Rewrite the scope of import specifiers in file content.
+ *
+ * An empty `to` removes the scope entirely.
+ *
+ * ```ts
+ * import { rescope } from "./_utils.ts"
+ * rescope('import { command } from "@lowlighter/run/command"', { from: "@libs", to: "@lowlighter" })
+ * ```
+ */ export function rescope(content, { from, to }) {
+  return content.replaceAll(`"${from}/`, to ? `"${to}/` : `"`);
+}
+/**
+ * Resolve all imports from file content against an import map.
+ *
+ * Bare specifiers matching an import map entry are replaced by their mapped value,
+ * and specifiers matching a trailing-slash entry have their prefix substituted.
+ *
+ * Both static imports and statically analyzable dynamic imports (i.e. `import()` calls with a string literal) are resolved.
+ *
+ * ```ts
+ * import { unmap } from "./_utils.ts"
+ * unmap('import { command } from "@lowlighter/run/command"', { "@lowlighter/run/": "jsr:@libs/run@^3.0.0/" })
+ * ```
+ */ export function unmap(content, imports) {
+  let resolved = 0;
+  const directories = Object.keys(imports).filter((module)=>module.endsWith("/"));
+  const remap = (module)=>{
+    let mapped = null;
+    if (module in imports) mapped = imports[module];
+    else if (directories.some((directory)=>module.startsWith(directory))) {
+      const [directory] = directories.filter((directory)=>module.startsWith(directory)).sort((a, b)=>b.length - a.length);
+      mapped = module.replace(directory, imports[directory]);
+    }
+    return mapped;
+  };
+  const substitute = (match, statement, quote, module)=>{
+    const mapped = remap(module);
+    if (typeof mapped === "string") {
+      resolved++;
+      return `${statement}${mapped}${quote}`;
+    }
+    return match;
+  };
+  const result = content.replace(/^(?<statement>\s*(?:import|export)\s*(?:(?:\s+type)?\s+(?:[^\n]+?|(?:\{[\s\S]*?\}))\s+from\s+)?(?<quote>["']))(?<module>[^\n]+?)\k<quote>/gm, substitute).replace(/(?<statement>\bimport\s*\(\s*(?<quote>["']))(?<module>[^"'\n]+?)\k<quote>/g, substitute);
+  return {
+    result,
+    resolved
+  };
+}
+/**
+ * Compute an import map for workspace members.
+ *
+ * The workspace root is located by walking up from `cwd` until a `deno.json(c)` manifest with a `workspace` field is found.
+ * Each member with a `name` and `version` is mapped to its jsr.io counterpart (e.g. `@libs/run/` → `jsr:@libs/run@^3.0.0/`),
+ * so cross-package imports resolved through the workspace keep working once published on deno.land/x.
+ */ export async function workspaceImports(cwd = Deno.cwd()) {
+  const imports = {};
+  for(let root = resolve(cwd);; root = dirname(root)){
+    const parsed = manifest(root);
+    if (parsed?.workspace) {
+      for (const member of parsed.workspace){
+        for await (const { path } of expandGlob(`${member}/deno.json?(c)`, {
+          root,
+          includeDirs: false
+        })){
+          const { name, version } = manifest(dirname(path));
+          if (!name || !version) continue;
+          imports[name] = `jsr:${name}@^${version}`;
+          imports[`${name}/`] = `jsr:${name}@^${version}/`;
+        }
+      }
+      return imports;
+    }
+    if (root === dirname(root)) return imports;
+  }
+}
+/** Read and parse the `deno.jsonc` or `deno.json` manifest from a directory (`null` when absent). */ export function manifest(directory) {
+  for (const filename of [
+    "deno.jsonc",
+    "deno.json"
+  ]){
+    try {
+      return JSONC.parse(Deno.readTextFileSync(resolve(directory, filename)));
+    } catch (error) {
+      if (!(error instanceof Deno.errors.NotFound)) throw error;
+    }
+  }
+  return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/scripts/publish/_utils.ts"],"sourcesContent":["// Imports\nimport type { Nullable } from \"@libs/typing\"\nimport { expandGlob } from \"@std/fs\"\nimport { dirname, resolve } from \"@std/path\"\nimport * as JSONC from \"@std/jsonc/parse\"\n\n/**\n * Rewrite the scope of import specifiers in file content.\n *\n * An empty `to` removes the scope entirely.\n *\n * ```ts\n * import { rescope } from \"./_utils.ts\"\n * rescope('import { command } from \"@libs/run/command\"', { from: \"@libs\", to: \"@lowlighter\" })\n * ```\n */\nexport function rescope(content: string, { from, to }: { from: string; to: string }): string {\n  return content.replaceAll(`\"${from}/`, to ? `\"${to}/` : `\"`)\n}\n\n/**\n * Resolve all imports from file content against an import map.\n *\n * Bare specifiers matching an import map entry are replaced by their mapped value,\n * and specifiers matching a trailing-slash entry have their prefix substituted.\n *\n * Both static imports and statically analyzable dynamic imports (i.e. `import()` calls with a string literal) are resolved.\n *\n * ```ts\n * import { unmap } from \"./_utils.ts\"\n * unmap('import { command } from \"@libs/run/command\"', { \"@libs/run/\": \"jsr:@libs/run@^3.0.0/\" })\n * ```\n */\nexport function unmap(content: string, imports: Record<string, string>): { result: string; resolved: number } {\n  let resolved = 0\n  const directories = Object.keys(imports).filter((module) => module.endsWith(\"/\"))\n  const remap = (module: string) => {\n    let mapped = null as Nullable<string>\n    if (module in imports)\n      mapped = imports[module]\n    else if (directories.some((directory) => module.startsWith(directory))) {\n      const [directory] = directories.filter((directory) => module.startsWith(directory)).sort((a, b) => b.length - a.length)\n      mapped = module.replace(directory, imports[directory])\n    }\n    return mapped\n  }\n  const substitute = (match: string, statement: string, quote: string, module: string) => {\n    const mapped = remap(module)\n    if (typeof mapped === \"string\") {\n      resolved++\n      return `${statement}${mapped}${quote}`\n    }\n    return match\n  }\n  const result = content\n    .replace(/^(?<statement>\\s*(?:import|export)\\s*(?:(?:\\s+type)?\\s+(?:[^\\n]+?|(?:\\{[\\s\\S]*?\\}))\\s+from\\s+)?(?<quote>[\"']))(?<module>[^\\n]+?)\\k<quote>/gm, substitute)\n    .replace(/(?<statement>\\bimport\\s*\\(\\s*(?<quote>[\"']))(?<module>[^\"'\\n]+?)\\k<quote>/g, substitute)\n  return { result, resolved }\n}\n\n/**\n * Compute an import map for workspace members.\n *\n * The workspace root is located by walking up from `cwd` until a `deno.json(c)` manifest with a `workspace` field is found.\n * Each member with a `name` and `version` is mapped to its jsr.io counterpart (e.g. `@libs/run/` → `jsr:@libs/run@^3.0.0/`),\n * so cross-package imports resolved through the workspace keep working once published on deno.land/x.\n */\nexport async function workspaceImports(cwd: string = Deno.cwd()): Promise<Record<string, string>> {\n  const imports = {} as Record<string, string>\n  for (let root = resolve(cwd);; root = dirname(root)) {\n    const parsed = manifest(root)\n    if (parsed?.workspace) {\n      for (const member of parsed.workspace) {\n        for await (const { path } of expandGlob(`${member}/deno.json?(c)`, { root, includeDirs: false })) {\n          const { name, version } = manifest(dirname(path))!\n          if ((!name) || (!version))\n            continue\n          imports[name] = `jsr:${name}@^${version}`\n          imports[`${name}/`] = `jsr:${name}@^${version}/`\n        }\n      }\n      return imports\n    }\n    if (root === dirname(root))\n      return imports\n  }\n}\n\n/** Parsed `deno.json(c)` manifest. */\ntype Manifest = { name?: string; version?: string; workspace?: string[]; imports?: Record<string, string>; publish?: { exclude?: string[] } }\n\n/** Read and parse the `deno.jsonc` or `deno.json` manifest from a directory (`null` when absent). */\nexport function manifest(directory: string): Nullable<Manifest> {\n  for (const filename of [\"deno.jsonc\", \"deno.json\"]) {\n    try {\n      return JSONC.parse(Deno.readTextFileSync(resolve(directory, filename))) as Manifest\n    } catch (error) {\n      if (!(error instanceof Deno.errors.NotFound))\n        throw error\n    }\n  }\n  return null\n}\n"],"names":[],"mappings":"AAAA,UAAU;AAEV,SAAS,UAAU,QAAQ,UAAS;AACpC,SAAS,OAAO,EAAE,OAAO,QAAQ,YAAW;AAC5C,YAAY,WAAW,mBAAkB;AAEzC;;;;;;;;;CASC,GACD,OAAO,SAAS,QAAQ,OAAe,EAAE,EAAE,IAAI,EAAE,EAAE,EAAgC;EACjF,OAAO,QAAQ,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7D;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAAS,MAAM,OAAe,EAAE,OAA+B;EACpE,IAAI,WAAW;EACf,MAAM,cAAc,OAAO,IAAI,CAAC,SAAS,MAAM,CAAC,CAAC,SAAW,OAAO,QAAQ,CAAC;EAC5E,MAAM,QAAQ,CAAC;IACb,IAAI,SAAS;IACb,IAAI,UAAU,SACZ,SAAS,OAAO,CAAC,OAAO;SACrB,IAAI,YAAY,IAAI,CAAC,CAAC,YAAc,OAAO,UAAU,CAAC,aAAa;MACtE,MAAM,CAAC,UAAU,GAAG,YAAY,MAAM,CAAC,CAAC,YAAc,OAAO,UAAU,CAAC,YAAY,IAAI,CAAC,CAAC,GAAG,IAAM,EAAE,MAAM,GAAG,EAAE,MAAM;MACtH,SAAS,OAAO,OAAO,CAAC,WAAW,OAAO,CAAC,UAAU;IACvD;IACA,OAAO;EACT;EACA,MAAM,aAAa,CAAC,OAAe,WAAmB,OAAe;IACnE,MAAM,SAAS,MAAM;IACrB,IAAI,OAAO,WAAW,UAAU;MAC9B;MACA,OAAO,GAAG,YAAY,SAAS,OAAO;IACxC;IACA,OAAO;EACT;EACA,MAAM,SAAS,QACZ,OAAO,CAAC,+IAA+I,YACvJ,OAAO,CAAC,8EAA8E;EACzF,OAAO;IAAE;IAAQ;EAAS;AAC5B;AAEA;;;;;;CAMC,GACD,OAAO,eAAe,iBAAiB,MAAc,KAAK,GAAG,EAAE;EAC7D,MAAM,UAAU,CAAC;EACjB,IAAK,IAAI,OAAO,QAAQ,OAAO,OAAO,QAAQ,MAAO;IACnD,MAAM,SAAS,SAAS;IACxB,IAAI,QAAQ,WAAW;MACrB,KAAK,MAAM,UAAU,OAAO,SAAS,CAAE;QACrC,WAAW,MAAM,EAAE,IAAI,EAAE,IAAI,WAAW,GAAG,OAAO,cAAc,CAAC,EAAE;UAAE;UAAM,aAAa;QAAM,GAAI;UAChG,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,SAAS,QAAQ;UAC3C,IAAI,AAAC,CAAC,QAAU,CAAC,SACf;UACF,OAAO,CAAC,KAAK,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS;UACzC,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,QAAQ,CAAC,CAAC;QAClD;MACF;MACA,OAAO;IACT;IACA,IAAI,SAAS,QAAQ,OACnB,OAAO;EACX;AACF;AAKA,mGAAmG,GACnG,OAAO,SAAS,SAAS,SAAiB;EACxC,KAAK,MAAM,YAAY;IAAC;IAAc;GAAY,CAAE;IAClD,IAAI;MACF,OAAO,MAAM,KAAK,CAAC,KAAK,gBAAgB,CAAC,QAAQ,WAAW;IAC9D,EAAE,OAAO,OAAO;MACd,IAAI,CAAC,CAAC,iBAAiB,KAAK,MAAM,CAAC,QAAQ,GACzC,MAAM;IACV;EACF;EACA,OAAO;AACT"}

package/scripts/publish/npm.d.ts

@@ -0,0 +1,11 @@
+/** Publish a package on npm registries. */ export declare function publish({}?: Options): Promise<{
+  name: string;
+  version: string;
+  directory: string;
+}>;
+/** Publishing options for {@linkcode publish()}. */ export type Options = {
+  /** Path to the package to publish (defaults to the current working directory). */ package?: string;
+  /** Scope to publish under: `"@"` keeps the original scope (default), `""` removes the scope, any other value replaces it. */ scope?: string;
+  /** Whether to publish with private (restricted) registry access (defaults to `false`). */ private?: boolean;
+  /** Do not actually publish (the package is packed and rewritten, but `npm publish` is run with `--dry-run`). */ dryrun?: boolean;
+};

package/scripts/publish/npm.js

@@ -0,0 +1,130 @@
+// deno-lint-ignore-file no-console
+/**
+ * Publish a package on npm registries.
+ *
+ * 1. Run `deno pack` to create an npm-compatible tarball
+ * 2. Extract it and rewrite the package scope (e.g. `@libs/git` → `@lowlighter/git`), both in `package.json` and in compiled files
+ * 3. Add `dependencies` entries for workspace members imported by the package (which `deno pack` leaves as bare specifiers)
+ * 4. Run `npm publish` on the extracted package
+ *
+ * Authentication is expected to be configured beforehand (e.g. through a `~/.npmrc` file).
+ *
+ * @module
+ */ // Imports
+import { parseArgs } from "@std/cli";
+import { expandGlob } from "@std/fs";
+import { command } from "@lowlighter/run/command";
+import { rescope, workspaceImports } from "./_utils.js";
+import { cyan, gray, green } from "@std/fmt/colors";
+/** Publish a package on npm registries. */ export async function publish({ package: pkg = Deno.cwd(), scope = "@", private: restricted = false, dryrun = false } = {}) {
+  // Create npm-compatible tarball and extract it
+  const env = Deno.env.toObject();
+  const directory = await Deno.makeTempDir();
+  console.error(`packing ${pkg} to ${directory}`);
+  await command("deno", [
+    "pack",
+    "--allow-dirty",
+    "--quiet",
+    "--output",
+    `${directory}/package.tgz`
+  ], {
+    env,
+    cwd: pkg,
+    throw: true
+  });
+  await command("tar", [
+    "--extract",
+    "--gzip",
+    `--file=${directory}/package.tgz`,
+    `--directory=${directory}`
+  ], {
+    env,
+    throw: true
+  });
+  // Rewrite package scope and register workspace dependencies
+  const manifest = JSON.parse(await Deno.readTextFile(`${directory}/package/package.json`));
+  if (!manifest.name.startsWith("@")) throw new RangeError(`Package name is not scoped: ${manifest.name}`);
+  const from = manifest.name.split("/")[0];
+  const to = scope === "@" ? from : scope;
+  const rename = (name)=>to ? name.replace(from, to) : name.replace(`${from}/`, "");
+  const workspace = await workspaceImports(pkg);
+  const members = Object.fromEntries(Object.entries(workspace).filter(([member])=>!member.endsWith("/")).map(([member, jsr])=>[
+      member,
+      jsr.match(/@\^(?<version>.*)$/).groups.version
+    ]));
+  manifest.name = rename(manifest.name);
+  console.error(`rewriting scope ${from} → ${to || "(no scope)"} for ${manifest.name}@${manifest.version}`);
+  for await (const { path } of expandGlob("package/**/*.{js,mjs,cjs,ts,mts,cts}", {
+    root: directory,
+    includeDirs: false
+  })){
+    const content = await Deno.readTextFile(path);
+    for (const [member, version] of Object.entries(members)){
+      if (new RegExp(`["']${member}(?:/[^"']*)?["']`).test(content)) {
+        manifest.dependencies ??= {};
+        manifest.dependencies[rename(member)] ??= `^${version}`;
+      }
+    }
+    await Deno.writeTextFile(path, rescope(content, {
+      from,
+      to
+    }));
+  }
+  const manifestJson = JSON.stringify(manifest, null, 2);
+  console.error(gray(manifestJson));
+  await Deno.writeTextFile(`${directory}/package/package.json`, `${manifestJson}\n`);
+  // Publish extracted package
+  console.error(cyan(`publishing ${manifest.name}@${manifest.version}${dryrun ? " (dryrun)" : ""}`));
+  await command("npm", [
+    "publish",
+    `${directory}/package`,
+    "--access",
+    restricted ? "restricted" : "public",
+    ...dryrun ? [
+      "--dry-run"
+    ] : []
+  ], {
+    env,
+    throw: true
+  });
+  console.error(green(`published ${manifest.name}@${manifest.version}`));
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    directory
+  };
+}
+// Entry point
+if (import.meta.main) {
+  const args = parseArgs(Deno.args, {
+    string: [
+      "package",
+      "scope"
+    ],
+    boolean: [
+      "private",
+      "dryrun",
+      "help"
+    ],
+    default: {
+      scope: "@"
+    }
+  });
+  if (args.help) {
+    console.error("Usage: deno run --allow-all jsr:@libs/toolbox/scripts/publish/npm [options]");
+    console.error("");
+    console.error("Options:");
+    console.error("  --package [package]  Path to the package to publish (defaults to the current working directory)");
+    console.error("  --scope [scope=@]    Scope to publish under (`@` keeps the original scope, an empty value removes it, any other value replaces it)");
+    console.error("  --private            Publish with private (restricted) registry access (default: public)");
+    console.error("  --dryrun             Do not actually publish");
+    Deno.exit(2);
+  }
+  await publish({
+    package: args.package,
+    scope: args.scope,
+    private: args.private,
+    dryrun: args.dryrun
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/scripts/publish/npm.ts"],"sourcesContent":["// deno-lint-ignore-file no-console\n/**\n * Publish a package on npm registries.\n *\n * 1. Run `deno pack` to create an npm-compatible tarball\n * 2. Extract it and rewrite the package scope (e.g. `@libs/git` → `@lowlighter/git`), both in `package.json` and in compiled files\n * 3. Add `dependencies` entries for workspace members imported by the package (which `deno pack` leaves as bare specifiers)\n * 4. Run `npm publish` on the extracted package\n *\n * Authentication is expected to be configured beforehand (e.g. through a `~/.npmrc` file).\n *\n * @module\n */\n\n// Imports\nimport { parseArgs } from \"@std/cli\"\nimport { expandGlob } from \"@std/fs\"\nimport { command } from \"@libs/run/command\"\nimport { rescope, workspaceImports } from \"./_utils.js\"\nimport { cyan, gray, green } from \"@std/fmt/colors\"\n\n/** Publish a package on npm registries. */\nexport async function publish({ package: pkg = Deno.cwd(), scope = \"@\", private: restricted = false, dryrun = false }: Options = {}): Promise<{ name: string; version: string; directory: string }> {\n  // Create npm-compatible tarball and extract it\n  const env = Deno.env.toObject()\n  const directory = await Deno.makeTempDir()\n  console.error(`packing ${pkg} to ${directory}`)\n  await command(\"deno\", [\"pack\", \"--allow-dirty\", \"--quiet\", \"--output\", `${directory}/package.tgz`], { env, cwd: pkg, throw: true })\n  await command(\"tar\", [\"--extract\", \"--gzip\", `--file=${directory}/package.tgz`, `--directory=${directory}`], { env, throw: true })\n\n  // Rewrite package scope and register workspace dependencies\n  const manifest = JSON.parse(await Deno.readTextFile(`${directory}/package/package.json`)) as { name: string; version: string; dependencies?: Record<string, string> }\n  if (!manifest.name.startsWith(\"@\"))\n    throw new RangeError(`Package name is not scoped: ${manifest.name}`)\n  const from = manifest.name.split(\"/\")[0]\n  const to = scope === \"@\" ? from : scope\n  const rename = (name: string) => to ? name.replace(from, to) : name.replace(`${from}/`, \"\")\n  const workspace = await workspaceImports(pkg)\n  const members = Object.fromEntries(\n    Object.entries(workspace)\n      .filter(([member]) => !member.endsWith(\"/\"))\n      .map(([member, jsr]) => [member, jsr.match(/@\\^(?<version>.*)$/)!.groups!.version]),\n  )\n  manifest.name = rename(manifest.name)\n  console.error(`rewriting scope ${from} → ${to || \"(no scope)\"} for ${manifest.name}@${manifest.version}`)\n  for await (const { path } of expandGlob(\"package/**/*.{js,mjs,cjs,ts,mts,cts}\", { root: directory, includeDirs: false })) {\n    const content = await Deno.readTextFile(path)\n    for (const [member, version] of Object.entries(members)) {\n      if (new RegExp(`[\"']${member}(?:/[^\"']*)?[\"']`).test(content)) {\n        manifest.dependencies ??= {}\n        manifest.dependencies[rename(member)] ??= `^${version}`\n      }\n    }\n    await Deno.writeTextFile(path, rescope(content, { from, to }))\n  }\n  const manifestJson = JSON.stringify(manifest, null, 2)\n  console.error(gray(manifestJson))\n  await Deno.writeTextFile(`${directory}/package/package.json`, `${manifestJson}\\n`)\n\n  // Publish extracted package\n  console.error(cyan(`publishing ${manifest.name}@${manifest.version}${dryrun ? \" (dryrun)\" : \"\"}`))\n  await command(\"npm\", [\"publish\", `${directory}/package`, \"--access\", restricted ? \"restricted\" : \"public\", ...(dryrun ? [\"--dry-run\"] : [])], { env, throw: true })\n  console.error(green(`published ${manifest.name}@${manifest.version}`))\n  return { name: manifest.name, version: manifest.version, directory }\n}\n\n/** Publishing options for {@linkcode publish()}. */\nexport type Options = {\n  /** Path to the package to publish (defaults to the current working directory). */\n  package?: string\n  /** Scope to publish under: `\"@\"` keeps the original scope (default), `\"\"` removes the scope, any other value replaces it. */\n  scope?: string\n  /** Whether to publish with private (restricted) registry access (defaults to `false`). */\n  private?: boolean\n  /** Do not actually publish (the package is packed and rewritten, but `npm publish` is run with `--dry-run`). */\n  dryrun?: boolean\n}\n\n// Entry point\nif (import.meta.main) {\n  const args = parseArgs(Deno.args, { string: [\"package\", \"scope\"], boolean: [\"private\", \"dryrun\", \"help\"], default: { scope: \"@\" } })\n  if (args.help) {\n    console.error(\"Usage: deno run --allow-all jsr:@libs/toolbox/scripts/publish/npm [options]\")\n    console.error(\"\")\n    console.error(\"Options:\")\n    console.error(\"  --package [package]  Path to the package to publish (defaults to the current working directory)\")\n    console.error(\"  --scope [scope=@]    Scope to publish under (`@` keeps the original scope, an empty value removes it, any other value replaces it)\")\n    console.error(\"  --private            Publish with private (restricted) registry access (default: public)\")\n    console.error(\"  --dryrun             Do not actually publish\")\n    Deno.exit(2)\n  }\n  await publish({ package: args.package, scope: args.scope, private: args.private, dryrun: args.dryrun })\n}\n"],"names":[],"mappings":"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"}

package/scripts/publish/x.d.ts

@@ -0,0 +1,20 @@
+/** Publish a package on deno.land/x. */ export declare function publish({}: Options): Promise<{
+  name: string;
+  version: string;
+  url: string;
+  changed: boolean;
+}>;
+/** Publishing options for {@linkcode publish()}. */ export type Options = {
+  /** GitHub API token. */ token: string;
+  /** GitHub repository (e.g. `octocat/hello-world`). */ repository: string;
+  /** Package name on deno.land/x. */ name: string;
+  /** Version to publish. */ version: string;
+  /** Subdirectory of the repository to publish (optional). */ directory?: string;
+  /** Path to an import map. When specified, a temporary branch with all imports resolved is created and published instead. */ map?: string;
+  /** Activate the webhook before publishing and restore its state afterwards. */ reactive?: boolean;
+  /** Remove the tag after publishing. */ remove?: boolean;
+  /** Maximum number of attempts for publishing operations to complete. */ attempts?: number;
+  /** Delay between each attempt (in milliseconds). */ delay?: number;
+  /** Do not actually publish (no file is written and no mutating git or remote call is made). */ dryrun?: boolean;
+  /** Fetch implementation (mostly used for testing purposes). */ fetcher?: typeof fetch;
+};