@quick-threejs/reactive 0.1.21 → 0.1.23

package/dist/common/constants/event.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const KEYBOARD_EVENT_CODES: string[];
+export declare const PROXY_EVENT_LISTENERS: readonly ["contextmenu", "resize", "mousedown", "mousemove", "mouseup", "pointerdown", "pointermove", "pointercancel", "pointerup", "touchstart", "touchmove", "touchend", "wheel", "keydown"];

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

@@ -0,0 +1 @@
+export * from './event.constants';

package/dist/common/enums/camera.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum DefaultCameraType {
+    PERSPECTIVE = 0,
+    ORTHOGRAPHIC = 1
+}

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

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

package/dist/common/enums/lifecycle.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum RegisterLifecycleState {
+    INITIALIZED = 0,
+    DISPOSED = 1
+}
+export declare enum AppLifecycleState {
+    INITIALIZED = 0,
+    STEP_STARTED = 1,
+    STEP_ENDED = 2,
+    DISPOSED = 3
+}

package/dist/common/index.d.ts

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

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

@@ -0,0 +1,6 @@
+export interface OffscreenCanvasWithStyle extends OffscreenCanvas {
+    style: Partial<CSSStyleDeclaration> & {
+        width: CSSStyleDeclaration["width"];
+        height: CSSStyleDeclaration["height"];
+    };
+}

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

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

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

@@ -0,0 +1,10 @@
+export interface StepPayload {
+    delta: number;
+    deltaRatio: number;
+}
+export interface ProxyEvent {
+    width: number;
+    height: number;
+    windowWidth: number;
+    windowHeight: number;
+}

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * @description Module representation.
+ *
+ * @important Each module should `implement` this interface.
+ */
+export interface Module {
+    /**
+     * @description Module initializer method.
+     *
+     * Can be used for direct initialization (when constructing `quick-three`) or manual (later in the code).
+     */
+    init(...props: any[]): void;
+    /**
+     * @description Module disposal.
+     *
+     * Used to terminate the Module execution and free memory.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,14 @@
+import { CubeTextureLoader, Texture, VideoTexture } from 'three';
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+export type LoadedResourceItem = GLTF | Texture | CubeTextureLoader | VideoTexture | AudioBuffer;
+export interface Resource {
+    name: string;
+    type: "cubeTexture" | "texture" | "gltfModel" | "video" | "audio";
+    path: string | string[];
+}
+export interface ProgressedResource {
+    file?: LoadedResourceItem;
+    resource: Resource;
+    loaded: number;
+    toLoad: number;
+}

package/dist/common/models/app-proxy-event-handler.model.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { ProxyEvent } from 'main';
+export declare class AppProxyEventHandlersModel {
+    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;
+}

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

@@ -0,0 +1,7 @@
+export * from './app-proxy-event-handler.model';
+export * from './launch-app-props.model';
+export * from './proxy-event-handler.model';
+export * from './proxy-event-observables.model';
+export * from './proxy-event-subjects.models';
+export * from './register-props.model';
+export * from './register-proxy-event-handler.model';

package/dist/common/models/launch-app-props.model.d.ts

@@ -0,0 +1,8 @@
+import { AppModule } from '../../main';
+/** @description `launchApp` initialization properties. */
+export declare class LaunchAppProps {
+    /**
+     * @description Handler triggered when the app is ready.
+     */
+    onReady?: (app: AppModule) => unknown;
+}

package/dist/common/models/proxy-event-handler.model.d.ts

@@ -0,0 +1,19 @@
+import { ProxyEvent } from 'main';
+import { ProxyEventHandlersImplementation } from '../types/object.type';
+import { ProxyEventObservablesModel } from './proxy-event-observables.model';
+export declare class ProxyEventHandlersModel extends ProxyEventObservablesModel 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;
+}

package/dist/common/models/proxy-event-observables.model.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { ProxyEvent } from 'main';
+import { ProxyEventSubjectsModel } from './proxy-event-subjects.models';
+import { ProxyEventObservablesImplementation } from '../types/object.type';
+export declare class ProxyEventObservablesModel extends ProxyEventSubjectsModel 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>;
+}

package/dist/common/models/proxy-event-subjects.models.d.ts

@@ -0,0 +1,19 @@
+import { Subject } from 'rxjs';
+import { ProxyEvent } from 'main';
+import { ProxyEventSubjectsImplementation } from '../types/object.type';
+export declare class ProxyEventSubjectsModel 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>;
+}

