angular-three-soba 2.0.0-beta.236 → 2.0.0-beta.237

package/cameras/README.md

@@ -0,0 +1,3 @@
+# angular-three-soba/cameras
+
+Secondary entry point of `angular-three-soba`. It can be used by importing from `angular-three-soba/cameras`.

package/cameras/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/camera-content';
+export * from './lib/perspective-camera';

package/cameras/lib/camera-content.d.ts

@@ -0,0 +1,10 @@
+import { Signal } from '@angular/core';
+import { Texture } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsCameraContentWithFboTexture {
+    static ngTemplateContextGuard(_: NgtsCameraContentWithFboTexture, ctx: unknown): ctx is {
+        $implicit: Signal<Texture>;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCameraContentWithFboTexture, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsCameraContentWithFboTexture, "ng-template[withTexture]", never, {}, {}, never, never, true, never>;
+}

package/cameras/lib/perspective-camera.d.ts

@@ -0,0 +1,35 @@
+import { TemplateRef } from '@angular/core';
+import { Group, PerspectiveCamera, Texture } from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsPerspectiveCameraOptions extends Partial<PerspectiveCamera> {
+    /** Registers the camera as the system default, fiber will start rendering with it */
+    makeDefault?: boolean;
+    /** Making it manual will stop responsiveness and you have to calculate aspect ratio yourself. */
+    manual?: boolean;
+    /** Number of frames to render, Infinity */
+    frames: number;
+    /** Resolution of the FBO, 256 */
+    resolution: number;
+    /** Optional environment map for functional use */
+    envMap?: Texture;
+}
+export declare class NgtsPerspectiveCamera {
+    cameraRef: import("@angular/core").InputSignal<import("angular-three").NgtInjectedRef<PerspectiveCamera>>;
+    options: import("@angular/core").InputSignalWithTransform<NgtsPerspectiveCameraOptions, "" | Partial<NgtsPerspectiveCameraOptions>>;
+    parameters: import("@angular/core").Signal<NgtsPerspectiveCameraOptions>;
+    content: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    withTextureContent: import("@angular/core").Signal<TemplateRef<any> | undefined>;
+    groupRef: import("angular-three").NgtInjectedRef<Group<import("three").Object3DEventMap>>;
+    private autoEffect;
+    private store;
+    private camera;
+    private size;
+    private manual;
+    private makeDefault;
+    private resolution;
+    private fbo;
+    texture: import("@angular/core").Signal<Texture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsPerspectiveCamera, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsPerspectiveCamera, "ngts-perspective-camera", never, { "cameraRef": { "alias": "cameraRef"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, ["content", "withTextureContent"], never, true, never>;
+}

package/controls/index.d.ts

@@ -1 +1 @@
-export * from './orbit-controls/orbit-controls';
+export * from './lib/orbit-controls';

package/controls/{orbit-controls → lib}/orbit-controls.d.ts

@@ -2,7 +2,7 @@ import { NgtInjectedRef, NgtVector3 } from 'angular-three';
 import { Camera, Event } from 'three';
 import { OrbitControls } from 'three-stdlib';
 import * as i0 from "@angular/core";
-export interface NgtsOrbitControlsState {
+export interface NgtsOrbitControlsOptions {
     camera?: Camera;
     domElement?: HTMLElement;
     target?: NgtVector3;
@@ -16,11 +16,12 @@ declare global {
         /**
          * @extends three-stdlib|OrbitControls
          */
-        'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;
+        'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsOptions;
     }
 }
 export declare class NgtsOrbitControls {
-    options: import("@angular/core").InputSignalWithTransform<NgtsOrbitControlsState, "" | Partial<NgtsOrbitControlsState>>;
+    options: import("@angular/core").InputSignalWithTransform<Partial<OrbitControls> & NgtsOrbitControlsOptions, "" | Partial<Partial<OrbitControls> & NgtsOrbitControlsOptions>>;
+    parameters: import("@angular/core").Signal<Partial<OrbitControls> & NgtsOrbitControlsOptions>;
     controlsRef: import("@angular/core").InputSignal<NgtInjectedRef<OrbitControls>>;
     changed: import("@angular/core").OutputEmitterRef<Event<string, unknown>>;
     started: import("@angular/core").OutputEmitterRef<Event<string, unknown>>;

package/esm2022/cameras/angular-three-soba-cameras.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWNhbWVyYXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvYW5ndWxhci10aHJlZS1zb2JhLWNhbWVyYXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/cameras/index.mjs

@@ -0,0 +1,3 @@
+export * from './lib/camera-content';
+export * from './lib/perspective-camera';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvY2FtZXJhLWNvbnRlbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcGVyc3BlY3RpdmUtY2FtZXJhJztcbiJdfQ==

package/esm2022/cameras/lib/camera-content.mjs

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NgtsCameraContentWithFboTexture {
+    static ngTemplateContextGuard(_, ctx) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsCameraContentWithFboTexture, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.3", type: NgtsCameraContentWithFboTexture, isStandalone: true, selector: "ng-template[withTexture]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsCameraContentWithFboTexture, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ng-template[withTexture]' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FtZXJhLWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY2FtZXJhcy9zcmMvbGliL2NhbWVyYS1jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7O0FBSWxELE1BQU0sT0FBTywrQkFBK0I7SUFDM0MsTUFBTSxDQUFDLHNCQUFzQixDQUM1QixDQUFrQyxFQUNsQyxHQUFZO1FBRVosT0FBTyxJQUFJLENBQUM7SUFDYixDQUFDOzhHQU5XLCtCQUErQjtrR0FBL0IsK0JBQStCOzsyRkFBL0IsK0JBQStCO2tCQUQzQyxTQUFTO21CQUFDLEVBQUUsVUFBVSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsMEJBQTBCLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIFNpZ25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVGV4dHVyZSB9IGZyb20gJ3RocmVlJztcblxuQERpcmVjdGl2ZSh7IHN0YW5kYWxvbmU6IHRydWUsIHNlbGVjdG9yOiAnbmctdGVtcGxhdGVbd2l0aFRleHR1cmVdJyB9KVxuZXhwb3J0IGNsYXNzIE5ndHNDYW1lcmFDb250ZW50V2l0aEZib1RleHR1cmUge1xuXHRzdGF0aWMgbmdUZW1wbGF0ZUNvbnRleHRHdWFyZChcblx0XHRfOiBOZ3RzQ2FtZXJhQ29udGVudFdpdGhGYm9UZXh0dXJlLFxuXHRcdGN0eDogdW5rbm93bixcblx0KTogY3R4IGlzIHsgJGltcGxpY2l0OiBTaWduYWw8VGV4dHVyZT4gfSB7XG5cdFx0cmV0dXJuIHRydWU7XG5cdH1cbn1cbiJdfQ==

package/esm2022/cameras/lib/perspective-camera.mjs

@@ -0,0 +1,109 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, TemplateRef, afterNextRender, computed, contentChild, input, untracked, } from '@angular/core';
+import { extend, injectBeforeRender, injectNgtRef, injectNgtStore, makeParameters } from 'angular-three';
+import { NgtsContent, injectFBO } from 'angular-three-soba/misc';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, PerspectiveCamera } from 'three';
+import { NgtsCameraContentWithFboTexture } from './camera-content';
+import * as i0 from "@angular/core";
+extend({ PerspectiveCamera, Group });
+const defaultOptions = {
+    frames: Infinity,
+    resolution: 256,
+    makeDefault: false,
+    manual: false,
+};
+export class NgtsPerspectiveCamera {
+    constructor() {
+        this.cameraRef = input(injectNgtRef());
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = makeParameters(this.options, ['envMap', 'makeDefault', 'manual', 'frames', 'resolution']);
+        this.content = contentChild(NgtsContent, { read: TemplateRef });
+        this.withTextureContent = contentChild(NgtsCameraContentWithFboTexture, { read: TemplateRef });
+        this.groupRef = injectNgtRef();
+        this.autoEffect = injectAutoEffect();
+        this.store = injectNgtStore();
+        this.camera = this.store.select('camera');
+        this.size = this.store.select('size');
+        this.manual = computed(() => this.options().manual);
+        this.makeDefault = computed(() => this.options().makeDefault);
+        this.resolution = computed(() => this.options().resolution);
+        this.fbo = injectFBO(() => ({ width: this.resolution() }));
+        this.texture = computed(() => this.fbo().texture);
+        afterNextRender(() => {
+            this.autoEffect(() => {
+                if (!this.manual()) {
+                    this.cameraRef().nativeElement.aspect = this.size().width / this.size().height;
+                }
+            });
+            this.autoEffect(() => {
+                if (this.makeDefault()) {
+                    const oldCam = untracked(this.camera);
+                    this.store.update({ camera: this.cameraRef().nativeElement });
+                    return () => this.store.update(() => ({ camera: oldCam }));
+                }
+                return;
+            });
+            this.cameraRef().nativeElement.aspect = this.size().width / this.size().height;
+        });
+        let count = 0;
+        let oldEnvMap = null;
+        injectBeforeRender(({ gl, scene }) => {
+            const [{ frames, envMap }, group, camera, fbo] = [
+                this.options(),
+                this.groupRef.nativeElement,
+                this.cameraRef().nativeElement,
+                this.fbo(),
+            ];
+            if (this.withTextureContent() && group && camera && fbo && (frames === Infinity || count < frames)) {
+                group.visible = false;
+                gl.setRenderTarget(fbo);
+                oldEnvMap = scene.background;
+                if (envMap)
+                    scene.background = envMap;
+                gl.render(scene, camera);
+                scene.background = oldEnvMap;
+                gl.setRenderTarget(null);
+                group.visible = true;
+                count++;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsPerspectiveCamera, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: NgtsPerspectiveCamera, isStandalone: true, selector: "ngts-perspective-camera", inputs: { cameraRef: { classPropertyName: "cameraRef", publicName: "cameraRef", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "content", first: true, predicate: NgtsContent, descendants: true, read: TemplateRef, isSignal: true }, { propertyName: "withTextureContent", first: true, predicate: NgtsCameraContentWithFboTexture, descendants: true, read: TemplateRef, isSignal: true }], ngImport: i0, template: `
+		<ngt-perspective-camera [ref]="cameraRef()" [parameters]="parameters()">
+			@if (content(); as template) {
+				<ng-container [ngTemplateOutlet]="template" />
+			}
+		</ngt-perspective-camera>
+		<ngt-group [ref]="groupRef">
+			@if (withTextureContent(); as withTextureTemplate) {
+				<ng-container [ngTemplateOutlet]="withTextureTemplate" [ngTemplateOutletContext]="{ $implicit: texture }" />
+			}
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsPerspectiveCamera, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-perspective-camera',
+                    standalone: true,
+                    template: `
+		<ngt-perspective-camera [ref]="cameraRef()" [parameters]="parameters()">
+			@if (content(); as template) {
+				<ng-container [ngTemplateOutlet]="template" />
+			}
+		</ngt-perspective-camera>
+		<ngt-group [ref]="groupRef">
+			@if (withTextureContent(); as withTextureTemplate) {
+				<ng-container [ngTemplateOutlet]="withTextureTemplate" [ngTemplateOutletContext]="{ $implicit: texture }" />
+			}
+		</ngt-group>
+	`,
+                    imports: [NgTemplateOutlet],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"perspective-camera.js","sourceRoot":"","sources":["../../../../../../libs/soba/cameras/src/lib/perspective-camera.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tChangeDetectionStrategy,\n\tComponent,\n\tTemplateRef,\n\tafterNextRender,\n\tcomputed,\n\tcontentChild,\n\tinput,\n\tuntracked,\n} from '@angular/core';\nimport { extend, injectBeforeRender, injectNgtRef, injectNgtStore, makeParameters } from 'angular-three';\nimport { NgtsContent, injectFBO } from 'angular-three-soba/misc';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Color, Group, PerspectiveCamera, Texture } from 'three';\nimport { NgtsCameraContentWithFboTexture } from './camera-content';\n\nextend({ PerspectiveCamera, Group });\n\nexport interface NgtsPerspectiveCameraOptions extends Partial<PerspectiveCamera> {\n\t/** Registers the camera as the system default, fiber will start rendering with it */\n\tmakeDefault?: boolean;\n\t/** Making it manual will stop responsiveness and you have to calculate aspect ratio yourself. */\n\tmanual?: boolean;\n\t/** Number of frames to render, Infinity */\n\tframes: number;\n\t/** Resolution of the FBO, 256 */\n\tresolution: number;\n\t/** Optional environment map for functional use */\n\tenvMap?: Texture;\n}\n\nconst defaultOptions: NgtsPerspectiveCameraOptions = {\n\tframes: Infinity,\n\tresolution: 256,\n\tmakeDefault: false,\n\tmanual: false,\n};\n\n@Component({\n\tselector: 'ngts-perspective-camera',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-perspective-camera [ref]=\"cameraRef()\" [parameters]=\"parameters()\">\n\t\t\t@if (content(); as template) {\n\t\t\t\t<ng-container [ngTemplateOutlet]=\"template\" />\n\t\t\t}\n\t\t</ngt-perspective-camera>\n\t\t<ngt-group [ref]=\"groupRef\">\n\t\t\t@if (withTextureContent(); as withTextureTemplate) {\n\t\t\t\t<ng-container [ngTemplateOutlet]=\"withTextureTemplate\" [ngTemplateOutletContext]=\"{ $implicit: texture }\" />\n\t\t\t}\n\t\t</ngt-group>\n\t`,\n\timports: [NgTemplateOutlet],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsPerspectiveCamera {\n\tcameraRef = input(injectNgtRef<PerspectiveCamera>());\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = makeParameters(this.options, ['envMap', 'makeDefault', 'manual', 'frames', 'resolution']);\n\n\tcontent = contentChild(NgtsContent, { read: TemplateRef });\n\twithTextureContent = contentChild(NgtsCameraContentWithFboTexture, { read: TemplateRef });\n\n\tgroupRef = injectNgtRef<Group>();\n\n\tprivate autoEffect = injectAutoEffect();\n\tprivate store = injectNgtStore();\n\n\tprivate camera = this.store.select('camera');\n\tprivate size = this.store.select('size');\n\n\tprivate manual = computed(() => this.options().manual);\n\tprivate makeDefault = computed(() => this.options().makeDefault);\n\tprivate resolution = computed(() => this.options().resolution);\n\tprivate fbo = injectFBO(() => ({ width: this.resolution() }));\n\ttexture = computed(() => this.fbo().texture);\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tif (!this.manual()) {\n\t\t\t\t\tthis.cameraRef().nativeElement.aspect = this.size().width / this.size().height;\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tif (this.makeDefault()) {\n\t\t\t\t\tconst oldCam = untracked(this.camera);\n\t\t\t\t\tthis.store.update({ camera: this.cameraRef().nativeElement });\n\t\t\t\t\treturn () => this.store.update(() => ({ camera: oldCam }));\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t});\n\n\t\t\tthis.cameraRef().nativeElement.aspect = this.size().width / this.size().height;\n\t\t});\n\n\t\tlet count = 0;\n\t\tlet oldEnvMap: Color | Texture | null = null;\n\t\tinjectBeforeRender(({ gl, scene }) => {\n\t\t\tconst [{ frames, envMap }, group, camera, fbo] = [\n\t\t\t\tthis.options(),\n\t\t\t\tthis.groupRef.nativeElement,\n\t\t\t\tthis.cameraRef().nativeElement,\n\t\t\t\tthis.fbo(),\n\t\t\t];\n\t\t\tif (this.withTextureContent() && group && camera && fbo && (frames === Infinity || count < frames)) {\n\t\t\t\tgroup.visible = false;\n\t\t\t\tgl.setRenderTarget(fbo);\n\t\t\t\toldEnvMap = scene.background;\n\t\t\t\tif (envMap) scene.background = envMap;\n\t\t\t\tgl.render(scene, camera);\n\t\t\t\tscene.background = oldEnvMap;\n\t\t\t\tgl.setRenderTarget(null);\n\t\t\t\tgroup.visible = true;\n\t\t\t\tcount++;\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/controls/index.mjs

@@ -1,2 +1,2 @@
-export * from './orbit-controls/orbit-controls';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY29udHJvbHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29yYml0LWNvbnRyb2xzL29yYml0LWNvbnRyb2xzJztcbiJdfQ==
+export * from './lib/orbit-controls';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvY29udHJvbHMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9vcmJpdC1jb250cm9scyc7XG4iXX0=

package/esm2022/controls/lib/orbit-controls.mjs

@@ -0,0 +1,140 @@
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, input, output } from '@angular/core';
+import { injectBeforeRender, injectNgtRef, injectNgtStore, makeParameters, NgtArgs, } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { OrbitControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    enableDamping: true,
+    regress: false,
+    makeDefault: false,
+    keyEvents: false,
+};
+export class NgtsOrbitControls {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = makeParameters(this.options, [
+            'makeDefault',
+            'camera',
+            'regress',
+            'domElement',
+            'keyEvents',
+            'enableDamping',
+        ]);
+        this.controlsRef = input(injectNgtRef());
+        this.changed = output();
+        this.started = output();
+        this.ended = output();
+        this.store = injectNgtStore();
+        this.invalidate = this.store.select('invalidate');
+        this.performanceRegress = this.store.select('performance', 'regress');
+        this.defaultCamera = this.store.select('camera');
+        this.glDomElement = this.store.select('gl', 'domElement');
+        this.camera = computed(() => this.options().camera);
+        this.regress = computed(() => this.options().regress);
+        this.keyEvents = computed(() => this.options().keyEvents);
+        this.domElement = computed(() => this.options().domElement);
+        this.makeDefault = computed(() => this.options().makeDefault);
+        this.args = computed(() => [this.controlsRef().nativeElement]);
+        this.enableDamping = computed(() => this.options().enableDamping);
+        injectBeforeRender(() => {
+            const controls = this.controlsRef().nativeElement;
+            if (controls?.enabled) {
+                controls.update();
+            }
+        }, { priority: -1 });
+        this.setControls();
+        this.connectElement();
+        this.makeControlsDefault();
+        this.setEvents();
+    }
+    setControls() {
+        effect(() => {
+            const [camera, defaultCamera, controlsRef] = [this.camera(), this.defaultCamera(), this.controlsRef()];
+            const controlsCamera = camera || defaultCamera;
+            if (!controlsRef.nativeElement || controlsRef.nativeElement.object !== controlsCamera) {
+                controlsRef.nativeElement = new OrbitControls(controlsCamera);
+            }
+        });
+    }
+    connectElement() {
+        effect((onCleanup) => {
+            const [keyEvents, domElement, controls] = [
+                this.keyEvents(),
+                this.domElement() || this.store.get('events', 'connected') || this.glDomElement(),
+                this.controlsRef().nativeElement,
+                this.invalidate(),
+                this.regress(),
+            ];
+            if (!controls)
+                return;
+            if (keyEvents) {
+                controls.connect(keyEvents === true ? domElement : keyEvents);
+            }
+            else {
+                controls.connect(domElement);
+            }
+            onCleanup(() => void controls.dispose());
+        });
+    }
+    makeControlsDefault() {
+        effect((onCleanup) => {
+            const [controls, makeDefault] = [this.controlsRef().nativeElement, this.makeDefault()];
+            if (!controls)
+                return;
+            if (makeDefault) {
+                const oldControls = this.store.get('controls');
+                this.store.update({ controls });
+                onCleanup(() => void this.store.update({ controls: oldControls }));
+            }
+        });
+    }
+    setEvents() {
+        effect((onCleanup) => {
+            const [controls, invalidate, performanceRegress, regress] = [
+                this.controlsRef().nativeElement,
+                this.invalidate(),
+                this.performanceRegress(),
+                this.regress(),
+            ];
+            if (!controls)
+                return;
+            const changeCallback = (e) => {
+                invalidate();
+                if (regress)
+                    performanceRegress();
+                this.changed.emit(e);
+            };
+            const startCallback = this.started.emit.bind(this.started);
+            const endCallback = this.ended.emit.bind(this.ended);
+            controls.addEventListener('change', changeCallback);
+            controls.addEventListener('start', startCallback);
+            controls.addEventListener('end', endCallback);
+            onCleanup(() => {
+                controls.removeEventListener('change', changeCallback);
+                controls.removeEventListener('start', startCallback);
+                controls.removeEventListener('end', endCallback);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsOrbitControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.3", type: NgtsOrbitControls, isStandalone: true, selector: "ngts-orbit-controls", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, controlsRef: { classPropertyName: "controlsRef", publicName: "controlsRef", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { changed: "changed", started: "started", ended: "ended" }, ngImport: i0, template: `
+		<ngt-primitive ngtCompound *args="args()" [parameters]="parameters()" [enableDamping]="enableDamping()">
+			<ng-content />
+		</ngt-primitive>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsOrbitControls, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-orbit-controls',
+                    standalone: true,
+                    template: `
+		<ngt-primitive ngtCompound *args="args()" [parameters]="parameters()" [enableDamping]="enableDamping()">
+			<ng-content />
+		</ngt-primitive>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orbit-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/controls/src/lib/orbit-controls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EACN,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,OAAO,GAIP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;;AAqB7C,MAAM,cAAc,GAAsD;IACzE,aAAa,EAAE,IAAI;IACnB,OAAO,EAAE,KAAK;IACd,WAAW,EAAE,KAAK;IAClB,SAAS,EAAE,KAAK;CAChB,CAAC;AAaF,MAAM,OAAO,iBAAiB;IA+B7B;QA9BA,YAAO,GAAG,KAAK,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QAC5E,eAAU,GAAG,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE;YACzC,aAAa;YACb,QAAQ;YACR,SAAS;YACT,YAAY;YACZ,WAAW;YACX,eAAe;SACf,CAAC,CAAC;QACH,gBAAW,GAAG,KAAK,CAAgC,YAAY,EAAE,CAAC,CAAC;QAEnE,YAAO,GAAG,MAAM,EAAS,CAAC;QAC1B,YAAO,GAAG,MAAM,EAAS,CAAC;QAC1B,UAAK,GAAG,MAAM,EAAS,CAAC;QAEhB,UAAK,GAAG,cAAc,EAAE,CAAC;QACzB,eAAU,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAC7C,uBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;QACjE,kBAAa,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC5C,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAErD,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;QAC/C,YAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;QACjD,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;QACrD,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;QACvD,gBAAW,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,CAAC;QAEvD,SAAI,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC;QAC1D,kBAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,aAAa,CAAC,CAAC;QAGtE,kBAAkB,CACjB,GAAG,EAAE;YACJ,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,aAAa,CAAC;YAClD,IAAI,QAAQ,EAAE,OAAO,EAAE,CAAC;gBACvB,QAAQ,CAAC,MAAM,EAAE,CAAC;YACnB,CAAC;QACF,CAAC,EACD,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAChB,CAAC;QAEF,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,SAAS,EAAE,CAAC;IAClB,CAAC;IAEO,WAAW;QAClB,MAAM,CAAC,GAAG,EAAE;YACX,MAAM,CAAC,MAAM,EAAE,aAAa,EAAE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;YACvG,MAAM,cAAc,GAAG,MAAM,IAAI,aAAa,CAAC;YAC/C,IAAI,CAAC,WAAW,CAAC,aAAa,IAAI,WAAW,CAAC,aAAa,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;gBACvF,WAAW,CAAC,aAAa,GAAG,IAAI,aAAa,CAAC,cAA2B,CAAC,CAAC;YAC5E,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAEO,cAAc;QACrB,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE;YACpB,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,GAAG;gBACzC,IAAI,CAAC,SAAS,EAAE;gBAChB,IAAI,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE;gBACjF,IAAI,CAAC,WAAW,EAAE,CAAC,aAAa;gBAChC,IAAI,CAAC,UAAU,EAAE;gBACjB,IAAI,CAAC,OAAO,EAAE;aACd,CAAC;YACF,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,IAAI,SAAS,EAAE,CAAC;gBACf,QAAQ,CAAC,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACP,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC9B,CAAC;YACD,SAAS,CAAC,GAAG,EAAE,CAAC,KAAK,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACJ,CAAC;IAEO,mBAAmB;QAC1B,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE;YACpB,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,aAAa,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;YACvF,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,IAAI,WAAW,EAAE,CAAC;gBACjB,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC/C,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAChC,SAAS,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC;YACpE,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAEO,SAAS;QAChB,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE;YACpB,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,kBAAkB,EAAE,OAAO,CAAC,GAAG;gBAC3D,IAAI,CAAC,WAAW,EAAE,CAAC,aAAa;gBAChC,IAAI,CAAC,UAAU,EAAE;gBACjB,IAAI,CAAC,kBAAkB,EAAE;gBACzB,IAAI,CAAC,OAAO,EAAE;aACd,CAAC;YACF,IAAI,CAAC,QAAQ;gBAAE,OAAO;YACtB,MAAM,cAAc,GAAuB,CAAC,CAAC,EAAE,EAAE;gBAChD,UAAU,EAAE,CAAC;gBACb,IAAI,OAAO;oBAAE,kBAAkB,EAAE,CAAC;gBAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACtB,CAAC,CAAC;YAEF,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAErD,QAAQ,CAAC,gBAAgB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;YACpD,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;YAClD,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAE9C,SAAS,CAAC,GAAG,EAAE;gBACd,QAAQ,CAAC,mBAAmB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;gBACvD,QAAQ,CAAC,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;gBACrD,QAAQ,CAAC,mBAAmB,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YAClD,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;8GArHW,iBAAiB;kGAAjB,iBAAiB,waARnB;;;;EAIT,4DACS,OAAO;;2FAGL,iBAAiB;kBAX7B,SAAS;mBAAC;oBACV,QAAQ,EAAE,qBAAqB;oBAC/B,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;EAIT;oBACD,OAAO,EAAE,CAAC,OAAO,CAAC;oBAClB,OAAO,EAAE,CAAC,sBAAsB,CAAC;iBACjC","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, input, output } from '@angular/core';\nimport {\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tmakeParameters,\n\tNgtArgs,\n\tNgtCamera,\n\tNgtInjectedRef,\n\tNgtVector3,\n} from 'angular-three';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Camera, Event } from 'three';\nimport { OrbitControls } from 'three-stdlib';\n\nexport interface NgtsOrbitControlsOptions {\n\tcamera?: Camera;\n\tdomElement?: HTMLElement;\n\ttarget?: NgtVector3;\n\tmakeDefault: boolean;\n\tregress: boolean;\n\tenableDamping: boolean;\n\tkeyEvents: boolean | HTMLElement;\n}\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends three-stdlib|OrbitControls\n\t\t */\n\t\t'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsOptions;\n\t}\n}\n\nconst defaultOptions: Partial<OrbitControls> & NgtsOrbitControlsOptions = {\n\tenableDamping: true,\n\tregress: false,\n\tmakeDefault: false,\n\tkeyEvents: false,\n};\n\n@Component({\n\tselector: 'ngts-orbit-controls',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive ngtCompound *args=\"args()\" [parameters]=\"parameters()\" [enableDamping]=\"enableDamping()\">\n\t\t\t<ng-content />\n\t\t</ngt-primitive>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsOrbitControls {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = makeParameters(this.options, [\n\t\t'makeDefault',\n\t\t'camera',\n\t\t'regress',\n\t\t'domElement',\n\t\t'keyEvents',\n\t\t'enableDamping',\n\t]);\n\tcontrolsRef = input<NgtInjectedRef<OrbitControls>>(injectNgtRef());\n\n\tchanged = output<Event>();\n\tstarted = output<Event>();\n\tended = output<Event>();\n\n\tprivate store = injectNgtStore();\n\tprivate invalidate = this.store.select('invalidate');\n\tprivate performanceRegress = this.store.select('performance', 'regress');\n\tprivate defaultCamera = this.store.select('camera');\n\tprivate glDomElement = this.store.select('gl', 'domElement');\n\n\tprivate camera = computed(() => this.options().camera);\n\tprivate regress = computed(() => this.options().regress);\n\tprivate keyEvents = computed(() => this.options().keyEvents);\n\tprivate domElement = computed(() => this.options().domElement);\n\tprivate makeDefault = computed(() => this.options().makeDefault);\n\n\tprotected args = computed(() => [this.controlsRef().nativeElement]);\n\tprotected enableDamping = computed(() => this.options().enableDamping);\n\n\tconstructor() {\n\t\tinjectBeforeRender(\n\t\t\t() => {\n\t\t\t\tconst controls = this.controlsRef().nativeElement;\n\t\t\t\tif (controls?.enabled) {\n\t\t\t\t\tcontrols.update();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ priority: -1 },\n\t\t);\n\n\t\tthis.setControls();\n\t\tthis.connectElement();\n\t\tthis.makeControlsDefault();\n\t\tthis.setEvents();\n\t}\n\n\tprivate setControls() {\n\t\teffect(() => {\n\t\t\tconst [camera, defaultCamera, controlsRef] = [this.camera(), this.defaultCamera(), this.controlsRef()];\n\t\t\tconst controlsCamera = camera || defaultCamera;\n\t\t\tif (!controlsRef.nativeElement || controlsRef.nativeElement.object !== controlsCamera) {\n\t\t\t\tcontrolsRef.nativeElement = new OrbitControls(controlsCamera as NgtCamera);\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate connectElement() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [keyEvents, domElement, controls] = [\n\t\t\t\tthis.keyEvents(),\n\t\t\t\tthis.domElement() || this.store.get('events', 'connected') || this.glDomElement(),\n\t\t\t\tthis.controlsRef().nativeElement,\n\t\t\t\tthis.invalidate(),\n\t\t\t\tthis.regress(),\n\t\t\t];\n\t\t\tif (!controls) return;\n\t\t\tif (keyEvents) {\n\t\t\t\tcontrols.connect(keyEvents === true ? domElement : keyEvents);\n\t\t\t} else {\n\t\t\t\tcontrols.connect(domElement);\n\t\t\t}\n\t\t\tonCleanup(() => void controls.dispose());\n\t\t});\n\t}\n\n\tprivate makeControlsDefault() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [controls, makeDefault] = [this.controlsRef().nativeElement, this.makeDefault()];\n\t\t\tif (!controls) return;\n\t\t\tif (makeDefault) {\n\t\t\t\tconst oldControls = this.store.get('controls');\n\t\t\t\tthis.store.update({ controls });\n\t\t\t\tonCleanup(() => void this.store.update({ controls: oldControls }));\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate setEvents() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [controls, invalidate, performanceRegress, regress] = [\n\t\t\t\tthis.controlsRef().nativeElement,\n\t\t\t\tthis.invalidate(),\n\t\t\t\tthis.performanceRegress(),\n\t\t\t\tthis.regress(),\n\t\t\t];\n\t\t\tif (!controls) return;\n\t\t\tconst changeCallback: (e: Event) => void = (e) => {\n\t\t\t\tinvalidate();\n\t\t\t\tif (regress) performanceRegress();\n\t\t\t\tthis.changed.emit(e);\n\t\t\t};\n\n\t\t\tconst startCallback = this.started.emit.bind(this.started);\n\t\t\tconst endCallback = this.ended.emit.bind(this.ended);\n\n\t\t\tcontrols.addEventListener('change', changeCallback);\n\t\t\tcontrols.addEventListener('start', startCallback);\n\t\t\tcontrols.addEventListener('end', endCallback);\n\n\t\t\tonCleanup(() => {\n\t\t\t\tcontrols.removeEventListener('change', changeCallback);\n\t\t\t\tcontrols.removeEventListener('start', startCallback);\n\t\t\t\tcontrols.removeEventListener('end', endCallback);\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/loaders/index.mjs

@@ -1,5 +1,5 @@
-export * from './gltf-loader/gltf-loader';
-export * from './loader/loader';
-export * from './progress/progress';
-export * from './texture-loader/texture-loader';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbG9hZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2x0Zi1sb2FkZXIvZ2x0Zi1sb2FkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9sb2FkZXIvbG9hZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZ3Jlc3MvcHJvZ3Jlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXh0dXJlLWxvYWRlci90ZXh0dXJlLWxvYWRlcic7XG4iXX0=
+export * from './lib/gltf-loader';
+export * from './lib/loader';
+export * from './lib/progress';
+export * from './lib/texture-loader';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvbG9hZGVycy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9nbHRmLWxvYWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9sb2FkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcHJvZ3Jlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdGV4dHVyZS1sb2FkZXInO1xuIl19

package/esm2022/loaders/lib/gltf-loader.mjs

@@ -0,0 +1,33 @@
+import { injectLoader } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { DRACOLoader, GLTFLoader, MeshoptDecoder } from 'three-stdlib';
+let dracoLoader = null;
+let decoderPath = 'https://www.gstatic.com/draco/versioned/decoders/1.5.5/';
+function _extensions(useDraco, useMeshOpt, extensions) {
+    return (loader) => {
+        if (extensions) {
+            extensions(loader);
+        }
+        if (useDraco) {
+            if (!dracoLoader) {
+                dracoLoader = new DRACOLoader();
+            }
+            dracoLoader.setDecoderPath(typeof useDraco === 'string' ? useDraco : decoderPath);
+            loader.setDRACOLoader(dracoLoader);
+        }
+        if (useMeshOpt) {
+            loader.setMeshoptDecoder(typeof MeshoptDecoder === 'function' ? MeshoptDecoder() : MeshoptDecoder);
+        }
+    };
+}
+function _injectGLTFLoader(path, { useDraco = true, useMeshOpt = true, injector, extensions, } = {}) {
+    return assertInjector(_injectGLTFLoader, injector, () => injectLoader(() => GLTFLoader, path, { extensions: _extensions(useDraco, useMeshOpt, extensions) }));
+}
+_injectGLTFLoader.preload = (path, { useDraco = true, useMeshOpt = true, extensions, } = {}) => {
+    injectLoader.preload(() => GLTFLoader, path, _extensions(useDraco, useMeshOpt, extensions));
+};
+_injectGLTFLoader.setDecoderPath = (path) => {
+    decoderPath = path;
+};
+export const injectGLTFLoader = _injectGLTFLoader;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/loaders/lib/loader.mjs

@@ -0,0 +1,108 @@
+import { ChangeDetectionStrategy, Component, computed, effect, input, signal, untracked, viewChild, } from '@angular/core';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { injectProgress } from './progress';
+import * as i0 from "@angular/core";
+const defaultDataInterpolation = (p) => `Loading ${p.toFixed(2)}%`;
+const defaultOptions = {
+    containerClass: '',
+    innerClass: '',
+    barClass: '',
+    dataClass: '',
+    dataInterpolation: defaultDataInterpolation,
+    initialState: (value) => value,
+};
+export class NgtsLoader {
+    constructor() {
+        this.progressState = injectProgress();
+        this.active = computed(() => this.progressState().active);
+        this.progress = computed(() => this.progressState().progress);
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.containerClass = computed(() => this.options().containerClass);
+        this.innerClass = computed(() => this.options().innerClass);
+        this.barClass = computed(() => this.options().barClass);
+        this.dataClass = computed(() => this.options().dataClass);
+        this.initialState = computed(() => this.options().initialState);
+        this.dataInterpolation = computed(() => this.options().dataInterpolation);
+        this.progressSpanRef = viewChild('progressSpanRef');
+        this.shown = signal(this.initialState()(this.active()));
+        this.setShown();
+        this.updateProgress();
+    }
+    setShown() {
+        effect((onCleanup) => {
+            const [active, lastShown] = [this.active(), untracked(this.shown)];
+            if (lastShown !== active) {
+                const timeoutId = setTimeout(() => {
+                    this.shown.set(active);
+                }, 300);
+                onCleanup(() => clearTimeout(timeoutId));
+            }
+        });
+    }
+    updateProgress() {
+        let progressRef = 0;
+        let rafId;
+        effect((onCleanup) => {
+            const [dataInterpolation, progress] = [this.dataInterpolation(), this.progress()];
+            const updateProgress = () => {
+                const progressSpan = this.progressSpanRef()?.nativeElement;
+                if (!progressSpan)
+                    return;
+                progressRef += (progress - progressRef) / 2;
+                if (progressRef > 0.95 * progress || progress === 100)
+                    progressRef = progress;
+                progressSpan.innerText = dataInterpolation(progressRef);
+                if (progressRef < progress) {
+                    rafId = requestAnimationFrame(updateProgress);
+                }
+            };
+            updateProgress();
+            onCleanup(() => cancelAnimationFrame(rafId));
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsLoader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: NgtsLoader, isStandalone: true, selector: "ngts-loader", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "progressSpanRef", first: true, predicate: ["progressSpanRef"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		@if (shown()) {
+			<div
+				class="ngts-loader-container"
+				[class]="containerClass() || ''"
+				[style.--ngts-loader-container-opacity]="active() ? 1 : 0"
+			>
+				<div>
+					<div class="ngts-loader-inner" [class]="innerClass() || ''">
+						<div
+							class="ngts-loader-bar"
+							[class]="barClass() || ''"
+							[style.--ngts-loader-bar-scale]="progress() / 100"
+						></div>
+						<span #progressSpanRef class="ngts-loader-data" [class]="dataClass() || ''"></span>
+					</div>
+				</div>
+			</div>
+		}
+	`, isInline: true, styles: [".ngts-loader-container{--ngts-loader-container-opacity: 0;position:absolute;top:0;left:0;width:100%;height:100%;background:#171717;display:flex;align-items:center;justify-content:center;transition:opacity .3s ease;z-index:1000;opacity:var(--ngts-loader-container-opacity)}.ngts-loader-inner{width:100px;height:3px;background:#272727;text-align:center}.ngts-loader-bar{--ngts-loader-bar-scale: 0;height:3px;width:100px;background:#fff;transition:transform .2s;transform-origin:left center;transform:scaleX(var(--ngts-loader-bar-scale))}.ngts-loader-data{display:inline-block;position:relative;font-variant-numeric:tabular-nums;margin-top:.8em;color:#f0f0f0;font-size:.6em;font-family:-apple-system,BlinkMacSystemFont,Inter,Segoe UI,Helvetica Neue,Helvetica,Arial,Roboto,Ubuntu,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\",Segoe UI Symbol;white-space:nowrap}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsLoader, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngts-loader', standalone: true, template: `
+		@if (shown()) {
+			<div
+				class="ngts-loader-container"
+				[class]="containerClass() || ''"
+				[style.--ngts-loader-container-opacity]="active() ? 1 : 0"
+			>
+				<div>
+					<div class="ngts-loader-inner" [class]="innerClass() || ''">
+						<div
+							class="ngts-loader-bar"
+							[class]="barClass() || ''"
+							[style.--ngts-loader-bar-scale]="progress() / 100"
+						></div>
+						<span #progressSpanRef class="ngts-loader-data" [class]="dataClass() || ''"></span>
+					</div>
+				</div>
+			</div>
+		}
+	`, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".ngts-loader-container{--ngts-loader-container-opacity: 0;position:absolute;top:0;left:0;width:100%;height:100%;background:#171717;display:flex;align-items:center;justify-content:center;transition:opacity .3s ease;z-index:1000;opacity:var(--ngts-loader-container-opacity)}.ngts-loader-inner{width:100px;height:3px;background:#272727;text-align:center}.ngts-loader-bar{--ngts-loader-bar-scale: 0;height:3px;width:100px;background:#fff;transition:transform .2s;transform-origin:left center;transform:scaleX(var(--ngts-loader-bar-scale))}.ngts-loader-data{display:inline-block;position:relative;font-variant-numeric:tabular-nums;margin-top:.8em;color:#f0f0f0;font-size:.6em;font-family:-apple-system,BlinkMacSystemFont,Inter,Segoe UI,Helvetica Neue,Helvetica,Arial,Roboto,Ubuntu,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\",Segoe UI Symbol;white-space:nowrap}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loader.js","sourceRoot":"","sources":["../../../../../../libs/soba/loaders/src/lib/loader.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tElementRef,\n\tcomputed,\n\teffect,\n\tinput,\n\tsignal,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { injectProgress } from './progress';\n\nconst defaultDataInterpolation = (p: number) => `Loading ${p.toFixed(2)}%`;\n\nexport interface NgtsLoaderState {\n\tcontainerClass?: string;\n\tinnerClass?: string;\n\tbarClass?: string;\n\tdataClass?: string;\n\tdataInterpolation: (value: number) => string;\n\tinitialState: (value: boolean) => boolean;\n}\n\nconst defaultOptions: NgtsLoaderState = {\n\tcontainerClass: '',\n\tinnerClass: '',\n\tbarClass: '',\n\tdataClass: '',\n\tdataInterpolation: defaultDataInterpolation,\n\tinitialState: (value) => value,\n};\n\n@Component({\n\tselector: 'ngts-loader',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (shown()) {\n\t\t\t<div\n\t\t\t\tclass=\"ngts-loader-container\"\n\t\t\t\t[class]=\"containerClass() || ''\"\n\t\t\t\t[style.--ngts-loader-container-opacity]=\"active() ? 1 : 0\"\n\t\t\t>\n\t\t\t\t<div>\n\t\t\t\t\t<div class=\"ngts-loader-inner\" [class]=\"innerClass() || ''\">\n\t\t\t\t\t\t<div\n\t\t\t\t\t\t\tclass=\"ngts-loader-bar\"\n\t\t\t\t\t\t\t[class]=\"barClass() || ''\"\n\t\t\t\t\t\t\t[style.--ngts-loader-bar-scale]=\"progress() / 100\"\n\t\t\t\t\t\t></div>\n\t\t\t\t\t\t<span #progressSpanRef class=\"ngts-loader-data\" [class]=\"dataClass() || ''\"></span>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t}\n\t`,\n\tstyleUrls: ['./loader.css'],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsLoader {\n\tprivate progressState = injectProgress();\n\n\tactive = computed(() => this.progressState().active);\n\tprogress = computed(() => this.progressState().progress);\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\n\tcontainerClass = computed(() => this.options().containerClass);\n\tinnerClass = computed(() => this.options().innerClass);\n\tbarClass = computed(() => this.options().barClass);\n\tdataClass = computed(() => this.options().dataClass);\n\tinitialState = computed(() => this.options().initialState);\n\tdataInterpolation = computed(() => this.options().dataInterpolation);\n\n\tprogressSpanRef = viewChild<ElementRef<HTMLSpanElement>>('progressSpanRef');\n\n\tshown = signal(this.initialState()(this.active()));\n\n\tconstructor() {\n\t\tthis.setShown();\n\t\tthis.updateProgress();\n\t}\n\n\tprivate setShown() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [active, lastShown] = [this.active(), untracked(this.shown)];\n\t\t\tif (lastShown !== active) {\n\t\t\t\tconst timeoutId = setTimeout(() => {\n\t\t\t\t\tthis.shown.set(active);\n\t\t\t\t}, 300);\n\t\t\t\tonCleanup(() => clearTimeout(timeoutId));\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate updateProgress() {\n\t\tlet progressRef = 0;\n\t\tlet rafId: ReturnType<typeof requestAnimationFrame>;\n\n\t\teffect((onCleanup) => {\n\t\t\tconst [dataInterpolation, progress] = [this.dataInterpolation(), this.progress()];\n\t\t\tconst updateProgress = () => {\n\t\t\t\tconst progressSpan = this.progressSpanRef()?.nativeElement;\n\t\t\t\tif (!progressSpan) return;\n\t\t\t\tprogressRef += (progress - progressRef) / 2;\n\t\t\t\tif (progressRef > 0.95 * progress || progress === 100) progressRef = progress;\n\t\t\t\tprogressSpan.innerText = dataInterpolation(progressRef);\n\t\t\t\tif (progressRef < progress) {\n\t\t\t\t\trafId = requestAnimationFrame(updateProgress);\n\t\t\t\t}\n\t\t\t};\n\t\t\tupdateProgress();\n\t\t\tonCleanup(() => cancelAnimationFrame(rafId));\n\t\t});\n\t}\n}\n"]}