@quick-threejs/reactive 0.1.41 → 0.1.43

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, OffscreenCanvasStb } 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?: OffscreenCanvasStb | HTMLCanvasElement;
     /** @description Handler triggered when the app is ready. */
     onReady?: (workerApp: ContainerizedApp<M>) => unknown;
 }

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

@@ -1,4 +1,4 @@
-export interface OffscreenCanvasWithStyle extends OffscreenCanvas {
+export interface OffscreenCanvasStb extends OffscreenCanvas {
     style: Partial<CSSStyleDeclaration> & {
         width: CSSStyleDeclaration["width"];
         height: CSSStyleDeclaration["height"];

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

@@ -1,3 +1,4 @@
+import { OffscreenCanvasStb } 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?: OffscreenCanvasStb | 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, OffscreenCanvasStb } 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(): OffscreenCanvasStb | HTMLCanvasElement | undefined;
     getIsInitialized(): boolean;
     getBeforeStep$(): Observable<import('@quick-threejs/utils').NonNever<{
         readonly frame: number;

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

@@ -1,9 +1,9 @@
 import { ProxyReceiver } from '@quick-threejs/utils';
-import { OffscreenCanvasWithStyle } from '../../common/interfaces';
+import { OffscreenCanvasStb } from '../../common/interfaces';
 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(): OffscreenCanvasStb | HTMLCanvasElement | undefined;
+    set canvas(canvas: HTMLCanvasElement | OffscreenCanvasStb);
 }

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

@@ -1,12 +1,12 @@
 import { Vector2Like } from 'three';
-import { Module, OffscreenCanvasWithStyle } from '../../../common/interfaces';
+import { Module, OffscreenCanvasStb } from '../../../common/interfaces';
 import { RendererService } from './renderer.service';
 import { RendererController } from './renderer.controller';
 export declare class RendererModule implements Module {
     private readonly _controller;
     private readonly _service;
     constructor(_controller: RendererController, _service: RendererService);
-    init(canvas: OffscreenCanvasWithStyle): void;
+    init(canvas: OffscreenCanvasStb): void;
     enabled(value?: boolean): boolean;
     instance(): import('three').WebGLRenderer | undefined;
     setSize(value: Vector2Like): void;

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

@@ -1,5 +1,5 @@
 import { WebGLRenderer } from 'three';
-import { OffscreenCanvasWithStyle } from '../../../common/interfaces';
+import { OffscreenCanvasStb } from '../../../common/interfaces';
 import { WorldService } from '../world/world.service';
 import { CameraService } from '../camera/camera.service';
 import { SizesService } from '../sizes/sizes.service';
@@ -11,7 +11,7 @@ export declare class RendererService {
     enabled: boolean;
     instance?: WebGLRenderer;
     constructor(_worldService: WorldService, _cameraService: CameraService, _sizesService: SizesService);
-    setWebGLRenderer(canvas: OffscreenCanvasWithStyle): void;
+    setWebGLRenderer(canvas: OffscreenCanvasStb | HTMLCanvasElement): void;
     setSize(width: number, height: number): void;
     render(): void;
 }

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

@@ -1,12 +1,12 @@
 import { SizesService } from './sizes.service';
 import { SizesController } from './sizes.controller';
 import { Module } from '../../../common/interfaces/module.interface';
-import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
+import { OffscreenCanvasStb } from '../../../common/interfaces/canvas.interface';
 export declare class SizesModule implements Module {
     private readonly _controller;
     private readonly _service;
     constructor(_controller: SizesController, _service: SizesService);
-    init(canvas: OffscreenCanvasWithStyle): void;
+    init(canvas: OffscreenCanvasStb | HTMLCanvasElement): void;
     dispose(): void;
     aspect(value?: number): number;
     enabled(value?: boolean): boolean;

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

@@ -1,4 +1,4 @@
-import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
+import { OffscreenCanvasStb } from '../../../common/interfaces/canvas.interface';
 export declare class SizesService {
     width: number;
     height: number;
@@ -6,5 +6,5 @@ export declare class SizesService {
     pixelRatio: number;
     frustrum: number;
     enabled: boolean;
-    init(canvas: OffscreenCanvasWithStyle, enabled?: boolean): void;
+    init(canvas: OffscreenCanvasStb | 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, OffscreenCanvasStb } 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(): OffscreenCanvasStb | 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 { OffscreenCanvasStb, RegisterPropsBlueprint } from '../../common';
 import { ExposedAppModule } from '../app/app.worker';
 export declare class RegisterService {
     private readonly _props;
     readonly workerPool: WorkerPool;
     canvas?: HTMLCanvasElement;
-    offscreenCanvas?: OffscreenCanvas;
+    offscreenCanvas?: OffscreenCanvasStb;
     worker?: WorkerThreadResolution<ExposedAppModule>["worker"];
     thread?: WorkerThreadResolution<ExposedAppModule>["thread"];
     constructor(_props: RegisterPropsBlueprint);