@needle-tools/engine 4.4.0-beta.3 → 4.4.0-beta.5

package/lib/engine/engine_hot_reload.d.ts

@@ -1,7 +1,7 @@
-/** @internal true during hot reload, can be used to modify behaviour in onEnable and onDisable */
-export declare function isHotReloading(): boolean;
-/** @internal */
-export declare function registerHotReloadType(instance: object): void;
-/** @internal */
-export declare function unregisterHotReloadType(instance: object): void;
-export declare function applyHMRChanges(newModule: any): boolean;
+/** @internal true during hot reload, can be used to modify behaviour in onEnable and onDisable */
+export declare function isHotReloading(): boolean;
+/** @internal */
+export declare function registerHotReloadType(instance: object): void;
+/** @internal */
+export declare function unregisterHotReloadType(instance: object): void;
+export declare function applyHMRChanges(newModule: any): boolean;

package/lib/engine/engine_hot_reload.js

@@ -1,185 +1,185 @@
-import { addLog, LogType } from "./debug/debug_overlay.js";
-import { addScriptToArrays, removeScriptFromContext } from "./engine_mainloop_utils.js";
-import { TypeStore } from "./engine_typestore.js";
-import { getParam } from "./engine_utils.js";
-const debug = getParam("debughotreload");
-//@ts-ignore
-if (import.meta.hot) {
-    //@ts-ignore
-    import.meta.hot.on('vite:beforeUpdate', (cb) => {
-        if (debug)
-            console.log(cb);
-        for (const update of cb.updates) {
-            console.log("[Needle Engine] Hot reloading " + update.path);
-        }
-    });
-}
-let isApplyingChanges = false;
-const instances = new Map();
-/** @internal true during hot reload, can be used to modify behaviour in onEnable and onDisable */
-export function isHotReloading() {
-    return isApplyingChanges;
-}
-/** @internal */
-export function registerHotReloadType(instance) {
-    if (isApplyingChanges)
-        return;
-    const type = instance.constructor;
-    const name = type.name;
-    if (!instances.has(name)) {
-        instances.set(name, [instance]);
-    }
-    else {
-        instances.get(name)?.push(instance);
-    }
-}
-/** @internal */
-export function unregisterHotReloadType(instance) {
-    if (isApplyingChanges)
-        return;
-    const type = instance.constructor;
-    const name = type.name;
-    const instancesOfType = instances.get(name);
-    if (!instancesOfType)
-        return;
-    const idx = instancesOfType.indexOf(instance);
-    if (idx === -1)
-        return;
-    instancesOfType.splice(idx, 1);
-}
-let didRegisterUnhandledExceptionListener = false;
-function reloadPageOnHotReloadError() {
-    if (debug)
-        return;
-    if (didRegisterUnhandledExceptionListener)
-        return;
-    didRegisterUnhandledExceptionListener = true;
-    const error = console.error;
-    console.error = (...args) => {
-        if (args.length) {
-            const arg = args[0];
-            // When making changes in e.g. the engine package and then making changes in project scripts again that import the engine package: hot reload fails and reports redefinitions of types, we just reload the page in those cases for now
-            // editing a script in one package seems to work for now so it should be good enough for a start
-            if (typeof arg === "string" && arg.includes("[hmr] Failed to reload ")) {
-                console.log("[Needle Engine] Hot reloading failed");
-                window.location.reload();
-                return;
-            }
-        }
-        error.apply(console, args);
-    };
-}
-export function applyHMRChanges(newModule) {
-    if (debug)
-        console.log("[HMR] Apply changes", newModule, Object.keys(newModule));
-    reloadPageOnHotReloadError();
-    // console.dir(newModule);
-    for (const key of Object.keys(newModule)) {
-        try {
-            isApplyingChanges = true;
-            const typeToUpdate = TypeStore.get(key);
-            if (!typeToUpdate) {
-                if (debug)
-                    console.log("[HMR] Type not found: " + key);
-                continue;
-            }
-            const newType = newModule[key];
-            const instancesOfType = instances.get(newType.name);
-            let hotReloadMessage = "[Needle Engine] Updating type: " + key;
-            const typesCount = instancesOfType?.length ?? -1;
-            if (typesCount > 0)
-                hotReloadMessage += " x" + typesCount;
-            else
-                hotReloadMessage += " - no instances";
-            console.log(hotReloadMessage);
-            // Update prototype (methods and properties)
-            const previousMethods = Object.getOwnPropertyNames(typeToUpdate.prototype);
-            const methodsAndProperties = Object.getOwnPropertyDescriptors(newType.prototype);
-            for (const typeKey in methodsAndProperties) {
-                const desc = methodsAndProperties[typeKey];
-                if (!desc.writable)
-                    continue;
-                typeToUpdate.prototype[typeKey] = newModule[key].prototype[typeKey];
-            }
-            // Remove methods that are no longer present
-            for (const typeKey of previousMethods) {
-                if (!methodsAndProperties[typeKey]) {
-                    delete typeToUpdate.prototype[typeKey];
-                }
-            }
-            // Update fields (we only add new fields if they are undefined)
-            // we create a instance to get access to the fields
-            if (instancesOfType) {
-                const newTypeInstance = new newType();
-                const keys = Object.getOwnPropertyDescriptors(newTypeInstance);
-                for (const inst of instancesOfType) {
-                    const componentInstance = inst;
-                    const isComponent = componentInstance.isComponent === true;
-                    const active = isComponent ? componentInstance.activeAndEnabled : true;
-                    const context = isComponent ? componentInstance.context : undefined;
-                    try {
-                        if (isComponent && context) {
-                            removeScriptFromContext(componentInstance, context);
-                        }
-                        if (isComponent && active) {
-                            componentInstance.enabled = false;
-                        }
-                        if (inst["onBeforeHotReloadFields"]) {
-                            const res = inst["onBeforeHotReloadFields"]();
-                            if (res === false)
-                                continue;
-                        }
-                        for (const key in keys) {
-                            const desc = keys[key];
-                            if (!desc.writable)
-                                continue;
-                            if (inst[key] === undefined) {
-                                inst[key] = newTypeInstance[key];
-                            }
-                            // if its a function but not on the prototype
-                            // then its a bound method that needs to be rebound
-                            else if (typeof inst[key] === "function" && !inst[key].prototype) {
-                                const boundMethod = inst[key];
-                                // try to get the target method name
-                                const targetMethodName = boundMethod.name;
-                                const prefix = "bound "; // < magic prefix
-                                if (targetMethodName === prefix)
-                                    continue;
-                                const name = boundMethod.name.substring(prefix.length);
-                                // if the target method name still exists on the new prototype
-                                // we want to rebind it and assign it to the field
-                                // Beware that this will not work if the method is added to some event listener etc
-                                const newTarget = newType.prototype[name];
-                                if (newTarget)
-                                    inst[key] = newTarget.bind(inst);
-                            }
-                        }
-                        if (inst["onAfterHotReloadFields"])
-                            inst["onAfterHotReloadFields"]();
-                    }
-                    finally {
-                        if (isComponent && context) {
-                            addScriptToArrays(componentInstance, context);
-                        }
-                        if (isComponent && active) {
-                            componentInstance.enabled = true;
-                        }
-                    }
-                }
-            }
-        }
-        catch (err) {
-            if (debug)
-                console.error(err);
-            // we only want to invalidate changes if we debug hot reload
-            else
-                return false;
-        }
-        finally {
-            isApplyingChanges = false;
-            addLog(LogType.Log, "Script changes applied (HMR)");
-        }
-    }
-    return true;
-}
+import { addLog, LogType } from "./debug/debug_overlay.js";
+import { addScriptToArrays, removeScriptFromContext } from "./engine_mainloop_utils.js";
+import { TypeStore } from "./engine_typestore.js";
+import { getParam } from "./engine_utils.js";
+const debug = getParam("debughotreload");
+//@ts-ignore
+if (import.meta.hot) {
+    //@ts-ignore
+    import.meta.hot.on('vite:beforeUpdate', (cb) => {
+        if (debug)
+            console.log(cb);
+        for (const update of cb.updates) {
+            console.log("[Needle Engine] Hot reloading " + update.path);
+        }
+    });
+}
+let isApplyingChanges = false;
+const instances = new Map();
+/** @internal true during hot reload, can be used to modify behaviour in onEnable and onDisable */
+export function isHotReloading() {
+    return isApplyingChanges;
+}
+/** @internal */
+export function registerHotReloadType(instance) {
+    if (isApplyingChanges)
+        return;
+    const type = instance.constructor;
+    const name = type.name;
+    if (!instances.has(name)) {
+        instances.set(name, [instance]);
+    }
+    else {
+        instances.get(name)?.push(instance);
+    }
+}
+/** @internal */
+export function unregisterHotReloadType(instance) {
+    if (isApplyingChanges)
+        return;
+    const type = instance.constructor;
+    const name = type.name;
+    const instancesOfType = instances.get(name);
+    if (!instancesOfType)
+        return;
+    const idx = instancesOfType.indexOf(instance);
+    if (idx === -1)
+        return;
+    instancesOfType.splice(idx, 1);
+}
+let didRegisterUnhandledExceptionListener = false;
+function reloadPageOnHotReloadError() {
+    if (debug)
+        return;
+    if (didRegisterUnhandledExceptionListener)
+        return;
+    didRegisterUnhandledExceptionListener = true;
+    const error = console.error;
+    console.error = (...args) => {
+        if (args.length) {
+            const arg = args[0];
+            // When making changes in e.g. the engine package and then making changes in project scripts again that import the engine package: hot reload fails and reports redefinitions of types, we just reload the page in those cases for now
+            // editing a script in one package seems to work for now so it should be good enough for a start
+            if (typeof arg === "string" && arg.includes("[hmr] Failed to reload ")) {
+                console.log("[Needle Engine] Hot reloading failed");
+                window.location.reload();
+                return;
+            }
+        }
+        error.apply(console, args);
+    };
+}
+export function applyHMRChanges(newModule) {
+    if (debug)
+        console.log("[HMR] Apply changes", newModule, Object.keys(newModule));
+    reloadPageOnHotReloadError();
+    // console.dir(newModule);
+    for (const key of Object.keys(newModule)) {
+        try {
+            isApplyingChanges = true;
+            const typeToUpdate = TypeStore.get(key);
+            if (!typeToUpdate) {
+                if (debug)
+                    console.log("[HMR] Type not found: " + key);
+                continue;
+            }
+            const newType = newModule[key];
+            const instancesOfType = instances.get(newType.name);
+            let hotReloadMessage = "[Needle Engine] Updating type: " + key;
+            const typesCount = instancesOfType?.length ?? -1;
+            if (typesCount > 0)
+                hotReloadMessage += " x" + typesCount;
+            else
+                hotReloadMessage += " - no instances";
+            console.log(hotReloadMessage);
+            // Update prototype (methods and properties)
+            const previousMethods = Object.getOwnPropertyNames(typeToUpdate.prototype);
+            const methodsAndProperties = Object.getOwnPropertyDescriptors(newType.prototype);
+            for (const typeKey in methodsAndProperties) {
+                const desc = methodsAndProperties[typeKey];
+                if (!desc.writable)
+                    continue;
+                typeToUpdate.prototype[typeKey] = newModule[key].prototype[typeKey];
+            }
+            // Remove methods that are no longer present
+            for (const typeKey of previousMethods) {
+                if (!methodsAndProperties[typeKey]) {
+                    delete typeToUpdate.prototype[typeKey];
+                }
+            }
+            // Update fields (we only add new fields if they are undefined)
+            // we create a instance to get access to the fields
+            if (instancesOfType) {
+                const newTypeInstance = new newType();
+                const keys = Object.getOwnPropertyDescriptors(newTypeInstance);
+                for (const inst of instancesOfType) {
+                    const componentInstance = inst;
+                    const isComponent = componentInstance.isComponent === true;
+                    const active = isComponent ? componentInstance.activeAndEnabled : true;
+                    const context = isComponent ? componentInstance.context : undefined;
+                    try {
+                        if (isComponent && context) {
+                            removeScriptFromContext(componentInstance, context);
+                        }
+                        if (isComponent && active) {
+                            componentInstance.enabled = false;
+                        }
+                        if (inst["onBeforeHotReloadFields"]) {
+                            const res = inst["onBeforeHotReloadFields"]();
+                            if (res === false)
+                                continue;
+                        }
+                        for (const key in keys) {
+                            const desc = keys[key];
+                            if (!desc.writable)
+                                continue;
+                            if (inst[key] === undefined) {
+                                inst[key] = newTypeInstance[key];
+                            }
+                            // if its a function but not on the prototype
+                            // then its a bound method that needs to be rebound
+                            else if (typeof inst[key] === "function" && !inst[key].prototype) {
+                                const boundMethod = inst[key];
+                                // try to get the target method name
+                                const targetMethodName = boundMethod.name;
+                                const prefix = "bound "; // < magic prefix
+                                if (targetMethodName === prefix)
+                                    continue;
+                                const name = boundMethod.name.substring(prefix.length);
+                                // if the target method name still exists on the new prototype
+                                // we want to rebind it and assign it to the field
+                                // Beware that this will not work if the method is added to some event listener etc
+                                const newTarget = newType.prototype[name];
+                                if (newTarget)
+                                    inst[key] = newTarget.bind(inst);
+                            }
+                        }
+                        if (inst["onAfterHotReloadFields"])
+                            inst["onAfterHotReloadFields"]();
+                    }
+                    finally {
+                        if (isComponent && context) {
+                            addScriptToArrays(componentInstance, context);
+                        }
+                        if (isComponent && active) {
+                            componentInstance.enabled = true;
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (debug)
+                console.error(err);
+            // we only want to invalidate changes if we debug hot reload
+            else
+                return false;
+        }
+        finally {
+            isApplyingChanges = false;
+            addLog(LogType.Log, "Script changes applied (HMR)");
+        }
+    }
+    return true;
+}
 //# sourceMappingURL=engine_hot_reload.js.map