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

package/dist/transforms/needle_toktx.js

@@ -1,243 +1,243 @@
-import { BufferUtils, FileUtils, ImageUtils, uuid } from "@gltf-transform/core";
-import { listTextureSlots, getTextureChannelMask, fitPowerOfTwo, TextureResizeFilter } from "@gltf-transform/functions";
-import { KHRTextureBasisu } from "@gltf-transform/extensions";
-import { checkKTXSoftware, createParams, KTX_SOFTWARE_VERSION_MIN, Mode } from "./toktx.js";
-import { existsSync, mkdirSync, rmSync } from "fs";
-import { formatBytes, spawn, waitExit } from './util.js';
-import { ETC1S_DEFAULTS, UASTC_DEFAULTS } from "./toktx_types.js";
-import fs from 'fs/promises';
-import os from 'os';
-import tmp from 'tmp';
-import pLimit from 'p-limit';
-import { replaceExtension } from "../utils/fileutils.js";
-import { ceilMultipleOfFour, isLightmap, isMultipleOfFour } from "../utils/index.js";
-import sharp from "sharp";
-const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
-let didLogEnvironmentInfo = false;
-export class NeedleToktxContext {
-    limit;
-    basisuExtension;
-    version;
-    cacheDirectory;
-    tmpPathBase;
-    document;
-    env;
-    numTextures;
-    _prepareFailed = false;
-    constructor(options) {
-        this.limit = pLimit(options.jobs || NUM_CPUS);
-        // allow overriding toktx installation location / adding additional search paths
-        const isUsingWindows = process.platform === 'win32';
-        this.env = {
-            PATH: process.env.PATH ?? ""
-        };
-        if (options?.toktxPath?.length && this.env) {
-            this.env.PATH = `${options.toktxPath};${this.env.PATH}`;
-        }
-        // Use global env variable
-        if (process.env.NEEDLE_TOKTX?.length) {
-            if (!existsSync(process.env.NEEDLE_TOKTX)) {
-                if (options.debug)
-                    console.log("WARN: NEEDLE_TOKTX is set to a non-existing path: \"" + process.env.NEEDLE_TOKTX + "\"");
-            }
-            else {
-                if (options.debug)
-                    console.log("INFO: Adding NEEDLE_TOKTX to PATH: \"" + process.env.NEEDLE_TOKTX + "\"");
-                this.env.PATH = `${process.env.NEEDLE_TOKTX};${this.env.PATH}`;
-            }
-        }
-        // fallback default installation directory:
-        if (isUsingWindows) {
-            const defaultPath = "C:\\Program Files\\KTX-Software\\bin";
-            if (existsSync(defaultPath))
-                this.env.PATH = `${this.env.PATH};${defaultPath}`;
-        }
-        // append default system paths
-        if (isUsingWindows && process.env.Path?.length)
-            this.env.PATH = `${this.env.PATH};${process.env.Path}`;
-        const ktxPaths = this.env.PATH.split(";").filter(p => p.toLocaleLowerCase().includes("ktx"));
-        if (options.debug) {
-            console.log("INFO: Found these paths including ktx:\n\t" + ktxPaths.join("\n\t") + "");
-        }
-        else if (ktxPaths?.length <= 0) {
-            if (didLogEnvironmentInfo === false)
-                console.log("INFO: Environment variable 'NEEDLE_TOKTX' not set. Use 'NEEDLE_TOKTX' to specify the directory of the toktx installation (path/to/bin)");
-            didLogEnvironmentInfo = true;
-        }
-    }
-    async prepare(document) {
-        try {
-            this.document = document;
-            const logger = document.getLogger();
-            this.version = await checkKTXSoftware(logger, this.env);
-            if (this.version === null) {
-                logger.warn(`WARN: toktx not found, skipping texture compression. Please install KTX-Software >= ${KTX_SOFTWARE_VERSION_MIN}`);
-                this._prepareFailed = true;
-                return false;
-            }
-            this.basisuExtension = document.createExtension(KHRTextureBasisu).setRequired(true);
-            const tmpDir = `${tmp.tmpdir}/gltf-transform`;
-            this.cacheDirectory = tmpDir;
-            if (!(existsSync(tmpDir)))
-                mkdirSync(tmpDir);
-            this.tmpPathBase = tmpDir + "/" + uuid();
-            this.numTextures = document.getRoot().listTextures().length;
-        }
-        catch (e) {
-            console.error(e);
-            console.log("Error preparing toktx transform");
-            this._prepareFailed = true;
-            return false;
-        }
-        return true;
-    }
-    async process(index, texture, settings, context) {
-        const task = async () => {
-            if (this._prepareFailed)
-                return false;
-            const doc = this.document;
-            const logger = doc.getLogger();
-            const slots = listTextureSlots(texture);
-            let channels = getTextureChannelMask(texture);
-            // const textureLabel =
-            //     texture.getURI() ||
-            //     texture.getName() ||
-            //     `${index + 1}/${doc.getRoot().listTextures().length}`;
-            const prefix = `toktx:texture[${index}] ${texture.getName()}`;
-            let srcMimeType = texture.getMimeType();
-            if (srcMimeType === 'image/ktx2') {
-                logger.debug(`${prefix}: Skipping, already KTX.`);
-                return;
-            }
-            else if (srcMimeType !== 'image/png' && srcMimeType !== 'image/jpeg') {
-                logger.warn(`${prefix}: Skipping, unsupported texture type "${texture.getMimeType()}".`);
-                return;
-            }
-            if (slots.length > 0)
-                logger.debug(`${prefix}: Slots → [${slots.join(', ')}]`);
-            else
-                logger.debug(`${prefix}: No slots, assuming default texture.`);
-            let srcImage = texture.getImage();
-            let srcExtension = texture.getURI()
-                ? FileUtils.extension(texture.getURI())
-                : ImageUtils.mimeTypeToExtension(texture.getMimeType());
-            const srcSize = texture.getSize();
-            const srcBytes = srcImage ? srcImage.byteLength : null;
-            if (!srcImage || !srcSize || !srcBytes) {
-                logger.warn(`${prefix}: Skipping, unreadable texture.`);
-                return;
-            }
-            if (!isMultipleOfFour(srcSize[0]) || !isMultipleOfFour(srcSize[1])) {
-                const limitInputPixels = true;
-                const instance = sharp(srcImage, { limitInputPixels }).toFormat('png');
-                const srcSize = ImageUtils.getSize(srcImage, srcMimeType);
-                const dstSize = fitPowerOfTwo(srcSize, 'nearest-pot');
-                dstSize[0] = ceilMultipleOfFour(dstSize[0]);
-                dstSize[1] = ceilMultipleOfFour(dstSize[1]);
-                logger.warn(`${prefix}: Resizing ${srcSize.join('x')} → ${dstSize.join('x')}px`);
-                instance.resize(dstSize[0], dstSize[1], { fit: 'fill', kernel: TextureResizeFilter.LANCZOS3 });
-                const buffer = await instance.toBuffer();
-                srcImage = BufferUtils.toView(new Uint8Array(buffer));
-                srcExtension = 'png';
-                srcMimeType = 'image/png';
-            }
-            const tmpName = this.tmpPathBase + "_" + index;
-            const inPath = tmpName + '.' + srcExtension;
-            const outPath = tmpName + '.ktx2';
-            // const inBytes = image.byteLength;
-            const buffer = Buffer.from(srcImage);
-            await fs.writeFile(inPath, buffer);
-            let mode = Mode.ETC1S;
-            let quality = 128;
-            let compression = 1;
-            if (settings) {
-                if (settings.mode === "auto") {
-                    const useUASTC = slots.includes("normalTexture") || slots.includes("metallicRoughnessTexture");
-                    mode = useUASTC ? Mode.UASTC : Mode.ETC1S;
-                    // in auto-mode we use higher quality for normal and metallicRoughness textures
-                    quality = useUASTC ? 255 : 128;
-                    compression = useUASTC ? 4 : 1;
-                }
-                else {
-                    mode = settings.mode === "ETC1S" ? Mode.ETC1S : Mode.UASTC;
-                }
-            }
-            else if (slots) {
-                const isNormal = slots.includes("normalTexture");
-                const isMetallicRoughness = slots.includes("metallicRoughnessTexture");
-                const betterQuality = isNormal || isMetallicRoughness;
-                mode = Mode.ETC1S;
-                // https://github.khronos.org/KTX-Software/ktxtools/toktx.html
-                quality = betterQuality ? 255 : 128;
-                // ETC1S / BasisLZ compression level, an encoding speed vs. quality tradeoff. Range is [0,5], default is 1. Higher values are slower but give higher quality.
-                compression = betterQuality ? 4 : 1;
-                // For the product usecase we use UASTC for meallicroughness and normal textures
-                if (context.config.usecase === "product") {
-                    if (betterQuality) {
-                        mode = Mode.UASTC;
-                    }
-                    quality = 255;
-                    compression = 4;
-                }
-                else if (slots.includes("lightmapTexture") || isLightmap(texture)) {
-                    quality = 255;
-                    compression = 4;
-                }
-            }
-            const defaults = mode === Mode.ETC1S ? ETC1S_DEFAULTS : UASTC_DEFAULTS;
-            // TODO: should we ensure that the texture is using all channels? Unused channels are discarded anyways. The issue we have here is that textures that are solely used from pointers have unknown channels. We register them with RGBA when generating progressive assets as well as assign texture json pointers /textures/ to
-            // Alpha blended materials to make sure RGBA channels are used when progressive GLBs are compressed (in needle_progressive 377) 
-            // https://linear.app/needle/issue/NE-4985
-            // channels = TextureChannel.R | TextureChannel.G | TextureChannel.B | TextureChannel.A;
-            //@ts-ignore
-            const toktxParams = createParams(texture, slots, channels, srcSize, logger, this.numTextures, { ...defaults, mode, quality, compression });
-            await fs.writeFile(inPath, Buffer.from(srcImage));
-            const params = [
-                'create',
-                ...toktxParams,
-                inPath,
-                outPath,
-            ];
-            logger.debug(`${prefix}: Spawning → toktx ${mode.toUpperCase()} ${params.join(' ')}`);
-            try {
-                // COMPRESS: Run `ktx create` CLI tool.
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const [status, stdout, stderr] = await waitExit(spawn('ktx', params, { env: this.env }));
-                if (status !== 0) {
-                    logger.error(`${prefix}: Failed → \n\n${stderr.toString()}`);
-                }
-                else {
-                    const result = await fs.readFile(outPath);
-                    texture.setImage(result).setMimeType('image/ktx2');
-                    // TODO: we also need to remove the old file when the extension has changed - this should probably be done outside of this method to also support webp
-                    // If this is a texture that was loaded from a file, we need to update the URI
-                    if (texture.getURI()) {
-                        const oldUri = texture.getURI();
-                        const newUri = replaceExtension(oldUri, 'ktx2');
-                        texture.setURI(newUri);
-                    }
-                    const dstBytes = texture.getImage().byteLength;
-                    logger.debug(`${prefix}: ${formatBytes(srcBytes)} → ${formatBytes(dstBytes)}`);
-                    return true;
-                }
-            }
-            catch (err) {
-                logger.error(`${prefix}: Toktx failed → ${err}`);
-            }
-            return false;
-        };
-        return this.limit(task);
-    }
-    async finalize(document) {
-        const usesKTX2 = document
-            .getRoot()
-            .listTextures()
-            .some((t) => t.getMimeType() === 'image/ktx2');
-        if (!usesKTX2) {
-            this.basisuExtension?.dispose();
-        }
-        if (this.cacheDirectory && existsSync(this.cacheDirectory)) {
-            rmSync(this.cacheDirectory, { recursive: true });
-        }
-    }
-}
+import { BufferUtils, FileUtils, ImageUtils, uuid } from "@gltf-transform/core";
+import { listTextureSlots, getTextureChannelMask, fitPowerOfTwo, TextureResizeFilter } from "@gltf-transform/functions";
+import { KHRTextureBasisu } from "@gltf-transform/extensions";
+import { checkKTXSoftware, createParams, KTX_SOFTWARE_VERSION_MIN, Mode } from "./toktx.js";
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { formatBytes, spawn, waitExit } from './util.js';
+import { ETC1S_DEFAULTS, UASTC_DEFAULTS } from "./toktx_types.js";
+import fs from 'fs/promises';
+import os from 'os';
+import tmp from 'tmp';
+import pLimit from 'p-limit';
+import { replaceExtension } from "../utils/fileutils.js";
+import { ceilMultipleOfFour, isLightmap, isMultipleOfFour } from "../utils/index.js";
+import sharp from "sharp";
+const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
+let didLogEnvironmentInfo = false;
+export class NeedleToktxContext {
+    limit;
+    basisuExtension;
+    version;
+    cacheDirectory;
+    tmpPathBase;
+    document;
+    env;
+    numTextures;
+    _prepareFailed = false;
+    constructor(options) {
+        this.limit = pLimit(options.jobs || NUM_CPUS);
+        // allow overriding toktx installation location / adding additional search paths
+        const isUsingWindows = process.platform === 'win32';
+        this.env = {
+            PATH: process.env.PATH ?? ""
+        };
+        if (options?.toktxPath?.length && this.env) {
+            this.env.PATH = `${options.toktxPath};${this.env.PATH}`;
+        }
+        // Use global env variable
+        if (process.env.NEEDLE_TOKTX?.length) {
+            if (!existsSync(process.env.NEEDLE_TOKTX)) {
+                if (options.debug)
+                    console.log("WARN: NEEDLE_TOKTX is set to a non-existing path: \"" + process.env.NEEDLE_TOKTX + "\"");
+            }
+            else {
+                if (options.debug)
+                    console.log("INFO: Adding NEEDLE_TOKTX to PATH: \"" + process.env.NEEDLE_TOKTX + "\"");
+                this.env.PATH = `${process.env.NEEDLE_TOKTX};${this.env.PATH}`;
+            }
+        }
+        // fallback default installation directory:
+        if (isUsingWindows) {
+            const defaultPath = "C:\\Program Files\\KTX-Software\\bin";
+            if (existsSync(defaultPath))
+                this.env.PATH = `${this.env.PATH};${defaultPath}`;
+        }
+        // append default system paths
+        if (isUsingWindows && process.env.Path?.length)
+            this.env.PATH = `${this.env.PATH};${process.env.Path}`;
+        const ktxPaths = this.env.PATH.split(";").filter(p => p.toLocaleLowerCase().includes("ktx"));
+        if (options.debug) {
+            console.log("INFO: Found these paths including ktx:\n\t" + ktxPaths.join("\n\t") + "");
+        }
+        else if (ktxPaths?.length <= 0) {
+            if (didLogEnvironmentInfo === false)
+                console.log("INFO: Environment variable 'NEEDLE_TOKTX' not set. Use 'NEEDLE_TOKTX' to specify the directory of the toktx installation (path/to/bin)");
+            didLogEnvironmentInfo = true;
+        }
+    }
+    async prepare(document) {
+        try {
+            this.document = document;
+            const logger = document.getLogger();
+            this.version = await checkKTXSoftware(logger, this.env);
+            if (this.version === null) {
+                logger.warn(`WARN: toktx not found, skipping texture compression. Please install KTX-Software >= ${KTX_SOFTWARE_VERSION_MIN}`);
+                this._prepareFailed = true;
+                return false;
+            }
+            this.basisuExtension = document.createExtension(KHRTextureBasisu).setRequired(true);
+            const tmpDir = `${tmp.tmpdir}/gltf-transform`;
+            this.cacheDirectory = tmpDir;
+            if (!(existsSync(tmpDir)))
+                mkdirSync(tmpDir);
+            this.tmpPathBase = tmpDir + "/" + uuid();
+            this.numTextures = document.getRoot().listTextures().length;
+        }
+        catch (e) {
+            console.error(e);
+            console.log("Error preparing toktx transform");
+            this._prepareFailed = true;
+            return false;
+        }
+        return true;
+    }
+    async process(index, texture, settings, context) {
+        const task = async () => {
+            if (this._prepareFailed)
+                return false;
+            const doc = this.document;
+            const logger = doc.getLogger();
+            const slots = listTextureSlots(texture);
+            let channels = getTextureChannelMask(texture);
+            // const textureLabel =
+            //     texture.getURI() ||
+            //     texture.getName() ||
+            //     `${index + 1}/${doc.getRoot().listTextures().length}`;
+            const prefix = `toktx:texture[${index}] ${texture.getName()}`;
+            let srcMimeType = texture.getMimeType();
+            if (srcMimeType === 'image/ktx2') {
+                logger.debug(`${prefix}: Skipping, already KTX.`);
+                return;
+            }
+            else if (srcMimeType !== 'image/png' && srcMimeType !== 'image/jpeg') {
+                logger.warn(`${prefix}: Skipping, unsupported texture type "${texture.getMimeType()}".`);
+                return;
+            }
+            if (slots.length > 0)
+                logger.debug(`${prefix}: Slots → [${slots.join(', ')}]`);
+            else
+                logger.debug(`${prefix}: No slots, assuming default texture.`);
+            let srcImage = texture.getImage();
+            let srcExtension = texture.getURI()
+                ? FileUtils.extension(texture.getURI())
+                : ImageUtils.mimeTypeToExtension(texture.getMimeType());
+            const srcSize = texture.getSize();
+            const srcBytes = srcImage ? srcImage.byteLength : null;
+            if (!srcImage || !srcSize || !srcBytes) {
+                logger.warn(`${prefix}: Skipping, unreadable texture.`);
+                return;
+            }
+            if (!isMultipleOfFour(srcSize[0]) || !isMultipleOfFour(srcSize[1])) {
+                const limitInputPixels = true;
+                const instance = sharp(srcImage, { limitInputPixels }).toFormat('png');
+                const srcSize = ImageUtils.getSize(srcImage, srcMimeType);
+                const dstSize = fitPowerOfTwo(srcSize, 'nearest-pot');
+                dstSize[0] = ceilMultipleOfFour(dstSize[0]);
+                dstSize[1] = ceilMultipleOfFour(dstSize[1]);
+                logger.warn(`${prefix}: Resizing ${srcSize.join('x')} → ${dstSize.join('x')}px`);
+                instance.resize(dstSize[0], dstSize[1], { fit: 'fill', kernel: TextureResizeFilter.LANCZOS3 });
+                const buffer = await instance.toBuffer();
+                srcImage = BufferUtils.toView(new Uint8Array(buffer));
+                srcExtension = 'png';
+                srcMimeType = 'image/png';
+            }
+            const tmpName = this.tmpPathBase + "_" + index;
+            const inPath = tmpName + '.' + srcExtension;
+            const outPath = tmpName + '.ktx2';
+            // const inBytes = image.byteLength;
+            const buffer = Buffer.from(srcImage);
+            await fs.writeFile(inPath, buffer);
+            let mode = Mode.ETC1S;
+            let quality = 128;
+            let compression = 1;
+            if (settings) {
+                if (settings.mode === "auto") {
+                    const useUASTC = slots.includes("normalTexture") || slots.includes("metallicRoughnessTexture");
+                    mode = useUASTC ? Mode.UASTC : Mode.ETC1S;
+                    // in auto-mode we use higher quality for normal and metallicRoughness textures
+                    quality = useUASTC ? 255 : 128;
+                    compression = useUASTC ? 4 : 1;
+                }
+                else {
+                    mode = settings.mode === "ETC1S" ? Mode.ETC1S : Mode.UASTC;
+                }
+            }
+            else if (slots) {
+                const isNormal = slots.includes("normalTexture");
+                const isMetallicRoughness = slots.includes("metallicRoughnessTexture");
+                const betterQuality = isNormal || isMetallicRoughness;
+                mode = Mode.ETC1S;
+                // https://github.khronos.org/KTX-Software/ktxtools/toktx.html
+                quality = betterQuality ? 255 : 128;
+                // ETC1S / BasisLZ compression level, an encoding speed vs. quality tradeoff. Range is [0,5], default is 1. Higher values are slower but give higher quality.
+                compression = betterQuality ? 4 : 1;
+                // For the product usecase we use UASTC for meallicroughness and normal textures
+                if (context.config.usecase === "product") {
+                    if (betterQuality) {
+                        mode = Mode.UASTC;
+                    }
+                    quality = 255;
+                    compression = 4;
+                }
+                else if (slots.includes("lightmapTexture") || isLightmap(texture)) {
+                    quality = 255;
+                    compression = 4;
+                }
+            }
+            const defaults = mode === Mode.ETC1S ? ETC1S_DEFAULTS : UASTC_DEFAULTS;
+            // TODO: should we ensure that the texture is using all channels? Unused channels are discarded anyways. The issue we have here is that textures that are solely used from pointers have unknown channels. We register them with RGBA when generating progressive assets as well as assign texture json pointers /textures/ to
+            // Alpha blended materials to make sure RGBA channels are used when progressive GLBs are compressed (in needle_progressive 377) 
+            // https://linear.app/needle/issue/NE-4985
+            // channels = TextureChannel.R | TextureChannel.G | TextureChannel.B | TextureChannel.A;
+            //@ts-ignore
+            const toktxParams = createParams(texture, slots, channels, srcSize, logger, this.numTextures, { ...defaults, mode, quality, compression });
+            await fs.writeFile(inPath, Buffer.from(srcImage));
+            const params = [
+                'create',
+                ...toktxParams,
+                inPath,
+                outPath,
+            ];
+            logger.debug(`${prefix}: Spawning → toktx ${mode.toUpperCase()} ${params.join(' ')}`);
+            try {
+                // COMPRESS: Run `ktx create` CLI tool.
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const [status, stdout, stderr] = await waitExit(spawn('ktx', params, { env: this.env }));
+                if (status !== 0) {
+                    logger.error(`${prefix}: Failed → \n\n${stderr.toString()}`);
+                }
+                else {
+                    const result = await fs.readFile(outPath);
+                    texture.setImage(result).setMimeType('image/ktx2');
+                    // TODO: we also need to remove the old file when the extension has changed - this should probably be done outside of this method to also support webp
+                    // If this is a texture that was loaded from a file, we need to update the URI
+                    if (texture.getURI()) {
+                        const oldUri = texture.getURI();
+                        const newUri = replaceExtension(oldUri, 'ktx2');
+                        texture.setURI(newUri);
+                    }
+                    const dstBytes = texture.getImage().byteLength;
+                    logger.debug(`${prefix}: ${formatBytes(srcBytes)} → ${formatBytes(dstBytes)}`);
+                    return true;
+                }
+            }
+            catch (err) {
+                logger.error(`${prefix}: Toktx failed → ${err}`);
+            }
+            return false;
+        };
+        return this.limit(task);
+    }
+    async finalize(document) {
+        const usesKTX2 = document
+            .getRoot()
+            .listTextures()
+            .some((t) => t.getMimeType() === 'image/ktx2');
+        if (!usesKTX2) {
+            this.basisuExtension?.dispose();
+        }
+        if (this.cacheDirectory && existsSync(this.cacheDirectory)) {
+            rmSync(this.cacheDirectory, { recursive: true });
+        }
+    }
+}

