@city41/gba-convertpng 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matt Greer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# GBA Convert png
+
+This is a nodejs based tool for converting png images to the tile data format used in GBA games.
+
+HEADS UP: I make games for the e-Reader, and so far have not done mainstream GBA development. So possibly this tool is missing things for GBA dev. If so, please let me know.

package/dist/asm.d.ts

@@ -0,0 +1,2 @@
+declare function toAsm(data: number[], width: "b" | "w", numbersPerRow: number): string;
+export { toAsm };

package/dist/asm.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAsm = toAsm;
+const toHex_1 = require("./toHex");
+function toAsm(data, width, numbersPerRow) {
+    const hexFn = width === "b" ? toHex_1.toHexByte : toHex_1.toHexWord;
+    const rows = [];
+    let row = [];
+    for (let i = 0; i < data.length; ++i) {
+        if (row.length === numbersPerRow) {
+            rows.push(` .d${width} ${row.join(",")}`);
+            row = [];
+        }
+        row.push(hexFn(data[i]));
+    }
+    rows.push(` .d${width} ${row.join(",")}`);
+    return rows.join("\r\n") + "\r\n";
+}
+//# sourceMappingURL=asm.js.map

package/dist/background.d.ts

@@ -0,0 +1,8 @@
+import { BackgroundSpec } from "./types";
+type ProcessBackgroundResult = {
+    tilesAsmSrc: string;
+    paletteAsmSrc: string;
+    mapAsmSrc: string;
+};
+declare function processBackground(bg: BackgroundSpec): Promise<ProcessBackgroundResult>;
+export { processBackground };

package/dist/background.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processBackground = processBackground;
+const asm_1 = require("./asm");
+const canvas_1 = require("./canvas");
+const palette_1 = require("./palette");
+const tile_1 = require("./tile");
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+function extractMap(allTilesThatFormImage, dedupedTiles) {
+    const map = [];
+    allTilesThatFormImage.forEach((tile, i) => {
+        const index = dedupedTiles.findIndex((dt) => {
+            return (0, isEqual_1.default)(dt, tile);
+        });
+        if (index < 0) {
+            throw new Error("extractMap: failed to find a matching tile in the deduped tile set");
+        }
+        map.push(index);
+    });
+    return map;
+}
+async function processBackground(bg) {
+    const canvas = await (0, canvas_1.reduceColors)(await (0, canvas_1.createCanvasFromPath)(bg.file), 16);
+    const palette = (0, palette_1.extractPalette)(canvas, !bg.trimPalette);
+    const allTilesThatFormImage = (0, tile_1.extractTiles)(canvas, palette, 1);
+    const dedupedTiles = (0, tile_1.dedupeTiles)(allTilesThatFormImage);
+    const map = extractMap(allTilesThatFormImage, dedupedTiles);
+    return {
+        tilesAsmSrc: (0, asm_1.toAsm)(dedupedTiles.flat(1), "b", 4),
+        paletteAsmSrc: (0, asm_1.toAsm)(palette, "w", 4),
+        mapAsmSrc: (0, asm_1.toAsm)(map, "w", 8),
+    };
+}
+//# sourceMappingURL=background.js.map

package/dist/c.d.ts

@@ -0,0 +1,2 @@
+declare function toC(data: number[], width: "b" | "w", numbersPerRow: number): string;
+export { toC };

package/dist/c.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toC = toC;
+const toHex_1 = require("./toHex");
+function toC(data, width, numbersPerRow) {
+    const hexFn = width === "b" ? toHex_1.toHexByte : toHex_1.toHexWord;
+    const rows = [];
+    let row = [];
+    for (let i = 0; i < data.length; ++i) {
+        if (row.length === numbersPerRow) {
+            rows.push(row.join(",") + ",");
+            row = [];
+        }
+        row.push(hexFn(data[i]));
+    }
+    rows.push(row.join(","));
+    return `{ ${rows.join("\r\n")} }`;
+}
+//# sourceMappingURL=c.js.map

package/dist/canvas.d.ts

@@ -0,0 +1,5 @@
+import { Canvas } from "canvas";
+declare function reduceColors(c: Canvas, maxColors: number): Promise<Canvas>;
+declare function createCanvasFromPath(pngPath: string): Promise<Canvas>;
+declare function forceCanvasToPalette(canvas: Canvas, palette: Canvas): Promise<Canvas>;
+export { createCanvasFromPath, reduceColors, forceCanvasToPalette };