package/dist/common/models/register-props.model.d.ts

@@ -0,0 +1,75 @@
+import { RegisterModule } from '../../core/register/register.module';
+import { DefaultCameraType } from '../enums/camera.enum';
+/** @description Quick-three register properties. */
+export declare class RegisterPropsModel {
+    /**
+     * @description The app worker logic location.
+     *
+     * @required
+     */
+    location: string;
+    /**
+     * @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;
+    /**
+     * 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 RegisterPropsModel.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 RegisterPropsModel.enableDebug}__
+     *
+     * @default undefined
+     */
+    gridSizes?: number;
+    /**
+     * Display a mini perfective camera at the top right corner of the screen.
+     *
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default false
+     */
+    withMiniCamera?: boolean;
+    /**
+     * @description Handler called when the app is ready.
+     *
+     * @default undefined
+     */
+    onReady?: (register: RegisterModule) => unknown;
+}

package/dist/common/models/register-proxy-event-handler.model.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+export declare class RegisterProxyEventHandlersModel {
+    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/types/index.d.ts

@@ -0,0 +1 @@
+export * from './object.type';

package/dist/common/types/object.type.d.ts

@@ -0,0 +1,13 @@
+import { Observable, Subject } from 'rxjs';
+import { PROXY_EVENT_LISTENERS } from '../constants/event.constants';
+/** @description  */
+export type ProxyEventListenerKeys = (typeof PROXY_EVENT_LISTENERS)[number];
+export type ProxyEventHandlersImplementation = {
+    [x in ProxyEventListenerKeys]: (event: any) => void;
+};
+export type ProxyEventSubjectsImplementation = {
+    [x in `${ProxyEventListenerKeys}$$`]: Subject<any>;
+};
+export type ProxyEventObservablesImplementation = {
+    [x in `${ProxyEventListenerKeys}$`]: Observable<any>;
+};

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

@@ -0,0 +1,7 @@
+import { ProxyReceiver } from '@quick-threejs/utils';
+import { OffscreenCanvasWithStyle } from '../../common/interfaces/canvas.interface';
+export declare class AppComponent {
+    readonly proxyReceiver: ProxyReceiver<Record<string, unknown>>;
+    initialized: boolean;
+    canvas?: OffscreenCanvasWithStyle;
+}

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

@@ -0,0 +1,10 @@
+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);
+}

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

@@ -0,0 +1,5 @@
+import { ExposedWorkerThreadModule, Methods } from '@quick-threejs/utils';
+import { AppModule } from './app.module';
+import { LaunchAppProps } from '../../common/models/launch-app-props.model';
+export declare const launchApp: (props?: LaunchAppProps) => AppModule;
+export type ExposedAppModule = ExposedWorkerThreadModule<Methods<AppModule>>;

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

@@ -0,0 +1,35 @@
+import { WorkerThreadModule } from '@quick-threejs/utils';
+import { AppController } from './app.controller';
+import { AppComponent } from './app.component';
+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;
+    readonly timer: TimerModule;
+    readonly sizes: SizesModule;
+    readonly camera: CameraModule;
+    readonly world: WorldModule;
+    readonly renderer: RendererModule;
+    readonly debug: DebugModule;
+    constructor(controller: AppController, component: AppComponent, timer: TimerModule, sizes: SizesModule, camera: CameraModule, world: WorldModule, renderer: RendererModule, debug: DebugModule);
+    private _initProxyEvents;
+    private _onMessage;
+    init(props: CoreModuleMessageEventData): void;
+    get canvas(): OffscreenCanvasWithStyle | undefined;
+    get initialized(): boolean;
+    isInitialized(): boolean;
+    dispose(): void;
+    lifecycle$(): Observable<AppLifecycleState>;
+}
+export declare const appModule: AppModule;

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

@@ -0,0 +1,18 @@
+import { Camera, Euler, PerspectiveCamera, Quaternion, Vector3 } from 'three';
+import { SizesComponent } from '../sizes/sizes.component';
+import { DefaultCameraType } from '../../../common/enums/camera.enum';
+export declare class CameraComponent {
+    private readonly sizesComponent;
+    instance?: Camera;
+    miniCamera?: PerspectiveCamera;
+    enabled: boolean;
+    constructor(sizesComponent: SizesComponent);
+    set aspectRatio(ratio: number);
+    set quaternion(quaternion: Quaternion);
+    set position(position: Vector3);
+    set rotation(rotation: Euler);
+    initDefaultCamera(cameraType?: DefaultCameraType): void;
+    setMiniCamera(): void;
+    removeCamera(): void;
+    removeMiniCamera(): void;
+}

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

