@lowlighter/toolbox 1.0.1

package/scripts/publish/x.js

@@ -0,0 +1,303 @@
+// deno-lint-ignore-file no-console
+/**
+ * Publish a package on deno.land/x.
+ *
+ * 1. Check whether `https://deno.land/x/<name>@<version>` is already published (in which case there is nothing to do)
+ * 2. When `map` is set, create a temporary git branch where all imports are resolved against import maps
+ *    (raw imports served by deno.land/x cannot resolve import maps, so bare specifiers are rewritten to fully qualified ones)
+ * 3. Search the github repository for the deno.land/x webhook, and activate it when `reactive` is set
+ *    (this lets you keep the hook disabled by default so unrelated tags are not published)
+ * 4. Create and push a git tag named after `version` to trigger the webhook
+ * 5. Wait for the webhook payload delivery and for the version to be published on deno.land/x
+ * 6. Restore the webhook state, and clean up the temporary branch and tag (when `remove` is set)
+ *
+ * Note that you must configure the webhook on deno.land/x prior to using this script.
+ *
+ * @module
+ */ // Imports
+import { parseArgs } from "@std/cli";
+import { expandGlob } from "@std/fs";
+import { dirname, resolve } from "@std/path";
+import { command } from "@lowlighter/run/command";
+import { commit, pull, push, tag } from "@lowlighter/git";
+import { manifest, unmap, workspaceImports } from "./_utils.js";
+import { cyan, gray, green, yellow } from "@std/fmt/colors";
+/** Publish a package on deno.land/x. */ export async function publish({ token, repository, name, version, directory = "", map = "", reactive = false, remove = false, attempts = 30, delay = 30000, dryrun = false, fetcher = fetch }) {
+  directory = directory.trim().replace(/\/$/, "");
+  const hooked = `https://api.deno.land/webhook/gh/${name}${directory ? `?subdir=${encodeURIComponent(`/${directory}/`)}` : ""}`;
+  const url = `https://deno.land/x/${name}@${version}`;
+  const github = (path, init = {})=>fetcher(`https://api.github.com/repos/${repository}${path}`, {
+      ...init,
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`
+      }
+    }).then(async (response)=>{
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`GitHub API request failed with status ${response.status}: ${path}`);
+      }
+      return response.json();
+    });
+  const published = ()=>fetcher(url, {
+      headers: {
+        Accept: "text/html"
+      }
+    }).then(async (response)=>{
+      await response.body?.cancel();
+      return response.ok;
+    });
+  const sleep = ()=>new Promise((resolve)=>setTimeout(resolve, delay));
+  // Check if package is already published
+  if (await published()) {
+    console.error(`${url} is already published, nothing to do`);
+    return {
+      name,
+      version,
+      url,
+      changed: false
+    };
+  }
+  // Resolve imports on a temporary branch if needed
+  const branch = {
+    current: "",
+    temporary: ""
+  };
+  try {
+    if (map) {
+      branch.current = command("git", [
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD"
+      ], {
+        sync: true,
+        throw: true
+      }).stdout.trim();
+      branch.temporary = `x-${name}-${version}`;
+      console.error(`switching from ${branch.current} to temporary branch ${branch.temporary}`);
+      if (!dryrun) {
+        command("git", [
+          "switch",
+          "--create",
+          branch.temporary
+        ], {
+          sync: true,
+          throw: true
+        });
+        push(branch.temporary);
+        command("git", [
+          "branch",
+          "--set-upstream-to",
+          `origin/${branch.temporary}`
+        ], {
+          sync: true,
+          throw: true
+        });
+      }
+      const cwd = resolve(Deno.cwd());
+      const workspace = await workspaceImports(cwd);
+      const mapped = manifest(dirname(resolve(cwd, map)))?.imports ?? {};
+      const exclude = [
+        ...new Set([
+          ...manifest(cwd)?.publish?.exclude ?? [],
+          "node_modules",
+          ".git",
+          "coverage",
+          ".github"
+        ])
+      ];
+      for await (const { path } of expandGlob("**/*.ts", {
+        root: cwd,
+        includeDirs: false,
+        exclude
+      })){
+        // Resolve against workspace members, the nearest manifest imports and the specified map
+        let local = {};
+        for(let base = dirname(path); base.startsWith(cwd); base = dirname(base)){
+          const parsed = manifest(base);
+          if (parsed) {
+            local = parsed.imports ?? {};
+            break;
+          }
+        }
+        const { result, resolved } = unmap(await Deno.readTextFile(path), {
+          ...workspace,
+          ...local,
+          ...mapped
+        });
+        if (resolved) {
+          console.error(gray(`resolved ${resolved} imports in ${path}`));
+          if (!dryrun) await Deno.writeTextFile(path, result);
+        }
+      }
+      console.error(gray(`committing resolved imports on ${branch.temporary}`));
+      if (!dryrun) {
+        commit(`build(${name}): deno.land/x@${version}`, {
+          all: true
+        });
+        push(branch.temporary);
+      }
+    }
+    // Search webhook and activate it if needed
+    const webhooks = await github("/hooks");
+    const hook = webhooks.find(({ config })=>config.url === hooked);
+    if (!hook) throw new Error(`Could not find a hook with expected url: ${hooked}`);
+    console.error(`found hook ${hook.id} (active: ${hook.active})`);
+    if (reactive && !hook.active) {
+      console.error(yellow("hook is inactive prior publishing, activating"));
+      if (!dryrun) await github(`/hooks/${hook.id}`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          active: true
+        })
+      });
+    }
+    try {
+      // Create and push tag to trigger webhook
+      console.error(`creating and pushing tag ${version}`);
+      const pushed = Date.now();
+      if (!dryrun) {
+        tag(version, {
+          force: true
+        });
+        pull({
+          rebase: true
+        });
+        push(version);
+      }
+      // Wait for webhook payload delivery and deno.land/x publishing
+      if (!dryrun) {
+        for(let attempt = 0;; attempt++){
+          const deliveries = await github(`/hooks/${hook.id}/deliveries`);
+          if (deliveries.some(({ event, delivered_at })=>event === "create" && Date.parse(delivered_at) >= pushed - delay)) break;
+          if (attempt >= attempts) throw new Error("Webhook payload has not been delivered in the expected time frame");
+          console.error(gray("webhook payload has not been delivered yet"));
+          await sleep();
+        }
+        console.error(cyan("webhook payload has been delivered"));
+        for(let attempt = 0;; attempt++){
+          if (await published()) break;
+          if (attempt >= attempts) throw new Error("Package has not been published in the expected time frame");
+          console.error(gray("package has not been published yet"));
+          await sleep();
+        }
+      }
+      console.error(green(`published on ${url}`));
+    } finally{
+      // Restore hook state if needed
+      if (reactive && !hook.active) {
+        console.error(yellow("hook was inactive prior publishing, restoring state"));
+        if (!dryrun) await github(`/hooks/${hook.id}`, {
+          method: "PATCH",
+          body: JSON.stringify({
+            active: false
+          })
+        });
+      }
+      // Remove tag if needed
+      if (remove && !dryrun) {
+        console.error(gray(`removing tag ${version} locally and from origin`));
+        command("git", [
+          "tag",
+          "--delete",
+          version
+        ], {
+          sync: true
+        });
+        push(version, {
+          args: [
+            "--delete"
+          ]
+        });
+      }
+    }
+  } finally{
+    // Remove temporary branch if needed
+    if (map && !dryrun && branch.temporary) {
+      console.error(`switching back to ${branch.current} and deleting temporary branch ${branch.temporary}`);
+      command("git", [
+        "switch",
+        branch.current
+      ], {
+        sync: true
+      });
+      command("git", [
+        "branch",
+        "--delete",
+        "--force",
+        branch.temporary
+      ], {
+        sync: true
+      });
+      push(branch.temporary, {
+        args: [
+          "--delete"
+        ]
+      });
+    }
+  }
+  return {
+    name,
+    version,
+    url,
+    changed: true
+  };
+}
+// Entry point
+if (import.meta.main) {
+  const args = parseArgs(Deno.args, {
+    string: [
+      "token",
+      "repository",
+      "name",
+      "version",
+      "directory",
+      "map",
+      "attempts",
+      "delay"
+    ],
+    boolean: [
+      "reactive",
+      "remove",
+      "dryrun",
+      "help"
+    ]
+  });
+  if (args.help) {
+    console.error("Usage: deno run --allow-all jsr:@libs/toolbox/scripts/publish/x --token <token> --repository <owner/repo> [options]");
+    console.error("");
+    console.error("Options:");
+    console.error("  --token <token>            GitHub API token");
+    console.error("  --repository <owner/repo>  GitHub repository");
+    console.error("  --name [name]              Package name on deno.land/x (defaults to the unscoped name from the deno.json(c) in the current directory)");
+    console.error("  --version [version]        Version to publish (defaults to the version from the deno.json(c) in the current directory)");
+    console.error("  --directory [directory]    Subdirectory of the repository to publish");
+    console.error("  --map [map]                Import map path, when specified imports are resolved on a temporary branch which is published instead");
+    console.error("  --reactive                 Activate the webhook before publishing and restore its state afterwards");
+    console.error("  --remove                   Remove the tag after publishing");
+    console.error("  --attempts [attempts=30]   Maximum number of attempts for publishing operations to complete");
+    console.error("  --delay [delay=30000]      Delay between each attempt (in milliseconds)");
+    console.error("  --dryrun                   Do not actually publish");
+    Deno.exit(2);
+  }
+  if (!args.name || !args.version) {
+    const { name = "", version = "" } = await manifest(Deno.cwd()) ?? {};
+    args.name ||= name.split("/").at(-1);
+    args.version ||= version;
+  }
+  const { token = "", repository = "", name = "", version = "", directory, map, reactive, remove, dryrun } = args;
+  await publish({
+    token,
+    repository,
+    name,
+    version,
+    directory,
+    map,
+    reactive,
+    remove,
+    dryrun,
+    attempts: Number(args.attempts) || undefined,
+    delay: Number(args.delay) || undefined
+  });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/libs/libs/@libs/toolbox/scripts/publish/x.ts"],"sourcesContent":["// deno-lint-ignore-file no-console\n/**\n * Publish a package on deno.land/x.\n *\n * 1. Check whether `https://deno.land/x/<name>@<version>` is already published (in which case there is nothing to do)\n * 2. When `map` is set, create a temporary git branch where all imports are resolved against import maps\n *    (raw imports served by deno.land/x cannot resolve import maps, so bare specifiers are rewritten to fully qualified ones)\n * 3. Search the github repository for the deno.land/x webhook, and activate it when `reactive` is set\n *    (this lets you keep the hook disabled by default so unrelated tags are not published)\n * 4. Create and push a git tag named after `version` to trigger the webhook\n * 5. Wait for the webhook payload delivery and for the version to be published on deno.land/x\n * 6. Restore the webhook state, and clean up the temporary branch and tag (when `remove` is set)\n *\n * Note that you must configure the webhook on deno.land/x prior to using this script.\n *\n * @module\n */\n\n// Imports\nimport { parseArgs } from \"@std/cli\"\nimport { expandGlob } from \"@std/fs\"\nimport { dirname, resolve } from \"@std/path\"\nimport { command } from \"@libs/run/command\"\nimport { commit, pull, push, tag } from \"@libs/git\"\nimport { manifest, unmap, workspaceImports } from \"./_utils.js\"\nimport { cyan, gray, green, yellow } from \"@std/fmt/colors\"\n\n/** Publish a package on deno.land/x. */\nexport async function publish({ token, repository, name, version, directory = \"\", map = \"\", reactive = false, remove = false, attempts = 30, delay = 30000, dryrun = false, fetcher = fetch }: Options): Promise<{ name: string; version: string; url: string; changed: boolean }> {\n  directory = directory.trim().replace(/\\/$/, \"\")\n  const hooked = `https://api.deno.land/webhook/gh/${name}${directory ? `?subdir=${encodeURIComponent(`/${directory}/`)}` : \"\"}`\n  const url = `https://deno.land/x/${name}@${version}`\n  const github = (path: string, init = {} as RequestInit) =>\n    fetcher(`https://api.github.com/repos/${repository}${path}`, { ...init, headers: { Accept: \"application/vnd.github+json\", Authorization: `Bearer ${token}` } }).then(async (response) => {\n      if (!response.ok) {\n        await response.body?.cancel()\n        throw new Error(`GitHub API request failed with status ${response.status}: ${path}`)\n      }\n      return response.json()\n    })\n  const published = () =>\n    fetcher(url, { headers: { Accept: \"text/html\" } }).then(async (response) => {\n      await response.body?.cancel()\n      return response.ok\n    })\n  const sleep = () => new Promise((resolve) => setTimeout(resolve, delay))\n\n  // Check if package is already published\n  if (await published()) {\n    console.error(`${url} is already published, nothing to do`)\n    return { name, version, url, changed: false }\n  }\n\n  // Resolve imports on a temporary branch if needed\n  const branch = { current: \"\", temporary: \"\" }\n  try {\n    if (map) {\n      branch.current = command(\"git\", [\"rev-parse\", \"--abbrev-ref\", \"HEAD\"], { sync: true, throw: true }).stdout.trim()\n      branch.temporary = `x-${name}-${version}`\n      console.error(`switching from ${branch.current} to temporary branch ${branch.temporary}`)\n      if (!dryrun) {\n        command(\"git\", [\"switch\", \"--create\", branch.temporary], { sync: true, throw: true })\n        push(branch.temporary)\n        command(\"git\", [\"branch\", \"--set-upstream-to\", `origin/${branch.temporary}`], { sync: true, throw: true })\n      }\n      const cwd = resolve(Deno.cwd())\n      const workspace = await workspaceImports(cwd)\n      const mapped = manifest(dirname(resolve(cwd, map)))?.imports ?? {}\n      const exclude = [...new Set([...(manifest(cwd)?.publish?.exclude ?? []), \"node_modules\", \".git\", \"coverage\", \".github\"])]\n      for await (const { path } of expandGlob(\"**/*.ts\", { root: cwd, includeDirs: false, exclude })) {\n        // Resolve against workspace members, the nearest manifest imports and the specified map\n        let local = {} as Record<string, string>\n        for (let base = dirname(path); base.startsWith(cwd); base = dirname(base)) {\n          const parsed = manifest(base)\n          if (parsed) {\n            local = parsed.imports ?? {}\n            break\n          }\n        }\n        const { result, resolved } = unmap(await Deno.readTextFile(path), { ...workspace, ...local, ...mapped })\n        if (resolved) {\n          console.error(gray(`resolved ${resolved} imports in ${path}`))\n          if (!dryrun)\n            await Deno.writeTextFile(path, result)\n        }\n      }\n      console.error(gray(`committing resolved imports on ${branch.temporary}`))\n      if (!dryrun) {\n        commit(`build(${name}): deno.land/x@${version}`, { all: true })\n        push(branch.temporary)\n      }\n    }\n\n    // Search webhook and activate it if needed\n    const webhooks = await github(\"/hooks\") as Array<{ id: number; active: boolean; config: { url?: string } }>\n    const hook = webhooks.find(({ config }) => config.url === hooked)\n    if (!hook)\n      throw new Error(`Could not find a hook with expected url: ${hooked}`)\n    console.error(`found hook ${hook.id} (active: ${hook.active})`)\n    if (reactive && (!hook.active)) {\n      console.error(yellow(\"hook is inactive prior publishing, activating\"))\n      if (!dryrun)\n        await github(`/hooks/${hook.id}`, { method: \"PATCH\", body: JSON.stringify({ active: true }) })\n    }\n\n    try {\n      // Create and push tag to trigger webhook\n      console.error(`creating and pushing tag ${version}`)\n      const pushed = Date.now()\n      if (!dryrun) {\n        tag(version, { force: true })\n        pull({ rebase: true })\n        push(version)\n      }\n\n      // Wait for webhook payload delivery and deno.land/x publishing\n      if (!dryrun) {\n        for (let attempt = 0;; attempt++) {\n          const deliveries = await github(`/hooks/${hook.id}/deliveries`) as Array<{ event: string; delivered_at: string }>\n          if (deliveries.some(({ event, delivered_at }) => (event === \"create\") && (Date.parse(delivered_at) >= pushed - delay)))\n            break\n          if (attempt >= attempts)\n            throw new Error(\"Webhook payload has not been delivered in the expected time frame\")\n          console.error(gray(\"webhook payload has not been delivered yet\"))\n          await sleep()\n        }\n        console.error(cyan(\"webhook payload has been delivered\"))\n        for (let attempt = 0;; attempt++) {\n          if (await published())\n            break\n          if (attempt >= attempts)\n            throw new Error(\"Package has not been published in the expected time frame\")\n          console.error(gray(\"package has not been published yet\"))\n          await sleep()\n        }\n      }\n      console.error(green(`published on ${url}`))\n    } finally {\n      // Restore hook state if needed\n      if (reactive && (!hook.active)) {\n        console.error(yellow(\"hook was inactive prior publishing, restoring state\"))\n        if (!dryrun)\n          await github(`/hooks/${hook.id}`, { method: \"PATCH\", body: JSON.stringify({ active: false }) })\n      }\n\n      // Remove tag if needed\n      if (remove && (!dryrun)) {\n        console.error(gray(`removing tag ${version} locally and from origin`))\n        command(\"git\", [\"tag\", \"--delete\", version], { sync: true })\n        push(version, { args: [\"--delete\"] })\n      }\n    }\n  } finally {\n    // Remove temporary branch if needed\n    if (map && (!dryrun) && branch.temporary) {\n      console.error(`switching back to ${branch.current} and deleting temporary branch ${branch.temporary}`)\n      command(\"git\", [\"switch\", branch.current], { sync: true })\n      command(\"git\", [\"branch\", \"--delete\", \"--force\", branch.temporary], { sync: true })\n      push(branch.temporary, { args: [\"--delete\"] })\n    }\n  }\n\n  return { name, version, url, changed: true }\n}\n\n/** Publishing options for {@linkcode publish()}. */\nexport type Options = {\n  /** GitHub API token. */\n  token: string\n  /** GitHub repository (e.g. `octocat/hello-world`). */\n  repository: string\n  /** Package name on deno.land/x. */\n  name: string\n  /** Version to publish. */\n  version: string\n  /** Subdirectory of the repository to publish (optional). */\n  directory?: string\n  /** Path to an import map. When specified, a temporary branch with all imports resolved is created and published instead. */\n  map?: string\n  /** Activate the webhook before publishing and restore its state afterwards. */\n  reactive?: boolean\n  /** Remove the tag after publishing. */\n  remove?: boolean\n  /** Maximum number of attempts for publishing operations to complete. */\n  attempts?: number\n  /** Delay between each attempt (in milliseconds). */\n  delay?: number\n  /** Do not actually publish (no file is written and no mutating git or remote call is made). */\n  dryrun?: boolean\n  /** Fetch implementation (mostly used for testing purposes). */\n  fetcher?: typeof fetch\n}\n\n// Entry point\nif (import.meta.main) {\n  const args = parseArgs(Deno.args, {\n    string: [\"token\", \"repository\", \"name\", \"version\", \"directory\", \"map\", \"attempts\", \"delay\"],\n    boolean: [\"reactive\", \"remove\", \"dryrun\", \"help\"],\n  })\n  if (args.help) {\n    console.error(\"Usage: deno run --allow-all jsr:@libs/toolbox/scripts/publish/x --token <token> --repository <owner/repo> [options]\")\n    console.error(\"\")\n    console.error(\"Options:\")\n    console.error(\"  --token <token>            GitHub API token\")\n    console.error(\"  --repository <owner/repo>  GitHub repository\")\n    console.error(\"  --name [name]              Package name on deno.land/x (defaults to the unscoped name from the deno.json(c) in the current directory)\")\n    console.error(\"  --version [version]        Version to publish (defaults to the version from the deno.json(c) in the current directory)\")\n    console.error(\"  --directory [directory]    Subdirectory of the repository to publish\")\n    console.error(\"  --map [map]                Import map path, when specified imports are resolved on a temporary branch which is published instead\")\n    console.error(\"  --reactive                 Activate the webhook before publishing and restore its state afterwards\")\n    console.error(\"  --remove                   Remove the tag after publishing\")\n    console.error(\"  --attempts [attempts=30]   Maximum number of attempts for publishing operations to complete\")\n    console.error(\"  --delay [delay=30000]      Delay between each attempt (in milliseconds)\")\n    console.error(\"  --dryrun                   Do not actually publish\")\n    Deno.exit(2)\n  }\n  if ((!args.name) || (!args.version)) {\n    const { name = \"\", version = \"\" } = (await manifest(Deno.cwd())) ?? {}\n    args.name ||= name.split(\"/\").at(-1)!\n    args.version ||= version\n  }\n  const { token = \"\", repository = \"\", name = \"\", version = \"\", directory, map, reactive, remove, dryrun } = args\n  await publish({ token, repository, name, version, directory, map, reactive, remove, dryrun, attempts: Number(args.attempts) || undefined, delay: Number(args.delay) || undefined })\n}\n"],"names":[],"mappings":"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"}

package/timezone.d.ts

@@ -0,0 +1,2 @@
+/** Supported timezones in the current runtime. */ export declare const timezones: string[];
+/** Current timezone in the runtime. */ export declare const timezone: string;

package/timezone.js

@@ -0,0 +1,8 @@
+/** Supported timezones in the current runtime. */ export const timezones = [
+  ...new Set([
+    ...Intl.supportedValuesOf("timeZone"),
+    "UTC"
+  ])
+];
+/** Current timezone in the runtime. */ export const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vaG9tZS9ydW5uZXIvd29yay9saWJzL2xpYnMvQGxpYnMvdG9vbGJveC90aW1lem9uZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKiogU3VwcG9ydGVkIHRpbWV6b25lcyBpbiB0aGUgY3VycmVudCBydW50aW1lLiAqL1xuZXhwb3J0IGNvbnN0IHRpbWV6b25lcyA9IFsuLi5uZXcgU2V0KFsuLi5JbnRsLnN1cHBvcnRlZFZhbHVlc09mKFwidGltZVpvbmVcIiksIFwiVVRDXCJdKV0gYXMgc3RyaW5nW11cblxuLyoqIEN1cnJlbnQgdGltZXpvbmUgaW4gdGhlIHJ1bnRpbWUuICovXG5leHBvcnQgY29uc3QgdGltZXpvbmUgPSBJbnRsLkRhdGVUaW1lRm9ybWF0KCkucmVzb2x2ZWRPcHRpb25zKCkudGltZVpvbmUgYXMgc3RyaW5nXG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0RBQWdELEdBQ2hELE9BQU8sTUFBTSxZQUFZO0tBQUksSUFBSSxJQUFJO09BQUksS0FBSyxpQkFBaUIsQ0FBQztJQUFhO0dBQU07Q0FBRSxDQUFZO0FBRWpHLHFDQUFxQyxHQUNyQyxPQUFPLE1BQU0sV0FBVyxLQUFLLGNBQWMsR0FBRyxlQUFlLEdBQUcsUUFBUSxDQUFVIn0=