@city41/gba-convertpng 0.0.33 → 0.0.35

package/dist/AsepriteParser.d.ts

@@ -0,0 +1,119 @@
+import { Canvas } from "canvas";
+export interface AsepriteHeader {
+    fileSize: number;
+    imageWidth: number;
+    imageHeight: number;
+    frameCount: number;
+    colorDepth: number;
+}
+export interface AsepriteFrame {
+    layers: Array<FrameLayer>;
+    duration: number;
+    image: Canvas;
+}
+export interface AsepriteLayer {
+    layerID: number;
+    layerName: string;
+}
+export interface AsepriteTag {
+    startIndex: number;
+    endIndex: number;
+    tagName: string;
+}
+interface FrameLayer {
+    layerID: number;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        w: number;
+        h: number;
+    };
+    imageData: Uint8Array;
+}
+export interface SpriteSheetOptions {
+    /**
+     * Frames: Array<number>
+     */
+    frames: Array<number> | "all";
+    /**
+     *rows: number - number of rows in spritesheet
+     */
+    rows: number;
+    /**
+     *cols: number - number of columns in spritesheet
+     */
+    cols?: number;
+}
+export declare class AsepriteParser {
+    filepath: string;
+    loaded: boolean;
+    header: AsepriteHeader | undefined;
+    frames: Array<AsepriteFrame>;
+    tags: Array<AsepriteTag>;
+    layers: Array<AsepriteLayer>;
+    palette: Array<string>;
+    constructor(filePath: string);
+    /**
+     * initialize - requiired call prior to making other calls
+     * reads in and parses asepreite or ase file
+     * Asynchronous function
+     * @returns Promise<boolean>
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * getTags() returns the parsed animation tags from the Aseprite file
+     * @returns Array<AsepriteTag>
+     */
+    getTags(): Array<AsepriteTag>;
+    /**
+     * getPalette - returns the array of colors that are in the aseprite file
+     * @returns Array<string>
+     */
+    getPalette(): Array<string>;
+    /**
+     * getTaggedAnimation - finds the animation tag from aseprite and uses the frame indexes associated
+     * to return either the spritesheet or an array of images associated with that tag, throws error
+     * if it cannot find that tag
+     * Asynchronous function
+     * @param {string} tag - the string text that is listed in the aseprite file for a collection of frames
+     * @param {boolean} split  - the boolean flag to return a spritesheet (false), or an array of images (true)
+     * @returns {Canvas|Array<Canvas>}
+     */
+    getTaggedAnimation(tag: string, split?: boolean): Promise<Array<Canvas> | Canvas>;
+    /**
+     * getFrames - returns specific frame content as spritesheet or array of images
+     * Asynchronous function
+     * @param {number} from - starting index for retrieving image frames
+     * @param {number} to - ending index for retrieving image frames
+     * @param {boolean} split - the boolean flag to return a spritesheet (false), or an array of images (true)
+     * @returns {HTMLImageElement|Array<HTMLImageElement>}
+     */
+    getFrames(from: number, to: number, split?: boolean): Promise<Array<Canvas> | Canvas>;
+    /**
+     * getSpriteSheet - returns a spritesheet based on options parameters
+     * Asynchronous function
+     * @param {SpriteSheetOptions} options - frames, rows, cols
+     * @returns {HTMLImageElement}
+     */
+    getSpriteSheet(options: SpriteSheetOptions): Promise<Canvas>;
+    /**
+     * getImage - pulls the image element for given frame
+     * @param {number} frame - number representing the index of the frame to pull image from
+     * @returns {HTMLIFrameElement}
+     */
+    getImage(frame: number): Canvas | undefined;
+    private _parseHeader;
+    private _parseFrames;
+    private _convertRGBAtoHexSTring;
+    private _makeSpriteSheet;
+    private _readByteString;
+    private _getBytes;
+    private _readLayersChunk;
+    private _readTagsChunk;
+    private _readPalletChunk;
+    private _readCelChunk;
+    private _loadCheck;
+}
+export {};

package/dist/AsepriteParser.js

