@needle-tools/engine 4.7.1 → 4.7.2-alpha

package/lib/engine/engine_lifecycle_api.d.ts

@@ -1,83 +1,83 @@
-import { type LifecycleMethod, LifecycleMethodOptions } from "./engine_lifecycle_functions_internal.js";
-/**
- * Register a callback in the engine context created event.
- * This happens once per context (after the context has been created and the first content has been loaded)
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onInitialized((ctx : Context) => {
- *     // do something
- * }
- * ```
- * */
-export declare function onInitialized(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/**
- * Register a callback before the engine context is cleared.
- * This happens if e.g. `<needle-engine src>` changes
- */
-export declare function onClear(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/**
- * Register a callback in the engine before the context is destroyed
- * This happens once per context (before the context is destroyed)
- */
-export declare function onDestroy(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/** Register a callback in the engine start event.
- * This happens once at the beginning of a frame
- * (e.g. once when the method is registered, after <needle-engine> is created or the src has changed)
- * @param cb The callback to be called. Optionally return a function that will be called when the onStart callback is removed again
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onStart((ctx : Context) => {
- *     // do something
- *     console.log("Needle Engine: onStart registered")
- *     // optional to cleanup:
- *     return () => { console.log("OnStart removed") }
- * }
- * ```
- * */
-export declare function onStart(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/** Register a callback in the engine update event
- * This is called every frame
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onUpdate((ctx : Context) => {
- *     // do something
- *     console.log("Needle Engine: onUpdate registered")
- *     // optional to cleanup:
- *     return () => { console.log("onUpdate removed") }
- * }
- * ```
- * */
-export declare function onUpdate(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/** Register a callback in the engine onBeforeRender event
- * This is called every frame before the main camera renders
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onBeforeRender((ctx : Context) => {
- *     // do something
- * }
- * ```
- * */
-export declare function onBeforeRender(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
-/**
- * Register a callback in the engine onAfterRender event
- * This is called every frame after the main camera has rendered
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * const unsubscribe = onAfterRender((ctx : Context) => {
- *    // do something...
- *    console.log("After render");
- *    // if you want to unsubscribe after the first call:
- *    unsubscribe();
- * });
- * ```
- */
-export declare function onAfterRender(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+import { type LifecycleMethod, LifecycleMethodOptions } from "./engine_lifecycle_functions_internal.js";
+/**
+ * Register a callback in the engine context created event.
+ * This happens once per context (after the context has been created and the first content has been loaded)
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onInitialized((ctx : Context) => {
+ *     // do something
+ * }
+ * ```
+ * */
+export declare function onInitialized(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/**
+ * Register a callback before the engine context is cleared.
+ * This happens if e.g. `<needle-engine src>` changes
+ */
+export declare function onClear(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/**
+ * Register a callback in the engine before the context is destroyed
+ * This happens once per context (before the context is destroyed)
+ */
+export declare function onDestroy(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/** Register a callback in the engine start event.
+ * This happens once at the beginning of a frame
+ * (e.g. once when the method is registered, after <needle-engine> is created or the src has changed)
+ * @param cb The callback to be called. Optionally return a function that will be called when the onStart callback is removed again
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onStart((ctx : Context) => {
+ *     // do something
+ *     console.log("Needle Engine: onStart registered")
+ *     // optional to cleanup:
+ *     return () => { console.log("OnStart removed") }
+ * }
+ * ```
+ * */
+export declare function onStart(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/** Register a callback in the engine update event
+ * This is called every frame
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onUpdate((ctx : Context) => {
+ *     // do something
+ *     console.log("Needle Engine: onUpdate registered")
+ *     // optional to cleanup:
+ *     return () => { console.log("onUpdate removed") }
+ * }
+ * ```
+ * */
+export declare function onUpdate(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/** Register a callback in the engine onBeforeRender event
+ * This is called every frame before the main camera renders
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onBeforeRender((ctx : Context) => {
+ *     // do something
+ * }
+ * ```
+ * */
+export declare function onBeforeRender(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;
+/**
+ * Register a callback in the engine onAfterRender event
+ * This is called every frame after the main camera has rendered
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * const unsubscribe = onAfterRender((ctx : Context) => {
+ *    // do something...
+ *    console.log("After render");
+ *    // if you want to unsubscribe after the first call:
+ *    unsubscribe();
+ * });
+ * ```
+ */
+export declare function onAfterRender(cb: LifecycleMethod, opts?: LifecycleMethodOptions): () => void;

package/lib/engine/engine_lifecycle_api.js

@@ -1,107 +1,107 @@
-import { FrameEvent } from "./engine_context.js";
-import { ContextEvent } from "./engine_context_registry.js";
-import { registerFrameEventCallback, unregisterFrameEventCallback } from "./engine_lifecycle_functions_internal.js";
-/**
- * Register a callback in the engine context created event.
- * This happens once per context (after the context has been created and the first content has been loaded)
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onInitialized((ctx : Context) => {
- *     // do something
- * }
- * ```
- * */
-export function onInitialized(cb, opts) {
-    registerFrameEventCallback(cb, ContextEvent.ContextCreated, opts);
-    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextCreated);
-}
-/**
- * Register a callback before the engine context is cleared.
- * This happens if e.g. `<needle-engine src>` changes
- */
-export function onClear(cb, opts) {
-    registerFrameEventCallback(cb, ContextEvent.ContextClearing, opts);
-    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextClearing);
-}
-/**
- * Register a callback in the engine before the context is destroyed
- * This happens once per context (before the context is destroyed)
- */
-export function onDestroy(cb, opts) {
-    registerFrameEventCallback(cb, ContextEvent.ContextDestroying, opts);
-    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextDestroying);
-}
-/** Register a callback in the engine start event.
- * This happens once at the beginning of a frame
- * (e.g. once when the method is registered, after <needle-engine> is created or the src has changed)
- * @param cb The callback to be called. Optionally return a function that will be called when the onStart callback is removed again
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onStart((ctx : Context) => {
- *     // do something
- *     console.log("Needle Engine: onStart registered")
- *     // optional to cleanup:
- *     return () => { console.log("OnStart removed") }
- * }
- * ```
- * */
-export function onStart(cb, opts) {
-    registerFrameEventCallback(cb, FrameEvent.Start, opts);
-    return () => unregisterFrameEventCallback(cb, FrameEvent.Start);
-}
-/** Register a callback in the engine update event
- * This is called every frame
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onUpdate((ctx : Context) => {
- *     // do something
- *     console.log("Needle Engine: onUpdate registered")
- *     // optional to cleanup:
- *     return () => { console.log("onUpdate removed") }
- * }
- * ```
- * */
-export function onUpdate(cb, opts) {
-    registerFrameEventCallback(cb, FrameEvent.Update, opts);
-    return () => unregisterFrameEventCallback(cb, FrameEvent.Update);
-}
-/** Register a callback in the engine onBeforeRender event
- * This is called every frame before the main camera renders
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * onBeforeRender((ctx : Context) => {
- *     // do something
- * }
- * ```
- * */
-export function onBeforeRender(cb, opts) {
-    registerFrameEventCallback(cb, FrameEvent.OnBeforeRender, opts);
-    return () => unregisterFrameEventCallback(cb, FrameEvent.OnBeforeRender);
-}
-/**
- * Register a callback in the engine onAfterRender event
- * This is called every frame after the main camera has rendered
- * @param cb The callback to be called
- * @returns A function that can be called to unregister the callback
- * @example
- * ```ts
- * const unsubscribe = onAfterRender((ctx : Context) => {
- *    // do something...
- *    console.log("After render");
- *    // if you want to unsubscribe after the first call:
- *    unsubscribe();
- * });
- * ```
- */
-export function onAfterRender(cb, opts) {
-    registerFrameEventCallback(cb, FrameEvent.OnAfterRender, opts);
-    return () => unregisterFrameEventCallback(cb, FrameEvent.OnAfterRender);
-}
+import { FrameEvent } from "./engine_context.js";
+import { ContextEvent } from "./engine_context_registry.js";
+import { registerFrameEventCallback, unregisterFrameEventCallback } from "./engine_lifecycle_functions_internal.js";
+/**
+ * Register a callback in the engine context created event.
+ * This happens once per context (after the context has been created and the first content has been loaded)
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onInitialized((ctx : Context) => {
+ *     // do something
+ * }
+ * ```
+ * */
+export function onInitialized(cb, opts) {
+    registerFrameEventCallback(cb, ContextEvent.ContextCreated, opts);
+    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextCreated);
+}
+/**
+ * Register a callback before the engine context is cleared.
+ * This happens if e.g. `<needle-engine src>` changes
+ */
+export function onClear(cb, opts) {
+    registerFrameEventCallback(cb, ContextEvent.ContextClearing, opts);
+    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextClearing);
+}
+/**
+ * Register a callback in the engine before the context is destroyed
+ * This happens once per context (before the context is destroyed)
+ */
+export function onDestroy(cb, opts) {
+    registerFrameEventCallback(cb, ContextEvent.ContextDestroying, opts);
+    return () => unregisterFrameEventCallback(cb, ContextEvent.ContextDestroying);
+}
+/** Register a callback in the engine start event.
+ * This happens once at the beginning of a frame
+ * (e.g. once when the method is registered, after <needle-engine> is created or the src has changed)
+ * @param cb The callback to be called. Optionally return a function that will be called when the onStart callback is removed again
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onStart((ctx : Context) => {
+ *     // do something
+ *     console.log("Needle Engine: onStart registered")
+ *     // optional to cleanup:
+ *     return () => { console.log("OnStart removed") }
+ * }
+ * ```
+ * */
+export function onStart(cb, opts) {
+    registerFrameEventCallback(cb, FrameEvent.Start, opts);
+    return () => unregisterFrameEventCallback(cb, FrameEvent.Start);
+}
+/** Register a callback in the engine update event
+ * This is called every frame
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onUpdate((ctx : Context) => {
+ *     // do something
+ *     console.log("Needle Engine: onUpdate registered")
+ *     // optional to cleanup:
+ *     return () => { console.log("onUpdate removed") }
+ * }
+ * ```
+ * */
+export function onUpdate(cb, opts) {
+    registerFrameEventCallback(cb, FrameEvent.Update, opts);
+    return () => unregisterFrameEventCallback(cb, FrameEvent.Update);
+}
+/** Register a callback in the engine onBeforeRender event
+ * This is called every frame before the main camera renders
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * onBeforeRender((ctx : Context) => {
+ *     // do something
+ * }
+ * ```
+ * */
+export function onBeforeRender(cb, opts) {
+    registerFrameEventCallback(cb, FrameEvent.OnBeforeRender, opts);
+    return () => unregisterFrameEventCallback(cb, FrameEvent.OnBeforeRender);
+}
+/**
+ * Register a callback in the engine onAfterRender event
+ * This is called every frame after the main camera has rendered
+ * @param cb The callback to be called
+ * @returns A function that can be called to unregister the callback
+ * @example
+ * ```ts
+ * const unsubscribe = onAfterRender((ctx : Context) => {
+ *    // do something...
+ *    console.log("After render");
+ *    // if you want to unsubscribe after the first call:
+ *    unsubscribe();
+ * });
+ * ```
+ */
+export function onAfterRender(cb, opts) {
+    registerFrameEventCallback(cb, FrameEvent.OnAfterRender, opts);
+    return () => unregisterFrameEventCallback(cb, FrameEvent.OnAfterRender);
+}
 //# sourceMappingURL=engine_lifecycle_api.js.map

package/lib/engine/engine_lifecycle_functions_internal.d.ts

@@ -1,32 +1,32 @@
-import { type Context, FrameEvent } from "./engine_context.js";
-import { ContextEvent } from "./engine_context_registry.js";
-export declare type Event = ContextEvent | FrameEvent;
-declare type LifecycleHookContext = {
-    context: Context;
-};
-/**
- * A function that can be called during the Needle Engine frame event at a specific point
- * @link https://engine.needle.tools/docs/scripting.html#special-lifecycle-hooks
- */
-export declare type LifecycleMethod = (this: LifecycleHookContext, ctx: Context) => void;
-/**
- * Options for `onStart(()=>{})` etc event hooks
- * @link https://engine.needle.tools/docs/scripting.html#special-lifecycle-hooks
- */
-export declare type LifecycleMethodOptions = {
-    /**
-     * If true, the callback will only be called once
-     */
-    once?: boolean;
-};
-/** register a function to be called during the Needle Engine frame event at a specific point
- * @param cb the function to call
- * @param evt the event to call the function at
- */
-export declare function registerFrameEventCallback(cb: LifecycleMethod, evt: Event, opts?: LifecycleMethodOptions): void;
-/**
- * unregister a function to be called during the Needle Engine frame event at a specific point
- */
-export declare function unregisterFrameEventCallback(cb: LifecycleMethod, evt: Event): void;
-export declare function invokeLifecycleFunctions(ctx: Context, evt: Event): void;
-export {};
+import { type Context, FrameEvent } from "./engine_context.js";
+import { ContextEvent } from "./engine_context_registry.js";
+export declare type Event = ContextEvent | FrameEvent;
+declare type LifecycleHookContext = {
+    context: Context;
+};
+/**
+ * A function that can be called during the Needle Engine frame event at a specific point
+ * @link https://engine.needle.tools/docs/scripting.html#special-lifecycle-hooks
+ */
+export declare type LifecycleMethod = (this: LifecycleHookContext, ctx: Context) => void;
+/**
+ * Options for `onStart(()=>{})` etc event hooks
+ * @link https://engine.needle.tools/docs/scripting.html#special-lifecycle-hooks
+ */
+export declare type LifecycleMethodOptions = {
+    /**
+     * If true, the callback will only be called once
+     */
+    once?: boolean;
+};
+/** register a function to be called during the Needle Engine frame event at a specific point
+ * @param cb the function to call
+ * @param evt the event to call the function at
+ */
+export declare function registerFrameEventCallback(cb: LifecycleMethod, evt: Event, opts?: LifecycleMethodOptions): void;
+/**
+ * unregister a function to be called during the Needle Engine frame event at a specific point
+ */
+export declare function unregisterFrameEventCallback(cb: LifecycleMethod, evt: Event): void;
+export declare function invokeLifecycleFunctions(ctx: Context, evt: Event): void;
+export {};