@dytsou/github-readme-stats 1.0.1

package/src/common/ops.js

@@ -0,0 +1,124 @@
+// @ts-check
+
+import toEmoji from "emoji-name-map";
+
+/**
+ * Returns boolean if value is either "true" or "false" else the value as it is.
+ *
+ * @param {string | boolean} value The value to parse.
+ * @returns {boolean | undefined } The parsed value.
+ */
+const parseBoolean = (value) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    if (value.toLowerCase() === "true") {
+      return true;
+    } else if (value.toLowerCase() === "false") {
+      return false;
+    }
+  }
+  return undefined;
+};
+
+/**
+ * Parse string to array of strings.
+ *
+ * @param {string} str The string to parse.
+ * @returns {string[]} The array of strings.
+ */
+const parseArray = (str) => {
+  if (!str) {
+    return [];
+  }
+  return str.split(",");
+};
+
+/**
+ * Clamp the given number between the given range.
+ *
+ * @param {number} number The number to clamp.
+ * @param {number} min The minimum value.
+ * @param {number} max The maximum value.
+ * @returns {number} The clamped number.
+ */
+const clampValue = (number, min, max) => {
+  // @ts-ignore
+  if (Number.isNaN(parseInt(number, 10))) {
+    return min;
+  }
+  return Math.max(min, Math.min(number, max));
+};
+
+/**
+ * Lowercase and trim string.
+ *
+ * @param {string} name String to lowercase and trim.
+ * @returns {string} Lowercased and trimmed string.
+ */
+const lowercaseTrim = (name) => name.toLowerCase().trim();
+
+/**
+ * Split array of languages in two columns.
+ *
+ * @template T Language object.
+ * @param {Array<T>} arr Array of languages.
+ * @param {number} perChunk Number of languages per column.
+ * @returns {Array<T>} Array of languages split in two columns.
+ */
+const chunkArray = (arr, perChunk) => {
+  return arr.reduce((resultArray, item, index) => {
+    const chunkIndex = Math.floor(index / perChunk);
+
+    if (!resultArray[chunkIndex]) {
+      // @ts-ignore
+      resultArray[chunkIndex] = []; // start a new chunk
+    }
+
+    // @ts-ignore
+    resultArray[chunkIndex].push(item);
+
+    return resultArray;
+  }, []);
+};
+
+/**
+ * Parse emoji from string.
+ *
+ * @param {string} str String to parse emoji from.
+ * @returns {string} String with emoji parsed.
+ */
+const parseEmojis = (str) => {
+  if (!str) {
+    throw new Error("[parseEmoji]: str argument not provided");
+  }
+  return str.replace(/:\w+:/gm, (emoji) => {
+    return toEmoji.get(emoji) || "";
+  });
+};
+
+/**
+ * Get diff in minutes between two dates.
+ *
+ * @param {Date} d1 First date.
+ * @param {Date} d2 Second date.
+ * @returns {number} Number of minutes between the two dates.
+ */
+const dateDiff = (d1, d2) => {
+  const date1 = new Date(d1);
+  const date2 = new Date(d2);
+  const diff = date1.getTime() - date2.getTime();
+  return Math.round(diff / (1000 * 60));
+};
+
+export {
+  parseBoolean,
+  parseArray,
+  clampValue,
+  lowercaseTrim,
+  chunkArray,
+  parseEmojis,
+  dateDiff,
+};

package/src/common/render.js

