@flighthq/bitmapfont 0.1.0

package/dist/bitmapFont.d.ts

@@ -0,0 +1,8 @@
+import type { BitmapFont, BitmapFontData, GlyphEntry, GlyphMetrics, TextureAtlas } from '@flighthq/types';
+export declare function createBitmapFont(data: Readonly<BitmapFontData>): BitmapFont;
+export declare function getBitmapFontGlyph(font: Readonly<BitmapFont>, codepoint: number): GlyphEntry | null;
+export declare function getBitmapFontKerning(font: Readonly<BitmapFont>, left: number, right: number): number;
+export declare function getBitmapFontMetrics(font: Readonly<BitmapFont>): Readonly<GlyphMetrics>;
+export declare function getBitmapFontPage(font: Readonly<BitmapFont>, page?: number): TextureAtlas | null;
+export declare function getBitmapFontPages(font: Readonly<BitmapFont>): readonly TextureAtlas[];
+//# sourceMappingURL=bitmapFont.d.ts.map

package/dist/bitmapFont.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFont.d.ts","sourceRoot":"","sources":["../src/bitmapFont.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAS1G,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,UAAU,CAiC3E;AAID,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAEnG;AAID,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpG;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,CAEvF;AAKD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,SAAI,GAAG,YAAY,GAAG,IAAI,CAE3F;AAID,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,SAAS,YAAY,EAAE,CAEtF"}

package/dist/bitmapFont.js

@@ -0,0 +1,73 @@
+// Builds an immutable static bitmap font from plain data: the glyph list becomes a
+// `codepoint → GlyphEntry` map, the kerning pairs become a `(left << 16) | right → amount` map, and
+// the page-indexed atlas list, line metrics, and encoding (default `raster`) are carried as-is. Each
+// glyph's `page` (default 0) indexes `data.pages`; an out-of-range page is clamped to 0 so the glyph
+// is still placed (on the primary page) rather than dropped — a bad page index is a source-data
+// defect the font should survive, not a reason to lose a glyph. Nothing mutates the font after this
+// call — it is the static counterpart to the growing `@flighthq/glyphatlas`.
+export function createBitmapFont(data) {
+    const pageCount = data.pages.length;
+    const glyphs = new Map();
+    for (const glyph of data.glyphs) {
+        const page = glyph.page ?? 0;
+        glyphs.set(glyph.codepoint, {
+            advance: glyph.advance,
+            bearingX: glyph.bearingX,
+            bearingY: glyph.bearingY,
+            height: glyph.height,
+            page: page >= 0 && page < pageCount ? page : 0,
+            width: glyph.width,
+            x: glyph.x,
+            y: glyph.y,
+        });
+    }
+    const kerning = new Map();
+    if (data.kerning !== undefined) {
+        for (const pair of data.kerning) {
+            kerning.set(packBitmapFontKerningKey(pair.left, pair.right), pair.amount);
+        }
+    }
+    return {
+        encoding: data.encoding ?? 'raster',
+        glyphs,
+        kerning,
+        metrics: {
+            ascent: data.metrics.ascent,
+            descent: data.metrics.descent,
+            lineGap: data.metrics.lineGap,
+        },
+        pages: data.pages.slice(),
+    };
+}
+// The glyph entry (atlas rectangle + advance + bearing) for a codepoint, or `null` when the font
+// carries no glyph for it. A pure map lookup — the static counterpart to glyphatlas's rasterize-on-miss.
+export function getBitmapFontGlyph(font, codepoint) {
+    return font.glyphs.get(codepoint) ?? null;
+}
+// The horizontal kerning adjustment (pixels) between an adjacent `left`/`right` glyph pair, or 0 when
+// the font carries no entry for the pair.
+export function getBitmapFontKerning(font, left, right) {
+    return font.kerning.get(packBitmapFontKerningKey(left, right)) ?? 0;
+}
+// The font's shared line metrics (ascent/descent/lineGap), in pixels at the baked glyph size.
+export function getBitmapFontMetrics(font) {
+    return font.metrics;
+}
+// The texture atlas for one page of a multi-page font, or `null` when `page` is out of range. Page 0
+// is the primary page. The pixels a renderer uploads and samples for glyphs whose `page` matches.
+// Immutable: the font shares these references, it does not clone the atlases.
+export function getBitmapFontPage(font, page = 0) {
+    return font.pages[page] ?? null;
+}
+// The font's page-indexed atlas list — one `TextureAtlas` per page image. A single-page font has
+// length 1; each glyph's `page` indexes this array. Immutable: shared, not cloned.
+export function getBitmapFontPages(font) {
+    return font.pages;
+}
+// Packs an adjacent glyph pair into the single-number kerning-map key `(left << 16) | right`. Both
+// codepoints are assumed to lie in the Basic Multilingual Plane (< 0x10000); supplementary-plane
+// pairs are outside this table's addressable range.
+function packBitmapFontKerningKey(left, right) {
+    return (left << 16) | right;
+}
+//# sourceMappingURL=bitmapFont.js.map

