@chr33s/pdf-standard-fonts 5.0.0

package/test/encoding.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "vitest";
+
+import { Encodings } from "../src/index.js";
+
+describe("Encodings", () => {
+  test("lists supported code points in ascending order", () => {
+    const winAnsi = Encodings.WinAnsi;
+    const { supportedCodePoints } = winAnsi;
+
+    expect(supportedCodePoints.length).toBeGreaterThan(0);
+    expect(supportedCodePoints).toEqual([...supportedCodePoints].sort((a, b) => a - b));
+  });
+
+  test("encodes mapped code points and reports unsupported ones", () => {
+    const encoding = Encodings.Symbol;
+    const [firstSupported] = encoding.supportedCodePoints;
+
+    expect(firstSupported).toBeDefined();
+    if (firstSupported) {
+      const result = encoding.encodeUnicodeCodePoint(firstSupported);
+      expect(typeof result.code).toBe("number");
+      expect(typeof result.name).toBe("string");
+      expect(encoding.canEncodeUnicodeCodePoint(firstSupported)).toBe(true);
+    }
+
+    const unsupportedCodePoint = 0xffff;
+    expect(encoding.canEncodeUnicodeCodePoint(unsupportedCodePoint)).toBe(false);
+    expect(() => encoding.encodeUnicodeCodePoint(unsupportedCodePoint)).toThrow(
+      /Symbol cannot encode/,
+    );
+  });
+});

package/test/encodings-async.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from "vitest";
+
+import { getEncodings } from "../src/index.js";
+
+describe("getEncodings", () => {
+  test("returns all three encodings", async () => {
+    const encodings = await getEncodings();
+
+    expect(encodings.Symbol).toBeDefined();
+    expect(encodings.ZapfDingbats).toBeDefined();
+    expect(encodings.WinAnsi).toBeDefined();
+  });
+
+  test("WinAnsi encoding supports common ASCII characters", async () => {
+    const encodings = await getEncodings();
+    const winAnsi = encodings.WinAnsi;
+
+    // Space (0x20)
+    expect(winAnsi.canEncodeUnicodeCodePoint(0x0020)).toBe(true);
+    // 'A' (0x41)
+    expect(winAnsi.canEncodeUnicodeCodePoint(0x0041)).toBe(true);
+    // 'a' (0x61)
+    expect(winAnsi.canEncodeUnicodeCodePoint(0x0061)).toBe(true);
+    // '0' (0x30)
+    expect(winAnsi.canEncodeUnicodeCodePoint(0x0030)).toBe(true);
+  });
+
+  test("Symbol encoding handles Greek letters", async () => {
+    const encodings = await getEncodings();
+    const symbol = encodings.Symbol;
+
+    // Symbol encoding uses different mappings
+    expect(symbol.supportedCodePoints.length).toBeGreaterThan(0);
+  });
+
+  test("ZapfDingbats encoding has supported code points", async () => {
+    const encodings = await getEncodings();
+    const zapf = encodings.ZapfDingbats;
+
+    expect(zapf.supportedCodePoints.length).toBeGreaterThan(0);
+  });
+
+  test("encodeUnicodeCodePoint returns code and name", async () => {
+    const encodings = await getEncodings();
+    const winAnsi = encodings.WinAnsi;
+
+    // Encode 'A'
+    const result = winAnsi.encodeUnicodeCodePoint(0x0041);
+    expect(typeof result.code).toBe("number");
+    expect(typeof result.name).toBe("string");
+    expect(result.name).toBe("A");
+  });
+
+  test("encodeUnicodeCodePoint throws for unsupported code points", async () => {
+    const encodings = await getEncodings();
+    const winAnsi = encodings.WinAnsi;
+
+    // High Unicode code point not in WinAnsi
+    expect(() => winAnsi.encodeUnicodeCodePoint(0x10000)).toThrow(/WinAnsi cannot encode/);
+  });
+
+  test("encodings are memoized", async () => {
+    const first = await getEncodings();
+    const second = await getEncodings();
+
+    expect(first).toBe(second);
+  });
+
+  test("supportedCodePoints are sorted in ascending order", async () => {
+    const encodings = await getEncodings();
+
+    for (const encoding of [encodings.WinAnsi, encodings.Symbol, encodings.ZapfDingbats]) {
+      const { supportedCodePoints } = encoding;
+      const sorted = [...supportedCodePoints].sort((a, b) => a - b);
+      expect(supportedCodePoints).toEqual(sorted);
+    }
+  });
+});

package/test/font.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+
+import { Font, FontNames } from "../src/index.js";
+
+describe("Font.load", () => {
+  test("returns memoized instances", async () => {
+    const firstLoad = await Font.load(FontNames.Courier);
+    const secondLoad = await Font.load(FontNames.Courier);
+
+    expect(firstLoad).toBe(secondLoad);
+  });
+
+  test("computes glyph widths and kerning lookups", async () => {
+    const font = await Font.load(FontNames.Helvetica);
+
+    const charMetrics = font.CharMetrics.find((metric) => metric.N === "A");
+    expect(charMetrics).toBeDefined();
+    expect(font.getWidthOfGlyph("A")).toBe(charMetrics?.WX);
+
+    const kernPair = font.KernPairs.find(
+      ([left, right]) => font.getXAxisKerningForPair(left, right) !== undefined,
+    );
+    expect(kernPair).toBeDefined();
+    if (kernPair) {
+      expect(font.getXAxisKerningForPair(kernPair[0], kernPair[1])).toBe(kernPair[2]);
+    }
+  });
+
+  test("accepts canonical font name aliases", async () => {
+    const fromAlias = await Font.load(FontNames.HelveticaBold);
+    const fromLiteral = await Font.load("Helvetica-Bold");
+
+    expect(fromAlias).toBe(fromLiteral);
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "vitest";
+import { decompressJson, padStart } from "../src/utils.js";
+
+describe("utils", () => {
+  describe("padStart", () => {
+    test("should pad string to specified length", () => {
+      expect(padStart("42", 4, "0")).toBe("0042");
+    });
+
+    test("should not pad if string is already long enough", () => {
+      expect(padStart("1234", 4, "0")).toBe("1234");
+    });
+
+    test("should not pad if string is longer than specified length", () => {
+      expect(padStart("12345", 4, "0")).toBe("12345");
+    });
+
+    test("should handle empty string", () => {
+      expect(padStart("", 3, "x")).toBe("xxx");
+    });
+
+    test("should handle single character padding", () => {
+      expect(padStart("a", 5, "-")).toBe("----a");
+    });
+  });
+
+  describe("decompressJson", () => {
+    // Note: This test requires a valid compressed JSON string
+    // The actual compressed format is base64-encoded deflated data
+    test("should be a function", () => {
+      expect(typeof decompressJson).toBe("function");
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}

package/tsconfig.typecheck.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "."
+  },
+  "include": [
+    "**/*.ts",
+  ],
+  "exclude": [
+    "dist",
+    "node_modules"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+  },
+});