@needle-tools/gltf-build-pipeline 2.13.0 → 2.13.1

package/dist/cli/index.js

@@ -1,198 +1,198 @@
-#! /usr/bin/env node
-import { program } from '@donmccurdy/caporal';
-import { calculateStats, packGLTF } from "../scripts/index.js";
-import { printStats, writeFileStatsToFile } from '../utils/stats.js';
-import { getVersion } from '../utils/version.js';
-import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
-import { isLOD, make_progressive } from '../transforms/needle_progressive.js';
-import { cacheSizeLimit, clearCache, limitCacheSize } from '../cache/cache.js';
-import { existsSync } from 'fs';
-import { ensureIsDirectory, foreachGLTF, isDirectory } from '../utils/fileutils.js';
-import path, { resolve } from 'path';
-import { ERROR_CODES } from '../constants.js';
-// For testing / dev you can run `npm link` in the package directory
-// For removing the link run `npm rm --global @needle-tools/gltf-build-pipeline`
-program
-    .command("version", "Print current version")
-    .action(async ({ logger }) => {
-    logger.info(getVersion());
-})
-    .command("clear-caches", "Clear all caches")
-    .help(`Clears all cached files
-Caches are limited to ${cacheSizeLimit} MB disc space by default.
-`)
-    .action(async ({ logger }) => {
-    logger.info("Clearing caches");
-    clearCache(logger);
-})
-    .command("stats", "Calculate glTF stats")
-    .help(`
-`)
-    .argument('<input>', "Path to a glTF, GLB or VRM file OR a directory")
-    .argument('<output>', "Output path for the stats", { default: null, validator: program.STRING })
-    .action(async ({ logger, args, options }) => {
-    logger.level = "info";
-    logger.info("Calculating stats for \"" + args.input + "\"");
-    const input = args.input.toString();
-    const filestats = new Array();
-    await foreachGLTF(input, async (file) => {
-        const stats = await calculateStats(file);
-        filestats.push(stats);
-    });
-    let output = args.ourput?.toString();
-    if (!output) {
-        if (isDirectory(input)) {
-            output = path.join(input, "stats.needle.json");
-        }
-        else {
-            output = input + ".needle.stats.json";
-        }
-    }
-    logger.info("Writing stats to: " + output);
-    writeFileStatsToFile(filestats, output);
-})
-    .command("transform", "Transform (progressive loading) and compress glTF, GLB or VRM files")
-    .help(`
-This will produce multiple versions of the input file, each with a different level of optimization.   
-Each version will be compressed and written to the output directory.
-`)
-    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed OR a directory that contains files to be compressed")
-    .argument('<output>', "The output file or directory. It can be an absolute path or a relative path to the input file. If not provided, the input file will be overwritten.", { default: null })
-    .option("--compress", `When enabled files will be compressed`, { validator: program.BOOLEAN, default: true })
-    .option("--progressive", `When enabled files will processed to be progressively loaded`, { validator: program.BOOLEAN, default: true })
-    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${UsecaseOptions.join(", ")}]`, { validator: program.STRING })
-    .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
-    .option("--cache", "Use \"--cache False\" to disable caching.\nWhen caching is enabled then previously processed files will be detected and loaded from disc cache instead of being processed again if settings or the file contents have not changed.", { validator: program.BOOLEAN, default: true })
-    .option("--debug", "Enable for more verbose outout with \"--debug True\"", { validator: program.BOOLEAN, default: false })
-    .option("--verbose", "Enable for more verbose outout with \"--verbose True\"", { validator: program.BOOLEAN, default: false })
-    .action(async ({ logger, args, options }) => {
-    logger.level = (options.debug || options.verbose) ? "debug" : "info";
-    // const logger = new Logger((options.debug || options.verbose) ? Verbosity.DEBUG : Verbosity.INFO);
-    if (options.compress === false && options.progressive === false) {
-        logger.error(`[Needle Build Pipeline] v${getVersion()} You need to enable at least one of the options: --compress or --progressive`);
-        return;
-    }
-    logger.info(`[Needle Build Pipeline] v${getVersion()} — Transform '${args.input}'`);
-    const stats = {
-        startTime: Date.now(),
-        totalGPUMemoryInMB: 0,
-        totalFilesProcessed: 0,
-        totalFileSizeInMB: 0,
-        totalFileSizeInMBBefore: 0,
-    };
-    const input = args.input.toString();
-    let config = getConfig(options.config?.toString(), input, {
-        logger
-    });
-    if (options.usecase) {
-        logger.info("Using usecase: " + options.usecase);
-        config = { ...createConfig(options.usecase.toString()), ...config, };
-        if (config.usecase != "default" && config.usecase != options.usecase.toString()) {
-            logger.warn(`Conflicting usecase. Your specific config at \"${options.config}\" has a different usecase than the one provided by the CLI: \"${options.usecase}\". Using the usecase from the config file.`);
-        }
-        else {
-            config.usecase = options.usecase.toString();
-        }
-    }
-    const inputIsDirectory = isDirectory(input);
-    let output = args.output?.toString();
-    // If the input path is a filepath and no specific output is defined we set output to the input file
-    if (!inputIsDirectory && !output) {
-        output = input;
-    }
-    const outputIsDirectory = output && isDirectory(output);
-    if (inputIsDirectory && output && !outputIsDirectory) {
-        logger.error("When <input> is a directory then <output> must also be a directory");
-        process.exit(ERROR_CODES.INVALID_ARGS);
-    }
-    // Handle the output bath being relative to the input path
-    if (output && path.isAbsolute(output) === false) {
-        const base = ensureIsDirectory(input);
-        output = resolve(base, output);
-    }
-    const set = new Set();
-    const useCache = options.cache !== false;
-    const debug = options.debug === true;
-    const verbose = options.verbose === true;
-    await foreachGLTF(input, async (file) => {
-        if (!existsSync(file)) {
-            // Safeguard if we run compression in a souce directory that already has progressive assets
-            // Here it can happen that a LOD file is generated with the same GUID at the moment 
-            // And then later removed because simplification is too small.
-            // See https://linear.app/needle/issue/NE-5518
-            if (isLOD(file)) {
-                logger.warn(`WARN: Ignore previously found file that does not exist anymore: \"${file}\"`);
-                return;
-            }
-            else {
-                logger.error(`ERR: Previously found file is now missing: \"${file}\"`);
-                process.exit(ERROR_CODES.LOST_FILE);
-            }
-        }
-        // If we run compression in a directory that has previously generated LOD files AND this command should also generate LOD files with this command we should ignore found LOD meshes or textures
-        else if (file != input && options.progressive === true && isLOD(file)) {
-            logger.debug(`→ Ignore existing LOD file at ${file}`);
-            return;
-        }
-        logger.info(`→ Transform ${file}`);
-        const progressive_results = new Array();
-        if (options.progressive === true) {
-            if (await make_progressive({
-                path: file,
-                outpath: output,
-                results: progressive_results,
-                config,
-                debug,
-                verbose,
-                useCache,
-                logger,
-            }).catch(err => {
-                logger.error(err);
-                process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
-            }) === false) {
-                process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
-            }
-            if (verbose) {
-                console.log("Progressive results:\n", progressive_results);
-            }
-        }
-        if (options.compress === true) {
-            const opts = {
-                config,
-                stats,
-                packedFiles: set,
-                debug,
-                verbose,
-                useCache,
-                logger: logger,
-            };
-            // If we have produced progressive assets then the array already contains the input
-            if (progressive_results.length > 0) {
-                for (const res of progressive_results) {
-                    if (await packGLTF(res, res, opts) === false) {
-                        process.exit(ERROR_CODES.PACKING_FAILED);
-                    }
-                }
-            }
-            // If we have not produced progressive assets then we just need to compress the input
-            // We can not just check if the file is in the list of results because the output path might have changed the name
-            else {
-                if (await packGLTF(file, output, opts) === false) {
-                    process.exit(ERROR_CODES.PACKING_FAILED);
-                }
-            }
-        }
-    });
-    printStats(stats, logger, config);
-    if (useCache)
-        limitCacheSize();
-});
-program.run().catch(err => {
-    // Since we still invoke this package with paths when running npm scripts we need to ignore this error
-    // We might want to move this code here into an extra package.
-    if (err.message.includes("Unknown command") && !err.message.includes("Did you mean")) {
-        // ignore
-        return;
-    }
-    throw err;
-});
+#! /usr/bin/env node
+import { program } from '@donmccurdy/caporal';
+import { calculateStats, packGLTF } from "../scripts/index.js";
+import { printStats, writeFileStatsToFile } from '../utils/stats.js';
+import { getVersion } from '../utils/version.js';
+import { UsecaseOptions, createConfig, getConfig } from '../config/index.js';
+import { isLOD, make_progressive } from '../transforms/needle_progressive.js';
+import { cacheSizeLimit, clearCache, limitCacheSize } from '../cache/cache.js';
+import { existsSync } from 'fs';
+import { ensureIsDirectory, foreachGLTF, isDirectory } from '../utils/fileutils.js';
+import path, { resolve } from 'path';
+import { ERROR_CODES } from '../constants.js';
+// For testing / dev you can run `npm link` in the package directory
+// For removing the link run `npm rm --global @needle-tools/gltf-build-pipeline`
+program
+    .command("version", "Print current version")
+    .action(async ({ logger }) => {
+    logger.info(getVersion());
+})
+    .command("clear-caches", "Clear all caches")
+    .help(`Clears all cached files
+Caches are limited to ${cacheSizeLimit} MB disc space by default.
+`)
+    .action(async ({ logger }) => {
+    logger.info("Clearing caches");
+    clearCache(logger);
+})
+    .command("stats", "Calculate glTF stats")
+    .help(`
+`)
+    .argument('<input>', "Path to a glTF, GLB or VRM file OR a directory")
+    .argument('<output>', "Output path for the stats", { default: null, validator: program.STRING })
+    .action(async ({ logger, args, options }) => {
+    logger.level = "info";
+    logger.info("Calculating stats for \"" + args.input + "\"");
+    const input = args.input.toString();
+    const filestats = new Array();
+    await foreachGLTF(input, async (file) => {
+        const stats = await calculateStats(file);
+        filestats.push(stats);
+    });
+    let output = args.ourput?.toString();
+    if (!output) {
+        if (isDirectory(input)) {
+            output = path.join(input, "stats.needle.json");
+        }
+        else {
+            output = input + ".needle.stats.json";
+        }
+    }
+    logger.info("Writing stats to: " + output);
+    writeFileStatsToFile(filestats, output);
+})
+    .command("transform", "Transform (progressive loading) and compress glTF, GLB or VRM files")
+    .help(`
+This will produce multiple versions of the input file, each with a different level of optimization.   
+Each version will be compressed and written to the output directory.
+`)
+    .argument('<input>', "The input glTF, GLB or VRM file that should be compressed OR a directory that contains files to be compressed")
+    .argument('<output>', "The output file or directory. It can be an absolute path or a relative path to the input file. If not provided, the input file will be overwritten.", { default: null })
+    .option("--compress", `When enabled files will be compressed`, { validator: program.BOOLEAN, default: true })
+    .option("--progressive", `When enabled files will processed to be progressively loaded`, { validator: program.BOOLEAN, default: true })
+    .option("--usecase <usecase>", `The usecase for the compression. This will set the compression settings. Possible options: [${UsecaseOptions.join(", ")}]`, { validator: program.STRING })
+    .option("--config <config>", "The path to a JSON file containing the compression settings. This can also be a needle.config.json file with a \"compression\" object or usecase string.", { validator: program.STRING })
+    .option("--cache", "Use \"--cache False\" to disable caching.\nWhen caching is enabled then previously processed files will be detected and loaded from disc cache instead of being processed again if settings or the file contents have not changed.", { validator: program.BOOLEAN, default: true })
+    .option("--debug", "Enable for more verbose outout with \"--debug True\"", { validator: program.BOOLEAN, default: false })
+    .option("--verbose", "Enable for more verbose outout with \"--verbose True\"", { validator: program.BOOLEAN, default: false })
+    .action(async ({ logger, args, options }) => {
+    logger.level = (options.debug || options.verbose) ? "debug" : "info";
+    // const logger = new Logger((options.debug || options.verbose) ? Verbosity.DEBUG : Verbosity.INFO);
+    if (options.compress === false && options.progressive === false) {
+        logger.error(`[Needle Build Pipeline] v${getVersion()} You need to enable at least one of the options: --compress or --progressive`);
+        return;
+    }
+    logger.info(`[Needle Build Pipeline] v${getVersion()} — Transform '${args.input}'`);
+    const stats = {
+        startTime: Date.now(),
+        totalGPUMemoryInMB: 0,
+        totalFilesProcessed: 0,
+        totalFileSizeInMB: 0,
+        totalFileSizeInMBBefore: 0,
+    };
+    const input = args.input.toString();
+    let config = getConfig(options.config?.toString(), input, {
+        logger
+    });
+    if (options.usecase) {
+        logger.info("Using usecase: " + options.usecase);
+        config = { ...createConfig(options.usecase.toString()), ...config, };
+        if (config.usecase != "default" && config.usecase != options.usecase.toString()) {
+            logger.warn(`Conflicting usecase. Your specific config at \"${options.config}\" has a different usecase than the one provided by the CLI: \"${options.usecase}\". Using the usecase from the config file.`);
+        }
+        else {
+            config.usecase = options.usecase.toString();
+        }
+    }
+    const inputIsDirectory = isDirectory(input);
+    let output = args.output?.toString();
+    // If the input path is a filepath and no specific output is defined we set output to the input file
+    if (!inputIsDirectory && !output) {
+        output = input;
+    }
+    const outputIsDirectory = output && isDirectory(output);
+    if (inputIsDirectory && output && !outputIsDirectory) {
+        logger.error("When <input> is a directory then <output> must also be a directory");
+        process.exit(ERROR_CODES.INVALID_ARGS);
+    }
+    // Handle the output bath being relative to the input path
+    if (output && path.isAbsolute(output) === false) {
+        const base = ensureIsDirectory(input);
+        output = resolve(base, output);
+    }
+    const set = new Set();
+    const useCache = options.cache !== false;
+    const debug = options.debug === true;
+    const verbose = options.verbose === true;
+    await foreachGLTF(input, async (file) => {
+        if (!existsSync(file)) {
+            // Safeguard if we run compression in a souce directory that already has progressive assets
+            // Here it can happen that a LOD file is generated with the same GUID at the moment 
+            // And then later removed because simplification is too small.
+            // See https://linear.app/needle/issue/NE-5518
+            if (isLOD(file)) {
+                logger.warn(`WARN: Ignore previously found file that does not exist anymore: \"${file}\"`);
+                return;
+            }
+            else {
+                logger.error(`ERR: Previously found file is now missing: \"${file}\"`);
+                process.exit(ERROR_CODES.LOST_FILE);
+            }
+        }
+        // If we run compression in a directory that has previously generated LOD files AND this command should also generate LOD files with this command we should ignore found LOD meshes or textures
+        else if (file != input && options.progressive === true && isLOD(file)) {
+            logger.debug(`→ Ignore existing LOD file at ${file}`);
+            return;
+        }
+        logger.info(`→ Transform ${file}`);
+        const progressive_results = new Array();
+        if (options.progressive === true) {
+            if (await make_progressive({
+                path: file,
+                outpath: output,
+                results: progressive_results,
+                config,
+                debug,
+                verbose,
+                useCache,
+                logger,
+            }).catch(err => {
+                logger.error(err);
+                process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
+            }) === false) {
+                process.exit(ERROR_CODES.PROGRESSIVE_FAILED);
+            }
+            if (verbose) {
+                console.log("Progressive results:\n", progressive_results);
+            }
+        }
+        if (options.compress === true) {
+            const opts = {
+                config,
+                stats,
+                packedFiles: set,
+                debug,
+                verbose,
+                useCache,
+                logger: logger,
+            };
+            // If we have produced progressive assets then the array already contains the input
+            if (progressive_results.length > 0) {
+                for (const res of progressive_results) {
+                    if (await packGLTF(res, res, opts) === false) {
+                        process.exit(ERROR_CODES.PACKING_FAILED);
+                    }
+                }
+            }
+            // If we have not produced progressive assets then we just need to compress the input
+            // We can not just check if the file is in the list of results because the output path might have changed the name
+            else {
+                if (await packGLTF(file, output, opts) === false) {
+                    process.exit(ERROR_CODES.PACKING_FAILED);
+                }
+            }
+        }
+    });
+    printStats(stats, logger, config);
+    if (useCache)
+        limitCacheSize();
+});
+program.run().catch(err => {
+    // Since we still invoke this package with paths when running npm scripts we need to ignore this error
+    // We might want to move this code here into an extra package.
+    if (err.message.includes("Unknown command") && !err.message.includes("Did you mean")) {
+        // ignore
+        return;
+    }
+    throw err;
+});

