@needle-tools/engine 4.7.1 → 4.7.2-alpha

package/lib/engine/engine_audio.d.ts

@@ -1,4 +1,4 @@
-/**
- * @internal
- * Ensure the audio context is resumed if it gets suspended or interrupted */
-export declare function ensureAudioContextIsResumed(): void;
+/**
+ * @internal
+ * Ensure the audio context is resumed if it gets suspended or interrupted */
+export declare function ensureAudioContextIsResumed(): void;

package/lib/engine/engine_audio.js

@@ -1,24 +1,24 @@
-import { AudioContext } from "three";
-import { Application } from "./engine_application.js";
-/**
- * @internal
- * Ensure the audio context is resumed if it gets suspended or interrupted */
-export function ensureAudioContextIsResumed() {
-    Application.registerWaitForInteraction(() => {
-        // this is a fix for https://github.com/mrdoob/three.js/issues/27779 & https://linear.app/needle/issue/NE-4257
-        const ctx = AudioContext.getContext();
-        ctx.addEventListener("statechange", () => {
-            setTimeout(() => {
-                // on iOS the audiocontext can be interrupted: https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/state#resuming_interrupted_play_states_in_ios_safari
-                const state = ctx.state;
-                if (state === "suspended" || state === "interrupted") {
-                    ctx.resume()
-                        .then(() => { console.log("AudioContext resumed successfully"); })
-                        .catch((e) => { console.log("Failed to resume AudioContext: " + e); });
-                }
-            }, 500);
-        });
-    });
-}
-setTimeout(ensureAudioContextIsResumed, 1000);
+import { AudioContext } from "three";
+import { Application } from "./engine_application.js";
+/**
+ * @internal
+ * Ensure the audio context is resumed if it gets suspended or interrupted */
+export function ensureAudioContextIsResumed() {
+    Application.registerWaitForInteraction(() => {
+        // this is a fix for https://github.com/mrdoob/three.js/issues/27779 & https://linear.app/needle/issue/NE-4257
+        const ctx = AudioContext.getContext();
+        ctx.addEventListener("statechange", () => {
+            setTimeout(() => {
+                // on iOS the audiocontext can be interrupted: https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/state#resuming_interrupted_play_states_in_ios_safari
+                const state = ctx.state;
+                if (state === "suspended" || state === "interrupted") {
+                    ctx.resume()
+                        .then(() => { console.log("AudioContext resumed successfully"); })
+                        .catch((e) => { console.log("Failed to resume AudioContext: " + e); });
+                }
+            }, 500);
+        });
+    });
+}
+setTimeout(ensureAudioContextIsResumed, 1000);
 //# sourceMappingURL=engine_audio.js.map

package/lib/engine/engine_camera.d.ts

@@ -1,13 +1,13 @@
-import { Camera, Object3D } from "three";
-import type { ICameraController } from "./engine_types.js";
-/** Get the camera controller for the given camera (if any)
- */
-export declare function getCameraController(cam: Camera): ICameraController | null;
-/** Set the camera controller for the given camera */
-export declare function setCameraController(cam: Camera, cameraController: ICameraController, active: boolean): void;
-/** @internal */
-export declare function useForAutoFit(obj: Object3D): boolean;
-/**
- * Enable or disable autofitting for the given object
- */
-export declare function setAutoFitEnabled(obj: Object3D, enabled: boolean): void;
+import { Camera, Object3D } from "three";
+import type { ICameraController } from "./engine_types.js";
+/** Get the camera controller for the given camera (if any)
+ */
+export declare function getCameraController(cam: Camera): ICameraController | null;
+/** Set the camera controller for the given camera */
+export declare function setCameraController(cam: Camera, cameraController: ICameraController, active: boolean): void;
+/** @internal */
+export declare function useForAutoFit(obj: Object3D): boolean;
+/**
+ * Enable or disable autofitting for the given object
+ */
+export declare function setAutoFitEnabled(obj: Object3D, enabled: boolean): void;

package/lib/engine/engine_camera.js

