binary-collections 2.0.13 → 2.0.15

package/lib/github-workflows/workflow-badge-cli.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/github-workflows/workflow-badge-cli.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils as require_utils2
+} from "../chunk-DPEE3FBB.mjs";
+import {
+  generateBadge
+} from "../chunk-X7UVQ6ZC.mjs";
+import "../chunk-3T6AMFI3.mjs";
+import "../chunk-J4M5EL5P.mjs";
+import {
+  require_utils
+} from "../chunk-6RK5UCTP.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/workflow-badge-cli.mjs
+init_esm_shims();
+var import_utils = __toESM(require_utils(), 1);
+import fs from "fs";
+import path from "upath";
+var import_utils2 = __toESM(require_utils2(), 1);
+var HELP = `
+Usage: workflow-badge [options]
+
+Generate a detailed SVG badge for the latest GitHub Actions workflow status.
+
+Options:
+  -o, --output <file>   Write SVG to file instead of stdout
+  --owner <owner>       GitHub repository owner (default: auto-detect from git)
+  --repo <repo>         GitHub repository name (default: auto-detect from git)
+  --workflow <name>     Filter by workflow filename (e.g. "test.yml") or workflow ID
+  --token <token>       GitHub access token (overrides env: ACCESS_TOKEN, GITHUB_TOKEN, GH_TOKEN)
+  --width <px>          SVG width in pixels (default: 520)
+  --max-steps <n>       Max steps to show per job (default: all)
+  -h, --help            Show this help message
+
+Examples:
+  workflow-badge
+  workflow-badge --output badge.svg
+  workflow-badge --owner dimaslanjaka --repo bin --width 600
+`;
+async function main() {
+  const argv = (0, import_utils.getArgs)({
+    string: ["output", "owner", "repo", "workflow", "width", "max-steps"],
+    boolean: ["help"],
+    alias: { o: "output", h: "help", w: "width" }
+  });
+  if (argv.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  const owner = argv.owner || process.env.GH_OWNER;
+  const repo = argv.repo || process.env.GH_REPO;
+  if (owner && repo) {
+    console.error(`[workflow-badge] Using owner=${owner} repo=${repo}`);
+  } else {
+    const parsed = await (0, import_utils2.getOwnerRepo)();
+    if (!owner) argv.owner = parsed.owner;
+    if (!repo) argv.repo = parsed.repo;
+    console.error(`[workflow-badge] Detected ${parsed.owner}/${parsed.repo} from git remote`);
+  }
+  const finalOwner = argv.owner || owner;
+  const finalRepo = argv.repo || repo;
+  const workflowId = argv.workflow;
+  const target = workflowId ? `${finalOwner}/${finalRepo} (workflow: ${workflowId})` : `${finalOwner}/${finalRepo}`;
+  console.error(`[workflow-badge] Fetching latest workflow for ${target} ...`);
+  const run = await (0, import_utils2.getLatestRun)(finalOwner, finalRepo, workflowId);
+  if (!run) {
+    console.error("[workflow-badge] No workflow runs found.");
+    process.exit(1);
+  }
+  const jobs = await (0, import_utils2.getJobs)(finalOwner, finalRepo, run.id);
+  console.error(
+    `[workflow-badge] Run #${run.id}: ${run.status}${run.conclusion ? ` (${run.conclusion})` : ""} \u2014 ${jobs.length} job(s)`
+  );
+  const maxSteps = argv["max-steps"] ? parseInt(argv["max-steps"], 10) : void 0;
+  const options = { width: parseInt(argv.width, 10) || 520 };
+  if (maxSteps !== void 0) options.maxSteps = maxSteps;
+  const svg = generateBadge(run, jobs, options);
+  if (argv.output) {
+    const outPath = path.resolve(argv.output);
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
+    }
+    fs.writeFileSync(outPath, svg, "utf-8");
+    console.error(`[workflow-badge] Badge written to ${outPath}`);
+  } else {
+    process.stdout.write(svg);
+  }
+}
+main().catch((err) => {
+  console.error("[workflow-badge] Error:", err.message);
+  process.exit(1);
+});

