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

package/esm2022/staging/lib/environment.mjs

@@ -0,0 +1,455 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, Directive, Injector, TemplateRef, afterNextRender, computed, contentChild, inject, input, signal, untracked, viewChild, } from '@angular/core';
+import { GainMapLoader, HDRJPGLoader } from '@monogrid/gainmap-js';
+import { NgtArgs, NgtPortal, NgtPortalContent, applyProps, extend, injectLoader, injectNextBeforeRender, injectNgtStore, is, prepare, } from 'angular-three';
+import { LinearEncoding, NgtsContent, sRGBEncoding } from 'angular-three-soba/misc';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { CubeCamera, CubeReflectionMapping, CubeTextureLoader, EquirectangularReflectionMapping, HalfFloatType, Scene, WebGLCubeRenderTarget, } from 'three';
+import { EXRLoader, GroundProjectedEnv, RGBELoader } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const CUBEMAP_ROOT = 'https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/';
+export const ENVIRONMENT_PRESETS = {
+    apartment: 'lebombo_1k.hdr',
+    city: 'potsdamer_platz_1k.hdr',
+    dawn: 'kiara_1_dawn_1k.hdr',
+    forest: 'forest_slope_1k.hdr',
+    lobby: 'st_fagans_interior_1k.hdr',
+    night: 'dikhololo_night_1k.hdr',
+    park: 'rooitou_park_1k.hdr',
+    studio: 'studio_small_03_1k.hdr',
+    sunset: 'venice_sunset_1k.hdr',
+    warehouse: 'empty_warehouse_01_1k.hdr',
+};
+function resolveScene(scene) {
+    return is.ref(scene) ? scene.nativeElement : scene;
+}
+function setEnvProps(background, scene, defaultScene, texture, sceneProps = {}) {
+    sceneProps.backgroundBlurriness ??= sceneProps.blur ?? 0;
+    sceneProps.backgroundIntensity ??= 1;
+    // @ts-expect-error - it's ok, we're sending through applyProps
+    sceneProps.backgroundRotation ??= [0, 0, 0];
+    sceneProps.environmentIntensity ??= 1;
+    // @ts-expect-error - it's ok, we're sending through applyProps
+    sceneProps.environmentRotation ??= [0, 0, 0];
+    const target = resolveScene(scene || defaultScene);
+    const oldbg = target.background;
+    const oldenv = target.environment;
+    const oldSceneProps = {
+        backgroundBlurriness: target.backgroundBlurriness,
+        backgroundIntensity: target.backgroundIntensity,
+        backgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],
+        environmentIntensity: target.environmentIntensity,
+        environmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0],
+    };
+    if (background !== 'only')
+        target.environment = texture;
+    if (background)
+        target.background = texture;
+    applyProps(target, sceneProps);
+    return () => {
+        if (background !== 'only')
+            target.environment = oldenv;
+        if (background)
+            target.background = oldbg;
+        applyProps(target, oldSceneProps);
+    };
+}
+export function injectEnvironment(options = () => ({}), { injector } = {}) {
+    return assertInjector(injectEnvironment, injector, () => {
+        const adjustedOptions = computed(() => {
+            let { files, path, preset, extensions, encoding } = options();
+            if (files == null) {
+                files = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];
+            }
+            if (path == null) {
+                path = '';
+            }
+            if (preset) {
+                if (!(preset in ENVIRONMENT_PRESETS))
+                    throw new Error('Preset must be one of: ' + Object.keys(ENVIRONMENT_PRESETS).join(', '));
+                files = ENVIRONMENT_PRESETS[preset];
+                path = CUBEMAP_ROOT;
+            }
+            return { files, preset, encoding, path, extensions };
+        });
+        const resultOptions = computed(() => {
+            const { files } = adjustedOptions();
+            const multiFile = Array.isArray(files);
+            const isCubeMap = multiFile && files.length === 6;
+            const isGainmain = multiFile && files.length === 3 && files.some((file) => file.endsWith('json'));
+            const firstEntry = multiFile ? files[0] : files;
+            const extension = isCubeMap
+                ? 'cube'
+                : isGainmain
+                    ? 'webp'
+                    : firstEntry.startsWith('data:application/exr')
+                        ? 'exr'
+                        : firstEntry.startsWith('data:application/hdr')
+                            ? 'hdr'
+                            : firstEntry.startsWith('data:image/jpeg')
+                                ? 'jpg'
+                                : firstEntry.split('.').pop()?.split('?')?.shift()?.toLowerCase();
+            return { multiFile, extension, isCubeMap };
+        });
+        const loader = computed(() => {
+            const { extension } = resultOptions();
+            const loader = extension === 'cube'
+                ? CubeTextureLoader
+                : extension === 'hdr'
+                    ? RGBELoader
+                    : extension === 'exr'
+                        ? EXRLoader
+                        : extension === 'jpg' || extension === 'jpeg'
+                            ? HDRJPGLoader
+                            : extension === 'webp'
+                                ? GainMapLoader
+                                : null;
+            if (!loader) {
+                throw new Error('injectEnvironment: Unrecognized file extension: ' + extension);
+            }
+            return loader;
+        });
+        const assertedInjector = inject(Injector);
+        const autoEffect = injectAutoEffect();
+        const store = injectNgtStore();
+        const gl = store.select('gl');
+        const texture = signal(null);
+        afterNextRender(() => {
+            const result = injectLoader(loader, 
+            // @ts-expect-error
+            () => {
+                const { files } = adjustedOptions();
+                return Array.isArray(files) ? [files] : files;
+            }, {
+                injector: assertedInjector,
+                extensions: (loader) => {
+                    const { extensions, path } = adjustedOptions();
+                    const { extension } = resultOptions();
+                    if (extension === 'webp' || extension === 'jpg' || extension === 'jpeg') {
+                        // @ts-expect-error - Gainmap requires a renderer
+                        loader.setRenderer(gl());
+                    }
+                    loader.setPath?.(path);
+                    if (extensions)
+                        extensions(loader);
+                },
+            });
+            //
+            autoEffect(() => {
+                const loaderResult = result();
+                if (!loaderResult)
+                    return;
+                untracked(() => {
+                    const { multiFile, extension, isCubeMap } = resultOptions();
+                    const { encoding } = adjustedOptions();
+                    // @ts-expect-error
+                    let textureResult = (multiFile ? loaderResult[0] : loaderResult);
+                    if (extension === 'jpg' || extension === 'jpeg' || extension === 'webp') {
+                        textureResult = textureResult.renderTarget?.texture;
+                    }
+                    textureResult.mapping = isCubeMap ? CubeReflectionMapping : EquirectangularReflectionMapping;
+                    if ('colorSpace' in textureResult)
+                        textureResult.colorSpace = encoding ?? isCubeMap ? 'srgb' : 'srgb-linear';
+                    else
+                        textureResult.encoding = encoding ?? isCubeMap ? sRGBEncoding : LinearEncoding;
+                    texture.set(textureResult);
+                });
+            });
+        });
+        return texture.asReadonly();
+    });
+}
+export class NgtsEnvironmentOptionsProvider {
+    constructor() {
+        this.options = input({});
+        this.autoEffect = injectAutoEffect();
+        this.store = injectNgtStore();
+        this.defaultScene = this.store.select('scene');
+        this.envConfig = computed(() => {
+            const { background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, } = this.options();
+            return {
+                background,
+                scene,
+                blur,
+                backgroundBlurriness,
+                backgroundIntensity,
+                backgroundRotation,
+                environmentIntensity,
+                environmentRotation,
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentOptionsProvider, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.3", type: NgtsEnvironmentOptionsProvider, isStandalone: true, inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentOptionsProvider, decorators: [{
+            type: Directive,
+            args: [{ standalone: true }]
+        }] });
+const defaultBackground = {
+    background: false,
+};
+export class NgtsEnvironmentMap {
+    constructor() {
+        this.options = input(defaultBackground, { transform: mergeInputs(defaultBackground) });
+        this.autoEffect = injectAutoEffect();
+        this.store = injectNgtStore();
+        this.defaultScene = this.store.select('scene');
+        this.envConfig = computed(() => {
+            const { background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, } = this.options();
+            return {
+                background,
+                scene,
+                blur,
+                backgroundBlurriness,
+                backgroundIntensity,
+                backgroundRotation,
+                environmentIntensity,
+                environmentRotation,
+            };
+        });
+        this.map = computed(() => this.options().map);
+        afterNextRender(() => {
+            this.autoEffect(() => {
+                const map = this.map();
+                if (!map)
+                    return;
+                const { background = false, scene, ...config } = this.envConfig();
+                return setEnvProps(background, scene, this.defaultScene(), map, config);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentMap, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.3", type: NgtsEnvironmentMap, isStandalone: true, selector: "ngts-environment-map", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentMap, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ngts-environment-map' }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentCube {
+    constructor() {
+        this.options = input(defaultBackground, { transform: mergeInputs(defaultBackground) });
+        this.autoEffect = injectAutoEffect();
+        this.store = injectNgtStore();
+        this.defaultScene = this.store.select('scene');
+        this.envConfig = computed(() => {
+            const { background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, } = this.options();
+            return {
+                background,
+                scene,
+                blur,
+                backgroundBlurriness,
+                backgroundIntensity,
+                backgroundRotation,
+                environmentIntensity,
+                environmentRotation,
+            };
+        });
+        this.environmentOptions = computed(() => {
+            const { encoding, preset, files, path, extensions } = this.options();
+            return { encoding, preset, files, path, extensions };
+        });
+        this.texture = injectEnvironment(this.environmentOptions);
+        afterNextRender(() => {
+            this.autoEffect(() => {
+                const texture = this.texture();
+                if (!texture)
+                    return;
+                const { background = false, scene, ...config } = this.envConfig();
+                return setEnvProps(background, scene, this.defaultScene(), texture, config);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentCube, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.3", type: NgtsEnvironmentCube, isStandalone: true, selector: "ngts-environment-cube", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentCube, decorators: [{
+            type: Directive,
+            args: [{ standalone: true, selector: 'ngts-environment-cube' }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentPortal {
+    constructor() {
+        this.defaultOptions = {
+            near: 1,
+            far: 1000,
+            resolution: 256,
+            frames: 1,
+            background: false,
+        };
+        this.options = input(this.defaultOptions, { transform: mergeInputs(this.defaultOptions) });
+        this.content = input.required();
+        this.autoEffect = injectAutoEffect();
+        this.store = injectNgtStore();
+        this.defaultScene = this.store.select('scene');
+        this.gl = this.store.select('gl');
+        this.camera = viewChild.required('cubeCamera');
+        this.map = computed(() => this.options().map);
+        this.extensions = computed(() => this.options().extensions);
+        this.files = computed(() => this.options().files);
+        this.path = computed(() => this.options().path);
+        this.preset = computed(() => this.options().preset);
+        this.envMapOptions = computed(() => ({ background: true, map: this.map(), extensions: this.extensions() }));
+        this.envCubeOptions = computed(() => ({
+            background: true,
+            files: this.files(),
+            preset: this.preset(),
+            extensions: this.extensions(),
+        }));
+        this.near = computed(() => this.options().near);
+        this.far = computed(() => this.options().far);
+        this.resolution = computed(() => this.options().resolution);
+        this.fbo = computed(() => {
+            const fbo = new WebGLCubeRenderTarget(this.resolution());
+            fbo.texture.type = HalfFloatType;
+            return fbo;
+        });
+        this.cameraArgs = computed(() => [this.near(), this.far(), this.fbo()]);
+        this.virtualScene = prepare(new Scene());
+        extend({ CubeCamera });
+        afterNextRender(() => {
+            this.autoEffect(() => {
+                const camera = this.camera();
+                if (!camera.nativeElement)
+                    return;
+                const [{ frames, background = false, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, }, gl, fbo, defaultScene,] = [this.options(), this.gl(), this.fbo(), this.defaultScene()];
+                if (frames === 1) {
+                    camera.nativeElement.update(gl, this.virtualScene);
+                }
+                return setEnvProps(background, scene, defaultScene, fbo.texture, {
+                    blur,
+                    backgroundBlurriness,
+                    backgroundIntensity,
+                    backgroundRotation,
+                    environmentIntensity,
+                    environmentRotation,
+                });
+            });
+        });
+        let count = 1;
+        injectNextBeforeRender(() => {
+            const frames = this.options().frames;
+            if (frames === Infinity || (frames != null && count < frames)) {
+                const camera = this.camera().nativeElement;
+                if (camera) {
+                    camera.update(this.gl(), this.virtualScene);
+                    count++;
+                }
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentPortal, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: NgtsEnvironmentPortal, isStandalone: true, selector: "ngts-environment-portal", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null }, content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "camera", first: true, predicate: ["cubeCamera"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-portal [container]="virtualScene">
+			<ng-container [ngTemplateOutlet]="content()" />
+
+			<ngt-cube-camera #cubeCamera *args="cameraArgs()" />
+
+			@if (files() || preset()) {
+				<ngts-environment-cube [options]="envCubeOptions()" />
+			} @else if (map()) {
+				<ngts-environment-map [options]="envMapOptions()" />
+			}
+		</ngt-portal>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["options"] }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }, { kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "camera", "state", "autoRender", "autoRenderPriority"] }, { 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: NgtsEnvironmentPortal, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-portal',
+                    standalone: true,
+                    template: `
+		<ngt-portal [container]="virtualScene">
+			<ng-container [ngTemplateOutlet]="content()" />
+
+			<ngt-cube-camera #cubeCamera *args="cameraArgs()" />
+
+			@if (files() || preset()) {
+				<ngts-environment-cube [options]="envCubeOptions()" />
+			} @else if (map()) {
+				<ngts-environment-map [options]="envMapOptions()" />
+			}
+		</ngt-portal>
+	`,
+                    imports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtArgs, NgtPortal, NgtPortalContent, NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironmentGround {
+    constructor() {
+        this.options = input({});
+        this.defaultTexture = injectEnvironment(this.options);
+        this.texture = computed(() => this.options().map || this.defaultTexture());
+        this.args = computed(() => [this.texture()]);
+        this.height = computed(() => this.options().ground?.height);
+        this.radius = computed(() => this.options().ground?.radius);
+        this.scale = computed(() => this.options().ground?.scale ?? 1000);
+        this.envMapOptions = computed(() => {
+            const { map: _, ...options } = this.options();
+            return Object.assign(options, { map: this.texture() });
+        });
+        extend({ GroundProjectedEnv });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentGround, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.3", type: NgtsEnvironmentGround, isStandalone: true, selector: "ngts-environment-ground", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		<ngts-environment-map [options]="envMapOptions()" />
+		<ngt-ground-projected-env *args="args()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"] }, { kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironmentGround, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment-ground',
+                    standalone: true,
+                    template: `
+		<ngts-environment-map [options]="envMapOptions()" />
+		<ngt-ground-projected-env *args="args()" [scale]="scale()" [height]="height()" [radius]="radius()" />
+	`,
+                    imports: [NgtsEnvironmentMap, NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+export class NgtsEnvironment {
+    constructor() {
+        this.optionsProvider = inject(NgtsEnvironmentOptionsProvider);
+        this.content = contentChild(NgtsContent, { read: TemplateRef });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironment, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: NgtsEnvironment, isStandalone: true, selector: "ngts-environment", queries: [{ propertyName: "content", first: true, predicate: NgtsContent, descendants: true, read: TemplateRef, isSignal: true }], hostDirectives: [{ directive: NgtsEnvironmentOptionsProvider, inputs: ["options", "options"] }], ngImport: i0, template: `
+		@if (optionsProvider.options().ground) {
+			<ngts-environment-ground [options]="optionsProvider.options()" />
+		} @else if (optionsProvider.options().map) {
+			<ngts-environment-map [options]="optionsProvider.options()" />
+		} @else if (content()) {
+			<ngts-environment-portal [options]="optionsProvider.options()" [content]="$any(content())" />
+		} @else {
+			<ngts-environment-cube [options]="optionsProvider.options()" />
+		}
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtsEnvironmentCube, selector: "ngts-environment-cube", inputs: ["options"] }, { kind: "directive", type: NgtsEnvironmentMap, selector: "ngts-environment-map", inputs: ["options"] }, { kind: "component", type: NgtsEnvironmentPortal, selector: "ngts-environment-portal", inputs: ["options", "content"] }, { kind: "component", type: NgtsEnvironmentGround, selector: "ngts-environment-ground", inputs: ["options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsEnvironment, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-environment',
+                    standalone: true,
+                    template: `
+		@if (optionsProvider.options().ground) {
+			<ngts-environment-ground [options]="optionsProvider.options()" />
+		} @else if (optionsProvider.options().map) {
+			<ngts-environment-map [options]="optionsProvider.options()" />
+		} @else if (content()) {
+			<ngts-environment-portal [options]="optionsProvider.options()" [content]="$any(content())" />
+		} @else {
+			<ngts-environment-cube [options]="optionsProvider.options()" />
+		}
+	`,
+                    imports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtsEnvironmentPortal, NgtsEnvironmentGround],
+                    hostDirectives: [{ directive: NgtsEnvironmentOptionsProvider, inputs: ['options'] }],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EACN,sBAAsB,EACtB,uBAAuB,EACvB,SAAS,EACT,SAAS,EAET,QAAQ,EACR,WAAW,EACX,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,KAAK,EACL,MAAM,EACN,SAAS,EACT,SAAS,GACT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EACN,OAAO,EACP,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,MAAM,EACN,YAAY,EACZ,sBAAsB,EACtB,cAAc,EACd,EAAE,EACF,OAAO,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,WAAW,EAAmB,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACrG,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EACN,UAAU,EACV,qBAAqB,EAErB,iBAAiB,EACjB,gCAAgC,EAEhC,aAAa,EAEb,KAAK,EAEL,qBAAqB,GACrB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;;AAEzE,MAAM,YAAY,GAAG,2FAA2F,CAAC;AAEjH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IAClC,SAAS,EAAE,gBAAgB;IAC3B,IAAI,EAAE,wBAAwB;IAC9B,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,qBAAqB;IAC7B,KAAK,EAAE,2BAA2B;IAClC,KAAK,EAAE,wBAAwB;IAC/B,IAAI,EAAE,qBAAqB;IAC3B,MAAM,EAAE,wBAAwB;IAChC,MAAM,EAAE,sBAAsB;IAC9B,SAAS,EAAE,2BAA2B;CACtC,CAAC;AAIF,SAAS,YAAY,CAAC,KAAgC;IACrD,OAAO,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC;AACpD,CAAC;AAED,SAAS,WAAW,CACnB,UAA4B,EAC5B,KAA4C,EAC5C,YAAmB,EACnB,OAAgB,EAChB,aAA8C,EAAE;IAEhD,UAAU,CAAC,oBAAoB,KAAK,UAAU,CAAC,IAAI,IAAI,CAAC,CAAC;IACzD,UAAU,CAAC,mBAAmB,KAAK,CAAC,CAAC;IACrC,+DAA+D;IAC/D,UAAU,CAAC,kBAAkB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,UAAU,CAAC,oBAAoB,KAAK,CAAC,CAAC;IACtC,+DAA+D;IAC/D,UAAU,CAAC,mBAAmB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAE7C,MAAM,MAAM,GAAG,YAAY,CAAC,KAAK,IAAI,YAAY,CAAC,CAAC;IACnD,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC;IAChC,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC;IAClC,MAAM,aAAa,GAAG;QACrB,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;QACjD,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;QAC/C,kBAAkB,EAAE,MAAM,CAAC,kBAAkB,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACrE,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;QACjD,mBAAmB,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KACvE,CAAC;IAEF,IAAI,UAAU,KAAK,MAAM;QAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC;IACxD,IAAI,UAAU;QAAE,MAAM,CAAC,UAAU,GAAG,OAAO,CAAC;IAC5C,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAE/B,OAAO,GAAG,EAAE;QACX,IAAI,UAAU,KAAK,MAAM;YAAE,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC;QACvD,IAAI,UAAU;YAAE,MAAM,CAAC,UAAU,GAAG,KAAK,CAAC;QAC1C,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACnC,CAAC,CAAC;AACH,CAAC;AAUD,MAAM,UAAU,iBAAiB,CAChC,UAAuD,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EACjE,EAAE,QAAQ,KAA8B,EAAE;IAE1C,OAAO,cAAc,CAAC,iBAAiB,EAAE,QAAQ,EAAE,GAAG,EAAE;QACvD,MAAM,eAAe,GAAG,QAAQ,CAAC,GAAG,EAAE;YACrC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC;YAE9D,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;gBACnB,KAAK,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;YAC5E,CAAC;YAED,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;gBAClB,IAAI,GAAG,EAAE,CAAC;YACX,CAAC;YAED,IAAI,MAAM,EAAE,CAAC;gBACZ,IAAI,CAAC,CAAC,MAAM,IAAI,mBAAmB,CAAC;oBACnC,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC1F,KAAK,GAAG,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBACpC,IAAI,GAAG,YAAY,CAAC;YACrB,CAAC;YAED,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,MAAM,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;YACnC,MAAM,EAAE,KAAK,EAAE,GAAG,eAAe,EAAE,CAAC;YACpC,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAEvC,MAAM,SAAS,GAAG,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;YAClD,MAAM,UAAU,GAAG,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;YAClG,MAAM,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAEhD,MAAM,SAAS,GAAG,SAAS;gBAC1B,CAAC,CAAC,MAAM;gBACR,CAAC,CAAC,UAAU;oBACX,CAAC,CAAC,MAAM;oBACR,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,sBAAsB,CAAC;wBAC9C,CAAC,CAAC,KAAK;wBACP,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,sBAAsB,CAAC;4BAC9C,CAAC,CAAC,KAAK;4BACP,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,iBAAiB,CAAC;gCACzC,CAAC,CAAC,KAAK;gCACP,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,CAAC;YACvE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC5B,MAAM,EAAE,SAAS,EAAE,GAAG,aAAa,EAAE,CAAC;YACtC,MAAM,MAAM,GACX,SAAS,KAAK,MAAM;gBACnB,CAAC,CAAC,iBAAiB;gBACnB,CAAC,CAAC,SAAS,KAAK,KAAK;oBACpB,CAAC,CAAC,UAAU;oBACZ,CAAC,CAAC,SAAS,KAAK,KAAK;wBACpB,CAAC,CAAC,SAAS;wBACX,CAAC,CAAC,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM;4BAC5C,CAAC,CAAE,YAAyC;4BAC5C,CAAC,CAAC,SAAS,KAAK,MAAM;gCACrB,CAAC,CAAE,aAA0C;gCAC7C,CAAC,CAAC,IAAI,CAAC;YAEb,IAAI,CAAC,MAAM,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,kDAAkD,GAAG,SAAS,CAAC,CAAC;YACjF,CAAC;YAED,OAAO,MAAuB,CAAC;QAChC,CAAC,CAAC,CAAC;QAEH,MAAM,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,UAAU,GAAG,gBAAgB,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,cAAc,EAAE,CAAC;QAC/B,MAAM,EAAE,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE9B,MAAM,OAAO,GAAG,MAAM,CAA+B,IAAI,CAAC,CAAC;QAC3D,eAAe,CAAC,GAAG,EAAE;YACpB,MAAM,MAAM,GAAG,YAAY,CAC1B,MAAM;YACN,mBAAmB;YACnB,GAAG,EAAE;gBACJ,MAAM,EAAE,KAAK,EAAE,GAAG,eAAe,EAAE,CAAC;gBACpC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;YAC/C,CAAC,EACD;gBACC,QAAQ,EAAE,gBAAgB;gBAC1B,UAAU,EAAE,CAAC,MAAM,EAAE,EAAE;oBACtB,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,eAAe,EAAE,CAAC;oBAC/C,MAAM,EAAE,SAAS,EAAE,GAAG,aAAa,EAAE,CAAC;oBACtC,IAAI,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;wBACzE,iDAAiD;wBACjD,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC,CAAC;oBAC1B,CAAC;oBAED,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;oBACvB,IAAI,UAAU;wBAAE,UAAU,CAAC,MAAM,CAAC,CAAC;gBACpC,CAAC;aACD,CACD,CAAC;YACF,EAAE;YACF,UAAU,CAAC,GAAG,EAAE;gBACf,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC;gBAC9B,IAAI,CAAC,YAAY;oBAAE,OAAO;gBAE1B,SAAS,CAAC,GAAG,EAAE;oBACd,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,aAAa,EAAE,CAAC;oBAC5D,MAAM,EAAE,QAAQ,EAAE,GAAG,eAAe,EAAE,CAAC;oBAEvC,mBAAmB;oBACnB,IAAI,aAAa,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAA0B,CAAC;oBAE1F,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,IAAI,SAAS,KAAK,MAAM,EAAE,CAAC;wBACzE,aAAa,GAAI,aAAqB,CAAC,YAAY,EAAE,OAAO,CAAC;oBAC9D,CAAC;oBAED,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,gCAAgC,CAAC;oBAE7F,IAAI,YAAY,IAAI,aAAa;wBAC/B,aAAqB,CAAC,UAAU,GAAG,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC;;wBAC9E,aAAqB,CAAC,QAAQ,GAAG,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC;oBAE7F,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;gBAC5B,CAAC,CAAC,CAAC;YACJ,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC,UAAU,EAAE,CAAC;IAC7B,CAAC,CAAC,CAAC;AACJ,CAAC;AAwBD,MAAM,OAAO,8BAA8B;IAD3C;QAEC,YAAO,GAAG,KAAK,CAAC,EAA4B,CAAC,CAAC;QAE9C,eAAU,GAAG,gBAAgB,EAAE,CAAC;QAChC,UAAK,GAAG,cAAc,EAAE,CAAC;QACzB,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE1C,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE;YACzB,MAAM,EACL,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,IAAI,EACJ,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,GACnB,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAEnB,OAAO;gBACN,UAAU;gBACV,KAAK;gBACL,IAAI;gBACJ,oBAAoB;gBACpB,mBAAmB;gBACnB,kBAAkB;gBAClB,oBAAoB;gBACpB,mBAAmB;aACnB,CAAC;QACH,CAAC,CAAC,CAAC;KACH;8GA9BY,8BAA8B;kGAA9B,8BAA8B;;2FAA9B,8BAA8B;kBAD1C,SAAS;mBAAC,EAAE,UAAU,EAAE,IAAI,EAAE;;AAiC/B,MAAM,iBAAiB,GAA2B;IACjD,UAAU,EAAE,KAAK;CACjB,CAAC;AAGF,MAAM,OAAO,kBAAkB;IAiC9B;QAhCA,YAAO,GAAG,KAAK,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;QAElF,eAAU,GAAG,gBAAgB,EAAE,CAAC;QAChC,UAAK,GAAG,cAAc,EAAE,CAAC;QACzB,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE1C,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE;YACzB,MAAM,EACL,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,IAAI,EACJ,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,GACnB,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAEnB,OAAO;gBACN,UAAU;gBACV,KAAK;gBACL,IAAI;gBACJ,oBAAoB;gBACpB,mBAAmB;gBACnB,kBAAkB;gBAClB,oBAAoB;gBACpB,mBAAmB;aACnB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;QAGxC,eAAe,CAAC,GAAG,EAAE;YACpB,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;gBACpB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACvB,IAAI,CAAC,GAAG;oBAAE,OAAO;gBACjB,MAAM,EAAE,UAAU,GAAG,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAClE,OAAO,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;YACzE,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;8GA1CW,kBAAkB;kGAAlB,kBAAkB;;2FAAlB,kBAAkB;kBAD9B,SAAS;mBAAC,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,sBAAsB,EAAE;;AA+CjE,MAAM,OAAO,mBAAmB;IAqC/B;QApCA,YAAO,GAAG,KAAK,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;QAElF,eAAU,GAAG,gBAAgB,EAAE,CAAC;QAChC,UAAK,GAAG,cAAc,EAAE,CAAC;QACzB,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE1C,cAAS,GAAG,QAAQ,CAAC,GAAG,EAAE;YACzB,MAAM,EACL,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,IAAI,EACJ,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,GACnB,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAEnB,OAAO;gBACN,UAAU;gBACV,KAAK;gBACL,IAAI;gBACJ,oBAAoB;gBACpB,mBAAmB;gBACnB,kBAAkB;gBAClB,oBAAoB;gBACpB,mBAAmB;aACnB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,uBAAkB,GAAG,QAAQ,CAAC,GAAG,EAAE;YAClC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YACrE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;QACH,YAAO,GAAG,iBAAiB,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAGpD,eAAe,CAAC,GAAG,EAAE;YACpB,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;gBACpB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC/B,IAAI,CAAC,OAAO;oBAAE,OAAO;gBACrB,MAAM,EAAE,UAAU,GAAG,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAClE,OAAO,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAC7E,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACJ,CAAC;8GA9CW,mBAAmB;kGAAnB,mBAAmB;;2FAAnB,mBAAmB;kBAD/B,SAAS;mBAAC,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,uBAAuB,EAAE;;AAsElE,MAAM,OAAO,qBAAqB;IA6CjC;QA5CQ,mBAAc,GAA2B;YAChD,IAAI,EAAE,CAAC;YACP,GAAG,EAAE,IAAI;YACT,UAAU,EAAE,GAAG;YACf,MAAM,EAAE,CAAC;YACT,UAAU,EAAE,KAAK;SACjB,CAAC;QACF,YAAO,GAAG,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QACtF,YAAO,GAAG,KAAK,CAAC,QAAQ,EAAwB,CAAC;QAEjD,eAAU,GAAG,gBAAgB,EAAE,CAAC;QAChC,UAAK,GAAG,cAAc,EAAE,CAAC;QACzB,iBAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC1C,OAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE7B,WAAM,GAAG,SAAS,CAAC,QAAQ,CAAyB,YAAY,CAAC,CAAC;QAElE,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;QACzC,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;QACvD,UAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QAC7C,SAAI,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAC3C,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;QAE/C,kBAAa,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC;QACvG,mBAAc,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;YAChC,UAAU,EAAE,IAAI;YAChB,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE;YACnB,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE;SAC7B,CAAC,CAAC,CAAC;QAEI,SAAI,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAC3C,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;QACzC,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;QACvD,QAAG,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC3B,MAAM,GAAG,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACzD,GAAG,CAAC,OAAO,CAAC,IAAI,GAAG,aAAa,CAAC;YACjC,OAAO,GAAG,CAAC;QACZ,CAAC,CAAC,CAAC;QAEH,eAAU,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QAEnE,iBAAY,GAAG,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;QAGnC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QACvB,eAAe,CAAC,GAAG,EAAE;YACpB,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE;gBACpB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;gBAC7B,IAAI,CAAC,MAAM,CAAC,aAAa;oBAAE,OAAO;gBAElC,MAAM,CACL,EACC,MAAM,EACN,UAAU,GAAG,KAAK,EAClB,KAAK,EACL,IAAI,EACJ,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,GACnB,EACD,EAAE,EACF,GAAG,EACH,YAAY,EACZ,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;gBACjE,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;oBAClB,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;gBACpD,CAAC;gBACD,OAAO,WAAW,CAAC,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,CAAC,OAAO,EAAE;oBAChE,IAAI;oBACJ,oBAAoB;oBACpB,mBAAmB;oBACnB,kBAAkB;oBAClB,oBAAoB;oBACpB,mBAAmB;iBACnB,CAAC,CAAC;YACJ,CAAC,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,sBAAsB,CAAC,GAAG,EAAE;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC;YACrC,IAAI,MAAM,KAAK,QAAQ,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC;gBAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,aAAa,CAAC;gBAC3C,IAAI,MAAM,EAAE,CAAC;oBACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;oBAC5C,KAAK,EAAE,CAAC;gBACT,CAAC;YACF,CAAC;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;8GA7FW,qBAAqB;kGAArB,qBAAqB,gdAjBvB;;;;;;;;;;;;EAYT,4DAhEW,mBAAmB,uFA9CnB,kBAAkB,sFA+GqB,OAAO,gFAAE,SAAS,qIAAoB,gBAAgB;;2FAI7F,qBAAqB;kBApBjC,SAAS;mBAAC;oBACV,QAAQ,EAAE,yBAAyB;oBACnC,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;;;EAYT;oBACD,OAAO,EAAE,CAAC,mBAAmB,EAAE,kBAAkB,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,CAAC;oBAC1G,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAC/C;;AA4GD,MAAM,OAAO,qBAAqB;IAgBjC;QAfA,YAAO,GAAG,KAAK,CAAC,EAA4B,CAAC,CAAC;QAEtC,mBAAc,GAAG,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACjD,YAAO,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QAE9E,SAAI,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;QACxC,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAE,IAAI,CAAC,OAAO,EAAE,CAAC,MAAc,EAAE,MAAM,CAAC,CAAC;QAChE,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAE,IAAI,CAAC,OAAO,EAAE,CAAC,MAAc,EAAE,MAAM,CAAC,CAAC;QAChE,UAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAE,IAAI,CAAC,OAAO,EAAE,CAAC,MAAc,EAAE,KAAK,IAAI,IAAI,CAAC,CAAC;QAEtE,kBAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC7B,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC9C,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,EAAE,CAA2B,CAAC;QAClF,CAAC,CAAC,CAAC;QAGF,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAC;IAChC,CAAC;8GAlBW,qBAAqB;kGAArB,qBAAqB,6NARvB;;;EAGT,4DAzNW,kBAAkB,sFA0NA,OAAO;;2FAIzB,qBAAqB;kBAXjC,SAAS;mBAAC;oBACV,QAAQ,EAAE,yBAAyB;oBACnC,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;EAGT;oBACD,OAAO,EAAE,CAAC,kBAAkB,EAAE,OAAO,CAAC;oBACtC,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAC/C;;AAyCD,MAAM,OAAO,eAAe;IAnB5B;QAoBC,oBAAe,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC;QACzD,YAAO,GAAG,YAAY,CAAC,WAAW,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;KAC3D;8GAHY,eAAe;kGAAf,eAAe,iHAEJ,WAAW,2BAAU,WAAW,mDA7S3C,8BAA8B,6DA2RhC;;;;;;;;;;EAUT,4DAlNW,mBAAmB,uFA9CnB,kBAAkB,sFAmHlB,qBAAqB,oGA2GrB,qBAAqB;;2FAwCrB,eAAe;kBAnB3B,SAAS;mBAAC;oBACV,QAAQ,EAAE,kBAAkB;oBAC5B,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE;;;;;;;;;;EAUT;oBACD,OAAO,EAAE,CAAC,mBAAmB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,qBAAqB,CAAC;oBAChG,cAAc,EAAE,CAAC,EAAE,SAAS,EAAE,8BAA8B,EAAE,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;oBACpF,OAAO,EAAE,CAAC,sBAAsB,CAAC;oBACjC,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAC/C","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tChangeDetectionStrategy,\n\tComponent,\n\tDirective,\n\tElementRef,\n\tInjector,\n\tTemplateRef,\n\tafterNextRender,\n\tcomputed,\n\tcontentChild,\n\tinject,\n\tinput,\n\tsignal,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { GainMapLoader, HDRJPGLoader } from '@monogrid/gainmap-js';\nimport {\n\tNgtArgs,\n\tNgtPortal,\n\tNgtPortalContent,\n\tapplyProps,\n\textend,\n\tinjectLoader,\n\tinjectNextBeforeRender,\n\tinjectNgtStore,\n\tis,\n\tprepare,\n} from 'angular-three';\nimport { LinearEncoding, NgtsContent, TextureEncoding, sRGBEncoding } from 'angular-three-soba/misc';\nimport { assertInjector } from 'ngxtension/assert-injector';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport {\n\tCubeCamera,\n\tCubeReflectionMapping,\n\tCubeTexture,\n\tCubeTextureLoader,\n\tEquirectangularReflectionMapping,\n\tEuler,\n\tHalfFloatType,\n\tLoader,\n\tScene,\n\tTexture,\n\tWebGLCubeRenderTarget,\n} from 'three';\nimport { EXRLoader, GroundProjectedEnv, RGBELoader } from 'three-stdlib';\n\nconst CUBEMAP_ROOT = 'https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/';\n\nexport const ENVIRONMENT_PRESETS = {\n\tapartment: 'lebombo_1k.hdr',\n\tcity: 'potsdamer_platz_1k.hdr',\n\tdawn: 'kiara_1_dawn_1k.hdr',\n\tforest: 'forest_slope_1k.hdr',\n\tlobby: 'st_fagans_interior_1k.hdr',\n\tnight: 'dikhololo_night_1k.hdr',\n\tpark: 'rooitou_park_1k.hdr',\n\tstudio: 'studio_small_03_1k.hdr',\n\tsunset: 'venice_sunset_1k.hdr',\n\twarehouse: 'empty_warehouse_01_1k.hdr',\n};\n\nexport type NgtsEnvironmentPresets = keyof typeof ENVIRONMENT_PRESETS;\n\nfunction resolveScene(scene: Scene | ElementRef<Scene>) {\n\treturn is.ref(scene) ? scene.nativeElement : scene;\n}\n\nfunction setEnvProps(\n\tbackground: boolean | 'only',\n\tscene: Scene | ElementRef<Scene> | undefined,\n\tdefaultScene: Scene,\n\ttexture: Texture,\n\tsceneProps: Partial<NgtsEnvironmentOptions> = {},\n) {\n\tsceneProps.backgroundBlurriness ??= sceneProps.blur ?? 0;\n\tsceneProps.backgroundIntensity ??= 1;\n\t// @ts-expect-error - it's ok, we're sending through applyProps\n\tsceneProps.backgroundRotation ??= [0, 0, 0];\n\tsceneProps.environmentIntensity ??= 1;\n\t// @ts-expect-error - it's ok, we're sending through applyProps\n\tsceneProps.environmentRotation ??= [0, 0, 0];\n\n\tconst target = resolveScene(scene || defaultScene);\n\tconst oldbg = target.background;\n\tconst oldenv = target.environment;\n\tconst oldSceneProps = {\n\t\tbackgroundBlurriness: target.backgroundBlurriness,\n\t\tbackgroundIntensity: target.backgroundIntensity,\n\t\tbackgroundRotation: target.backgroundRotation?.clone?.() ?? [0, 0, 0],\n\t\tenvironmentIntensity: target.environmentIntensity,\n\t\tenvironmentRotation: target.environmentRotation?.clone?.() ?? [0, 0, 0],\n\t};\n\n\tif (background !== 'only') target.environment = texture;\n\tif (background) target.background = texture;\n\tapplyProps(target, sceneProps);\n\n\treturn () => {\n\t\tif (background !== 'only') target.environment = oldenv;\n\t\tif (background) target.background = oldbg;\n\t\tapplyProps(target, oldSceneProps);\n\t};\n}\n\nexport interface NgtsInjectEnvironmentOptions {\n\tfiles: string | string[];\n\tpath: string;\n\tpreset?: NgtsEnvironmentPresets;\n\textensions?: (loader: Loader) => void;\n\tencoding?: TextureEncoding;\n}\n\nexport function injectEnvironment(\n\toptions: () => Partial<NgtsInjectEnvironmentOptions> = () => ({}),\n\t{ injector }: { injector?: Injector } = {},\n) {\n\treturn assertInjector(injectEnvironment, injector, () => {\n\t\tconst adjustedOptions = computed(() => {\n\t\t\tlet { files, path, preset, extensions, encoding } = options();\n\n\t\t\tif (files == null) {\n\t\t\t\tfiles = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];\n\t\t\t}\n\n\t\t\tif (path == null) {\n\t\t\t\tpath = '';\n\t\t\t}\n\n\t\t\tif (preset) {\n\t\t\t\tif (!(preset in ENVIRONMENT_PRESETS))\n\t\t\t\t\tthrow new Error('Preset must be one of: ' + Object.keys(ENVIRONMENT_PRESETS).join(', '));\n\t\t\t\tfiles = ENVIRONMENT_PRESETS[preset];\n\t\t\t\tpath = CUBEMAP_ROOT;\n\t\t\t}\n\n\t\t\treturn { files, preset, encoding, path, extensions };\n\t\t});\n\n\t\tconst resultOptions = computed(() => {\n\t\t\tconst { files } = adjustedOptions();\n\t\t\tconst multiFile = Array.isArray(files);\n\n\t\t\tconst isCubeMap = multiFile && files.length === 6;\n\t\t\tconst isGainmain = multiFile && files.length === 3 && files.some((file) => file.endsWith('json'));\n\t\t\tconst firstEntry = multiFile ? files[0] : files;\n\n\t\t\tconst extension = isCubeMap\n\t\t\t\t? 'cube'\n\t\t\t\t: isGainmain\n\t\t\t\t\t? 'webp'\n\t\t\t\t\t: firstEntry.startsWith('data:application/exr')\n\t\t\t\t\t\t? 'exr'\n\t\t\t\t\t\t: firstEntry.startsWith('data:application/hdr')\n\t\t\t\t\t\t\t? 'hdr'\n\t\t\t\t\t\t\t: firstEntry.startsWith('data:image/jpeg')\n\t\t\t\t\t\t\t\t? 'jpg'\n\t\t\t\t\t\t\t\t: firstEntry.split('.').pop()?.split('?')?.shift()?.toLowerCase();\n\t\t\treturn { multiFile, extension, isCubeMap };\n\t\t});\n\n\t\tconst loader = computed(() => {\n\t\t\tconst { extension } = resultOptions();\n\t\t\tconst loader =\n\t\t\t\textension === 'cube'\n\t\t\t\t\t? CubeTextureLoader\n\t\t\t\t\t: extension === 'hdr'\n\t\t\t\t\t\t? RGBELoader\n\t\t\t\t\t\t: extension === 'exr'\n\t\t\t\t\t\t\t? EXRLoader\n\t\t\t\t\t\t\t: extension === 'jpg' || extension === 'jpeg'\n\t\t\t\t\t\t\t\t? (HDRJPGLoader as unknown as typeof Loader)\n\t\t\t\t\t\t\t\t: extension === 'webp'\n\t\t\t\t\t\t\t\t\t? (GainMapLoader as unknown as typeof Loader)\n\t\t\t\t\t\t\t\t\t: null;\n\n\t\t\tif (!loader) {\n\t\t\t\tthrow new Error('injectEnvironment: Unrecognized file extension: ' + extension);\n\t\t\t}\n\n\t\t\treturn loader as typeof Loader;\n\t\t});\n\n\t\tconst assertedInjector = inject(Injector);\n\t\tconst autoEffect = injectAutoEffect();\n\t\tconst store = injectNgtStore();\n\t\tconst gl = store.select('gl');\n\n\t\tconst texture = signal<Texture | CubeTexture | null>(null);\n\t\tafterNextRender(() => {\n\t\t\tconst result = injectLoader(\n\t\t\t\tloader,\n\t\t\t\t// @ts-expect-error\n\t\t\t\t() => {\n\t\t\t\t\tconst { files } = adjustedOptions();\n\t\t\t\t\treturn Array.isArray(files) ? [files] : files;\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tinjector: assertedInjector,\n\t\t\t\t\textensions: (loader) => {\n\t\t\t\t\t\tconst { extensions, path } = adjustedOptions();\n\t\t\t\t\t\tconst { extension } = resultOptions();\n\t\t\t\t\t\tif (extension === 'webp' || extension === 'jpg' || extension === 'jpeg') {\n\t\t\t\t\t\t\t// @ts-expect-error - Gainmap requires a renderer\n\t\t\t\t\t\t\tloader.setRenderer(gl());\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tloader.setPath?.(path);\n\t\t\t\t\t\tif (extensions) extensions(loader);\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t);\n\t\t\t//\n\t\t\tautoEffect(() => {\n\t\t\t\tconst loaderResult = result();\n\t\t\t\tif (!loaderResult) return;\n\n\t\t\t\tuntracked(() => {\n\t\t\t\t\tconst { multiFile, extension, isCubeMap } = resultOptions();\n\t\t\t\t\tconst { encoding } = adjustedOptions();\n\n\t\t\t\t\t// @ts-expect-error\n\t\t\t\t\tlet textureResult = (multiFile ? loaderResult[0] : loaderResult) as Texture | CubeTexture;\n\n\t\t\t\t\tif (extension === 'jpg' || extension === 'jpeg' || extension === 'webp') {\n\t\t\t\t\t\ttextureResult = (textureResult as any).renderTarget?.texture;\n\t\t\t\t\t}\n\n\t\t\t\t\ttextureResult.mapping = isCubeMap ? CubeReflectionMapping : EquirectangularReflectionMapping;\n\n\t\t\t\t\tif ('colorSpace' in textureResult)\n\t\t\t\t\t\t(textureResult as any).colorSpace = encoding ?? isCubeMap ? 'srgb' : 'srgb-linear';\n\t\t\t\t\telse (textureResult as any).encoding = encoding ?? isCubeMap ? sRGBEncoding : LinearEncoding;\n\n\t\t\t\t\ttexture.set(textureResult);\n\t\t\t\t});\n\t\t\t});\n\t\t});\n\n\t\treturn texture.asReadonly();\n\t});\n}\n\nexport interface NgtsEnvironmentOptions extends Partial<NgtsInjectEnvironmentOptions> {\n\tframes?: number;\n\tnear?: number;\n\tfar?: number;\n\tresolution?: number;\n\tbackground?: boolean | 'only';\n\n\t/** deprecated, use backgroundBlurriness */\n\tblur?: number;\n\tbackgroundBlurriness?: number;\n\tbackgroundIntensity?: number;\n\tbackgroundRotation?: Euler;\n\tenvironmentIntensity?: number;\n\tenvironmentRotation?: Euler;\n\n\tmap?: Texture;\n\tpreset?: NgtsEnvironmentPresets;\n\tscene?: Scene | ElementRef<Scene>;\n\tground?: boolean | { radius?: number; height?: number; scale?: number };\n}\n\n@Directive({ standalone: true })\nexport class NgtsEnvironmentOptionsProvider {\n\toptions = input({} as NgtsEnvironmentOptions);\n\n\tautoEffect = injectAutoEffect();\n\tstore = injectNgtStore();\n\tdefaultScene = this.store.select('scene');\n\n\tenvConfig = computed(() => {\n\t\tconst {\n\t\t\tbackground = false,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t} = this.options();\n\n\t\treturn {\n\t\t\tbackground,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t};\n\t});\n}\n\nconst defaultBackground: NgtsEnvironmentOptions = {\n\tbackground: false,\n};\n\n@Directive({ standalone: true, selector: 'ngts-environment-map' })\nexport class NgtsEnvironmentMap {\n\toptions = input(defaultBackground, { transform: mergeInputs(defaultBackground) });\n\n\tautoEffect = injectAutoEffect();\n\tstore = injectNgtStore();\n\tdefaultScene = this.store.select('scene');\n\n\tenvConfig = computed(() => {\n\t\tconst {\n\t\t\tbackground = false,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t} = this.options();\n\n\t\treturn {\n\t\t\tbackground,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t};\n\t});\n\n\tmap = computed(() => this.options().map);\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tconst map = this.map();\n\t\t\t\tif (!map) return;\n\t\t\t\tconst { background = false, scene, ...config } = this.envConfig();\n\t\t\t\treturn setEnvProps(background, scene, this.defaultScene(), map, config);\n\t\t\t});\n\t\t});\n\t}\n}\n\n@Directive({ standalone: true, selector: 'ngts-environment-cube' })\nexport class NgtsEnvironmentCube {\n\toptions = input(defaultBackground, { transform: mergeInputs(defaultBackground) });\n\n\tautoEffect = injectAutoEffect();\n\tstore = injectNgtStore();\n\tdefaultScene = this.store.select('scene');\n\n\tenvConfig = computed(() => {\n\t\tconst {\n\t\t\tbackground = false,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t} = this.options();\n\n\t\treturn {\n\t\t\tbackground,\n\t\t\tscene,\n\t\t\tblur,\n\t\t\tbackgroundBlurriness,\n\t\t\tbackgroundIntensity,\n\t\t\tbackgroundRotation,\n\t\t\tenvironmentIntensity,\n\t\t\tenvironmentRotation,\n\t\t};\n\t});\n\n\tenvironmentOptions = computed(() => {\n\t\tconst { encoding, preset, files, path, extensions } = this.options();\n\t\treturn { encoding, preset, files, path, extensions };\n\t});\n\ttexture = injectEnvironment(this.environmentOptions);\n\n\tconstructor() {\n\t\tafterNextRender(() => {\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tconst texture = this.texture();\n\t\t\t\tif (!texture) return;\n\t\t\t\tconst { background = false, scene, ...config } = this.envConfig();\n\t\t\t\treturn setEnvProps(background, scene, this.defaultScene(), texture, config);\n\t\t\t});\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment-portal',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal [container]=\"virtualScene\">\n\t\t\t<ng-container [ngTemplateOutlet]=\"content()\" />\n\n\t\t\t<ngt-cube-camera #cubeCamera *args=\"cameraArgs()\" />\n\n\t\t\t@if (files() || preset()) {\n\t\t\t\t<ngts-environment-cube [options]=\"envCubeOptions()\" />\n\t\t\t} @else if (map()) {\n\t\t\t\t<ngts-environment-map [options]=\"envMapOptions()\" />\n\t\t\t}\n\t\t</ngt-portal>\n\t`,\n\timports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtArgs, NgtPortal, NgtPortalContent, NgTemplateOutlet],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironmentPortal {\n\tprivate defaultOptions: NgtsEnvironmentOptions = {\n\t\tnear: 1,\n\t\tfar: 1000,\n\t\tresolution: 256,\n\t\tframes: 1,\n\t\tbackground: false,\n\t};\n\toptions = input(this.defaultOptions, { transform: mergeInputs(this.defaultOptions) });\n\tcontent = input.required<TemplateRef<unknown>>();\n\n\tautoEffect = injectAutoEffect();\n\tstore = injectNgtStore();\n\tdefaultScene = this.store.select('scene');\n\tgl = this.store.select('gl');\n\n\tcamera = viewChild.required<ElementRef<CubeCamera>>('cubeCamera');\n\n\tmap = computed(() => this.options().map);\n\textensions = computed(() => this.options().extensions);\n\tfiles = computed(() => this.options().files);\n\tpath = computed(() => this.options().path);\n\tpreset = computed(() => this.options().preset);\n\n\tenvMapOptions = computed(() => ({ background: true, map: this.map(), extensions: this.extensions() }));\n\tenvCubeOptions = computed(() => ({\n\t\tbackground: true,\n\t\tfiles: this.files(),\n\t\tpreset: this.preset(),\n\t\textensions: this.extensions(),\n\t}));\n\n\tprivate near = computed(() => this.options().near);\n\tprivate far = computed(() => this.options().far);\n\tprivate resolution = computed(() => this.options().resolution);\n\tprivate fbo = computed(() => {\n\t\tconst fbo = new WebGLCubeRenderTarget(this.resolution());\n\t\tfbo.texture.type = HalfFloatType;\n\t\treturn fbo;\n\t});\n\n\tcameraArgs = computed(() => [this.near(), this.far(), this.fbo()]);\n\n\tvirtualScene = prepare(new Scene());\n\n\tconstructor() {\n\t\textend({ CubeCamera });\n\t\tafterNextRender(() => {\n\t\t\tthis.autoEffect(() => {\n\t\t\t\tconst camera = this.camera();\n\t\t\t\tif (!camera.nativeElement) return;\n\n\t\t\t\tconst [\n\t\t\t\t\t{\n\t\t\t\t\t\tframes,\n\t\t\t\t\t\tbackground = false,\n\t\t\t\t\t\tscene,\n\t\t\t\t\t\tblur,\n\t\t\t\t\t\tbackgroundBlurriness,\n\t\t\t\t\t\tbackgroundIntensity,\n\t\t\t\t\t\tbackgroundRotation,\n\t\t\t\t\t\tenvironmentIntensity,\n\t\t\t\t\t\tenvironmentRotation,\n\t\t\t\t\t},\n\t\t\t\t\tgl,\n\t\t\t\t\tfbo,\n\t\t\t\t\tdefaultScene,\n\t\t\t\t] = [this.options(), this.gl(), this.fbo(), this.defaultScene()];\n\t\t\t\tif (frames === 1) {\n\t\t\t\t\tcamera.nativeElement.update(gl, this.virtualScene);\n\t\t\t\t}\n\t\t\t\treturn setEnvProps(background, scene, defaultScene, fbo.texture, {\n\t\t\t\t\tblur,\n\t\t\t\t\tbackgroundBlurriness,\n\t\t\t\t\tbackgroundIntensity,\n\t\t\t\t\tbackgroundRotation,\n\t\t\t\t\tenvironmentIntensity,\n\t\t\t\t\tenvironmentRotation,\n\t\t\t\t});\n\t\t\t});\n\t\t});\n\n\t\tlet count = 1;\n\t\tinjectNextBeforeRender(() => {\n\t\t\tconst frames = this.options().frames;\n\t\t\tif (frames === Infinity || (frames != null && count < frames)) {\n\t\t\t\tconst camera = this.camera().nativeElement;\n\t\t\t\tif (camera) {\n\t\t\t\t\tcamera.update(this.gl(), this.virtualScene);\n\t\t\t\t\tcount++;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment-ground',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngts-environment-map [options]=\"envMapOptions()\" />\n\t\t<ngt-ground-projected-env *args=\"args()\" [scale]=\"scale()\" [height]=\"height()\" [radius]=\"radius()\" />\n\t`,\n\timports: [NgtsEnvironmentMap, NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironmentGround {\n\toptions = input({} as NgtsEnvironmentOptions);\n\n\tprivate defaultTexture = injectEnvironment(this.options);\n\tprivate texture = computed(() => this.options().map || this.defaultTexture());\n\n\targs = computed(() => [this.texture()]);\n\theight = computed(() => (this.options().ground as any)?.height);\n\tradius = computed(() => (this.options().ground as any)?.radius);\n\tscale = computed(() => (this.options().ground as any)?.scale ?? 1000);\n\n\tenvMapOptions = computed(() => {\n\t\tconst { map: _, ...options } = this.options();\n\t\treturn Object.assign(options, { map: this.texture() }) as NgtsEnvironmentOptions;\n\t});\n\n\tconstructor() {\n\t\textend({ GroundProjectedEnv });\n\t}\n}\n\n@Component({\n\tselector: 'ngts-environment',\n\tstandalone: true,\n\ttemplate: `\n\t\t@if (optionsProvider.options().ground) {\n\t\t\t<ngts-environment-ground [options]=\"optionsProvider.options()\" />\n\t\t} @else if (optionsProvider.options().map) {\n\t\t\t<ngts-environment-map [options]=\"optionsProvider.options()\" />\n\t\t} @else if (content()) {\n\t\t\t<ngts-environment-portal [options]=\"optionsProvider.options()\" [content]=\"$any(content())\" />\n\t\t} @else {\n\t\t\t<ngts-environment-cube [options]=\"optionsProvider.options()\" />\n\t\t}\n\t`,\n\timports: [NgtsEnvironmentCube, NgtsEnvironmentMap, NgtsEnvironmentPortal, NgtsEnvironmentGround],\n\thostDirectives: [{ directive: NgtsEnvironmentOptionsProvider, inputs: ['options'] }],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsEnvironment {\n\toptionsProvider = inject(NgtsEnvironmentOptionsProvider);\n\tcontent = contentChild(NgtsContent, { read: TemplateRef });\n}\n"]}

package/esm2022/staging/lib/float.mjs

@@ -0,0 +1,70 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, TemplateRef, contentChild, input, } from '@angular/core';
+import { extend, injectNextBeforeRender, injectNgtRef, makeParameters } from 'angular-three';
+import { NgtsContent } from 'angular-three-soba/misc';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, MathUtils } from 'three';
+import * as i0 from "@angular/core";
+extend({ Group });
+const defaultOptions = {
+    enabled: true,
+    speed: 1,
+    rotationIntensity: 1,
+    floatIntensity: 1,
+    floatingRange: [-0.1, 0.1],
+};
+export class NgtsFloat {
+    constructor() {
+        this.floatRef = input(injectNgtRef());
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = makeParameters(this.options, [
+            'enabled',
+            'speed',
+            'rotationIntensity',
+            'floatIntensity',
+            'floatingRange',
+        ]);
+        this.content = contentChild.required(NgtsContent, { read: TemplateRef });
+        const offset = Math.random() * 10000;
+        injectNextBeforeRender(({ clock }) => {
+            const [{ enabled, speed, rotationIntensity, floatingRange, floatIntensity }] = [this.options()];
+            if (!enabled || speed === 0)
+                return;
+            const container = this.floatRef().nativeElement;
+            const offsetTime = offset + clock.getElapsedTime();
+            container.rotation.x = (Math.cos((offsetTime / 4) * speed) / 8) * rotationIntensity;
+            container.rotation.y = (Math.sin((offsetTime / 4) * speed) / 8) * rotationIntensity;
+            container.rotation.z = (Math.sin((offsetTime / 4) * speed) / 20) * rotationIntensity;
+            let yPosition = Math.sin((offsetTime / 4) * speed) / 10;
+            yPosition = MathUtils.mapLinear(yPosition, -0.1, 0.1, floatingRange[0] ?? -0.1, floatingRange[1] ?? 0.1);
+            container.position.y = yPosition * floatIntensity;
+            container.updateMatrix();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: NgtsFloat, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.0.3", type: NgtsFloat, isStandalone: true, selector: "ngts-float", inputs: { floatRef: { classPropertyName: "floatRef", publicName: "floatRef", 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 }], ngImport: i0, template: `
+		<ngt-group [parameters]="parameters()">
+			<ngt-group [ref]="floatRef()" [matrixAutoUpdate]="false">
+				<ng-container [ngTemplateOutlet]="content()" />
+			</ngt-group>
+		</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: NgtsFloat, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-float',
+                    standalone: true,
+                    template: `
+		<ngt-group [parameters]="parameters()">
+			<ngt-group [ref]="floatRef()" [matrixAutoUpdate]="false">
+				<ng-container [ngTemplateOutlet]="content()" />
+			</ngt-group>
+		</ngt-group>
+	`,
+                    imports: [NgTemplateOutlet],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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