@@ -1,31 +1,31 @@
-const $cameraController = "needle:cameraController";
-/** Get the camera controller for the given camera (if any)
- */
-export function getCameraController(cam) {
-    return cam[$cameraController];
-}
-/** Set the camera controller for the given camera */
-export function setCameraController(cam, cameraController, active) {
-    if (active)
-        cam[$cameraController] = cameraController;
-    else {
-        if (cam[$cameraController] === cameraController)
-            cam[$cameraController] = null;
-    }
-}
-const autofit = "needle:autofit";
-/** @internal */
-export function useForAutoFit(obj) {
-    // if autofit is not defined we assume it may be included
-    if (obj[autofit] === undefined)
-        return true;
-    // otherwise if anything is set except false we assume it should be included
-    return obj[autofit] !== false;
-}
-/**
- * Enable or disable autofitting for the given object
- */
-export function setAutoFitEnabled(obj, enabled) {
-    obj[autofit] = enabled;
-}
+const $cameraController = "needle:cameraController";
+/** Get the camera controller for the given camera (if any)
+ */
+export function getCameraController(cam) {
+    return cam[$cameraController];
+}
+/** Set the camera controller for the given camera */
+export function setCameraController(cam, cameraController, active) {
+    if (active)
+        cam[$cameraController] = cameraController;
+    else {
+        if (cam[$cameraController] === cameraController)
+            cam[$cameraController] = null;
+    }
+}
+const autofit = "needle:autofit";
+/** @internal */
+export function useForAutoFit(obj) {
+    // if autofit is not defined we assume it may be included
+    if (obj[autofit] === undefined)
+        return true;
+    // otherwise if anything is set except false we assume it should be included
+    return obj[autofit] !== false;
+}
+/**
+ * Enable or disable autofitting for the given object
+ */
+export function setAutoFitEnabled(obj, enabled) {
+    obj[autofit] = enabled;
+}
 //# sourceMappingURL=engine_camera.js.map

package/lib/engine/engine_components.d.ts