package/lib/github-workflows/workflow-badge-generator.cjs

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/github-workflows/workflow-badge-generator.mjs
+var workflow_badge_generator_exports = {};
+__export(workflow_badge_generator_exports, {
+  generateBadge: () => generateBadge
+});
+module.exports = __toCommonJS(workflow_badge_generator_exports);
+var COLORS = {
+  success: "#2da44e",
+  failure: "#cf222e",
+  cancelled: "#656d76",
+  skipped: "#656d76",
+  inProgress: "#d4920b",
+  pending: "#656d76",
+  unknown: "#656d76",
+  text: "#1f2328",
+  textSecondary: "#656d76",
+  border: "#d0d7de",
+  bg: "#ffffff",
+  cardBg: "#f6f8fa"
+};
+function getStatusMeta(run) {
+  const { status, conclusion } = run;
+  if (conclusion === "success") return { label: "Passing", color: COLORS.success };
+  if (conclusion === "failure") return { label: "Failing", color: COLORS.failure };
+  if (conclusion === "cancelled") return { label: "Cancelled", color: COLORS.cancelled };
+  if (conclusion === "skipped") return { label: "Skipped", color: COLORS.skipped };
+  if (status === "in_progress") return { label: "In Progress", color: COLORS.inProgress };
+  if (status === "queued" || status === "pending") return { label: "Pending", color: COLORS.pending };
+  return { label: status || "Unknown", color: COLORS.unknown };
+}
+function esc(str) {
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function countSteps(jobs) {
+  let total = 0, passed = 0, failed = 0, skipped = 0, pending = 0;
+  for (const job of jobs) {
+    for (const step of job.steps || []) {
+      total++;
+      if (step.conclusion === "success") passed++;
+      else if (step.conclusion === "failure") failed++;
+      else if (step.conclusion === "skipped") skipped++;
+      else pending++;
+    }
+  }
+  return { total, passed, failed, skipped, pending };
+}
+function jobColor(job) {
+  if (job.conclusion === "success") return COLORS.success;
+  if (job.conclusion === "failure") return COLORS.failure;
+  if (job.status === "in_progress") return COLORS.inProgress;
+  return COLORS.pending;
+}
+function generateBadge(run, jobs, options = {}) {
+  const width = options.width || 520;
+  const maxSteps = options.maxSteps;
+  const { label: statusLabel, color: accentColor } = getStatusMeta(run);
+  const steps = countSteps(jobs);
+  const PAD = 20;
+  const W = width;
+  const RIGHT = width - PAD;
+  const INNER_W = RIGHT - PAD;
+  const els = [];
+  const el = (str) => els.push(str);
+  const LABEL_X = PAD;
+  const VALUE_X = 110;
+  let yCursor = 0;
+  const divider = () => {
+    yCursor += 4;
+    el(`<line x1="${PAD}" y1="${yCursor}" x2="${RIGHT}" y2="${yCursor}" stroke="${COLORS.border}" stroke-width="1"/>`);
+    yCursor += 5;
+  };
+  const sectionHeading = (text) => {
+    yCursor += 8;
+    el(
+      `<text x="${PAD}" y="${yCursor + 13}" font-size="11" font-weight="700" fill="${COLORS.textSecondary}" letter-spacing="0.5">${esc(text)}</text>`
+    );
+    yCursor += 22;
+  };
+  el(`<rect x="0" y="0" width="${W}" height="4" fill="${accentColor}"/>`);
+  yCursor = 4;
+  yCursor += 14;
+  const titleBaseline = yCursor + 15;
+  el(
+    `<text x="${PAD}" y="${titleBaseline}" font-size="15" font-weight="700" fill="${COLORS.text}">Workflow Status</text>`
+  );
+  const pillText = statusLabel;
+  const pillTextW = pillText.length * 7.8 + 32;
+  const pillX = RIGHT - pillTextW;
+  const pillY = titleBaseline - 12;
+  el(`<rect x="${pillX}" y="${pillY}" width="${pillTextW}" height="22" rx="11" fill="${accentColor}" opacity="0.12"/>`);
+  el(`<circle cx="${pillX + 14}" cy="${titleBaseline - 2}" r="4.5" fill="${accentColor}"/>`);
+  el(
+    `<text x="${pillX + 24}" y="${titleBaseline + 1}" font-size="12" font-weight="600" fill="${accentColor}">${esc(pillText)}</text>`
+  );
+  yCursor = titleBaseline + 4;
+  divider();
+  const metaRows = [
+    { label: "Workflow", value: run.name || "" },
+    { label: "Status", value: `${run.status}${run.conclusion ? ` (${run.conclusion})` : ""}` },
+    { label: "Branch", value: run.head_branch || "" },
+    { label: "Run ID", value: `#${run.id || ""}` }
+  ];
+  for (const row of metaRows) {
+    const rowBaseline = yCursor + 14;
+    el(
+      `<text x="${LABEL_X}" y="${rowBaseline}" font-size="12" fill="${COLORS.textSecondary}">${esc(row.label)}</text>`
+    );
+    el(
+      `<text x="${VALUE_X}" y="${rowBaseline}" font-size="13" fill="${COLORS.text}" font-weight="500">${esc(row.value)}</text>`
+    );
+    yCursor += 22;
+  }
+  divider();
+  sectionHeading("JOBS");
+  for (const job of jobs) {
+    const jColor = jobColor(job);
+    const jStatus = job.conclusion || job.status;
+    el(`<rect x="${PAD}" y="${yCursor}" width="${INNER_W}" height="28" rx="6" fill="${COLORS.cardBg}"/>`);
+    el(
+      `<text x="${PAD + 10}" y="${yCursor + 18}" font-size="13" font-weight="600" fill="${COLORS.text}">${esc(job.name)}</text>`
+    );
+    const jobStatusX = RIGHT - 14;
+    el(`<circle cx="${jobStatusX - 16}" cy="${yCursor + 14}" r="3.5" fill="${jColor}"/>`);
+    el(
+      `<text x="${jobStatusX}" y="${yCursor + 18}" font-size="11" fill="${COLORS.textSecondary}" text-anchor="end">${esc(jStatus)}</text>`
+    );
+    yCursor += 34;
+    if (job.steps && job.steps.length > 0) {
+      const stepsToRender = maxSteps ? job.steps.slice(0, maxSteps) : job.steps;
+      const hiddenCount = maxSteps ? job.steps.length - maxSteps : 0;
+      for (const step of stepsToRender) {
+        const sIcon = step.conclusion === "success" ? "\u2713" : step.conclusion === "failure" ? "\u2717" : step.conclusion === "skipped" ? "\u2013" : "\u25CB";
+        const sColor = step.conclusion === "success" ? COLORS.success : step.conclusion === "failure" ? COLORS.failure : step.conclusion === "skipped" ? COLORS.textSecondary : COLORS.inProgress;
+        el(`<text x="${PAD + 18}" y="${yCursor + 13}" font-size="12" fill="${sColor}">${sIcon}</text>`);
+        let stepName = step.name || "";
+        const maxChars = 52;
+        if (stepName.length > maxChars) {
+          stepName = stepName.slice(0, maxChars - 3) + "...";
+        }
+        el(`<text x="${PAD + 36}" y="${yCursor + 13}" font-size="12" fill="${COLORS.text}">${esc(stepName)}</text>`);
+        const stepStatus = step.conclusion || step.status || "";
+        el(
+          `<text x="${RIGHT}" y="${yCursor + 13}" font-size="11" fill="${COLORS.textSecondary}" text-anchor="end">${esc(stepStatus)}</text>`
+        );
+        yCursor += 20;
+      }
+      if (hiddenCount > 0) {
+        el(
+          `<text x="${PAD + 18}" y="${yCursor + 13}" font-size="12" fill="${COLORS.textSecondary}" font-style="italic">and ${hiddenCount} more step${hiddenCount !== 1 ? "s" : ""}...</text>`
+        );
+        yCursor += 20;
+      }
+      yCursor += 4;
+    }
+  }
+  divider();
+  const footerParts = [];
+  if (steps.passed > 0) footerParts.push(`${steps.passed} \u2713 passed`);
+  if (steps.failed > 0) footerParts.push(`${steps.failed} \u2717 failed`);
+  if (steps.pending > 0) footerParts.push(`${steps.pending} \u25CB pending`);
+  if (steps.skipped > 0) footerParts.push(`${steps.skipped} \u2013 skipped`);
+  const footerText = footerParts.length > 0 ? footerParts.join("  \xB7  ") : "No steps recorded";
+  el(`<text x="${PAD}" y="${yCursor + 13}" font-size="12" fill="${COLORS.textSecondary}">${esc(footerText)}</text>`);
+  yCursor += 22;
+  const totalHeight = yCursor + 6;
+  const svg = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${totalHeight}" viewBox="0 0 ${W} ${totalHeight}" font-family="-apple-system,BlinkMacSystemFont,Segoe UI,Noto Sans,Helvetica,Arial,sans-serif">`,
+    `  <defs>`,
+    `    <filter id="badge-shadow" x="-2%" y="-2%" width="104%" height="104%">`,
+    `      <feDropShadow dx="0" dy="1" stdDeviation="3" flood-color="#000" flood-opacity="0.12"/>`,
+    `    </filter>`,
+    `  </defs>`,
+    `  <rect x="0.5" y="0.5" width="${W - 1}" height="${totalHeight - 1}" rx="8" fill="${COLORS.bg}" stroke="${COLORS.border}" stroke-width="1" filter="url(#badge-shadow)"/>`,
+    ...els,
+    `</svg>`
+  ].join("\n");
+  return svg;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateBadge
+});