package/dist/bitmapFont.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmapFont.js","sourceRoot":"","sources":["../src/bitmapFont.ts"],"names":[],"mappings":"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"}

package/dist/glyphSource.d.ts

@@ -0,0 +1,3 @@
+import type { BitmapFont, GlyphSource } from '@flighthq/types';
+export declare function createGlyphSourceFromBitmapFont(font: Readonly<BitmapFont>): GlyphSource;
+//# sourceMappingURL=glyphSource.d.ts.map

package/dist/glyphSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyphSource.d.ts","sourceRoot":"","sources":["../src/glyphSource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,WAAW,CAiBvF"}

package/dist/glyphSource.js

@@ -0,0 +1,24 @@
+import { getBitmapFontGlyph, getBitmapFontKerning, getBitmapFontMetrics } from './bitmapFont';
+// Adapts a `BitmapFont` into the `GlyphSource` seam a text renderer consumes, binding the font's pure
+// lookups into the method object. `getGlyphEntry` is the static map lookup (no side effects) — the
+// static counterpart to `@flighthq/glyphatlas`'s `createGlyphSourceFromGlyphAtlas`, whose
+// `getGlyphEntry` rasterizes on miss. A renderer holds either behind the one seam without knowing which.
+export function createGlyphSourceFromBitmapFont(font) {
+    return {
+        getGlyphAtlasImage(page = 0) {
+            // Each page's atlas image, indexed by the glyph's `page`. An out-of-range page (or a page whose
+            // atlas carries no image yet) yields null — the renderer skips glyphs it cannot sample.
+            return font.pages[page]?.image ?? null;
+        },
+        getGlyphEntry(codepoint) {
+            return getBitmapFontGlyph(font, codepoint);
+        },
+        getGlyphKerning(left, right) {
+            return getBitmapFontKerning(font, left, right);
+        },
+        getGlyphMetrics() {
+            return getBitmapFontMetrics(font);
+        },
+    };
+}
+//# sourceMappingURL=glyphSource.js.map

package/dist/glyphSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glyphSource.js","sourceRoot":"","sources":["../src/glyphSource.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAE9F,sGAAsG;AACtG,mGAAmG;AACnG,0FAA0F;AAC1F,yGAAyG;AACzG,MAAM,UAAU,+BAA+B,CAAC,IAA0B;IACxE,OAAO;QACL,kBAAkB,CAAC,IAAI,GAAG,CAAC;YACzB,gGAAgG;YAChG,wFAAwF;YACxF,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;QACzC,CAAC;QACD,aAAa,CAAC,SAAS;YACrB,OAAO,kBAAkB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC;QACD,eAAe,CAAC,IAAI,EAAE,KAAK;YACzB,OAAO,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QACjD,CAAC;QACD,eAAe;YACb,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bitmapFont';
+export * from './glyphSource';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './bitmapFont';
+export * from './glyphSource';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC"}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@flighthq/bitmapfont",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/textureatlas": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Static bitmap font — an immutable pre-baked atlas + glyph/kerning/metrics tables implementing the GlyphSource seam, the static sibling of the dynamic glyphatlas",
+  "sideEffects": false
+}

package/src/bitmapFont.test.ts