@@ -0,0 +1,261 @@
+// @ts-check
+
+import escapeHtml from "escape-html";
+import { SECONDARY_ERROR_MESSAGES, TRY_AGAIN_LATER } from "./error.js";
+import { getCardColors } from "./color.js";
+import { escapeCSSValue } from "./html.js";
+import { clampValue } from "./ops.js";
+
+/**
+ * Auto layout utility, allows us to layout things vertically or horizontally with
+ * proper gaping.
+ *
+ * @param {object} props Function properties.
+ * @param {string[]} props.items Array of items to layout.
+ * @param {number} props.gap Gap between items.
+ * @param {"column" | "row"=} props.direction Direction to layout items.
+ * @param {number[]=} props.sizes Array of sizes for each item.
+ * @returns {string[]} Array of items with proper layout.
+ */
+const flexLayout = ({ items, gap, direction, sizes = [] }) => {
+  let lastSize = 0;
+  // filter() for filtering out empty strings
+  return items.filter(Boolean).map((item, i) => {
+    const size = sizes[i] || 0;
+    let transform = `translate(${lastSize}, 0)`;
+    if (direction === "column") {
+      transform = `translate(0, ${lastSize})`;
+    }
+    lastSize += size + gap;
+    return `<g transform="${transform}">${item}</g>`;
+  });
+};
+
+/**
+ * Creates a node to display the primary programming language of the repository/gist.
+ *
+ * **Security Note:** This function safely handles untrusted input by HTML-encoding
+ * the `langName` parameter and CSS-escaping the `langColor` parameter.
+ * Data from external APIs (like GitHub) is sanitized before being inserted into the SVG.
+ *
+ * @param {string} langName Language name (will be HTML-encoded).
+ * @param {string} langColor Language color (will be CSS-escaped).
+ * @returns {string} Language display SVG object.
+ */
+const createLanguageNode = (langName, langColor) => {
+  const safeLangColor = escapeCSSValue(langColor);
+  return `
+    <g data-testid="primary-lang">
+      <circle data-testid="lang-color" cx="0" cy="-5" r="6" fill="${safeLangColor}" />
+      <text data-testid="lang-name" class="gray" x="15">${escapeHtml(langName)}</text>
+    </g>
+    `;
+};
+
+/**
+ * Create a node to indicate progress in percentage along a horizontal line.
+ *
+ * @param {Object} params Object that contains the createProgressNode parameters.
+ * @param {number} params.x X-axis position.
+ * @param {number} params.y Y-axis position.
+ * @param {number} params.width Width of progress bar.
+ * @param {string} params.color Progress color.
+ * @param {number} params.progress Progress value.
+ * @param {string} params.progressBarBackgroundColor Progress bar bg color.
+ * @param {number} params.delay Delay before animation starts.
+ * @returns {string} Progress node.
+ */
+const createProgressNode = ({
+  x,
+  y,
+  width,
+  color,
+  progress,
+  progressBarBackgroundColor,
+  delay,
+}) => {
+  const progressPercentage = clampValue(progress, 2, 100);
+
+  return `
+    <svg width="${width}" x="${x}" y="${y}">
+      <rect rx="5" ry="5" x="0" y="0" width="${width}" height="8" fill="${progressBarBackgroundColor}"></rect>
+      <svg data-testid="lang-progress" width="${progressPercentage}%">
+        <rect
+            height="8"
+            fill="${color}"
+            rx="5" ry="5" x="0" y="0"
+            class="lang-progress"
+            style="animation-delay: ${delay}ms;"
+        />
+      </svg>
+    </svg>
+  `;
+};
+
+/**
+ * Creates an icon with label to display repository/gist stats like forks, stars, etc.
+ *
+ * @param {string} icon The icon to display.
+ * @param {number|string} label The label to display.
+ * @param {string} testid The testid to assign to the label.
+ * @param {number} iconSize The size of the icon.
+ * @returns {string} Icon with label SVG object.
+ */
+const iconWithLabel = (icon, label, testid, iconSize) => {
+  if (typeof label === "number" && label <= 0) {
+    return "";
+  }
+  const iconSvg = `
+      <svg
+        class="icon"
+        y="-12"
+        viewBox="0 0 16 16"
+        version="1.1"
+        width="${iconSize}"
+        height="${iconSize}"
+      >
+        ${icon}
+      </svg>
+    `;
+  const text = `<text data-testid="${testid}" class="gray">${label}</text>`;
+  return flexLayout({ items: [iconSvg, text], gap: 20 }).join("");
+};
+
+// Script parameters.
+const ERROR_CARD_LENGTH = 576.5;
+
+const UPSTREAM_API_ERRORS = [
+  TRY_AGAIN_LATER,
+  SECONDARY_ERROR_MESSAGES.MAX_RETRY,
+];
+
+/**
+ * Renders error message on the card.
+ *
+ * **Security Note:** This function safely handles untrusted input by HTML-encoding
+ * the `message` and `secondaryMessage` parameters using the escape-html library.
+ * All user-provided or external data is sanitized before being inserted into the SVG.
+ *
+ * @param {object} args Function arguments.
+ * @param {string} args.message Main error message (will be HTML-encoded).
+ * @param {string} [args.secondaryMessage=""] The secondary error message (will be HTML-encoded).
+ * @param {object} [args.renderOptions={}] Render options.
+ * @param {string=} args.renderOptions.title_color Card title color.
+ * @param {string=} args.renderOptions.text_color Card text color.
+ * @param {string=} args.renderOptions.bg_color Card background color.
+ * @param {string=} args.renderOptions.border_color Card border color.
+ * @param {Parameters<typeof getCardColors>[0]["theme"]=} args.renderOptions.theme Card theme.
+ * @param {boolean=} args.renderOptions.show_repo_link Whether to show repo link or not.
+ * @returns {string} The SVG markup.
+ */
+const renderError = ({
+  message,
+  secondaryMessage = "",
+  renderOptions = {},
+}) => {
+  const {
+    title_color,
+    text_color,
+    bg_color,
+    border_color,
+    theme = "default",
+    show_repo_link = true,
+  } = renderOptions;
+
+  // returns theme based colors with proper overrides and defaults
+  const { titleColor, textColor, bgColor, borderColor } = getCardColors({
+    title_color,
+    text_color,
+    icon_color: "",
+    bg_color,
+    border_color,
+    ring_color: "",
+    theme,
+  });
+
+  // Sanitize color values to prevent XSS in SVG attributes
+  const safeTitleColor = escapeCSSValue(titleColor);
+  const safeTextColor = escapeCSSValue(textColor);
+  // Handle both string colors and gradient arrays (for gradients, use first color as fallback)
+  const safeBgColor =
+    typeof bgColor === "string"
+      ? escapeCSSValue(bgColor)
+      : Array.isArray(bgColor) && bgColor.length > 0
+        ? escapeCSSValue(`#${bgColor[0]}`)
+        : "#1f2328"; // Default fallback color
+  const safeBorderColor = escapeCSSValue(borderColor);
+
+  return `
+    <svg width="${ERROR_CARD_LENGTH}"  height="120" viewBox="0 0 ${ERROR_CARD_LENGTH} 120" fill="${safeBgColor}" xmlns="http://www.w3.org/2000/svg">
+    <style>
+    .text { font: 600 16px 'Segoe UI', Ubuntu, Sans-Serif; fill: ${safeTitleColor} }
+    .small { font: 600 12px 'Segoe UI', Ubuntu, Sans-Serif; fill: ${safeTextColor} }
+    .gray { fill: #858585 }
+    </style>
+    <rect x="0.5" y="0.5" width="${
+      ERROR_CARD_LENGTH - 1
+    }" height="99%" rx="4.5" fill="${safeBgColor}" stroke="${safeBorderColor}"/>
+    <text x="25" y="45" class="text">Something went wrong!${
+      UPSTREAM_API_ERRORS.includes(secondaryMessage) || !show_repo_link
+        ? ""
+        : " file an issue at https://tiny.one/readme-stats"
+    }</text>
+    <text data-testid="message" x="25" y="55" class="text small">
+      <tspan x="25" dy="18">${escapeHtml(message)}</tspan>
+      <tspan x="25" dy="18" class="gray">${escapeHtml(secondaryMessage)}</tspan>
+    </text>
+    </svg>
+  `;
+};
+
+/**
+ * Retrieve text length.
+ *
+ * @see https://stackoverflow.com/a/48172630/10629172
+ * @param {string} str String to measure.
+ * @param {number} fontSize Font size.
+ * @returns {number} Text length.
+ */
+const measureText = (str, fontSize = 10) => {
+  // prettier-ignore
+  const widths = [
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0.2796875, 0.2765625,
+    0.3546875, 0.5546875, 0.5546875, 0.8890625, 0.665625, 0.190625,
+    0.3328125, 0.3328125, 0.3890625, 0.5828125, 0.2765625, 0.3328125,
+    0.2765625, 0.3015625, 0.5546875, 0.5546875, 0.5546875, 0.5546875,
+    0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875, 0.5546875,
+    0.2765625, 0.2765625, 0.584375, 0.5828125, 0.584375, 0.5546875,
+    1.0140625, 0.665625, 0.665625, 0.721875, 0.721875, 0.665625,
+    0.609375, 0.7765625, 0.721875, 0.2765625, 0.5, 0.665625,
+    0.5546875, 0.8328125, 0.721875, 0.7765625, 0.665625, 0.7765625,
+    0.721875, 0.665625, 0.609375, 0.721875, 0.665625, 0.94375,
+    0.665625, 0.665625, 0.609375, 0.2765625, 0.3546875, 0.2765625,
+    0.4765625, 0.5546875, 0.3328125, 0.5546875, 0.5546875, 0.5,
+    0.5546875, 0.5546875, 0.2765625, 0.5546875, 0.5546875, 0.221875,
+    0.240625, 0.5, 0.221875, 0.8328125, 0.5546875, 0.5546875,
+    0.5546875, 0.5546875, 0.3328125, 0.5, 0.2765625, 0.5546875,
+    0.5, 0.721875, 0.5, 0.5, 0.5, 0.3546875, 0.259375, 0.353125, 0.5890625,
+  ];
+
+  const avg = 0.5279276315789471;
+  return (
+    str
+      .split("")
+      .map((c) =>
+        c.charCodeAt(0) < widths.length ? widths[c.charCodeAt(0)] : avg,
+      )
+      .reduce((cur, acc) => acc + cur) * fontSize
+  );
+};
+
+export {
+  ERROR_CARD_LENGTH,
+  renderError,
+  createLanguageNode,
+  createProgressNode,
+  iconWithLabel,
+  flexLayout,
+  measureText,
+};

