@jjlmoya/utils-games-development 1.56.0 → 1.57.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-games-development",
-    "version": "1.56.0",
+    "version": "1.57.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/entries.ts

@@ -23,7 +23,8 @@ import { spriteSheetPacker } from './tool/spriteSheetPacker/entry';
 import { audioLoopPointFinder } from './tool/audioLoopPointFinder/entry';
 import { saveFileEditor } from './tool/saveFileEditor/entry';
 import { localizationSanitizer } from './tool/localizationSanitizer/entry';
+import { steamBbcodeTranslator } from './tool/steamBbcodeTranslator/entry';
 import { retroSfxGenerator } from './tool/retroSfxGenerator/entry';
 import { pixelArtPaletteSwapper } from './tool/pixelArtPaletteSwapper/entry';
 
-export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, retroSfxGenerator, pixelArtPaletteSwapper];
+export const ALL_ENTRIES = [steamCapsuleGenerator, itchioGameTester, spriteSheetPacker, audioLoopPointFinder, saveFileEditor, localizationSanitizer, steamBbcodeTranslator, retroSfxGenerator, pixelArtPaletteSwapper];

package/src/tests/runtime_registry.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ALL_ENTRIES } from '../entries';
+import { ALL_TOOLS } from '../tools';
+
+describe('runtime registry', () => {
+  it('keeps every runtime tool represented in the data registry', () => {
+    const toolIds = ALL_TOOLS.map(({ entry }) => entry.id).sort();
+    const entryIds = ALL_ENTRIES.map(({ id }) => id).sort();
+
+    expect(entryIds).toEqual(toolIds);
+  });
+
+  it('keeps every runtime directory represented in the data registry', () => {
+    const runtimeIds = readdirSync(join(process.cwd(), 'src', 'tool'), { withFileTypes: true })
+      .filter((directory) => directory.isDirectory())
+      .map((directory) => join(process.cwd(), 'src', 'tool', directory.name))
+      .filter((directory) => existsSync(join(directory, 'index.ts')) && existsSync(join(directory, 'entry.ts')))
+      .map((directory) => readFileSync(join(directory, 'entry.ts'), 'utf8').match(/\bid\s*:\s*['"]([^'"]+)['"]/)?.[1])
+      .filter((id): id is string => Boolean(id))
+      .sort();
+
+    const entryIds = ALL_ENTRIES.map(({ id }) => id).sort();
+    expect(entryIds).toEqual(runtimeIds);
+  });
+});

package/src/tool/pixelArtPaletteSwapper/app-client.ts

@@ -61,7 +61,10 @@ function queryAppElements(root: HTMLElement): AppEls | null {
 
 function renderSwatches(root: HTMLElement): void {
   root.querySelectorAll<HTMLElement>('[data-swatch-palette]').forEach((strip) => {
-    const palette = PRESET_PALETTES[strip.dataset.swatchPalette ?? ''] ?? [];
+    const id = strip.dataset.swatchPalette;
+    const palette = id && id in PRESET_PALETTES
+      ? PRESET_PALETTES[id as keyof typeof PRESET_PALETTES]
+      : [];
     strip.replaceChildren(...palette.map((c) => {
       const s = document.createElement('span');
       s.style.backgroundColor = c.hex;
@@ -151,8 +154,10 @@ function setupFileHandler(els: AppEls, onLoaded: (src: SourceImageState) => void
 function setupPresetButtons(els: AppEls, onApply: (p: PaletteColor[], id: string) => void): void {
   els.root.querySelectorAll<HTMLButtonElement>('[data-palette-id]').forEach((b) => b.addEventListener('click', () => {
     const id = b.dataset.paletteId ?? 'gameBoy';
-    els.customPaletteInput.value = PRESET_PALETTES[id].map((c) => c.hex).join(', ');
-    onApply(PRESET_PALETTES[id], id);
+    const palette = PRESET_PALETTES[id as keyof typeof PRESET_PALETTES];
+    if (!palette) return;
+    els.customPaletteInput.value = palette.map((c) => c.hex).join(', ');
+    onApply(palette, id);
   }));
 }
 

package/src/tool/pixelArtPaletteSwapper/logic.ts

@@ -8,13 +8,21 @@ export interface PaletteColor extends RGBColor {
   hex: string;
 }
 
+interface PresetPalettes {
+  gameBoy: PaletteColor[];
+  nes: PaletteColor[];
+  pico8: PaletteColor[];
+  commodore64: PaletteColor[];
+  dawnBringer16: PaletteColor[];
+}
+
 export interface QuantizationResult {
   data: Uint8ClampedArray;
   sourceColors: number;
   mappedColors: number;
 }
 
-export const PRESET_PALETTES: Record<string, PaletteColor[]> = {
+export const PRESET_PALETTES: PresetPalettes = {
   gameBoy: ['#0f380f', '#306230', '#8bac0f', '#9bbc0f'].map(createPresetPaletteColor),
   nes: [
     '#000000', '#fcfcfc', '#f8f8f8', '#b8b8b8', '#7c7c7c', '#a80000', '#e45c10', '#f8b800',
@@ -94,11 +102,17 @@ export function findNearestColor(source: RGBColor, palette: PaletteColor[]): Pal
     return null;
   }
 
-  let nearest = palette[0];
+  const nearestColor = palette[0];
+  if (!nearestColor) {
+    return null;
+  }
+
+  let nearest = nearestColor;
   let distance = colorDistanceSquared(source, nearest);
 
   for (let index = 1; index < palette.length; index += 1) {
     const candidate = palette[index];
+    if (!candidate) continue;
     const candidateDistance = colorDistanceSquared(source, candidate);
     if (candidateDistance < distance) {
       nearest = candidate;
@@ -125,16 +139,32 @@ interface QuantizePixelContext {
   mappedColors: Set<string>;
 }
 
+interface PixelData {
+  alpha: number;
+  color: RGBColor;
+}
+
+function readPixel(data: Uint8ClampedArray, index: number): PixelData | null {
+  const alpha = data[index + 3];
+  const red = data[index];
+  const green = data[index + 1];
+  const blue = data[index + 2];
+  if (alpha === undefined) return null;
+  if (red === undefined) return null;
+  if (green === undefined) return null;
+  if (blue === undefined) return null;
+  return { alpha, color: { r: red, g: green, b: blue } };
+}
+
 function processPixel(ctx: QuantizePixelContext): void {
   const { data, index, palette, preserveTransparency, sourceColors, mappedColors } = ctx;
-  const alpha = data[index + 3];
-  if (alpha === 0 && preserveTransparency) return;
+  const pixel = readPixel(data, index);
+  if (!pixel || (pixel.alpha === 0 && preserveTransparency)) return;
 
-  const sourceColor = { r: data[index], g: data[index + 1], b: data[index + 2] };
-  const mapped = findNearestColor(sourceColor, palette);
+  const mapped = findNearestColor(pixel.color, palette);
   if (!mapped) return;
 
-  sourceColors.add(rgbToHex(sourceColor));
+  sourceColors.add(rgbToHex(pixel.color));
   mappedColors.add(mapped.hex);
   data[index] = mapped.r;
   data[index + 1] = mapped.g;