@@ -1,110 +1,110 @@
-import { Object3D, Scene } from "three";
-import type { ComponentInit, Constructor, ConstructorConcrete, IComponent } from "./engine_types.js";
-export declare function removeComponent<T extends IComponent>(go: Object3D, componentInstance: T): T;
-export declare function getOrAddComponent<T extends IComponent>(go: Object3D, typeName: ConstructorConcrete<T>, init?: ComponentInit<T>): T;
-export declare function addNewComponent<T extends IComponent>(obj: Object3D, componentInstance: T, callAwake?: boolean): T;
-export declare function addComponent<T extends IComponent>(obj: Object3D, componentInstance: T | ConstructorConcrete<T>, init?: ComponentInit<T>, opts?: {
-    callAwake: boolean;
-}): T;
-export declare function destroyComponentInstance(componentInstance: IComponent): void;
-/**
- * Searches for a given component type in the given object.
- * @param obj The object to search in.
- * @param componentType The type of the component to search for.
- * @returns The first component of the given type found in the given object.
- * @example
- * ```typescript
- * const myComponent = getComponent(myObject, MyComponent);
- * ```
- */
-export declare function getComponent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>): T | null;
-/**
- * Searches for a given component type in the children of the given object.
- * @param obj The object to start the search from - this object is also included in the search.
- * @param componentType The type of the component to search for.
- * @param arr An optional array to store the found components in. If not provided, a new array is created.
- * @param clearArray If true, the array is cleared before storing the found components. Default is true.
- * @returns An array of components of the given type found in the children of the given object.
- * @example
- * ```typescript
- * const myComponents = getComponents(myObject, MyComponent);
- * ```
- */
-export declare function getComponents<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null, clearArray?: boolean): T[];
-/**
- * Searches for a given component type in the children of the given object.
- * @param obj The object to start the search from - this object is also included in the search.
- * @param componentType The type of the component to search for.
- * @param includeInactive If true, also inactive components are returned. Default is true.
- * @returns The first component of the given type found in the children of the given object.
- * @example
- * ```typescript
- * const myComponent = getComponentInChildren(myObject, MyComponent);
- * ```
- */
-export declare function getComponentInChildren<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, includeInactive?: boolean): T | null;
-/**
- * Searches for a given component type in the children of the given object.
- * @param obj The object to start the search from - this object is also included in the search.
- * @param componentType The type of the component to search for.
- * @param arr An optional array to store the found components in. If not provided, a new array is created.
- * @param clearArray If true, the array is cleared before storing the found components. Default is true.
- * @returns An array of components of the given type found in the children of the given object.
- * @example
- * ```typescript
- * const myComponents = getComponentsInChildren(myObject, MyComponent);
- * ```
- */
-export declare function getComponentsInChildren<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[], clearArray?: boolean): T[];
-/**
- * Searches for a given component type in the parent hierarchy of the given object.
- * @param obj The object to start the search from - this object is also included in the search.
- * @param componentType The type of the component to search for.
- * @returns The first component of the given type found in the parent hierarchy of the given object.
- * @example
- * ```typescript
- * const myComponent = getComponentInParent(myObject, MyComponent);
- * ```
- */
-export declare function getComponentInParent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>): T | null;
-/**
- * Searches for a given component type in the parent hierarchy of the given object.
- * @param obj The object to start the search from - this object is also included in the search.
- * @param componentType The type of the component to search for.
- * @param arr An optional array to store the found components in. If not provided, a new array is created.
- * @param clearArray If true, the array is cleared before storing the found components. Default is true.
- * @returns An array of components of the given type found in the parent hierarchy of the given object.
- * @example
- * ```typescript
- * const myComponents = getComponentsInParent(myObject, MyComponent);
- * ```
- */
-export declare function getComponentsInParent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null, clearArray?: boolean): T[];
-/**
- * Searches the the scene for a component of the given type.
- * If the contextOrScene is not provided, the current context is used.
- * @param type The type of the component to search for.
- * @param contextOrScene The context or scene to search in. If not provided, the current context is used.
- * @param includeInactive If true, also inactive components are returned. Default is true.
- * @returns The first component of the given type found in the scene or null if none was found.
- * @example
- * ```typescript
- * const myComponent = findObjectOfType(MyComponent);
- * ```
- */
-export declare function findObjectOfType<T extends IComponent>(type: Constructor<T>, contextOrScene?: undefined | Object3D | {
-    scene: Scene;
-}, includeInactive?: boolean): T | null;
-/**
- * Searches the the scene for all components of the given type.
- * If the contextOrScene is not provided, the current context is used.
- * @param type The type of the component to search for.
- * @param contextOrScene The context or scene to search in. If not provided, the current context is used.
- * @example
- * ```typescript
- * const myComponents = findObjectsOfType(MyComponent);
- * ```
- */
-export declare function findObjectsOfType<T extends IComponent>(type: Constructor<T>, array?: T[], contextOrScene?: undefined | Object3D | {
-    scene: Scene;
-}): T[];
+import { Object3D, Scene } from "three";
+import type { ComponentInit, Constructor, ConstructorConcrete, IComponent } from "./engine_types.js";
+export declare function removeComponent<T extends IComponent>(go: Object3D, componentInstance: T): T;
+export declare function getOrAddComponent<T extends IComponent>(go: Object3D, typeName: ConstructorConcrete<T>, init?: ComponentInit<T>): T;
+export declare function addNewComponent<T extends IComponent>(obj: Object3D, componentInstance: T, callAwake?: boolean): T;
+export declare function addComponent<T extends IComponent>(obj: Object3D, componentInstance: T | ConstructorConcrete<T>, init?: ComponentInit<T>, opts?: {
+    callAwake: boolean;
+}): T;
+export declare function destroyComponentInstance(componentInstance: IComponent): void;
+/**
+ * Searches for a given component type in the given object.
+ * @param obj The object to search in.
+ * @param componentType The type of the component to search for.
+ * @returns The first component of the given type found in the given object.
+ * @example
+ * ```typescript
+ * const myComponent = getComponent(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>): T | null;
+/**
+ * Searches for a given component type in the children of the given object.
+ * @param obj The object to start the search from - this object is also included in the search.
+ * @param componentType The type of the component to search for.
+ * @param arr An optional array to store the found components in. If not provided, a new array is created.
+ * @param clearArray If true, the array is cleared before storing the found components. Default is true.
+ * @returns An array of components of the given type found in the children of the given object.
+ * @example
+ * ```typescript
+ * const myComponents = getComponents(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponents<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null, clearArray?: boolean): T[];
+/**
+ * Searches for a given component type in the children of the given object.
+ * @param obj The object to start the search from - this object is also included in the search.
+ * @param componentType The type of the component to search for.
+ * @param includeInactive If true, also inactive components are returned. Default is true.
+ * @returns The first component of the given type found in the children of the given object.
+ * @example
+ * ```typescript
+ * const myComponent = getComponentInChildren(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponentInChildren<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, includeInactive?: boolean): T | null;
+/**
+ * Searches for a given component type in the children of the given object.
+ * @param obj The object to start the search from - this object is also included in the search.
+ * @param componentType The type of the component to search for.
+ * @param arr An optional array to store the found components in. If not provided, a new array is created.
+ * @param clearArray If true, the array is cleared before storing the found components. Default is true.
+ * @returns An array of components of the given type found in the children of the given object.
+ * @example
+ * ```typescript
+ * const myComponents = getComponentsInChildren(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponentsInChildren<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[], clearArray?: boolean): T[];
+/**
+ * Searches for a given component type in the parent hierarchy of the given object.
+ * @param obj The object to start the search from - this object is also included in the search.
+ * @param componentType The type of the component to search for.
+ * @returns The first component of the given type found in the parent hierarchy of the given object.
+ * @example
+ * ```typescript
+ * const myComponent = getComponentInParent(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponentInParent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>): T | null;
+/**
+ * Searches for a given component type in the parent hierarchy of the given object.
+ * @param obj The object to start the search from - this object is also included in the search.
+ * @param componentType The type of the component to search for.
+ * @param arr An optional array to store the found components in. If not provided, a new array is created.
+ * @param clearArray If true, the array is cleared before storing the found components. Default is true.
+ * @returns An array of components of the given type found in the parent hierarchy of the given object.
+ * @example
+ * ```typescript
+ * const myComponents = getComponentsInParent(myObject, MyComponent);
+ * ```
+ */
+export declare function getComponentsInParent<T extends IComponent>(obj: Object3D, componentType: Constructor<T>, arr?: T[] | null, clearArray?: boolean): T[];
+/**
+ * Searches the the scene for a component of the given type.
+ * If the contextOrScene is not provided, the current context is used.
+ * @param type The type of the component to search for.
+ * @param contextOrScene The context or scene to search in. If not provided, the current context is used.
+ * @param includeInactive If true, also inactive components are returned. Default is true.
+ * @returns The first component of the given type found in the scene or null if none was found.
+ * @example
+ * ```typescript
+ * const myComponent = findObjectOfType(MyComponent);
+ * ```
+ */
+export declare function findObjectOfType<T extends IComponent>(type: Constructor<T>, contextOrScene?: undefined | Object3D | {
+    scene: Scene;
+}, includeInactive?: boolean): T | null;
+/**
+ * Searches the the scene for all components of the given type.
+ * If the contextOrScene is not provided, the current context is used.
+ * @param type The type of the component to search for.
+ * @param contextOrScene The context or scene to search in. If not provided, the current context is used.
+ * @example
+ * ```typescript
+ * const myComponents = findObjectsOfType(MyComponent);
+ * ```
+ */
+export declare function findObjectsOfType<T extends IComponent>(type: Constructor<T>, array?: T[], contextOrScene?: undefined | Object3D | {
+    scene: Scene;
+}): T[];