@@ -0,0 +1,12 @@
+import { Observable, Subject } from 'rxjs';
+import { CameraComponent } from './camera.component';
+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);
+}

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

@@ -0,0 +1,20 @@
+import { Camera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
+import { CameraComponent } from './camera.component';
+import { CameraController } from './camera.controller';
+import { SizesComponent } from '../sizes/sizes.component';
+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);
+    init(withMiniCamera?: boolean): void;
+    dispose(): void;
+    aspectRatio(value?: number): number;
+    enabled(value?: boolean): boolean;
+    instance(value?: Camera): Camera | undefined;
+    miniCamera(value?: PerspectiveCamera): PerspectiveCamera | undefined;
+    position(value?: Vector3): Vector3;
+    quaternion(value?: Quaternion): Quaternion;
+    enabled$(): import('rxjs').Observable<boolean>;
+}

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

@@ -0,0 +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;
+    enabled: boolean;
+    cameraControls?: OrbitControls;
+    miniCameraControls?: OrbitControls;
+    cameraHelper?: CameraHelper;
+    axesHelper?: AxesHelper;
+    gridHelper?: GridHelper;
+    constructor(appComponent: AppComponent, cameraComponent: CameraComponent, worldComponent: WorldComponent);
+    private _setCameraOrbitControl;
+    private _setMiniCameraOrbitControls;
+    private _setCameraHelper;
+    private _setAxesHelper;
+    private _setGridHelper;
+    init(props?: {
+        axesSizes?: number;
+        gridSizes?: number;
+    }): void;
+    update(): void;
+    dispose(): void;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { DebugComponent } from './debug.component';
+import { DebugController } from './debug.controller';
+import { Module } from '../../../common/interfaces/module.interface';
+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;
+    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>;
+}

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

@@ -0,0 +1,19 @@
+import { WebGLRenderer } from 'three';
+import { WorldComponent } from '../world/world.component';
+import { CameraComponent } from '../camera/camera.component';
+import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
+import { SizesComponent } from '../sizes/sizes.component';
+import { DebugComponent } from '../debug/debug.component';
+export declare class RendererComponent {
+    private readonly worldComponent;
+    private readonly cameraComponent;
+    private readonly sizesComponent;
+    private readonly debugComponent;
+    static readonly RENDERER_PIXEL_RATIO: number;
+    enabled: boolean;
+    instance?: WebGLRenderer;
+    constructor(worldComponent: WorldComponent, cameraComponent: CameraComponent, sizesComponent: SizesComponent, debugComponent: DebugComponent);
+    init(canvas: OffscreenCanvasWithStyle): void;
+    setSize(width: number, height: number): void;
+    render(): void;
+}

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

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

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

@@ -0,0 +1,17 @@
+import { Vector2Like } from 'three';
+import { RendererComponent } from './renderer.component';
+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);
+    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>;
+}

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

@@ -0,0 +1,10 @@
+import { OffscreenCanvasWithStyle } from '../../../common/interfaces/canvas.interface';
+export declare class SizesComponent {
+    width: number;
+    height: number;
+    aspect: number;
+    pixelRatio: number;
+    frustrum: number;
+    enabled: boolean;
+    init(canvas: OffscreenCanvasWithStyle, enabled?: boolean): void;
+}

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

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

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

@@ -0,0 +1,19 @@
+import { SizesComponent } from './sizes.component';
+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);
+    init(canvas: OffscreenCanvasWithStyle): void;
+    dispose(): void;
+    aspect(value?: number): number;
+    enabled(value?: boolean): boolean;
+    frustrum(value?: number): number;
+    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/timer/timer.component.d.ts

@@ -0,0 +1,8 @@
+import { Clock } from 'three';
+export declare class TimerComponent {
+    readonly clock: Clock;
+    readonly frame: number;
+    delta: number;
+    deltaRatio: number;
+    enabled: boolean;
+}

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

@@ -0,0 +1,14 @@
+import { Subject } from 'rxjs';
+import { TimerComponent } from './timer.component';
+import { StepPayload } from '../../../common/interfaces/event.interface';
+import { AppController } from '../app.controller';
+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;
+}