@hobenakicoffee/libraries 0.0.10 → 0.0.12

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@hobenakicoffee/libraries",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "type": "module",
   "types": "src/index.ts",
   "exports": {
     ".": "./src/index.ts",
-    "./constants": "./src/constants/index.ts"
+    "./constants": "./src/constants/index.ts",
+    "./utils": "./src/utils/index.ts"
   },
   "files": [
     "src",
@@ -30,5 +31,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "sonner": "^2.0.7"
   }
 }

package/src/utils/format-amount.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { formatAmount, formatSignedAmount } from "./format-amount";
+
+describe("formatAmount", () => {
+  test("formats absolute number with currency symbol", () => {
+    const expected = new Intl.NumberFormat(undefined, {
+      maximumFractionDigits: 0,
+    }).format(1234);
+
+    expect(formatAmount(-1234)).toBe(`৳${expected}`);
+  });
+});
+
+describe("formatSignedAmount", () => {
+  test("uses minus sign for debit", () => {
+    const expected = new Intl.NumberFormat(undefined, {
+      maximumFractionDigits: 0,
+    }).format(2000);
+
+    expect(formatSignedAmount(2000, "debit")).toBe(`- ৳${expected}`);
+  });
+
+  test("uses plus sign for credit and absolute value", () => {
+    const expected = new Intl.NumberFormat(undefined, {
+      maximumFractionDigits: 0,
+    }).format(2000);
+
+    expect(formatSignedAmount(-2000, "credit")).toBe(`+ ৳${expected}`);
+  });
+});

package/src/utils/format-amount.ts

@@ -0,0 +1,19 @@
+export function formatAmount(value: number) {
+  const formatted = new Intl.NumberFormat(undefined, {
+    maximumFractionDigits: 0,
+  }).format(Math.abs(value));
+
+  return `৳${formatted}`;
+}
+
+export function formatSignedAmount(
+  value: number,
+  direction: "debit" | "credit"
+) {
+  const formatted = new Intl.NumberFormat(undefined, {
+    maximumFractionDigits: 0,
+  }).format(Math.abs(value));
+
+  const sign = direction === "debit" ? "-" : "+";
+  return `${sign} ৳${formatted}`;
+}

package/src/utils/format-date.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { formatDate } from "./format-date";
+
+describe("formatDate", () => {
+  test("returns dash for invalid date", () => {
+    expect(formatDate("not-a-date")).toBe("-");
+  });
+
+  test("formats a valid date", () => {
+    const input = "2026-02-13T00:00:00.000Z";
+    const expected = new Date(input).toLocaleDateString(undefined, {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+    });
+
+    expect(formatDate(input)).toBe(expected);
+  });
+});

package/src/utils/format-date.ts

@@ -0,0 +1,13 @@
+export function formatDate(value: string) {
+  const date = new Date(value);
+
+  if (Number.isNaN(date.getTime())) {
+    return "-";
+  }
+
+  return date.toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+}

package/src/utils/format-plain-text.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { formatMetadataKey, formatToPlainText } from "./format-plain-text";
+
+describe("formatToPlainText", () => {
+  test("returns empty string for null and undefined", () => {
+    expect(formatToPlainText(null)).toBe("");
+    expect(formatToPlainText(undefined)).toBe("");
+  });
+
+  test("formats booleans to Yes/No by default", () => {
+    expect(formatToPlainText(true)).toBe("Yes");
+    expect(formatToPlainText(false)).toBe("No");
+  });
+
+  test("can keep raw boolean text", () => {
+    expect(formatToPlainText(true, { formatBooleans: false })).toBe("true");
+  });
+
+  test("truncates long strings with ellipsis", () => {
+    expect(formatToPlainText("abcdef", { maxStringLength: 5 })).toBe("ab...");
+  });
+
+  test("stringifies objects and arrays", () => {
+    expect(formatToPlainText({ a: 1 })).toBe(JSON.stringify({ a: 1 }, null, 2));
+    expect(formatToPlainText(["x", "y"])).toBe(
+      JSON.stringify(["x", "y"], null, 2),
+    );
+  });
+});
+
+describe("formatMetadataKey", () => {
+  test("formats camelCase and snake_case keys", () => {
+    expect(formatMetadataKey("supporterName")).toBe("Supporter Name");
+    expect(formatMetadataKey("is_monthly")).toBe("Is monthly");
+  });
+});

