@quick-threejs/reactive 0.1.24 → 0.1.26

package/dist/common/blueprints/index.d.ts

@@ -0,0 +1,2 @@
+export * from './proxy.blueprint';
+export * from './props.blueprint';

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

@@ -0,0 +1,105 @@
+import { RegisterModule } from '../../core';
+import { DefaultCameraType } from '../enums';
+import { ContainerizedApp, Module, LoaderSource } from '../interfaces';
+/**
+ * @description {@link RegisterModule} initialization properties.
+ */
+export declare class RegisterPropsBlueprint {
+    /**
+     * @description The app worker logic location.
+     *
+     * @required
+     */
+    location: string;
+    /**
+     * @description Initialize the app on construct.
+     *
+     * @default true
+     */
+    initOnConstruct?: boolean;
+    /**
+     * @description App `canvas` element reference.
+     *
+     * @default undefined
+     */
+    canvas?: HTMLCanvasElement;
+    /**
+     * @description Set the `canvas` view in fullscreen and auto-resize it.
+     *
+     * @default true
+     */
+    fullScreen?: boolean;
+    /**
+     * Default used camera.
+     *
+     * @see {@link DefaultCameraType}
+     *
+     * @default DefaultCameraType.PERSPECTIVE
+     */
+    defaultCamera?: DefaultCameraType;
+    /**
+     * @description Start timer update on launch.
+     *
+     * @default true
+     */
+    startTimer?: boolean;
+    /**
+     * @description Resources to load.
+     *
+     * @default []
+     */
+    loaderDataSources?: LoaderSource[];
+    /**
+     * @description Will directly load the resources on initialization.
+     *
+     * @remark __This property depends on {@link RegisterPropsBlueprint.initOnConstruct initOnConstruct}__
+     *
+     * @default true
+     */
+    loadResourcesOnInit?: boolean;
+    /**
+     * @description Enable the debug mode
+     *
+     * @default undefined
+     */
+    enableDebug?: boolean;
+    /**
+     * Define the {@link THREE.AxesHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
+     *
+     * @default undefined
+     */
+    axesSizes?: number;
+    /**
+     * Define the {@link THREE.GridHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
+     *
+     * @default undefined
+     */
+    gridSizes?: number;
+    /**
+     * Display a mini perfective camera at the top right corner of the screen.
+     *
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
+     *
+     * @default false
+     */
+    withMiniCamera?: boolean;
+    /**
+     * @description Handler called when the app is ready.
+     *
+     * @default undefined
+     */
+    onReady?: (app: ContainerizedApp<RegisterModule>) => unknown;
+}
+/**
+ * @description {@link AppModule} initialization properties.
+ */
+export declare class LaunchAppProps<M extends Module> {
+    /** @description Handler triggered when the app is ready. */
+    onReady?: (workerApp: ContainerizedApp<M>) => unknown;
+}

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

