@remvst/asset-catalog 1.0.0

package/README.md

@@ -0,0 +1,2 @@
+# asset-catalog
+

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

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

package/lib/generate-image-catalog.js

@@ -0,0 +1,106 @@
+#!/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 image_size_1 = __importDefault(require("image-size"));
+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, png) {
+    let importName = png;
+    importName = (0, path_1.resolve)(png);
+    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, name, indent = '') {
+    let generated = '{\n';
+    for (const [subname, item] of tree.entries()) {
+        if (item instanceof Map) {
+            const generatedSub = generatedTemplateInterface(item, subname, indent + '    ');
+            generated += indent + `    ${(0, utils_1.lowerCamelize)(subname)}: ${generatedSub}`;
+        }
+        else {
+            generated += indent + `    ${(0, utils_1.lowerCamelize)(subname)}: 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 dimensions = (0, image_size_1.default)(item);
+                const stats = await fs_1.promises.stat(item);
+                generated += indent + `    ${(0, utils_1.lowerCamelize)(subname)}: createItem({
+                    path: ${importName(assetDir, item)},
+                    width: ${dimensions.width},
+                    height: ${dimensions.height},
+                    size: ${stats.size},
+                }),\n`;
+            }
+        }
+        generated += indent + '}';
+        return generated;
+    }
+    let generated = '\n';
+    generated += 'export function createTextureCatalog<T>(createItem: (opts: {path: string, width: number, height: number, size: number}) => T): TextureCatalog<T> {\n';
+    generated += `    return ${await rec(tree, '   ')};\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: '.',
+            alias: 'o',
+            describe: 'Directory to generate the files into',
+        },
+        'assetDir': {
+            type: 'string',
+            default: './package.json',
+            alias: 'a',
+            describe: 'package.json file to use for the version',
+        }
+    })
+        .argv;
+    const texturesRoot = argv.assetDir;
+    const generatedTs = argv.outFile;
+    try {
+        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 imports = [];
+    const tree = await (0, tree_1.generateTree)(argv.assetDir, pngs);
+    for (const png of pngs) {
+        const importPath = (0, path_1.relative)((0, path_1.dirname)(argv.outFile), png).replace(/\\/g, '/');
+        imports.push(`import ${importName(argv.assetDir, png)} from './${importPath}';`);
+    }
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
+    generatedFileContent += '\n\n';
+    generatedFileContent += await generatedCreateCatalogFunction(argv.assetDir, tree);
+    await fs_1.promises.writeFile(generatedTs, generatedFileContent);
+}
+main();

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

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

package/lib/generate-sound-catalog.js

@@ -0,0 +1,124 @@
+#!/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 yargs_1 = __importDefault(require("yargs/yargs"));
+const helpers_1 = require("yargs/helpers");
+const path_1 = require("path");
+async function main() {
+    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': {
+            type: 'string',
+            default: './package.json',
+            alias: 'a',
+            describe: 'package.json file to use for the version',
+        },
+        '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',
+        },
+    })
+        .argv;
+    const extensions = [];
+    if (argv.mp3)
+        extensions.push('.mp3');
+    if (argv.ogg)
+        extensions.push('.ogg');
+    if (argv.wav)
+        extensions.push('.wav');
+    const generatedTs = argv.outFile;
+    try {
+        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);
+    console.log(sounds);
+    // const categories = new Map<string, Set<string>>();
+    const defs = new Map();
+    for (const sound of sounds) {
+        const category = (0, utils_1.categoryPath)(argv.assetDir, sound).join('_');
+        const ext = (0, path_1.extname)(sound);
+        const filenameWithoutExt = (0, path_1.basename)(sound, ext);
+        if (!defs.has(category)) {
+            defs.set(category, new Map());
+        }
+        if (!defs.get(category).has(filenameWithoutExt)) {
+            defs.get(category).set(filenameWithoutExt, new Set());
+        }
+        defs.get(category).get(filenameWithoutExt).add(sound);
+    }
+    console.log(defs);
+    const imports = [];
+    const definitions = [];
+    const funcs = [];
+    let soundDefinition = '';
+    soundDefinition += 'export class SoundDefinition {\n';
+    soundDefinition += '    constructor(\n';
+    soundDefinition += '        readonly basename: string,\n';
+    soundDefinition += '        readonly files: string[],\n';
+    soundDefinition += '        readonly averageFileSize: number,\n';
+    soundDefinition += '    ) {}\n';
+    soundDefinition += '}\n';
+    definitions.push(soundDefinition);
+    for (const category of defs.keys()) {
+        let func = `export function sound_${category}(): SoundDefinition[] {\n`;
+        func += `   return [\n`;
+        for (const filenameWithoutExt of defs.get(category).keys()) {
+            func += `        new SoundDefinition(\n`;
+            func += `            '${filenameWithoutExt}',\n`;
+            func += '            [\n';
+            const files = Array.from(defs.get(category).get(filenameWithoutExt));
+            const idealOrder = ['.ogg', '.mp3', '.wav'];
+            files.sort((a, b) => {
+                return idealOrder.indexOf((0, path_1.extname)(a)) - idealOrder.indexOf((0, path_1.extname)(b));
+            });
+            let totalFileSize = 0;
+            for (const soundFile of files) {
+                const importName = (0, utils_1.sanitize)(soundFile);
+                imports.push(`import ${importName} from '${(0, path_1.relative)((0, path_1.dirname)(argv.outFile), soundFile)}';`);
+                func += `                ${importName},\n`;
+                const stats = await fs_1.promises.stat(soundFile);
+                totalFileSize += stats.size;
+            }
+            const averageFileSize = Math.round(totalFileSize / files.length);
+            func += '            ],\n';
+            func += `            ${averageFileSize},\n`;
+            func += '        ),\n';
+        }
+        func += `   ];\n`;
+        func += `}`;
+        funcs.push(func);
+    }
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += definitions.join('\n\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += funcs.join('\n\n');
+    generatedFileContent += '\n';
+    await fs_1.promises.writeFile(generatedTs, generatedFileContent);
+}
+main();

