silphscope 1.4.21 → 1.4.23

package/src/graphics/mons/render-mon-icon.js

@@ -27,7 +27,8 @@ export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
         throw new TypeError("renderMonIcon(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
-    let fileCount = 0;
+    let fullFileCount = 0;
+    const results = returnFileBuffer? [] : null;
     const mon = mons[monName];
     if (!mon) {
         throw new Error(`Missing mon entry for ${monName}`);
@@ -71,12 +72,32 @@ export async function renderMonIcon(monName, mons, reader, rom, options = {}) {
         await fs.promises.mkdir(dir, { recursive: true });
         await fs.promises.writeFile(`${dir}/icon_frame1.png`, buffer1);
         await fs.promises.writeFile(`${dir}/icon_frame2.png`, buffer2);
-        fileCount += 2;
+        fullFileCount += 2;
+    }
+    if (returnFileBuffer) {
+        results.push({
+            name: `${monName}-icon-frame1`,
+            category: "mon",
+            asset: "icon",
+            path: `out/mons/${monName}/icon_frame1`,
+            buffer: buffer1,
+            meta: {
+                frame: 1,
+            }
+        });
+        results.push({
+            name: `${monName}-icon-frame2`,
+            category: "mon",
+            asset: "icon",
+            path: `out/mons/${monName}/icon_frame2`,
+            buffer: buffer2,
+            meta: {
+                frame: 2,
+            },
+        });
     }
-
     return {
-        ...(returnFileBuffer && { frame1: buffer1 }),
-        ...(returnFileBuffer && { frame2: buffer2 }),
-        fileCount,
+        ...(returnFileBuffer && { results }),
+        fullFileCount,
     };
 }

package/src/graphics/mons/render-mons.js

@@ -45,10 +45,9 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
             returnFileBuffer,
             outputDir,
         });
-        fullFileCount += monIconData.fileCount;
+        fullFileCount += monIconData.fullFileCount;
         if (returnFileBuffer) {
-            results.push(monIconData.frame1);
-            results.push(monIconData.frame2);
+            results.push(...monIconData.results);
         }
     }
     if (footprint === true) {
@@ -58,9 +57,9 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
             returnFileBuffer,
             outputDir,
         });
-        fullFileCount += monFootData.fileCount;
+        fullFileCount += monFootData.fullFileCount;
         if (returnFileBuffer) {
-            results.push(monFootData.pngBuffer);
+            results.push(...monFootData.results);
         }
     }
 
@@ -108,12 +107,22 @@ export async function renderMon(monName, mons, reader, rom, options = {}) {
                 const dir = `${outputDir}/${monName}`;
                 const fileName = `${dir}/${side}${variant === "shiny" ? "_shiny" : ""}.png`;
                 await fs.promises.writeFile(fileName, pngBuffer);
+                fullFileCount += 1;
             }
 
             if (returnFileBuffer) {
-                results.push(pngBuffer);
+                results.push({
+                    name: `${monName}-${variant === "shiny"? "shiny" : "normal"}-${side}-sprite`,
+                    category: "mon",
+                    asset: "sprite",
+                    path: `out/mons/${monName}/${side}_${variant === "shiny"? "shiny" : "normal"}`,
+                    buffer: pngBuffer,
+                    meta: {
+                        side: side,
+                        variant: variant,
+                    },
+                });
             }
-            fullFileCount += 1;
         }
     }
 

package/src/graphics/moves/render-moves.js

@@ -49,7 +49,7 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
     }
 
     let fullFileCount = 0;