package/src/utils/format-plain-text.ts

@@ -0,0 +1,58 @@
+const CAPITALIZE_REGEX = /([A-Z])/g;
+const SPACE_REPLACE_REGEX = /_/g;
+const FIRST_LETTER_REGEX = /^\w/;
+
+export function formatToPlainText(
+  value: unknown,
+  options?: {
+    formatBooleans?: boolean;
+    preserveNumbers?: boolean;
+    maxStringLength?: number;
+  }
+): string {
+  const formatBooleans = options?.formatBooleans ?? true;
+  const preserveNumbers = options?.preserveNumbers ?? true;
+  const maxStringLength = options?.maxStringLength ?? 100;
+
+  // Handle null/undefined values
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  // Format based on type
+  switch (typeof value) {
+    case "boolean":
+      return formatBooleans ? (value ? "Yes" : "No") : String(value);
+
+    case "number":
+      return preserveNumbers ? value.toString() : value.toString();
+
+    case "string": {
+      const stringValue = value as string;
+      return maxStringLength && stringValue.length > maxStringLength
+        ? `${stringValue.substring(0, maxStringLength - 3)}...`
+        : stringValue;
+    }
+
+    case "object":
+      if (Array.isArray(value)) {
+        return JSON.stringify(value, null, 2);
+      }
+      return JSON.stringify(value, null, 2);
+
+    default:
+      return String(value);
+  }
+}
+
+function capitalizeKey(keyToFormat: string): string {
+  return keyToFormat
+    .replace(CAPITALIZE_REGEX, " $1") // "supporterName" → "supporter Name"
+    .replace(SPACE_REPLACE_REGEX, " ") // "is_monthly" → "is monthly"
+    .replace(FIRST_LETTER_REGEX, (c) => c.toUpperCase()) // "supporter" → "Supporter"
+    .trim();
+}
+
+export function formatMetadataKey(key: string): string {
+  return capitalizeKey(key);
+}

package/src/utils/get-social-handle.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { getSocialUrl } from "./get-social-handle";
+import { getUserPageLink } from "./get-user-page-link";
+
+describe("getSocialUrl", () => {
+  test("returns our platform URL when username is provided", () => {
+    expect(getSocialUrl("alice", "x", "ignored")).toBe(
+      getUserPageLink("alice"),
+    );
+  });
+
+  test("returns # when required fields are missing", () => {
+    expect(getSocialUrl(undefined, "x", "")).toBe("#");
+    expect(getSocialUrl(undefined, null, "name")).toBe("#");
+  });
+
+  test("builds social URL with sanitized handle", () => {
+    expect(getSocialUrl(undefined, "instagram", " @john doe ")).toBe(
+      "https://instagram.com/johndoe",
+    );
+  });
+
+  test("uses platform-specific format for youtube", () => {
+    expect(getSocialUrl(undefined, "youtube", "Jane")).toBe(
+      "https://youtube.com/@Jane",
+    );
+  });
+
+  test("returns # for unsupported platform", () => {
+    expect(getSocialUrl(undefined, "myspace" as any, "Jane")).toBe("#");
+  });
+});

package/src/utils/get-social-handle.ts