package/dist/transforms/needle_webp.d.ts

@@ -1,15 +1,15 @@
-import { Document, ILogger, Texture } from '@gltf-transform/core';
-import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
-import { INeedleTextureTransformContext, NeedleTransformContext } from './needle_common.js';
-import sharp from 'sharp';
-export interface NeedleWebPOptions {
-}
-export declare class NeedleWebPContext implements INeedleTextureTransformContext {
-    options: NeedleWebPOptions;
-    logger: ILogger;
-    private compressed;
-    constructor(options: NeedleWebPOptions);
-    prepare(document: Document): Promise<void>;
-    process(index: number, texture: Texture, settings: Pick<NEEDLE_compression_texture_schema, "quality" | "slot"> & Partial<sharp.WebpOptions>, context: NeedleTransformContext): Promise<boolean>;
-    finalize(document: Document): Promise<void>;
-}
+import { Document, ILogger, Texture } from '@gltf-transform/core';
+import { NEEDLE_compression_texture_schema } from '../extensions/index.js';
+import { INeedleTextureTransformContext, NeedleTransformContext } from './needle_common.js';
+import sharp from 'sharp';
+export interface NeedleWebPOptions {
+}
+export declare class NeedleWebPContext implements INeedleTextureTransformContext {
+    options: NeedleWebPOptions;
+    logger: ILogger;
+    private compressed;
+    constructor(options: NeedleWebPOptions);
+    prepare(document: Document): Promise<void>;
+    process(index: number, texture: Texture, settings: Pick<NEEDLE_compression_texture_schema, "quality" | "slot"> & Partial<sharp.WebpOptions>, context: NeedleTransformContext): Promise<boolean>;
+    finalize(document: Document): Promise<void>;
+}

