@needle-tools/engine 4.14.0 → 4.15.0-next.f391a30

package/plugins/vite/custom-element-data.js

@@ -1,15 +1,18 @@
+// @ts-check
 import fs from 'fs';
 import path from 'path';
 
+/** @typedef {{ version?: number, tags?: {name: string, [key: string]: unknown}[], valueSets?: {name: string, [key: string]: unknown}[], globalAttributes?: unknown[] }} CustomElementData */
+
 /** Known needle-engine tag names that should be updated from the source */
 const NEEDLE_TAG_NAMES = ['needle-engine', 'needle-menu', 'needle-button'];
 
 /**
  * Merges needle-engine custom element data into an existing custom-elements.json file.
  * Preserves user-defined tags while updating needle-engine specific tags.
- * @param {object} sourceData - The needle-engine custom-elements.json data
- * @param {object} targetData - The existing project custom-elements.json data
- * @returns {object} Merged data
+ * @param {CustomElementData} sourceData - The needle-engine custom-elements.json data
+ * @param {CustomElementData} targetData - The existing project custom-elements.json data
+ * @returns {CustomElementData} Merged data
  */
 function mergeCustomElementData(sourceData, targetData) {
     const merged = { ...targetData };
@@ -74,23 +77,30 @@ export const needleCustomElementData = (command, config, userSettings = {}) => {
 
                 // Path to source custom-elements.json in node_modules
                 const sourceFile = path.join(cwd, 'node_modules', '@needle-tools', 'engine', 'custom-elements.json');
-                // Path to target custom-elements.json in project root
-                const targetFile = path.join(cwd, 'custom-elements.json');
+                // Path to target custom-elements.json in project vs code directory
+                const targetFile = path.join(cwd, '.vscode', 'custom-elements.json');
 
                 // Copy/merge custom-elements.json to project
                 if (fs.existsSync(sourceFile)) {
                     try {
-                        const sourceData = JSON.parse(fs.readFileSync(sourceFile, 'utf8'));
+                        const sourceData = /** @type {CustomElementData} */ (JSON.parse(fs.readFileSync(sourceFile, 'utf8')));
 
-                        let targetData = {};
+                        let targetData = /** @type {CustomElementData} */ ({});
                         if (fs.existsSync(targetFile)) {
                             // Merge with existing file to preserve user content
                             try {
-                                targetData = JSON.parse(fs.readFileSync(targetFile, 'utf8'));
+                                targetData = /** @type {CustomElementData} */ (JSON.parse(fs.readFileSync(targetFile, 'utf8')));
                             } catch {
                                 targetData = {};
                             }
                         }
+                        else {
+                            // Ensure .vscode directory exists
+                            const vscodeDir = path.dirname(targetFile);
+                            if (!fs.existsSync(vscodeDir)) {
+                                fs.mkdirSync(vscodeDir);
+                            }
+                        }
 
                         const mergedData = mergeCustomElementData(sourceData, targetData);
                         const newContent = JSON.stringify(mergedData, null, 2);
@@ -125,7 +135,7 @@ export const needleCustomElementData = (command, config, userSettings = {}) => {
                     const full = path.join(cwd, f);
                     try {
                         const raw = fs.readFileSync(full, 'utf8');
-                        const data = JSON.parse(raw);
+                        const data = /** @type {{settings?: {'html.customData'?: string[], [key: string]: unknown}}} */ (JSON.parse(raw));
 
                         // Ensure settings.html.customData contains the local path
                         data.settings = data.settings || {};
@@ -156,20 +166,20 @@ export const needleCustomElementData = (command, config, userSettings = {}) => {
                 if (fs.existsSync(settingsFile)) {
                     try {
                         const rawSettings = fs.readFileSync(settingsFile, 'utf8');
-                        /** @type {Record<string, any>} */
+                        /** @type {Record<string, unknown>} */
                         const settings = JSON.parse(rawSettings) || {};
-
-                        settings['html.customData'] = settings['html.customData'] || [];
+                        const htmlData = /** @type {string[]} */ (settings['html.customData'] || []);
+                        settings['html.customData'] = htmlData;
 
                         // Remove old node_modules path if present
-                        const oldIndex = settings['html.customData'].indexOf(oldNodeModulesPath);
+                        const oldIndex = htmlData.indexOf(oldNodeModulesPath);
                         if (oldIndex >= 0) {
-                            settings['html.customData'].splice(oldIndex, 1);
+                            htmlData.splice(oldIndex, 1);
                         }
 
                         // Add local path if not present
-                        if (!settings['html.customData'].includes(localCustomDataPath)) {
-                            settings['html.customData'].push(localCustomDataPath);
+                        if (!htmlData.includes(localCustomDataPath)) {
+                            htmlData.push(localCustomDataPath);
 
                             // Write back settings.json if changed
                             const newRawSettings = JSON.stringify(settings, null, 2);

package/plugins/vite/defines.js

@@ -1,6 +1,7 @@
 import { loadConfig } from "./config.js";
 import { tryGetNeedleEngineVersion } from "../common/version.js";
 import { getPublicIdentifier as getPublicIdentifier } from "../common/license.js";
+import { needleLog } from "./logging.js";
 
 // NOTE: ALL DEFINES MUST BE SET HERE! NEVER ADD OR RELY ON DEFINES IN ANY OTHER PLUGIN
 
@@ -11,6 +12,8 @@ import { getPublicIdentifier as getPublicIdentifier } from "../common/license.js
 // https://vitejs.dev/config/#using-environment-variables-in-config
 
 /**
+ * @param {string} command
+ * @param {{ generator?: string, useRapier?: boolean } | null | undefined} needleEngineConfig
  * @param {import('../types').userSettings} userSettings
  */
 export const needleDefines = (command, needleEngineConfig, userSettings) => {
@@ -28,11 +31,11 @@ export const needleDefines = (command, needleEngineConfig, userSettings) => {
     return {
         name: 'needle:defines',
         enforce: 'pre',
-        async config(viteConfig) {
+        async config(/** @type {{ define?: Record<string, unknown> }} */ viteConfig) {
             // console.log("Update vite defines -------------------------------------------");
             if (!viteConfig.define) viteConfig.define = {};
             const version = tryGetNeedleEngineVersion();
-            console.log("Needle Engine Version: " + version, needleEngineConfig?.generator ?? "(unknown generator)");
+            needleLog("needle-defines", "Needle Engine Version: " + version + " " + (needleEngineConfig?.generator ?? "(unknown generator)"));
             if (version)
                 viteConfig.define.NEEDLE_ENGINE_VERSION = "\"" + version + "\"";
             if (needleEngineConfig)
@@ -57,11 +60,11 @@ export const needleDefines = (command, needleEngineConfig, userSettings) => {
             // this gives a timestamp containing the timezone
             viteConfig.define.NEEDLE_PROJECT_BUILD_TIME = "\"" + new Date().toString() + "\"";
 
-            const projectId = undefined; // TODO: this needs to be exported by the integration (if any)
+            const projectId = /** @type {string | undefined} */ (undefined); // TODO: this needs to be exported by the integration (if any)
             const publicIdentifier = await getPublicIdentifier(projectId, {
                 loglevel: userSettings?.debugLicense === true ? "verbose" : undefined,
-            }).catch(err => {
-                console.warn("Failed to get public identifier:", err.message);
+            }).catch((/** @type {{ message?: string }} */ err) => {
+                needleLog("needle-defines", "Failed to get public identifier: " + err.message, "warn");
             });
             if (publicIdentifier) {
                 viteConfig.define.NEEDLE_PUBLIC_KEY = "\"" + publicIdentifier + "\"";

package/plugins/vite/dependencies.js

@@ -1,4 +1,5 @@
 import { tryGetNeedleEngineVersion, tryGetPackageVersion } from '../common/version.js';
+import { needleLog } from './logging.js';
 
 /**
  * @type {string[]}
@@ -39,9 +40,10 @@ const excludeDependencies = [
  * @param {import('vite').UserConfig} config
  */
 function handleOptimizeDeps(config) {
+    const logLines = [];
     excludeDependencies.forEach(dep => {
         if (config.optimizeDeps?.include?.includes(dep)) {
-            console.log(`[needle-dependencies] ${dep} is included in the optimizeDeps.include array. This may cause issues with the worker import.`);
+            logLines.push(`${dep} is included in the optimizeDeps.include array. This may cause issues with the worker import.`);
         }
         else {
             if (!config.optimizeDeps) {
@@ -54,7 +56,7 @@ function handleOptimizeDeps(config) {
             // This needs to be excluded from optimization because otherwise the worker import fails
             // three-mesh-bvh/src/workers/generateMeshBVH.worker.js?worker
             // same for gltf-progressive
-            console.log(`[needle-dependencies] Adding ${dep} to the optimizeDeps.exclude array to support workers.`);
+            logLines.push(`Adding ${dep} to the optimizeDeps.exclude array to support workers.`);
             config.optimizeDeps.exclude.push(dep);
 
             if (!config.server) config.server = {};
@@ -65,12 +67,14 @@ function handleOptimizeDeps(config) {
             }
         }
     });
+    if (logLines.length) needleLog("needle-dependencies", logLines.join("\n"));
 }
 
 /**
  * @param {import('vite').UserConfig} config
  */
 function handleManualChunks(config) {
+    const logLines = [];
     if (!config.build) {
         config.build = {};
     }
@@ -85,7 +89,7 @@ function handleManualChunks(config) {
 
     if (Array.isArray(rollupOutput)) {
         // append the manualChunks function to the array
-        console.log("[needle-dependencies] registering manualChunks");
+        logLines.push("registering manualChunks");
         rollupOutput.push({
             manualChunks: needleManualChunks
         })
@@ -96,37 +100,39 @@ function handleManualChunks(config) {
         if ("manualChunks" in rollupOutput) {
             allowManualChunks = false;
             // if the user has already defined manualChunks (even when set to undefined), we don't want to overwrite it
-            console.log("[needle-dependencies] manualChunks already found in vite config - will not overwrite it");
+            logLines.push("manualChunks already found in vite config - will not overwrite it");
         }
         else if (rollupOutput.preserveModules === true) {
             allowManualChunks = false;
-            console.log("[needle-dependencies] manualChunks can not be registered because preserveModules is true");
+            logLines.push("manualChunks can not be registered because preserveModules is true");
         }
         if (rollupOutput.inlineDynamicImports === true) {
             allowManualChunks = false;
-            console.log("[needle-dependencies] manualChunks can not be registered because inlineDynamicImports is true");
+            logLines.push("manualChunks can not be registered because inlineDynamicImports is true");
         }
 
         if (allowManualChunks) {
-            console.log("[needle-dependencies] registering manualChunks");
+            logLines.push("registering manualChunks");
             rollupOutput.manualChunks = needleManualChunks;
         }
 
         if (rollupOutput.chunkFileNames) {
-            console.log("[needle-dependencies] chunkFileNames already defined");
+            logLines.push("chunkFileNames already defined");
         }
         else {
             rollupOutput.chunkFileNames = handleChunkFileNames;
         }
 
         if (rollupOutput.assetFileNames) {
-            console.log("[needle-dependencies] assetFileNames already defined");
+            logLines.push("assetFileNames already defined");
         }
         else {
             rollupOutput.assetFileNames = assetFileNames;
         }
     }
 
+    if (logLines.length) needleLog("needle-dependencies", logLines.join("\n"));
+
     // TODO: this was a test if it allows us to remove the sync import of postprocessing due to n8ao's import
     // config.build.rollupOptions.external = (source, importer, isResolved) => {
     //     if (importer?.includes("node_modules/n8ao/") || importer?.includes("node_modules/postprocessing/")) {
@@ -159,7 +165,7 @@ function handleManualChunks(config) {
                 }
             }
             catch (e) {
-                console.warn("[needle-dependencies] Error reading version", e);
+                needleLog("needle-dependencies", "Error reading version " + e, "warn");
             }
         }
         else if (chunk.name === 'three') {

package/plugins/vite/dependency-watcher.js

@@ -1,13 +1,19 @@
+// @ts-check
 import { exec, execSync } from 'child_process';
 import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'fs';
 import path from 'path';
+import { needleLog } from './logging.js';
 
-const prefix = "[needle-dependency-watcher] ";
+/** @typedef {{dependencies?: Record<string, string>, devDependencies?: Record<string, string>}} PackageJson */
+
+/** @param {...string} msg */
 function log(...msg) {
-    console.log(prefix, ...msg)
+    needleLog("needle-dependency-watcher", msg.join(" "));
 }
 
 /**
+ * @param {string} command
+ * @param {unknown} config
  * @param {import('../types').userSettings} userSettings
  */
 export const needleDependencyWatcher = (command, config, userSettings) => {
@@ -19,17 +25,26 @@ export const needleDependencyWatcher = (command, config, userSettings) => {
     const packageJsonPath = path.join(dir, "package.json");
     const viteCacheDir = path.join(dir, "node_modules", ".vite");
 
-    return {
+    return /** @type {import('vite').Plugin} */ ({
         name: 'needle-dependency-watcher',
+        /** @param {import('vite').ViteDevServer} server */
         configureServer(server) {
-            watchPackageJson(server, dir, packageJsonPath, viteCacheDir);
             manageClients(server);
+            const startWatching = () => watchPackageJson(server, dir, packageJsonPath, viteCacheDir);
+            if (server.httpServer?.listening) {
+                startWatching();
+            }
+            else {
+                server.httpServer?.once("listening", startWatching);
+            }
         }
-    }
+    });
 }
 
+/** @type {Set<{send: (data: string) => void, on: (event: string, cb: () => void) => void}>} */
 const currentClients = new Set();
 
+/** @param {import('vite').ViteDevServer} server */
 function manageClients(server) {
     server.ws.on("connection", (socket) => {
         currentClients.add(socket);
@@ -50,12 +65,22 @@ async function triggerReloadOnClients() {
 }
 
 
+/** @type {import('fs').Stats | undefined} */
 let packageJsonStat;
+/** @type {Date | undefined} */
 let lastEditTime;
+/** @type {number | undefined} */
 let packageJsonSize;
+/** @type {PackageJson | undefined} */
 let packageJson;
 let requireInstall = false;
 
+/**
+ * @param {import('vite').ViteDevServer} server
+ * @param {string} projectDir
+ * @param {string} packageJsonPath
+ * @param {string} cachePath
+ */
 function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
 
     if (!existsSync(packageJsonPath)) {
@@ -68,6 +93,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
     packageJsonStat = statSync(packageJsonPath);
     lastEditTime = packageJsonStat.mtime;
     packageJsonSize = packageJsonStat.size;
+    /** @type {PackageJson} */
     packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 
     setTimeout(() => {
@@ -91,7 +117,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
             }
 
             // test if dependencies changed
-            let newPackageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+            let newPackageJson = /** @type {PackageJson} */ (JSON.parse(readFileSync(packageJsonPath, "utf8")));
             if (newPackageJson.dependencies) {
                 for (const key in newPackageJson.dependencies) {
                     if (packageJson.dependencies[key] !== newPackageJson.dependencies[key] && newPackageJson.dependencies[key] !== undefined) {
@@ -125,6 +151,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
     }, 2000);
 }
 
+/** @param {string} projectDir @param {PackageJson | undefined} packageJson @returns {boolean} */
 function testIfInstallIsRequired(projectDir, packageJson) {
     if (packageJson.dependencies) {
         for (const key in packageJson.dependencies) {
@@ -195,6 +222,7 @@ let isRunningRestart = false;
 let restartId = 0;
 let lastRestartTime = 0;
 
+/** @param {import('vite').ViteDevServer} server @param {string} projectDir @param {string} cachePath */
 async function restart(server, projectDir, cachePath) {
 
     if (isRunningRestart) return;
@@ -233,7 +261,7 @@ async function restart(server, projectDir, cachePath) {
             server.restart();
         }
         isRunningRestart = false;
-        console.log("-----------------------------------------------")
+        needleLog("needle-dependency-watcher", "-----------------------------------------------");
     }
     catch (err) {
         log("Error restarting server", err);

package/plugins/vite/drop-client.js

@@ -6,8 +6,8 @@ import { Context, destroy, loadSync } from "@needle-tools/engine"
 
 if (import.meta?.hot) {
 
-    const previouslyLoaded = [];
-    import.meta.hot.on("needle-editor:exported-file", async msg => {
+    const previouslyLoaded = /** @type {unknown[]} */ ([]);
+    import.meta.hot.on("needle-editor:exported-file", async (/** @type {{ path: string }} */ msg) => {
         try {
             console.log(msg);
             const ctx = Context.Current;
@@ -21,11 +21,12 @@ if (import.meta?.hot) {
             console.log(glb);
             ctx.scene.add(glb.scene);
         }
-        catch (err) {
+        catch (/** @type {unknown} */ err) {
             console.error(err);
         }
     })
 
+    /** @param {unknown} target */
     function isNeedleCanvas(target) {
         if (target instanceof HTMLCanvasElement) {
             return true
@@ -45,8 +46,9 @@ if (import.meta?.hot) {
 
     window.addEventListener('drop', (e) => {
         if (!isNeedleCanvas(e.target)) return;
+        if (!e.dataTransfer) return;
 
-        for (const file of e.dataTransfer.files) {
+        for (const file of /** @type {Iterable<File>} */ (e.dataTransfer.files)) {
             if (file.name.endsWith(".prefab") ||
                 file.name.endsWith(".fbx") ||
                 file.name.endsWith(".gltf") ||
@@ -60,7 +62,7 @@ if (import.meta?.hot) {
                     name: file.name,
                     size: file.size,
                     lastModified: file.lastModified,
-                    location: undefined
+                    location: /** @type {{ x: number, y: number, z: number } | undefined} */ (undefined)
                 };
 
                 const hits = Context.Current?.physics.raycast();

package/plugins/vite/drop.js

@@ -8,6 +8,8 @@ const __dirname = path.dirname(__filename);
 
 /** experimental, allow dropping files from Unity into the running scene */
 /**
+ * @param {string} command
+ * @param {import('../types/needleConfig').needleMeta | null | undefined} config
  * @param {import('../types/userconfig.js').userSettings} userSettings
  */
 export const needleDrop = (command, config, userSettings) => {
@@ -17,16 +19,16 @@ export const needleDrop = (command, config, userSettings) => {
 
     return {
         name: "needle:drop",
-        config(config) {
+        config(/** @type {{ server?: { hmr?: { port?: number } } }} */ viteConfig) {
             if(userSettings)
-            if (!config.server) config.server = {};
-            if (!config.server.hmr) config.server.hmr = {};
-            config.server.hmr.port = 8080;
-            setTimeout(() => console.log("Update HMR port to " + config.server.hmr.port));
+            if (!viteConfig.server) viteConfig.server = {};
+            if (!viteConfig.server.hmr) viteConfig.server.hmr = {};
+            viteConfig.server.hmr.port = 8080;
+            setTimeout(() => console.log("Update HMR port to " + viteConfig.server?.hmr?.port));
         },
         transformIndexHtml: {
             order: 'pre',
-            handler(html, _) {
+            handler(/** @type {string} */ html, /** @type {unknown} */ _) {
                 const file = path.join(__dirname, 'drop-client.js');
                 return [
                     {
@@ -40,28 +42,28 @@ export const needleDrop = (command, config, userSettings) => {
                 ];
             },
         },
-        configureServer(server) {
+        configureServer(/** @type {{ ws: { on(event: string, cb: (...args: unknown[]) => void): void, send(type: string, data?: unknown): void } }} */ server) {
 
-            server.ws.on('needle:drop-file', async (data, client) => {
-                server.ws.send({ type: 'needle-editor:drop-file', data: data });
+            server.ws.on('needle:drop-file', async (/** @type {unknown} */ data, /** @type {unknown} */ client) => {
+                server.ws.send('needle-editor:drop-file', data);
             });
             // TODO: not sure how we can receive it with the normal vite server
             // server.ws.on("custom", (data, client) => {
             //     console.log(data);
             // })
 
-            server.ws.on('connection', (socket, request) => {
-                socket.on('message', async (bytes) => {
+            server.ws.on('connection', (/** @type {{ on(event: string, cb: (...args: unknown[]) => void): void }} */ socket, /** @type {unknown} */ request) => {
+                socket.on('message', async (/** @type {Buffer | string} */ bytes) => {
                     try {
-                        const message = Buffer.from(bytes).toString();
+                        const message = Buffer.from(/** @type {ArrayBuffer} */ (bytes)).toString();
                         if (message && message.startsWith("{")) {
-                            const obj = JSON.parse(message);
+                            const obj = /** @type {{ type: string, data: unknown }} */ (JSON.parse(message));
                             if (obj.type === "needle-editor:exported-file") {
                                 server.ws.send(obj.type, obj.data);
                             }
                         }
                     }
-                    catch (e) {
+                    catch (/** @type {{ message?: string }} */ e) {
                         console.error(e.message);
                     }
                 });

package/plugins/vite/editor-connection.js

@@ -1,4 +1,5 @@
 import { existsSync } from "fs";
+import { needleLog } from "./logging.js";
 
 const root = process.cwd();
 
@@ -13,7 +14,7 @@ const editorSyncPackageName = "@needle-tools/editor-sync"
 let editorSyncEnabled = false;
 
 /**
- * @param {import('../types').userSettings} userSettings
+ * @type {(command: string, config: { generator?: string | null, needleEditor?: { enabled?: boolean } | string | null, dontInstallEditor?: boolean }, userSettings: { dontInstallEditor?: boolean }, pluginsArray: unknown[]) => Promise<import('vite').Plugin | undefined>}
  */
 export const editorConnection = async (command, config, userSettings, pluginsArray) => {
     if (command === "build") return;
@@ -22,7 +23,7 @@ export const editorConnection = async (command, config, userSettings, pluginsArr
     if (typeof config.generator === "string" && !config.generator.includes("Unity")) return;
 
     if (!config) {
-        setTimeout(() => console.log("Needle Editor Sync can not be installed automatically to vite: missing config"), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync can not be installed automatically to vite: missing config", "warn"), 1000);
         return createPlugin(false);
     }
 
@@ -37,29 +38,31 @@ export const editorConnection = async (command, config, userSettings, pluginsArr
     //     }
     // }
     if (needleEditorSettings && needleEditorSettings.enabled === false) {
-        setTimeout(() => console.log("Needle Editor Sync is not enabled. Add a 'Needle Editor Sync' component to your scene to enable"), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", "Needle Editor Sync is not enabled. Add a 'Needle Editor Sync' component to your scene to enable", "warn"), 1000);
         return createPlugin(false);
     }
 
     // Check if the editor package is installed
     let path = root + `/node_modules/${editorSyncPackageName}/plugins/index.js`;
     if (existsSync(path) === false) {
-        setTimeout(() => console.log(`> ${editorSyncPackageName} is not installed: Add the "Needle Editor Sync" component to your scene if you want to send changes directly from the Unity Editor to web app`), 1000);
+        setTimeout(() => needleLog("needle-editor-sync", `${editorSyncPackageName} is not installed: Add the "Needle Editor Sync" component to your scene if you want to send changes directly from the Unity Editor to web app`, "warn"), 1000);
         return createPlugin(false);
     }
 
 
     // Load vite plugin
     if (!path.startsWith("file:")) path = "file:" + path;
-    const { needleEditor } = await import(path);
-    setTimeout(() => console.log("Automatically installed Needle Editor Sync"), 500)
+    const { needleEditor } = /** @type {{ needleEditor: () => Record<string, unknown> }} */ (await import(path));
+    setTimeout(() => needleLog("needle-editor-sync", "Automatically installed Needle Editor Sync"), 500)
     const method = needleEditor();
-    pluginsArray.push(method);
+    const typedPluginsArray = /** @type {Array<Record<string, unknown>>} */ (pluginsArray);
+    typedPluginsArray.push(method);
     return createPlugin(true);
 }
 
+/** @param {boolean} isInstalled */
 function createPlugin(isInstalled) {
-    return {
+    return /** @type {import('vite').Plugin} */ ({
         name: "needle-editor-connection",
         // Setup HMR port for connecting to the editor
         config(config) {
@@ -67,12 +70,12 @@ function createPlugin(isInstalled) {
                 if (!config.server) config.server = {};
                 if (!config.server.hmr) config.server.hmr = {};
                 if (config.server.hmr === false) {
-                    setTimeout(() => console.log("[needle-editor-sync] HMR is disabled, not initializing Needle Editor"));
+                    setTimeout(() => needleLog("needle-editor-sync", "HMR is disabled, not initializing Needle Editor", "warn"));
                     return;
                 }
                 if (config.server.hmr.port === undefined) {
                     config.server.hmr.port = 1107;
-                    setTimeout(() => console.log("[needle-editor-sync] Update HMR port to " + config.server.hmr.port));
+                    setTimeout(() => needleLog("needle-editor-sync", "Update HMR port to " + config.server.hmr.port));
                 }
             }
 
@@ -94,7 +97,7 @@ function createPlugin(isInstalled) {
                         if (bytes?.length < 50) {
                             const message = Buffer.from(bytes).toString();
                             if (message === "needle:editor:restart") {
-                                console.log("Received request for a soft restart of the vite server... ")
+                                needleLog("needle-editor-sync", "Received request for a soft restart of the vite server...")
                                 // This just restarts the vite server
                                 server.restart();
                             }
@@ -105,7 +108,7 @@ function createPlugin(isInstalled) {
                                 socket.send(JSON.stringify({ type: "pong" }));
                             }
                             else if (message === "needle:editor:editor-sync-enabled") {
-                                console.log("Editor sync enabled")
+                                needleLog("needle-editor-sync", "Editor sync enabled")
                                 editorSyncEnabled = true;
                             }
                             else if (message === "needle:editor:editor-sync-disabled") {
@@ -115,11 +118,10 @@ function createPlugin(isInstalled) {
                     })
                 });
             }
-            catch(err){
-                console.error("Error in needle-editor-connection")
+            catch(/** @type {unknown} */ err){
+                needleLog("needle-editor-sync", "Error in needle-editor-connection", "error")
                 console.error(err)
             }
         }
-
-    }
+    })
 }

package/plugins/vite/imports-logger.js

@@ -1,14 +1,20 @@
+// @ts-check
 import path from 'path';
 import fs from 'fs';
 
+/** @typedef {{ id: string, imports: GraphNode[], importedBy: GraphNode[] }} GraphNode */
+
 /**
+ * @param {string} command
+ * @param {unknown} config
  * @param {import('../types').userSettings} userSettings
  */
 export const needleImportsLogger = (command, config, userSettings) => {
 
     if (!userSettings.debugImportChains) return;
 
-    const graph =  {
+    /** @type {{allNodes: Map<string, GraphNode>, graph: Record<string, unknown>}} */
+    const graph = {
         allNodes: new Map(),
         graph: {},
     };
@@ -21,6 +27,7 @@ export const needleImportsLogger = (command, config, userSettings) => {
     return {
         name: 'needle:imports-logger',
         enforce: 'pre',
+        /** @param {string} id @param {string | undefined} importer */
         resolveId(id, importer) {
 
             // we want to make a graph of all the imports
@@ -57,6 +64,7 @@ export const needleImportsLogger = (command, config, userSettings) => {
 
             return;
         },
+        /** @param {Error | undefined} [error] */
         buildEnd(error) {
             try {
                 // create log file and append lines to it
@@ -64,6 +72,7 @@ export const needleImportsLogger = (command, config, userSettings) => {
                 // append a single line efficiently; replace if necessary
                 const fd = fs.openSync(logFile, "w");
 
+                /** @param {string} str */
                 const write = (str) => {
                     if (logToConsole)
                         console.log(str);
@@ -76,7 +85,8 @@ export const needleImportsLogger = (command, config, userSettings) => {
                 }
                 
                 // log graph
-                const loggedNodes = new Set();
+                const loggedNodes = /** @type {Set<string>} */ (new Set());
+                /** @param {GraphNode} node @param {number} depth @param {0|1|2} type */
                 const logNode = (node, depth, type) => {
                     if (!showOneLevelOfImportsThatWereAlreadyLogged && loggedNodes.has(node.id))
                         return;