@needle-tools/gltf-build-pipeline 0.1.0

package/dist/transforms/needle_webp.js

@@ -0,0 +1,53 @@
+import { WebPEncoderOptions } from "./types/squoosh.js";
+import sharp from 'sharp';
+import { BufferUtils, HTTPUtils } from '@gltf-transform/core';
+var Codec;
+(function (Codec) {
+    Codec["OXIPNG"] = "oxipng";
+    Codec["MOZJPEG"] = "mozjpeg";
+    Codec["WEBP"] = "webp";
+})(Codec || (Codec = {}));
+const CODEC_TO_MIME_TYPE = {
+    [Codec.OXIPNG]: 'image/png',
+    [Codec.MOZJPEG]: 'image/jpeg',
+    [Codec.WEBP]: 'image/webp',
+};
+const defaultWebpCodecOptions = new WebPEncoderOptions();
+defaultWebpCodecOptions.quality = 90;
+defaultWebpCodecOptions.filter_type = 0; // turn strong filter off
+defaultWebpCodecOptions.use_sharp_yuv = 1; // use sharp rgb -> YUV conversion
+export class NeedleWebPContext {
+    options;
+    logger;
+    constructor(options) {
+        this.options = options;
+    }
+    async prepare(document) {
+        this.logger = document.getLogger();
+    }
+    async process(index, texture, settings) {
+        const options = {
+            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 = settings.quality * 100;
+        }
+        if (options.quality <= 0) {
+            options.quality = 1;
+        }
+        // console.log(options);
+        console.log(`> Will compress texture ${texture.getName()} to webp with quality ${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');
+        return true;
+    }
+    async finalize(document) {
+    }
+}

package/dist/transforms/toktx.d.ts

@@ -0,0 +1,77 @@
+import { Document, ILogger, vec2, Texture } from '@gltf-transform/core';
+/**********************************************************************************************
+ * Interfaces.
+ */
+export declare const Mode: {
+    ETC1S: string;
+    UASTC: string;
+};
+export declare const Filter: {
+    BOX: string;
+    TENT: string;
+    BELL: string;
+    BSPLINE: string;
+    MITCHELL: string;
+    LANCZOS3: string;
+    LANCZOS4: string;
+    LANCZOS6: string;
+    LANCZOS12: string;
+    BLACKMAN: string;
+    KAISER: string;
+    GAUSSIAN: string;
+    CATMULLROM: string;
+    QUADRATIC_INTERP: string;
+    QUADRATIC_APPROX: string;
+    QUADRATIC_MIX: string;
+};
+export type TextureModeArgs = {
+    doc: Document;
+    texture: Texture;
+    index: number;
+    options: ETC1SOptions | UASTCOptions;
+};
+export type TextureParamsArgs = {
+    doc: Document;
+    texture: Texture;
+    index: number;
+    params: Array<string | number>;
+};
+export interface ToktxOptions {
+    toktxPath?: string;
+    /** return false if texture should not be compressed */
+    modifyOptions?: (args: TextureModeArgs) => void | boolean;
+    modifyParams?: (args: TextureParamsArgs) => void;
+}
+export interface GlobalOptions {
+    mode: string;
+    slots?: string;
+    filter?: string;
+    filterScale?: number;
+    powerOfTwo?: boolean;
+    jobs?: number;
+}
+export interface ETC1SOptions extends GlobalOptions {
+    quality?: number;
+    compression?: number;
+    maxEndpoints?: number;
+    maxSelectors?: number;
+    rdoOff?: boolean;
+    rdoThreshold?: number;
+}
+export interface UASTCOptions extends GlobalOptions {
+    level?: number;
+    rdo?: number;
+    rdoDictionarySize?: number;
+    rdoBlockScale?: number;
+    rdoStdDev?: number;
+    rdoMultithreading?: boolean;
+    zstd?: number;
+}
+export declare const ETC1S_DEFAULTS: Omit<ETC1SOptions, 'mode'>;
+export declare const UASTC_DEFAULTS: Omit<UASTCOptions, 'mode'>;
+/**********************************************************************************************
+ * Utilities.
+ */
+/** Create CLI parameters from the given options. Attempts to write only non-default options. */
+export declare function createParams(slots: string[], channels: number, size: vec2, logger: ILogger, numTextures: number, options: ETC1SOptions | UASTCOptions, version: string): (string | number)[];
+export declare function checkKTXSoftware(logger: ILogger, env?: any): Promise<string>;

package/dist/transforms/toktx.js

@@ -0,0 +1,230 @@
+import micromatch from 'micromatch';
+import os from 'os';
+import semver from 'semver';
+import tmp from 'tmp';
+import { TextureChannel } from '@gltf-transform/core';
+// import { TextureBasisu } from '@gltf-transform/extensions';
+// import { getTextureChannelMask, listTextureSlots } from '@gltf-transform/functions';
+import { execSync } from 'child_process';
+import { spawn, commandExists, waitExit, MICROMATCH_OPTIONS } from './util.js';
+// import { existsSync, mkdirSync } from 'fs';
+// import { tryGetFromCache, getKey, addToCache } from '../cache';
+// import { resizeTextureIfNecessary } from "./needle_texture_transform"
+tmp.setGracefulCleanup();
+const NUM_CPUS = os.cpus().length || 1; // microsoft/vscode#112122
+const KTX_SOFTWARE_VERSION_MIN = '4.0.0-rc1';
+const KTX_SOFTWARE_VERSION_ACTIVE = '4.1.0-rc1';
+const { R, G } = TextureChannel;
+/**********************************************************************************************
+ * Interfaces.
+ */
+export const Mode = {
+    ETC1S: 'etc1s',
+    UASTC: 'uastc',
+};
+export const Filter = {
+    BOX: 'box',
+    TENT: 'tent',
+    BELL: 'bell',
+    BSPLINE: 'b-spline',
+    MITCHELL: 'mitchell',
+    LANCZOS3: 'lanczos3',
+    LANCZOS4: 'lanczos4',
+    LANCZOS6: 'lanczos6',
+    LANCZOS12: 'lanczos12',
+    BLACKMAN: 'blackman',
+    KAISER: 'kaiser',
+    GAUSSIAN: 'gaussian',
+    CATMULLROM: 'catmullrom',
+    QUADRATIC_INTERP: 'quadratic_interp',
+    QUADRATIC_APPROX: 'quadratic_approx',
+    QUADRATIC_MIX: 'quadratic_mix',
+};
+const GLOBAL_DEFAULTS = {
+    filter: Filter.LANCZOS4,
+    filterScale: 1,
+    powerOfTwo: false,
+    slots: '*',
+    // See: https://github.com/donmccurdy/glTF-Transform/pull/389#issuecomment-1089842185
+    jobs: 2 * NUM_CPUS,
+};
+export const ETC1S_DEFAULTS = {
+    quality: 128,
+    compression: 1,
+    ...GLOBAL_DEFAULTS,
+};
+export const UASTC_DEFAULTS = {
+    level: 2,
+    rdo: 0,
+    rdoDictionarySize: 32768,
+    rdoBlockScale: 10.0,
+    rdoStdDev: 18.0,
+    rdoMultithreading: true,
+    zstd: 18,
+    ...GLOBAL_DEFAULTS,
+};
+/**********************************************************************************************
+ * Utilities.
+ */
+/** Create CLI parameters from the given options. Attempts to write only non-default options. */
+export function createParams(slots, channels, size, logger, numTextures, options, version) {
+    const params = [];
+    params.push('--genmipmap');
+    if (options.filter !== GLOBAL_DEFAULTS.filter)
+        params.push('--filter', options.filter);
+    if (options.filterScale !== GLOBAL_DEFAULTS.filterScale) {
+        params.push('--fscale', options.filterScale);
+    }
+    if (options.mode === Mode.UASTC) {
+        const _options = options;
+        params.push('--uastc', _options.level);
+        if (_options.rdo !== UASTC_DEFAULTS.rdo) {
+            params.push('--uastc_rdo_l', _options.rdo);
+        }
+        if (_options.rdoDictionarySize !== UASTC_DEFAULTS.rdoDictionarySize) {
+            params.push('--uastc_rdo_d', _options.rdoDictionarySize);
+        }
+        if (_options.rdoBlockScale !== UASTC_DEFAULTS.rdoBlockScale) {
+            params.push('--uastc_rdo_b', _options.rdoBlockScale);
+        }
+        if (_options.rdoStdDev !== UASTC_DEFAULTS.rdoStdDev) {
+            params.push('--uastc_rdo_s', _options.rdoStdDev);
+        }
+        if (!_options.rdoMultithreading) {
+            params.push('--uastc_rdo_m');
+        }
+        if (_options.zstd && _options.zstd > 0)
+            params.push('--zcmp', _options.zstd);
+    }
+    else {
+        const _options = options;
+        params.push('--bcmp');
+        if (_options.quality !== ETC1S_DEFAULTS.quality) {
+            params.push('--qlevel', _options.quality);
+        }
+        if (_options.compression !== ETC1S_DEFAULTS.compression) {
+            params.push('--clevel', _options.compression);
+        }
+        if (_options.maxEndpoints)
+            params.push('--max_endpoints', _options.maxEndpoints);
+        if (_options.maxSelectors)
+            params.push('--max_selectors', _options.maxSelectors);
+        if (_options.rdoOff) {
+            params.push('--no_endpoint_rdo', '--no_selector_rdo');
+        }
+        else if (_options.rdoThreshold) {
+            params.push('--endpoint_rdo_threshold', _options.rdoThreshold);
+            params.push('--selector_rdo_threshold', _options.rdoThreshold);
+        }
+    }
+    if (slots.find((slot) => micromatch.isMatch(slot, '*normal*', MICROMATCH_OPTIONS))) {
+        // See: https://github.com/KhronosGroup/KTX-Software/issues/600
+        if (semver.gte(version, KTX_SOFTWARE_VERSION_ACTIVE)) {
+            params.push('--normal_mode', '--input_swizzle', 'rgb1');
+        }
+        else if (options.mode === Mode.ETC1S) {
+            params.push('--normal_map');
+        }
+    }
+    if (slots.length && !slots.find((slot) => micromatch.isMatch(slot, '*{color,emissive}*', MICROMATCH_OPTIONS))) {
+        // See: https://github.com/donmccurdy/glTF-Transform/issues/215
+        params.push('--assign_oetf', 'linear', '--assign_primaries', 'none');
+    }
+    if (channels === R) {
+        params.push('--target_type', 'R');
+    }
+    else if (channels === G || channels === (R | G)) {
+        params.push('--target_type', 'RG');
+    }
+    // Minimum size on any dimension is 4px.
+    // See: https://github.com/donmccurdy/glTF-Transform/issues/502
+    let width;
+    let height;
+    if (options.powerOfTwo) {
+        width = preferredPowerOfTwo(size[0]);
+        height = preferredPowerOfTwo(size[1]);
+    }
+    else {
+        if (!isPowerOfTwo(size[0]) || !isPowerOfTwo(size[1])) {
+            logger.warn(`toktx: Texture dimensions ${size[0]}x${size[1]} are NPOT, and may` +
+                ' fail in older APIs (including WebGL 1.0) on certain devices.');
+        }
+        width = isMultipleOfFour(size[0]) ? size[0] : ceilMultipleOfFour(size[0]);
+        height = isMultipleOfFour(size[1]) ? size[1] : ceilMultipleOfFour(size[1]);
+    }
+    if (width !== size[0] || height !== size[1]) {
+        if (width > 4096 || height > 4096) {
+            logger.warn(`toktx: Resizing to nearest power of two, ${width}x${height}px. Texture dimensions` +
+                ' greater than 4096px may not render on some mobile devices.' +
+                ' Resize to a lower resolution before compressing, if needed.');
+        }
+        params.push('--resize', `${width}x${height}`);
+    }
+    if (options.jobs && options.jobs > 1 && numTextures > 1) {
+        // See: https://github.com/donmccurdy/glTF-Transform/pull/389#issuecomment-1089842185
+        const threads = Math.max(2, Math.min(NUM_CPUS, (3 * NUM_CPUS) / numTextures));
+        params.push('--threads', threads);
+    }
+    return params;
+}
+export async function checkKTXSoftware(logger, env) {
+    const [status, stdout, stderr] = await waitExit(spawn('toktx', ['--version'], { env: env }));
+    const version = (stdout || stderr)
+        .replace(/toktx\s+/, '')
+        .replace(/~\d+/, '')
+        .trim();
+    if (status !== 0 || !semver.valid(semver.clean(version))) {
+        throw new Error('Unable to find "toktx" version. Confirm KTX-Software is installed from:\n\nhttps://github.com/KhronosGroup/KTX-Software.');
+    }
+    else if (semver.lt(semver.clean(version), KTX_SOFTWARE_VERSION_MIN)) {
+        logger.warn(`toktx: Expected KTX-Software >= v${KTX_SOFTWARE_VERSION_MIN}, found ${version}.`);
+    }
+    else {
+        logger.debug(`toktx: Found KTX-Software ${version}.`);
+    }
+    return semver.clean(version);
+}
+async function toktxCommandExistsSync(env) {
+    if (env) {
+        // if env is defined use that to check if toktx is installed
+        try {
+            execSync('toktx --version', { encoding: 'utf-8', env: env });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    else if (!await commandExists('toktx')) {
+        return false;
+    }
+    return true;
+}
+function isPowerOfTwo(value) {
+    if (value <= 2)
+        return true;
+    return (value & (value - 1)) === 0 && value !== 0;
+}
+function preferredPowerOfTwo(value) {
+    if (value <= 4)
+        return 4;
+    const lo = floorPowerOfTwo(value);
+    const hi = ceilPowerOfTwo(value);
+    if (hi - value > value - lo)
+        return lo;
+    return hi;
+}
+function floorPowerOfTwo(value) {
+    return Math.pow(2, Math.floor(Math.log(value) / Math.LN2));
+}
+function ceilPowerOfTwo(value) {
+    return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2));
+}
+function isMultipleOfFour(value) {
+    return value % 4 === 0;
+}
+function ceilMultipleOfFour(value) {
+    if (value <= 4)
+        return 4;
+    return value % 4 ? value + 4 - (value % 4) : value;
+}

package/dist/transforms/types/squoosh.d.ts

@@ -0,0 +1,31 @@
+export declare class WebPEncoderOptions {
+    quality: number;
+    target_size: number;
+    target_PSNR: number;
+    method: number;
+    sns_strength: number;
+    filter_strength: number;
+    filter_sharpness: number;
+    /** 1 = strong filter */
+    filter_type: number;
+    partitions: number;
+    segments: number;
+    pass: number;
+    show_compressed: number;
+    preprocessing: number;
+    autofilter: number;
+    partition_limit: number;
+    alpha_compression: number;
+    alpha_filtering: number;
+    alpha_quality: number;
+    lossless: number;
+    exact: number;
+    image_hint: number;
+    emulate_jpeg_size: number;
+    thread_level: number;
+    low_memory: number;
+    near_lossless: number;
+    use_delta_palette: number;
+    /** probably sharp rgb -> YUV conversion */
+    use_sharp_yuv: number;
+}

package/dist/transforms/types/squoosh.js

@@ -0,0 +1,33 @@
+// client: https://github.com/GoogleChromeLabs/squoosh/blob/97d13de273b67ee01a80cb32161f1bb2103b73cb/src/features/encoders/webP/client/index.tsx#L292
+// emscripten bindings: 
+export class WebPEncoderOptions {
+    quality = 75;
+    target_size = 0;
+    target_PSNR = 0;
+    method = 4;
+    sns_strength = 50;
+    filter_strength = 60;
+    filter_sharpness = 0;
+    /** 1 = strong filter */
+    filter_type = 1;
+    partitions = 0;
+    segments = 4;
+    pass = 1;
+    show_compressed = 0;
+    preprocessing = 0;
+    autofilter = 0;
+    partition_limit = 0;
+    alpha_compression = 1;
+    alpha_filtering = 1;
+    alpha_quality = 100;
+    lossless = 0;
+    exact = 0;
+    image_hint = 0;
+    emulate_jpeg_size = 0;
+    thread_level = 0;
+    low_memory = 0;
+    near_lossless = 100;
+    use_delta_palette = 0;
+    /** probably sharp rgb -> YUV conversion */
+    use_sharp_yuv = 0;
+}

package/dist/transforms/util.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+import { spawn as _spawn } from 'child_process';
+import type { ChildProcess } from 'child_process';
+export declare const XMPContext: Record<string, string>;
+export declare const MICROMATCH_OPTIONS: {
+    nocase: boolean;
+    contains: boolean;
+};
+export declare let spawn: typeof _spawn;
+export declare let commandExists: (cmd: string) => any;
+export declare let waitExit: typeof _waitExit;
+export declare function mockSpawn(_spawn: unknown): void;
+export declare function mockCommandExists(_commandExists: (n: string) => Promise<boolean>): void;
+export declare function mockWaitExit(_waitExit: (process: ChildProcess) => Promise<[unknown, string, string]>): void;
+export declare function _waitExit(process: ChildProcess): Promise<[unknown, string, string]>;
+export declare function formatLong(x: number): string;
+export declare function formatBytes(bytes: number, decimals?: number): string;
+export declare function formatParagraph(str: string): string;
+export declare function formatHeader(title: string): string;
+export declare function formatXMP(value: string | number | boolean | Record<string, unknown> | null): string;
+export declare function underline(str: string): string;

package/dist/transforms/util.js

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+import { spawn as _spawn } from 'child_process';
+import _commandExists from 'command-exists';
+// Constants.
+export const XMPContext = {
+    dc: 'http://purl.org/dc/elements/1.1/',
+    model3d: 'https://schema.khronos.org/model3d/xsd/1.0/',
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    xmp: 'http://ns.adobe.com/xap/1.0/',
+    xmpRights: 'http://ns.adobe.com/xap/1.0/rights/',
+};
+// Using 'micromatch' because 'contains: true' did not work as expected with
+// minimatch. Need to ensure that '*' matches patterns like 'image/png'.
+export const MICROMATCH_OPTIONS = { nocase: true, contains: true };
+// Mocks for tests.
+export let spawn = _spawn;
+// See https://github.com/mathisonian/command-exists/issues/22
+export let commandExists = (cmd) => _commandExists(cmd)?.catch(() => false) ?? false;
+export let waitExit = _waitExit;
+export function mockSpawn(_spawn) {
+    //@ts-ignore
+    spawn = _spawn;
+}
+export function mockCommandExists(_commandExists) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    commandExists = _commandExists;
+}
+export function mockWaitExit(_waitExit) {
+    waitExit = _waitExit;
+}
+export async function _waitExit(process) {
+    let stdout = '';
+    if (process.stdout) {
+        for await (const chunk of process.stdout) {
+            stdout += chunk;
+        }
+    }
+    let stderr = '';
+    if (process.stderr) {
+        for await (const chunk of process.stderr) {
+            stderr += chunk;
+        }
+    }
+    const status = await new Promise((resolve, _) => {
+        process.on('close', resolve);
+    });
+    return [status, stdout, stderr];
+}
+// Formatting.
+export function formatLong(x) {
+    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+export function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1000;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+export function formatParagraph(str) {
+    return str
+        .match(/.{1,80}(\s|$)/g)
+        .map((line) => line.trim())
+        .join('\n');
+}
+export function formatHeader(title) {
+    return '' + '\n ' + title.toUpperCase() + '\n ────────────────────────────────────────────';
+}
+export function formatXMP(value) {
+    if (!value) {
+        return '';
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value.toString();
+    }
+    if (value['@list']) {
+        const list = value['@list'];
+        const hasCommas = list.some((value) => value.indexOf(',') > 0);
+        return list.join(hasCommas ? '; ' : ', ');
+    }
+    if (value['@type'] === 'rdf:Alt') {
+        return value['rdf:_1']['@value'];
+    }
+    return JSON.stringify(value);
+}
+export function underline(str) {
+    return `\x1b[4m${str}\x1b[0m`;
+}

package/dist/utils/fileutils.d.ts

@@ -0,0 +1,2 @@
+export declare type GLTFFileCallback = (file: string) => void | Promise<void>;
+export declare function foreachGLTF(args: string | string[], callback: GLTFFileCallback): void;

package/dist/utils/fileutils.js

@@ -0,0 +1,95 @@
+import { existsSync, statSync, readdirSync, readFileSync } from 'fs';
+import { isAbsolute } from 'path';
+export function foreachGLTF(args, callback) {
+    // get original directory this run was invoked from
+    const initDir = process.env.INIT_CWD;
+    const context = {
+        baseDirectory: initDir,
+        filesFound: 0
+    };
+    // traverse recursively through all files and directories
+    if (Array.isArray(args)) {
+        for (const arg of args) {
+            testEntry(arg, callback, context);
+        }
+    }
+    else if (typeof args === "string") {
+        testEntry(args, callback, context);
+    }
+    // try to run with needle config
+    if (context.filesFound <= 0 && context.baseDirectory) {
+        const needleConfigPath = context.baseDirectory + "/needle.config.json";
+        if (existsSync(needleConfigPath)) {
+            const config = JSON.parse(readFileSync(needleConfigPath, "utf8"));
+            const buildDirectory = config.buildDirectory;
+            if (buildDirectory?.length) {
+                // If it's an absolute path
+                if (existsSync(buildDirectory)) {
+                    console.log("INFO: Using build directory from needle.config.json: " + buildDirectory);
+                    testEntry(buildDirectory, callback, context);
+                }
+                else { // if its a relative path
+                    const newPath = context.baseDirectory + "/" + buildDirectory;
+                    if (existsSync(newPath)) {
+                        console.log("INFO: Using build directory from needle.config.json: " + newPath);
+                        testEntry(newPath, callback, context);
+                    }
+                }
+            }
+        }
+    }
+    if (context.filesFound <= 0) {
+        console.log("WARN: No glTF files found. Make sure to invoke with a valid path to a glTF file or directory. This path may be relative to " + initDir);
+    }
+}
+function testEntry(entry, callback, context) {
+    if (entry === "." || entry === "./") {
+        if (context.baseDirectory) {
+            entry = context.baseDirectory;
+        }
+    }
+    if (existsSync(entry) === false) {
+        // If no base directory is defined we cannot try to resolve the path
+        if (context.baseDirectory === undefined) {
+            return;
+        }
+        // Try resolve potential relative path
+        const newPath = context.baseDirectory + "/" + entry;
+        console.log(newPath);
+        if (existsSync(newPath) === false) {
+            return;
+        }
+        else {
+            console.log(`INFO: Resolved path: ${entry} -> ${newPath}`);
+            entry = newPath;
+        }
+    }
+    else {
+        // When passing in a relative path (e.g. `dist`) we dont want to accidentally traverse this package's directory
+        // So in that case make sure we resolve to an absolute path relative to the calling directory
+        const isAbs = isAbsolute(entry);
+        if (!isAbs) {
+            if (context.baseDirectory) {
+                const newPath = context.baseDirectory + "/" + entry;
+                console.log(`INFO: Resolved path: ${entry} -> ${newPath}`);
+                entry = newPath;
+                if (!existsSync(entry)) {
+                    return;
+                }
+            }
+        }
+    }
+    if (entry.endsWith(".glb") || entry.endsWith(".gltf")) {
+        context.filesFound += 1;
+        callback(entry);
+    }
+    else {
+        const stat = statSync(entry);
+        if (stat.isDirectory()) {
+            const files = readdirSync(entry);
+            for (const file of files) {
+                testEntry(entry + "/" + file, callback, context);
+            }
+        }
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./fileutils.js";

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from "./fileutils.js";

package/fileutils.mjs

@@ -0,0 +1,6 @@
+import { foreachGLTF as foreach } from './dist/index.js';
+
+
+export function foreachGLTF(args, callback) {
+    return foreach(args, callback);
+}

package/index.mjs

@@ -0,0 +1,33 @@
+
+
+import { spawnSync } from "child_process";
+const workingDir = process.cwd();
+
+// Original invoked dir set by npm
+// const dir = process.env.INIT_CWD;
+
+
+const defaultArgs = { shell: true, cwd: workingDir, stdio: 'inherit' }
+
+function getCommandLineArgs(_cmd) {
+    // Wrap paths with parentheses if they contain spaces
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.includes("\\") || arg.includes("/")) {
+            if (arg.includes(" "))
+                args[i] = "\"" + arg + "\"";
+        }
+    }
+    return args;
+}
+
+
+function runWithArgs(cmd) {
+    const commandline_args = getCommandLineArgs(cmd).join(" ");
+    spawnSync(cmd + " " + commandline_args, defaultArgs);
+}
+
+
+runWithArgs("node make-progressive.mjs");
+runWithArgs("node pack-gltf.mjs");