package/dist/canvas.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCanvasFromPath = createCanvasFromPath;
+exports.reduceColors = reduceColors;
+exports.forceCanvasToPalette = forceCanvasToPalette;
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const fsp = __importStar(require("node:fs/promises"));
+const canvas_1 = require("canvas");
+const imagemagick_1 = __importDefault(require("imagemagick"));
+const mkdirp_1 = require("mkdirp");
+const nearest_color_1 = __importDefault(require("nearest-color"));
+async function _reduceColorsWithMagick(renderedFilePath, maxColors) {
+    const outputPath = `${renderedFilePath}.reduced.png`;
+    return new Promise((resolve, reject) => {
+        imagemagick_1.default.convert([
+            renderedFilePath,
+            "-dither",
+            "none",
+            "-colors",
+            maxColors.toString(),
+            `png8:${outputPath}`,
+        ], (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(outputPath);
+            }
+        });
+    });
+}
+async function reduceColors(c, maxColors) {
+    const tmpDir = path.resolve(os.tmpdir(), `reduceColors_${Date.now()}`);
+    await (0, mkdirp_1.mkdirp)(tmpDir);
+    const tmpPath = path.resolve(tmpDir, `_reduceColors_${maxColors}_${Date.now()}.png`);
+    const b = c.toBuffer();
+    await fsp.writeFile(tmpPath, b);
+    const reducedPath = await _reduceColorsWithMagick(tmpPath, maxColors);
+    return createCanvasFromPath(reducedPath);
+}
+async function createCanvasFromPath(pngPath) {
+    return new Promise((resolve, reject) => {
+        const img = new canvas_1.Image();
+        img.onload = () => {
+            const canvas = (0, canvas_1.createCanvas)(img.width, img.height);
+            const context = canvas.getContext("2d");
+            context.drawImage(img, 0, 0);
+            resolve(canvas);
+        };
+        img.onerror = reject;
+        img.src = pngPath;
+    });
+}
+function findNearestColor(pixel, palette) {
+    const colorsInput = [];
+    for (let p = 0; p < palette.length; p += 4) {
+        colorsInput.push({
+            name: `color${p / 4}`,
+            source: "",
+            rgb: {
+                r: palette[p],
+                g: palette[p + 1],
+                b: palette[p + 2],
+            },
+        });
+    }
+    const pixelInput = {
+        r: pixel[0],
+        g: pixel[1],
+        b: pixel[2],
+    };
+    const nearestResult = (0, nearest_color_1.default)(pixelInput, colorsInput);
+    pixel[0] = nearestResult.rgb.r;
+    pixel[1] = nearestResult.rgb.g;
+    pixel[2] = nearestResult.rgb.b;
+    return pixel;
+}
+function isMagenta(pixel) {
+    return pixel[0] === 255 && pixel[1] === 0 && pixel[2] === 255;
+}
+async function forceCanvasToPalette(canvas, palette) {
+    if (palette.width !== 15) {
+        throw new Error("forceCanvasToPalette: palette needs to be 15px wide (it should not have zero/magenta in it)");
+    }
+    if (palette.height !== 1) {
+        throw new Error("forceCanvasToPalette: palette needs to be 1px tall");
+    }
+    const canvasImageData = canvas
+        .getContext("2d")
+        .getImageData(0, 0, canvas.width, canvas.height);
+    const paletteImageData = palette
+        .getContext("2d")
+        .getImageData(0, 0, palette.width, palette.height);
+    for (let p = 0; p < canvasImageData.data.length; p += 4) {
+        const pixel = canvasImageData.data.slice(p, p + 4);
+        if (isMagenta(pixel)) {
+            continue;
+        }
+        const nearestPixel = findNearestColor(pixel, paletteImageData.data);
+        canvasImageData.data.set(nearestPixel, p);
+    }
+    canvas.getContext("2d").putImageData(canvasImageData, 0, 0);
+    return canvas;
+}
+//# sourceMappingURL=canvas.js.map

package/dist/colors.d.ts

@@ -0,0 +1,2 @@
+declare function rgbToGBA16(r: number, g: number, b: number): number;
+export { rgbToGBA16 };

