@quick-threejs/reactive 0.1.46 → 0.1.47

package/dist/common/interfaces/proxy-event.interface.d.ts

@@ -3,6 +3,8 @@ import { PROXY_EVENT_LISTENERS } from '../constants/event.constants';
 export interface ProxyEvent {
     width: number;
     height: number;
+    wrapperWidth: number;
+    wrapperHeight: number;
     windowWidth: number;
     windowHeight: number;
 }

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, OffscreenCanvasStb, AppProxyEventHandlersBlueprint } from '../../common';
+import { AppModulePropsMessageEvent, Module, AppProxyEventHandlersBlueprint } 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(): OffscreenCanvasStb | HTMLCanvasElement | undefined;
+    getCanvas(): import('../../common').OffscreenCanvasStb | HTMLCanvasElement | undefined;
     getIsInitialized(): boolean;
     getBeforeStep$(): Observable<import('@quick-threejs/utils').NonNever<{
         readonly fps: 60;

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

@@ -1,9 +1,10 @@
 import { ProxyReceiver } from '@quick-threejs/utils';
-import { OffscreenCanvasStb } from '../../common';
+import { AppModulePropsMessageEvent, OffscreenCanvasStb } from '../../common';
 export declare class AppService {
     private _canvas?;
     readonly proxyReceiver: ProxyReceiver<Record<string, unknown>>;
     isInitialized: boolean;
+    init(canvas: AppModulePropsMessageEvent["data"]["canvas"]): void;
     get canvas(): OffscreenCanvasStb | HTMLCanvasElement | undefined;
     set canvas(canvas: HTMLCanvasElement | OffscreenCanvasStb);
 }

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

@@ -2,5 +2,5 @@ import { Methods } from '@quick-threejs/utils';
 import { ExposedWorkerThreadModule } from '@quick-threejs/worker';
 import { ProxyEventListenerKeys, ContainerizedApp, LaunchAppProps } from '../../common';
 import { AppModule } from './app.module';
-export declare const launchApp: (props?: LaunchAppProps<AppModule>) => ContainerizedApp<AppModule>;
+export declare const launchApp: (props?: LaunchAppProps<AppModule>) => Promise<ContainerizedApp<AppModule>>;
 export type ExposedAppModule = Omit<ExposedWorkerThreadModule<Methods<AppModule>>, `${ProxyEventListenerKeys}$` | "init" | "getCanvas">;

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

@@ -2,13 +2,11 @@ import { Camera, Quaternion, Vector3 } from 'three';
 import { Module } from '../../../common';
 import { CameraService } from './camera.service';
 import { CameraController } from './camera.controller';
-import { SizesService } from '../sizes/sizes.service';
 export declare class CameraModule implements Module {
-    private readonly _sizesService;
     private readonly _controller;
     private readonly _service;
-    private readonly _subscriptions;
-    constructor(_sizesService: SizesService, _controller: CameraController, _service: CameraService);
+    private _subscriptions;
+    constructor(_controller: CameraController, _service: CameraService);
     init(): void;
     enabled(value?: boolean): boolean;
     aspectRatio(value?: number): number;

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

@@ -2,14 +2,15 @@ import { Euler, Quaternion, Vector3, Camera } from 'three';
 import { DefaultCameraType } from '../../../common';
 import { SizesService } from '../sizes/sizes.service';
 export declare class CameraService {
-    private readonly _sizesService;
+    private readonly _sizes;
     instance?: Camera;
     enabled: boolean;
-    constructor(_sizesService: SizesService);
+    constructor(_sizes: SizesService);
     set aspectRatio(ratio: number);
     set quaternion(quaternion: Quaternion);
     set position(position: Vector3);
     set rotation(rotation: Euler);
     init(cameraType?: DefaultCameraType): void;
+    handleStep(): void;
     dispose(): void;
 }

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

@@ -5,7 +5,7 @@ import { DebugController } from './debug.controller';
 export declare class DebugModule implements Module {
     readonly _service: DebugService;
     readonly _controller: DebugController;
-    private readonly _subscriptions;
+    private _subscriptions;
     constructor(_service: DebugService, _controller: DebugController);
     init(props: AppModulePropsMessageEvent["data"]): void;
     enabled(value?: boolean): boolean;

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

@@ -7,7 +7,7 @@ import { SizesService } from '../sizes/sizes.service';
 import { RendererService } from '../renderer/renderer.service';
 export declare class DebugService {
     private readonly _appService;
-    private readonly _sizesService;
+    private readonly _sizes;
     private readonly _rendererService;
     private readonly _cameraService;
     private readonly _worldService;
@@ -17,7 +17,7 @@ export declare class DebugService {
     miniCameraControls?: OrbitControls;
     axesHelper?: AxesHelper;
     gridHelper?: GridHelper;
-    constructor(_appService: AppService, _sizesService: SizesService, _rendererService: RendererService, _cameraService: CameraService, _worldService: WorldService);
+    constructor(_appService: AppService, _sizes: SizesService, _rendererService: RendererService, _cameraService: CameraService, _worldService: WorldService);
     private _renderMiniCamera;
     initMiniCamera(): void;
     initOrbitControl(): void;

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

@@ -4,7 +4,7 @@ import { LoaderService } from './loader.service';
 export declare class LoaderModule implements Module {
     private readonly _controller;
     private readonly _service;
-    private readonly _subscriptions;
+    private _subscriptions;
     constructor(_controller: LoaderController, _service: LoaderService);
     init(): void;
     getLoadedResources(): Record<string, import('../../../common').LoaderResource>;

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

@@ -1,15 +1,15 @@
-import { Vector2Like } from 'three';
-import { Module, OffscreenCanvasStb } from '../../../common';
+import { AppModulePropsMessageEvent, Module } from '../../../common';
 import { RendererService } from './renderer.service';
 import { RendererController } from './renderer.controller';
 export declare class RendererModule implements Module {
     private readonly _controller;
     private readonly _service;
+    private _subscriptions;
     constructor(_controller: RendererController, _service: RendererService);
-    init(canvas: OffscreenCanvasStb): void;
+    init({ canvas }: AppModulePropsMessageEvent["data"]): void;
     enabled(value?: boolean): boolean;
+    enabledAutoResize(value?: boolean): boolean;
     instance(): import('three').WebGLRenderer | undefined;
-    setSize(value: Vector2Like): void;
     render(): void;
     dispose(): void;
 }

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

@@ -6,12 +6,12 @@ import { SizesService } from '../sizes/sizes.service';
 export declare class RendererService {
     private readonly _worldService;
     private readonly _cameraService;
-    private readonly _sizesService;
-    static readonly RENDERER_PIXEL_RATIO: number;
+    private readonly _sizes;
     enabled: boolean;
+    enabledAutoResize: boolean;
     instance?: WebGLRenderer;
-    constructor(_worldService: WorldService, _cameraService: CameraService, _sizesService: SizesService);
-    setWebGLRenderer(canvas: OffscreenCanvasStb | HTMLCanvasElement): void;
-    setSize(width: number, height: number): void;
+    constructor(_worldService: WorldService, _cameraService: CameraService, _sizes: SizesService);
+    init(canvas: OffscreenCanvasStb | HTMLCanvasElement): void;
+    handleAutoResize(): void;
     render(): void;
 }

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

@@ -1,17 +1,26 @@
+import { AppModulePropsMessageEvent, Module } from '../../../common';
 import { SizesService } from './sizes.service';
 import { SizesController } from './sizes.controller';
-import { Module, OffscreenCanvasStb } from '../../../common';
 export declare class SizesModule implements Module {
     private readonly _controller;
     private readonly _service;
+    private _subscriptions;
     constructor(_controller: SizesController, _service: SizesService);
-    init(canvas: OffscreenCanvasStb | HTMLCanvasElement): void;
+    init({ canvas, pixelRatio, fullScreen, hasCanvasWrapper }: AppModulePropsMessageEvent["data"]): void;
     dispose(): void;
-    aspect(value?: number): number;
     enabled(value?: boolean): boolean;
     frustrum(value?: number): number;
     height(value?: number): number;
-    pixelRatio(value?: number): number;
     width(value?: number): number;
+    wrapperHeight(value?: number): number;
+    wrapperWidth(value?: number): number;
+    windowHeight(value?: number): number;
+    windowWidth(value?: number): number;
+    aspect(value?: number): number;
+    pixelRatio(value?: number): number;
+    getViewPortSizes(): {
+        width: number;
+        height: number;
+    };
     resize$(): import('rxjs').Observable<UIEvent & import('../../../common').ProxyEvent>;
 }

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

@@ -1,10 +1,21 @@
-import { OffscreenCanvasStb } from '../../../common';
+import { ProxyEvent, OffscreenCanvasStb } from '../../../common';
 export declare class SizesService {
     width: number;
     height: number;
+    wrapperWidth: number;
+    wrapperHeight: number;
+    windowWidth: number;
+    windowHeight: number;
     aspect: number;
     pixelRatio: number;
     frustrum: number;
     enabled: boolean;
-    init(canvas: OffscreenCanvasStb | HTMLCanvasElement, enabled?: boolean): void;
+    fullscreen: boolean;
+    hasCanvasWrapper: boolean;
+    init(canvas: OffscreenCanvasStb | HTMLCanvasElement, pixelRatio?: number, fullscreen?: boolean, hasCanvasWrapper?: boolean, enabled?: boolean): void;
+    handleResize(size: UIEvent & ProxyEvent): void;
+    getViewPortSizes(): {
+        width: number;
+        height: number;
+    };
 }

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

@@ -1,6 +1,5 @@
 import { DependencyContainer } from 'tsyringe';
 import { Module, OffscreenCanvasStb, RegisterPropsBlueprint, RegisterProxyEventHandlersBlueprint } from '../../common';
-import { ExposedAppModule } from '../app/app.worker';
 import { RegisterService } from './register.service';
 import { RegisterController } from './register.controller';
 import { LoaderModule } from './loader/loader.module';
@@ -17,18 +16,16 @@ export declare class RegisterModule extends RegisterProxyEventHandlersBlueprint
     constructor(_service: RegisterService, _controller: RegisterController, _loaderController: LoaderController, container: DependencyContainer, props: RegisterPropsBlueprint, loader: LoaderModule);
     private get currentWorker();
     private _initCanvas;
-    private _initServiceWorker;
     private _initEvents;
-    private _initOnMainThread;
-    private _initOnWorkerThread;
+    private _initCore;
     private _initObservables;
     private _initLoader;
     init(): Promise<void>;
     getCanvas(): HTMLCanvasElement | undefined;
     getOffscreenCanvas(): OffscreenCanvasStb | undefined;
-    getThread(): import('threads').ModuleThread<ExposedAppModule> | undefined;
-    getWorker(): import('threads/dist/types/master').Worker | undefined;
-    getWorkerPool(): import('@quick-threejs/worker').WorkerPool;
+    getWorkerThread(): any;
+    getWorkerPool(): WorkerPool;
+    getProps(): RegisterPropsBlueprint;
     isInitialized(): boolean;
     dispose(): Promise<void>;
 }

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

@@ -5,17 +5,18 @@ export declare class RegisterService {
     private readonly _props;
     readonly workerPool: WorkerPool;
     canvas?: HTMLCanvasElement;
+    canvasWrapper?: HTMLElement;
     offscreenCanvas?: OffscreenCanvasStb;
-    worker?: WorkerThreadResolution<ExposedAppModule>["worker"];
-    thread?: WorkerThreadResolution<ExposedAppModule>["thread"];
+    workerThread?: WorkerThreadResolution<ExposedAppModule>;
     constructor(_props: RegisterPropsBlueprint);
-    init(app: WorkerThreadResolution<ExposedAppModule>): void;
     preventDefaultHandler(e: Event): {
         type: string;
     };
     getScreenSizes(): {
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     };
@@ -25,22 +26,26 @@ export declare class RegisterService {
         left: number | undefined;
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     };
     mouseEventHandler(e: PointerEvent): {
         button: number;
-        clientX: number;
-        clientY: number;
         ctrlKey: boolean;
         metaKey: boolean;
-        pageX: number;
-        pageY: number;
         shiftKey: boolean;
         pointerType: string;
+        clientX: number;
+        clientY: number;
+        pageX: number;
+        pageY: number;
         type?: string;
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     };
@@ -52,6 +57,8 @@ export declare class RegisterService {
         }[];
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     };
@@ -61,6 +68,8 @@ export declare class RegisterService {
         type?: string;
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     };
@@ -72,6 +81,8 @@ export declare class RegisterService {
         type?: string;
         width: number | undefined;
         height: number | undefined;
+        wrapperWidth: number;
+        wrapperHeight: number;
         windowWidth: number;
         windowHeight: number;
     } | undefined;