@@ -0,0 +1,66 @@
+import type { SupporterPlatform } from "@hobenakicoffee/libraries";
+import { getUserPageLink } from "./get-user-page-link";
+
+const patternsToRemove = /^@/;
+
+const sanitizeHandle = (value: string) =>
+  encodeURIComponent(
+    value.trim().replace(patternsToRemove, "").replace(/\s+/g, "")
+  );
+
+export const getSocialUrl = (
+  ourPlatformUsername?: string | null,
+  platform?: SupporterPlatform | null,
+  supporterName?: string | null
+) => {
+  if (ourPlatformUsername) {
+    return getUserPageLink(ourPlatformUsername);
+  }
+
+  if (!(platform && supporterName?.trim())) {
+    return "#";
+  }
+
+  const handle = sanitizeHandle(supporterName);
+
+  switch (platform) {
+    case "facebook":
+      return `https://facebook.com/${handle}`;
+    case "x":
+      return `https://x.com/${handle}`;
+    case "instagram":
+      return `https://instagram.com/${handle}`;
+    case "youtube":
+      return `https://youtube.com/@${handle}`;
+    case "github":
+      return `https://github.com/${handle}`;
+    case "linkedin":
+      return `https://www.linkedin.com/in/${handle}`;
+    case "twitch":
+      return `https://twitch.tv/${handle}`;
+    case "tiktok":
+      return `https://www.tiktok.com/@${handle}`;
+    case "threads":
+      return `https://www.threads.net/@${handle}`;
+    case "whatsapp":
+      return `https://wa.me/${handle}`;
+    case "telegram":
+      return `https://t.me/${handle}`;
+    case "discord":
+      return `https://discord.com/users/${handle}`;
+    case "reddit":
+      return `https://reddit.com/u/${handle}`;
+    case "pinterest":
+      return `https://pinterest.com/${handle}`;
+    case "medium":
+      return `https://medium.com/@${handle}`;
+    case "devto":
+      return `https://dev.to/${handle}`;
+    case "behance":
+      return `https://www.behance.net/${handle}`;
+    case "dribbble":
+      return `https://dribbble.com/${handle}`;
+    default:
+      return "#";
+  }
+};

package/src/utils/get-user-page-link.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from "bun:test";
+import { getUserPageLink } from "./get-user-page-link";
+
+describe("getUserPageLink", () => {
+  test("builds user page link with sanitized username", () => {
+    const result = getUserPageLink(" @john doe ");
+
+    expect(result.endsWith("/@%40johndoe")).toBe(true);
+  });
+});

package/src/utils/get-user-page-link.ts

@@ -0,0 +1,6 @@
+export function getUserPageLink(username: string) {
+  const sanitizedUsername = encodeURIComponent(
+    username.trim().replace(/\s+/g, ""),
+  );
+  return `https://hobenakicoffee.com/@${sanitizedUsername}`;
+}

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+export * from "./format-amount";
+export * from "./format-date";
+export * from "./format-plain-text";
+export * from "./get-social-handle";
+export * from "./get-user-page-link";
+export * from "./open-to-new-window";
+export * from "./post-to-facebook";
+export * from "./post-to-instagram";
+export * from "./post-to-linkedin";
+export * from "./post-to-x";
+export * from "./qr-svg-utils";

package/src/utils/open-to-new-window.test.ts

@@ -0,0 +1,34 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { openInNewWindow } from "./open-to-new-window";
+
+describe("openInNewWindow", () => {
+  const originalWindow = (globalThis as any).window;
+
+  afterEach(() => {
+    (globalThis as any).window = originalWindow;
+  });
+
+  test("opens url in a new tab", () => {
+    const calls: unknown[][] = [];
+    (globalThis as any).window = {
+      open: (...args: unknown[]) => {
+        calls.push(args);
+      },
+    };
+
+    openInNewWindow("https://example.com");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual([
+      "https://example.com",
+      "_blank",
+      "noopener,noreferrer",
+    ]);
+  });
+
+  test("does nothing when window is undefined", () => {
+    (globalThis as any).window = undefined;
+
+    expect(() => openInNewWindow("https://example.com")).not.toThrow();
+  });
+});

package/src/utils/open-to-new-window.ts

@@ -0,0 +1,5 @@
+export const openInNewWindow = (url: string): void => {
+  if (typeof window === "undefined") return;
+
+  window.open(url, "_blank", "noopener,noreferrer");
+};

