@remvst/asset-catalog 1.4.0 → 1.6.0

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.husky/pre-push

@@ -0,0 +1 @@
+npm test

package/.idea/asset-catalog.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/copilot.data.migration.agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

package/.idea/copilot.data.migration.ask2agent.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Ask2AgentMigrationStateService">
+    <option name="migrationStatus" value="COMPLETED" />
+  </component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/asset-catalog.iml" filepath="$PROJECT_DIR$/.idea/asset-catalog.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/.prettierignore

@@ -0,0 +1,5 @@
+node_modules
+lib
+testOut
+*.min.js
+package-lock.json

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+    "semi": true,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "printWidth": 100,
+    "tabWidth": 4
+}

package/lib/generate-file-catalog.d.ts

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

package/lib/generate-file-catalog.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const utils_1 = require("./utils");
+const path_1 = require("path");
+const yargs_1 = __importDefault(require("yargs/yargs"));
+const helpers_1 = require("yargs/helpers");
+const tree_1 = require("./tree");
+function importName(assetDir, file) {
+    let importName = file;
+    importName = (0, path_1.resolve)(file);
+    const prefix = (0, path_1.resolve)(assetDir);
+    const prefixIndex = importName.indexOf(prefix);
+    if (prefixIndex >= 0) {
+        importName = importName.slice(prefixIndex + prefix.length);
+    }
+    importName = (0, utils_1.sanitize)(importName);
+    return importName;
+}
+function generatedTemplateInterface(tree, indent = '') {
+    let generated = '{\n';
+    for (const [subname, item] of tree.entries()) {
+        if (item instanceof Map) {
+            const generatedSub = generatedTemplateInterface(item, indent + '    ');
+            generated += indent + `    ${(0, utils_1.lowerCamelize)(subname)}: ${generatedSub}`;
+        }
+        else {
+            const name = (0, path_1.basename)(subname);
+            generated += indent + `    ${(0, utils_1.lowerCamelize)(name)}: T,\n`;
+        }
+    }
+    generated += indent + '}\n';
+    return generated;
+}
+async function generatedCreateCatalogFunction(assetDir, tree) {
+    async function rec(tree, indent = '') {
+        let generated = '{\n';
+        for (const [subname, item] of tree.entries()) {
+            if (item instanceof Map) {
+                const generatedSub = await rec(item, indent + '    ');
+                generated += indent + `    ${(0, utils_1.lowerCamelize)(subname)}: ${generatedSub},\n`;
+            }
+            else {
+                const stats = await fs_1.promises.stat(item);
+                const name = (0, path_1.basename)(subname);
+                generated +=
+                    indent +
+                        `    ${(0, utils_1.lowerCamelize)(name)}: createItem(expand(
+                    ${importName(assetDir, item)},
+                    ${stats.size},
+                    '${item}',
+                )),\n`;
+            }
+        }
+        generated += indent + '}';
+        return generated;
+    }
+    let generated = '';
+    generated +=
+        'export function createFileCatalog<T>(createItem: (opts: CreateItemOptions) => T): FileCatalog<T> {\n';
+    generated += `    return ${await rec(tree, '   ')};\n`;
+    generated += '}\n';
+    return generated;
+}
+function generateExpandFunction() {
+    let generated = '';
+    generated +=
+        'function expand(path: string, size: number, originalPath: string): CreateItemOptions {\n';
+    generated += `    return { path, size, originalPath };\n`;
+    generated += '}\n';
+    return generated;
+}
+function generateResolveFunction() {
+    let generated = '';
+    generated +=
+        'export function resolveFromCatalog<T>(catalog: FileCatalog<T>, path: string[]): T {\n';
+    generated += '    let current: any = catalog;\n';
+    generated += `    for (const component of path) {\n`;
+    generated += `        if (!(component in current)) throw new Error('Unresolvable catalog path: ' + path.join('.'));\n`;
+    generated += `        current = current[component];\n`;
+    generated += `    }\n`;
+    generated += `    return current as T;\n`;
+    generated += '}\n';
+    return generated;
+}
+async function main() {
+    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)).options({
+        outFile: {
+            type: 'string',
+            default: 'files.ts',
+            alias: 'o',
+            describe: 'Directory to generate the files into',
+        },
+        dir: {
+            type: 'string',
+            default: '.',
+            alias: 'd',
+            describe: 'Asset directory where all the PNGs are located',
+        },
+    }).argv;
+    const filesRoot = argv.dir;
+    const generatedTs = argv.outFile;
+    try {
+        await fs_1.promises.rm(generatedTs, { recursive: true });
+    }
+    catch (e) { }
+    const files = await (0, utils_1.allFiles)(filesRoot);
+    const imports = [];
+    const tree = await (0, tree_1.generateTree)(argv.dir, files);
+    for (const file of files) {
+        const importPath = (0, path_1.relative)((0, path_1.dirname)(argv.outFile), file).replace(/\\/g, '/');
+        imports.push(`import ${importName(argv.dir, file)} from './${importPath}';`);
+    }
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += `export interface CreateItemOptions {
+        path: string;
+        size: number;
+        originalPath: string;
+    }\n\n`;
+    generatedFileContent += 'export type FileCatalog<T> = ' + generatedTemplateInterface(tree);
+    generatedFileContent += '\n';
+    generatedFileContent += generateExpandFunction();
+    generatedFileContent += '\n';
+    generatedFileContent += generateResolveFunction();
+    generatedFileContent += '\n';
+    generatedFileContent += await generatedCreateCatalogFunction(argv.dir, tree);
+    await fs_1.promises.writeFile(generatedTs, generatedFileContent);
+}
+main();

