@city41/gba-convertpng 0.0.30 → 0.0.32

package/dist/background.d.ts

@@ -1,4 +1,3 @@
 import { BackgroundSpec, ProcessBackgroundResult } from "./types";
-declare function isProcessBackgroundResult(obj: unknown): obj is ProcessBackgroundResult;
 declare function processBackground(bg: BackgroundSpec): Promise<ProcessBackgroundResult>;
-export { processBackground, isProcessBackgroundResult };
+export { processBackground };

package/dist/background.js

@@ -1,19 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBackground = processBackground;
-exports.isProcessBackgroundResult = isProcessBackgroundResult;
 const canvas_1 = require("./canvas");
 const colors_1 = require("./colors");
 const lodash_1 = require("lodash");
 const palette_1 = require("./palette");
-function isProcessBackgroundResult(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        "background" in obj &&
-        typeof obj.background === "object" &&
-        obj.background !== null &&
-        "file" in obj.background);
-}
 function convertTileTo15Bit(rawTile) {
     const data15 = [];
     for (let p = 0; p < rawTile.length; p += 4) {
@@ -152,7 +143,8 @@ async function processBackground(bg) {
         paletteData[0] = bg.transparentColor;
     }
     return {
-        background: bg,
+        type: "Background",
+        spec: bg,
         canvas,
         map,
         palette: paletteData,

package/dist/bitmap.d.ts

@@ -1,4 +1,3 @@
 import { BitmapSpec, ProcessBitmapResult } from "./types";
-declare function isProcessBitmapResult(obj: unknown): obj is ProcessBitmapResult;
 declare function processBitmap(bmp: BitmapSpec): Promise<ProcessBitmapResult>;
-export { processBitmap, isProcessBitmapResult };
+export { processBitmap };

package/dist/bitmap.js

@@ -1,17 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBitmap = processBitmap;
-exports.isProcessBitmapResult = isProcessBitmapResult;
 const canvas_1 = require("./canvas");
 const colors_1 = require("./colors");
-function isProcessBitmapResult(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        "bitmap" in obj &&
-        typeof obj.bitmap === "object" &&
-        obj.bitmap !== null &&
-        "file" in obj.bitmap);
-}
 async function processBitmap(bmp) {
     const canvas = await (0, canvas_1.createCanvasFromPath)(bmp.file);
     const context = canvas.getContext("2d");
@@ -22,7 +13,8 @@ async function processBitmap(bmp) {
         pixels.push(gbaColor);
     }
     return {
-        bitmap: bmp,
+        type: "Bitmap",
+        spec: bmp,
         width: canvas.width,
         height: canvas.height,
         pixels,

package/dist/main.js

@@ -42,6 +42,16 @@ const c_1 = require("./c");
 const asm_1 = require("./asm");
 const bitmap_1 = require("./bitmap");
 const palette_1 = require("./palette");
+function getExportResultsFunction(spec, rootDir) {
+    let exportResults;
+    if (spec.exportResultsPath) {
+        exportResults = require(path.resolve(rootDir, spec.exportResultsPath));
+    }
+    else {
+        exportResults = defaultExportResults;
+    }
+    return exportResults;
+}
 /**
  * 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
@@ -49,8 +59,10 @@ const palette_1 = require("./palette");
 function hydrateJsonSpec(jsonSpecPath) {
     const rootDir = path.dirname(jsonSpecPath);
     const initialSpec = require(jsonSpecPath);
+    const exportResults = getExportResultsFunction(initialSpec, rootDir);
     return {
         ...initialSpec,
+        exportResults,
         outputDir: path.resolve(rootDir, initialSpec.outputDir),
         format: initialSpec.format ?? "z80",
         sprites: (initialSpec.sprites ?? []).map((s) => {
@@ -93,61 +105,53 @@ function hydrateJsonSpec(jsonSpecPath) {
                 file: path.resolve(rootDir, bmp.file),
             };
         }),
-        palettes: (initialSpec.palettes ?? []).map(p => {
+        palettes: (initialSpec.palettes ?? []).map((p) => {
             return {
                 ...p,
-                file: path.resolve(rootDir, p.file)
+                file: path.resolve(rootDir, p.file),
             };
-        })
+        }),
     };
 }
 function getBitmapDefines(result) {
-    const name = path.basename(result.bitmap.file, path.extname(result.bitmap.file));
+    const name = path.basename(result.spec.file, path.extname(result.spec.file));
     return `#define ${name.toUpperCase()}_WIDTH ${result.width}
 #define ${name.toUpperCase()}_HEIGHT ${result.height}`;
 }
 function getPaletteDefines(result, file) {
-    if ((0, sprite_1.isProcessBasicSpriteResult)(result)) {
-        return '';
+    if (result.type === "BasicSprite") {
+        return "";
     }
     const name = path.basename(file, ".png");
     return `#define ${name.toUpperCase()}_NUM_PALETTES ${result.paletteCount}`;
 }
 function getTileDefines(result, file) {
     const name = path.basename(file, ".png");
-    let tileWidth = result.canvas.width / 8;
+    let allFrameTileWidth = result.canvas.width / 8;
     let tileHeight = result.canvas.height / 8;
     let frameCountSrc = "";
     let frameCount = 1;
-    if ((0, sprite_1.isProcessBasicSpriteResult)(result)) {
-        frameCount = result.sprite.frames;
-        frameCountSrc = `\n#define ${name.toUpperCase()}_FRAME_COUNT ${result.sprite.frames}`;
+    if (result.type == "BasicSprite") {
+        frameCount = result.spec.frames;
+        frameCountSrc = `\n#define ${name.toUpperCase()}_FRAME_COUNT ${frameCount}`;
     }
-    return `#define ${name.toUpperCase()}_TILE_WIDTH ${tileWidth / frameCount}
+    let singleFrameTileWidth = allFrameTileWidth / frameCount;
+    if (singleFrameTileWidth != Math.floor(singleFrameTileWidth)) {
+        throw new Error(`getTileDefines, tile width is not an integer, got: ${singleFrameTileWidth}`);
+    }
+    return `#define ${name.toUpperCase()}_TILE_WIDTH ${singleFrameTileWidth}
 #define ${name.toUpperCase()}_TILE_HEIGHT ${tileHeight}${frameCountSrc}`;
 }
 function toSrcFiles(result, format) {
     let file;
-    if ((0, sprite_1.isProcessBasicSpriteResult)(result)) {
-        file = result.sprite.file;
-    }
-    else if ((0, background_1.isProcessBackgroundResult)(result)) {
-        file = result.background.file;
-    }
-    else if ((0, sprite_1.isProcessSharedPaletteSpritesResult)(result)) {
-        file = result.sprite.name;
-    }
-    else if ((0, bitmap_1.isProcessBitmapResult)(result)) {
-        file = result.bitmap.file;
-    }
-    else if ((0, palette_1.isProcessPaletteResult)(result)) {
-        file = result.palette.file;
+    if (result.type == "SharedPaletteSprites") {
+        file = result.spec.name;
     }
     else {
-        throw new Error(`toSrcFiles: unexpected object: ${JSON.stringify(result)}`);
+        file = result.spec.file;
     }
     const fileRoot = path.basename(file, path.extname(file));
-    if ((0, bitmap_1.isProcessBitmapResult)(result)) {
+    if (result.type === "Bitmap") {
         switch (format) {
             case "C":
                 return {
@@ -187,7 +191,7 @@ function toSrcFiles(result, format) {
                 throw new Error('gba-convertpng does not support "bin"');
         }
     }
-    else if ((0, sprite_1.isProcessSharedPaletteSpritesResult)(result)) {
+    else if (result.type === "SharedPaletteSprites") {
         switch (format) {
             case "C":
                 return {
@@ -229,7 +233,7 @@ function toSrcFiles(result, format) {
                 throw new Error('gba-convertpng does not support "bin"');
         }
     }
-    else if ((0, palette_1.isProcessPaletteResult)(result)) {
+    else if (result.type === "Palette") {
         switch (format) {
             case "C":
                 return {
@@ -250,9 +254,7 @@ function toSrcFiles(result, format) {
             case "C.inc":
                 return {
                     tile: [],
-                    palette: [
-                        { src: (0, c_1.toCinc)(result.data, "w", 8), extension: "c.inc" },
-                    ],
+                    palette: [{ src: (0, c_1.toCinc)(result.data, "w", 8), extension: "c.inc" }],
                     map: [],
                     bitmap: [],
                 };
@@ -297,7 +299,7 @@ function toSrcFiles(result, format) {
                             },
                         ]
                         : [],
-                    map: "background" in result
+                    map: result.type === "Background"
                         ? [
                             {
                                 src: (0, c_1.toCc)(result.map, "w", 8, fileRoot + "_map", fileRoot + ".map"),
@@ -317,7 +319,7 @@ function toSrcFiles(result, format) {
                     palette: result.palette
                         ? [{ src: (0, c_1.toCinc)(result.palette, "w", 8), extension: "c.inc" }]
                         : [],
-                    map: "background" in result
+                    map: result.type === "Background"
                         ? [{ src: (0, c_1.toCinc)(result.map, "w", 8), extension: "c.inc" }]
                         : [],
                     bitmap: [],
@@ -332,7 +334,7 @@ function toSrcFiles(result, format) {
                     palette: result.palette
                         ? [{ src: (0, asm_1.toAsm)(result.palette, "w", 8, format), extension: "asm" }]
                         : [],
-                    map: "background" in result
+                    map: result.type === "Background"
                         ? [{ src: (0, asm_1.toAsm)(result.map, "w", 8, format), extension: "asm" }]
                         : [],
                     bitmap: [],
@@ -373,41 +375,47 @@ async function writeFiles(srcFiles, spec, outputDir) {
         console.log("wrote", bitmapOutputPath);
     }
 }
+async function defaultExportResults(results, spec, writeFiles, toSrcFiles) {
+    for (let i = 0; i < results.length; ++i) {
+        const result = results[i];
+        const srcFiles = toSrcFiles(result, spec.format);
+        await writeFiles(srcFiles, result.spec, spec.outputDir);
+        if (result.type === "SharedPaletteSprites") {
+            for (const processSubResult of result.subsprites) {
+                const srcFiles = toSrcFiles(processSubResult, spec.format);
+                await writeFiles(srcFiles, processSubResult.spec, spec.outputDir);
+            }
+        }
+    }
+}
 async function main(jsonSpec) {
     if (jsonSpec.format === "bin") {
         throw new Error("convertpng does not support bin format");
     }
+    const results = [];
     for (const sprite of jsonSpec.sprites) {
         if ((0, sprite_1.isBasicSpriteSpec)(sprite)) {
             const processResult = await (0, sprite_1.processBasicSprite)(sprite);
-            const srcFiles = toSrcFiles(processResult, jsonSpec.format);
-            await writeFiles(srcFiles, sprite, jsonSpec.outputDir);
+            results.push(processResult);
         }
         else {
             const processResult = await (0, sprite_1.processSharedPaletteSprites)(sprite);
-            const srcFiles = toSrcFiles(processResult, jsonSpec.format);
-            await writeFiles(srcFiles, processResult.sprite, jsonSpec.outputDir);
-            for (const processSubResult of processResult.subsprites) {
-                const srcFiles = toSrcFiles(processSubResult, jsonSpec.format);
-                await writeFiles(srcFiles, processSubResult.sprite, jsonSpec.outputDir);
-            }
+            results.push(processResult);
         }
     }
     for (const bg of jsonSpec.backgrounds) {
         const processResult = await (0, background_1.processBackground)(bg);
-        const srcFiles = toSrcFiles(processResult, jsonSpec.format);
-        await writeFiles(srcFiles, bg, jsonSpec.outputDir);
+        results.push(processResult);
     }
     for (const bmp of jsonSpec.bitmaps) {
         const processResult = await (0, bitmap_1.processBitmap)(bmp);
-        const srcFiles = toSrcFiles(processResult, jsonSpec.format);
-        await writeFiles(srcFiles, bmp, jsonSpec.outputDir);
+        results.push(processResult);
     }
     for (const palette of jsonSpec.palettes) {
         const processResult = await (0, palette_1.processPalette)(palette);
-        const srcFiles = toSrcFiles(processResult, jsonSpec.format);
-        await writeFiles(srcFiles, palette, jsonSpec.outputDir);
+        results.push(processResult);
     }
+    jsonSpec.exportResults(results, jsonSpec, writeFiles, toSrcFiles);
 }
 if (require.main === module) {
     const [_tsNode, _convertpng, jsonSpecPath] = process.argv;

package/dist/palette.d.ts

@@ -1,7 +1,6 @@
 import { Canvas } from "canvas";
 import { PaletteSpec, ProcessPaletteResult } from "./types";
 declare const MAGENTA_15: number;
-declare function isProcessPaletteResult(obj: unknown): obj is ProcessPaletteResult;
 declare function getForcedPalette(c: Canvas): number[];
 declare function extractPalette(c: Canvas, pad?: boolean): number[];
 declare function extractPalette15(data15: number[], pad?: boolean): number[];
@@ -10,4 +9,4 @@ declare function reduceCanvases(canvases: Canvas[]): {
     canvas: Canvas;
 };
 declare function processPalette(palette: PaletteSpec): Promise<ProcessPaletteResult>;
-export { processPalette, isProcessPaletteResult, extractPalette, extractPalette15, getForcedPalette, reduceCanvases, MAGENTA_15 };
+export { processPalette, extractPalette, extractPalette15, getForcedPalette, reduceCanvases, MAGENTA_15, };

package/dist/palette.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAGENTA_15 = void 0;
 exports.processPalette = processPalette;
-exports.isProcessPaletteResult = isProcessPaletteResult;
 exports.extractPalette = extractPalette;
 exports.extractPalette15 = extractPalette15;
 exports.getForcedPalette = getForcedPalette;
@@ -13,14 +12,6 @@ const canvas_2 = require("./canvas");
 const MAGENTA_24 = [255, 0, 255, 255];
 const MAGENTA_15 = (0, colors_1.rgbToGBA15)(255, 0, 255);
 exports.MAGENTA_15 = MAGENTA_15;
-function isProcessPaletteResult(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        "palette" in obj &&
-        typeof obj.palette === "object" &&
-        obj.palette !== null &&
-        "file" in obj.palette);
-}
 function is24BitMagenta(color) {
     return (color.length === MAGENTA_24.length &&
         color.every((channel, i) => channel === MAGENTA_24[i]));
@@ -124,8 +115,9 @@ async function processPalette(palette) {
         paletteData = extractPalette(paletteCanvas, !palette.trimPalette);
     }
     return {
-        palette,
-        data: paletteData
+        type: "Palette",
+        spec: palette,
+        data: paletteData,
     };
 }
 //# sourceMappingURL=palette.js.map

package/dist/sprite.d.ts

@@ -1,10 +1,8 @@
 import { BasicSpriteSpec, ProcessBasicSpriteResult, ProcessSharedPaletteSpritesResult, SharedPaletteSpriteSpec, SpriteSpec } from "./types";
 import { Canvas } from "canvas";
 declare function isSharedPaletteSpriteSpec(obj: unknown): obj is SharedPaletteSpriteSpec;
-declare function isProcessBasicSpriteResult(obj: unknown): obj is ProcessBasicSpriteResult;
-declare function isProcessSharedPaletteSpritesResult(obj: unknown): obj is ProcessSharedPaletteSpritesResult;
 declare function isBasicSpriteSpec(sprite: SpriteSpec): sprite is BasicSpriteSpec;
 declare function processBasicSprite(sprite: BasicSpriteSpec, forcedPaletteOverride?: Canvas): Promise<ProcessBasicSpriteResult>;
 declare function processSharedPaletteSprites(sharedPaletteSprite: SharedPaletteSpriteSpec): Promise<ProcessSharedPaletteSpritesResult>;
-export { isBasicSpriteSpec, processBasicSprite, processSharedPaletteSprites, isSharedPaletteSpriteSpec, isProcessBasicSpriteResult, isProcessSharedPaletteSpritesResult, };
+export { isBasicSpriteSpec, isSharedPaletteSpriteSpec, processBasicSprite, processSharedPaletteSprites, };
 export type { ProcessBasicSpriteResult, ProcessSharedPaletteSpritesResult };

package/dist/sprite.js

@@ -1,31 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBasicSpriteSpec = isBasicSpriteSpec;
+exports.isSharedPaletteSpriteSpec = isSharedPaletteSpriteSpec;
 exports.processBasicSprite = processBasicSprite;
 exports.processSharedPaletteSprites = processSharedPaletteSprites;
-exports.isSharedPaletteSpriteSpec = isSharedPaletteSpriteSpec;
-exports.isProcessBasicSpriteResult = isProcessBasicSpriteResult;
-exports.isProcessSharedPaletteSpritesResult = isProcessSharedPaletteSpritesResult;
 const canvas_1 = require("./canvas");
 const palette_1 = require("./palette");
 const tile_1 = require("./tile");
 function isSharedPaletteSpriteSpec(obj) {
     return typeof obj === "object" && obj !== null && "name" in obj;
 }
-function isProcessBasicSpriteResult(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        "sprite" in obj &&
-        typeof obj.sprite === "object" &&
-        obj.sprite !== null &&
-        "file" in obj.sprite);
-}
-function isProcessSharedPaletteSpritesResult(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        "sprite" in obj &&
-        isSharedPaletteSpriteSpec(obj.sprite));
-}
 function isBasicSpriteSpec(sprite) {
     return "file" in sprite;
 }
@@ -50,7 +34,8 @@ async function processBasicSprite(sprite, forcedPaletteOverride) {
         palette[0] = sprite.transparentColor;
     }
     return {
-        sprite,
+        type: "BasicSprite",
+        spec: sprite,
         canvas,
         tiles,
         palette,
@@ -95,7 +80,8 @@ async function processSharedPaletteSprites(sharedPaletteSprite) {
         commonPalette[0] = sharedPaletteSprite.transparentColor;
     }
     return {
-        sprite: sharedPaletteSprite,
+        type: "SharedPaletteSprites",
+        spec: sharedPaletteSprite,
         palette: commonPalette,
         subsprites: subspriteResults,
     };

package/dist/types.d.ts

@@ -38,34 +38,56 @@ export type ImportedJsonSpec = {
     backgrounds?: BackgroundSpec[];
     bitmaps?: BitmapSpec[];
     palettes?: PaletteSpec[];
+    exportResultsPath?: string;
+};
+export type SrcFile = {
+    src: string;
+    extension: string;
+};
+export type SrcFiles = {
+    tile: SrcFile[];
+    palette: SrcFile[];
+    map: SrcFile[];
+    bitmap: SrcFile[];
+};
+export type WriteFiles = (srcFiles: SrcFiles, spec: BasicSpriteSpec | BackgroundSpec | SharedPaletteSpriteSpec | BitmapSpec | PaletteSpec, outputDir: string) => Promise<void>;
+export type ToSrcFiles = (result: ProcessBasicSpriteResult | ProcessBackgroundResult | ProcessSharedPaletteSpritesResult | ProcessBitmapResult | ProcessPaletteResult, format: Format) => SrcFiles;
+export type ExportResults = (results: ProcessResult[], spec: JsonSpec, writeFiles: WriteFiles, toSrcFiles: ToSrcFiles) => Promise<void>;
+export type JsonSpec = Required<Omit<ImportedJsonSpec, "exportResultsPath">> & {
+    exportResults: ExportResults;
 };
-export type JsonSpec = Required<ImportedJsonSpec>;
 export type ProcessBasicSpriteResult = {
-    sprite: BasicSpriteSpec;
+    type: "BasicSprite";
+    spec: BasicSpriteSpec;
     canvas: Canvas;
     tiles: number[];
     palette?: number[];
 };
 export type ProcessSharedPaletteSpritesResult = {
-    sprite: SharedPaletteSpriteSpec;
+    type: "SharedPaletteSprites";
+    spec: SharedPaletteSpriteSpec;
     subsprites: ProcessBasicSpriteResult[];
     palette: number[];
 };
 export type ProcessBackgroundResult = {
+    type: "Background";
     canvas: Canvas;
-    background: BackgroundSpec;
+    spec: BackgroundSpec;
     tiles: number[];
     palette: number[];
     paletteCount: number;
     map: number[];
 };
 export type ProcessBitmapResult = {
-    bitmap: BitmapSpec;
+    type: "Bitmap";
+    spec: BitmapSpec;
     width: number;
     height: number;
     pixels: number[];
 };
 export type ProcessPaletteResult = {
-    palette: PaletteSpec;
+    type: "Palette";
+    spec: PaletteSpec;
     data: number[];
 };
+export type ProcessResult = ProcessBasicSpriteResult | ProcessSharedPaletteSpritesResult | ProcessBackgroundResult | ProcessBitmapResult | ProcessPaletteResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@city41/gba-convertpng",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "Converts png images to GBA tile format",
   "main": "index.js",
   "repository": "github.com/city41/gba-convertpng",