Needle Engine 3.47.3-beta

Files changed (11) hide show

plugins/vite/build-pipeline.js +62 -233
plugins/common/buildinfo.js +3 -4
plugins/vite/buildinfo.js +14 -20
plugins/vite/copyfiles.js +67 -66
plugins/common/files.js +0 -31
plugins/vite/index.js +1 -1
plugins/common/timers.js +0 -8
src/engine/engine_element.ts +1 -0
src/engine/engine_utils_screenshot.ts +1 -1
plugins/types/needleConfig.d.ts +0 -3
plugins/types/userconfig.d.ts +5 -23

plugins/vite/build-pipeline.js CHANGED Viewed

@@ -1,85 +1,21 @@
-import { ChildProcess, exec } from 'child_process';
-import { getOutputDirectory, loadConfig } from './config.js';
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
-import { copyFilesSync } from '../common/files.js';
-import { delay } from '../common/timers.js';
+import { ChildProcess, exec, execSync, spawn } from 'child_process';
+import { getOutputDirectory, loadConfig, tryLoadProjectConfig } from './config.js';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs';
-/**
- * @param {import('../types').userSettings} config
- * @returns {boolean}
- */
-function validateCloudBuildConfiguration(config) {
-    if (config.buildPipeline != undefined) {
-        if (process.env.CI) {
-            if ((process.env.NEEDLE_CLOUD_TOKEN == undefined || process.env.NEEDLE_CLOUD_TOKEN.length <= 0)) {
-                const isGithubAction = process.env.CI && process.env.GITHUB_ACTION;
-                let msg = `Missing Needle Cloud access token. Please set your Needle Cloud token via \`process.env.NEEDLE_CLOUD_TOKEN\`.`;
-                if (isGithubAction) {
-                    msg += `
-Make sure to pass the token as a secret to the Github action.
-For this you may have to modify your .github workflow yaml file to include the following code:
-env:
-- NEEDLE_CLOUD_TOKEN: \${{ secrets.NEEDLE_CLOUD_TOKEN }}
-`;
-                    let error = `${msg}`;
-                    throw new Error(error);
-                }
-            }
-        }
-    }
-    return true;
-}
 // see https://linear.app/needle/issue/NE-3798