-    const results = returnFileBuffer? [] : null;
+    const results = returnFileBuffer ? [] : null;
     const move = moves[moveName];
     if (!move) {
         throw new Error(`Missing move: ${moveName}`)
@@ -75,48 +75,63 @@ export async function renderMove(moveName, moves, reader, rom, options = {}) {
 
     const png = new PNG({ width, height });
     png.data = image;
-    const pngBuffer = PNG.sync.write(png, { 
+    const pngBuffer = PNG.sync.write(png, {
         filterType: pngFilterType,
-        deflateLevel: pngCompressionLevel, 
+        deflateLevel: pngCompressionLevel,
     });
 
-    if (outputDir) { // I will update this later but in theory it should also work... eventually though it will need a split inside to handle full image generation :p
-        const rootDir = (sortUnused && move?.unused === true)? `${outputDir}/unused` : `${outputDir}`
-        const dir = `${rootDir}/${moveName}`;
-        await fs.promises.mkdir(dir, { recursive: true });
-        if (renderMasterImage) {
-            const png = new PNG({ width, height });
-            png.data = image;
-            const pngBuffer = PNG.sync.write(png, { 
-                filterType: pngFilterType,
-                deflateLevel: pngCompressionLevel,
-            });
+    const rootDir = (sortUnused && move?.unused === true) ? `${outputDir}/unused` : `${outputDir}` // yes this could become null if outputDir is null (who would have thought :p) but since nothing uses this unless outputDir is true then it isn't really an issue... although it is a bit messy...
+    const dir = `${rootDir}/${moveName}`;
+
+    if (renderMasterImage) {
+        if (outputDir) {
             await fs.promises.writeFile(`${dir}/master.png`, pngBuffer);
             fullFileCount += 1;
-            if (returnFileBuffer) {
-                results.push(pngBuffer);
-            }
         }
-        for (let i = 0; i < move.frames.length; i++) {
-            const frame = move.frames[i];
-            const frameImageData = extractFrameFromImage(image, width, frame);
-
-            const png = new PNG({ width: frame.width, height: frame.height });
-            png.data = frameImageData;
-            const pngBuffer = PNG.sync.write(png, { 
-                filterType: pngFilterType,
-                deflateLevel: pngCompressionLevel, 
+        if (returnFileBuffer) {
+            results.push({
+                name: `${moveName}-full-sprite`,
+                category: "move",
+                asset: "sprite",
+                path: `out/moves/${(sortUnused && move?.unused) === true? `unused/${moveName}` : `${moveName}`}/master`,
+                buffer: pngBuffer,
+                meta: { },
             });
+        }
+    }
 
+    if (outputDir) { // I will update this later but in theory it should also work... eventually though it will need a split inside to handle full image generation :p
+        await fs.promises.mkdir(dir, { recursive: true });
+    }
+    for (let i = 0; i < move.frames.length; i++) {
+        const frame = move.frames[i];
+        const frameImageData = extractFrameFromImage(image, width, frame);
+
+        const png = new PNG({ width: frame.width, height: frame.height });
+        png.data = frameImageData;
+        const pngBuffer = PNG.sync.write(png, {
+            filterType: pngFilterType,
+            deflateLevel: pngCompressionLevel,
+        });
+
+        if (outputDir) {
             const fileName = `${dir}/frame-${i}.png`;
             await fs.promises.writeFile(fileName, pngBuffer);
             fullFileCount += 1;
-            if (returnFileBuffer) {
-                results.push(pngBuffer);
-            }
+        }
+        if (returnFileBuffer) {
+            results.push({
+                name: `${moveName}-frame${i}`,
+                category: "move",
+                asset: "frame",
+                path: `out/moves/${(sortUnused && move?.unused) === true ? `unused/${moveName}` : `${moveName}`}/frame-${i}`,
+                buffer: pngBuffer,
+                meta: { },
+            });
         }
     }
 
+
     return {
         ...(returnFileBuffer && { results }),
         fullFileCount,

package/src/graphics/trainers/render-trainer-back-pics.js

@@ -27,7 +27,8 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         throw new TypeError("renderTrainerBackPic(..., rom) requires a ROM Buffer/Uint8Array");
     }
 
-    let fileCount = 0;
+    let fullFileCount = 0;
+    const results = returnFileBuffer? [] : null;
     const trainer = trainers[trainerName];
     if (!trainer) {
         throw new Error(`Missing trainer entry for ${trainerName}`);
@@ -98,7 +99,7 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
         await fs.promises.writeFile(`${dir}/trainer_back_frame_2.png`, buffer2);
         await fs.promises.writeFile(`${dir}/trainer_back_frame_3.png`, buffer3);
         await fs.promises.writeFile(`${dir}/trainer_back_frame_4.png`, buffer4);
-        fileCount += 4;
+        fullFileCount += 4;
         if (frame5) {
             const pngFrame5 = new PNG({ width, height: frameHeight });
             pngFrame5.data = frame5;
@@ -106,17 +107,58 @@ export async function renderTrainerBackPic(trainerName, trainers, reader, rom, o
                 filterType: pngFilterType,
                 deflateLevel: pngCompressionLevel,
             });
-            fs.writeFileSync(`${dir}/trainer_back_frame_5.png`, buffer5);
-            fileCount += 1;
+            await fs.promises.writeFile(`${dir}/trainer_back_frame_5.png`, buffer5);
+            fullFileCount += 1;
+        }
+    }
+
+    if (returnFileBuffer) {
+        results.push({
+            name: `${trainerName}-back-frame1`,
+            category: "trainer",
+            asset: "frame",
+            path: `out/trainers/${trainerName}/back_frame_1`,
+            buffer: buffer1,
+            meta: {},
+        });
+        results.push({
+            name: `${trainerName}-back-frame2`,
+            category: "trainer",
+            asset: "frame",
+            path: `out/trainers/${trainerName}/back_frame_2`,
+            buffer: buffer2,
+            meta: {},
+        });
+        results.push({
+            name: `${trainerName}-back-frame3`,
+            category: "trainer",
+            asset: "frame",
+            path: `out/trainers/${trainerName}/back_frame_3`,
+            buffer: buffer3,
+            meta: {},
+        });
+        results.push({
+            name: `${trainerName}-back-frame4`,
+            category: "trainer",
+            asset: "frame",
+            path: `out/trainers/${trainerName}/back_frame_4`,
+            buffer: buffer4,
+            meta: {},
+        });
+        if (frame5) {
+            results.push({
+                name: `${trainerName}-back-frame5`,
+                category: "trainer",
+                asset: "frame",
+                path: `out/trainers/${trainerName}/back_frame_5`,
+                buffer: buffer5,
+                meta: {},
+            });
         }
     }
 
     return {
-        ...(returnFileBuffer && { frame1: buffer1 }),
-        ...(returnFileBuffer && { frame2: buffer2 }),
-        ...(returnFileBuffer && { frame3: buffer3 }),
-        ...(returnFileBuffer && { frame4: buffer4 }),
-        ...(returnFileBuffer && { frame5: buffer5 }),
-        fileCount,
+        ...(returnFileBuffer && { results }),
+        fullFileCount,
     };
 }

package/src/graphics/trainers/render-trainers.js

@@ -45,15 +45,9 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
                 returnFileBuffer,
                 outputDir,
             });
-            fullFileCount += trainerBackPicData.fileCount;
+            fullFileCount += trainerBackPicData.fullFileCount;
             if (returnFileBuffer) {
-                results.push(trainerBackPicData.frame1);
-                results.push(trainerBackPicData.frame2);
-                results.push(trainerBackPicData.frame3);
-                results.push(trainerBackPicData.frame4);
-                if (trainerBackPicData?.frame5) {
-                    results.push(trainerBackPicData.frame5);
-                }
+                results.push(...trainerBackPicData.results);
             }
         }
         else if (backTrainerName === false && trainerName === "PAINTER") {
@@ -63,12 +57,9 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
                 returnFileBuffer,
                 outputDir,
             });
-            fullFileCount += trainerBackPicData.fileCount;
+            fullFileCount += trainerBackPicData.fullFileCount;
             if (returnFileBuffer) {
-                results.push(trainerBackPicData.frame1);
-                results.push(trainerBackPicData.frame2);
-                results.push(trainerBackPicData.frame3);
-                results.push(trainerBackPicData.frame4);
+                results.push(...trainerBackPicData.results);
             }
             const trainerBackPicData2 = await renderTrainerBackPic("POKEDUDE", backTrainers, reader, rom, { 
                 pngFilterType,
@@ -76,12 +67,9 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
                 returnFileBuffer,
                 outputDir,
             });
-            fullFileCount += trainerBackPicData2.fileCount;
+            fullFileCount += trainerBackPicData2.fullFileCount;
             if (returnFileBuffer) {
-                results.push(trainerBackPicData.frame1);
-                results.push(trainerBackPicData.frame2);
-                results.push(trainerBackPicData.frame3);
-                results.push(trainerBackPicData.frame4);
+                results.push(...trainerBackPicData2.results);
             }
         }
     }
@@ -112,7 +100,16 @@ export async function renderTrainer(trainerName, trainers, backTrainers, reader,
     });
 
     if (returnFileBuffer) {
-        results.push(pngBuffer);
+        results.push({
+            name: `${trainerName}-front-sprite`,
+            category: "trainer",
+            asset: "sprite",
+            path: `out/trainers/${trainerName}/front`,
+            buffer: pngBuffer,
+            meta: {
+                side: "front" // now some of you may be wondering why I added this... well it's because eventually I want you to be able to make a master image of the back sprites so we need to be able to differentiate the buffers here... anyway that was a long explanation :p
+            },
+        });
     }
 
     if (outputDir) {

package/src/is-valid-filter-type.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+export function isValidFilterType(filterTypeValue) {
+    if (Number.isInteger(filterTypeValue)) {
+        return filterTypeValue >= -1 && filterTypeValue <= 4;
+    }
+    if (Array.isArray(filterTypeValue)) {
+        return filterTypeValue.length > 0 && filterTypeValue.every(entry =>
+            Number.isInteger(entry) && entry >= 0 && entry <= 4
+        );
+    }
+
+    return false;
+}

package/src/run-with-concurrency.js

@@ -0,0 +1,12 @@
+import { mapLimit } from "./map-limit.js";
+
+export async function runWithConcurrency(items, concurrency, callback) { // this seems simple... but I have no idea if this will do what I am thinking it will do... (don't be a dum dum like me who decided to code kids!)
+    if (concurrency <= 1) {
+        for (const item of items) {
+            await callback(item);
+        }
+
+        return;
+    }
+    await mapLimit(items, concurrency, callback);
+}

package/src/validate-render-options.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2026 chickenPoo
+// Licensed under the MIT License. See LICENSE file in project root.
+
+import { isValidFilterType } from "./is-valid-filter-type.js";
+
+export function validateRenderOptions(functionName, options = {}) {
+    const {
+        concurrency = null,
+        filterType = null,
+        compressionLevel = null,
+    } = options;
+
+    if (concurrency) {
+        if (!Number.isInteger(concurrency) || concurrency < 1) {
+            throw new TypeError(`${functionName}(rom, options = { concurrency, ... }) requires concurrency to be a integer greater than 0 (recieved ${concurrency})`);
+        }
+    }
+    if (filterType) {
+        if (!isValidFilterType(filterType)) {
+            throw new TypeError(`${functionName}renderAllMons(rom, options = { pngFilterType, ... }) requires pngFilterType to be a integer between -1 and 4 (received ${pngFilterType})`)
+        }
+    }
+    if (compressionLevel) {
+        if (!Number.isInteger(compressionLevel) || compressionLevel < 0 || compressionLevel > 9) {
+            throw new TypeError(`${functionName}renderAllMons(rom, options = { pngCompressionLevel, ... }) requires pngCompressionLevel to be a integer between 0 and 9 (received ${pngCompressionLevel})`)
+        }
+    }
+}