@@ -0,0 +1,443 @@
+"use strict";
+/* Aseprite-parser.ts - 6/30/2023 - version 1.0.8
+Author: Justin Young
+https://github.com/jyoung4242/aseprite-parser
+
+exported types:
+AsepriteHeader, AsepriteFrame, AspriteTag, SpriteSheetOptions
+
+exported class AsepriteModule{}
+
+constructor
+@params -> either the relative path to an *.Aseprite or *.ase file, or passing the file itself
+
+usage:
+const myAsepriteFile = new AsepriteModule(myasefile);
+await myAsepriteFile.initialize()
+
+... then you can call one of several methods
+getTags(), getPalette(), getTaggedAnimation(), getFrames(), getSpriteSheet(), getImage()
+
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsepriteParser = void 0;
+const pako_1 = require("pako");
+const canvas_1 = require("canvas");
+const promises_1 = __importDefault(require("node:fs/promises"));
+var chunktype;
+(function (chunktype) {
+    chunktype[chunktype["OldPalletChunk1"] = 4] = "OldPalletChunk1";
+    chunktype[chunktype["OldPalletChunk2"] = 17] = "OldPalletChunk2";
+    chunktype[chunktype["LayerChunk"] = 8196] = "LayerChunk";
+    chunktype[chunktype["CelChunk"] = 8197] = "CelChunk";
+    chunktype[chunktype["CelExtraChunk"] = 8198] = "CelExtraChunk";
+    chunktype[chunktype["ColorProfileChunk"] = 8199] = "ColorProfileChunk";
+    chunktype[chunktype["ExternalFilesChunk"] = 8200] = "ExternalFilesChunk";
+    chunktype[chunktype["MaskChunk"] = 8214] = "MaskChunk";
+    chunktype[chunktype["TagsChunk"] = 8216] = "TagsChunk";
+    chunktype[chunktype["PalletChunk"] = 8217] = "PalletChunk";
+    chunktype[chunktype["UserDataChunk"] = 8224] = "UserDataChunk";
+    chunktype[chunktype["SliceChunk"] = 8226] = "SliceChunk";
+    chunktype[chunktype["TileSetChunk"] = 8227] = "TileSetChunk";
+})(chunktype || (chunktype = {}));
+class AsepriteParser {
+    /*Public Methods */
+    constructor(filePath) {
+        //Properties
+        this.filepath = "";
+        this.loaded = false;
+        this._parseFrames = async (fileData) => {
+            return new Promise(async (resolve, reject) => {
+                // let numBytesinFrame = 0;
+                // let magicWord = 0;
+                let oldChunks, newChunks, numChunks;
+                let frameDuration = 0;
+                let newPalletChunk = false;
+                let framelayers = [];
+                //remove Aseprite Header
+                const frameBytes = fileData.slice(128);
+                let fileCursor = 0;
+                const tempFrames = [];
+                for (let frameIndex = 0; frameIndex < this.header.frameCount; frameIndex++) {
+                    // numBytesinFrame = new DataView(frameBytes.buffer).getUint32(
+                    //   fileCursor,
+                    //   true,
+                    // );
+                    // magicWord = new DataView(frameBytes.buffer).getUint16(
+                    //   fileCursor + 4,
+                    //   true,
+                    // );
+                    oldChunks = new DataView(frameBytes.buffer).getUint16(fileCursor + 6, true);
+                    frameDuration = new DataView(frameBytes.buffer).getUint16(fileCursor + 8, true);
+                    newChunks = new DataView(frameBytes.buffer).getUint32(fileCursor + 12, true);
+                    numChunks = newChunks === 0 ? oldChunks : newChunks;
+                    fileCursor += 16;
+                    //iterate over chunks
+                    framelayers = [];
+                    for (let chunkIndex = 0; chunkIndex < numChunks; chunkIndex++) {
+                        //Chunk Parsing
+                        let chunkSize = new DataView(frameBytes.buffer).getUint32(fileCursor, true);
+                        const chunkStartIndex = fileCursor;
+                        let chunkType = new DataView(frameBytes.buffer).getUint16(fileCursor + 4, true);
+                        switch (chunkType) {
+                            case chunktype.OldPalletChunk1:
+                                if (newPalletChunk)
+                                    break;
+                                break;
+                            case chunktype.OldPalletChunk2:
+                                if (newPalletChunk)
+                                    break;
+                                break;
+                            case chunktype.LayerChunk:
+                                this._readLayersChunk(fileCursor, frameBytes.buffer);
+                                break;
+                            case chunktype.CelChunk:
+                                let frameLayer = this._readCelChunk(fileCursor, frameBytes, chunkSize, chunkStartIndex);
+                                framelayers.push(frameLayer);
+                                break;
+                            case chunktype.CelExtraChunk:
+                                break;
+                            case chunktype.ColorProfileChunk:
+                                break;
+                            case chunktype.ExternalFilesChunk:
+                                break;
+                            case chunktype.MaskChunk:
+                                break;
+                            case chunktype.TagsChunk:
+                                this._readTagsChunk(fileCursor, frameBytes);
+                                break;
+                            case chunktype.PalletChunk:
+                                this._readPalletChunk(fileCursor, frameBytes);
+                                break;
+                            case chunktype.UserDataChunk:
+                                break;
+                            case chunktype.SliceChunk:
+                                break;
+                            case chunktype.TileSetChunk:
+                                break;
+                        }
+                        fileCursor += chunkSize;
+                        //Last Chunk, build out frame data
+                        if (chunkIndex == numChunks - 1) {
+                            let myCanvas = (0, canvas_1.createCanvas)(this.header?.imageWidth, this.header?.imageHeight);
+                            let ctx = myCanvas.getContext("2d");
+                            ctx?.clearRect(0, 0, this.header?.imageWidth, this.header?.imageHeight);
+                            //build out frame entry in array
+                            framelayers.forEach((frame) => {
+                                let myClampedArray = new Uint8ClampedArray(frame?.imageData);
+                                const newImageData = new canvas_1.ImageData(myClampedArray, frame?.size.w, frame?.size.h);
+                                let tempCanvas = (0, canvas_1.createCanvas)(frame.size.w, frame.size.h);
+                                let tempctx = tempCanvas.getContext("2d");
+                                tempctx?.putImageData(newImageData, 0, 0);
+                                ctx?.drawImage(tempCanvas, frame.position.x, frame.position.y, frame.size.w, frame.size.h);
+                            });
+                            tempFrames.push({
+                                layers: framelayers,
+                                duration: frameDuration,
+                                image: myCanvas,
+                            });
+                        }
+                    }
+                }
+                resolve(tempFrames);
+            });
+        };
+        this.filepath = filePath;
+        this.tags = [];
+        this.palette = [];
+        this.layers = [];
+        this.frames = [];
+    }
+    /**
+     * initialize - requiired call prior to making other calls
+     * reads in and parses asepreite or ase file
+     * Asynchronous function
+     * @returns Promise<boolean>
+     */
+    async initialize() {
+        const fileData = Uint8Array.from(await promises_1.default.readFile(this.filepath));
+        this.header = await this._parseHeader(fileData);
+        this.frames = await this._parseFrames(fileData);
+        if (!this.header || !this.frames) {
+            return false;
+        }
+        if (this.header.fileSize != 0 &&
+            this.frames.length != 0) {
+            this.loaded = true;
+        }
+        return true;
+    }
+    /**
+     * getTags() returns the parsed animation tags from the Aseprite file
+     * @returns Array<AsepriteTag>
+     */
+    getTags() {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        return this.tags;
+    }
+    /**
+     * getPalette - returns the array of colors that are in the aseprite file
+     * @returns Array<string>
+     */
+    getPalette() {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        return this.palette;
+    }
+    /**
+     * getTaggedAnimation - finds the animation tag from aseprite and uses the frame indexes associated
+     * to return either the spritesheet or an array of images associated with that tag, throws error
+     * if it cannot find that tag
+     * Asynchronous function
+     * @param {string} tag - the string text that is listed in the aseprite file for a collection of frames
+     * @param {boolean} split  - the boolean flag to return a spritesheet (false), or an array of images (true)
+     * @returns {Canvas|Array<Canvas>}
+     */
+    async getTaggedAnimation(tag, split = true) {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        //find tag
+        const foundTag = this.tags.findIndex((tagstring) => tag == tagstring.tagName);
+        if (foundTag == -1)
+            throw new Error("tagname not found");
+        //tagindex found
+        const result = await this.getFrames(this.tags[foundTag].startIndex, this.tags[foundTag].endIndex, split);
+        return result;
+    }
+    /**
+     * getFrames - returns specific frame content as spritesheet or array of images
+     * Asynchronous function
+     * @param {number} from - starting index for retrieving image frames
+     * @param {number} to - ending index for retrieving image frames
+     * @param {boolean} split - the boolean flag to return a spritesheet (false), or an array of images (true)
+     * @returns {HTMLImageElement|Array<HTMLImageElement>}
+     */
+    async getFrames(from, to, split = true) {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        if (split) {
+            let tempArray = [];
+            for (let index = from; index <= to; index++) {
+                tempArray.push(this.frames[index].image);
+            }
+            return tempArray;
+        }
+        else {
+            let tempArray = [];
+            //console.log(from, to);
+            for (let index = from; index <= to; index++) {
+                tempArray.push(index);
+            }
+            //console.log(tempArray);
+            const tempImage = await this._makeSpriteSheet(tempArray, 1, tempArray.length);
+            return tempImage;
+        }
+    }
+    /**
+     * getSpriteSheet - returns a spritesheet based on options parameters
+     * Asynchronous function
+     * @param {SpriteSheetOptions} options - frames, rows, cols
+     * @returns {HTMLImageElement}
+     */
+    async getSpriteSheet(options) {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        const tempImage = await this._makeSpriteSheet(options.frames, options.rows, options.cols);
+        return tempImage;
+    }
+    /**
+     * getImage - pulls the image element for given frame
+     * @param {number} frame - number representing the index of the frame to pull image from
+     * @returns {HTMLIFrameElement}
+     */
+    getImage(frame) {
+        this._loadCheck();
+        if (!this.frames)
+            return undefined;
+        return this.frames[frame].image;
+    }
+    /*Private Methods */
+    async _parseHeader(fileData) {
+        return new Promise((resolve, reject) => {
+            //isolate Aseprite Header
+            const headerBytes = fileData.slice(0, 128);
+            // Parse the header fields
+            const fileSize = new DataView(headerBytes.buffer).getUint32(0, true);
+            const frameCount = new DataView(headerBytes.buffer).getUint16(6, true);
+            const imageWidth = new DataView(headerBytes.buffer).getUint16(8, true);
+            const imageHeight = new DataView(headerBytes.buffer).getUint16(10, true);
+            const colorDepth = new DataView(headerBytes.buffer).getUint16(12, true);
+            resolve({ fileSize, imageWidth, imageHeight, colorDepth, frameCount });
+        });
+    }
+    _convertRGBAtoHexSTring(color) {
+        function padTo2(str) {
+            return str.padStart(2, "0");
+        }
+        const hexR = padTo2(color.r.toString(16));
+        const hexG = padTo2(color.g.toString(16));
+        const hexB = padTo2(color.b.toString(16));
+        const hexA = padTo2(color.a.toString(16));
+        return `#${hexR}${hexG}${hexB}${hexA}`;
+    }
+    async _makeSpriteSheet(frames, rows, cols) {
+        if (frames === "all") {
+            cols = this.header?.frameCount;
+        }
+        if (!cols) {
+            throw new Error("_makeSpriteSheet: cols not specified");
+        }
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+        let tempFrames = [];
+        let rowIndex = 0;
+        let colIndex = 0;
+        let ssWidth = 0;
+        let ssHeight = 0;
+        if (this.header) {
+            ssWidth = this.header.imageWidth * cols;
+            ssHeight = this.header.imageHeight * rows;
+        }
+        let tempCanvas = (0, canvas_1.createCanvas)(ssWidth, ssHeight);
+        let tempCtx = tempCanvas.getContext("2d");
+        let imageIndex = 0;
+        if (frames === "all") {
+            //console.log(this.header?.frameCount);
+            if (this.header)
+                for (let index = 0; index < this.header?.frameCount; index++) {
+                    //console.log("loop index: ", index);
+                    tempFrames.push(index);
+                }
+        }
+        else {
+            tempFrames = [...frames];
+        }
+        //console.log(tempFrames);
+        tempFrames.forEach((frame) => {
+            colIndex = imageIndex % cols;
+            rowIndex = Math.floor(imageIndex / cols);
+            let drawX, drawY;
+            if (this.header)
+                drawX = colIndex * this.header?.imageWidth;
+            if (this.header)
+                drawY = rowIndex * this.header?.imageHeight;
+            //console.log(rowIndex, colIndex, drawX, drawY);
+            tempCtx?.drawImage(this.frames[frame].image, drawX, drawY);
+            imageIndex++;
+        });
+        return tempCanvas;
+    }
+    _readByteString(frameBuffer, startingIndex, length) {
+        const myStringArray = new Uint8Array(length);
+        for (let i = 0; i < myStringArray.length; i++) {
+            myStringArray[i] = new DataView(frameBuffer).getUint8(startingIndex + i);
+        }
+        let decoder = new TextDecoder();
+        return decoder.decode(myStringArray);
+    }
+    _getBytes(n, start, buffer) {
+        return new Uint8Array(buffer.slice(start, start + n));
+    }
+    _readLayersChunk(cursor, buffer) {
+        let layerCursor = cursor + 6;
+        let layerNameLength = new DataView(buffer).getInt16(layerCursor + 16, true);
+        layerCursor += 18;
+        let layerName = this._readByteString(buffer, layerCursor, layerNameLength);
+        let layerID = this.layers?.length;
+        this.layers?.push({ layerID: layerID, layerName: layerName });
+    }
+    _readTagsChunk(cursor, parentbuffer) {
+        let tagsChunkOffsetCursor = cursor + 6;
+        let buffer = parentbuffer.buffer;
+        let numTags = new DataView(buffer).getUint16(tagsChunkOffsetCursor, true);
+        tagsChunkOffsetCursor += 10;
+        for (let index = 0; index < numTags; index++) {
+            let fromIndex = new DataView(buffer).getUint16(tagsChunkOffsetCursor, true);
+            let toIndex = new DataView(buffer).getUint16(tagsChunkOffsetCursor + 2, true);
+            tagsChunkOffsetCursor += 17;
+            let nameLength = new DataView(buffer).getUint16(tagsChunkOffsetCursor, true);
+            tagsChunkOffsetCursor += 2;
+            let tagName = this._readByteString(parentbuffer.buffer, tagsChunkOffsetCursor, nameLength);
+            tagsChunkOffsetCursor += nameLength;
+            this.tags?.push({
+                startIndex: fromIndex,
+                endIndex: toIndex,
+                tagName: tagName,
+            });
+        }
+    }
+    _readPalletChunk(cursor, parentbuffer) {
+        let palletCursor = cursor + 6;
+        let buffer = parentbuffer.buffer;
+        let newPalletSize = new DataView(buffer).getUint32(palletCursor, true);
+        palletCursor += 20;
+        for (let index = 0; index < newPalletSize; index++) {
+            let red = new DataView(buffer).getUint8(palletCursor + 2);
+            let green = new DataView(buffer).getUint8(palletCursor + 3);
+            let blue = new DataView(buffer).getUint8(palletCursor + 4);
+            let alpha = new DataView(buffer).getUint8(palletCursor + 5);
+            let colorstring = this._convertRGBAtoHexSTring({
+                r: red,
+                g: green,
+                b: blue,
+                a: alpha,
+            });
+            this.palette?.push(colorstring);
+        }
+    }
+    _readCelChunk(cursor, parentbuffer, size, startIndex) {
+        let celCursor = cursor + 6;
+        let buffer = parentbuffer.buffer;
+        // let framelayers = [];
+        let layer = new DataView(buffer).getUint16(celCursor, true);
+        let xpos = new DataView(buffer).getInt16(celCursor + 2, true);
+        let ypos = new DataView(buffer).getInt16(celCursor + 4, true);
+        // let opacity = new DataView(buffer).getUint8(celCursor + 6);
+        let celType = new DataView(buffer).getUint16(celCursor + 7, true);
+        // let zindex = new DataView(buffer).getInt16(celCursor + 9, true);
+        let pixelWidth, pixelHeight;
+        celCursor += 16;
+        switch (celType) {
+            case 0:
+                //raw image
+                break;
+            case 1:
+                //linked cell
+                break;
+            case 2:
+                //compressed image
+                pixelWidth = new DataView(buffer).getUint16(celCursor, true);
+                pixelHeight = new DataView(buffer).getUint16(celCursor + 2, true);
+                celCursor += 4;
+                const bytesToRead = size - (celCursor - startIndex);
+                let compressedArray = this._getBytes(bytesToRead, celCursor, parentbuffer);
+                let decompressedArray;
+                try {
+                    decompressedArray = (0, pako_1.inflate)(compressedArray);
+                }
+                catch (error) {
+                    throw new Error("Error unpacking compressed Image");
+                }
+                return {
+                    layerID: layer,
+                    position: { x: xpos, y: ypos },
+                    size: { w: pixelWidth, h: pixelHeight },
+                    imageData: decompressedArray,
+                };
+                break;
+            case 3:
+                //compressed tilemap
+                break;
+        }
+    }
+    _loadCheck() {
+        if (!this.loaded)
+            throw new Error("Aseprite file not loaded");
+    }
+}
+exports.AsepriteParser = AsepriteParser;
+//# sourceMappingURL=AsepriteParser.js.map