+export let buildPipelineTask;
-/**  @type {Promise<any>|null} */
-let buildPipelineTask;
-/** @type {null | {tempDirectory:string, outputDirectory:string}} */
-let buildPipelineTaskResults = null;
-export function waitForBuildPipelineToFinish() {
-    return buildPipelineTask;
-}
-/** This time is set when a build plugin is triggered to run
- * We increase the time by 10-20 seconds each time because we might have a multi step process
- * where the build pipeline is triggered in the SSR build (which we can not always detect)
- * and the final client build is triggered later (but the build pipeline is still running and waiting)
- */
-let maxOutputDirectoryCreatedWaitTime = 0;
 /**
- * @param {boolean} debugLog
- */
-function increaseMaxWaitTime(debugLog) {
-    maxOutputDirectoryCreatedWaitTime = Date.now();
-    let maxWaitTime = 10_000;
-    if (process.env.CI) {
-        maxWaitTime += 50_000;
-    }
-    maxOutputDirectoryCreatedWaitTime += maxWaitTime;
-    if (debugLog) {
-        log(`Increased max wait time by ${maxWaitTime / 1000}sec until ${new Date(maxOutputDirectoryCreatedWaitTime).toISOString()}`);
-    }
-}
-/**
  * Runs the needle build pipeline as part of the vite build process
- * @param {string} command
- * @param {import('vite').UserConfig} config
  * @param {import('../types').userSettings} userSettings
- * @returns {Promise<import('vite').Plugin | null>}
+ * @returns {import('vite').Plugin}
  */
 export const needleBuildPipeline = async (command, config, userSettings) => {
     // we only want to run compression here if this is a distribution build
     // this is handled however in the `apply` hook
-    if (userSettings.noBuildPipeline) return null;
-    if (userSettings.buildPipeline?.enabled === false) {
-        log("Skipping build pipeline because it is disabled in the user settings via `buildPipeline.enabled: false`");
-        return null;
-    }
+    if (userSettings.noBuildPipeline) return;
     const packageJsonPath = process.cwd() + "/package.json";
     await fixPackageJson(packageJsonPath);
@@ -100,98 +36,43 @@
     if (!shouldRun) {
         log("Skipping build pipeline because this is a development build.\n- Invoke with `--production` to run the build pipeline.\n- For example \"vite build -- --production\".");
         await new Promise((resolve, _) => setTimeout(resolve, 1000));
-        return null;
+        return;
     }
-    if (process.env.CI) {
-        log("Running in CI environment");
-    }
-    validateCloudBuildConfiguration(userSettings);
-    const verboseOutput = userSettings?.buildPipeline?.verbose || false;
-    let taskHasCompleted = false;
+    /** @type {Promise<any>|null} */
+    let task = null;
+    let taskFinished = false;
+    let taskSucceeded = false;
     return {
         name: 'needle-buildpipeline',
         enforce: "post",
-        apply: (_conf, env) => {
-            if (verboseOutput) {
-                log("Apply:", env);
-            }
-            // Don't run for SSR builds (e.g. sveltekit).
-            // Unfortunately this is always falls in vite 4.3 so we can not rely on it solely
-            if (env.ssrBuild) return false;
-            // Dont run if there's already a build pipeline task running
-            if (env.command === "build") {
-                increaseMaxWaitTime(verboseOutput);
-                if (buildPipelineTask) {
-                    return false;
-                }
-                return true;
-            }
-            return false;
+        apply: 'build',
+        buildEnd() {
+            // start the compression process once vite is done copying the files
+            task = invokeBuildPipeline(userSettings).then((res) => {
+                taskFinished = true;
+                taskSucceeded = res;
+            });
+            buildPipelineTask = task;
         },
-        buildEnd(error) {
-            increaseMaxWaitTime(verboseOutput);
-            if (verboseOutput) {
-                log("Build end:", error ?? "No error");
-            }
-            if (error) {
-                // if there was an error during the build we should not run the build pipeline
-            }
-            else {
-                if (buildPipelineTask) {
-                    log("Build pipeline already running...");
-                    return;
-                }
-                let taskSucceeded = false;
-                // start the compression process once vite is done copying the files
-                buildPipelineTask = invokeBuildPipeline(userSettings)
-                    .then((res) => {
-                        taskSucceeded = res;
-                    })
-                    .finally(() => {
-                        taskHasCompleted = true;
-                        if (!taskSucceeded) {
-                            throw new Error("[needle-buildpipeline] - Build pipeline failed. Check the logs for more information.");
-                        }
-                        else {
-                            log("Finished successfully");
-                        }
-                    });
-            }
-        },
         closeBundle() {
-            if (!buildPipelineTask) {
-                return;
-            }
-            if (!taskHasCompleted) {
-                log("Waiting for build pipeline to finish...");
-            }
-            // // this is the last hook that is called, so we can wait for the task to finish here
-            return buildPipelineTask = buildPipelineTask?.then(() => {
-                // Copy the results to their final output directory.
-                if (buildPipelineTaskResults != null) {
-                    log("Copying files from temporary output directory to final output directory...");
-                    const ctx = { count: 0 }
-                    copyFilesSync(buildPipelineTaskResults.tempDirectory, buildPipelineTaskResults.outputDirectory, true, ctx);
-                    log(`Copied ${ctx.count} file(s)`);
-                }
-                else {
-                    log("No files to copy - build pipeline did not run or did not finish successfully");
-                }
+            log("Waiting for postprocessing to finish...");
+            // this is the last hook that is called, so we can wait for the task to finish here
+            if (taskFinished) return;
+            // delay the final log slightly to give other plugins a chance to log their stuff
+            wait(100).then(() => {
+                if (!taskFinished) log("Waiting for postprocessing to finish...")
             });
+            return task.then(_ => {
+                log("finished", taskSucceeded ? "successfully" : "with errors");
+            });
         },
     }
 }
 /**
  * Previously we did always install the build pipeline and run an extra command to invoke the build pipeline.
  * This is now done automatically by the needle build pipeline plugin - so we update all legacy projects to use the new method.
- * @param {string} packageJsonPath
  */
 async function fixPackageJson(packageJsonPath) {
     if (!existsSync(packageJsonPath)) {
@@ -208,11 +89,9 @@
     writeFileSync(packageJsonPath, fixed);
 }
-/** @param {any} args */
 function log(...args) {
     console.log("[needle-buildpipeline]", ...args);
 }
-/** @param {any} args */
 function warn(...args) {
     console.warn("WARN: [needle-buildpipeline]", ...args);
 }
@@ -225,113 +104,63 @@
     const installPath = "node_modules/@needle-tools/gltf-build-pipeline";
     const fullInstallPath = process.cwd() + "/" + installPath;
     const existsLocally = existsSync(fullInstallPath);
-    if (existsLocally) {
-        log("Found local build pipeline installation at " + fullInstallPath);
+    if (!existsLocally) {
+        // await execSync("npx --yes @needle-tools/n")
+        // throw new Error(`ERR: Build pipeline not found at \"${fullInstallPath}\". \nTo disable this plugin you can pass \"noBuildPipeline: true\" to the needle config in vite.config.js`);
+        warn("@needle-tools/gltf-build-pipeline not found in package - using latest version")
     }
-    await delay(500);
+    await wait(500);
     const outputDirectory = getOutputDirectory() + "/assets";
-    const startWaitTime = Date.now();
-    const maxEndTime = startWaitTime + 120_000;
-    /** wait until the output directory exists
-     * @param {number} iteration
-     * @returns {Promise<boolean>}
-     */
+    // wait until the output directory exists - this depends on speed
     function waitForOutputDirectory(iteration) {
-        // we wait for the output directory
         if (!existsSync(outputDirectory)) {
-            if (maxOutputDirectoryCreatedWaitTime != 0 && Date.now() > maxOutputDirectoryCreatedWaitTime) {
+            if (iteration > 10) {
                 return Promise.resolve(false);
             }
-            else if (Date.now() > maxEndTime) {
-                log("Max wait time exceeded - aborting...");
-                return Promise.resolve(false);
-            }
-            if (iteration <= 0) log(`Waiting for output directory to be created... (${outputDirectory})`);
-            return delay(1000).then(() => waitForOutputDirectory(iteration + 1));
+            if (iteration <= 0) log("Waiting for output directory to be created...");
+            return wait(1000).then(() => waitForOutputDirectory(iteration + 1));
         }
         return Promise.resolve(true);
     }
     if (!await waitForOutputDirectory(0)) {
-        warn(`Output directory not found/created at \"${outputDirectory}\" - aborting...`);
-        return false;
+        warn("Directory not found at " + outputDirectory);
+        return;
     }
-    const files = readdirSync(outputDirectory).filter(f => f.endsWith(".glb") || f.endsWith(".gltf") || f.endsWith(".vrm") || f.endsWith(".fbx"));
-    log(`${files.length} file(s) to process in ${outputDirectory}`);
+    const files = readdirSync(outputDirectory).filter(f => f.endsWith(".glb") || f.endsWith(".gltf"));
+    log(files.length + " file(s) to process");
     /** @type {null | ChildProcess} */
-    let proc = null;
+    let sub = null;
-    const cloudAccessToken = process.env.NEEDLE_CLOUD_TOKEN;
-    const runInCloud = typeof cloudAccessToken === "string" && cloudAccessToken.length > 0;
-    // if a user has defined the build pipeline settings object but not passed in a token we should print out some information
-    // or perhaps log an error / prevent the build from running completely
-    if (opts.buildPipeline && !runInCloud && process.env.CI) {
-        warn(`No cloud access token found. Please set it via process.env.NEEDLE_CLOUD_TOKEN`);
-        return false;
-    }
-    // put the processed files first in a temporary directory. They will be moved to the output directory at the end of the buildstep
-    // this is so that processes like sveltekit-static-adapter can run first and does not override already compressed files
-    const tempOutputPath = process.cwd() + "/node_modules/.needle/build-pipeline/output";
-    if (existsSync(tempOutputPath)) {
-        log("Removing temporary output directory at " + tempOutputPath);
-        rmSync(tempOutputPath, { recursive: true, force: true });
-    }
-    mkdirSync(tempOutputPath, { recursive: true });
-    /** @param {number} code */
-    function onExit(code) {
-        if (code === 0)
-            buildPipelineTaskResults = {
-                tempDirectory: tempOutputPath,
-                outputDirectory: outputDirectory
-            }
-    }
-    // allow running the build pipeline in the cloud. It requires and access token to be set in the vite.config.js
-    // this can be set via e.g. process.env.NEEDLE_CLOUD_TOKEN
-    if (runInCloud) {
-        if (!cloudAccessToken || !(typeof cloudAccessToken === "string") || cloudAccessToken.length <= 0) {
-            throw new Error("No cloud access token configured. Please set it via process.env.NEEDLE_CLOUD_TOKEN or in the vite.config.js");
-        }
-        let cmd = `npx --yes @needle-tools/cloud-cli@latest optimize "${outputDirectory}" --accessToken ${cloudAccessToken}`;
-        const projectName = opts.buildPipeline?.projectName;
-        if (projectName) {
-            cmd += ` --name "${projectName}"`;
-        }
-        if (opts.buildPipeline?.verbose === true) {
-            cmd += " --verbose";
-        }
-        cmd += " --outdir \"" + tempOutputPath + "\"";
-        console.log("\n")
-        log("Running compression in cloud");
-        proc = exec(cmd);
-    }
-    else if (existsLocally) {
+    if (existsLocally) {
         const cmd = `needle-gltf transform "${outputDirectory}"`;
         log("Running command \"" + cmd + "\" at " + process.cwd() + "...");
-        proc = exec(cmd, { cwd: installPath });
+        sub = exec(cmd, { cwd: installPath });
     }
     else {
-        const version = opts.buildPipeline?.version || "latest";
-        const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}" \"${tempOutputPath}\"`;
-        log(`Running compression locally with version ${version}`);
-        proc = exec(cmd);
+        const version = opts.buildPipelineVersion || "latest";
+        const cmd = `npx --yes @needle-tools/gltf-build-pipeline@${version} transform "${outputDirectory}"`;
+        log("Running command \"" + cmd);
+        sub = exec(cmd);
     }
-    /** @param {any} data */
-    function onLog(data) {
+    sub.stdout.on('data', data => {
         if (data.length <= 0) return;
         // ensure that it doesnt end with a newline
-        while (data.endsWith("\n")) data = data.slice(0, -1);
-        log(data);
-    }
-    proc.stdout?.on('data', onLog);
-    proc.stderr?.on('data', onLog);
+        if (data.endsWith("\n")) data = data.slice(0, -1);
+        console.log(data);
+    });
+    sub.stderr.on('data', console.error);
     return new Promise((resolve, reject) => {
-        proc.on('exit', (code) => {
-            onExit(code || 0);
+        sub.on('exit', (code) => {
             resolve(code === 0);
         });
     });
 }
+function wait(ms) {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}

plugins/common/buildinfo.js CHANGED Viewed

@@ -16,11 +16,11 @@
         totalsize: 0,
         files: []
     };
-    console.log(`[needle-buildinfo] - Begin collecting files in \"${buildDirectory}\"`);
+    console.log("[needle-buildinfo] - Collect files in " + buildDirectory);
     recursivelyCollectFiles(buildDirectory, "", buildInfo);
     const buildInfoPath = `${buildDirectory}/needle.buildinfo.json`;
     const totalSizeInMB = buildInfo.totalsize / 1024 / 1024;
-    console.log(`[needle-buildinfo] - Collected ${buildInfo.files.length} files (${totalSizeInMB.toFixed(2)} MB). Writing build info to \"${buildInfoPath}\"`);
+    console.log(`[needle-buildinfo] - Collected ${buildInfo.files.length} files (${totalSizeInMB.toFixed(2)} MB). Write info to \"${buildInfoPath}\"`);
     fs.writeFileSync(buildInfoPath, JSON.stringify(buildInfo));
 }
@@ -39,11 +39,10 @@
             }
             const newPath = path?.length <= 0 ? entry.name : `${path}/${entry.name}`;
             const newDirectory = `${directory}/${entry.name}`;
-            console.log(`[needle-buildinfo] - Collect files in \"/${newPath}\"`);
+            console.log("[needle-buildinfo] - Collect files in " + newPath);
             recursivelyCollectFiles(newDirectory, newPath, info);
         } else {
             const relpath = `${path}/${entry.name}`;
-            // console.log("[needle-buildinfo] - New File: " + relpath);
             const filehash = crypto.createHash('sha256');
             const fullpath = `${directory}/${entry.name}`;
             filehash.update(fs.readFileSync(fullpath));

plugins/vite/buildinfo.js CHANGED Viewed

@@ -1,38 +1,32 @@
 import { createBuildInfoFile } from '../common/buildinfo.js';
-import { waitForBuildPipelineToFinish } from './build-pipeline.js';
+import { buildPipelineTask } from './build-pipeline.js';
 import { getOutputDirectory } from './config.js';
-let level = 0;
 /** Create a buildinfo file in the build directory
  * @param {import('../types').userSettings} userSettings
- * @returns {import('vite').Plugin | null}
+ * @returns {import('vite').Plugin}
  */
 export const needleBuildInfo = (command, config, userSettings) => {
-    if (userSettings?.noBuildInfo) return null;
+    if (userSettings?.noBuildInfo) return;
     return {
         name: 'needle-buildinfo',
         apply: "build",
         enforce: "post",
-        buildStart: () => {
-            level++;
-        },
         closeBundle: async () => {
-            if (--level > 0) {
-                console.log("[needle-buildinfo] - Skipped because of nested build");
-                return;
-            }
-            const task = waitForBuildPipelineToFinish();
-            if (task instanceof Promise) {
-                console.log("[needle-buildinfo] - Waiting for build pipeline to finish");
-                await task.catch(() => { }).finally(() => console.log("[needle-buildinfo] - Build pipeline finished!"));
-            }
-            // wait for gzip
-            await delay(500);
-            const buildDirectory = getOutputDirectory();
-            createBuildInfoFile(buildDirectory);
+            return new Promise(async res => {
+                if (buildPipelineTask instanceof Promise) {
+                    await buildPipelineTask.catch(() => { });
+                }
+                // wait for gzip
+                await delay(500);
+                const buildDirectory = getOutputDirectory();
+                createBuildInfoFile(buildDirectory);
+                res();
+            });
         }
     }
 }

plugins/vite/copyfiles.js CHANGED Viewed

@@ -2,55 +2,40 @@
 import { resolve, join, isAbsolute } from 'path'
 import { existsSync, statSync, mkdirSync, readdirSync, copyFileSync, mkdir } from 'fs';
 import { builtAssetsDirectory, tryLoadProjectConfig } from './config.js';
-import { copyFilesSync } from '../common/files.js';
-const pluginName = "needle-copy-files";
 /** copy files on build from assets to dist
  * @param {import('../types').userSettings} userSettings
- * @returns {import('vite').Plugin | null}
  */
 export const needleCopyFiles = (command, config, userSettings) => {
     if (config?.noCopy === true || userSettings?.noCopy === true) {
-        return null;
+        return;
     }
     return {
         name: 'needle-copy-files',
-        // explicitly don't enforce post or pre because we want to run before the build-pipeline plugin
-        enforce: "pre",
-        apply: (_conf, env) => {
-            if (env.ssrBuild === true) return false;
-            return true;
-        },
         buildStart() {
-            return run("start", config);
+            return run(false, config);
         },
         closeBundle() {
-            return run("end", config);
+            return run(true, config);
         },
     }
 }
-/**
- * @param {"start" | "end"} buildstep
- * @param {import('../types').userSettings} config
- */
-async function run(buildstep, config) {
-    console.log(`[${pluginName}] - Copy files at ${buildstep}`);
+async function run(isBuild, config) {
     const copyIncludesFromEngine = config?.copyIncludesFromEngine ?? true;
     const baseDir = process.cwd();
-    const override = buildstep === "start";
+    const pluginName = "needle-copy-files";
     let assetsDirName = "assets";
     let outdirName = "dist";
     const needleConfig = tryLoadProjectConfig();
     if (needleConfig) {
-        assetsDirName = needleConfig.assetsDirectory || assetsDirName;
+        assetsDirName = needleConfig.assetsDirectory;
         while (assetsDirName.startsWith('/')) assetsDirName = assetsDirName.substring(1);
         if (needleConfig.buildDirectory)
@@ -63,61 +48,60 @@
         if (existsSync(engineIncludeDir)) {
             console.log(`[${pluginName}] - Copy engine include to ${baseDir}/include`)
             const projectIncludeDir = resolve(baseDir, 'include');
-            copyFilesSync(engineIncludeDir, projectIncludeDir);
+            copyRecursiveSync(engineIncludeDir, projectIncludeDir);
         }
     }
-    const outDir = resolve(baseDir, outdirName);
-    if (!existsSync(outDir)) {
-        mkdirSync(outDir);
-    }
+    if (isBuild) {
+        const outDir = resolve(baseDir, outdirName);
+        if (!existsSync(outDir)) {
+            mkdirSync(outDir);
+        }
-    // copy a list of files or directories declared in build.copy = [] in the needle.config.json
-    /*
-    "build": {
-        "copy": ["myFolder", "myFile.txt"]
-    }
-    */
-    if (needleConfig?.build?.copy) {
-        const arr = needleConfig.build.copy;
-        for (let i = 0; i < arr.length; i++) {
-            const entry = arr[i];
-            if (Array.isArray(entry)) {
-                console.log("WARN: build.copy can only contain string paths to copy to. Found array instead.");
-                continue;
+        // copy a list of files or directories declared in build.copy = [] in the needle.config.json
+        /*
+        "build": {
+            "copy": ["myFolder", "myFile.txt"]
+        }
+        */
+        if (needleConfig?.build?.copy) {
+            const arr = needleConfig.build.copy;
+            for (let i = 0; i < arr.length; i++) {
+                const entry = arr[i];
+                if (Array.isArray(entry)) {
+                    console.log("WARN: build.copy can only contain string paths to copy to. Found array instead.");
+                    continue;
+                }
+                const src = resolve(baseDir, entry);
+                const dest = resolvePath(outDir, entry);
+                if (existsSync(src)) {
+                    console.log(`[${pluginName}] - Copy ${entry} to ${outdirName}/${entry}`)
+                    copyRecursiveSync(src, dest);
+                }
             }
-            const src = resolve(baseDir, entry);
-            const dest = resolvePath(outDir, entry);
-            if (existsSync(src) && dest) {
-                console.log(`[${pluginName}] - Copy ${entry} to ${outdirName}/${entry}`)
-                copyFilesSync(src, dest, override);
-            }
         }
-    }
-    // copy assets dir
-    const assetsDir = resolve(baseDir, assetsDirName);
-    if (existsSync(assetsDir)) {
-        console.log(`[${pluginName}] - Copy assets to ${outdirName}/${builtAssetsDirectory()}`)
-        const targetDir = resolve(outDir, 'assets');
-        copyFilesSync(assetsDir, targetDir, override);
+        // copy assets dir
+        const assetsDir = resolve(baseDir, assetsDirName);
+        if (existsSync(assetsDir)) {
+            console.log(`[${pluginName}] - Copy assets to ${outdirName}/${builtAssetsDirectory()}`)
+            const targetDir = resolve(outDir, 'assets');
+            copyRecursiveSync(assetsDir, targetDir);
+        }
+        else console.log(`WARN: No assets directory found. Skipping copy of ${assetsDirName} resolved to ${assetsDir}`)
+        // copy include dir
+        const includeDir = resolve(baseDir, 'include');
+        if (existsSync(includeDir)) {
+            console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
+            const targetDir = resolve(outDir, 'include');
+            copyRecursiveSync(includeDir, targetDir);
+        }
     }
-    else console.log(`WARN: No assets directory found. Skipping copy of ${assetsDirName} resolved to ${assetsDir}`)
-    // copy include dir
-    const includeDir = resolve(baseDir, 'include');
-    if (existsSync(includeDir)) {
-        console.log(`[${pluginName}] - Copy include to ${outdirName}/include`)
-        const targetDir = resolve(outDir, 'include');
-        copyFilesSync(includeDir, targetDir, override);
-    }
 }
 /** resolves relative or absolute paths to a path inside the out directory
  * for example D:/myFile.txt would resolve to outDir/myFile.txt
  * wherereas "some/relative/path" would become outDir/some/relative/path
- * @param {string} outDir
- * @param {string} pathValue
  */
 function resolvePath(outDir, pathValue) {
     if (isAbsolute(pathValue)) {
@@ -126,12 +110,29 @@
         var stats = exists && statSync(pathValue);
         if (stats.isDirectory()) {
             const dirName = pathValue.replaceAll('\\', '/').split('/').pop();
-            if (!dirName) return null;
             return resolve(outDir, dirName);
         }
         const fileName = pathValue.replaceAll('\\', '/').split('/').pop();
-        if (!fileName) return null;
         return resolve(outDir, fileName);
     }
     return resolve(outDir, pathValue);
-}
+}
+function copyRecursiveSync(src, dest) {
+    if (dest === null) {
+        console.log(`[${pluginName}] - Copy ${src} to ${dest} - dest is null`)
+        return;
+    }
+    var exists = existsSync(src);
+    var stats = exists && statSync(src);
+    var isDirectory = exists && stats.isDirectory();
+    if (isDirectory) {
+        if (!existsSync(dest))
+            mkdirSync(dest, { recursive: true });
+        readdirSync(src).forEach(function (childItemName) {
+            copyRecursiveSync(join(src, childItemName), join(dest, childItemName));
+        });
+    } else {
+        copyFileSync(src, dest);
+    }
+};

plugins/common/files.js DELETED Viewed

@@ -1,31 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
-import { join } from "path";
-/**
- * @param {string} src
- * @param {string} dest
- * @param {boolean} override
- * @param {{count:number} | undefined} ctx
- */
-export function copyFilesSync(src, dest, override = true, ctx = undefined) {
-    if (dest === null) {
-        console.log(`[needle-copy] - Copy ${src} to ${dest} - dest is null`)
-        return;
-    }
-    let exists = existsSync(src);
-    let stats = exists && statSync(src);
-    let isDirectory = exists && typeof stats != "boolean" && stats.isDirectory();
-    if (isDirectory) {
-        if (!existsSync(dest))
-            mkdirSync(dest, { recursive: true });
-        readdirSync(src).forEach(function (childItemName) {
-            // recurse
-            copyFilesSync(join(src, childItemName), join(dest, childItemName), override, ctx);
-        });
-    } else if (!exists || override) {
-        if (ctx) {
-            ctx.count += 1;
-        }
-        copyFileSync(src, dest);
-    }
-};

plugins/vite/index.js CHANGED Viewed

@@ -96,7 +96,7 @@
     }
  * ```
  * @param {string} command
- * @param {import('../types/index.js').userSettings} userSettings
+ * @param {import('../types').userSettings} userSettings
  */
 export const needlePlugins = async (command, config, userSettings) => {

plugins/common/timers.js DELETED Viewed

@@ -1,8 +0,0 @@
-/**
- * @param {number} ms
- */
-export function delay(ms) {
-    return new Promise(res => setTimeout(res, ms));
-}

src/engine/engine_element.ts CHANGED Viewed

@@ -140,6 +140,7 @@
         width: max(600px, 100%);
         height: max(300px, 100%);
         touch-action: none;
+        -webkit-tap-highlight-color: transparent;
     }
     @media (max-width: 600px) {

src/engine/engine_utils_screenshot.ts CHANGED Viewed

@@ -1,10 +1,10 @@
 import { Camera, Color, ColorRepresentation, PerspectiveCamera } from "three";
 import { Renderer } from "../engine-components/Renderer.js";
+import { RGBAColor } from "./api.js";
 import { getComponentsInChildren } from "./engine_components.js";
 import { ContextRegistry } from "./engine_context_registry.js";
 import { Context } from "./engine_setup.js";
-import { RGBAColor } from "./api.js";
 declare type ScreenshotImageMimeType = "image/webp" | "image/png";

plugins/types/needleConfig.d.ts CHANGED Viewed

@@ -22,7 +22,4 @@
     assetsDirectory?: string;
     scriptsDirectory?: string;
     codegenDirectory?: string;
-    build?: {
-        copy?: Array<string>;
-    }
 }

plugins/types/userconfig.d.ts CHANGED Viewed

@@ -5,9 +5,6 @@
     webpack: object | undefined
 }
-/**
- * Settings for the Needle plugin
- */
 export type userSettings = {
     /** disable needle asap plugin */
@@ -23,8 +20,6 @@
     /** disable automatic copying of files to include and output directory (dist) */
     noCopy?: boolean;
-    /** When enabled the needle-engine include directory will be copied */
-    copyIncludesFromEngine?: boolean;
     /** set to false to tree-shake rapier physics engine to the reduce bundle size */
     useRapier?: boolean;
     noDependencyWatcher?: boolean;
@@ -49,25 +44,12 @@
     /** Set to true to disable the needle build pipeline (running compression and optimization as a postprocessing step on the exported glTF files) */
     noBuildPipeline?: boolean;
+    /** Set to a specific version of the Needle Build Pipeline.
+     * @default "latest"
+     * @example "2.2.0-alpha"
+    */
+    buildPipelineVersion?: string;
-    /**
-     * Use to configure optimized builds
-     */
-    buildPipeline?: {
-        /** Set to false to prevent the build pipeline from running */
-        enabled?: boolean,
-        /** Set a project name (cloud only) */
-        projectName?: string,
-        /** Enable for verbose log output */
-        verbose?: boolean,
-        /** Set to a specific version of the Needle Build Pipeline.
-         * @default "latest"
-         * @example "2.2.0-alpha"
-        */
-        version?: string;
-    }
     /** required for @serializable https://github.com/vitejs/vite/issues/13736 */
     vite44Hack?: boolean;