package/src/common/retryer.js

@@ -0,0 +1,97 @@
+// @ts-check
+
+import { CustomError } from "./error.js";
+import { logger } from "./log.js";
+
+// Script variables.
+
+// Count the number of GitHub API tokens available.
+const PATs = Object.keys(process.env).filter((key) =>
+  /PAT_\d*$/.exec(key),
+).length;
+const RETRIES = process.env.NODE_ENV === "test" ? 7 : PATs;
+
+/**
+ * @typedef {import("axios").AxiosResponse} AxiosResponse Axios response.
+ * @typedef {(variables: any, token: string, retriesForTests?: number) => Promise<AxiosResponse>} FetcherFunction Fetcher function.
+ */
+
+/**
+ * Try to execute the fetcher function until it succeeds or the max number of retries is reached.
+ *
+ * @param {FetcherFunction} fetcher The fetcher function.
+ * @param {any} variables Object with arguments to pass to the fetcher function.
+ * @param {number} retries How many times to retry.
+ * @returns {Promise<any>} The response from the fetcher function.
+ */
+const retryer = async (fetcher, variables, retries = 0) => {
+  if (!RETRIES) {
+    throw new CustomError("No GitHub API tokens found", CustomError.NO_TOKENS);
+  }
+
+  if (retries > RETRIES) {
+    throw new CustomError(
+      "Downtime due to GitHub API rate limiting",
+      CustomError.MAX_RETRY,
+    );
+  }
+
+  try {
+    // try to fetch with the first token since RETRIES is 0 index i'm adding +1
+    let response = await fetcher(
+      variables,
+      // @ts-ignore
+      process.env[`PAT_${retries + 1}`],
+      // used in tests for faking rate limit
+      retries,
+    );
+
+    // react on both type and message-based rate-limit signals.
+    // https://github.com/anuraghazra/github-readme-stats/issues/4425
+    const errors = response?.data?.errors;
+    const errorType = errors?.[0]?.type;
+    const errorMsg = errors?.[0]?.message || "";
+    const isRateLimited =
+      (errors && errorType === "RATE_LIMITED") || /rate limit/i.test(errorMsg);
+
+    // if rate limit is hit increase the RETRIES and recursively call the retryer
+    // with username, and current RETRIES
+    if (isRateLimited) {
+      logger.log(`PAT_${retries + 1} Failed`);
+      retries++;
+      // directly return from the function
+      return retryer(fetcher, variables, retries);
+    }
+
+    // finally return the response
+    return response;
+  } catch (err) {
+    /** @type {any} */
+    const e = err;
+
+    // network/unexpected error → let caller treat as failure
+    if (!e?.response) {
+      throw e;
+    }
+
+    // prettier-ignore
+    // also checking for bad credentials if any tokens gets invalidated
+    const isBadCredential =
+      e?.response?.data?.message === "Bad credentials";
+    const isAccountSuspended =
+      e?.response?.data?.message === "Sorry. Your account was suspended.";
+
+    if (isBadCredential || isAccountSuspended) {
+      logger.log(`PAT_${retries + 1} Failed`);
+      retries++;
+      // directly return from the function
+      return retryer(fetcher, variables, retries);
+    }
+
+    // HTTP error with a response → return it for caller-side handling
+    return e.response;
+  }
+};
+
+export { retryer, RETRIES };
+export default retryer;

