@quick-threejs/reactive 0.1.40 → 0.1.42

package/dist/{FontLoader-Cp39O036.mjs → FontLoader-Dz0z8aMc.mjs}

@@ -2940,9 +2940,23 @@ function We(e, t) {
   }
 }
 class ei extends cr {
+  /**
+   * Constructs a new font loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
   constructor(t) {
     super(t);
   }
+  /**
+   * Starts loading from the given URL and passes the loaded font
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(Font)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
   load(t, r, n, i) {
     const o = this, s = new fr(this.manager);
     s.setPath(this.path), s.setRequestHeader(this.requestHeader), s.setWithCredentials(this.withCredentials), s.load(t, function(c) {
@@ -2950,14 +2964,33 @@ class ei extends cr {
       r && r(d);
     }, n, i);
   }
+  /**
+   * Parses the given font data and returns the resulting font.
+   *
+   * @param {Object} json - The raw font data as a JSON object.
+   * @return {Font} The font.
+   */
   parse(t) {
     return new Rn(t);
   }
 }
 class Rn {
+  /**
+   * Constructs a new font.
+   *
+   * @param {Object} data - The font data as JSON.
+   */
   constructor(t) {
     this.isFont = !0, this.type = "Font", this.data = t;
   }
+  /**
+   * Generates geometry shapes from the given text and size. The result of this method
+   * should be used with {@link ShapeGeometry} to generate the actual geometry data.
+   *
+   * @param {string} text - The text.
+   * @param {number} [size=100] - The text size.
+   * @return {Array<Shape>} An array of shapes representing the text.
+   */
   generateShapes(t, r = 100) {
     const n = [], i = Pn(t, r, this.data);
     for (let o = 0, s = i.length; o < s; o++)
@@ -3035,16 +3068,16 @@ export {
   zr as e,
   qn as f,
   Ln as g,
-  jn as h,
+  Ar as h,
   Zn as i,
-  Pt as j,
-  Xn as k,
-  Kn as l,
+  jn as j,
+  Pt as k,
+  Xn as l,
   Ht as m,
-  Bn as n,
-  zn as o,
-  Fn as p,
-  Ar as q,
+  Kn as n,
+  Bn as o,
+  zn as p,
+  Fn as q,
   Dr as r,
   Yn as s,
   Gn as t,

package/dist/common/blueprints/props.blueprint.d.ts

@@ -1,5 +1,5 @@
 import { DefaultCameraType } from '../enums';
-import { ContainerizedApp, Module, LoaderSource } from '../interfaces';
+import { ContainerizedApp, Module, LoaderSource, OffscreenCanvasWithStyle } from '../interfaces';
 import { RegisterModule } from '../../core/register/register.module';
 /**
  * @description {@link RegisterModule} initialization properties.
@@ -17,6 +17,12 @@ export declare class RegisterPropsBlueprint {
      * @default true
      */
     initOnConstruct?: boolean;
+    /**
+     * @description Initialize the app on main thread.
+     *
+     * @default false
+     */
+    mainThread?: boolean;
     /**
      * @description App `canvas` element reference.
      *
@@ -118,6 +124,8 @@ export declare class RegisterPropsBlueprint {
  * @description {@link AppModule} initialization properties.
  */
 export declare class LaunchAppProps<M extends Module> {
+    /** @description App `canvas` element reference. */
+    canvas?: OffscreenCanvasWithStyle | HTMLCanvasElement;
     /** @description Handler triggered when the app is ready. */
     onReady?: (workerApp: ContainerizedApp<M>) => unknown;
 }

package/dist/common/interfaces/core.interface.d.ts

@@ -1,3 +1,4 @@
+import { OffscreenCanvasWithStyle } from 'main';
 import { RegisterPropsBlueprint } from '../blueprints/props.blueprint';
 export interface AppModulePropsMessageEvent extends MessageEvent<Omit<RegisterPropsBlueprint, "canvas" | "location" | "loaderDataSources"> & {
     /**
@@ -5,6 +6,6 @@ export interface AppModulePropsMessageEvent extends MessageEvent<Omit<RegisterPr
      *
      * @default `undefined`
      */
-    canvas?: OffscreenCanvas;
+    canvas?: OffscreenCanvasWithStyle | HTMLCanvasElement;
 }> {
 }

package/dist/core/app/app.module.d.ts

@@ -1,6 +1,6 @@
 import { WorkerThreadModule } from '@quick-threejs/worker';
 import { Observable } from 'rxjs';
-import { AppModulePropsMessageEvent, Module, AppProxyEventHandlersBlueprint } from '../../common';
+import { AppModulePropsMessageEvent, Module, AppProxyEventHandlersBlueprint, OffscreenCanvasWithStyle } from '../../common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { TimerModule } from './timer/timer.module';
@@ -23,7 +23,7 @@ export declare class AppModule extends AppProxyEventHandlersBlueprint implements
     constructor(_controller: AppController, _service: AppService, timer: TimerModule, sizes: SizesModule, camera: CameraModule, world: WorldModule, renderer: RendererModule, loader: LoaderModule, debug: DebugModule);
     private _initProxyEvents;
     getProxyReceiver(): import('@quick-threejs/utils').ProxyReceiver<Record<string, unknown>>;
-    getCanvas(): import('../../common').OffscreenCanvasWithStyle | undefined;
+    getCanvas(): OffscreenCanvasWithStyle | HTMLCanvasElement | undefined;
     getIsInitialized(): boolean;
     getBeforeStep$(): Observable<import('@quick-threejs/utils').NonNever<{
         readonly frame: number;

package/dist/core/app/app.service.d.ts

@@ -4,6 +4,6 @@ export declare class AppService {
     private _canvas?;
     readonly proxyReceiver: ProxyReceiver<Record<string, unknown>>;
     isInitialized: boolean;
-    get canvas(): OffscreenCanvasWithStyle | undefined;
-    set canvas(canvas: OffscreenCanvasWithStyle | OffscreenCanvas);
+    get canvas(): OffscreenCanvasWithStyle | HTMLCanvasElement | undefined;
+    set canvas(canvas: HTMLCanvasElement | OffscreenCanvasWithStyle);
 }

package/dist/core/app/sizes/sizes.module.d.ts

@@ -6,7 +6,7 @@ export declare class SizesModule implements Module {
     private readonly _controller;
     private readonly _service;
     constructor(_controller: SizesController, _service: SizesService);
-    init(canvas: OffscreenCanvasWithStyle): void;
+    init(canvas: OffscreenCanvasWithStyle | HTMLCanvasElement): void;
     dispose(): void;
     aspect(value?: number): number;
     enabled(value?: boolean): boolean;

package/dist/core/app/sizes/sizes.service.d.ts

@@ -6,5 +6,5 @@ export declare class SizesService {
     pixelRatio: number;
     frustrum: number;
     enabled: boolean;
-    init(canvas: OffscreenCanvasWithStyle, enabled?: boolean): void;
+    init(canvas: OffscreenCanvasWithStyle | HTMLCanvasElement, enabled?: boolean): void;
 }

package/dist/core/register/register.module.d.ts

@@ -1,5 +1,5 @@
 import { DependencyContainer } from 'tsyringe';
-import { Module, RegisterPropsBlueprint, RegisterProxyEventHandlersBlueprint } from '../../common';
+import { Module, RegisterPropsBlueprint, RegisterProxyEventHandlersBlueprint, OffscreenCanvasWithStyle } from '../../common';
 import { ExposedAppModule } from '../app/app.worker';
 import { RegisterService } from './register.service';
 import { RegisterController } from './register.controller';
@@ -15,15 +15,17 @@ export declare class RegisterModule extends RegisterProxyEventHandlersBlueprint
     private readonly _subscriptions;
     private _initialized;
     constructor(_service: RegisterService, _controller: RegisterController, _loaderController: LoaderController, container: DependencyContainer, props: RegisterPropsBlueprint, loader: LoaderModule);
+    private get currentWorker();
     private _initCanvas;
-    private _initService;
+    private _initServiceWorker;
     private _initEvents;
-    private _initWorkerThread;
-    private _initObservableProxyEvents;
+    private _initOnMainThread;
+    private _initOnWorkerThread;
+    private _initObservables;
     private _initLoader;
     init(): Promise<void>;
     getCanvas(): HTMLCanvasElement | undefined;
-    getOffscreenCanvas(): OffscreenCanvas | undefined;
+    getOffscreenCanvas(): OffscreenCanvasWithStyle | undefined;
     getThread(): import('threads').ModuleThread<ExposedAppModule> | undefined;
     getWorker(): import('threads/dist/types/master').Worker | undefined;
     getWorkerPool(): import('@quick-threejs/worker').WorkerPool;

package/dist/core/register/register.service.d.ts

@@ -1,11 +1,11 @@
 import { WorkerPool, WorkerThreadResolution } from '@quick-threejs/worker';
-import { RegisterPropsBlueprint } from '../../common';
+import { OffscreenCanvasWithStyle, RegisterPropsBlueprint } from '../../common';
 import { ExposedAppModule } from '../app/app.worker';
 export declare class RegisterService {
     private readonly _props;
     readonly workerPool: WorkerPool;
     canvas?: HTMLCanvasElement;
-    offscreenCanvas?: OffscreenCanvas;
+    offscreenCanvas?: OffscreenCanvasWithStyle;
     worker?: WorkerThreadResolution<ExposedAppModule>["worker"];
     thread?: WorkerThreadResolution<ExposedAppModule>["thread"];
     constructor(_props: RegisterPropsBlueprint);