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

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

@@ -1,18 +1,15 @@
-// @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 {CustomElementData} sourceData - The needle-engine custom-elements.json data
- * @param {CustomElementData} targetData - The existing project custom-elements.json data
- * @returns {CustomElementData} Merged data
+ * @param {object} sourceData - The needle-engine custom-elements.json data
+ * @param {object} targetData - The existing project custom-elements.json data
+ * @returns {object} Merged data
  */
 function mergeCustomElementData(sourceData, targetData) {
     const merged = { ...targetData };
@@ -77,30 +74,23 @@ 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 vs code directory
-                const targetFile = path.join(cwd, '.vscode', 'custom-elements.json');
+                // Path to target custom-elements.json in project root
+                const targetFile = path.join(cwd, 'custom-elements.json');
 
                 // Copy/merge custom-elements.json to project
                 if (fs.existsSync(sourceFile)) {
                     try {
-                        const sourceData = /** @type {CustomElementData} */ (JSON.parse(fs.readFileSync(sourceFile, 'utf8')));
+                        const sourceData = JSON.parse(fs.readFileSync(sourceFile, 'utf8'));
 
-                        let targetData = /** @type {CustomElementData} */ ({});
+                        let targetData = {};
                         if (fs.existsSync(targetFile)) {
                             // Merge with existing file to preserve user content
                             try {
-                                targetData = /** @type {CustomElementData} */ (JSON.parse(fs.readFileSync(targetFile, 'utf8')));
+                                targetData = 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);
@@ -135,7 +125,7 @@ export const needleCustomElementData = (command, config, userSettings = {}) => {
                     const full = path.join(cwd, f);
                     try {
                         const raw = fs.readFileSync(full, 'utf8');
-                        const data = /** @type {{settings?: {'html.customData'?: string[], [key: string]: unknown}}} */ (JSON.parse(raw));
+                        const data = JSON.parse(raw);
 
                         // Ensure settings.html.customData contains the local path
                         data.settings = data.settings || {};
@@ -166,20 +156,20 @@ export const needleCustomElementData = (command, config, userSettings = {}) => {
                 if (fs.existsSync(settingsFile)) {
                     try {
                         const rawSettings = fs.readFileSync(settingsFile, 'utf8');
-                        /** @type {Record<string, unknown>} */
+                        /** @type {Record<string, any>} */
                         const settings = JSON.parse(rawSettings) || {};
-                        const htmlData = /** @type {string[]} */ (settings['html.customData'] || []);
-                        settings['html.customData'] = htmlData;
+
+                        settings['html.customData'] = settings['html.customData'] || [];
 
                         // Remove old node_modules path if present
-                        const oldIndex = htmlData.indexOf(oldNodeModulesPath);
+                        const oldIndex = settings['html.customData'].indexOf(oldNodeModulesPath);
                         if (oldIndex >= 0) {
-                            htmlData.splice(oldIndex, 1);
+                            settings['html.customData'].splice(oldIndex, 1);
                         }
 
                         // Add local path if not present
-                        if (!htmlData.includes(localCustomDataPath)) {
-                            htmlData.push(localCustomDataPath);
+                        if (!settings['html.customData'].includes(localCustomDataPath)) {
+                            settings['html.customData'].push(localCustomDataPath);
 
                             // Write back settings.json if changed
                             const newRawSettings = JSON.stringify(settings, null, 2);

package/plugins/vite/defines.js

@@ -1,7 +1,6 @@
 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
 
@@ -12,8 +11,6 @@ import { needleLog } from "./logging.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) => {
@@ -31,11 +28,11 @@ export const needleDefines = (command, needleEngineConfig, userSettings) => {
     return {
         name: 'needle:defines',
         enforce: 'pre',
-        async config(/** @type {{ define?: Record<string, unknown> }} */ viteConfig) {
+        async config(viteConfig) {
             // console.log("Update vite defines -------------------------------------------");
             if (!viteConfig.define) viteConfig.define = {};
             const version = tryGetNeedleEngineVersion();
-            needleLog("needle-defines", "Needle Engine Version: " + version + " " + (needleEngineConfig?.generator ?? "(unknown generator)"));
+            console.log("Needle Engine Version: " + version, needleEngineConfig?.generator ?? "(unknown generator)");
             if (version)
                 viteConfig.define.NEEDLE_ENGINE_VERSION = "\"" + version + "\"";
             if (needleEngineConfig)
@@ -60,11 +57,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 = /** @type {string | undefined} */ (undefined); // TODO: this needs to be exported by the integration (if any)
+            const projectId = undefined; // TODO: this needs to be exported by the integration (if any)
             const publicIdentifier = await getPublicIdentifier(projectId, {
                 loglevel: userSettings?.debugLicense === true ? "verbose" : undefined,
-            }).catch((/** @type {{ message?: string }} */ err) => {
-                needleLog("needle-defines", "Failed to get public identifier: " + err.message, "warn");
+            }).catch(err => {
+                console.warn("Failed to get public identifier:", err.message);
             });
             if (publicIdentifier) {
                 viteConfig.define.NEEDLE_PUBLIC_KEY = "\"" + publicIdentifier + "\"";

package/plugins/vite/dependencies.js

@@ -1,5 +1,4 @@
 import { tryGetNeedleEngineVersion, tryGetPackageVersion } from '../common/version.js';
-import { needleLog } from './logging.js';
 
 /**
  * @type {string[]}
@@ -40,10 +39,9 @@ const excludeDependencies = [
  * @param {import('vite').UserConfig} config
  */
 function handleOptimizeDeps(config) {
-    const logLines = [];
     excludeDependencies.forEach(dep => {
         if (config.optimizeDeps?.include?.includes(dep)) {
-            logLines.push(`${dep} is included in the optimizeDeps.include array. This may cause issues with the worker import.`);
+            console.log(`[needle-dependencies] ${dep} is included in the optimizeDeps.include array. This may cause issues with the worker import.`);
         }
         else {
             if (!config.optimizeDeps) {
@@ -56,7 +54,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
-            logLines.push(`Adding ${dep} to the optimizeDeps.exclude array to support workers.`);
+            console.log(`[needle-dependencies] Adding ${dep} to the optimizeDeps.exclude array to support workers.`);
             config.optimizeDeps.exclude.push(dep);
 
             if (!config.server) config.server = {};
@@ -67,14 +65,12 @@ 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 = {};
     }
@@ -89,7 +85,7 @@ function handleManualChunks(config) {
 
     if (Array.isArray(rollupOutput)) {
         // append the manualChunks function to the array
-        logLines.push("registering manualChunks");
+        console.log("[needle-dependencies] registering manualChunks");
         rollupOutput.push({
             manualChunks: needleManualChunks
         })
@@ -100,39 +96,37 @@ 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
-            logLines.push("manualChunks already found in vite config - will not overwrite it");
+            console.log("[needle-dependencies] manualChunks already found in vite config - will not overwrite it");
         }
         else if (rollupOutput.preserveModules === true) {
             allowManualChunks = false;
-            logLines.push("manualChunks can not be registered because preserveModules is true");
+            console.log("[needle-dependencies] manualChunks can not be registered because preserveModules is true");
         }
         if (rollupOutput.inlineDynamicImports === true) {
             allowManualChunks = false;
-            logLines.push("manualChunks can not be registered because inlineDynamicImports is true");
+            console.log("[needle-dependencies] manualChunks can not be registered because inlineDynamicImports is true");
         }
 
         if (allowManualChunks) {
-            logLines.push("registering manualChunks");
+            console.log("[needle-dependencies] registering manualChunks");
             rollupOutput.manualChunks = needleManualChunks;
         }
 
         if (rollupOutput.chunkFileNames) {
-            logLines.push("chunkFileNames already defined");
+            console.log("[needle-dependencies] chunkFileNames already defined");
         }
         else {
             rollupOutput.chunkFileNames = handleChunkFileNames;
         }
 
         if (rollupOutput.assetFileNames) {
-            logLines.push("assetFileNames already defined");
+            console.log("[needle-dependencies] 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/")) {
@@ -165,7 +159,7 @@ function handleManualChunks(config) {
                 }
             }
             catch (e) {
-                needleLog("needle-dependencies", "Error reading version " + e, "warn");
+                console.warn("[needle-dependencies] Error reading version", e);
             }
         }
         else if (chunk.name === 'three') {

package/plugins/vite/dependency-watcher.js

@@ -1,19 +1,13 @@
-// @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';
 
-/** @typedef {{dependencies?: Record<string, string>, devDependencies?: Record<string, string>}} PackageJson */
-
-/** @param {...string} msg */
+const prefix = "[needle-dependency-watcher] ";
 function log(...msg) {
-    needleLog("needle-dependency-watcher", msg.join(" "));
+    console.log(prefix, ...msg)
 }
 
 /**
- * @param {string} command
- * @param {unknown} config
  * @param {import('../types').userSettings} userSettings
  */
 export const needleDependencyWatcher = (command, config, userSettings) => {
@@ -25,26 +19,17 @@ export const needleDependencyWatcher = (command, config, userSettings) => {
     const packageJsonPath = path.join(dir, "package.json");
     const viteCacheDir = path.join(dir, "node_modules", ".vite");
 
-    return /** @type {import('vite').Plugin} */ ({
+    return {
         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);
@@ -65,22 +50,12 @@ 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)) {
@@ -93,7 +68,6 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
     packageJsonStat = statSync(packageJsonPath);
     lastEditTime = packageJsonStat.mtime;
     packageJsonSize = packageJsonStat.size;
-    /** @type {PackageJson} */
     packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 
     setTimeout(() => {
@@ -117,7 +91,7 @@ function watchPackageJson(server, projectDir, packageJsonPath, cachePath) {
             }
 
             // test if dependencies changed
-            let newPackageJson = /** @type {PackageJson} */ (JSON.parse(readFileSync(packageJsonPath, "utf8")));
+            let newPackageJson = 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) {
@@ -151,7 +125,6 @@ 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) {
@@ -222,7 +195,6 @@ 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;
@@ -261,7 +233,7 @@ async function restart(server, projectDir, cachePath) {
             server.restart();
         }
         isRunningRestart = false;
-        needleLog("needle-dependency-watcher", "-----------------------------------------------");
+        console.log("-----------------------------------------------")
     }
     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 = /** @type {unknown[]} */ ([]);
-    import.meta.hot.on("needle-editor:exported-file", async (/** @type {{ path: string }} */ msg) => {
+    const previouslyLoaded = [];
+    import.meta.hot.on("needle-editor:exported-file", async msg => {
         try {
             console.log(msg);
             const ctx = Context.Current;
@@ -21,12 +21,11 @@ if (import.meta?.hot) {
             console.log(glb);
             ctx.scene.add(glb.scene);
         }
-        catch (/** @type {unknown} */ err) {
+        catch (err) {
             console.error(err);
         }
     })
 
-    /** @param {unknown} target */
     function isNeedleCanvas(target) {
         if (target instanceof HTMLCanvasElement) {
             return true
@@ -46,9 +45,8 @@ if (import.meta?.hot) {
 
     window.addEventListener('drop', (e) => {
         if (!isNeedleCanvas(e.target)) return;
-        if (!e.dataTransfer) return;
 
-        for (const file of /** @type {Iterable<File>} */ (e.dataTransfer.files)) {
+        for (const file of e.dataTransfer.files) {
             if (file.name.endsWith(".prefab") ||
                 file.name.endsWith(".fbx") ||
                 file.name.endsWith(".gltf") ||
@@ -62,7 +60,7 @@ if (import.meta?.hot) {
                     name: file.name,
                     size: file.size,
                     lastModified: file.lastModified,
-                    location: /** @type {{ x: number, y: number, z: number } | undefined} */ (undefined)
+                    location: undefined
                 };
 
                 const hits = Context.Current?.physics.raycast();

package/plugins/vite/drop.js

@@ -8,8 +8,6 @@ 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) => {
@@ -19,16 +17,16 @@ export const needleDrop = (command, config, userSettings) => {
 
     return {
         name: "needle:drop",
-        config(/** @type {{ server?: { hmr?: { port?: number } } }} */ viteConfig) {
+        config(config) {
             if(userSettings)
-            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));
+            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));
         },
         transformIndexHtml: {
             order: 'pre',
-            handler(/** @type {string} */ html, /** @type {unknown} */ _) {
+            handler(html, _) {
                 const file = path.join(__dirname, 'drop-client.js');
                 return [
                     {
@@ -42,28 +40,28 @@ export const needleDrop = (command, config, userSettings) => {
                 ];
             },
         },
-        configureServer(/** @type {{ ws: { on(event: string, cb: (...args: unknown[]) => void): void, send(type: string, data?: unknown): void } }} */ server) {
+        configureServer(server) {
 
-            server.ws.on('needle:drop-file', async (/** @type {unknown} */ data, /** @type {unknown} */ client) => {
-                server.ws.send('needle-editor:drop-file', data);
+            server.ws.on('needle:drop-file', async (data, client) => {
+                server.ws.send({ type: 'needle-editor:drop-file', data: 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', (/** @type {{ on(event: string, cb: (...args: unknown[]) => void): void }} */ socket, /** @type {unknown} */ request) => {
-                socket.on('message', async (/** @type {Buffer | string} */ bytes) => {
+            server.ws.on('connection', (socket, request) => {
+                socket.on('message', async (bytes) => {
                     try {
-                        const message = Buffer.from(/** @type {ArrayBuffer} */ (bytes)).toString();
+                        const message = Buffer.from(bytes).toString();
                         if (message && message.startsWith("{")) {
-                            const obj = /** @type {{ type: string, data: unknown }} */ (JSON.parse(message));
+                            const obj = JSON.parse(message);
                             if (obj.type === "needle-editor:exported-file") {
                                 server.ws.send(obj.type, obj.data);
                             }
                         }
                     }
-                    catch (/** @type {{ message?: string }} */ e) {
+                    catch (e) {
                         console.error(e.message);
                     }
                 });

package/plugins/vite/editor-connection.js

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

package/plugins/vite/imports-logger.js

@@ -1,20 +1,14 @@
-// @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;
 
-    /** @type {{allNodes: Map<string, GraphNode>, graph: Record<string, unknown>}} */
-    const graph = {
+    const graph =  {
         allNodes: new Map(),
         graph: {},
     };
@@ -27,7 +21,6 @@ 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
@@ -64,7 +57,6 @@ export const needleImportsLogger = (command, config, userSettings) => {
 
             return;
         },
-        /** @param {Error | undefined} [error] */
         buildEnd(error) {
             try {
                 // create log file and append lines to it
@@ -72,7 +64,6 @@ 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);
@@ -85,8 +76,7 @@ export const needleImportsLogger = (command, config, userSettings) => {
                 }
                 
                 // log graph
-                const loggedNodes = /** @type {Set<string>} */ (new Set());
-                /** @param {GraphNode} node @param {number} depth @param {0|1|2} type */
+                const loggedNodes = new Set();
                 const logNode = (node, depth, type) => {
                     if (!showOneLevelOfImportsThatWereAlreadyLogged && loggedNodes.has(node.id))
                         return;