@quick-threejs/reactive 0.1.23 → 0.1.25

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

@@ -1,13 +1,13 @@
 import { Camera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
-import { CameraComponent } from './camera.component';
+import { CameraService } from './camera.service';
 import { CameraController } from './camera.controller';
-import { SizesComponent } from '../sizes/sizes.component';
+import { SizesService } from '../sizes/sizes.service';
 import { Module } from '../../../common/interfaces/module.interface';
 export declare class CameraModule implements Module {
-    private readonly component;
-    private readonly sizesComponent;
-    private readonly controller;
-    constructor(component: CameraComponent, sizesComponent: SizesComponent, controller: CameraController);
+    private readonly _sizesService;
+    private readonly _controller;
+    private readonly _service;
+    constructor(_sizesService: SizesService, _controller: CameraController, _service: CameraService);
     init(withMiniCamera?: boolean): void;
     dispose(): void;
     aspectRatio(value?: number): number;
@@ -16,5 +16,4 @@ export declare class CameraModule implements Module {
     miniCamera(value?: PerspectiveCamera): PerspectiveCamera | undefined;
     position(value?: Vector3): Vector3;
     quaternion(value?: Quaternion): Quaternion;
-    enabled$(): import('rxjs').Observable<boolean>;
 }

package/dist/core/app/camera/{camera.component.d.ts → camera.service.d.ts}

@@ -1,12 +1,12 @@
 import { Camera, Euler, PerspectiveCamera, Quaternion, Vector3 } from 'three';
-import { SizesComponent } from '../sizes/sizes.component';
+import { SizesService } from '../sizes/sizes.service';
 import { DefaultCameraType } from '../../../common/enums/camera.enum';
-export declare class CameraComponent {
-    private readonly sizesComponent;
+export declare class CameraService {
+    private readonly _sizesService;
     instance?: Camera;
     miniCamera?: PerspectiveCamera;
     enabled: boolean;
-    constructor(sizesComponent: SizesComponent);
+    constructor(_sizesService: SizesService);
     set aspectRatio(ratio: number);
     set quaternion(quaternion: Quaternion);
     set position(position: Vector3);

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

@@ -1,9 +1,8 @@
-import { Subject } from 'rxjs';
 import { TimerController } from '../timer/timer.controller';
+import { CameraService } from '../camera/camera.service';
 export declare class DebugController {
     private readonly timerController;
-    readonly enable$$: Subject<boolean>;
-    readonly enable$: import('rxjs').Observable<boolean>;
+    private readonly _service;
     readonly step$: TimerController["step$"];
-    constructor(timerController: TimerController);
+    constructor(timerController: TimerController, _service: CameraService);
 }

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

@@ -1,17 +1,19 @@
-import { DebugComponent } from './debug.component';
-import { DebugController } from './debug.controller';
 import { Module } from '../../../common/interfaces/module.interface';
+import { DebugService } from './debug.service';
+import { DebugController } from './debug.controller';
 export declare class DebugModule implements Module {
-    readonly component: DebugComponent;
-    readonly controller: DebugController;
-    constructor(component: DebugComponent, controller: DebugController);
-    init(props?: Parameters<DebugComponent["init"]>[0]): void;
-    dispose(): void;
+    readonly _service: DebugService;
+    readonly _controller: DebugController;
+    constructor(_service: DebugService, _controller: DebugController);
+    step$(): import('rxjs').Observable<Omit<import('../timer/timer.service').TimerService, never> & {
+        type?: string;
+    }>;
+    init(props?: Parameters<DebugService["activate"]>[0]): void;
     axesHelper(): import('three').AxesHelper | undefined;
     cameraControls(): import('three/examples/jsm/controls/OrbitControls').OrbitControls | undefined;
     cameraHelper(): import('three').CameraHelper | undefined;
     enabled(value?: boolean): boolean;
     gridHelper(): import('three').GridHelper | undefined;
     miniCameraControls(): import('three/examples/jsm/controls/OrbitControls').OrbitControls | undefined;
-    enabled$(): import('rxjs').Observable<boolean>;
+    dispose(): void;
 }

package/dist/core/app/debug/{debug.component.d.ts → debug.service.d.ts}

@@ -1,28 +1,28 @@
 import { AxesHelper, CameraHelper, GridHelper } from 'three';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
-import { CameraComponent } from '../camera/camera.component';
-import { AppComponent } from '../app.component';
-import { WorldComponent } from '../world/world.component';
-export declare class DebugComponent {
-    private readonly appComponent;
-    private readonly cameraComponent;
-    private readonly worldComponent;
+import { CameraService } from '../camera/camera.service';
+import { AppService } from '../app.service';
+import { WorldService } from '../world/world.service';
+export declare class DebugService {
+    private readonly _appService;
+    private readonly _cameraService;
+    private readonly _worldService;
     enabled: boolean;
     cameraControls?: OrbitControls;
     miniCameraControls?: OrbitControls;
     cameraHelper?: CameraHelper;
     axesHelper?: AxesHelper;
     gridHelper?: GridHelper;
-    constructor(appComponent: AppComponent, cameraComponent: CameraComponent, worldComponent: WorldComponent);
+    constructor(_appService: AppService, _cameraService: CameraService, _worldService: WorldService);
     private _setCameraOrbitControl;
     private _setMiniCameraOrbitControls;
     private _setCameraHelper;
     private _setAxesHelper;
     private _setGridHelper;
-    init(props?: {
+    activate(props?: {
         axesSizes?: number;
         gridSizes?: number;
     }): void;
     update(): void;
-    dispose(): void;
+    deactivate(): void;
 }

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

@@ -1,15 +1,13 @@
-import { Observable, Subject } from 'rxjs';
-import { ProxyEvent, StepPayload } from 'common';
+import { Observable } from 'rxjs';
+import { ProxyEvent } from '../../../common/interfaces/event.interface';
 import { SizesController } from '../sizes/sizes.controller';
 import { TimerController } from '../timer/timer.controller';
-import { RendererComponent } from './renderer.component';
+import { RendererService } from './renderer.service';
 export declare class RendererController {
-    private readonly rendererComponent;
+    private readonly _service;
     private readonly timerController;
     private readonly sizesController;
-    readonly enable$$: Subject<boolean>;
-    readonly enable$: Observable<boolean>;
-    readonly step$: Observable<StepPayload>;
+    readonly step$: TimerController["step$"];
     readonly resize$: Observable<UIEvent & ProxyEvent>;
-    constructor(rendererComponent: RendererComponent, timerController: TimerController, sizesController: SizesController);
+    constructor(_service: RendererService, timerController: TimerController, sizesController: SizesController);
 }

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

@@ -1,17 +1,15 @@
 import { Vector2Like } from 'three';
-import { RendererComponent } from './renderer.component';
+import { Module, OffscreenCanvasWithStyle } from '../../../common/interfaces';
+import { RendererService } from './renderer.service';
 import { RendererController } from './renderer.controller';
-import { Module } from '../../../common/interfaces/module.interface';
-import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
 export declare class RendererModule implements Module {
-    private readonly component;
-    private readonly controller;
-    constructor(component: RendererComponent, controller: RendererController);
+    private readonly _controller;
+    private readonly _service;
+    constructor(_controller: RendererController, _service: RendererService);
     init(canvas: OffscreenCanvasWithStyle): void;
-    dispose(): void;
     enabled(value?: boolean): boolean;
     instance(): import('three').WebGLRenderer | undefined;
     setSize(value: Vector2Like): void;
     render(): void;
-    enabled$(): import('rxjs').Observable<boolean>;
+    dispose(): void;
 }

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

@@ -0,0 +1,19 @@
+import { WebGLRenderer } from 'three';
+import { OffscreenCanvasWithStyle } from '../../../common/interfaces';
+import { WorldService } from '../world/world.service';
+import { CameraService } from '../camera/camera.service';
+import { SizesService } from '../sizes/sizes.service';
+import { DebugService } from '../debug/debug.service';
+export declare class RendererService {
+    private readonly _worldService;
+    private readonly _cameraService;
+    private readonly _sizesService;
+    private readonly _debugComponent;
+    static readonly RENDERER_PIXEL_RATIO: number;
+    enabled: boolean;
+    instance?: WebGLRenderer;
+    constructor(_worldService: WorldService, _cameraService: CameraService, _sizesService: SizesService, _debugComponent: DebugService);
+    setWebGLRenderer(canvas: OffscreenCanvasWithStyle): void;
+    setSize(width: number, height: number): void;
+    render(): void;
+}

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

@@ -1,12 +1,10 @@
-import { Observable, Subject } from 'rxjs';
+import { Observable } from 'rxjs';
 import { ProxyEvent } from 'common';
 import { AppController } from '../app.controller';
-import { SizesComponent } from './sizes.component';
+import { SizesService } from './sizes.service';
 export declare class SizesController {
-    private readonly appController;
-    private readonly component;
-    readonly enable$$: Subject<boolean>;
-    readonly enable$: Observable<boolean>;
+    private readonly _appController;
+    private readonly _service;
     readonly resize$: Observable<UIEvent & ProxyEvent>;
-    constructor(appController: AppController, component: SizesComponent);
+    constructor(_appController: AppController, _service: SizesService);
 }

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

@@ -1,11 +1,11 @@
-import { SizesComponent } from './sizes.component';
+import { SizesService } from './sizes.service';
 import { SizesController } from './sizes.controller';
 import { Module } from '../../../common/interfaces/module.interface';
 import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
 export declare class SizesModule implements Module {
-    private readonly component;
-    private readonly controller;
-    constructor(component: SizesComponent, controller: SizesController);
+    private readonly _controller;
+    private readonly _service;
+    constructor(_controller: SizesController, _service: SizesService);
     init(canvas: OffscreenCanvasWithStyle): void;
     dispose(): void;
     aspect(value?: number): number;
@@ -14,6 +14,5 @@ export declare class SizesModule implements Module {
     height(value?: number): number;
     pixelRatio(value?: number): number;
     width(value?: number): number;
-    enabled$(): import('rxjs').Observable<boolean>;
     resize$(): import('rxjs').Observable<UIEvent & import('../../../common').ProxyEvent>;
 }

package/dist/core/app/sizes/{sizes.component.d.ts → sizes.service.d.ts}

@@ -1,5 +1,5 @@
 import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
-export declare class SizesComponent {
+export declare class SizesService {
     width: number;
     height: number;
     aspect: number;

package/dist/core/app/timer/timer.controller.d.ts

@@ -1,14 +1,20 @@
-import { Subject } from 'rxjs';
-import { TimerComponent } from './timer.component';
-import { StepPayload } from '../../../common/interfaces/event.interface';
-import { AppController } from '../app.controller';
+import { TimerService } from './timer.service';
 export declare class TimerController {
-    private readonly component;
-    private readonly appController;
-    readonly step$$: Subject<StepPayload>;
-    readonly enable$$: Subject<boolean>;
-    readonly step$: import('rxjs').Observable<StepPayload>;
-    readonly enable$: import('rxjs').Observable<boolean>;
-    constructor(component: TimerComponent, appController: AppController);
-    step(): void;
+    private readonly _service;
+    private readonly beforeStep$$;
+    private _previousTime;
+    readonly beforeStep$: import('rxjs').Observable<import('@quick-threejs/utils').NonNever<{
+        readonly frame: number;
+        readonly initialTime: number;
+        currentTime: number;
+        deltaTime: number;
+        deltaRatio: number;
+        elapsedTime: number;
+        enabled: boolean;
+        step: never;
+    }>>;
+    readonly step$: import('rxjs').Observable<Omit<TimerService, never> & {
+        type?: string;
+    }>;
+    constructor(_service: TimerService);
 }

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

@@ -1,19 +1,29 @@
-import { TimerComponent } from './timer.component';
-import { RendererComponent } from '../renderer/renderer.component';
+import { Module } from '../../../common/interfaces';
+import { TimerService } from './timer.service';
 import { TimerController } from './timer.controller';
-import { Module } from '../../../common/interfaces/module.interface';
 export declare class TimerModule implements Module {
-    private readonly component;
-    private readonly controller;
-    private readonly rendererComponent;
-    constructor(component: TimerComponent, controller: TimerController, rendererComponent: RendererComponent);
-    init(startTimer?: boolean): void;
-    clock(): import('three').Clock;
+    private readonly _controller;
+    private readonly _service;
+    private _initialAnimationFrameId?;
+    private _subscriptions;
+    constructor(_controller: TimerController, _service: TimerService);
+    init(enabled?: boolean): void;
     frame(): number;
-    delta(value?: number): number;
+    deltaTime(value?: number): number;
     deltaRatio(value?: number): number;
     enabled(value?: boolean): boolean;
     dispose(): void;
-    enabled$(): import('rxjs').Observable<boolean>;
-    step$(): import('rxjs').Observable<import('../../../common').StepPayload>;
+    beforeStep$(): import('rxjs').Observable<import('@quick-threejs/utils').NonNever<{
+        readonly frame: number;
+        readonly initialTime: number;
+        currentTime: number;
+        deltaTime: number;
+        deltaRatio: number;
+        elapsedTime: number;
+        enabled: boolean;
+        step: never;
+    }>>;
+    step$(): import('rxjs').Observable<Omit<TimerService, never> & {
+        type?: string;
+    }>;
 }

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

@@ -0,0 +1,10 @@
+export declare class TimerService {
+    readonly frame: number;
+    readonly initialTime: number;
+    currentTime: number;
+    deltaTime: number;
+    deltaRatio: number;
+    elapsedTime: number;
+    enabled: boolean;
+    step(): void;
+}

package/dist/core/app/world/world.controller.d.ts

@@ -1,5 +1,2 @@
-import { Subject } from 'rxjs';
 export declare class WorldController {
-    readonly enable$$: Subject<boolean>;
-    readonly enable$: import('rxjs').Observable<boolean>;
 }

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

@@ -1,14 +1,11 @@
 import { Scene } from 'three';
-import { WorldComponent } from './world.component';
-import { WorldController } from './world.controller';
+import { WorldService } from './world.service';
 import { Module } from '../../../common/interfaces/module.interface';
 export declare class WorldModule implements Module {
-    private readonly component;
-    private readonly controller;
-    constructor(component: WorldComponent, controller: WorldController);
+    private readonly _service;
+    constructor(_service: WorldService);
     init(): void;
     dispose(): void;
     scene(value?: Scene): Scene;
     enabled(value?: boolean): boolean;
-    get enable$(): import('rxjs').Observable<boolean>;
 }

package/dist/core/app/world/{world.component.d.ts → world.service.d.ts}

@@ -1,5 +1,5 @@
 import { Scene } from 'three';
-export declare class WorldComponent {
+export declare class WorldService {
     scene: Scene;
     enabled: boolean;
 }

package/dist/core/loader/loader.controller.d.ts

@@ -1,9 +1,7 @@
 import { Subject } from 'rxjs';
 import { ProgressedResource } from '../../common/interfaces/resource.interface';
 export declare class LoaderController {
-    readonly lifecycle$$: Subject<unknown>;
     readonly progress$$: Subject<ProgressedResource>;
     readonly progress$: import('rxjs').Observable<ProgressedResource>;
-    readonly lifecycle$: import('rxjs').Observable<unknown>;
     readonly progressCompleted$: import('rxjs').Observable<ProgressedResource>;
 }

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

@@ -27,7 +27,6 @@ export declare class LoaderModule implements Module, WorkerThreadModule {
     toLoad(): number;
     init(resources?: Resource[]): void;
     dispose(): void;
-    lifecycle$(): import('rxjs').Observable<unknown>;
     progress$(): import('rxjs').Observable<import('../../common/interfaces/resource.interface').ProgressedResource>;
     progressCompleted$(): import('rxjs').Observable<import('../../common/interfaces/resource.interface').ProgressedResource>;
 }

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

@@ -1,13 +1,9 @@
-import { Subject } from 'rxjs';
-import { RegisterComponent } from './register.component';
-import { RegisterLifecycleState } from '../../common/enums/lifecycle.enum';
+import { RegisterService } from './register.service';
 import { ProxyEventHandlersModel } from '../../common/models/proxy-event-handler.model';
 export declare class RegisterController extends ProxyEventHandlersModel {
-    private readonly component;
+    private readonly _service;
     private canvas;
-    readonly lifecycle$$: Subject<RegisterLifecycleState>;
-    readonly lifecycle$: import('rxjs').Observable<RegisterLifecycleState>;
-    constructor(component: RegisterComponent);
+    constructor(_service: RegisterService);
     init(canvas: HTMLCanvasElement): void;
     preventDefaultHandler(e: Event): {
         type: string;

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

@@ -1,23 +1,22 @@
-import { RegisterComponent } from './register.component';
-import { RegisterController } from './register.controller';
+import { DependencyContainer } from 'tsyringe';
+import { Module, ProgressedResource, Resource, RegisterPropsModel, RegisterProxyEventHandlersModel } from '../../common';
+import { ExposedAppModule } from '../app/app.module-worker';
 import { LoaderModule } from '../loader/loader.module';
 import { ExposedLoaderModule } from '../loader/loader.module-worker';
-import { ExposedAppModule } from '../app/app.module-worker';
-import { RegisterPropsModel } from '../../common/models/register-props.model';
-import { RegisterLifecycleState } from '../../common/enums/lifecycle.enum';
-import { RegisterProxyEventHandlersModel } from '../../common/models/register-proxy-event-handler.model';
-import { ProgressedResource, Resource } from '../../common/interfaces/resource.interface';
-import { Module } from '../../common/interfaces/module.interface';
+import { RegisterService } from './register.service';
+import { RegisterController } from './register.controller';
 export declare class RegisterModule extends RegisterProxyEventHandlersModel implements Module {
-    private readonly component;
-    private readonly controller;
-    private readonly registerProps;
-    constructor(component: RegisterComponent, controller: RegisterController, registerProps: RegisterPropsModel);
+    private readonly _container;
+    private readonly _service;
+    private readonly _controller;
+    readonly registerProps: RegisterPropsModel;
+    initialized: boolean;
+    constructor(_container: DependencyContainer, _service: RegisterService, _controller: RegisterController, registerProps: RegisterPropsModel);
     private _initCanvas;
     private _initComponent;
     private _initController;
     private _initWorkerThread;
-    private _initProxyEvents;
+    private _initObservableProxyEvents;
     init(): Promise<void>;
     loadResources(props: {
         resources: Resource[];
@@ -37,10 +36,8 @@ export declare class RegisterModule extends RegisterProxyEventHandlersModel impl
         thread?: import('threads').ModuleThread<ExposedLoaderModule> | undefined;
     }>;
     workerPool(): import('@quick-threejs/utils').WorkerPool;
-    canvas(): HTMLCanvasElement;
+    canvas(): HTMLCanvasElement | undefined;
     worker(): import('threads/dist/types/master').Worker | undefined;
     thread(): import('threads').ModuleThread<ExposedAppModule> | undefined;
-    gui(): import('three/examples/jsm/libs/lil-gui.module.min').default | undefined;
-    dispose(): void;
-    lifecycle$(): import('rxjs').Observable<RegisterLifecycleState>;
+    dispose(): Promise<void>;
 }

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

@@ -0,0 +1,9 @@
+import { WorkerThreadResolution } from '@quick-threejs/utils';
+import { ExposedAppModule } from '../app/app.module-worker';
+export declare class RegisterService {
+    readonly workerPool: import('@quick-threejs/utils').WorkerPool;
+    canvas?: HTMLCanvasElement;
+    worker?: WorkerThreadResolution<ExposedAppModule>["worker"];
+    thread?: WorkerThreadResolution<ExposedAppModule>["thread"];
+    init(app: WorkerThreadResolution<ExposedAppModule>): void;
+}

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

@@ -1,10 +1,13 @@
-import { RegisterPropsModel } from '../../common/models/register-props.model';
+import { ContainerizedApp } from '../../common/interfaces';
+import { RegisterPropsModel } from '../../common/models';
 import { RegisterModule } from './register.module';
 /**
- * @description Register the main logic of the app.
+ * @description
  *
- * @remark __🏁 Should be called on your main thread. Separated from the worker thread implementation__
+ * Register the main logic of the app.
  *
- * @param props Quick-three register properties.
+ * **🏁  This helper should be called from the main thread**
+ *
+ * @param props {@link RegisterPropsModel}.
  */
-export declare const register: (props: RegisterPropsModel) => RegisterModule;
+export declare const register: (props: RegisterPropsModel) => ContainerizedApp<RegisterModule>;