package/dist/transforms/needle_webp.js

@@ -1,53 +1,53 @@
-import sharp from 'sharp';
-import { BufferUtils, HTTPUtils } from '@gltf-transform/core';
-import { EXTTextureWebP } from '@gltf-transform/extensions';
-export class NeedleWebPContext {
-    options;
-    logger;
-    compressed = 0;
-    constructor(options) {
-        this.options = options;
-    }
-    async prepare(document) {
-        this.compressed = 0;
-        this.logger = document.getLogger();
-    }
-    async process(index, texture, settings, context) {
-        const size = texture.getSize();
-        // if the texture is too small we will use lossless compression
-        let lossless = false;
-        if (size[0] < 64 || size[1] < 64) {
-            lossless = true;
-        }
-        const options = {
-            lossless,
-            ...settings,
-            quality: settings.quality,
-            // effort: remap(options.effort, 100, 6),
-            // lossless: options.lossless,
-            // nearLossless: options.nearLossless,
-        };
-        if (typeof options !== "string" && options.quality >= 0) {
-            // the quality range is 0-1 so we remap to 0-100
-            options.quality = Math.round(settings.quality * 100);
-        }
-        if (options.quality < 0) {
-            options.quality = undefined; // If quality is 0 we use the default value
-        }
-        // console.log(options);
-        this.logger.info(`webp:texture[${index}] ${texture.getName()}: Slots → [${settings.slot}] with quality '${options.quality === undefined ? 'default' : options.quality}'`);
-        const buffer = await sharp(texture.getImage()).toFormat('webp', options).toBuffer();
-        texture
-            .setMimeType('image/webp')
-            .setImage(BufferUtils.toView(buffer))
-            .setURI(HTTPUtils.basename(texture.getURI()) + '.webp');
-        this.compressed += 1;
-        return true;
-    }
-    async finalize(document) {
-        if (this.compressed > 0) {
-            const webpExtension = document.createExtension(EXTTextureWebP);
-            webpExtension.setRequired(true);
-        }
-    }
-}
+import sharp from 'sharp';
+import { BufferUtils, HTTPUtils } from '@gltf-transform/core';
+import { EXTTextureWebP } from '@gltf-transform/extensions';
+export class NeedleWebPContext {
+    options;
+    logger;
+    compressed = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    async prepare(document) {
+        this.compressed = 0;
+        this.logger = document.getLogger();
+    }
+    async process(index, texture, settings, context) {
+        const size = texture.getSize();
+        // if the texture is too small we will use lossless compression
+        let lossless = false;
+        if (size[0] < 64 || size[1] < 64) {
+            lossless = true;
+        }
+        const options = {
+            lossless,
+            ...settings,
+            quality: settings.quality,
+            // effort: remap(options.effort, 100, 6),
+            // lossless: options.lossless,
+            // nearLossless: options.nearLossless,
+        };
+        if (typeof options !== "string" && options.quality >= 0) {
+            // the quality range is 0-1 so we remap to 0-100
+            options.quality = Math.round(settings.quality * 100);
+        }
+        if (options.quality < 0) {
+            options.quality = undefined; // If quality is 0 we use the default value
+        }
+        // console.log(options);
+        this.logger.info(`webp:texture[${index}] ${texture.getName()}: Slots → [${settings.slot}] with quality '${options.quality === undefined ? 'default' : options.quality}'`);
+        const buffer = await sharp(texture.getImage()).toFormat('webp', options).toBuffer();
+        texture
+            .setMimeType('image/webp')
+            .setImage(BufferUtils.toView(buffer))
+            .setURI(HTTPUtils.basename(texture.getURI()) + '.webp');
+        this.compressed += 1;
+        return true;
+    }
+    async finalize(document) {
+        if (this.compressed > 0) {
+            const webpExtension = document.createExtension(EXTTextureWebP);
+            webpExtension.setRequired(true);
+        }
+    }
+}