package/lib/github-workflows/workflow-badge-generator.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Generate a detailed SVG badge for a GitHub Actions workflow run.
+ *
+ * @param {object}   run           - Workflow run object from the GitHub API
+ * @param {object[]} jobs          - Array of job objects from the GitHub API
+ * @param {object}   [options]
+ * @param {number}   [options.width=520] - SVG width in pixels
+ * @param {number}   [options.maxSteps]  - Max steps to show per job (rest summarized)
+ * @returns {string} SVG markup
+ */
+export function generateBadge(run: object, jobs: object[], options?: {
+    width?: number;
+    maxSteps?: number;
+}): string;

package/lib/github-workflows/workflow-badge-generator.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  generateBadge
+} from "../chunk-X7UVQ6ZC.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  generateBadge
+};

package/lib/github-workflows/workflow-test-data.cjs

@@ -0,0 +1,73 @@
+// src/github-workflows/workflow-test-data.cjs
+var workflow = {
+  name: "Node.js Package Test",
+  concurrency: {
+    group: "test-${{ github.event_name }}",
+    "cancel-in-progress": true
+  },
+  on: {
+    workflow_dispatch: {},
+    push: {
+      paths: ["**/test*/**", "**/test*", "**/src/**"]
+    }
+  },
+  env: {
+    CI_NODE_VERSION: "24.16.0",
+    CI_PYTHON_VERSION: "3.11",
+    ACCESS_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}",
+    GH_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}"
+  },
+  jobs: {
+    ci: {
+      name: "\u{1F528} Build, Pack & Test",
+      "runs-on": "ubuntu-latest",
+      steps: [
+        {
+          name: "\u2B07\uFE0F Checkout workflow repository",
+          uses: "actions/checkout@v6"
+        },
+        {
+          name: "\u2B07\uFE0F Setup CI Environment",
+          uses: "./.github/actions/setup-environments",
+          with: {
+            "node-version": "${{ env.CI_NODE_VERSION }}",
+            "python-version": "${{ env.CI_PYTHON_VERSION }}",
+            token: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}",
+            "prefix-cache-key": "${{ runner.os }}-test-"
+          }
+        },
+        {
+          name: "\u{1F4E6} Install dependencies",
+          run: `touch yarn.lock && corepack yarn install`
+        },
+        {
+          name: "\u{1F528} Build project",
+          run: "corepack yarn build"
+        },
+        {
+          name: "\u{1F4E6} Pack project",
+          run: "corepack yarn pack"
+        },
+        // {
+        //   name: '🧪 Run committed composite tests action',
+        //   uses: './.github/actions/run-tests',
+        //   env: {
+        //     ACCESS_TOKEN: '${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}',
+        //     GH_TOKEN: '${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}'
+        //   }
+        // },
+        {
+          name: "\u{1F9F9} Clean GitHub Actions Cache",
+          // if: 'always()',
+          "continue-on-error": true,
+          env: {
+            GH_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}"
+          },
+          shell: "bash",
+          run: `npx --legacy-peer-deps -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo "\${{ github.repository }}" --sha "\${{ github.sha }}"`
+        }
+      ]
+    }
+  }
+};
+module.exports = workflow;