@@ -0,0 +1,127 @@
+import { createTextureAtlas } from '@flighthq/textureatlas';
+import type { BitmapFontData } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import {
+  createBitmapFont,
+  getBitmapFontGlyph,
+  getBitmapFontKerning,
+  getBitmapFontMetrics,
+  getBitmapFontPage,
+  getBitmapFontPages,
+} from './bitmapFont';
+
+describe('createBitmapFont', () => {
+  it('builds glyph and kerning lookups from plain data', () => {
+    const font = createBitmapFont(sampleFontData());
+
+    expect(font.glyphs.size).toBe(3);
+    expect(font.kerning.size).toBe(1);
+    expect(getBitmapFontGlyph(font, 65)).toEqual({
+      advance: 9,
+      bearingX: 1,
+      bearingY: 8,
+      height: 8,
+      page: 0,
+      width: 7,
+      x: 0,
+      y: 0,
+    });
+  });
+
+  it('defaults encoding to raster and carries an explicit encoding', () => {
+    expect(createBitmapFont(sampleFontData()).encoding).toBe('raster');
+    expect(createBitmapFont({ ...sampleFontData(), encoding: 'msdf' }).encoding).toBe('msdf');
+  });
+
+  it('assigns each glyph its declared page and defaults an omitted page to 0', () => {
+    const font = createBitmapFont({
+      ...sampleFontData(),
+      glyphs: [
+        { advance: 9, bearingX: 1, bearingY: 8, codepoint: 65, height: 8, page: 1, width: 7, x: 0, y: 0 },
+        { advance: 10, bearingX: 1, bearingY: 8, codepoint: 66, height: 8, width: 7, x: 8, y: 0 },
+      ],
+      pages: [createTextureAtlas(), createTextureAtlas()],
+    });
+
+    expect(getBitmapFontGlyph(font, 65)!.page).toBe(1);
+    expect(getBitmapFontGlyph(font, 66)!.page).toBe(0);
+  });
+
+  it('clamps an out-of-range glyph page to 0 rather than dropping the glyph', () => {
+    const font = createBitmapFont({
+      ...sampleFontData(),
+      glyphs: [{ advance: 9, bearingX: 1, bearingY: 8, codepoint: 65, height: 8, page: 5, width: 7, x: 0, y: 0 }],
+    });
+
+    expect(getBitmapFontGlyph(font, 65)!.page).toBe(0);
+  });
+});
+
+describe('getBitmapFontGlyph', () => {
+  it('returns the entry for a present codepoint and null for an absent one', () => {
+    const font = createBitmapFont(sampleFontData());
+
+    expect(getBitmapFontGlyph(font, 66)?.advance).toBe(10);
+    expect(getBitmapFontGlyph(font, 0x1f600)).toBeNull();
+  });
+
+  it('returns a stable entry across repeated lookups (immutable)', () => {
+    const font = createBitmapFont(sampleFontData());
+
+    expect(getBitmapFontGlyph(font, 65)).toBe(getBitmapFontGlyph(font, 65));
+  });
+});
+
+describe('getBitmapFontKerning', () => {
+  it('returns the pair amount and 0 for an absent pair', () => {
+    const font = createBitmapFont(sampleFontData());
+
+    expect(getBitmapFontKerning(font, 65, 86)).toBe(-2);
+    expect(getBitmapFontKerning(font, 86, 65)).toBe(0);
+  });
+});
+
+describe('getBitmapFontMetrics', () => {
+  it('returns the font line metrics', () => {
+    const font = createBitmapFont(sampleFontData());
+
+    expect(getBitmapFontMetrics(font)).toEqual({ ascent: 8, descent: 2, lineGap: 1 });
+  });
+});
+
+describe('getBitmapFontPage', () => {
+  it('returns the page atlas by index and null when out of range', () => {
+    const page0 = createTextureAtlas();
+    const page1 = createTextureAtlas();
+    const font = createBitmapFont({ ...sampleFontData(), pages: [page0, page1] });
+
+    expect(getBitmapFontPage(font)).toBe(page0);
+    expect(getBitmapFontPage(font, 0)).toBe(page0);
+    expect(getBitmapFontPage(font, 1)).toBe(page1);
+    expect(getBitmapFontPage(font, 2)).toBeNull();
+  });
+});
+
+describe('getBitmapFontPages', () => {
+  it('returns the page-indexed atlas list', () => {
+    const page0 = createTextureAtlas();
+    const page1 = createTextureAtlas();
+    const font = createBitmapFont({ ...sampleFontData(), pages: [page0, page1] });
+
+    expect(getBitmapFontPages(font)).toEqual([page0, page1]);
+  });
+});
+
+function sampleFontData(): BitmapFontData {
+  return {
+    glyphs: [
+      { advance: 9, bearingX: 1, bearingY: 8, codepoint: 65, height: 8, width: 7, x: 0, y: 0 },
+      { advance: 10, bearingX: 1, bearingY: 8, codepoint: 66, height: 8, width: 7, x: 8, y: 0 },
+      { advance: 8, bearingX: 1, bearingY: 8, codepoint: 86, height: 8, width: 6, x: 16, y: 0 },
+    ],
+    kerning: [{ amount: -2, left: 65, right: 86 }],
+    metrics: { ascent: 8, descent: 2, lineGap: 1 },
+    pages: [createTextureAtlas()],
+  };
+}

