@quick-threejs/reactive 0.1.25 → 0.1.27

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

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

package/dist/common/{models/register-props.model.d.ts → blueprints/props.blueprint.d.ts}

@@ -1,8 +1,10 @@
-import { ContainerizedApp } from '../interfaces';
-import { DefaultCameraType } from '../enums/camera.enum';
 import { RegisterModule } from '../../core';
-/** @description Quick-three register properties. */
-export declare class RegisterPropsModel {
+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.
      *
@@ -42,7 +44,21 @@ export declare class RegisterPropsModel {
      */
     startTimer?: boolean;
     /**
-     * Enable the debug mode
+     * @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
      */
@@ -51,7 +67,7 @@ export declare class RegisterPropsModel {
      * Define the {@link THREE.AxesHelper} sizes.
      *
      * @remark __Deactivated if the value is `0` or `undefined`__
-     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
      *
      * @default undefined
      */
@@ -60,7 +76,7 @@ export declare class RegisterPropsModel {
      * Define the {@link THREE.GridHelper} sizes.
      *
      * @remark __Deactivated if the value is `0` or `undefined`__
-     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
      *
      * @default undefined
      */
@@ -68,7 +84,7 @@ export declare class RegisterPropsModel {
     /**
      * Display a mini perfective camera at the top right corner of the screen.
      *
-     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     * @remark __This property depends on {@link RegisterPropsBlueprint.enableDebug enableDebug}__
      *
      * @default false
      */
@@ -80,3 +96,10 @@ export declare class RegisterPropsModel {
      */
     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/index.d.ts

@@ -1,5 +1,5 @@
 export * from './constants';
 export * from './enums';
 export * from './interfaces';
-export * from './models';
+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,6 +1,5 @@
 export * from './canvas.interface';
 export * from './core.interface';
-export * from './event.interface';
 export * from './module.interface';
-export * from './object.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

@@ -8,7 +8,7 @@ export interface Module extends Disposable {
     /**
      * @description Module initializer method.
      *
-     * Can be used for on-launch initialization (when the app is constructed) if the {@link RegisterPropsModel.initOnConstruct initOnConstruct} param is `true` or manually 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;
     /**

package/dist/common/interfaces/{object.interface.d.ts → 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

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

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,6 +1,6 @@
 import { AppService } from './app.service';
-import { ProxyEventHandlersModel } from '../../common/models/proxy-event-handler.model';
-export declare class AppController extends ProxyEventHandlersModel {
+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,6 +1,6 @@
 import { WorkerThreadModule } from '@quick-threejs/utils';
 import { Observable } from 'rxjs';
-import { CoreModuleMessageEventData, Module, AppProxyEventHandlersModel } from '../../common';
+import { AppModulePropsMessageEvent, Module, AppProxyEventHandlersBlueprint } from '../../common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { TimerModule } from './timer/timer.module';
@@ -9,7 +9,8 @@ import { RendererModule } from './renderer/renderer.module';
 import { SizesModule } from './sizes/sizes.module';
 import { WorldModule } from './world/world.module';
 import { DebugModule } from './debug/debug.module';
-export declare class AppModule extends AppProxyEventHandlersModel implements Module, WorkerThreadModule {
+import { LoaderModule } from './loader/loader.module';
+export declare class AppModule extends AppProxyEventHandlersBlueprint implements Module, WorkerThreadModule {
     private readonly _controller;
     private readonly _service;
     readonly timer: TimerModule;
@@ -17,10 +18,11 @@ export declare class AppModule extends AppProxyEventHandlersModel implements Mod
     readonly camera: CameraModule;
     readonly world: WorldModule;
     readonly renderer: RendererModule;
+    readonly loader: LoaderModule;
     readonly debug: DebugModule;
-    constructor(_controller: AppController, _service: AppService, 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;
-    init(props: CoreModuleMessageEventData): void;
+    init(props: AppModulePropsMessageEvent["data"]): void;
     isInitialized(): boolean;
     beforeStep$(): Observable<import('@quick-threejs/utils').NonNever<{
         readonly frame: number;

package/dist/core/app/{app.module-worker.d.ts → app.util.d.ts}

@@ -1,6 +1,6 @@
 import { ExposedWorkerThreadModule, Methods } from '@quick-threejs/utils';
 import { ProxyEventListenerKeys, ContainerizedApp } from '../../common';
-import { LaunchAppProps } from '../../common/models';
+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/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,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { ProxyEvent } from '../../../common/interfaces/event.interface';
+import { ProxyEvent } from '../../../common/interfaces/proxy-event.interface';
 import { SizesController } from '../sizes/sizes.controller';
 import { TimerController } from '../timer/timer.controller';
 import { RendererService } from './renderer.service';

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,6 +1,6 @@
 import { RegisterService } from './register.service';
-import { ProxyEventHandlersModel } from '../../common/models/proxy-event-handler.model';
-export declare class RegisterController extends ProxyEventHandlersModel {
+import { ProxyEventHandlersBlueprint } from '../../common/blueprints/proxy.blueprint';
+export declare class RegisterController extends ProxyEventHandlersBlueprint {
     private readonly _service;
     private canvas;
     constructor(_service: RegisterService);

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

@@ -1,43 +1,30 @@
 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 { Module, RegisterPropsBlueprint, RegisterProxyEventHandlersBlueprint } from '../../common';
+import { ExposedAppModule } from '../app/app.util';
 import { RegisterService } from './register.service';
 import { RegisterController } from './register.controller';
-export declare class RegisterModule extends RegisterProxyEventHandlersModel implements Module {
-    private readonly _container;
+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;
-    readonly registerProps: RegisterPropsModel;
+    private readonly _loaderController;
+    readonly props: RegisterPropsBlueprint;
+    readonly loader: LoaderModule;
+    readonly container: DependencyContainer;
     initialized: boolean;
-    constructor(_container: DependencyContainer, _service: RegisterService, _controller: RegisterController, registerProps: RegisterPropsModel);
+    constructor(_service: RegisterService, _controller: RegisterController, _loaderController: LoaderController, props: RegisterPropsBlueprint, loader: LoaderModule, container: DependencyContainer);
     private _initCanvas;
-    private _initComponent;
+    private _initService;
     private _initController;
     private _initWorkerThread;
     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 | undefined;
-    worker(): import('threads/dist/types/master').Worker | undefined;
     thread(): import('threads').ModuleThread<ExposedAppModule> | undefined;
+    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

@@ -1,5 +1,5 @@
 import { WorkerThreadResolution } from '@quick-threejs/utils';
-import { ExposedAppModule } from '../app/app.module-worker';
+import { ExposedAppModule } from '../app/app.util';
 export declare class RegisterService {
     readonly workerPool: import('@quick-threejs/utils').WorkerPool;
     canvas?: HTMLCanvasElement;

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

@@ -1,5 +1,5 @@
 import { ContainerizedApp } from '../../common/interfaces';
-import { RegisterPropsModel } from '../../common/models';
+import { RegisterPropsBlueprint } from '../../common/blueprints';
 import { RegisterModule } from './register.module';
 /**
  * @description
@@ -8,6 +8,6 @@ import { RegisterModule } from './register.module';
  *
  * **🏁  This helper should be called from the main thread**
  *
- * @param props {@link RegisterPropsModel}.
+ * @param props {@link RegisterPropsBlueprint}.
  */
-export declare const register: (props: RegisterPropsModel) => ContainerizedApp<RegisterModule>;
+export declare const register: (props: RegisterPropsBlueprint) => ContainerizedApp<RegisterModule>;