package/src/utils/post-to-facebook.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { shareToFacebook } from "./post-to-facebook";
+
+describe("shareToFacebook", () => {
+  const originalWindow = (globalThis as any).window;
+
+  afterEach(() => {
+    (globalThis as any).window = originalWindow;
+  });
+
+  test("throws when url is missing", () => {
+    expect(() => shareToFacebook({ url: "" })).toThrow(
+      "Facebook share requires a URL",
+    );
+  });
+
+  test("opens facebook share url with params", () => {
+    const calls: unknown[][] = [];
+    (globalThis as any).window = {
+      open: (...args: unknown[]) => {
+        calls.push(args);
+      },
+    };
+
+    shareToFacebook({
+      url: "https://example.com",
+      quote: "Hello",
+      hashtag: "#coffee",
+      ref: "campaign",
+    });
+
+    const params = new URLSearchParams({ u: "https://example.com" });
+    params.append("quote", "Hello");
+    params.append("hashtag", "#coffee");
+    params.append("ref", "campaign");
+
+    expect(calls[0]).toEqual([
+      `https://www.facebook.com/sharer/sharer.php?${params.toString()}`,
+      "_blank",
+      "noopener,noreferrer",
+    ]);
+  });
+});

package/src/utils/post-to-facebook.ts

@@ -0,0 +1,29 @@
+type FacebookShareOptions = {
+  url: string; // Required
+  quote?: string; // Optional (may be ignored by FB)
+  hashtag?: string; // Only ONE hashtag allowed
+  ref?: string; // Channel / campaign reference
+};
+
+export function shareToFacebook({
+  url,
+  quote,
+  hashtag,
+  ref,
+}: FacebookShareOptions) {
+  if (!url) {
+    throw new Error("Facebook share requires a URL");
+  }
+
+  const params = new URLSearchParams({
+    u: url,
+  });
+
+  if (quote) params.append("quote", quote);
+  if (hashtag) params.append("hashtag", hashtag);
+  if (ref) params.append("ref", ref);
+
+  const shareUrl = `https://www.facebook.com/sharer/sharer.php?${params.toString()}`;
+
+  window.open(shareUrl, "_blank", "noopener,noreferrer");
+}

package/src/utils/post-to-instagram.test.ts

@@ -0,0 +1,56 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("sonner", () => ({
+  toast: {
+    success: () => undefined,
+    error: () => undefined,
+  },
+}));
+
+describe("shareToInstagram", () => {
+  const originalNavigator = (globalThis as any).navigator;
+  const originalWindow = (globalThis as any).window;
+
+  beforeEach(() => {
+    (globalThis as any).window = {
+      open: () => undefined,
+    };
+  });
+
+  afterEach(() => {
+    (globalThis as any).navigator = originalNavigator;
+    (globalThis as any).window = originalWindow;
+  });
+
+  test("throws when url is missing", async () => {
+    const { shareToInstagram } = await import("./post-to-instagram");
+
+    expect(() => shareToInstagram({ url: "" })).toThrow(
+      "Instagram share requires a URL",
+    );
+  });
+
+  test("uses Web Share API when available", async () => {
+    const shareCalls: unknown[] = [];
+
+    (globalThis as any).navigator = {
+      share: (payload: unknown) => {
+        shareCalls.push(payload);
+        return Promise.resolve();
+      },
+      clipboard: {
+        writeText: () => Promise.resolve(),
+      },
+    };
+
+    const { shareToInstagram } = await import("./post-to-instagram");
+
+    shareToInstagram({ url: "https://example.com", text: "Look" });
+
+    expect(shareCalls).toHaveLength(1);
+    expect(shareCalls[0]).toEqual({
+      title: "Look",
+      url: "https://example.com",
+    });
+  });
+});

package/src/utils/post-to-instagram.ts

@@ -0,0 +1,42 @@
+import { toast } from "sonner";
+
+type InstagramShareOptions = {
+  url: string; // Required
+  text?: string; // Optional text to include
+};
+
+export function shareToInstagram({ url, text }: InstagramShareOptions) {
+  if (!url) {
+    throw new Error("Instagram share requires a URL");
+  }
+
+  // Instagram doesn't have a direct web share URL like Facebook or LinkedIn
+  // We'll use the Web Share API if available, otherwise fall back to copying the link
+  if (navigator.share) {
+    navigator
+      .share({
+        title: text || "Check this out!",
+        url,
+      })
+      .catch(() => {
+        toast.error("Failed to share to Instagram.");
+      });
+  } else {
+    // Fallback: Open Instagram website or copy to clipboard
+    // Since Instagram doesn't support direct web sharing, we'll open their homepage
+    // Users can manually paste the link in their post
+    window.open("https://www.instagram.com/", "_blank", "noopener,noreferrer");
+
+    // Copy the URL to clipboard for easy pasting
+    navigator.clipboard
+      .writeText(url)
+      .then(() => {
+        toast.success(
+          "Link copied to clipboard. You can now paste it in your Instagram post."
+        );
+      })
+      .catch(() => {
+        toast.error("Failed to copy link to clipboard.");
+      });
+  }
+}