package/src/common/worker-adapter.js

@@ -0,0 +1,148 @@
+// @ts-check
+/**
+ * Adapter utilities to convert Express-style handlers to Hono handlers.
+ */
+
+import { encodeHTML } from "./html.js";
+
+/**
+ * Creates a mock Express response object that works with Hono context.
+ *
+ * @returns {any} Mock Express response object
+ */
+export function createMockResponse() {
+  const headers = {};
+  let responseSent = false;
+  let responseBody = null;
+
+  return {
+    setHeader: (name, value) => {
+      headers[name] = value;
+    },
+    send: (body) => {
+      responseSent = true;
+      responseBody = body;
+
+      // Ensure body is a string (Camo requires valid SVG)
+      const svgBody = typeof body === "string" ? body : String(body);
+
+      // Build headers object
+      const responseHeaders = new Headers();
+
+      // Set Content-Type first (required by GitHub Camo CDN - must be image/svg+xml)
+      responseHeaders.set("Content-Type", "image/svg+xml; charset=utf-8");
+
+      // Set Cache-Control if not already set (Camo expects cacheable responses)
+      const cacheControl = headers["Cache-Control"] || headers["cache-control"];
+      if (cacheControl) {
+        responseHeaders.set("Cache-Control", String(cacheControl));
+      } else {
+        responseHeaders.set("Cache-Control", "public, max-age=3600");
+      }
+
+      // Set all other headers
+      Object.entries(headers).forEach(([name, value]) => {
+        // Don't override Content-Type or Cache-Control if already set
+        const lowerName = name.toLowerCase();
+        if (lowerName !== "content-type" && lowerName !== "cache-control") {
+          responseHeaders.set(name, String(value));
+        }
+      });
+
+      // Return Response with proper image content type for Camo compatibility
+      return new Response(svgBody, {
+        status: 200,
+        headers: responseHeaders,
+      });
+    },
+    _wasSent: () => responseSent,
+    _getBody: () => responseBody,
+  };
+}
+
+/**
+ * Creates a mock Express request object from Hono context.
+ *
+ * @param {import('hono').Context} c Hono context
+ * @returns {any} Mock Express request object
+ */
+export function createMockRequest(c) {
+  return {
+    query: c.req.query(),
+  };
+}
+
+/**
+ * Adapts an Express-style handler to work with Hono.
+ *
+ * @param {Function} expressHandler Express handler function (req, res) => {}
+ * @returns {Function} Hono handler function
+ */
+export function adaptExpressHandler(expressHandler) {
+  return async (c) => {
+    const req = createMockRequest(c);
+    const res = createMockResponse();
+
+    try {
+      const result = await expressHandler(req, res);
+
+      // If res.send() was called, it returns a Response object
+      if (res._wasSent()) {
+        // If result is a Response (from res.send()), return it directly
+        if (result instanceof Response) {
+          return result;
+        }
+        // Otherwise, result might be undefined or something else
+        // In that case, we already have the body from res._getBody()
+        const body = res._getBody();
+        if (body !== null) {
+          // Reconstruct the response with proper image content type for Camo
+          const svgBody = typeof body === "string" ? body : String(body);
+          return new Response(svgBody, {
+            status: 200,
+            headers: {
+              "Content-Type": "image/svg+xml; charset=utf-8",
+              "Cache-Control": "public, max-age=3600",
+            },
+          });
+        }
+        if (result !== undefined) {
+          return result;
+        }
+        return c;
+      }
+
+      // If handler returns something directly (like a Response from guardAccess)
+      if (result !== undefined) {
+        // If it's a Response, return it directly
+        if (result instanceof Response) {
+          return result;
+        }
+        return result;
+      }
+
+      // Fallback - should not happen in normal flow
+      // Return SVG error card instead of text for Camo compatibility
+      const errorSvg = `<svg width="400" height="100" xmlns="http://www.w3.org/2000/svg"><text x="20" y="50" font-family="Arial" font-size="16" fill="red">No response generated</text></svg>`;
+      return new Response(errorSvg, {
+        status: 500,
+        headers: { "Content-Type": "image/svg+xml; charset=utf-8" },
+      });
+    } catch (error) {
+      // Log the error for debugging
+      console.error("Adapter error:", error);
+      console.error("Error stack:", error.stack);
+      console.error("Request URL:", c.req.url);
+      console.error("Request query:", c.req.query());
+
+      // Return SVG error card instead of text for Camo compatibility
+      // Sanitize error message to prevent XSS
+      const safeMessage = encodeHTML(String(error.message || "Unknown error"));
+      const errorSvg = `<svg width="400" height="100" xmlns="http://www.w3.org/2000/svg"><text x="20" y="50" font-family="Arial" font-size="16" fill="red">Error: ${safeMessage}</text></svg>`;
+      return new Response(errorSvg, {
+        status: 500,
+        headers: { "Content-Type": "image/svg+xml; charset=utf-8" },
+      });
+    }
+  };
+}

