angular-three-soba 1.14.0 → 2.0.0-beta.3

package/esm2022/abstractions/line/line.mjs

@@ -0,0 +1,165 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, effect, inject } from '@angular/core';
+import { NgtArgs, NgtStore, injectNgtRef, requestAnimationInInjectionContext } from 'angular-three';
+import * as THREE from 'three';
+import { Line2, LineGeometry, LineMaterial, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';
+import { NgtsLineInputs } from './line-input';
+import * as i0 from "@angular/core";
+class NgtsLine extends NgtsLineInputs {
+    set points(points) {
+        this.set({ points });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    #store;
+    #size;
+    #lineResolution;
+    #resolution;
+    #points;
+    #pointValues;
+    #vertexColors;
+    #vertexColorValues;
+    #segments;
+    constructor() {
+        super();
+        this.lineRef = injectNgtRef();
+        this.#store = inject(NgtStore);
+        this.#size = this.#store.select('size');
+        this.#lineResolution = this.select('resolution');
+        this.#resolution = computed(() => this.#lineResolution() ? this.#lineResolution() : [this.#size().width, this.#size().height]);
+        this.#points = this.select('points');
+        this.#pointValues = computed(() => this.#points().map((p) => {
+            const isArray = Array.isArray(p);
+            return p instanceof THREE.Vector3
+                ? [p.x, p.y, p.z]
+                : p instanceof THREE.Vector2
+                    ? [p.x, p.y, 0]
+                    : isArray && p.length === 3
+                        ? [p[0], p[1], p[2]]
+                        : isArray && p.length === 2
+                            ? [p[0], p[1], 0]
+                            : p;
+        }));
+        this.#vertexColors = this.select('vertexColors');
+        this.#vertexColorValues = computed(() => (this.#vertexColors() || []).map((c) => (c instanceof THREE.Color ? c.toArray() : c)));
+        this.#segments = this.select('segments');
+        this.lineGeometry = computed(() => {
+            const pointValues = this.#pointValues();
+            const vertexColors = this.#vertexColorValues();
+            const geometry = this.#segments() ? new LineSegmentsGeometry() : new LineGeometry();
+            geometry.setPositions(pointValues.flat());
+            if (vertexColors.length) {
+                geometry.setColors(vertexColors.flat());
+            }
+            return geometry;
+        });
+        this.lineMaterial = new LineMaterial();
+        this.line = computed(() => (this.#segments() ? new LineSegments2() : new Line2()));
+        this.lineMaterialParameters = computed(() => {
+            const parameters = this.lineParameters();
+            const resolution = this.#resolution();
+            const vertexColors = Boolean(parameters.vertexColors);
+            if (vertexColors) {
+                parameters.color = undefined;
+            }
+            return {
+                ...parameters,
+                vertexColors,
+                resolution,
+                dashScale: parameters.dashScale ?? this.lineMaterial.dashScale,
+                dashSize: parameters.dashSize ?? this.lineMaterial.dashSize,
+                dashOffset: parameters.dashOffset ?? this.lineMaterial.dashOffset,
+                gapSize: parameters.gapSize ?? this.lineMaterial.gapSize,
+                wireframe: parameters.wireframe ?? this.lineMaterial.wireframe,
+                worldUnits: parameters.worldUnits ?? this.lineMaterial.worldUnits,
+            };
+        });
+        this.set({ segments: false });
+        requestAnimationInInjectionContext(() => {
+            this.#disposeGeometry();
+            this.#computeLineDistances();
+        });
+    }
+    #computeLineDistances() {
+        const points = this.select('points');
+        const trigger = computed(() => {
+            const lineGeometry = this.lineGeometry();
+            const line = this.lineRef.nativeElement;
+            const children = this.lineRef.children('nonObjects');
+            return { points: points(), lineGeometry, line, children: children() };
+        });
+        effect(() => {
+            const { line } = trigger();
+            if (!line)
+                return;
+            line.computeLineDistances();
+        });
+    }
+    #disposeGeometry() {
+        effect((onCleanup) => {
+            const lineGeometry = this.lineGeometry();
+            onCleanup(() => lineGeometry.dispose());
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsLine, isStandalone: true, selector: "ngts-line", inputs: { lineRef: "lineRef", points: "points", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-primitive *args="[line()]" [ref]="lineRef" ngtCompound>
+            <ngt-primitive *args="[lineGeometry()]" attach="geometry" />
+            <ngt-primitive
+                *args="[lineMaterial]"
+                attach="material"
+                [resolution]="lineMaterialParameters().resolution"
+                [color]="lineMaterialParameters().color"
+                [vertexColors]="lineMaterialParameters().vertexColors"
+                [linewidth]="lineMaterialParameters().linewidth"
+                [alphaToCoverage]="lineMaterialParameters().alphaToCoverage"
+                [dashed]="lineMaterialParameters().dashed"
+                [dashScale]="lineMaterialParameters().dashScale"
+                [dashSize]="lineMaterialParameters().dashSize"
+                [dashOffset]="lineMaterialParameters().dashOffset"
+                [gapSize]="lineMaterialParameters().gapSize"
+                [wireframe]="lineMaterialParameters().wireframe"
+                [worldUnits]="lineMaterialParameters().worldUnits"
+            />
+        </ngt-primitive>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsLine };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-line',
+                    standalone: true,
+                    template: `
+        <ngt-primitive *args="[line()]" [ref]="lineRef" ngtCompound>
+            <ngt-primitive *args="[lineGeometry()]" attach="geometry" />
+            <ngt-primitive
+                *args="[lineMaterial]"
+                attach="material"
+                [resolution]="lineMaterialParameters().resolution"
+                [color]="lineMaterialParameters().color"
+                [vertexColors]="lineMaterialParameters().vertexColors"
+                [linewidth]="lineMaterialParameters().linewidth"
+                [alphaToCoverage]="lineMaterialParameters().alphaToCoverage"
+                [dashed]="lineMaterialParameters().dashed"
+                [dashScale]="lineMaterialParameters().dashScale"
+                [dashSize]="lineMaterialParameters().dashSize"
+                [dashOffset]="lineMaterialParameters().dashOffset"
+                [gapSize]="lineMaterialParameters().gapSize"
+                [wireframe]="lineMaterialParameters().wireframe"
+                [worldUnits]="lineMaterialParameters().worldUnits"
+            />
+        </ngt-primitive>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { lineRef: [{
+                type: Input
+            }], points: [{
+                type: Input,
+                args: [{ required: true }]
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/line/line.ts"],"names":[],"mappings":"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","sourcesContent":["import { CUSTOM_ELEMENTS_SCHEMA, Component, Input, computed, effect, inject } from '@angular/core';\nimport { NgtArgs, NgtStore, injectNgtRef, requestAnimationInInjectionContext } from 'angular-three';\nimport * as THREE from 'three';\nimport { Line2, LineGeometry, LineMaterial, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';\nimport { NgtsLineInputs, type NgtsLineState } from './line-input';\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-line': NgtsLineState;\n    }\n}\n\n@Component({\n    selector: 'ngts-line',\n    standalone: true,\n    template: `\n        <ngt-primitive *args=\"[line()]\" [ref]=\"lineRef\" ngtCompound>\n            <ngt-primitive *args=\"[lineGeometry()]\" attach=\"geometry\" />\n            <ngt-primitive\n                *args=\"[lineMaterial]\"\n                attach=\"material\"\n                [resolution]=\"lineMaterialParameters().resolution\"\n                [color]=\"lineMaterialParameters().color\"\n                [vertexColors]=\"lineMaterialParameters().vertexColors\"\n                [linewidth]=\"lineMaterialParameters().linewidth\"\n                [alphaToCoverage]=\"lineMaterialParameters().alphaToCoverage\"\n                [dashed]=\"lineMaterialParameters().dashed\"\n                [dashScale]=\"lineMaterialParameters().dashScale\"\n                [dashSize]=\"lineMaterialParameters().dashSize\"\n                [dashOffset]=\"lineMaterialParameters().dashOffset\"\n                [gapSize]=\"lineMaterialParameters().gapSize\"\n                [wireframe]=\"lineMaterialParameters().wireframe\"\n                [worldUnits]=\"lineMaterialParameters().worldUnits\"\n            />\n        </ngt-primitive>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsLine extends NgtsLineInputs {\n    @Input() lineRef = injectNgtRef<LineSegments2 | Line2>();\n\n    @Input({ required: true }) set points(\n        points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>\n    ) {\n        this.set({ points });\n    }\n\n    @Input() set segments(segments: boolean) {\n        this.set({ segments });\n    }\n\n    readonly #store = inject(NgtStore);\n    readonly #size = this.#store.select('size');\n\n    readonly #lineResolution = this.select('resolution');\n    readonly #resolution = computed(() =>\n        this.#lineResolution() ? this.#lineResolution() : [this.#size().width, this.#size().height]\n    );\n\n    readonly #points = this.select('points');\n    readonly #pointValues = computed(() =>\n        this.#points().map((p) => {\n            const isArray = Array.isArray(p);\n            return p instanceof THREE.Vector3\n                ? [p.x, p.y, p.z]\n                : p instanceof THREE.Vector2\n                ? [p.x, p.y, 0]\n                : isArray && p.length === 3\n                ? [p[0], p[1], p[2]]\n                : isArray && p.length === 2\n                ? [p[0], p[1], 0]\n                : p;\n        })\n    );\n\n    readonly #vertexColors = this.select('vertexColors');\n    readonly #vertexColorValues = computed(() =>\n        (this.#vertexColors() || []).map((c) => (c instanceof THREE.Color ? c.toArray() : c))\n    );\n\n    readonly #segments = this.select('segments');\n    readonly lineGeometry = computed(() => {\n        const pointValues = this.#pointValues();\n        const vertexColors = this.#vertexColorValues();\n\n        const geometry = this.#segments() ? new LineSegmentsGeometry() : new LineGeometry();\n        geometry.setPositions(pointValues.flat());\n\n        if (vertexColors.length) {\n            geometry.setColors(vertexColors.flat());\n        }\n\n        return geometry;\n    });\n    readonly lineMaterial = new LineMaterial();\n    readonly line = computed(() => (this.#segments() ? new LineSegments2() : new Line2()));\n\n    readonly lineMaterialParameters = computed(() => {\n        const parameters = this.lineParameters();\n        const resolution = this.#resolution();\n\n        const vertexColors = Boolean(parameters.vertexColors);\n\n        if (vertexColors) {\n            parameters.color = undefined!;\n        }\n\n        return {\n            ...parameters,\n            vertexColors,\n            resolution,\n            dashScale: parameters.dashScale ?? this.lineMaterial.dashScale,\n            dashSize: parameters.dashSize ?? this.lineMaterial.dashSize,\n            dashOffset: parameters.dashOffset ?? this.lineMaterial.dashOffset,\n            gapSize: parameters.gapSize ?? this.lineMaterial.gapSize,\n            wireframe: parameters.wireframe ?? this.lineMaterial.wireframe,\n            worldUnits: parameters.worldUnits ?? this.lineMaterial.worldUnits,\n        };\n    });\n\n    constructor() {\n        super();\n        this.set({ segments: false });\n        requestAnimationInInjectionContext(() => {\n            this.#disposeGeometry();\n            this.#computeLineDistances();\n        });\n    }\n\n    #computeLineDistances() {\n        const points = this.select('points');\n        const trigger = computed(() => {\n            const lineGeometry = this.lineGeometry();\n            const line = this.lineRef.nativeElement;\n            const children = this.lineRef.children('nonObjects');\n            return { points: points(), lineGeometry, line, children: children() };\n        });\n        effect(() => {\n            const { line } = trigger();\n            if (!line) return;\n            line.computeLineDistances();\n        });\n    }\n\n    #disposeGeometry() {\n        effect((onCleanup) => {\n            const lineGeometry = this.lineGeometry();\n            onCleanup(() => lineGeometry.dispose());\n        });\n    }\n}\n"]}

package/esm2022/abstractions/quadratic-bezier-line/quadratic-bezier-line.mjs

@@ -0,0 +1,128 @@
+import { Component, Input, computed, effect } from '@angular/core';
+import { injectNgtRef } from 'angular-three';
+import * as THREE from 'three';
+import { NgtsLine } from '../line/line';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+const v = new THREE.Vector3();
+class NgtsQuadraticBezierLine extends NgtsLineInputs {
+    set start(start) {
+        this.set({ start });
+    }
+    set end(end) {
+        this.set({ end });
+    }
+    set mid(mid) {
+        this.set({ mid });
+    }
+    set segments(segments) {
+        this.set({ segments });
+    }
+    #curve;
+    #start;
+    #end;
+    #mid;
+    #segments;
+    constructor() {
+        super();
+        this.lineRef = injectNgtRef();
+        this.#curve = new THREE.QuadraticBezierCurve3(undefined, undefined, undefined);
+        this.#start = this.select('start');
+        this.#end = this.select('end');
+        this.#mid = this.select('mid');
+        this.#segments = this.select('segments');
+        this.points = computed(() => this.#getPoints(this.#start(), this.#end(), this.#mid(), this.#segments()));
+        this.set({ start: [0, 0, 0], end: [0, 0, 0], segments: 20 });
+        this.#replaceSetPoints();
+    }
+    #replaceSetPoints() {
+        effect(() => {
+            const line = this.lineRef.nativeElement;
+            if (!line)
+                return;
+            line.setPoints = (start, end, mid) => {
+                const points = this.#getPoints(start, end, mid);
+                if (line.geometry) {
+                    line.geometry.setPositions(points.map((p) => p.toArray()).flat());
+                }
+            };
+        });
+    }
+    #getPoints(start, end, mid, segments = 20) {
+        if (start instanceof THREE.Vector3)
+            this.#curve.v0.copy(start);
+        else
+            this.#curve.v0.set(...start);
+        if (end instanceof THREE.Vector3)
+            this.#curve.v2.copy(end);
+        else
+            this.#curve.v2.set(...end);
+        if (mid instanceof THREE.Vector3) {
+            this.#curve.v1.copy(mid);
+        }
+        else {
+            this.#curve.v1.copy(this.#curve.v0
+                .clone()
+                .add(this.#curve.v2.clone().sub(this.#curve.v0))
+                .add(v.set(0, this.#curve.v0.y - this.#curve.v2.y, 0)));
+        }
+        return this.#curve.getPoints(segments);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsQuadraticBezierLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsQuadraticBezierLine, isStandalone: true, selector: "ngts-quadratic-bezier-line", inputs: { lineRef: "lineRef", start: "start", end: "end", mid: "mid", segments: "segments" }, usesInheritance: true, ngImport: i0, template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="points()"
+            [color]="lineParameters().color"
+            [vertexColors]="lineParameters().vertexColors"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["lineRef", "points", "segments"] }] }); }
+}
+export { NgtsQuadraticBezierLine };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsQuadraticBezierLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-quadratic-bezier-line',
+                    standalone: true,
+                    template: `
+        <ngts-line
+            [lineRef]="lineRef"
+            [points]="points()"
+            [color]="lineParameters().color"
+            [vertexColors]="lineParameters().vertexColors"
+            [resolution]="lineParameters().resolution"
+            [lineWidth]="lineParameters().linewidth"
+            [alphaToCoverage]="lineParameters().alphaToCoverage"
+            [dashed]="lineParameters().dashed"
+            [dashScale]="lineParameters().dashScale"
+            [dashSize]="lineParameters().dashSize"
+            [dashOffset]="lineParameters().dashOffset"
+            [gapSize]="lineParameters().gapSize"
+            [wireframe]="lineParameters().wireframe"
+            [worldUnits]="lineParameters().worldUnits"
+        />
+    `,
+                    imports: [NgtsLine],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { lineRef: [{
+                type: Input
+            }], start: [{
+                type: Input
+            }], end: [{
+                type: Input
+            }], mid: [{
+                type: Input
+            }], segments: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quadratic-bezier-line.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/quadratic-bezier-line/quadratic-bezier-line.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, computed, effect } from '@angular/core';\nimport { injectNgtRef } from 'angular-three';\nimport * as THREE from 'three';\nimport { Line2 } from 'three-stdlib';\nimport { NgtsLine } from '../line/line';\nimport { NgtsLineInputs } from '../line/line-input';\n\ndeclare module '../line/line-input' {\n    interface NgtsLineState {\n        start: THREE.Vector3 | [number, number, number];\n        end: THREE.Vector3 | [number, number, number];\n        mid?: THREE.Vector3 | [number, number, number];\n    }\n}\n\nconst v = new THREE.Vector3();\n\n@Component({\n    selector: 'ngts-quadratic-bezier-line',\n    standalone: true,\n    template: `\n        <ngts-line\n            [lineRef]=\"lineRef\"\n            [points]=\"points()\"\n            [color]=\"lineParameters().color\"\n            [vertexColors]=\"lineParameters().vertexColors\"\n            [resolution]=\"lineParameters().resolution\"\n            [lineWidth]=\"lineParameters().linewidth\"\n            [alphaToCoverage]=\"lineParameters().alphaToCoverage\"\n            [dashed]=\"lineParameters().dashed\"\n            [dashScale]=\"lineParameters().dashScale\"\n            [dashSize]=\"lineParameters().dashSize\"\n            [dashOffset]=\"lineParameters().dashOffset\"\n            [gapSize]=\"lineParameters().gapSize\"\n            [wireframe]=\"lineParameters().wireframe\"\n            [worldUnits]=\"lineParameters().worldUnits\"\n        />\n    `,\n    imports: [NgtsLine],\n})\nexport class NgtsQuadraticBezierLine extends NgtsLineInputs {\n    @Input() lineRef = injectNgtRef<Line2>();\n\n    @Input() set start(start: THREE.Vector3 | [number, number, number]) {\n        this.set({ start });\n    }\n\n    @Input() set end(end: THREE.Vector3 | [number, number, number]) {\n        this.set({ end });\n    }\n\n    @Input() set mid(mid: THREE.Vector3 | [number, number, number]) {\n        this.set({ mid });\n    }\n\n    @Input() set segments(segments: number) {\n        this.set({ segments });\n    }\n\n    readonly #curve = new THREE.QuadraticBezierCurve3(undefined!, undefined!, undefined!);\n\n    readonly #start = this.select('start');\n    readonly #end = this.select('end');\n    readonly #mid = this.select('mid');\n    readonly #segments = this.select('segments');\n    readonly points = computed(() =>\n        this.#getPoints(this.#start(), this.#end(), this.#mid(), this.#segments() as number)\n    );\n\n    constructor() {\n        super();\n        this.set({ start: [0, 0, 0], end: [0, 0, 0], segments: 20 });\n        this.#replaceSetPoints();\n    }\n\n    #replaceSetPoints() {\n        effect(() => {\n            const line = this.lineRef.nativeElement;\n            if (!line) return;\n            (\n                line as unknown as {\n                    setPoints: (\n                        start: THREE.Vector3 | [number, number, number],\n                        end: THREE.Vector3 | [number, number, number],\n                        mid: THREE.Vector3 | [number, number, number]\n                    ) => void;\n                }\n            ).setPoints = (start, end, mid) => {\n                const points = this.#getPoints(start, end, mid);\n                if (line.geometry) {\n                    line.geometry.setPositions(points.map((p) => p.toArray()).flat());\n                }\n            };\n        });\n    }\n\n    #getPoints(\n        start: THREE.Vector3 | [number, number, number],\n        end: THREE.Vector3 | [number, number, number],\n        mid?: THREE.Vector3 | [number, number, number],\n        segments = 20\n    ) {\n        if (start instanceof THREE.Vector3) this.#curve.v0.copy(start);\n        else this.#curve.v0.set(...(start as [number, number, number]));\n        if (end instanceof THREE.Vector3) this.#curve.v2.copy(end);\n        else this.#curve.v2.set(...(end as [number, number, number]));\n        if (mid instanceof THREE.Vector3) {\n            this.#curve.v1.copy(mid);\n        } else {\n            this.#curve.v1.copy(\n                this.#curve.v0\n                    .clone()\n                    .add(this.#curve.v2.clone().sub(this.#curve.v0))\n                    .add(v.set(0, this.#curve.v0.y - this.#curve.v2.y, 0))\n            );\n        }\n        return this.#curve.getPoints(segments);\n    }\n}\n"]}

package/esm2022/abstractions/text/text.mjs

@@ -0,0 +1,275 @@
+import { CUSTOM_ELEMENTS_SCHEMA, Component, DestroyRef, EventEmitter, Input, Output, computed, effect, inject, } from '@angular/core';
+import { NgtArgs, NgtSignalStore, NgtStore, injectNgtRef } from 'angular-three';
+// @ts-expect-error: no type def for troika-three-text
+import { Text, preloadFont } from 'troika-three-text';
+import * as i0 from "@angular/core";
+class NgtsText extends NgtSignalStore {
+    set text(text) {
+        this.set({ text });
+    }
+    set font(font) {
+        this.set({ font });
+    }
+    set fontSize(fontSize) {
+        this.set({ fontSize });
+    }
+    set anchorX(anchorX) {
+        this.set({ anchorX });
+    }
+    set anchorY(anchorY) {
+        this.set({ anchorY });
+    }
+    set sdfGlyphSize(sdfGlyphSize) {
+        this.set({ sdfGlyphSize });
+    }
+    set characters(characters) {
+        this.set({ characters });
+    }
+    set color(color) {
+        this.set({ color });
+    }
+    set maxWidth(maxWidth) {
+        this.set({ maxWidth });
+    }
+    set lineHeight(lineHeight) {
+        this.set({ lineHeight });
+    }
+    set letterSpacing(letterSpacing) {
+        this.set({ letterSpacing });
+    }
+    set textAlign(textAlign) {
+        this.set({ textAlign });
+    }
+    set clipRect(clipRect) {
+        this.set({ clipRect });
+    }
+    set depthOffset(depthOffset) {
+        this.set({ depthOffset });
+    }
+    set direction(direction) {
+        this.set({ direction });
+    }
+    set overflowWrap(overflowWrap) {
+        this.set({ overflowWrap });
+    }
+    set whiteSpace(whiteSpace) {
+        this.set({ whiteSpace });
+    }
+    set outlineWidth(outlineWidth) {
+        this.set({ outlineWidth });
+    }
+    set outlineOffsetX(outlineOffsetX) {
+        this.set({ outlineOffsetX });
+    }
+    set outlineOffsetY(outlineOffsetY) {
+        this.set({ outlineOffsetY });
+    }
+    set outlineBlur(outlineBlur) {
+        this.set({ outlineBlur });
+    }
+    set outlineColor(outlineColor) {
+        this.set({ outlineColor });
+    }
+    set outlineOpacity(outlineOpacity) {
+        this.set({ outlineOpacity });
+    }
+    set strokeWidth(strokeWidth) {
+        this.set({ strokeWidth });
+    }
+    set strokeColor(strokeColor) {
+        this.set({ strokeColor });
+    }
+    set strokeOpacity(strokeOpacity) {
+        this.set({ strokeOpacity });
+    }
+    set fillOpacity(fillOpacity) {
+        this.set({ fillOpacity });
+    }
+    set debugSDF(debugSDF) {
+        this.set({ debugSDF });
+    }
+    #store;
+    constructor() {
+        super({ fontSize: 1, sdfGlyphSize: 64, anchorX: 'center', anchorY: 'middle' });
+        this.textRef = injectNgtRef();
+        this.sync = new EventEmitter();
+        this.troikaText = new Text();
+        this.#store = inject(NgtStore);
+        this.state = this.select();
+        inject(DestroyRef).onDestroy(() => {
+            this.troikaText.dispose();
+        });
+        this.#preloadFont();
+        this.#syncText();
+    }
+    #preloadFont() {
+        const font = this.select('font');
+        const characters = this.select('characters');
+        const trigger = computed(() => ({ font: font(), characters: characters() }));
+        effect(() => {
+            const { font, characters } = trigger();
+            const invalidate = this.#store.get('invalidate');
+            preloadFont({ font, characters }, () => invalidate());
+        });
+    }
+    #syncText() {
+        const state = this.select();
+        effect(() => {
+            state();
+            const invalidate = this.#store.get('invalidate');
+            this.troikaText.sync(() => {
+                invalidate();
+                if (this.sync.observed) {
+                    this.sync.emit(this.troikaText);
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsText, isStandalone: true, selector: "ngts-text", inputs: { textRef: "textRef", text: "text", font: "font", fontSize: "fontSize", anchorX: "anchorX", anchorY: "anchorY", sdfGlyphSize: "sdfGlyphSize", characters: "characters", color: "color", maxWidth: "maxWidth", lineHeight: "lineHeight", letterSpacing: "letterSpacing", textAlign: "textAlign", clipRect: "clipRect", depthOffset: "depthOffset", direction: "direction", overflowWrap: "overflowWrap", whiteSpace: "whiteSpace", outlineWidth: "outlineWidth", outlineOffsetX: "outlineOffsetX", outlineOffsetY: "outlineOffsetY", outlineBlur: "outlineBlur", outlineColor: "outlineColor", outlineOpacity: "outlineOpacity", strokeWidth: "strokeWidth", strokeColor: "strokeColor", strokeOpacity: "strokeOpacity", fillOpacity: "fillOpacity", debugSDF: "debugSDF" }, outputs: { sync: "sync" }, usesInheritance: true, ngImport: i0, template: `
+        <ngt-primitive
+            ngtCompound
+            *args="[troikaText]"
+            [ref]="textRef"
+            [text]="state().text"
+            [anchorX]="state().anchorX"
+            [anchorY]="state().anchorY"
+            [font]="state().font"
+            [fontSize]="state().fontSize"
+            [sdfGlyphSize]="state().sdfGlyphSize"
+            [characters]="state().characters"
+            [color]="state().color"
+            [maxWidth]="state().maxWidth"
+            [lineHeight]="state().lineHeight"
+            [letterSpacing]="state().letterSpacing"
+            [textAlign]="state().textAlign"
+            [clipRect]="state().clipRect"
+            [depthOffset]="state().depthOffset"
+            [direction]="state().direction"
+            [overflowWrap]="state().overflowWrap"
+            [whiteSpace]="state().whiteSpace"
+            [outlineWidth]="state().outlineWidth"
+            [outlineOffsetX]="state().outlineOffsetX"
+            [outlineOffsetY]="state().outlineOffsetY"
+            [outlineBlur]="state().outlineBlur"
+            [outlineColor]="state().outlineColor"
+            [outlineOpacity]="state().outlineOpacity"
+            [strokeWidth]="state().strokeWidth"
+            [strokeColor]="state().strokeColor"
+            [strokeOpacity]="state().strokeOpacity"
+            [fillOpacity]="state().fillOpacity"
+            [debugSDF]="state().debugSDF"
+        >
+            <ng-content />
+        </ngt-primitive>
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+}
+export { NgtsText };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsText, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text',
+                    standalone: true,
+                    template: `
+        <ngt-primitive
+            ngtCompound
+            *args="[troikaText]"
+            [ref]="textRef"
+            [text]="state().text"
+            [anchorX]="state().anchorX"
+            [anchorY]="state().anchorY"
+            [font]="state().font"
+            [fontSize]="state().fontSize"
+            [sdfGlyphSize]="state().sdfGlyphSize"
+            [characters]="state().characters"
+            [color]="state().color"
+            [maxWidth]="state().maxWidth"
+            [lineHeight]="state().lineHeight"
+            [letterSpacing]="state().letterSpacing"
+            [textAlign]="state().textAlign"
+            [clipRect]="state().clipRect"
+            [depthOffset]="state().depthOffset"
+            [direction]="state().direction"
+            [overflowWrap]="state().overflowWrap"
+            [whiteSpace]="state().whiteSpace"
+            [outlineWidth]="state().outlineWidth"
+            [outlineOffsetX]="state().outlineOffsetX"
+            [outlineOffsetY]="state().outlineOffsetY"
+            [outlineBlur]="state().outlineBlur"
+            [outlineColor]="state().outlineColor"
+            [outlineOpacity]="state().outlineOpacity"
+            [strokeWidth]="state().strokeWidth"
+            [strokeColor]="state().strokeColor"
+            [strokeOpacity]="state().strokeOpacity"
+            [fillOpacity]="state().fillOpacity"
+            [debugSDF]="state().debugSDF"
+        >
+            <ng-content />
+        </ngt-primitive>
+    `,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { textRef: [{
+                type: Input
+            }], text: [{
+                type: Input,
+                args: [{ required: true }]
+            }], font: [{
+                type: Input
+            }], fontSize: [{
+                type: Input
+            }], anchorX: [{
+                type: Input
+            }], anchorY: [{
+                type: Input
+            }], sdfGlyphSize: [{
+                type: Input
+            }], characters: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], lineHeight: [{
+                type: Input
+            }], letterSpacing: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], clipRect: [{
+                type: Input
+            }], depthOffset: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], overflowWrap: [{
+                type: Input
+            }], whiteSpace: [{
+                type: Input
+            }], outlineWidth: [{
+                type: Input
+            }], outlineOffsetX: [{
+                type: Input
+            }], outlineOffsetY: [{
+                type: Input
+            }], outlineBlur: [{
+                type: Input
+            }], outlineColor: [{
+                type: Input
+            }], outlineOpacity: [{
+                type: Input
+            }], strokeWidth: [{
+                type: Input
+            }], strokeColor: [{
+                type: Input
+            }], strokeOpacity: [{
+                type: Input
+            }], fillOpacity: [{
+                type: Input
+            }], debugSDF: [{
+                type: Input
+            }], sync: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/text/text.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    CUSTOM_ELEMENTS_SCHEMA,\n    Component,\n    DestroyRef,\n    EventEmitter,\n    Input,\n    Output,\n    computed,\n    effect,\n    inject,\n} from '@angular/core';\nimport { NgtArgs, NgtSignalStore, NgtStore, injectNgtRef, type NgtMesh } from 'angular-three';\n\n// @ts-expect-error: no type def for troika-three-text\nimport { Text, preloadFont } from 'troika-three-text';\n\nexport type NgtsTextState = {\n    text: string;\n    /** Font size, default: 1 */\n    fontSize: number;\n    anchorX: number | 'left' | 'center' | 'right';\n    anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';\n    sdfGlyphSize: number;\n    font?: string;\n    characters?: string;\n    color?: THREE.ColorRepresentation;\n    maxWidth?: number;\n    lineHeight?: number;\n    letterSpacing?: number;\n    textAlign?: 'left' | 'right' | 'center' | 'justify';\n    clipRect?: [number, number, number, number];\n    depthOffset?: number;\n    direction?: 'auto' | 'ltr' | 'rtl';\n    overflowWrap?: 'normal' | 'break-word';\n    whiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';\n    outlineWidth?: number | string;\n    outlineOffsetX?: number | string;\n    outlineOffsetY?: number | string;\n    outlineBlur?: number | string;\n    outlineColor?: THREE.ColorRepresentation;\n    outlineOpacity?: number;\n    strokeWidth?: number | string;\n    strokeColor?: THREE.ColorRepresentation;\n    strokeOpacity?: number;\n    fillOpacity?: number;\n    debugSDF?: boolean;\n};\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-text': NgtsTextState & NgtMesh;\n    }\n}\n\n@Component({\n    selector: 'ngts-text',\n    standalone: true,\n    template: `\n        <ngt-primitive\n            ngtCompound\n            *args=\"[troikaText]\"\n            [ref]=\"textRef\"\n            [text]=\"state().text\"\n            [anchorX]=\"state().anchorX\"\n            [anchorY]=\"state().anchorY\"\n            [font]=\"state().font\"\n            [fontSize]=\"state().fontSize\"\n            [sdfGlyphSize]=\"state().sdfGlyphSize\"\n            [characters]=\"state().characters\"\n            [color]=\"state().color\"\n            [maxWidth]=\"state().maxWidth\"\n            [lineHeight]=\"state().lineHeight\"\n            [letterSpacing]=\"state().letterSpacing\"\n            [textAlign]=\"state().textAlign\"\n            [clipRect]=\"state().clipRect\"\n            [depthOffset]=\"state().depthOffset\"\n            [direction]=\"state().direction\"\n            [overflowWrap]=\"state().overflowWrap\"\n            [whiteSpace]=\"state().whiteSpace\"\n            [outlineWidth]=\"state().outlineWidth\"\n            [outlineOffsetX]=\"state().outlineOffsetX\"\n            [outlineOffsetY]=\"state().outlineOffsetY\"\n            [outlineBlur]=\"state().outlineBlur\"\n            [outlineColor]=\"state().outlineColor\"\n            [outlineOpacity]=\"state().outlineOpacity\"\n            [strokeWidth]=\"state().strokeWidth\"\n            [strokeColor]=\"state().strokeColor\"\n            [strokeOpacity]=\"state().strokeOpacity\"\n            [fillOpacity]=\"state().fillOpacity\"\n            [debugSDF]=\"state().debugSDF\"\n        >\n            <ng-content />\n        </ngt-primitive>\n    `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsText extends NgtSignalStore<NgtsTextState> {\n    @Input() textRef = injectNgtRef<Text>();\n\n    @Input({ required: true }) set text(text: string) {\n        this.set({ text });\n    }\n\n    @Input() set font(font: string) {\n        this.set({ font });\n    }\n\n    @Input() set fontSize(fontSize: number) {\n        this.set({ fontSize });\n    }\n\n    @Input() set anchorX(anchorX: number | 'left' | 'center' | 'right') {\n        this.set({ anchorX });\n    }\n\n    @Input() set anchorY(anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom') {\n        this.set({ anchorY });\n    }\n\n    @Input() set sdfGlyphSize(sdfGlyphSize: number) {\n        this.set({ sdfGlyphSize });\n    }\n\n    @Input() set characters(characters: string) {\n        this.set({ characters });\n    }\n\n    @Input() set color(color: THREE.ColorRepresentation) {\n        this.set({ color });\n    }\n\n    @Input() set maxWidth(maxWidth: number) {\n        this.set({ maxWidth });\n    }\n\n    @Input() set lineHeight(lineHeight: number) {\n        this.set({ lineHeight });\n    }\n\n    @Input() set letterSpacing(letterSpacing: number) {\n        this.set({ letterSpacing });\n    }\n\n    @Input() set textAlign(textAlign: 'left' | 'right' | 'center' | 'justify') {\n        this.set({ textAlign });\n    }\n\n    @Input() set clipRect(clipRect: [number, number, number, number]) {\n        this.set({ clipRect });\n    }\n\n    @Input() set depthOffset(depthOffset: number) {\n        this.set({ depthOffset });\n    }\n\n    @Input() set direction(direction: 'auto' | 'ltr' | 'rtl') {\n        this.set({ direction });\n    }\n\n    @Input() set overflowWrap(overflowWrap: 'normal' | 'break-word') {\n        this.set({ overflowWrap });\n    }\n\n    @Input() set whiteSpace(whiteSpace: 'normal' | 'overflowWrap' | 'nowrap') {\n        this.set({ whiteSpace });\n    }\n\n    @Input() set outlineWidth(outlineWidth: number | string) {\n        this.set({ outlineWidth });\n    }\n\n    @Input() set outlineOffsetX(outlineOffsetX: number | string) {\n        this.set({ outlineOffsetX });\n    }\n\n    @Input() set outlineOffsetY(outlineOffsetY: number | string) {\n        this.set({ outlineOffsetY });\n    }\n\n    @Input() set outlineBlur(outlineBlur: number | string) {\n        this.set({ outlineBlur });\n    }\n\n    @Input() set outlineColor(outlineColor: THREE.ColorRepresentation) {\n        this.set({ outlineColor });\n    }\n\n    @Input() set outlineOpacity(outlineOpacity: number) {\n        this.set({ outlineOpacity });\n    }\n\n    @Input() set strokeWidth(strokeWidth: number | string) {\n        this.set({ strokeWidth });\n    }\n\n    @Input() set strokeColor(strokeColor: THREE.ColorRepresentation) {\n        this.set({ strokeColor });\n    }\n\n    @Input() set strokeOpacity(strokeOpacity: number) {\n        this.set({ strokeOpacity });\n    }\n\n    @Input() set fillOpacity(fillOpacity: number) {\n        this.set({ fillOpacity });\n    }\n\n    @Input() set debugSDF(debugSDF: boolean) {\n        this.set({ debugSDF });\n    }\n\n    @Output() sync = new EventEmitter<Text>();\n\n    readonly troikaText = new Text();\n\n    readonly #store = inject(NgtStore);\n\n    readonly state = this.select();\n\n    constructor() {\n        super({ fontSize: 1, sdfGlyphSize: 64, anchorX: 'center', anchorY: 'middle' });\n        inject(DestroyRef).onDestroy(() => {\n            this.troikaText.dispose();\n        });\n        this.#preloadFont();\n        this.#syncText();\n    }\n\n    #preloadFont() {\n        const font = this.select('font');\n        const characters = this.select('characters');\n        const trigger = computed(() => ({ font: font(), characters: characters() }));\n\n        effect(() => {\n            const { font, characters } = trigger();\n            const invalidate = this.#store.get('invalidate');\n            preloadFont({ font, characters }, () => invalidate());\n        });\n    }\n\n    #syncText() {\n        const state = this.select();\n        effect(() => {\n            state();\n            const invalidate = this.#store.get('invalidate');\n            this.troikaText.sync(() => {\n                invalidate();\n                if (this.sync.observed) {\n                    this.sync.emit(this.troikaText);\n                }\n            });\n        });\n    }\n}\n"]}