package/dist/config/index.d.ts

@@ -1,53 +1,53 @@
-import { ILogger } from "@gltf-transform/core";
-declare type Usecase = "default" | "product" | "world";
-export declare const UsecaseOptions: string[];
-/**
- * The config object contains information about how a file should be processed.
- */
-export type Config = {
-    /** High-level configuration */
-    usecase: Usecase;
-    textures?: {
-        lods: boolean;
-    };
-    meshes?: {
-        lods: boolean;
-    };
-};
-/**
- * Create a config object with the given usecase.
- */
-export declare function createConfig(usecase: string): {
-    usecase: Usecase;
-};
-/**
- * Get the config object either provided by a CLI path or a needle.config.json file in the parent directory.
- *
- * @example CLI argument where the path points to a json file containing the config as `Config`
- * ```sh
- * node script.js --config path/to/my-optimization-config.json
- * ```
- *
- * @example needle.config.json - the usecase can be provided as a string
- * ```json
- * {
- *    "optimization": "product"
- * }
- * ```
- *
- * @example needle.config.json - the whole config object can be provided
- * ```json
- * {
- *   "optimization": {
- *      "usecase": "product"
- *   }
- * }
- * ```
- *
- *
- */
-export declare function getConfig(configPath?: string, fallbackSearchDirectory?: string, opts?: {
-    logger: ILogger;
-}): Config;
-export declare function searchConfig(directory: string, logger: ILogger): Config | null;
-export {};
+import { ILogger } from "@gltf-transform/core";
+declare type Usecase = "default" | "product" | "world";
+export declare const UsecaseOptions: string[];
+/**
+ * The config object contains information about how a file should be processed.
+ */
+export type Config = {
+    /** High-level configuration */
+    usecase: Usecase;
+    textures?: {
+        lods: boolean;
+    };
+    meshes?: {
+        lods: boolean;
+    };
+};
+/**
+ * Create a config object with the given usecase.
+ */
+export declare function createConfig(usecase: string): {
+    usecase: Usecase;
+};
+/**
+ * Get the config object either provided by a CLI path or a needle.config.json file in the parent directory.
+ *
+ * @example CLI argument where the path points to a json file containing the config as `Config`
+ * ```sh
+ * node script.js --config path/to/my-optimization-config.json
+ * ```
+ *
+ * @example needle.config.json - the usecase can be provided as a string
+ * ```json
+ * {
+ *    "optimization": "product"
+ * }
+ * ```
+ *
+ * @example needle.config.json - the whole config object can be provided
+ * ```json
+ * {
+ *   "optimization": {
+ *      "usecase": "product"
+ *   }
+ * }
+ * ```
+ *
+ *
+ */
+export declare function getConfig(configPath?: string, fallbackSearchDirectory?: string, opts?: {
+    logger: ILogger;
+}): Config;
+export declare function searchConfig(directory: string, logger: ILogger): Config | null;
+export {};