@remvst/asset-catalog 1.3.1 → 1.5.0

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.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/lib/generate-file-catalog.d.ts

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

package/lib/generate-file-catalog.js

@@ -0,0 +1,131 @@
+#!/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},
+                )),\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): CreateItemOptions {\n';
+    generated += `    return { path, size };\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;
+    }\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

@@ -84,6 +84,18 @@ function generateExpandFunction() {
     generated += '}\n';
     return generated;
 }
+function generateResolveFunction() {
+    let generated = '\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`;
+    generated += `        current = current[component];\n`;
+    generated += `    }\n`;
+    generated += `    return current as T;\n`;
+    generated += '}\n';
+    return generated;
+}
 async function createSpritesheet(tree, outFile, excludes) {
     const bins = [];
     const padding = 1;
@@ -196,11 +208,12 @@ async function main() {
         width: number;
         height: number;
         size: number;
-        spriteData: SpriteData | null;   
+        spriteData: SpriteData | null;
     }\n\n`;
     generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
     generatedFileContent += '\n\n';
     generatedFileContent += generateExpandFunction();
+    generatedFileContent += generateResolveFunction();
     generatedFileContent += await generatedCreateCatalogFunction(argv.assetDir, tree, spritesheet);
     await fs_1.promises.writeFile(generatedTs, generatedFileContent);
 }

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

@@ -30,7 +30,7 @@ function camelize(str) {
 }
 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;

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "@remvst/asset-catalog",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "",
   "bin": {
     "generate-image-catalog": "./lib/generate-image-catalog.js",
-    "generate-sound-catalog": "./lib/generate-sound-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": "npm run test:images && npm run test:sounds",
+    "test:files": "ts-node src/generate-file-catalog.ts --dir=./testData --outFile=testOut/files.ts",
+    "test": "npm run test:images && npm run test:sounds && npm run test:files",
     "prepublishOnly": "npm i && npm run build"
   },
   "author": "Rémi Vansteelandt",

package/src/generate-file-catalog.ts

@@ -0,0 +1,141 @@
+#!/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},
+                )),\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): CreateItemOptions {\n';
+    generated += `    return { path, size };\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;
+    }\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

@@ -90,6 +90,19 @@ function generateExpandFunction() {
     return generated;
 }
 
+function generateResolveFunction() {
+    let generated = '\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`;
+    generated += `        current = current[component];\n`;
+    generated += `    }\n`;
+    generated += `    return current as T;\n`;
+    generated += '}\n';
+    return generated;
+}
+
 async function createSpritesheet(tree: Tree, outFile: string, excludes: string[]): Promise<SpritesheetResult> {
     const bins: (pack.Bin & {path: string})[] = [];
 
@@ -217,11 +230,12 @@ async function main() {
         width: number;
         height: number;
         size: number;
-        spriteData: SpriteData | null;   
+        spriteData: SpriteData | null;
     }\n\n`;
     generatedFileContent += 'export type TextureCatalog<T> = ' + generatedTemplateInterface(tree, 'TextureCatalog');
     generatedFileContent += '\n\n';
     generatedFileContent += generateExpandFunction();
+    generatedFileContent += generateResolveFunction();
     generatedFileContent += await generatedCreateCatalogFunction(argv.assetDir, tree, spritesheet);
 
     await fs.writeFile(generatedTs, generatedFileContent);

package/src/tree.ts

@@ -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

@@ -30,7 +30,7 @@ export function camelize(str: string) {
 }
 
 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);
 }