@quick-threejs/reactive 0.1.24 → 0.1.26

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/index.d.ts

@@ -1,4 +1,3 @@
 export * from './app/app.module';
-export * from './loader/loader.module';
 export * from './register/register.module';
 export * from './register/register.util';

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

@@ -0,0 +1,11 @@
+import { Observable, Subject } from 'rxjs';
+import { LoadedResourcePayload, SerializedLoadedResourcePayload } from '../../../common/interfaces/loader.interface';
+import { LoaderService } from './loader.service';
+export declare class LoaderController {
+    private readonly _service;
+    readonly load$$: Subject<Pick<LoadedResourcePayload, "resource" | "source">>;
+    readonly load$: Observable<LoadedResourcePayload>;
+    readonly serializedLoad$: Observable<SerializedLoadedResourcePayload>;
+    readonly loadCompleted$: Observable<LoadedResourcePayload>;
+    constructor(_service: LoaderService);
+}

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

@@ -0,0 +1,31 @@
+import { Module, LoaderSource, LoaderResource } from '../../../common/interfaces';
+import { LoaderController } from './loader.controller';
+import { LoaderService } from './loader.service';
+import { RegisterPropsBlueprint } from '../../../common/blueprints';
+export declare class LoaderModule implements Module {
+    private readonly _controller;
+    private readonly _service;
+    private readonly _props;
+    private readonly _subscriptions;
+    constructor(_controller: LoaderController, _service: LoaderService, _props: RegisterPropsBlueprint);
+    private _performLoad;
+    init(sources?: LoaderSource[]): void;
+    load(): void;
+    getLoadedResources(): Record<string, LoaderResource>;
+    getLoaders(): {
+        dracoLoader?: import('three/examples/jsm/loaders/DRACOLoader').DRACOLoader;
+        gltfLoader?: import('three/examples/jsm/loaders/GLTFLoader').GLTFLoader;
+        textureLoader?: import('three').ImageBitmapLoader;
+        cubeTextureLoader?: import('three').CubeTextureLoader;
+        audioLoader?: import('three').AudioLoader;
+        videoLoader?: LoaderService["videoLoader"];
+    };
+    getSources(): LoaderSource[];
+    getLoadedCount(): number;
+    getToLoadCount(): number;
+    getLoad$(): import('rxjs').Observable<import('../../../common/interfaces').LoadedResourcePayload>;
+    getLoadCompleted$(): import('rxjs').Observable<import('../../../common/interfaces').LoadedResourcePayload>;
+    setDracoDecoder(dracoDecoderPath: string): void;
+    dispose(): void;
+}
+export declare const loaderModule: LoaderModule;

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

@@ -0,0 +1,26 @@
+import { AudioLoader, CubeTextureLoader, ImageBitmapLoader, LoadingManager } from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { LoadedResourcePayload, LoaderResource, LoaderSource } from '../../../common/interfaces/loader.interface';
+export declare class LoaderService {
+    readonly loadingManager: LoadingManager;
+    readonly loaders: {
+        dracoLoader?: DRACOLoader;
+        gltfLoader?: GLTFLoader;
+        textureLoader?: ImageBitmapLoader;
+        cubeTextureLoader?: CubeTextureLoader;
+        audioLoader?: AudioLoader;
+        videoLoader?: LoaderService["videoLoader"];
+    };
+    sources: LoaderSource[];
+    loadedResources: Record<string, LoaderResource>;
+    toLoadCount: number;
+    loadedCount: number;
+    /** @description The video loader. based on {@link HTMLVideoElement}. */
+    private get videoLoader();
+    private _initLoaders;
+    _initSources(sources: LoaderSource[]): void;
+    init(sources?: LoaderSource[]): void;
+    setDracoDecoder(dracoDecoderPath?: string): void;
+    handleLoad({ source, resource, toLoadCount, loadedCount }: LoadedResourcePayload): void;
+}

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 { ProxyEventHandlersModel } from '../../common/models/proxy-event-handler.model';
-export declare class RegisterController extends ProxyEventHandlersModel {
-    private readonly component;
+import { RegisterService } from './register.service';
+import { ProxyEventHandlersBlueprint } from '../../common/blueprints/proxy.blueprint';
+export declare class RegisterController extends ProxyEventHandlersBlueprint {
+    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,46 +1,30 @@
-import { RegisterComponent } from './register.component';
+import { DependencyContainer } from 'tsyringe';
+import { Module, RegisterPropsBlueprint, RegisterProxyEventHandlersBlueprint } from '../../common';
+import { ExposedAppModule } from '../app/app.util';
+import { RegisterService } from './register.service';
 import { RegisterController } from './register.controller';
-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';
-export declare class RegisterModule extends RegisterProxyEventHandlersModel implements Module {
-    private readonly component;
-    private readonly controller;
-    private readonly registerProps;
-    constructor(component: RegisterComponent, controller: RegisterController, registerProps: RegisterPropsModel);
+import { LoaderModule } from './loader/loader.module';
+import { LoaderController } from './loader/loader.controller';
+export declare class RegisterModule extends RegisterProxyEventHandlersBlueprint implements Module {
+    private readonly _service;
+    private readonly _controller;
+    private readonly _loaderController;
+    readonly props: RegisterPropsBlueprint;
+    readonly loader: LoaderModule;
+    readonly container: DependencyContainer;
+    initialized: boolean;
+    constructor(_service: RegisterService, _controller: RegisterController, _loaderController: LoaderController, props: RegisterPropsBlueprint, loader: LoaderModule, container: DependencyContainer);
     private _initCanvas;
-    private _initComponent;
+    private _initService;
     private _initController;
     private _initWorkerThread;
-    private _initProxyEvents;
+    private _initObservableProxyEvents;
+    private _initLoader;
+    isInitialized(): boolean;
     init(): Promise<void>;
-    loadResources(props: {
-        resources: Resource[];
-        disposeOnComplete?: boolean;
-        onMainThread?: boolean;
-        immediateLoad?: boolean;
-        onProgress?: (resource: ProgressedResource) => unknown;
-        onProgressComplete?: (resource: ProgressedResource) => unknown;
-    }): Promise<{
-        load: LoaderModule["load"];
-        items: ReturnType<LoaderModule["items"]>;
-        loaders: ReturnType<LoaderModule["loaders"]>;
-        toLoad: ReturnType<LoaderModule["toLoad"]>;
-        loaded: ReturnType<LoaderModule["loaded"]>;
-        resources: ReturnType<LoaderModule["resources"]>;
-        worker?: import('threads').Worker;
-        thread?: import('threads').ModuleThread<ExposedLoaderModule> | undefined;
-    }>;
-    workerPool(): import('@quick-threejs/utils').WorkerPool;
-    canvas(): HTMLCanvasElement;
-    worker(): import('threads/dist/types/master').Worker | undefined;
+    canvas(): HTMLCanvasElement | 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>;
+    worker(): import('threads/dist/types/master').Worker | undefined;
+    workerPool(): import('@quick-threejs/utils').WorkerPool;
+    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.util';
+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 { RegisterPropsBlueprint } from '../../common/blueprints';
 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 RegisterPropsBlueprint}.
  */
-export declare const register: (props: RegisterPropsModel) => RegisterModule;
+export declare const register: (props: RegisterPropsBlueprint) => ContainerizedApp<RegisterModule>;