package/lib/tree.d.ts

@@ -0,0 +1,3 @@
+export type Tree = Map<string, TreeOrPath>;
+export type TreeOrPath = Tree | string;
+export declare function generateTree(dir: string, files: string[]): Promise<Tree>;

package/lib/tree.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTree = void 0;
+const utils_1 = require("./utils");
+async function generateTree(dir, files) {
+    const tree = new Map();
+    for (const file of files) {
+        let subtree = tree;
+        for (const category of (0, utils_1.categoryPath)(dir, file)) {
+            if (!subtree.has(category)) {
+                subtree.set(category, new Map());
+            }
+            subtree = subtree.get(category);
+        }
+        subtree.set((0, utils_1.basename)(file).replace('.file', ''), file);
+    }
+    return tree;
+}
+exports.generateTree = generateTree;

package/lib/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function allFiles(path: string): Promise<string[]>;
+export declare function basename(path: string): string;
+export declare function sanitize(string: string): string;
+export declare function execShellCommand(cmd: string): Promise<string>;
+export declare function toUpperSnakeCase(str: string): string;
+export declare function camelize(str: string): string;
+export declare function lowerCamelize(str: string): string;
+export declare function categoryPath(assetDir: string, png: string): string[];

package/lib/utils.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categoryPath = exports.lowerCamelize = exports.camelize = exports.toUpperSnakeCase = exports.execShellCommand = exports.sanitize = exports.basename = exports.allFiles = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function allFiles(path) {
+    const files = await fs_1.promises.readdir(path);
+    const res = [];
+    for (const file of files) {
+        const filePath = `${path}/${file}`;
+        const stat = await fs_1.promises.lstat(filePath);
+        if (stat.isDirectory()) {
+            for (const subfile of await allFiles(filePath)) {
+                res.push(subfile);
+            }
+        }
+        else {
+            res.push(filePath);
+        }
+    }
+    return res;
+}
+exports.allFiles = allFiles;
+function basename(path) {
+    const filename = path.slice(path.lastIndexOf('/') + 1);
+    return filename.slice(0, filename.lastIndexOf('.'));
+}
+exports.basename = basename;
+function sanitize(string) {
+    return string.replace(/[^a-zA-Z0-9]/g, '_');
+}
+exports.sanitize = sanitize;
+function execShellCommand(cmd) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout ? stdout : stderr);
+        });
+    });
+}
+exports.execShellCommand = execShellCommand;
+function toUpperSnakeCase(str) {
+    return str.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+}
+exports.toUpperSnakeCase = toUpperSnakeCase;
+function camelize(str) {
+    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);
+    return camelized.slice(0, 1).toLowerCase() + camelized.slice(1);
+}
+exports.lowerCamelize = lowerCamelize;
+function categoryPath(assetDir, png) {
+    const dir = (0, path_1.dirname)(png);
+    const trimmedDir = (0, path_1.relative)(assetDir, dir);
+    return trimmedDir
+        .split('/')
+        .map(component => lowerCamelize(component))
+        .filter(component => component.length > 0);
+}
+exports.categoryPath = categoryPath;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@remvst/asset-catalog",
+  "version": "1.0.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",
+    "test:images": "ts-node src/generate-image-catalog.ts --assetDir=./testData --outFile=testOut/images.ts",
+    "test:sounds": "ts-node src/generate-sound-catalog.ts --assetDir=./testData/sounds --outFile=testOut/sounds.ts",
+    "test": "npm run test:images && npm run test:sounds"
+  },
+  "author": "Rémi Vansteelandt",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "image-size": "^1.0.2",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.5",
+    "@types/yargs": "^17.0.32",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.2"
+  }
+}