@@ -0,0 +1,96 @@
+import { Observable, Subject } from 'rxjs';
+import { ProxyEvent, ProxyEventHandlersImplementation, ProxyEventObservablesImplementation, ProxyEventSubjectsImplementation } from '../interfaces/proxy-event.interface';
+export declare class ProxyEventSubjectsBlueprint implements ProxyEventSubjectsImplementation {
+    contextmenu$$: Subject<MouseEvent & ProxyEvent>;
+    resize$$: Subject<UIEvent & ProxyEvent>;
+    mousedown$$: Subject<PointerEvent & ProxyEvent>;
+    mousemove$$: Subject<PointerEvent & ProxyEvent>;
+    mouseup$$: Subject<PointerEvent & ProxyEvent>;
+    pointerdown$$: Subject<PointerEvent & ProxyEvent>;
+    pointermove$$: Subject<PointerEvent & ProxyEvent>;
+    pointercancel$$: Subject<PointerEvent & ProxyEvent>;
+    pointerup$$: Subject<PointerEvent & ProxyEvent>;
+    touchstart$$: Subject<TouchEvent & ProxyEvent>;
+    touchmove$$: Subject<TouchEvent & ProxyEvent>;
+    touchend$$: Subject<TouchEvent & ProxyEvent>;
+    wheel$$: Subject<WheelEvent & ProxyEvent>;
+    keydown$$: Subject<KeyboardEvent & ProxyEvent>;
+}
+export declare class ProxyEventObservablesBlueprint extends ProxyEventSubjectsBlueprint implements ProxyEventObservablesImplementation {
+    contextmenu$: Observable<MouseEvent & ProxyEvent>;
+    resize$: Observable<UIEvent & ProxyEvent>;
+    mousedown$: Observable<PointerEvent & ProxyEvent>;
+    mousemove$: Observable<PointerEvent & ProxyEvent>;
+    mouseup$: Observable<PointerEvent & ProxyEvent>;
+    pointerdown$: Observable<PointerEvent & ProxyEvent>;
+    pointermove$: Observable<PointerEvent & ProxyEvent>;
+    pointercancel$: Observable<PointerEvent & ProxyEvent>;
+    pointerup$: Observable<PointerEvent & ProxyEvent>;
+    touchstart$: Observable<TouchEvent & ProxyEvent>;
+    touchmove$: Observable<TouchEvent & ProxyEvent>;
+    touchend$: Observable<TouchEvent & ProxyEvent>;
+    wheel$: Observable<WheelEvent & ProxyEvent>;
+    keydown$: Observable<KeyboardEvent & ProxyEvent>;
+}
+export declare class ProxyEventHandlersBlueprint extends ProxyEventObservablesBlueprint implements ProxyEventHandlersImplementation {
+    contextmenu: (e: MouseEvent & ProxyEvent) => void;
+    resize: (e: UIEvent & ProxyEvent) => void;
+    mousedown: (e: PointerEvent & ProxyEvent) => void;
+    mousemove: (e: PointerEvent & ProxyEvent) => void;
+    mouseup: (e: PointerEvent & ProxyEvent) => void;
+    pointerdown: (e: PointerEvent & ProxyEvent) => void;
+    pointermove: (e: PointerEvent & ProxyEvent) => void;
+    pointercancel: (e: PointerEvent & ProxyEvent) => void;
+    pointerup: (e: PointerEvent & ProxyEvent) => void;
+    touchstart: (e: TouchEvent & ProxyEvent) => void;
+    touchmove: (e: TouchEvent & ProxyEvent) => void;
+    touchend: (e: TouchEvent & ProxyEvent) => void;
+    wheel: (e: WheelEvent & ProxyEvent) => void;
+    keydown: (e: KeyboardEvent & ProxyEvent) => void;
+}
+export declare class AppProxyEventHandlersBlueprint {
+    contextmenu$?: () => Observable<MouseEvent & ProxyEvent>;
+    resize$?: () => Observable<UIEvent & ProxyEvent>;
+    mousedown$?: () => Observable<PointerEvent & ProxyEvent>;
+    mousemove$?: () => Observable<PointerEvent & ProxyEvent>;
+    mouseup$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointerdown$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointermove$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointercancel$?: () => Observable<PointerEvent & ProxyEvent>;
+    pointerup$?: () => Observable<PointerEvent & ProxyEvent>;
+    touchstart$?: () => Observable<TouchEvent & ProxyEvent>;
+    touchmove$?: () => Observable<TouchEvent & ProxyEvent>;
+    touchend$?: () => Observable<TouchEvent & ProxyEvent>;
+    wheel$?: () => Observable<WheelEvent & ProxyEvent>;
+    keydown$?: () => Observable<KeyboardEvent & ProxyEvent>;
+    contextmenu: (e: MouseEvent & ProxyEvent) => void;
+    resize: (e: UIEvent & ProxyEvent) => void;
+    mousedown: (e: PointerEvent & ProxyEvent) => void;
+    mousemove: (e: PointerEvent & ProxyEvent) => void;
+    mouseup: (e: PointerEvent & ProxyEvent) => void;
+    pointerdown: (e: PointerEvent & ProxyEvent) => void;
+    pointermove: (e: PointerEvent & ProxyEvent) => void;
+    pointercancel: (e: PointerEvent & ProxyEvent) => void;
+    pointerup: (e: PointerEvent & ProxyEvent) => void;
+    touchstart: (e: TouchEvent & ProxyEvent) => void;
+    touchmove: (e: TouchEvent & ProxyEvent) => void;
+    touchend: (e: TouchEvent & ProxyEvent) => void;
+    wheel: (e: WheelEvent & ProxyEvent) => void;
+    keydown: (e: KeyboardEvent & ProxyEvent) => void;
+}
+export declare class RegisterProxyEventHandlersBlueprint {
+    contextmenu$?: () => Observable<Event>;
+    resize$?: () => Observable<Event>;
+    mousedown$?: () => Observable<Event>;
+    mousemove$?: () => Observable<Event>;
+    mouseup$?: () => Observable<Event>;
+    pointerdown$?: () => Observable<Event>;
+    pointermove$?: () => Observable<Event>;
+    pointercancel$?: () => Observable<Event>;
+    pointerup$?: () => Observable<Event>;
+    touchstart$?: () => Observable<Event>;
+    touchmove$?: () => Observable<Event>;
+    touchend$?: () => Observable<Event>;
+    wheel$?: () => Observable<Event>;
+    keydown$?: () => Observable<Event>;
+}

