@quick-threejs/reactive 0.1.20 → 0.1.22

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

@@ -0,0 +1,19 @@
+import { TimerComponent } from './timer.component';
+import { RendererComponent } from '../renderer/renderer.component';
+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;
+    frame(): number;
+    delta(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>;
+}

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

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

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

@@ -0,0 +1,5 @@
+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

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

package/dist/core/index.d.ts

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

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

@@ -0,0 +1,25 @@
+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 { LoadedResourceItem, Resource } from '../../common/interfaces/resource.interface';
+export declare class LoaderComponent {
+    readonly loadingManager: LoadingManager;
+    readonly loaders: {
+        dracoLoader?: DRACOLoader;
+        gltfLoader?: GLTFLoader;
+        textureLoader?: ImageBitmapLoader;
+        cubeTextureLoader?: CubeTextureLoader;
+        audioLoader?: AudioLoader;
+        videoLoader?: LoaderComponent["videoLoader"];
+    };
+    resources: Resource[];
+    items: {
+        [name: Resource["name"]]: LoadedResourceItem;
+    };
+    toLoad: number;
+    loaded: number;
+    private get videoLoader();
+    private _setLoaders;
+    setResources(resources: Resource[]): void;
+    init(resources?: Resource[]): void;
+}

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

@@ -0,0 +1,9 @@
+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-worker.d.ts

@@ -0,0 +1,3 @@
+import { ExposedWorkerThreadModule } from '@quick-threejs/utils';
+import { LoaderModule } from './loader.module';
+export type ExposedLoaderModule = ExposedWorkerThreadModule<LoaderModule>;

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

@@ -0,0 +1,34 @@
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { WorkerThreadModule } from '@quick-threejs/utils';
+import { LoaderController } from './loader.controller';
+import { LoaderComponent } from './loader.component';
+import { Module } from '../../common/interfaces/module.interface';
+import { LoadedResourceItem, Resource } from '../../common/interfaces/resource.interface';
+export declare class LoaderModule implements Module, WorkerThreadModule {
+    private readonly controller;
+    private readonly component;
+    constructor(controller: LoaderController, component: LoaderComponent);
+    private _handleLoadedResource;
+    setDracoLoader(dracoDecoderPath: string, linkWithGltfLoader?: boolean): void;
+    load(): void;
+    items(): {
+        [name: string]: LoadedResourceItem;
+    };
+    loaders(): {
+        dracoLoader?: DRACOLoader;
+        gltfLoader?: import('three/examples/jsm/loaders/GLTFLoader').GLTFLoader;
+        textureLoader?: import('three').ImageBitmapLoader;
+        cubeTextureLoader?: import('three').CubeTextureLoader;
+        audioLoader?: import('three').AudioLoader;
+        videoLoader?: LoaderComponent["videoLoader"];
+    };
+    resources(): Resource[];
+    loaded(): number;
+    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>;
+}
+export declare const loaderModule: LoaderModule;

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

@@ -0,0 +1,13 @@
+import { WorkerThreadResolution } from '@quick-threejs/utils';
+import { default as GUI } from 'three/examples/jsm/libs/lil-gui.module.min.js';
+import { default as Stats } from 'stats.js';
+import { ExposedAppModule } from '../app/app.module-worker';
+export declare class RegisterComponent {
+    readonly workerPool: import('@quick-threejs/utils').WorkerPool;
+    canvas: HTMLCanvasElement;
+    worker: WorkerThreadResolution<ExposedAppModule>["worker"];
+    thread: WorkerThreadResolution<ExposedAppModule>["thread"];
+    gui?: GUI;
+    stats?: Stats;
+    init(app: WorkerThreadResolution<ExposedAppModule>): void;
+}

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

@@ -0,0 +1,77 @@
+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;
+    private canvas;
+    readonly lifecycle$$: Subject<RegisterLifecycleState>;
+    readonly lifecycle$: import('rxjs').Observable<RegisterLifecycleState>;
+    constructor(component: RegisterComponent);
+    init(canvas: HTMLCanvasElement): void;
+    preventDefaultHandler(e: Event): {
+        type: string;
+    };
+    getScreenSizes(): {
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    uiEventHandler(e: UIEvent): {
+        type: string;
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    mouseEventHandler(e: PointerEvent): {
+        button: number;
+        clientX: number;
+        clientY: number;
+        ctrlKey: boolean;
+        metaKey: boolean;
+        pageX: number;
+        pageY: number;
+        shiftKey: boolean;
+        pointerType: string;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    touchEventHandler(e: TouchEvent): {
+        type: string;
+        touches: {
+            pageX: number;
+            pageY: number;
+        }[];
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    wheelEventHandler(e: WheelEvent): {
+        deltaX: number;
+        deltaY: number;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    };
+    keyEventHandler(e: KeyboardEvent): {
+        ctrlKey: boolean;
+        metaKey: boolean;
+        shiftKey: boolean;
+        keyCode: number;
+        type?: string;
+        width: number;
+        height: number;
+        windowWidth: number;
+        windowHeight: number;
+    } | undefined;
+}

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

@@ -0,0 +1,46 @@
+import { RegisterComponent } from './register.component';
+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);
+    private _initCanvas;
+    private _initComponent;
+    private _initController;
+    private _initWorkerThread;
+    private _initProxyEvents;
+    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;
+    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>;
+}

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

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

package/dist/main.d.ts

@@ -1,26 +1,2 @@
-import { R as RegisterPropsModel, a as RegisterModule } from './main.worker-DSzVtnTj.js';
-export { d as AppLifecycleState, A as AppModule, j as AppProxyEventHandlersModel, e as CoreModuleMessageEvent, C as CoreModuleMessageEventData, D as DefaultCameraType, K as KEYBOARD_EVENT_CODES, k as LaunchAppProps, g as LoadedResourceItem, L as LoaderModule, M as Module, O as OffscreenCanvasWithStyle, P as PROXY_EVENT_LISTENERS, i as ProgressedResource, f as ProxyEvent, r as ProxyEventHandlersImplementation, m as ProxyEventHandlersModel, q as ProxyEventListenerKeys, t as ProxyEventObservablesImplementation, n as ProxyEventObservablesModel, s as ProxyEventSubjectsImplementation, o as ProxyEventSubjectsModel, c as RegisterLifecycleState, p as RegisterProxyEventHandlersModel, h as Resource, S as StepPayload, b as appModule, l as loaderModule } from './main.worker-DSzVtnTj.js';
-import { SerializerImplementation } from 'threads';
-import '@quick-threejs/utils';
-import 'rxjs';
-import 'three';
-import 'three/examples/jsm/controls/OrbitControls';
-import 'three/examples/jsm/libs/lil-gui.module.min';
-import 'threads/dist/types/master';
-import 'three/examples/jsm/libs/lil-gui.module.min.js';
-import 'stats.js';
-import 'three/examples/jsm/loaders/GLTFLoader';
-import 'three/examples/jsm/loaders/DRACOLoader';
-
-declare const object3DSerializer: SerializerImplementation;
-
-/**
- * @description Register the main logic of the app.
- *
- * @remark __🏁 Should be called on your main thread. Separated from the worker thread implementation__
- *
- * @param props Quick-three register properties.
- */
-declare const register: (props: RegisterPropsModel) => RegisterModule;
-
-export { RegisterModule, RegisterPropsModel, object3DSerializer, register };
+export * from './core';
+export * from './common';