package/dist/background.js

@@ -57,10 +57,33 @@ function buildMap(tiles, bgWidthPx, bgHeightPx) {
     const map = [];
     const bgWidthT = bgWidthPx / 8;
     const bgHeightT = bgHeightPx / 8;
-    for (let y = 0; y < bgHeightT; ++y) {
-        for (let x = 0; x < bgWidthT; ++x) {
-            const tile = tiles[y * bgWidthT + x];
-            map.push((tile.paletteIndex << 12) | tile.tileIndex);
+    if (bgWidthT % 32 !== 0) {
+        throw new Error(`buildMap: bg is of unexpected tile width: ${bgWidthT}`);
+    }
+    if (bgHeightT % 32 !== 0) {
+        throw new Error(`buildMap: bg is of unexpected tile height: ${bgHeightT}`);
+    }
+    // when backgrounds are 64 tiles high/wide
+    // then the map gets divided into quadrants,
+    // the quads are laid out colunm first
+    //
+    // [1][2]
+    //
+    // [1]
+    // [2]
+    //
+    // [1][2]
+    // [3][4]
+    const quadranteColumns = bgWidthT / 32;
+    const quadranteRows = bgHeightT / 32;
+    for (let qc = 0; qc < quadranteColumns; ++qc) {
+        for (let qy = 0; qy < quadranteRows; ++qy) {
+            for (let y = qy * 32; y < (qy + 1) * 32; ++y) {
+                for (let x = qc * 32; x < (qc + 1) * 32; ++x) {
+                    const tile = tiles[y * bgWidthT + x];
+                    map.push((tile.paletteIndex << 12) | tile.tileIndex);
+                }
+            }
         }
     }
     return map;

package/dist/main.js

@@ -132,7 +132,7 @@ function getTileDefines(result, file) {
     let frameCountSrc = "";
     let frameCount = 1;
     if (result.type == "BasicSprite") {
-        frameCount = result.spec.frames;
+        frameCount = result.spec.frames ?? 1;
         frameCountSrc = `\n#define ${name.toUpperCase()}_FRAME_COUNT ${frameCount}`;
     }
     let singleFrameTileWidth = allFrameTileWidth / frameCount;

package/dist/sprite.js

@@ -1,25 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isBasicSpriteSpec = isBasicSpriteSpec;
 exports.isSharedPaletteSpriteSpec = isSharedPaletteSpriteSpec;
 exports.processBasicSprite = processBasicSprite;
 exports.processSharedPaletteSprites = processSharedPaletteSprites;
+const promises_1 = __importDefault(require("node:fs/promises"));
 const canvas_1 = require("./canvas");
 const palette_1 = require("./palette");
 const tile_1 = require("./tile");
+const AsepriteParser_1 = require("./AsepriteParser");
 function isSharedPaletteSpriteSpec(obj) {
     return typeof obj === "object" && obj !== null && "name" in obj;
 }
 function isBasicSpriteSpec(sprite) {
     return "file" in sprite;
 }
+async function processBasicAseprite(sprite, forcedPaletteOverride) {
+    const parser = new AsepriteParser_1.AsepriteParser(sprite.file);
+    await parser.initialize();
+    const spriteSheetCanvas = await parser.getSpriteSheet({
+        rows: 1,
+        frames: "all",
+    });
+    const spriteSheetBuffer = spriteSheetCanvas.toBuffer();
+    const newFilePath = sprite.file.replace(".aseprite", ".png");
+    await promises_1.default.writeFile(newFilePath, spriteSheetBuffer);
+    const processBasicResult = await processBasicSprite({
+        ...sprite,
+        file: newFilePath,
+        frames: parser.frames.length,
+    }, forcedPaletteOverride);
+    return {
+        ...processBasicResult,
+        frameDurations: parser.frames.map((f) => f.duration),
+    };
+}
 async function processBasicSprite(sprite, forcedPaletteOverride) {
-    if (sprite.frames === undefined || sprite.frames === 0) {
-        throw new Error(`sprite, ${sprite.file}, has no frames defined`);
+    if (sprite.file.toLowerCase().endsWith(".aseprite")) {
+        return processBasicAseprite(sprite, forcedPaletteOverride);
     }
     let canvas = await (0, canvas_1.reduceColors)(await (0, canvas_1.createCanvasFromPath)(sprite.file), 16);
+    const frames = sprite.frames ?? 1;
     // before rounding up the canvas, grab its actual pixel size
-    const framePixelWidth = Math.ceil(canvas.width / sprite.frames);
+    const framePixelWidth = Math.ceil(canvas.width / 1);
     const framePixelHeight = canvas.height;
     canvas = (0, canvas_1.roundUpToTileSize)(canvas);
     let palette;
@@ -32,7 +58,7 @@ async function processBasicSprite(sprite, forcedPaletteOverride) {
     else {
         palette = (0, palette_1.extractPalette)(canvas, !sprite.trimPalette);
     }
-    const tiles = (0, tile_1.extractTiles)(canvas, palette, sprite.frames).flat(1);
+    const tiles = (0, tile_1.extractTiles)(canvas, palette, 1).flat(1);
     if (typeof sprite.transparentColor === "number") {
         palette[0] = sprite.transparentColor;
     }
@@ -44,6 +70,7 @@ async function processBasicSprite(sprite, forcedPaletteOverride) {
         palette,
         framePixelWidth,
         framePixelHeight,
+        frameDurations: new Array(frames).fill(100),
     };
 }
 async function processSharedPaletteSprites(sharedPaletteSprite) {

package/dist/types.d.ts

@@ -3,7 +3,7 @@ export type Format = "C" | "C.inc" | "z80" | "pyz80" | "asz80" | "bin";
 export type DataWidth = "b" | "w" | "dw";
 export type BasicSpriteSpec = {
     file: string;
-    frames: number;
+    frames?: number;
     trimPalette?: boolean;
     forcePalette?: string;
     transparentColor?: number;
@@ -62,6 +62,7 @@ export type ProcessBasicSpriteResult = {
     canvas: Canvas;
     framePixelWidth: number;
     framePixelHeight: number;
+    frameDurations: number[];
     tiles: number[];
     palette?: number[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@city41/gba-convertpng",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Converts png images to GBA tile format",
   "main": "index.js",
   "repository": "github.com/city41/gba-convertpng",
@@ -27,7 +27,8 @@
     "imagemagick": "^0.1.3",
     "lodash": "^4.17.23",
     "mkdirp": "^3.0.1",
-    "nearest-color": "^0.4.4"
+    "nearest-color": "^0.4.4",
+    "pako": "^3.0.2"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",