package/dist/common/enums/index.d.ts

@@ -1,2 +1 @@
 export * from './camera.enum';
-export * from './lifecycle.enum';

package/dist/common/index.d.ts

@@ -1,5 +1,5 @@
 export * from './constants';
 export * from './enums';
 export * from './interfaces';
-export * from './models';
-export * from './types';
+export * from './blueprints';
+export * from './tokens';

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

@@ -1,11 +1,10 @@
-import { RegisterPropsModel } from '../models/register-props.model';
-export interface CoreModuleMessageEventData extends Omit<RegisterPropsModel, "canvas" | "location"> {
+import { RegisterPropsBlueprint } from '../blueprints/props.blueprint';
+export interface AppModulePropsMessageEvent extends MessageEvent<Omit<RegisterPropsBlueprint, "canvas" | "location" | "loaderDataSources"> & {
     /**
      * The canvas element based on.
      *
-     * @defaultValue `undefined`
+     * @default `undefined`
      */
     canvas?: OffscreenCanvas;
-}
-export interface CoreModuleMessageEvent extends MessageEvent<CoreModuleMessageEventData> {
+}> {
 }

package/dist/common/interfaces/index.d.ts

@@ -1,5 +1,5 @@
 export * from './canvas.interface';
 export * from './core.interface';
-export * from './event.interface';
 export * from './module.interface';
-export * from './resource.interface';
+export * from './proxy-event.interface';
+export * from './loader.interface';

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

@@ -0,0 +1,23 @@
+import { JsonSerializable } from 'threads';
+import { CubeTextureLoader, Texture, VideoTexture } from 'three';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+/** @description The sources of the {@link LoaderResource resources} to load. */
+export interface LoaderSource {
+    name: string;
+    type: "cubeTexture" | "texture" | "gltfModel" | "video" | "audio";
+    path: string | string[];
+}
+/** @description Supported loadable resource. */
+export type LoaderResource = GLTF | Texture | CubeTextureLoader | VideoTexture | AudioBuffer;
+/** @description Represent a loaded resource. */
+export interface LoadedResourcePayload {
+    source: LoaderSource;
+    resource?: LoaderResource;
+    /** @description The number of loaded resources. */
+    loadedCount: number;
+    /** @description The number of resources to load. */
+    toLoadCount: number;
+}
+export interface SerializedLoadedResourcePayload extends Omit<LoadedResourcePayload, "resource"> {
+    resource?: JsonSerializable;
+}

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

@@ -1,13 +1,14 @@
+import { DependencyContainer, Disposable } from 'tsyringe';
 /**
  * @description Module representation.
  *
  * @important Each module should `implement` this interface.
  */
-export interface Module {
+export interface Module extends Disposable {
     /**
      * @description Module initializer method.
      *
-     * Can be used for direct initialization (when constructing `quick-three`) or manual (later in the code).
+     * Can be used for on-launch initialization (when the app is constructed) if the {@link RegisterPropsBlueprint.initOnConstruct initOnConstruct} param is `true` or manually later in the code.
      */
     init(...props: any[]): void;
     /**
@@ -17,3 +18,10 @@ export interface Module {
      */
     dispose(): void;
 }
+/**
+ * @description Containerized App representation.
+ */
+export interface ContainerizedApp<M extends Module = Module> {
+    container: DependencyContainer;
+    module: M;
+}

package/dist/common/{types/object.type.d.ts → interfaces/proxy-event.interface.d.ts}

@@ -1,5 +1,11 @@
 import { Observable, Subject } from 'rxjs';
 import { PROXY_EVENT_LISTENERS } from '../constants/event.constants';
+export interface ProxyEvent {
+    width: number;
+    height: number;
+    windowWidth: number;
+    windowHeight: number;
+}
 /** @description  */
 export type ProxyEventListenerKeys = (typeof PROXY_EVENT_LISTENERS)[number];
 export type ProxyEventHandlersImplementation = {

package/dist/common/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ioc.token';
+export * from './loader.token';

package/dist/common/tokens/ioc.token.d.ts

@@ -0,0 +1 @@
+export declare const CONTAINER_TOKEN = "CONTAINER";

package/dist/common/tokens/loader.token.d.ts

@@ -0,0 +1 @@
+export declare const LOADER_SERIALIZED_LOAD_TOKEN = "LOADER_SERIALIZED_LOAD";

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

@@ -1,10 +1,6 @@
-import { Observable, Subject } from 'rxjs';
-import { AppComponent } from './app.component';
-import { ProxyEventHandlersModel } from '../../common/models/proxy-event-handler.model';
-import { AppLifecycleState } from '../../common/enums/lifecycle.enum';
-export declare class AppController extends ProxyEventHandlersModel {
-    private readonly component;
-    readonly lifecycle$$: Subject<AppLifecycleState>;
-    readonly lifecycle$: Observable<AppLifecycleState>;
-    constructor(component: AppComponent);
+import { AppService } from './app.service';
+import { ProxyEventHandlersBlueprint } from '../../common/blueprints/proxy.blueprint';
+export declare class AppController extends ProxyEventHandlersBlueprint {
+    private readonly _service;
+    constructor(_service: AppService);
 }

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

@@ -1,35 +1,41 @@
 import { WorkerThreadModule } from '@quick-threejs/utils';
+import { Observable } from 'rxjs';
+import { AppModulePropsMessageEvent, Module, AppProxyEventHandlersBlueprint } from '../../common';
 import { AppController } from './app.controller';
-import { AppComponent } from './app.component';
+import { AppService } from './app.service';
 import { TimerModule } from './timer/timer.module';
 import { CameraModule } from './camera/camera.module';
 import { RendererModule } from './renderer/renderer.module';
 import { SizesModule } from './sizes/sizes.module';
 import { WorldModule } from './world/world.module';
 import { DebugModule } from './debug/debug.module';
-import { AppLifecycleState } from '../../common/enums/lifecycle.enum';
-import { AppProxyEventHandlersModel } from '../../common/models/app-proxy-event-handler.model';
-import { Module } from '../../common/interfaces/module.interface';
-import { OffscreenCanvasWithStyle } from '../../common/interfaces/canvas.interface';
-import { CoreModuleMessageEventData } from '../../common/interfaces/core.interface';
-import { Observable } from 'rxjs';
-export declare class AppModule extends AppProxyEventHandlersModel implements Module, WorkerThreadModule {
-    private readonly controller;
-    private readonly component;
+import { LoaderModule } from './loader/loader.module';
+export declare class AppModule extends AppProxyEventHandlersBlueprint implements Module, WorkerThreadModule {
+    private readonly _controller;
+    private readonly _service;
     readonly timer: TimerModule;
     readonly sizes: SizesModule;
     readonly camera: CameraModule;
     readonly world: WorldModule;
     readonly renderer: RendererModule;
+    readonly loader: LoaderModule;
     readonly debug: DebugModule;
-    constructor(controller: AppController, component: AppComponent, timer: TimerModule, sizes: SizesModule, camera: CameraModule, world: WorldModule, renderer: RendererModule, debug: DebugModule);
+    constructor(_controller: AppController, _service: AppService, timer: TimerModule, sizes: SizesModule, camera: CameraModule, world: WorldModule, renderer: RendererModule, loader: LoaderModule, debug: DebugModule);
     private _initProxyEvents;
-    private _onMessage;
-    init(props: CoreModuleMessageEventData): void;
-    get canvas(): OffscreenCanvasWithStyle | undefined;
-    get initialized(): boolean;
+    init(props: AppModulePropsMessageEvent["data"]): void;
     isInitialized(): boolean;
+    beforeStep$(): 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$(): Observable<Omit<import('./timer/timer.service').TimerService, never> & {
+        type?: string;
+    }>;
     dispose(): void;
-    lifecycle$(): Observable<AppLifecycleState>;
 }
-export declare const appModule: AppModule;

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

@@ -1,7 +1,9 @@
 import { ProxyReceiver } from '@quick-threejs/utils';
-import { OffscreenCanvasWithStyle } from '../../common/interfaces/canvas.interface';
-export declare class AppComponent {
+import { OffscreenCanvasWithStyle } from '../../common/interfaces';
+export declare class AppService {
+    private _canvas?;
     readonly proxyReceiver: ProxyReceiver<Record<string, unknown>>;
     initialized: boolean;
-    canvas?: OffscreenCanvasWithStyle;
+    get canvas(): OffscreenCanvasWithStyle | undefined;
+    set canvas(canvas: OffscreenCanvasWithStyle | OffscreenCanvas);
 }

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

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

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

@@ -1,12 +1,8 @@
-import { Observable, Subject } from 'rxjs';
-import { CameraComponent } from './camera.component';
+import { CameraService } from './camera.service';
 import { TimerController } from '../timer/timer.controller';
-import { StepPayload } from '../../../common/interfaces/event.interface';
 export declare class CameraController {
-    private readonly component;
     private readonly timerController;
-    readonly enable$$: Subject<boolean>;
-    readonly enable$: Observable<boolean>;
-    readonly step$: Observable<StepPayload>;
-    constructor(component: CameraComponent, timerController: TimerController);
+    private readonly _service;
+    readonly step$: TimerController["step$"];
+    constructor(timerController: TimerController, _service: CameraService);
 }

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

@@ -0,0 +1,5 @@
+import { LoadedResourcePayload } from '../../../common';
+export declare class LoaderController {
+    readonly load$: import('rxjs').Observable<LoadedResourcePayload>;
+    readonly loadCompleted$: import('rxjs').Observable<LoadedResourcePayload>;
+}

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

@@ -0,0 +1,16 @@
+import { Module } from '../../../common/interfaces';
+import { LoaderController } from './loader.controller';
+import { LoaderService } from './loader.service';
+export declare class LoaderModule implements Module {
+    private readonly _controller;
+    private readonly _service;
+    private readonly _subscriptions;
+    constructor(_controller: LoaderController, _service: LoaderService);
+    init(): void;
+    getLoadedResources(): Record<string, import('../../../common/interfaces').LoaderResource>;
+    getLoadedCount(): number;
+    getToLoadCount(): number;
+    getLoad$(): import('rxjs').Observable<import('../../../common/interfaces').LoadedResourcePayload>;
+    getLoadCompleted$(): import('rxjs').Observable<import('../../../common/interfaces').LoadedResourcePayload>;
+    dispose(): void;
+}

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

@@ -0,0 +1,8 @@
+import { LoadedResourcePayload, LoaderResource } from '../../../common/interfaces';
+import { LoaderService as RegisterLoaderService } from '../../register/loader/loader.service';
+export declare class LoaderService implements Pick<RegisterLoaderService, "toLoadCount" | "loadedCount" | "loadedResources"> {
+    loadedResources: Record<string, LoaderResource>;
+    toLoadCount: number;
+    loadedCount: number;
+    handleLoad(payload: LoadedResourcePayload): 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/proxy-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);
 }