package/src/generate-image-catalog.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import sizeOf from 'image-size';
+import { sanitize, allFiles, lowerCamelize } from './utils';
+import { resolve, relative, dirname, extname } from 'path';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import { Tree, generateTree } from './tree';
+
+function importName(assetDir: string, png: string): string {
+    let importName = png;
+    importName = resolve(png);
+
+    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, name: string, indent: string = ''): string {
+    let generated = '{\n';
+    for (const [subname, item] of tree.entries()) {
+        if (item instanceof Map) {
+            const generatedSub = generatedTemplateInterface(item, subname, indent + '    ');
+            generated += indent + `    ${lowerCamelize(subname)}: ${generatedSub}`;
+        } else {
+            generated += indent + `    ${lowerCamelize(subname)}: 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 dimensions = sizeOf(item);
+                const stats = await fs.stat(item);
+                generated += indent + `    ${lowerCamelize(subname)}: createItem({
+                    path: ${importName(assetDir, item)},
+                    width: ${dimensions.width},
+                    height: ${dimensions.height},
+                    size: ${stats.size},
+                }),\n`;
+            }
+        }
+        generated += indent + '}';
+        return generated;
+    }
+
+    let generated = '\n';
+    generated += 'export function createTextureCatalog<T>(createItem: (opts: {path: string, width: number, height: number, size: number}) => T): TextureCatalog<T> {\n';
+    generated += `    return ${await rec(tree, '   ')};\n`;
+    generated += '}\n';
+    return generated;
+}
+
+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: './package.json', 
+                alias: 'a', 
+                describe: 'package.json file to use for the version',
+            }
+        })
+        .argv;
+
+    const texturesRoot = argv.assetDir;
+    const generatedTs = argv.outFile;
+    try {
+        await fs.rm(generatedTs, { 'recursive': true });
+    } catch (e) {}
+
+    const files = await allFiles(texturesRoot);
+    const pngs = files.filter(file => extname(file) === '.png');
+
+    const imports = [];
+    const tree = await generateTree(argv.assetDir, pngs);
+
+    for (const png of pngs) {
+        const importPath = relative(dirname(argv.outFile), png).replace(/\\/g, '/');
+        imports.push(`import ${importName(argv.assetDir, png)} from './${importPath}';`);
+    }
+
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
+    generatedFileContent += '\n\n';
+    generatedFileContent += await generatedCreateCatalogFunction(argv.assetDir, tree);
+
+    await fs.writeFile(generatedTs, generatedFileContent);
+}
+
+main();

package/src/generate-sound-catalog.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'fs';
+import { sanitize, allFiles, categoryPath } from './utils';
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import { dirname, extname, basename, relative } from 'path';
+
+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: './package.json', 
+                alias: 'a', 
+                describe: 'package.json file to use for the version',
+            },
+            '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',
+            },
+        })
+        .argv;
+
+    const extensions: string[] = [];
+    if (argv.mp3) extensions.push('.mp3');
+    if (argv.ogg) extensions.push('.ogg');
+    if (argv.wav) extensions.push('.wav');
+
+    const generatedTs = argv.outFile;
+    try {
+        await fs.rm(generatedTs, { 'recursive': true });
+    } catch (e) {}
+
+
+    const files = await allFiles(argv.assetDir);
+    const sounds = files.filter(file => extensions.indexOf(extname(file)) >= 0);
+
+    const defs = new Map<string, Map<string, Set<string>>>();
+
+    for (const sound of sounds) {
+        const category = categoryPath(argv.assetDir, sound).join('_');
+        const ext = extname(sound);
+        const filenameWithoutExt = basename(sound, ext);
+
+        if (!defs.has(category)) {
+            defs.set(category, new Map());
+        }
+
+        if (!defs.get(category)!.has(filenameWithoutExt)) {
+            defs.get(category)!.set(filenameWithoutExt, new Set());
+        }
+
+        defs.get(category)!.get(filenameWithoutExt)!.add(sound);
+    }
+
+    console.log(defs);
+
+    const imports = [];
+    const definitions = [];
+    const funcs = [];
+
+    let soundDefinition = '';
+    soundDefinition += 'export class SoundDefinition {\n';
+    soundDefinition += '    constructor(\n';
+    soundDefinition += '        readonly basename: string,\n';
+    soundDefinition += '        readonly files: string[],\n';
+    soundDefinition += '        readonly averageFileSize: number,\n';
+    soundDefinition += '    ) {}\n';
+    soundDefinition += '}\n';
+    definitions.push(soundDefinition);
+
+    for (const category of defs.keys()) {
+        let func = `export function sound_${category}(): SoundDefinition[] {\n`;
+        func += `   return [\n`;
+
+        for (const filenameWithoutExt of defs.get(category)!.keys()) {
+            func += `        new SoundDefinition(\n`;
+            func += `            '${filenameWithoutExt}',\n`;
+            func += '            [\n';
+
+            const files = Array.from(defs.get(category)!.get(filenameWithoutExt)!);
+            const idealOrder = ['.ogg', '.mp3', '.wav'];
+            files.sort((a, b) => {
+                return idealOrder.indexOf(extname(a)) - idealOrder.indexOf(extname(b));
+            });
+
+            let totalFileSize = 0;
+            for (const soundFile of files) {
+                const importName = sanitize(soundFile);
+                imports.push(`import ${importName} from '${relative(dirname(argv.outFile), soundFile)}';`);
+                func += `                ${importName},\n`;
+                const stats = await fs.stat(soundFile);
+                totalFileSize += stats.size;
+            }
+
+            const averageFileSize = Math.round(totalFileSize / files.length);
+
+            func += '            ],\n';
+            func += `            ${averageFileSize},\n`;
+            func += '        ),\n';
+        }
+
+        func += `   ];\n`;
+        func += `}`;
+
+        funcs.push(func);
+    }
+
+    let generatedFileContent = '';
+    generatedFileContent += imports.join('\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += definitions.join('\n\n');
+    generatedFileContent += '\n\n';
+    generatedFileContent += funcs.join('\n\n');
+    generatedFileContent += '\n';
+
+    await fs.writeFile(generatedTs, generatedFileContent);
+}
+
+main();

package/src/tree.ts

@@ -0,0 +1,23 @@
+import { basename } from "path";
+import { categoryPath } from "./utils";
+
+export type Tree = Map<string, TreeOrPath>;
+export type TreeOrPath = Tree | string;
+
+export async function generateTree(dir: string, files: string[]): Promise<Tree> {
+    const tree = new Map();
+
+    for (const file of files) {
+        let subtree = tree;
+        for (const category of categoryPath(dir, file)) {
+            if (!subtree.has(category)) {
+                subtree.set(category, new Map());
+            }
+            subtree = subtree.get(category);
+        }
+
+        subtree.set(basename(file).replace('.file', ''), file);
+    }
+
+    return tree;
+}

package/src/utils.ts

@@ -0,0 +1,45 @@
+import { promises as fs } from 'fs';
+import { dirname, relative } from 'path';
+
+export async function allFiles(path: string): Promise<string[]> {
+    const files = await fs.readdir(path);
+
+    const res: string[] = [];
+    for (const file of files) {
+        const filePath = `${path}/${file}`;
+
+        const stat = await fs.lstat(filePath);
+        if (stat.isDirectory()) {
+            for (const subfile of await allFiles(filePath)) {
+                res.push(subfile);
+            }
+        } else {
+            res.push(filePath);
+        }
+    }
+
+    return res;
+}
+
+export function sanitize(string: string): string {
+    return string.replace(/[^a-zA-Z0-9]/g, '_');   
+}
+
+export function camelize(str: string) {
+    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);
+    return camelized.slice(0, 1).toLowerCase() + camelized.slice(1);
+}
+
+
+export function categoryPath(assetDir: string, png: string): string[] {
+    const dir = dirname(png);
+    const trimmedDir = relative(assetDir, dir);
+    return trimmedDir
+        .split('/')
+        .map(component => lowerCamelize(component))
+        .filter(component => component.length > 0);
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "target": "es2020",
+        "module": "commonjs",
+        "declaration": true,
+        "strict": true,
+        "esModuleInterop": true,
+        "allowJs": false,
+        "outDir": "./lib",
+        "skipLibCheck": true
+    },
+    "include": ["./src/**/*"],
+    "exclude": ["node_modules"]
+}