package/dist/colors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rgbToGBA16 = rgbToGBA16;
+function rgbToGBA16(r, g, b) {
+    const gbaR = Math.floor((31 * r) / 255);
+    const gbaG = Math.floor((31 * g) / 255);
+    const gbaB = Math.floor((31 * b) / 255);
+    return (gbaB << 10) | (gbaG << 5) | gbaR;
+}
+//# sourceMappingURL=colors.js.map

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("node:path"));
+const fsp = __importStar(require("fs/promises"));
+const sprite_1 = require("./sprite");
+const background_1 = require("./background");
+/**
+ * Loads the json spec from the file path and converts all file paths
+ * inside to absolute paths so the rest of the tool doesn't have to think about it
+ */
+function hydrateJsonSpec(jsonSpecPath) {
+    const rootDir = path.dirname(jsonSpecPath);
+    const initialSpec = require(jsonSpecPath);
+    return {
+        ...initialSpec,
+        outputDir: path.resolve(rootDir, initialSpec.outputDir),
+        format: initialSpec.format ?? "z80",
+        sprites: (initialSpec.sprites ?? []).map((s) => {
+            if ((0, sprite_1.isBasicSpriteSpec)(s)) {
+                return {
+                    ...s,
+                    file: path.resolve(rootDir, s.file),
+                    forcePalette: s.forcePalette
+                        ? path.resolve(rootDir, s.forcePalette)
+                        : undefined,
+                };
+            }
+            else {
+                return {
+                    ...s,
+                    forcePalette: s.forcePalette
+                        ? path.resolve(rootDir, s.forcePalette)
+                        : undefined,
+                    sharedPalette: s.sharedPalette.map((ss) => {
+                        return {
+                            ...ss,
+                            file: path.resolve(rootDir, ss.file),
+                        };
+                    }),
+                };
+            }
+        }),
+        backgrounds: (initialSpec.backgrounds ?? []).map((bg) => {
+            return {
+                ...bg,
+                file: path.resolve(rootDir, bg.file),
+            };
+        }),
+    };
+}
+async function main(jsonSpec) {
+    if (jsonSpec.format === "bin") {
+        throw new Error("convertpng does not support bin format");
+    }
+    const ext = jsonSpec.format === "z80" ? "asm" : "c.inc";
+    for (const sprite of jsonSpec.sprites) {
+        const processResult = await (0, sprite_1.processSprite)(sprite, jsonSpec.format, sprite.forcePalette);
+        if ((0, sprite_1.isBasicSpriteSpec)(sprite)) {
+            const fileRoot = path.basename(sprite.file, path.extname(sprite.file));
+            const tilesOutputPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.tiles.${ext}`);
+            const paletteOutputPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.palette.${ext}`);
+            await fsp.writeFile(tilesOutputPath, processResult.tilesSrc[0]);
+            console.log("wrote", tilesOutputPath);
+            await fsp.writeFile(paletteOutputPath, processResult.paletteSrc);
+            console.log("wrote", paletteOutputPath);
+        }
+        else {
+            for (let i = 0; i < sprite.sharedPalette.length; ++i) {
+                const subsprite = sprite.sharedPalette[i];
+                const fileRoot = path.basename(subsprite.file, path.extname(subsprite.file));
+                const tilesOutputPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.tiles.${ext}`);
+                await fsp.writeFile(tilesOutputPath, processResult.tilesSrc[i]);
+                console.log("wrote", tilesOutputPath);
+            }
+            const paletteOutputPath = path.resolve(jsonSpec.outputDir, `${sprite.name}.shared.palette.${ext}`);
+            await fsp.writeFile(paletteOutputPath, processResult.paletteSrc);
+            console.log("wrote", paletteOutputPath);
+        }
+    }
+    for (const bg of jsonSpec.backgrounds) {
+        const processResult = await (0, background_1.processBackground)(bg);
+        const fileRoot = path.basename(bg.file, path.extname(bg.file));
+        const tilesAsmPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.tiles.asm`);
+        const paletteAsmPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.palette.asm`);
+        const mapAsmPath = path.resolve(jsonSpec.outputDir, `${fileRoot}.map.asm`);
+        await fsp.writeFile(tilesAsmPath, processResult.tilesAsmSrc);
+        console.log("wrote", tilesAsmPath);
+        await fsp.writeFile(paletteAsmPath, processResult.paletteAsmSrc);
+        console.log("wrote", paletteAsmPath);
+        await fsp.writeFile(mapAsmPath, processResult.mapAsmSrc);
+        console.log("wrote", mapAsmPath);
+    }
+}
+if (require.main === module) {
+    const [_tsNode, _convertpng, jsonSpecPath] = process.argv;
+    if (!jsonSpecPath) {
+        console.error("usage: gba-convertpng <json-spec-path>");
+        process.exit(1);
+    }
+    const jsonSpec = hydrateJsonSpec(path.resolve(jsonSpecPath));
+    main(jsonSpec)
+        .then(() => console.log("done"))
+        .catch((e) => console.error(e));
+}
+//# sourceMappingURL=main.js.map

package/dist/palette.d.ts

@@ -0,0 +1,4 @@
+import { Canvas } from "canvas";
+declare function extractPalette(c: Canvas, pad?: boolean): number[];
+declare function reducePalettes(palettes: number[][]): number[];
+export { extractPalette, reducePalettes };

package/dist/palette.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPalette = extractPalette;
+exports.reducePalettes = reducePalettes;
+const colors_1 = require("./colors");
+const MAGENTA = (0, colors_1.rgbToGBA16)(255, 0, 255);
+function extractPalette(c, pad = true) {
+    const gbaColors = new Set();
+    const imageData = c.getContext("2d").getImageData(0, 0, c.width, c.height);
+    for (let p = 0; p < imageData.data.length; p += 4) {
+        // skip anything not fully opaque
+        if (imageData.data[p + 3] !== 255) {
+            continue;
+        }
+        const r = imageData.data[p];
+        const g = imageData.data[p + 1];
+        const b = imageData.data[p + 2];
+        const gbaColor = (0, colors_1.rgbToGBA16)(r, g, b);
+        gbaColors.add(gbaColor);
+    }
+    const rawPalette = Array.from(gbaColors);
+    // make sure there is no magenta in the palette
+    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA);
+    // then append magenta as the first color, to become transparent
+    const palette = [MAGENTA].concat(paletteWithoutMangenta);
+    while (pad && palette.length < 16) {
+        palette.push(0);
+    }
+    return palette;
+}
+function reducePalettes(palettes) {
+    const colorMap = {};
+    const mergedPalette = [];
+    for (const palette of palettes) {
+        for (const color of palette) {
+            if (!colorMap[color]) {
+                colorMap[color] = true;
+                mergedPalette.push(color);
+            }
+        }
+    }
+    if (mergedPalette.length > 16) {
+        throw new Error(`reducePalette: final palette is too large: ${mergedPalette.length}`);
+    }
+    return mergedPalette;
+}
+//# sourceMappingURL=palette.js.map

package/dist/sprite.d.ts

@@ -0,0 +1,11 @@
+import { BasicSpriteSpec, Format, SpriteSpec } from "./types";
+import { Canvas } from "canvas";
+type ProcessSpriteResult = {
+    canvas: Canvas;
+    tilesSrc: string[] | number[];
+    paletteSrc: string | number[];
+};
+declare function isBasicSpriteSpec(sprite: SpriteSpec): sprite is BasicSpriteSpec;
+declare function processSprite(sprite: SpriteSpec, format: Format, forcedPalettePath?: string): Promise<ProcessSpriteResult>;
+export { isBasicSpriteSpec, processSprite };
+export type { ProcessSpriteResult };

package/dist/sprite.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBasicSpriteSpec = isBasicSpriteSpec;
+exports.processSprite = processSprite;
+const asm_1 = require("./asm");
+const c_1 = require("./c");
+const canvas_1 = require("./canvas");
+const palette_1 = require("./palette");
+const tile_1 = require("./tile");
+function isBasicSpriteSpec(sprite) {
+    return "file" in sprite;
+}
+async function processBasicSprite(sprite, format, forcedPalette) {
+    let canvas = await (0, canvas_1.reduceColors)(await (0, canvas_1.createCanvasFromPath)(sprite.file), 16);
+    let palette;
+    if (forcedPalette) {
+        canvas = await (0, canvas_1.forceCanvasToPalette)(canvas, forcedPalette);
+        palette = (0, palette_1.extractPalette)(forcedPalette, false);
+    }
+    else {
+        palette = (0, palette_1.extractPalette)(canvas, !sprite.trimPalette);
+    }
+    const tiles = (0, tile_1.extractTiles)(canvas, palette, sprite.frames).flat(1);
+    if (format === "bin") {
+        return {
+            canvas,
+            tilesSrc: tiles,
+            paletteSrc: palette,
+        };
+    }
+    const tileSrcFun = format === "z80" ? asm_1.toAsm : c_1.toC;
+    const paletteSrcFun = format === "z80" ? asm_1.toAsm : c_1.toC;
+    return {
+        canvas,
+        tilesSrc: [tileSrcFun(tiles, "b", 4)],
+        paletteSrc: paletteSrcFun(palette, "w", 4),
+    };
+}
+async function processSharedPaletteSprites(sharedPaletteSprite, format, forcedPalette) {
+    const canvases = [];
+    const palettes = [];
+    for (let i = 0; i < sharedPaletteSprite.sharedPalette.length; ++i) {
+        let c = await (0, canvas_1.reduceColors)(await (0, canvas_1.createCanvasFromPath)(sharedPaletteSprite.sharedPalette[i].file), 16);
+        if (forcedPalette) {
+            c = await (0, canvas_1.forceCanvasToPalette)(c, forcedPalette);
+        }
+        canvases.push(c);
+        palettes.push((0, palette_1.extractPalette)(c, !sharedPaletteSprite.trimPalette));
+    }
+    const commonPalette = forcedPalette
+        ? (0, palette_1.extractPalette)(forcedPalette, false)
+        : (0, palette_1.reducePalettes)(palettes);
+    const tiles = [];
+    for (let i = 0; i < sharedPaletteSprite.sharedPalette.length; ++i) {
+        const t = (0, tile_1.extractTiles)(canvases[i], commonPalette, sharedPaletteSprite.sharedPalette[i].frames).flat(1);
+        tiles.push(t);
+    }
+    const tileSrcFun = format === "z80" ? asm_1.toAsm : c_1.toC;
+    const paletteSrcFun = format === "z80" ? asm_1.toAsm : c_1.toC;
+    return {
+        // this is useless in this scenario, but canvas
+        // really only exists for the puzzle generator
+        canvas: canvases[0],
+        tilesSrc: tiles.map((t) => tileSrcFun(t, "b", 4)),
+        paletteSrc: paletteSrcFun(commonPalette, "w", 4),
+    };
+}
+async function processSprite(sprite, format, forcedPalettePath) {
+    const forcedPalette = forcedPalettePath
+        ? await (0, canvas_1.createCanvasFromPath)(forcedPalettePath)
+        : undefined;
+    if (isBasicSpriteSpec(sprite)) {
+        return processBasicSprite(sprite, format, forcedPalette);
+    }
+    else {
+        return processSharedPaletteSprites(sprite, format, forcedPalette);
+    }
+}
+//# sourceMappingURL=sprite.js.map

package/dist/tile.d.ts

@@ -0,0 +1,4 @@
+import { Canvas } from "canvas";
+declare function extractTiles(c: Canvas, palette: number[], frameCount: number): number[][];
+declare function dedupeTiles(tiles: number[][]): number[][];
+export { extractTiles, dedupeTiles };

package/dist/tile.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTiles = extractTiles;
+exports.dedupeTiles = dedupeTiles;
+const colors_1 = require("./colors");
+function extractTile(imageData, palette) {
+    const tileData = [];
+    for (let p = 0; p < imageData.data.length; p += 8) {
+        // first pixel in tile, high nibble
+        // if this pixel has any transparency, then use palette index 0
+        // which will make it fully transparent on the gba
+        let hindex = 0;
+        if (imageData.data[p + 7] === 255) {
+            // this is a fully opaque pixel, so use it
+            const hr = imageData.data[p + 4];
+            const hg = imageData.data[p + 5];
+            const hb = imageData.data[p + 6];
+            const hgbaColor = (0, colors_1.rgbToGBA16)(hr, hg, hb);
+            hindex = palette.indexOf(hgbaColor);
+        }
+        // second pixel in tile, low nibble
+        // if this pixel has any transparency, then use palette index 0
+        // which will make it fully transparent on the gba
+        let lindex = 0;
+        if (imageData.data[p + 3] === 255) {
+            // this is a fully opaque pixel, so use it
+            const lr = imageData.data[p + 0];
+            const lg = imageData.data[p + 1];
+            const lb = imageData.data[p + 2];
+            const lgbaColor = (0, colors_1.rgbToGBA16)(lr, lg, lb);
+            lindex = palette.indexOf(lgbaColor);
+        }
+        const tileByte = ((hindex & 0xf) << 4) | (lindex & 0xf);
+        tileData.push(tileByte);
+    }
+    return tileData;
+}
+// a GBA tile using a 16 color palette has two indexes per byte
+// so one 8x8 tile is 4x8 bytes
+//
+// [ p1|p2,   p3|p4,   p5|p6,   p7|p8]
+// [p9|p10, p11|p12, p13|p14, p15|p16]
+// ...
+//
+// it is stored row oriented
+// for an image that has multiple tiles, it is stored in a flat 1d array
+//
+// [a|b]
+// [c|d]
+//
+// becomes [a][b][c][d]
+//
+// sprites with more than one frame look like this in the png
+//
+// [a1|b1][a2|b2]
+// [c1|d1][c2|d2]
+//
+// and become this in the data
+// [a1][b1][c1][d1][a2][b2][c2][d2]
+function extractTiles(c, palette, frameCount) {
+    const context = c.getContext("2d");
+    const tilesData = [];
+    const frameWidthT = c.width / 8 / frameCount;
+    const frameHeightT = c.height / 8;
+    for (let f = 0; f < frameCount; ++f) {
+        for (let y = 0; y < frameHeightT; ++y) {
+            for (let x = f * frameWidthT; x < (f + 1) * frameWidthT; ++x) {
+                const imageData = context.getImageData(x * 8, y * 8, 8, 8);
+                const curTileData = extractTile(imageData, palette);
+                tilesData.push(curTileData);
+            }
+        }
+    }
+    return tilesData;
+}
+function dedupeTiles(tiles) {
+    const dedupedMap = tiles.reduce((accum, tile) => {
+        const key = tile.join(",");
+        accum[key] = tile;
+        return accum;
+    }, {});
+    return Object.values(dedupedMap);
+}
+//# sourceMappingURL=tile.js.map

package/dist/toHex.d.ts

@@ -0,0 +1,2 @@
+export declare function toHexByte(num: number): string;
+export declare function toHexWord(num: number): string;

package/dist/toHex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHexByte = toHexByte;
+exports.toHexWord = toHexWord;
+function toHexByte(num) {
+    const rawHex = num.toString(16);
+    const neededFiller = Math.max(2 - rawHex.length, 0);
+    const filler = new Array(neededFiller).fill("0").join("");
+    return `0x${filler}${rawHex}`;
+}
+function toHexWord(num) {
+    const rawHex = num.toString(16);
+    const neededFiller = Math.max(4 - rawHex.length, 0);
+    const filler = new Array(neededFiller).fill("0").join("");
+    return `0x${filler}${rawHex}`;
+}
+//# sourceMappingURL=toHex.js.map

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export type Format = "C" | "z80" | "bin";
+export type BasicSpriteSpec = {
+    file: string;
+    frames: number;
+    trimPalette?: boolean;
+    forcePalette?: string;
+};
+export type SharedPaletteSpriteSpec = {
+    name: string;
+    trimPalette?: boolean;
+    sharedPalette: BasicSpriteSpec[];
+    forcePalette?: string;
+};
+export type SpriteSpec = BasicSpriteSpec | SharedPaletteSpriteSpec;
+export type BackgroundSpec = {
+    file: string;
+    trimPalette?: boolean;
+};
+export type ImportedJsonSpec = {
+    outputDir: string;
+    format?: Format;
+    sprites?: SpriteSpec[];
+    backgrounds?: BackgroundSpec[];
+};
+export type JsonSpec = Required<ImportedJsonSpec>;

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@city41/gba-convertpng",
+  "version": "0.0.2",
+  "description": "Converts png images to GBA tile format",
+  "main": "index.js",
+  "repository": "github.com/city41/gba-convertpng",
+  "author": "Matt Greer <matt.e.greer@gmail.com>",
+  "license": "MIT",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "bin": {
+    "gba-convertpng": "./dist/main.js"
+  },
+  "scripts": {
+    "type-check": "yarn tsc --noEmit",
+    "prebuild": "yarn type-check",
+    "build": "tsc",
+    "prepublish": "yarn build"
+  },
+  "dependencies": {
+    "@types/imagemagick": "^0.0.35",
+    "@types/lodash": "^4.17.20",
+    "@types/nearest-color": "^0.4.1",
+    "canvas": "^3.2.0",
+    "imagemagick": "^0.1.3",
+    "lodash": "^4.17.21",
+    "mkdirp": "^3.0.1",
+    "nearest-color": "^0.4.4"
+  },
+  "devDependencies": {
+    "@types/node": "^24.9.1",
+    "typescript": "^5.9.3"
+  }
+}