package/src/glyphSource.test.ts

@@ -0,0 +1,56 @@
+import { createTextureAtlas } from '@flighthq/textureatlas';
+import type { BitmapFontData, ImageResource } from '@flighthq/types';
+import { describe, expect, it } from 'vitest';
+
+import { createBitmapFont, getBitmapFontGlyph } from './bitmapFont';
+import { createGlyphSourceFromBitmapFont } from './glyphSource';
+
+describe('createGlyphSourceFromBitmapFont', () => {
+  it('exposes the font as a GlyphSource whose lookups match the font', () => {
+    const font = createBitmapFont(sampleFontData());
+    const source = createGlyphSourceFromBitmapFont(font);
+
+    expect(source.getGlyphEntry(65)).toBe(getBitmapFontGlyph(font, 65));
+    expect(source.getGlyphEntry(65)!.page).toBe(0);
+    expect(source.getGlyphEntry(0x1f600)).toBeNull();
+    expect(source.getGlyphKerning(65, 86)).toBe(-2);
+    expect(source.getGlyphKerning(86, 65)).toBe(0);
+    expect(source.getGlyphMetrics()).toEqual({ ascent: 8, descent: 2, lineGap: 1 });
+  });
+
+  it('pairs page 0 with the font atlas image and has no other page', () => {
+    const image = {} as ImageResource;
+    const font = createBitmapFont({ ...sampleFontData(), pages: [createTextureAtlas({ image })] });
+    const source = createGlyphSourceFromBitmapFont(font);
+
+    expect(source.getGlyphAtlasImage(0)).toBe(image);
+    expect(source.getGlyphAtlasImage()).toBe(image);
+    expect(source.getGlyphAtlasImage(1)).toBeNull();
+  });
+
+  it('resolves each page image of a multi-page font', () => {
+    const image0 = {} as ImageResource;
+    const image1 = {} as ImageResource;
+    const font = createBitmapFont({
+      ...sampleFontData(),
+      pages: [createTextureAtlas({ image: image0 }), createTextureAtlas({ image: image1 })],
+    });
+    const source = createGlyphSourceFromBitmapFont(font);
+
+    expect(source.getGlyphAtlasImage(0)).toBe(image0);
+    expect(source.getGlyphAtlasImage(1)).toBe(image1);
+    expect(source.getGlyphAtlasImage(2)).toBeNull();
+  });
+});
+
+function sampleFontData(): BitmapFontData {
+  return {
+    glyphs: [
+      { advance: 9, bearingX: 1, bearingY: 8, codepoint: 65, height: 8, width: 7, x: 0, y: 0 },
+      { advance: 8, bearingX: 1, bearingY: 8, codepoint: 86, height: 8, width: 6, x: 16, y: 0 },
+    ],
+    kerning: [{ amount: -2, left: 65, right: 86 }],
+    metrics: { ascent: 8, descent: 2, lineGap: 1 },
+    pages: [createTextureAtlas()],
+  };
+}