package/lib/github-workflows/workflow-test-data.d.cts

@@ -0,0 +1,63 @@
+export let name: string;
+export let concurrency: {
+    group: string;
+    'cancel-in-progress': boolean;
+};
+export namespace on {
+    let workflow_dispatch: {};
+    namespace push {
+        let paths: string[];
+    }
+}
+export namespace env {
+    let CI_NODE_VERSION: string;
+    let CI_PYTHON_VERSION: string;
+    let ACCESS_TOKEN: string;
+    let GH_TOKEN: string;
+}
+export namespace jobs {
+    let ci: {
+        name: string;
+        'runs-on': string;
+        steps: ({
+            name: string;
+            uses: string;
+            with?: undefined;
+            run?: undefined;
+            'continue-on-error'?: undefined;
+            env?: undefined;
+            shell?: undefined;
+        } | {
+            name: string;
+            uses: string;
+            with: {
+                'node-version': string;
+                'python-version': string;
+                token: string;
+                'prefix-cache-key': string;
+            };
+            run?: undefined;
+            'continue-on-error'?: undefined;
+            env?: undefined;
+            shell?: undefined;
+        } | {
+            name: string;
+            run: string;
+            uses?: undefined;
+            with?: undefined;
+            'continue-on-error'?: undefined;
+            env?: undefined;
+            shell?: undefined;
+        } | {
+            name: string;
+            'continue-on-error': boolean;
+            env: {
+                GH_TOKEN: string;
+            };
+            shell: string;
+            run: string;
+            uses?: undefined;
+            with?: undefined;
+        })[];
+    };
+}

package/lib/github-workflows/workflow-test-data.mjs

@@ -0,0 +1,6 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_workflow_test_data
+} from "../chunk-TP3O2JGW.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export default require_workflow_test_data();

package/lib/node-cache-cleaner-cli.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-import {
-  cleanNpmCache
-} from "./chunk-R5FJOR63.mjs";
 import {
   cleanNpxCache
 } from "./chunk-OXV52GD5.mjs";
 import {
   cleanYarnCache
 } from "./chunk-UXCFNAR6.mjs";
+import {
+  cleanNpmCache
+} from "./chunk-R5FJOR63.mjs";
 import {
   require_utils
 } from "./chunk-6RK5UCTP.mjs";