package/lib/generate-image-catalog.js

@@ -56,7 +56,9 @@ async function generatedCreateCatalogFunction(assetDir, tree, spritesheet) {
                 if (spriteData) {
                     spriteDataArr = `expandSpriteData(SpriteSheetPng, ${spriteData.x}, ${spriteData.y}, ${spriteData.width}, ${spriteData.height})`;
                 }
-                generated += indent + `    ${(0, utils_1.lowerCamelize)(withoutExt)}: createItem(expand(
+                generated +=
+                    indent +
+                        `    ${(0, utils_1.lowerCamelize)(withoutExt)}: createItem(expand(
                     ${importName(assetDir, item)},
                     ${dimensions.width},
                     ${dimensions.height},
@@ -69,24 +71,28 @@ async function generatedCreateCatalogFunction(assetDir, tree, spritesheet) {
         return generated;
     }
     let generated = '\n';
-    generated += 'export function createTextureCatalog<T>(createItem: (opts: CreateItemOptions) => T): TextureCatalog<T> {\n';
+    generated +=
+        'export function createTextureCatalog<T>(createItem: (opts: CreateItemOptions) => T): TextureCatalog<T> {\n';
     generated += `    return ${await rec(tree, '   ')};\n`;
     generated += '}\n';
     return generated;
 }
 function generateExpandFunction() {
     let generated = '\n';
-    generated += 'function expandSpriteData(sheet: string, x: number, y: number, width: number, height: number): SpriteData {\n';
+    generated +=
+        'function expandSpriteData(sheet: string, x: number, y: number, width: number, height: number): SpriteData {\n';
     generated += `    return { sheet, frame: { x, y, width, height } };\n`;
     generated += '}\n\n';
-    generated += 'function expand(path: string, width: number, height: number, size: number, spriteData: SpriteData | null = null): CreateItemOptions {\n';
+    generated +=
+        'function expand(path: string, width: number, height: number, size: number, spriteData: SpriteData | null = null): CreateItemOptions {\n';
     generated += `    return { path, width, height, size, spriteData };\n`;
     generated += '}\n';
     return generated;
 }
 function generateResolveFunction() {
     let generated = '\n';
-    generated += 'export function resolveFromCatalog<T>(catalog: TextureCatalog<T>, path: string[]): T {\n';
+    generated +=
+        'export function resolveFromCatalog<T>(catalog: TextureCatalog<T>, path: string[]): T {\n';
     generated += '    let current = catalog;\n';
     generated += `    for (const component of path) {\n`;
     generated += `        if (!(component in current)) throw new Error('Unresolvable catalog path: ' + path.join('.'));\n`;
@@ -127,7 +133,7 @@ async function createSpritesheet(tree, outFile, excludes) {
         const image = await (0, canvas_1.loadImage)(item.item.path);
         ctx.drawImage(image, item.x + padding, item.y + padding);
     }
-    const buffer = canvas.toBuffer("image/png");
+    const buffer = canvas.toBuffer('image/png');
     await fs_1.promises.writeFile(outFile, buffer);
     const resultMap = new Map();
     for (const item of packed.items) {
@@ -141,43 +147,41 @@ async function createSpritesheet(tree, outFile, excludes) {
     return resultMap;
 }
 async function main() {
-    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .options({
-        'outFile': {
+    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)).options({
+        outFile: {
             type: 'string',
             default: 'textures.ts',
             alias: 'o',
             describe: 'Directory to generate the files into',
         },
-        'assetDir': {
+        assetDir: {
             type: 'string',
             default: '.',
             alias: 'a',
             describe: 'Asset directory where all the PNGs are located',
         },
-        'outSpritesheet': {
+        outSpritesheet: {
             type: 'string',
             required: false,
             alias: 's',
             describe: 'Path to the generated spritesheet',
         },
-        'spritesheetExclude': {
+        spritesheetExclude: {
             type: 'string',
             array: true,
             required: false,
             alias: 'x',
             describe: 'Exclude certain paths from the spritesheet',
         },
-    })
-        .argv;
+    }).argv;
     const texturesRoot = argv.assetDir;
     const generatedTs = argv.outFile;
     try {
-        await fs_1.promises.rm(generatedTs, { 'recursive': true });
+        await fs_1.promises.rm(generatedTs, { recursive: true });
     }
     catch (e) { }
     const files = await (0, utils_1.allFiles)(texturesRoot);
-    const pngs = files.filter(file => (0, path_1.extname)(file) === '.png');
+    const pngs = files.filter((file) => (0, path_1.extname)(file) === '.png');
     const imports = [];
     const tree = await (0, tree_1.generateTree)(argv.assetDir, pngs);
     for (const png of pngs) {
@@ -210,7 +214,8 @@ async function main() {
         size: number;
         spriteData: SpriteData | null;
     }\n\n`;
-    generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
+    generatedFileContent +=
+        'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
     generatedFileContent += '\n\n';
     generatedFileContent += generateExpandFunction();
     generatedFileContent += generateResolveFunction();

package/lib/generate-sound-catalog.js

@@ -11,41 +11,40 @@ const helpers_1 = require("yargs/helpers");
 const path_1 = require("path");
 const audiosprite_1 = __importDefault(require("audiosprite"));
 async function main() {
-    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .options({
-        'outFile': {
+    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv)).options({
+        outFile: {
             type: 'string',
             default: '.',
             alias: 'o',
             describe: 'Directory to generate the files into',
         },
-        'assetDir': {
+        assetDir: {
             type: 'string',
             default: '.',
             alias: 'a',
             describe: 'Asset directory where all the PNGs are located',
         },
-        'wav': {
+        wav: {
             type: 'boolean',
             default: false,
             describe: 'Include .wav files',
         },
-        'ogg': {
+        ogg: {
             type: 'boolean',
             default: true,
             describe: 'Include .ogg files',
         },
-        'mp3': {
+        mp3: {
             type: 'boolean',
             default: true,
             describe: 'Include .mp3 files',
         },
-        'outSpritesheet': {
+        outSpritesheet: {
             type: 'string',
             required: false,
             describe: 'Path to the exported spritesheet (without the extension)',
         },
-        'spritesheetExcludeCategory': {
+        spritesheetExcludeCategory: {
             type: 'string',
             array: true,
             required: false,
@@ -53,8 +52,7 @@ async function main() {
             default: [],
             describe: 'Exclude certain categories from the spritesheet',
         },
-    })
-        .argv;
+    }).argv;
     const extensions = [];
     if (argv.mp3)
         extensions.push('.mp3');
@@ -64,12 +62,13 @@ async function main() {
         extensions.push('.wav');
     const generatedTs = argv.outFile;
     try {
-        await fs_1.promises.rm(generatedTs, { 'recursive': true });
+        await fs_1.promises.rm(generatedTs, { recursive: true });
     }
     catch (e) { }
     const files = await (0, utils_1.allFiles)(argv.assetDir);
-    const sounds = files.filter(file => extensions.indexOf((0, path_1.extname)(file)) >= 0)
-        .filter(file => (0, path_1.basename)(file, (0, path_1.extname)(file)) !== 'sprites');
+    const sounds = files
+        .filter((file) => extensions.indexOf((0, path_1.extname)(file)) >= 0)
+        .filter((file) => (0, path_1.basename)(file, (0, path_1.extname)(file)) !== 'sprites');
     const defs = new Map();
     for (const sound of sounds) {
         const category = (0, utils_1.categoryPath)(argv.assetDir, sound).join('_');
@@ -100,9 +99,9 @@ async function main() {
             for (const filenameWithoutExt of defs.get(category).keys()) {
                 const fileSet = defs.get(category).get(filenameWithoutExt);
                 const files = Array.from(fileSet);
-                const pickedFile = files.find(file => (0, path_1.extname)(file) === '.wav') ||
-                    files.find(file => (0, path_1.extname)(file) === '.ogg') ||
-                    files.find(file => (0, path_1.extname)(file) === '.mp3');
+                const pickedFile = files.find((file) => (0, path_1.extname)(file) === '.wav') ||
+                    files.find((file) => (0, path_1.extname)(file) === '.ogg') ||
+                    files.find((file) => (0, path_1.extname)(file) === '.mp3');
                 if (!pickedFile) {
                     throw new Error('Unable to pick file for sprite in ' + category);
                 }
@@ -113,7 +112,7 @@ async function main() {
             const options = {
                 output: argv.outSpritesheet,
                 format: 'howler',
-                export: extensions.map(ext => ext.slice(1)).join(','),
+                export: extensions.map((ext) => ext.slice(1)).join(','),
             };
             (0, audiosprite_1.default)(Array.from(spriteSounds.values()), options, (err, res) => {
                 if (err) {
@@ -140,7 +139,7 @@ async function main() {
     definitions.push(soundDefinition);
     if (argv.outSpritesheet) {
         const modifiedSpritesheetJson = { ...spritesheetJson };
-        modifiedSpritesheetJson.urls = extensions.map(ext => argv.outSpritesheet + ext);
+        modifiedSpritesheetJson.urls = extensions.map((ext) => argv.outSpritesheet + ext);
         let spriteSheetFunc = 'export function sound_spritesheet() {\n';
         spriteSheetFunc += '    return {\n';
         spriteSheetFunc += '        urls: [\n';

package/lib/tree.js

@@ -13,7 +13,7 @@ async function generateTree(dir, files) {
             }
             subtree = subtree.get(category);
         }
-        subtree.set((0, path_1.basename)(file).replace('.file', ''), file);
+        subtree.set((0, path_1.basename)(file), file);
     }
     return tree;
 }

package/lib/utils.js

@@ -26,11 +26,14 @@ function sanitize(string) {
 }
 exports.sanitize = sanitize;
 function camelize(str) {
-    return str.split(/[^a-z0-9]/gi).map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+    return str
+        .split(/[^a-z0-9]/gi)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
 }
 exports.camelize = camelize;
 function lowerCamelize(str) {
-    const camelized = module.exports.camelize(str);
+    const camelized = camelize(str);
     return camelized.slice(0, 1).toLowerCase() + camelized.slice(1);
 }
 exports.lowerCamelize = lowerCamelize;
@@ -39,7 +42,7 @@ function categoryPath(assetDir, filepath) {
     const trimmedDir = (0, path_1.relative)(assetDir, dir);
     return trimmedDir
         .split(/[\/\\]/g)
-        .map(component => lowerCamelize(component))
-        .filter(component => component.length > 0);
+        .map((component) => lowerCamelize(component))
+        .filter((component) => component.length > 0);
 }
 exports.categoryPath = categoryPath;

package/package.json

@@ -1,33 +1,44 @@
 {
-  "name": "@remvst/asset-catalog",
-  "version": "1.4.0",
-  "description": "",
-  "bin": {
-    "generate-image-catalog": "./lib/generate-image-catalog.js",
-    "generate-sound-catalog": "./lib/generate-sound-catalog.js"
-  },
-  "scripts": {
-    "build": "rm -rf lib && tsc && chmod +x lib/generate-image-catalog.js lib/generate-sound-catalog.js",
-    "test:images": "ts-node src/generate-image-catalog.ts --assetDir=./testData --outFile=testOut/images.ts --outSpritesheet=testOut/spritesheet.png",
-    "test:sounds": "ts-node src/generate-sound-catalog.ts --assetDir=./testData/sounds --outFile=testOut/sounds.ts --outSpritesheet=testData/sounds/sprites --spritesheetExcludeCategory=jump",
-    "test": "npm run test:images && npm run test:sounds",
-    "prepublishOnly": "npm i && npm run build"
-  },
-  "author": "Rémi Vansteelandt",
-  "license": "UNLICENSED",
-  "dependencies": {
-    "audiosprite": "^0.7.2",
-    "bin-pack": "^1.0.2",
-    "canvas": "^2.11.2",
-    "image-size": "^1.0.2",
-    "yargs": "^17.7.2"
-  },
-  "devDependencies": {
-    "@types/audiosprite": "^0.7.3",
-    "@types/bin-pack": "^1.0.3",
-    "@types/node": "^18.11.5",
-    "@types/yargs": "^17.0.32",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.2.2"
-  }
+    "name": "@remvst/asset-catalog",
+    "version": "1.6.0",
+    "description": "",
+    "bin": {
+        "generate-image-catalog": "./lib/generate-image-catalog.js",
+        "generate-sound-catalog": "./lib/generate-sound-catalog.js",
+        "generate-file-catalog": "./lib/generate-file-catalog.js"
+    },
+    "scripts": {
+        "build": "rm -rf lib && tsc && chmod +x lib/generate-image-catalog.js lib/generate-sound-catalog.js",
+        "test:images": "ts-node src/generate-image-catalog.ts --assetDir=./testData --outFile=testOut/images.ts --outSpritesheet=testOut/spritesheet.png",
+        "test:sounds": "ts-node src/generate-sound-catalog.ts --assetDir=./testData/sounds --outFile=testOut/sounds.ts --outSpritesheet=testData/sounds/sprites --spritesheetExcludeCategory=jump",
+        "test:files": "ts-node src/generate-file-catalog.ts --dir=./testData --outFile=testOut/files.ts",
+        "prettier:check": "prettier --check .",
+        "prettier:write": "prettier --write .",
+        "test": "npm run prettier:check && npm run test:images && npm run test:sounds && npm run test:files",
+        "prepublishOnly": "npm i && npm run build",
+        "prepare": "husky"
+    },
+    "author": "Rémi Vansteelandt",
+    "license": "UNLICENSED",
+    "dependencies": {
+        "audiosprite": "^0.7.2",
+        "bin-pack": "^1.0.2",
+        "canvas": "^2.11.2",
+        "image-size": "^1.0.2",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "@types/audiosprite": "^0.7.3",
+        "@types/bin-pack": "^1.0.3",
+        "@types/node": "^18.11.5",
+        "@types/yargs": "^17.0.32",
+        "husky": "^9.1.7",
+        "lint-staged": "^16.3.0",
+        "prettier": "^3.8.1",
+        "ts-node": "^10.9.1",
+        "typescript": "^5.2.2"
+    },
+    "lint-staged": {
+        "*.{js,ts,json,md}": "prettier --write"
+    }
 }

package/src/generate-file-catalog.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import { allFiles, lowerCamelize, sanitize } from './utils';
+import { basename, dirname, extname, relative, resolve } from 'path';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import { generateTree, Tree } from './tree';
+
+function importName(assetDir: string, file: string): string {
+    let importName = file;
+    importName = resolve(file);
+
+    const prefix = resolve(assetDir);
+    const prefixIndex = importName.indexOf(prefix);
+    if (prefixIndex >= 0) {
+        importName = importName.slice(prefixIndex + prefix.length);
+    }
+
+    importName = sanitize(importName);
+    return importName;
+}
+
+function generatedTemplateInterface(tree: Tree, indent: string = ''): string {
+    let generated = '{\n';
+    for (const [subname, item] of tree.entries()) {
+        if (item instanceof Map) {
+            const generatedSub = generatedTemplateInterface(item, indent + '    ');
+            generated += indent + `    ${lowerCamelize(subname)}: ${generatedSub}`;
+        } else {
+            const name = basename(subname);
+            generated += indent + `    ${lowerCamelize(name)}: T,\n`;
+        }
+    }
+    generated += indent + '}\n';
+    return generated;
+}
+
+async function generatedCreateCatalogFunction(assetDir: string, tree: Tree): Promise<string> {
+    async function rec(tree: Tree, indent: string = '') {
+        let generated = '{\n';
+        for (const [subname, item] of tree.entries()) {
+            if (item instanceof Map) {
+                const generatedSub = await rec(item, indent + '    ');
+                generated += indent + `    ${lowerCamelize(subname)}: ${generatedSub},\n`;
+            } else {
+                const stats = await fs.stat(item);
+                const name = basename(subname);
+
+                generated +=
+                    indent +
+                    `    ${lowerCamelize(name)}: createItem(expand(
+                    ${importName(assetDir, item)},
+                    ${stats.size},
+                    '${item}',
+                )),\n`;
+            }
+        }
+        generated += indent + '}';
+        return generated;
+    }
+
+    let generated = '';
+    generated +=
+        'export function createFileCatalog<T>(createItem: (opts: CreateItemOptions) => T): FileCatalog<T> {\n';
+    generated += `    return ${await rec(tree, '   ')};\n`;
+    generated += '}\n';
+    return generated;
+}
+
+function generateExpandFunction() {
+    let generated = '';
+    generated +=
+        'function expand(path: string, size: number, originalPath: string): CreateItemOptions {\n';
+    generated += `    return { path, size, originalPath };\n`;
+    generated += '}\n';
+    return generated;
+}
+
+function generateResolveFunction() {
+    let generated = '';
+    generated +=
+        'export function resolveFromCatalog<T>(catalog: FileCatalog<T>, path: string[]): T {\n';
+    generated += '    let current: any = catalog;\n';
+    generated += `    for (const component of path) {\n`;
+    generated += `        if (!(component in current)) throw new Error('Unresolvable catalog path: ' + path.join('.'));\n`;
+    generated += `        current = current[component];\n`;
+    generated += `    }\n`;
+    generated += `    return current as T;\n`;
+    generated += '}\n';
+    return generated;
+}
+
+async function main() {
+    const argv = await yargs(hideBin(process.argv)).options({
+        outFile: {
+            type: 'string',
+            default: 'files.ts',
+            alias: 'o',
+            describe: 'Directory to generate the files into',
+        },
+        dir: {
+            type: 'string',
+            default: '.',
+            alias: 'd',
+            describe: 'Asset directory where all the PNGs are located',
+        },
+    }).argv;
+
+    const filesRoot = argv.dir;
+    const generatedTs = argv.outFile;
+    try {
+        await fs.rm(generatedTs, { recursive: true });
+    } catch (e) {}
+
+    const files = await allFiles(filesRoot);
+
+    const imports = [];
+    const tree = await generateTree(argv.dir, files);
+
+    for (const file of files) {
+        const importPath = relative(dirname(argv.outFile), file).replace(/\\/g, '/');
+        imports.push(`import ${importName(argv.dir, file)} from './${importPath}';`);
+    }
+
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += `export interface CreateItemOptions {
+        path: string;
+        size: number;
+        originalPath: string;
+    }\n\n`;
+    generatedFileContent += 'export type FileCatalog<T> = ' + generatedTemplateInterface(tree);
+    generatedFileContent += '\n';
+    generatedFileContent += generateExpandFunction();
+    generatedFileContent += '\n';
+    generatedFileContent += generateResolveFunction();
+    generatedFileContent += '\n';
+    generatedFileContent += await generatedCreateCatalogFunction(argv.dir, tree);
+
+    await fs.writeFile(generatedTs, generatedFileContent);
+}
+
+main();

package/src/generate-image-catalog.ts

@@ -10,7 +10,7 @@ import { Tree, generateTree } from './tree';
 import pack from 'bin-pack';
 import { createCanvas, loadImage } from 'canvas';
 
-type Rectangle = {x: number, y: number, width: number, height: number};
+type Rectangle = { x: number; y: number; width: number; height: number };
 type SpritesheetResult = Map<string, Rectangle>;
 
 function importName(assetDir: string, png: string): string {
@@ -42,7 +42,11 @@ function generatedTemplateInterface(tree: Tree, name: string, indent: string = '
     return generated;
 }
 
-async function generatedCreateCatalogFunction(assetDir: string, tree: Tree, spritesheet: SpritesheetResult | null): Promise<string> {
+async function generatedCreateCatalogFunction(
+    assetDir: string,
+    tree: Tree,
+    spritesheet: SpritesheetResult | null,
+): Promise<string> {
     async function rec(tree: Tree, indent: string = '') {
         let generated = '{\n';
         for (const [subname, item] of tree.entries()) {
@@ -55,11 +59,13 @@ async function generatedCreateCatalogFunction(assetDir: string, tree: Tree, spri
                 const withoutExt = basename(subname, extname(subname));
                 const spriteData = spritesheet?.get(resolve(item)) || null;
                 let spriteDataArr: string | null = null;
-                if (spriteData)  {
+                if (spriteData) {
                     spriteDataArr = `expandSpriteData(SpriteSheetPng, ${spriteData.x}, ${spriteData.y}, ${spriteData.width}, ${spriteData.height})`;
                 }
 
-                generated += indent + `    ${lowerCamelize(withoutExt)}: createItem(expand(
+                generated +=
+                    indent +
+                    `    ${lowerCamelize(withoutExt)}: createItem(expand(
                     ${importName(assetDir, item)},
                     ${dimensions.width},
                     ${dimensions.height},
@@ -73,7 +79,8 @@ async function generatedCreateCatalogFunction(assetDir: string, tree: Tree, spri
     }
 
     let generated = '\n';
-    generated += 'export function createTextureCatalog<T>(createItem: (opts: CreateItemOptions) => T): TextureCatalog<T> {\n';
+    generated +=
+        'export function createTextureCatalog<T>(createItem: (opts: CreateItemOptions) => T): TextureCatalog<T> {\n';
     generated += `    return ${await rec(tree, '   ')};\n`;
     generated += '}\n';
     return generated;
@@ -81,10 +88,12 @@ async function generatedCreateCatalogFunction(assetDir: string, tree: Tree, spri
 
 function generateExpandFunction() {
     let generated = '\n';
-    generated += 'function expandSpriteData(sheet: string, x: number, y: number, width: number, height: number): SpriteData {\n';
+    generated +=
+        'function expandSpriteData(sheet: string, x: number, y: number, width: number, height: number): SpriteData {\n';
     generated += `    return { sheet, frame: { x, y, width, height } };\n`;
     generated += '}\n\n';
-    generated += 'function expand(path: string, width: number, height: number, size: number, spriteData: SpriteData | null = null): CreateItemOptions {\n';
+    generated +=
+        'function expand(path: string, width: number, height: number, size: number, spriteData: SpriteData | null = null): CreateItemOptions {\n';
     generated += `    return { path, width, height, size, spriteData };\n`;
     generated += '}\n';
     return generated;
@@ -92,7 +101,8 @@ function generateExpandFunction() {
 
 function generateResolveFunction() {
     let generated = '\n';
-    generated += 'export function resolveFromCatalog<T>(catalog: TextureCatalog<T>, path: string[]): T {\n';
+    generated +=
+        'export function resolveFromCatalog<T>(catalog: TextureCatalog<T>, path: string[]): T {\n';
     generated += '    let current = catalog;\n';
     generated += `    for (const component of path) {\n`;
     generated += `        if (!(component in current)) throw new Error('Unresolvable catalog path: ' + path.join('.'));\n`;
@@ -103,8 +113,12 @@ function generateResolveFunction() {
     return generated;
 }
 
-async function createSpritesheet(tree: Tree, outFile: string, excludes: string[]): Promise<SpritesheetResult> {
-    const bins: (pack.Bin & {path: string})[] = [];
+async function createSpritesheet(
+    tree: Tree,
+    outFile: string,
+    excludes: string[],
+): Promise<SpritesheetResult> {
+    const bins: (pack.Bin & { path: string })[] = [];
 
     const padding = 1;
 
@@ -141,10 +155,10 @@ async function createSpritesheet(tree: Tree, outFile: string, excludes: string[]
         ctx.drawImage(image, item.x + padding, item.y + padding);
     }
 
-    const buffer = canvas.toBuffer("image/png");
+    const buffer = canvas.toBuffer('image/png');
     await fs.writeFile(outFile, buffer);
 
-    const resultMap = new Map<string, {x: number, y: number, width: number, height: number}>();
+    const resultMap = new Map<string, { x: number; y: number; width: number; height: number }>();
     for (const item of packed.items) {
         resultMap.set(item.item.path, {
             x: item.x + padding,
@@ -157,44 +171,42 @@ async function createSpritesheet(tree: Tree, outFile: string, excludes: string[]
 }
 
 async function main() {
-    const argv = await yargs(hideBin(process.argv))
-        .options({
-            'outFile': {
-                type: 'string',
-                default: 'textures.ts',
-                alias: 'o',
-                describe: 'Directory to generate the files into',
-            },
-            'assetDir': {
-                type: 'string',
-                default: '.',
-                alias: 'a',
-                describe: 'Asset directory where all the PNGs are located',
-            },
-            'outSpritesheet': {
-                type: 'string',
-                required: false,
-                alias: 's',
-                describe: 'Path to the generated spritesheet',
-            },
-            'spritesheetExclude': {
-                type: 'string',
-                array: true,
-                required: false,
-                alias: 'x',
-                describe: 'Exclude certain paths from the spritesheet',
-            },
-        })
-        .argv;
+    const argv = await yargs(hideBin(process.argv)).options({
+        outFile: {
+            type: 'string',
+            default: 'textures.ts',
+            alias: 'o',
+            describe: 'Directory to generate the files into',
+        },
+        assetDir: {
+            type: 'string',
+            default: '.',
+            alias: 'a',
+            describe: 'Asset directory where all the PNGs are located',
+        },
+        outSpritesheet: {
+            type: 'string',
+            required: false,
+            alias: 's',
+            describe: 'Path to the generated spritesheet',
+        },
+        spritesheetExclude: {
+            type: 'string',
+            array: true,
+            required: false,
+            alias: 'x',
+            describe: 'Exclude certain paths from the spritesheet',
+        },
+    }).argv;
 
     const texturesRoot = argv.assetDir;
     const generatedTs = argv.outFile;
     try {
-        await fs.rm(generatedTs, { 'recursive': true });
+        await fs.rm(generatedTs, { recursive: true });
     } catch (e) {}
 
     const files = await allFiles(texturesRoot);
-    const pngs = files.filter(file => extname(file) === '.png');
+    const pngs = files.filter((file) => extname(file) === '.png');
 
     const imports = [];
     const tree = await generateTree(argv.assetDir, pngs);
@@ -206,9 +218,16 @@ async function main() {
 
     let spritesheet: SpritesheetResult | null = null;
     if (argv.outSpritesheet) {
-        spritesheet = await createSpritesheet(tree, argv.outSpritesheet, argv.spritesheetExclude || []);
+        spritesheet = await createSpritesheet(
+            tree,
+            argv.outSpritesheet,
+            argv.spritesheetExclude || [],
+        );
 
-        const importPath = relative(dirname(argv.outFile), resolve(argv.outSpritesheet)).replace(/\\/g, '/');
+        const importPath = relative(dirname(argv.outFile), resolve(argv.outSpritesheet)).replace(
+            /\\/g,
+            '/',
+        );
         imports.push(`import SpriteSheetPng from './${importPath}';`);
     }
 
@@ -232,7 +251,8 @@ async function main() {
         size: number;
         spriteData: SpriteData | null;
     }\n\n`;
-    generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
+    generatedFileContent +=
+        'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
     generatedFileContent += '\n\n';
     generatedFileContent += generateExpandFunction();
     generatedFileContent += generateResolveFunction();

package/src/generate-sound-catalog.ts

@@ -8,50 +8,48 @@ import { dirname, extname, basename, relative, parse } from 'path';
 import audiosprite from 'audiosprite';
 
 async function main() {
-    const argv = await yargs(hideBin(process.argv))
-        .options({
-            'outFile': {
-                type: 'string',
-                default: '.',
-                alias: 'o',
-                describe: 'Directory to generate the files into',
-            },
-            'assetDir': {
-                type: 'string',
-                default: '.',
-                alias: 'a',
-                describe: 'Asset directory where all the PNGs are located',
-            },
-            'wav': {
-                type: 'boolean',
-                default: false,
-                describe: 'Include .wav files',
-            },
-            'ogg': {
-                type: 'boolean',
-                default: true,
-                describe: 'Include .ogg files',
-            },
-            'mp3': {
-                type: 'boolean',
-                default: true,
-                describe: 'Include .mp3 files',
-            },
-            'outSpritesheet': {
-                type: 'string',
-                required: false,
-                describe: 'Path to the exported spritesheet (without the extension)',
-            },
-            'spritesheetExcludeCategory': {
-                type: 'string',
-                array: true,
-                required: false,
-                alias: 'x',
-                default: [] as string[],
-                describe: 'Exclude certain categories from the spritesheet',
-            },
-        })
-        .argv;
+    const argv = await yargs(hideBin(process.argv)).options({
+        outFile: {
+            type: 'string',
+            default: '.',
+            alias: 'o',
+            describe: 'Directory to generate the files into',
+        },
+        assetDir: {
+            type: 'string',
+            default: '.',
+            alias: 'a',
+            describe: 'Asset directory where all the PNGs are located',
+        },
+        wav: {
+            type: 'boolean',
+            default: false,
+            describe: 'Include .wav files',
+        },
+        ogg: {
+            type: 'boolean',
+            default: true,
+            describe: 'Include .ogg files',
+        },
+        mp3: {
+            type: 'boolean',
+            default: true,
+            describe: 'Include .mp3 files',
+        },
+        outSpritesheet: {
+            type: 'string',
+            required: false,
+            describe: 'Path to the exported spritesheet (without the extension)',
+        },
+        spritesheetExcludeCategory: {
+            type: 'string',
+            array: true,
+            required: false,
+            alias: 'x',
+            default: [] as string[],
+            describe: 'Exclude certain categories from the spritesheet',
+        },
+    }).argv;
 
     const extensions: string[] = [];
     if (argv.mp3) extensions.push('.mp3');
@@ -60,13 +58,13 @@ async function main() {
 
     const generatedTs = argv.outFile;
     try {
-        await fs.rm(generatedTs, { 'recursive': true });
+        await fs.rm(generatedTs, { recursive: true });
     } catch (e) {}
 
-
     const files = await allFiles(argv.assetDir);
-    const sounds = files.filter(file => extensions.indexOf(extname(file)) >= 0)
-        .filter(file => basename(file, extname(file)) !== 'sprites');
+    const sounds = files
+        .filter((file) => extensions.indexOf(extname(file)) >= 0)
+        .filter((file) => basename(file, extname(file)) !== 'sprites');
 
     const defs = new Map<string, Map<string, Set<string>>>();
 
@@ -106,9 +104,10 @@ async function main() {
                 const fileSet = defs.get(category)!.get(filenameWithoutExt)!;
 
                 const files = Array.from(fileSet);
-                const pickedFile = files.find(file => extname(file) === '.wav') ||
-                    files.find(file => extname(file) === '.ogg') ||
-                    files.find(file => extname(file) === '.mp3');
+                const pickedFile =
+                    files.find((file) => extname(file) === '.wav') ||
+                    files.find((file) => extname(file) === '.ogg') ||
+                    files.find((file) => extname(file) === '.mp3');
                 if (!pickedFile) {
                     throw new Error('Unable to pick file for sprite in ' + category);
                 }
@@ -120,7 +119,7 @@ async function main() {
             const options: audiosprite.Option = {
                 output: argv.outSpritesheet,
                 format: 'howler',
-                export: extensions.map(ext => ext.slice(1)).join(','),
+                export: extensions.map((ext) => ext.slice(1)).join(','),
             };
 
             audiosprite(Array.from(spriteSounds.values()), options, (err, res) => {
@@ -150,18 +149,21 @@ async function main() {
 
     if (argv.outSpritesheet) {
         const modifiedSpritesheetJson = { ...spritesheetJson };
-        modifiedSpritesheetJson.urls = extensions.map(ext => argv.outSpritesheet + ext);
+        modifiedSpritesheetJson.urls = extensions.map((ext) => argv.outSpritesheet + ext);
 
         let spriteSheetFunc = 'export function sound_spritesheet() {\n';
         spriteSheetFunc += '    return {\n';
         spriteSheetFunc += '        urls: [\n';
 
-
         const idealOrder = ['.ogg', '.mp3', '.wav'];
-        const sortedExtensions = extensions.sort((a, b) => idealOrder.indexOf(a) - idealOrder.indexOf(b));
+        const sortedExtensions = extensions.sort(
+            (a, b) => idealOrder.indexOf(a) - idealOrder.indexOf(b),
+        );
         for (const extension of sortedExtensions) {
             const importName = 'sprites_' + extension.slice(1);
-            imports.push(`import ${importName} from '${relative(dirname(argv.outFile), argv.outSpritesheet + extension).replace(/\\/g, '/')}';`);
+            imports.push(
+                `import ${importName} from '${relative(dirname(argv.outFile), argv.outSpritesheet + extension).replace(/\\/g, '/')}';`,
+            );
 
             spriteSheetFunc += `            ${importName},\n`;
         }
@@ -201,7 +203,9 @@ async function main() {
             let totalFileSize = 0;
             for (const soundFile of files) {
                 const importName = sanitize(soundFile);
-                imports.push(`import ${importName} from '${relative(dirname(argv.outFile), soundFile).replace(/\\/g, '/')}';`);
+                imports.push(
+                    `import ${importName} from '${relative(dirname(argv.outFile), soundFile).replace(/\\/g, '/')}';`,
+                );
                 func += `                ${importName},\n`;
                 const stats = await fs.stat(soundFile);
                 totalFileSize += stats.size;

package/src/tree.ts

@@ -1,5 +1,5 @@
-import { basename } from "path";
-import { categoryPath } from "./utils";
+import { basename } from 'path';
+import { categoryPath } from './utils';
 
 export type Tree = Map<string, TreeOrPath>;
 export type TreeOrPath = Tree | string;
@@ -16,7 +16,7 @@ export async function generateTree(dir: string, files: string[]): Promise<Tree>
             subtree = subtree.get(category);
         }
 
-        subtree.set(basename(file).replace('.file', ''), file);
+        subtree.set(basename(file), file);
     }
 
     return tree;

package/src/utils.ts

@@ -26,11 +26,14 @@ export function sanitize(string: string): string {
 }
 
 export function camelize(str: string) {
-    return str.split(/[^a-z0-9]/gi).map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+    return str
+        .split(/[^a-z0-9]/gi)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
 }
 
 export function lowerCamelize(str: string): string {
-    const camelized = module.exports.camelize(str);
+    const camelized = camelize(str);
     return camelized.slice(0, 1).toLowerCase() + camelized.slice(1);
 }
 
@@ -39,6 +42,6 @@ export function categoryPath(assetDir: string, filepath: string): string[] {
     const trimmedDir = relative(assetDir, dir);
     return trimmedDir
         .split(/[\/\\]/g)
-        .map(component => lowerCamelize(component))
-        .filter(component => component.length > 0);
+        .map((component) => lowerCamelize(component))
+        .filter((component) => component.length > 0);
 }