package/src/utils/post-to-linkedin.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { shareToLinkedIn } from "./post-to-linkedin";
+
+describe("shareToLinkedIn", () => {
+  const originalWindow = (globalThis as any).window;
+
+  afterEach(() => {
+    (globalThis as any).window = originalWindow;
+  });
+
+  test("throws when url is missing", () => {
+    expect(() => shareToLinkedIn({ url: "" })).toThrow(
+      "LinkedIn share requires a URL",
+    );
+  });
+
+  test("opens linkedin share url with params", () => {
+    const calls: unknown[][] = [];
+    (globalThis as any).window = {
+      open: (...args: unknown[]) => {
+        calls.push(args);
+      },
+    };
+
+    shareToLinkedIn({
+      url: "https://example.com",
+      title: "Title",
+      summary: "Summary",
+      source: "Source",
+    });
+
+    const params = new URLSearchParams({ url: "https://example.com" });
+    params.append("title", "Title");
+    params.append("summary", "Summary");
+    params.append("source", "Source");
+
+    expect(calls[0]).toEqual([
+      `https://www.linkedin.com/sharing/share-offsite/?${params.toString()}`,
+      "_blank",
+      "noopener,noreferrer",
+    ]);
+  });
+});

package/src/utils/post-to-linkedin.ts

@@ -0,0 +1,29 @@
+type LinkedInShareOptions = {
+  url: string; // Required
+  title?: string; // Optional title
+  summary?: string; // Optional summary/description
+  source?: string; // Optional source attribution
+};
+
+export function shareToLinkedIn({
+  url,
+  title,
+  summary,
+  source,
+}: LinkedInShareOptions) {
+  if (!url) {
+    throw new Error("LinkedIn share requires a URL");
+  }
+
+  const params = new URLSearchParams({
+    url,
+  });
+
+  if (title) params.append("title", title);
+  if (summary) params.append("summary", summary);
+  if (source) params.append("source", source);
+
+  const shareUrl = `https://www.linkedin.com/sharing/share-offsite/?${params.toString()}`;
+
+  window.open(shareUrl, "_blank", "noopener,noreferrer");
+}

package/src/utils/post-to-x.test.ts

@@ -0,0 +1,45 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { shareToX } from "./post-to-x";
+
+describe("shareToX", () => {
+  const originalWindow = (globalThis as any).window;
+
+  afterEach(() => {
+    (globalThis as any).window = originalWindow;
+  });
+
+  test("throws when text is missing", () => {
+    expect(() => shareToX({ text: "" })).toThrow(
+      "X share requires text content",
+    );
+  });
+
+  test("opens x intent url with params", () => {
+    const calls: unknown[][] = [];
+    (globalThis as any).window = {
+      open: (...args: unknown[]) => {
+        calls.push(args);
+      },
+    };
+
+    shareToX({
+      text: "Hello",
+      url: "https://example.com",
+      hashtags: "coffee,shop",
+      via: "hobenaki",
+      related: "friend1,friend2",
+    });
+
+    const params = new URLSearchParams({ text: "Hello" });
+    params.append("url", "https://example.com");
+    params.append("hashtags", "coffee,shop");
+    params.append("via", "hobenaki");
+    params.append("related", "friend1,friend2");
+
+    expect(calls[0]).toEqual([
+      `https://twitter.com/intent/tweet?${params.toString()}`,
+      "_blank",
+      "noopener,noreferrer",
+    ]);
+  });
+});

package/src/utils/post-to-x.ts

