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

package/dist/config/index.js

@@ -1,152 +1,152 @@
-import { Logger, Verbosity } from "@gltf-transform/core";
-import { existsSync, readFileSync, statSync } from "fs";
-import path, { dirname, resolve } from "path";
-export const UsecaseOptions = ["product", "world"];
-const defaultConfig = {
-    usecase: "default",
-};
-/**
- * Create a config object with the given usecase.
- */
-export function createConfig(usecase) {
-    if (!UsecaseOptions.includes(usecase)) {
-        throw new Error(`Invalid usecase: \"${usecase}\". Valid usecases: ${UsecaseOptions.join(", ")}`);
-    }
-    return {
-        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 function getConfig(configPath, fallbackSearchDirectory, opts) {
-    let logger = opts?.logger;
-    if (!logger) {
-        logger = new Logger(Verbosity.WARN);
-    }
-    if (configPath != null) {
-        configPath = resolve(process.cwd(), configPath);
-        if (!existsSync(configPath)) {
-            throw new Error(`No config found at \"${configPath}\"`);
-        }
-        const isDirectory = statSync(configPath).isDirectory();
-        if (isDirectory) {
-            const res = searchConfig(configPath, logger);
-            if (res) {
-                return res;
-            }
-            else {
-                throw new Error(`No config found in directory \"${configPath}\"`);
-            }
-        }
-        const res = resolveConfig(configPath, readFileSync(configPath, "utf8"), logger);
-        if (res) {
-            return res;
-        }
-        else {
-            throw new Error(`Failed parsing config at \"${configPath}\"`);
-        }
-    }
-    if (_cachedConfig !== undefined) {
-        return _cachedConfig;
-    }
-    // Resolve the config once and cache it
-    // Check if a needle.config.json exists in the directory from which the script is run (or any parent directory)
-    if (fallbackSearchDirectory) {
-        const result = searchConfig(fallbackSearchDirectory, logger);
-        if (result) {
-            _cachedConfig = { ...defaultConfig, ...result };
-            logger.info("Using config with usecase: " + _cachedConfig.usecase);
-        }
-    }
-    // If no config was found, use the default config
-    if (!_cachedConfig) {
-        logger.info("No config found. Using default config.");
-        _cachedConfig = defaultConfig;
-    }
-    return _cachedConfig;
-}
-let _cachedConfig = undefined;
-export function searchConfig(directory, logger) {
-    if (statSync(directory).isFile()) {
-        directory = dirname(directory);
-    }
-    directory = directory.replaceAll("\\", "/");
-    while (directory.length > 0) {
-        const configPath = path.join(directory, "needle.config.json");
-        if (existsSync(configPath)) {
-            const content = readFileSync(configPath, "utf8");
-            const config = resolveConfig(configPath, content, logger);
-            if (config) {
-                return config;
-            }
-        }
-        const lastSlash = directory.lastIndexOf("/");
-        if (lastSlash < 0) {
-            break;
-        }
-        directory = directory.slice(0, lastSlash);
-    }
-    return null;
-}
-function resolveConfig(filename, content, logger) {
-    // Handle config being part of `needle.config.json`
-    if (filename.endsWith("needle.config.json")) {
-        try {
-            const config = JSON.parse(content);
-            if (config.gltf) {
-                logger.info("Found \"gltf\" config at \"" + filename + "\".");
-                // If the optimization config is a string, it's the usecase
-                if (typeof config.gltf === "string") {
-                    return createConfig(config.gltf);
-                }
-                return config.gltf;
-            }
-            else {
-                logger.info("No \"gltf\" config found in needle.config.json. Using default config.");
-                return null;
-            }
-        }
-        catch (err) {
-            logger.error(`Failed parsing config \"${err.message}\" at ${filename}`);
-        }
-    }
-    // Handle config being the content of the file
-    else if (content.trimStart().startsWith("{")) {
-        try {
-            return JSON.parse(content);
-        }
-        catch (err) {
-            if (err instanceof Error)
-                logger.error(`Failed parsing config \"${err.message}\" at ${filename}`);
-            else
-                logger.error(`Failed parsing config \"${err}\" at ${filename}`);
-        }
-    }
-    else {
-        logger.error("Invalid config file format. Expected JSON object at " + filename);
-    }
-}
+import { Logger, Verbosity } from "@gltf-transform/core";
+import { existsSync, readFileSync, statSync } from "fs";
+import path, { dirname, resolve } from "path";
+export const UsecaseOptions = ["product", "world"];
+const defaultConfig = {
+    usecase: "default",
+};
+/**
+ * Create a config object with the given usecase.
+ */
+export function createConfig(usecase) {
+    if (!UsecaseOptions.includes(usecase)) {
+        throw new Error(`Invalid usecase: \"${usecase}\". Valid usecases: ${UsecaseOptions.join(", ")}`);
+    }
+    return {
+        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 function getConfig(configPath, fallbackSearchDirectory, opts) {
+    let logger = opts?.logger;
+    if (!logger) {
+        logger = new Logger(Verbosity.WARN);
+    }
+    if (configPath != null) {
+        configPath = resolve(process.cwd(), configPath);
+        if (!existsSync(configPath)) {
+            throw new Error(`No config found at \"${configPath}\"`);
+        }
+        const isDirectory = statSync(configPath).isDirectory();
+        if (isDirectory) {
+            const res = searchConfig(configPath, logger);
+            if (res) {
+                return res;
+            }
+            else {
+                throw new Error(`No config found in directory \"${configPath}\"`);
+            }
+        }
+        const res = resolveConfig(configPath, readFileSync(configPath, "utf8"), logger);
+        if (res) {
+            return res;
+        }
+        else {
+            throw new Error(`Failed parsing config at \"${configPath}\"`);
+        }
+    }
+    if (_cachedConfig !== undefined) {
+        return _cachedConfig;
+    }
+    // Resolve the config once and cache it
+    // Check if a needle.config.json exists in the directory from which the script is run (or any parent directory)
+    if (fallbackSearchDirectory) {
+        const result = searchConfig(fallbackSearchDirectory, logger);
+        if (result) {
+            _cachedConfig = { ...defaultConfig, ...result };
+            logger.info("Using config with usecase: " + _cachedConfig.usecase);
+        }
+    }
+    // If no config was found, use the default config
+    if (!_cachedConfig) {
+        logger.info("No config found. Using default config.");
+        _cachedConfig = defaultConfig;
+    }
+    return _cachedConfig;
+}
+let _cachedConfig = undefined;
+export function searchConfig(directory, logger) {
+    if (statSync(directory).isFile()) {
+        directory = dirname(directory);
+    }
+    directory = directory.replaceAll("\\", "/");
+    while (directory.length > 0) {
+        const configPath = path.join(directory, "needle.config.json");
+        if (existsSync(configPath)) {
+            const content = readFileSync(configPath, "utf8");
+            const config = resolveConfig(configPath, content, logger);
+            if (config) {
+                return config;
+            }
+        }
+        const lastSlash = directory.lastIndexOf("/");
+        if (lastSlash < 0) {
+            break;
+        }
+        directory = directory.slice(0, lastSlash);
+    }
+    return null;
+}
+function resolveConfig(filename, content, logger) {
+    // Handle config being part of `needle.config.json`
+    if (filename.endsWith("needle.config.json")) {
+        try {
+            const config = JSON.parse(content);
+            if (config.gltf) {
+                logger.info("Found \"gltf\" config at \"" + filename + "\".");
+                // If the optimization config is a string, it's the usecase
+                if (typeof config.gltf === "string") {
+                    return createConfig(config.gltf);
+                }
+                return config.gltf;
+            }
+            else {
+                logger.info("No \"gltf\" config found in needle.config.json. Using default config.");
+                return null;
+            }
+        }
+        catch (err) {
+            logger.error(`Failed parsing config \"${err.message}\" at ${filename}`);
+        }
+    }
+    // Handle config being the content of the file
+    else if (content.trimStart().startsWith("{")) {
+        try {
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (err instanceof Error)
+                logger.error(`Failed parsing config \"${err.message}\" at ${filename}`);
+            else
+                logger.error(`Failed parsing config \"${err}\" at ${filename}`);
+        }
+    }
+    else {
+        logger.error("Invalid config file format. Expected JSON object at " + filename);
+    }
+}

package/dist/constants.d.ts

@@ -1,7 +1,7 @@
-export declare const ERROR_CODES: {
-    UNKNOWN_ERROR: number;
-    PACKING_FAILED: number;
-    PROGRESSIVE_FAILED: number;
-    INVALID_ARGS: number;
-    LOST_FILE: number;
-};
+export declare const ERROR_CODES: {
+    UNKNOWN_ERROR: number;
+    PACKING_FAILED: number;
+    PROGRESSIVE_FAILED: number;
+    INVALID_ARGS: number;
+    LOST_FILE: number;
+};

package/dist/constants.js

@@ -1,7 +1,7 @@
-export const ERROR_CODES = {
-    UNKNOWN_ERROR: 1,
-    PACKING_FAILED: 2,
-    PROGRESSIVE_FAILED: 3,
-    INVALID_ARGS: 4,
-    LOST_FILE: 5,
-};
+export const ERROR_CODES = {
+    UNKNOWN_ERROR: 1,
+    PACKING_FAILED: 2,
+    PROGRESSIVE_FAILED: 3,
+    INVALID_ARGS: 4,
+    LOST_FILE: 5,
+};

package/dist/extensions/NEEDLE_compression_texture/NEEDLE_compression_texture.d.ts

@@ -1,24 +1,24 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare const EXTENSION_NAME = "NEEDLE_compression_texture";
-export declare interface NEEDLE_compression_texture_schema {
-    mode: "none" | "auto" | "webp" | "UASTC" | "ETC1S" | "world" | "product";
-    slot: string;
-    /** quality in range of 0 - 1 */
-    quality: number;
-    maxSize: number;
-}
-export declare class NEEDLE_compression_texture extends Extension {
-    static EXTENSION_NAME: string;
-    extensionName: string;
-    create(toktxInfo: NEEDLE_compression_texture_schema): NEEDLE_compression_texture_property;
-    read(context: ReaderContext): this;
-    write(context: WriterContext): this;
-}
-export declare class NEEDLE_compression_texture_property extends ExtensionProperty {
-    static EXTENSION_NAME: string;
-    extensionName: string;
-    parentTypes: PropertyType[];
-    propertyType: any;
-    init(): void;
-    model: NEEDLE_compression_texture_schema;
-}
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare const EXTENSION_NAME = "NEEDLE_compression_texture";
+export declare interface NEEDLE_compression_texture_schema {
+    mode: "none" | "auto" | "webp" | "UASTC" | "ETC1S" | "world" | "product";
+    slot: string;
+    /** quality in range of 0 - 1 */
+    quality: number;
+    maxSize: number;
+}
+export declare class NEEDLE_compression_texture extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    create(toktxInfo: NEEDLE_compression_texture_schema): NEEDLE_compression_texture_property;
+    read(context: ReaderContext): this;
+    write(context: WriterContext): this;
+}
+export declare class NEEDLE_compression_texture_property extends ExtensionProperty {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: any;
+    init(): void;
+    model: NEEDLE_compression_texture_schema;
+}

package/dist/extensions/NEEDLE_compression_texture/NEEDLE_compression_texture.js

@@ -1,54 +1,54 @@
-import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
-import { getTextureDefinition } from "../utils.js";
-export const EXTENSION_NAME = "NEEDLE_compression_texture";
-const debugLog = false;
-export class NEEDLE_compression_texture extends Extension {
-    static EXTENSION_NAME = EXTENSION_NAME;
-    extensionName = EXTENSION_NAME;
-    create(toktxInfo) {
-        const ext = new NEEDLE_compression_texture_property(this.document.getGraph(), "");
-        ext.model = toktxInfo;
-        return ext;
-    }
-    read(context) {
-        if (debugLog)
-            console.log("READ " + EXTENSION_NAME);
-        if (!context.jsonDoc.json.textures)
-            return this;
-        context.textures?.forEach((tex, _) => {
-            const textureDefinition = getTextureDefinition(context, tex);
-            if (textureDefinition?.extensions && textureDefinition.extensions[EXTENSION_NAME]) {
-                const prop = new NEEDLE_compression_texture_property(this.document.getGraph(), EXTENSION_NAME);
-                prop.model = textureDefinition.extensions[EXTENSION_NAME];
-                tex.setExtension(EXTENSION_NAME, prop);
-            }
-        });
-        return this;
-    }
-    write(context) {
-        if (debugLog)
-            console.log("WRITE " + EXTENSION_NAME);
-        const root = this.document.getRoot();
-        const textures = root.listTextures();
-        for (const tex of textures) {
-            const ext = tex.getExtension(EXTENSION_NAME);
-            if (ext) {
-                const def = getTextureDefinition(context, tex);
-                if (def) {
-                    def.extensions = def.extensions || {};
-                    def.extensions[EXTENSION_NAME] = ext.model;
-                }
-            }
-        }
-        return this;
-    }
-}
-export class NEEDLE_compression_texture_property extends ExtensionProperty {
-    static EXTENSION_NAME = EXTENSION_NAME;
-    init() {
-        this.extensionName = EXTENSION_NAME;
-        this.parentTypes = [PropertyType.TEXTURE];
-        this.propertyType = EXTENSION_NAME;
-    }
-    model;
-}
+import { Extension, ExtensionProperty, PropertyType } from "@gltf-transform/core";
+import { getTextureDefinition } from "../utils.js";
+export const EXTENSION_NAME = "NEEDLE_compression_texture";
+const debugLog = false;
+export class NEEDLE_compression_texture extends Extension {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    extensionName = EXTENSION_NAME;
+    create(toktxInfo) {
+        const ext = new NEEDLE_compression_texture_property(this.document.getGraph(), "");
+        ext.model = toktxInfo;
+        return ext;
+    }
+    read(context) {
+        if (debugLog)
+            console.log("READ " + EXTENSION_NAME);
+        if (!context.jsonDoc.json.textures)
+            return this;
+        context.textures?.forEach((tex, _) => {
+            const textureDefinition = getTextureDefinition(context, tex);
+            if (textureDefinition?.extensions && textureDefinition.extensions[EXTENSION_NAME]) {
+                const prop = new NEEDLE_compression_texture_property(this.document.getGraph(), EXTENSION_NAME);
+                prop.model = textureDefinition.extensions[EXTENSION_NAME];
+                tex.setExtension(EXTENSION_NAME, prop);
+            }
+        });
+        return this;
+    }
+    write(context) {
+        if (debugLog)
+            console.log("WRITE " + EXTENSION_NAME);
+        const root = this.document.getRoot();
+        const textures = root.listTextures();
+        for (const tex of textures) {
+            const ext = tex.getExtension(EXTENSION_NAME);
+            if (ext) {
+                const def = getTextureDefinition(context, tex);
+                if (def) {
+                    def.extensions = def.extensions || {};
+                    def.extensions[EXTENSION_NAME] = ext.model;
+                }
+            }
+        }
+        return this;
+    }
+}
+export class NEEDLE_compression_texture_property extends ExtensionProperty {
+    static EXTENSION_NAME = EXTENSION_NAME;
+    init() {
+        this.extensionName = EXTENSION_NAME;
+        this.parentTypes = [PropertyType.TEXTURE];
+        this.propertyType = EXTENSION_NAME;
+    }
+    model;
+}

package/dist/extensions/NEEDLE_compression_texture/index.d.ts

@@ -1 +1 @@
-export * from "./NEEDLE_compression_texture.js";
+export * from "./NEEDLE_compression_texture.js";

package/dist/extensions/NEEDLE_compression_texture/index.js

@@ -1 +1 @@
-export * from "./NEEDLE_compression_texture.js";
+export * from "./NEEDLE_compression_texture.js";

package/dist/extensions/NEEDLE_mesh_compression/NEEDLE_mesh_compression.d.ts

@@ -1,27 +1,27 @@
-import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
-export declare class NEEDLE_mesh_compression_model_root {
-    compression: "none" | "draco" | "meshopt";
-    constructor(compression: "none" | "draco" | "meshopt");
-}
-export declare class NEEDLE_mesh_compression_model {
-    useSimplifier: boolean;
-    error: number;
-    ratio: number;
-    lockBorder: boolean;
-}
-export declare class NEEDLE_mesh_compression extends Extension {
-    static EXTENSION_NAME: string;
-    extensionName: string;
-    create(model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root): NEEDLE_mesh_compression_property;
-    read(context: ReaderContext): this;
-    write(ctx: WriterContext): this;
-}
-export declare class NEEDLE_mesh_compression_property extends ExtensionProperty {
-    static EXTENSION_NAME: string;
-    readonly extensionName: string;
-    parentTypes: PropertyType[];
-    propertyType: string;
-    init(): void;
-    model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root;
-    copy(other: this, resolve?: (property: ExtensionProperty) => ExtensionProperty): this;
-}
+import { Extension, ExtensionProperty, PropertyType, ReaderContext, WriterContext } from "@gltf-transform/core";
+export declare class NEEDLE_mesh_compression_model_root {
+    compression: "none" | "draco" | "meshopt";
+    constructor(compression: "none" | "draco" | "meshopt");
+}
+export declare class NEEDLE_mesh_compression_model {
+    useSimplifier: boolean;
+    error: number;
+    ratio: number;
+    lockBorder: boolean;
+}
+export declare class NEEDLE_mesh_compression extends Extension {
+    static EXTENSION_NAME: string;
+    extensionName: string;
+    create(model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root): NEEDLE_mesh_compression_property;
+    read(context: ReaderContext): this;
+    write(ctx: WriterContext): this;
+}
+export declare class NEEDLE_mesh_compression_property extends ExtensionProperty {
+    static EXTENSION_NAME: string;
+    readonly extensionName: string;
+    parentTypes: PropertyType[];
+    propertyType: string;
+    init(): void;
+    model: NEEDLE_mesh_compression_model | NEEDLE_mesh_compression_model_root;
+    copy(other: this, resolve?: (property: ExtensionProperty) => ExtensionProperty): this;
+}