package/src/common/worker-env.js

@@ -0,0 +1,48 @@
+// @ts-check
+
+// Initialize process.env early to prevent errors during module imports
+// This is safe because if we're in Node.js, process.env already exists
+// If we're in Workers, we'll populate it later via setupWorkerEnv
+if (typeof globalThis.process === "undefined") {
+  globalThis.process = { env: {} };
+}
+
+/**
+ * Checks if we're running in Cloudflare Workers environment.
+ * Detects by checking for Cloudflare-specific globals that exist at import time.
+ * @returns {boolean} True if running in Cloudflare Workers, false otherwise
+ */
+export function isCloudflareWorkers() {
+  // Check for Cloudflare Workers runtime globals
+  // These exist at import time, before setupWorkerEnv is called
+  // In Workers, process.env typically doesn't exist or is empty at import time
+  return (
+    typeof globalThis.process === "undefined" ||
+    !globalThis.process.env ||
+    Object.keys(globalThis.process.env).length === 0
+  );
+}
+
+/**
+ * Sets up process.env from Cloudflare Workers env object.
+ * This allows the existing codebase to work with Cloudflare Workers
+ * without requiring changes to all files that use process.env.
+ *
+ * @param {Record<string, any>} env Cloudflare Workers environment object
+ */
+export function setupWorkerEnv(env) {
+  // Copy all env vars to process.env
+  // Cloudflare Workers don't have process.env, so we create a mock
+  if (typeof globalThis.process === "undefined") {
+    globalThis.process = { env: {} };
+  }
+
+  // Merge Cloudflare env vars into process.env
+  Object.assign(globalThis.process.env, env);
+
+  // Also set NODE_ENV if not already set
+  // Check using 'in' operator to avoid triggering the "define" replacement warning
+  if (!("NODE_ENV" in globalThis.process.env)) {
+    globalThis.process.env.NODE_ENV = "production";
+  }
+}