@@ -0,0 +1,26 @@
+type XShareOptions = {
+  text: string; // Required
+  url?: string; // Optional URL to share
+  hashtags?: string; // Comma-separated hashtags (without #)
+  via?: string; // Twitter username to attribute (without @)
+  related?: string; // Comma-separated accounts to recommend
+};
+
+export function shareToX({ text, url, hashtags, via, related }: XShareOptions) {
+  if (!text) {
+    throw new Error("X share requires text content");
+  }
+
+  const params = new URLSearchParams({
+    text,
+  });
+
+  if (url) params.append("url", url);
+  if (hashtags) params.append("hashtags", hashtags);
+  if (via) params.append("via", via);
+  if (related) params.append("related", related);
+
+  const shareUrl = `https://twitter.com/intent/tweet?${params.toString()}`;
+
+  window.open(shareUrl, "_blank", "noopener,noreferrer");
+}

package/src/utils/qr-svg-utils.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("sonner", () => ({
+  toast: {
+    success: () => undefined,
+    error: () => undefined,
+  },
+}));
+
+describe("downloadQrSvgAsPng", () => {
+  const originalImage = (globalThis as any).Image;
+
+  afterEach(() => {
+    (globalThis as any).Image = originalImage;
+  });
+
+  test("calls onError when image loading fails", async () => {
+    class BrokenImage {
+      public onload: (() => void) | null = null;
+      public onerror: (() => void) | null = null;
+      public decoding = "async";
+
+      set src(_value: string) {
+        this.onerror?.();
+      }
+    }
+
+    (globalThis as any).Image = BrokenImage;
+
+    const { downloadQrSvgAsPng } = await import("./qr-svg-utils");
+
+    let failed = false;
+    await downloadQrSvgAsPng("<svg></svg>", "test.png", undefined, () => {
+      failed = true;
+    });
+
+    expect(failed).toBe(true);
+  });
+});
+
+describe("printQrSvg", () => {
+  const originalDocument = (globalThis as any).document;
+  const originalDOMParser = (globalThis as any).DOMParser;
+
+  afterEach(() => {
+    (globalThis as any).document = originalDocument;
+    (globalThis as any).DOMParser = originalDOMParser;
+  });
+
+  test("calls onError for invalid SVG markup", async () => {
+    const createNode = () => ({
+      style: {},
+      textContent: "",
+      setAttribute: () => undefined,
+      append: () => undefined,
+      appendChild: () => undefined,
+    });
+
+    const iframeDocument = {
+      documentElement: {},
+      createElement: () => createNode(),
+      replaceChild: () => undefined,
+    };
+
+    const iframe = {
+      style: {},
+      contentWindow: {
+        document: iframeDocument,
+        addEventListener: () => undefined,
+        focus: () => undefined,
+        print: () => undefined,
+      },
+      setAttribute: () => undefined,
+      remove: () => undefined,
+    };
+
+    (globalThis as any).document = {
+      createElement: (tagName: string) =>
+        tagName === "iframe" ? iframe : createNode(),
+      body: {
+        append: () => undefined,
+      },
+    };
+
+    (globalThis as any).DOMParser = class {
+      parseFromString() {
+        return {
+          documentElement: {
+            nodeName: "parsererror",
+          },
+        };
+      }
+    };
+
+    const { printQrSvg } = await import("./qr-svg-utils");
+
+    let failed = false;
+    printQrSvg("<svg", "QR Print", () => {
+      failed = true;
+    });
+
+    expect(failed).toBe(true);
+  });
+});

package/src/utils/qr-svg-utils.ts

@@ -0,0 +1,182 @@
+// Utility functions for QR code SVG download and print
+
+import { toast } from "sonner";
+
+/**
+ * Downloads a QR code SVG as a PNG file.
+ * @param svgMarkup - The SVG markup string
+ * @param fileName - The file name for the PNG
+ * @param onSuccess - Callback for success
+ * @param onError - Callback for error
+ */
+export async function downloadQrSvgAsPng(
+  svgMarkup: string,
+  fileName: string,
+  onSuccess?: () => void,
+  onError?: () => void
+): Promise<void> {
+  try {
+    const svgBlob = new Blob([svgMarkup], { type: "image/svg+xml" });
+    const svgUrl = URL.createObjectURL(svgBlob);
+
+    const image = new Image();
+    image.decoding = "async";
+
+    await new Promise<void>((resolve, reject) => {
+      image.onload = () => resolve();
+      image.onerror = () => reject(new Error("QR image failed to load"));
+      image.src = svgUrl;
+    });
+
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    if (!context) {
+      URL.revokeObjectURL(svgUrl);
+      throw new Error("Canvas context unavailable");
+    }
+
+    const exportScale = 8;
+    const maxSize = 2400;
+    const scaleFromMaxSize = maxSize / image.width;
+    const scale = Math.min(exportScale, scaleFromMaxSize);
+
+    canvas.width = Math.round(image.width * scale);
+    canvas.height = Math.round(image.height * scale);
+
+    context.fillStyle = "white";
+    context.fillRect(0, 0, canvas.width, canvas.height);
+    context.imageSmoothingEnabled = false;
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+
+    URL.revokeObjectURL(svgUrl);
+
+    const pngBlob = await new Promise<Blob>((resolve, reject) => {
+      canvas.toBlob((blob) => {
+        if (!blob) {
+          reject(new Error("PNG blob generation failed"));
+          return;
+        }
+        resolve(blob);
+      }, "image/png");
+    });
+
+    const pngUrl = URL.createObjectURL(pngBlob);
+    const link = document.createElement("a");
+    link.href = pngUrl;
+    link.download = fileName;
+    link.click();
+
+    setTimeout(() => {
+      URL.revokeObjectURL(pngUrl);
+    }, 1000);
+
+    onSuccess?.();
+  } catch {
+    toast.error("Download failed");
+    onError?.();
+  }
+}
+
+/**
+ * Prints a QR code SVG markup.
+ * @param svgMarkup - The SVG markup string
+ * @param printTitle - The title for the print window
+ * @param onError - Callback for error
+ */
+export function printQrSvg(
+  svgMarkup: string,
+  printTitle: string,
+  onError?: () => void
+): void {
+  const iframe = document.createElement("iframe");
+  iframe.setAttribute("title", printTitle);
+  iframe.style.position = "fixed";
+  iframe.style.right = "0";
+  iframe.style.bottom = "0";
+  iframe.style.width = "0";
+  iframe.style.height = "0";
+  iframe.style.border = "0";
+  iframe.style.opacity = "0";
+  iframe.style.pointerEvents = "none";
+
+  document.body.append(iframe);
+
+  const cleanup = (): void => {
+    iframe.remove();
+  };
+
+  const iframeWindow = iframe.contentWindow;
+  const iframeDocument = iframeWindow?.document;
+
+  if (!(iframeWindow && iframeDocument)) {
+    cleanup();
+    onError?.();
+    return;
+  }
+
+  iframeWindow.addEventListener(
+    "afterprint",
+    () => {
+      cleanup();
+    },
+    { once: true }
+  );
+
+  // Construct document structure using DOM methods
+  const html = iframeDocument.createElement("html");
+  const head = iframeDocument.createElement("head");
+  const body = iframeDocument.createElement("body");
+
+  const meta = iframeDocument.createElement("meta");
+  meta.setAttribute("charset", "utf-8");
+
+  const title = iframeDocument.createElement("title");
+  title.textContent = printTitle;
+
+  const style = iframeDocument.createElement("style");
+  style.textContent = `
+    @page { margin: 0; }
+    html, body { height: 100%; }
+    body {
+      margin: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: #fff;
+    }
+    svg { width: 70vmin; height: 70vmin; }
+  `;
+
+  head.append(meta, title, style);
+  html.append(head, body);
+
+  // Replace the existing document element
+  iframeDocument.replaceChild(html, iframeDocument.documentElement);
+
+  // Safely parse and insert SVG
+  try {
+    const parser = new DOMParser();
+    const svgDoc = parser.parseFromString(svgMarkup, "image/svg+xml");
+    const svgElement = svgDoc.documentElement;
+
+    if (svgElement.nodeName === "parsererror") {
+      throw new Error("Invalid SVG markup");
+    }
+
+    body.appendChild(svgElement);
+  } catch {
+    toast.error("Failed to load QR code for printing");
+    cleanup();
+    onError?.();
+    return;
+  }
+
+  try {
+    iframeWindow.focus();
+    iframeWindow.print();
+  } catch {
+    toast.error("Printing failed");
+    cleanup();
+    onError?.();
+  }
+}