angular-three-soba 1.13.0 → 2.0.0-beta.2

package/README.md

@@ -1,7 +1,7 @@
-# angular-three-soba
+# soba
 
 This library was generated with [Nx](https://nx.dev).
 
 ## Running unit tests
 
-Run `nx test angular-three-soba` to execute the unit tests.
+Run `nx test soba` to execute the unit tests.

package/abstractions/billboard/billboard.d.ts

@@ -0,0 +1,24 @@
+import { NgtSignalStore, type NgtGroup } from 'angular-three';
+import { Group } from 'three';
+import * as i0 from "@angular/core";
+export type NgtsBillboardState = {
+    follow?: boolean;
+    lockX?: boolean;
+    lockY?: boolean;
+    lockZ?: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-billboard': NgtsBillboardState & NgtGroup;
+    }
+}
+export declare class NgtsBillboard extends NgtSignalStore<NgtsBillboardState> {
+    billboardRef: import("angular-three").NgtInjectedRef<Group>;
+    set follow(follow: boolean);
+    set lockX(lockX: boolean);
+    set lockY(lockY: boolean);
+    set lockZ(lockZ: boolean);
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsBillboard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsBillboard, "ngts-billboard", never, { "billboardRef": { "alias": "billboardRef"; "required": false; }; "follow": { "alias": "follow"; "required": false; }; "lockX": { "alias": "lockX"; "required": false; }; "lockY": { "alias": "lockY"; "required": false; }; "lockZ": { "alias": "lockZ"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/catmull-rom-line/catmull-rom-line.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+import { Line2 } from 'three-stdlib';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+declare module '../line/line-input' {
+    interface NgtsLineState {
+        closed: boolean;
+        curveType: 'centripetal' | 'chordal' | 'catmullrom';
+        tension: number;
+    }
+}
+export declare class NgtsCatmullRomLine extends NgtsLineInputs {
+    #private;
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set points(points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>);
+    set closed(closed: boolean);
+    set curveType(curveType: 'centripetal' | 'chordal' | 'catmullrom');
+    set tension(tension: number);
+    set segments(segments: number);
+    readonly segmentedPoints: import("@angular/core").Signal<THREE.Vector3[]>;
+    readonly interpolatedVertexColors: import("@angular/core").Signal<(THREE.Color | [number, number, number])[] | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCatmullRomLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCatmullRomLine, "ngts-catmull-rom-line", never, { "lineRef": { "alias": "lineRef"; "required": false; }; "points": { "alias": "points"; "required": true; }; "closed": { "alias": "closed"; "required": false; }; "curveType": { "alias": "curveType"; "required": false; }; "tension": { "alias": "tension"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
+}

package/abstractions/cubic-bezier-line/cubic-bezier-line.d.ts

@@ -0,0 +1,25 @@
+import * as THREE from 'three';
+import type { Line2 } from 'three-stdlib';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+declare module '../line/line-input' {
+    interface NgtsLineState {
+        start: THREE.Vector3 | [number, number, number];
+        end: THREE.Vector3 | [number, number, number];
+        midA: THREE.Vector3 | [number, number, number];
+        midB: THREE.Vector3 | [number, number, number];
+    }
+}
+export declare class NgtsCubicBezierLine extends NgtsLineInputs {
+    #private;
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set start(start: THREE.Vector3 | [number, number, number]);
+    set end(end: THREE.Vector3 | [number, number, number]);
+    set midA(midA: THREE.Vector3 | [number, number, number]);
+    set midB(midB: THREE.Vector3 | [number, number, number]);
+    set segments(segments: number);
+    readonly points: import("@angular/core").Signal<THREE.Vector3[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsCubicBezierLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsCubicBezierLine, "ngts-cubic-bezier-line", never, { "lineRef": { "alias": "lineRef"; "required": false; }; "start": { "alias": "start"; "required": true; }; "end": { "alias": "end"; "required": true; }; "midA": { "alias": "midA"; "required": true; }; "midB": { "alias": "midB"; "required": true; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
+}

package/abstractions/edges/edges.d.ts

@@ -0,0 +1,22 @@
+import { NgtAnyRecord, NgtSignalStore } from 'angular-three';
+import * as THREE from 'three';
+import * as i0 from "@angular/core";
+export interface NgtsEdgesState {
+    threshold: number;
+    color: THREE.ColorRepresentation;
+    geometry: THREE.BufferGeometry;
+    userData: NgtAnyRecord;
+}
+export declare class NgtsEdges extends NgtSignalStore<NgtsEdgesState> {
+    #private;
+    edgesRef: import("angular-three").NgtInjectedRef<THREE.LineSegments<THREE.BufferGeometry, THREE.Material | THREE.Material[]>>;
+    set threshold(threshold: number);
+    set color(color: THREE.ColorRepresentation);
+    set geometry(geometry: THREE.BufferGeometry);
+    set userData(userData: NgtAnyRecord);
+    withChildren: boolean;
+    readonly noop: () => null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsEdges, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsEdges, "ngts-edges", never, { "edgesRef": { "alias": "edgesRef"; "required": false; }; "threshold": { "alias": "threshold"; "required": false; }; "color": { "alias": "color"; "required": false; }; "geometry": { "alias": "geometry"; "required": false; }; "userData": { "alias": "userData"; "required": false; }; "withChildren": { "alias": "withChildren"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/abstractions/gizmo-helper/gizmo-helper.d.ts

@@ -0,0 +1,34 @@
+import { EventEmitter, InjectionToken, Signal, TemplateRef } from '@angular/core';
+import { NgtSignalStore } from 'angular-three';
+import { Group, OrthographicCamera, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+export type NgtsGizmoHelperApi = (direction: Vector3) => void;
+export declare const NGTS_GIZMO_HELPER_API: InjectionToken<Signal<NgtsGizmoHelperApi>>;
+export interface NgtsGizmoHelperState {
+    alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin: [number, number];
+    renderPriority: number;
+    autoClear: boolean;
+}
+export declare class NgtsGizmoHelperContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelperContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoHelperContent, "ng-template[ngtsGizmoHelperContent]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoHelper extends NgtSignalStore<NgtsGizmoHelperState> {
+    #private;
+    readonly gizmoRef: import("angular-three").NgtInjectedRef<Group>;
+    readonly virtualCameraRef: import("angular-three").NgtInjectedRef<OrthographicCamera>;
+    set alignment(alignment: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center');
+    set margin(margin: [number, number]);
+    set renderPriority(renderPriority: number);
+    set autoClear(autoClear: boolean);
+    updated: EventEmitter<void>;
+    gizmoHelperContent: TemplateRef<unknown>;
+    readonly priority: Signal<number>;
+    readonly position: Signal<number[]>;
+    readonly api: Signal<(direction: THREE.Vector3) => void>;
+    constructor();
+    onBeforeRender(delta: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoHelper, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoHelper, "ngts-gizmo-helper", never, { "alignment": { "alias": "alignment"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "renderPriority": { "alias": "renderPriority"; "required": false; }; "autoClear": { "alias": "autoClear"; "required": false; }; }, { "updated": "updated"; }, ["gizmoHelperContent"], never, true, never>;
+}

package/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-edge.d.ts

@@ -0,0 +1,22 @@
+import { NgtSignalStore, NgtThreeEvent } from 'angular-three';
+import { Vector3 } from 'three';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeEdgeCube extends NgtSignalStore<{
+    position: THREE.Vector3;
+    dimensions: [number, number, number];
+}> {
+    #private;
+    protected readonly viewcubeInputs: NgtsGizmoViewcubeInputs;
+    hover: import("@angular/core").WritableSignal<boolean>;
+    set dimensions(dimensions: [number, number, number]);
+    set position(position: Vector3);
+    readonly edgePosition: import("@angular/core").Signal<Vector3>;
+    readonly edgeDimensions: import("@angular/core").Signal<[number, number, number]>;
+    constructor();
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeEdgeCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeEdgeCube, "ngts-gizmo-viewcube-edge-cube", never, { "dimensions": { "alias": "dimensions"; "required": true; }; "position": { "alias": "position"; "required": true; }; }, {}, never, never, true, never>;
+}

package/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-face.d.ts

@@ -0,0 +1,30 @@
+import { NgtSignalStore, NgtThreeEvent } from 'angular-three';
+import { CanvasTexture } from 'three';
+import { NgtsGizmoViewcubeInputs } from './gizmo-viewcube-inputs';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewcubeFaceMaterial extends NgtSignalStore<{
+    index: number;
+    hover: boolean;
+}> {
+    #private;
+    protected readonly gl: import("@angular/core").Signal<import("three").WebGLRenderer>;
+    protected readonly viewcubeInputs: NgtsGizmoViewcubeInputs;
+    set index(index: number);
+    set hover(hover: boolean);
+    readonly faceIndex: import("@angular/core").Signal<number>;
+    readonly faceHover: import("@angular/core").Signal<boolean>;
+    readonly texture: import("@angular/core").Signal<CanvasTexture>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceMaterial, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceMaterial, "ngts-gizmo-viewcube-face-material", never, { "index": { "alias": "index"; "required": true; }; "hover": { "alias": "hover"; "required": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewcubeFaceCube {
+    #private;
+    protected readonly viewcubeInputs: NgtsGizmoViewcubeInputs;
+    hover: import("@angular/core").WritableSignal<number>;
+    onPointerMove(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    onClick(event: NgtThreeEvent<MouseEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeFaceCube, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcubeFaceCube, "ngts-gizmo-viewcube-face-cube", never, {}, {}, never, never, true, never>;
+}

package/abstractions/gizmo-helper/gizmo-viewcube/gizmo-viewcube-inputs.d.ts

@@ -0,0 +1,32 @@
+import { type EventEmitter } from '@angular/core';
+import { NgtSignalStore, type NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export interface NgtsGizmoViewCubeInputsState {
+    opacity: number;
+    hoverColor: string;
+    textColor: string;
+    strokeColor: string;
+    faces: string[];
+    font?: string;
+    color?: string;
+    clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>;
+}
+export declare abstract class NgtsGizmoViewcubeInputs extends NgtSignalStore<NgtsGizmoViewCubeInputsState> {
+    set opacity(opacity: number);
+    set hoverColor(hoverColor: string);
+    set textColor(textColor: string);
+    set strokeColor(strokeColor: string);
+    set faces(faces: string[]);
+    set font(font: string);
+    set color(color: string);
+    set clickEmitter(clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>);
+    readonly viewcubeHoverColor: import("@angular/core").Signal<string>;
+    readonly viewcubeOpacity: import("@angular/core").Signal<number>;
+    readonly viewcubeTextColor: import("@angular/core").Signal<string>;
+    readonly viewcubeStrokeColor: import("@angular/core").Signal<string>;
+    readonly viewcubeFaces: import("@angular/core").Signal<string[]>;
+    readonly viewcubeFont: import("@angular/core").Signal<string | undefined>;
+    readonly viewcubeColor: import("@angular/core").Signal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcubeInputs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsGizmoViewcubeInputs, never, never, { "opacity": { "alias": "opacity"; "required": false; }; "hoverColor": { "alias": "hoverColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "faces": { "alias": "faces"; "required": false; }; "font": { "alias": "font"; "required": false; }; "color": { "alias": "color"; "required": false; }; "clickEmitter": { "alias": "clickEmitter"; "required": false; }; }, {}, never, never, false, never>;
+}

package/abstractions/{lib/gizmo-helper → gizmo-helper}/gizmo-viewcube/gizmo-viewcube.d.ts

@@ -7,9 +7,8 @@ export declare class NgtsGizmoViewcube extends NgtsGizmoViewcubeInputs {
     readonly edgeDimensions: [number, number, number][];
     readonly corners: import("three").Vector3[];
     readonly cornerDimensions: [number, number, number];
-    set font(font: string);
-    set color(color: string);
     clicked: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewcube, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcube, "ngts-gizmo-viewcube", never, { "font": "font"; "color": "color"; }, { "clicked": "clicked"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewcube, "ngts-gizmo-viewcube", never, {}, { "clicked": "clicked"; }, never, never, true, never>;
 }

package/abstractions/gizmo-helper/gizmo-viewport/gizmo-viewport-axis.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from '@angular/core';
+import { NgtSignalStore, NgtThreeEvent } from 'angular-three';
+import { CanvasTexture } from 'three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewportAxis extends NgtSignalStore<{
+    color: string;
+    rotation: [number, number, number];
+    scale: [number, number, number];
+}> {
+    set color(color: string);
+    set rotation(rotation: [number, number, number]);
+    set scale(scale: [number, number, number]);
+    readonly axisRotation: import("@angular/core").Signal<[number, number, number]>;
+    readonly axisColor: import("@angular/core").Signal<string>;
+    readonly axisScale: import("@angular/core").Signal<[number, number, number]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxis, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxis, "ngts-gizmo-viewport-axis", never, { "color": { "alias": "color"; "required": true; }; "rotation": { "alias": "rotation"; "required": true; }; "scale": { "alias": "scale"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class NgtsGizmoViewportAxisHead extends NgtSignalStore<{
+    arcStyle: string;
+    label: string;
+    labelColor: string;
+    axisHeadScale: number;
+    disabled: boolean;
+    font: string;
+    clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>;
+}> {
+    #private;
+    readonly gl: import("@angular/core").Signal<import("three").WebGLRenderer>;
+    set arcStyle(arcStyle: string);
+    set label(label: string);
+    set labelColor(labelColor: string);
+    set axisHeadScale(axisHeadScale: number);
+    set disabled(disabled: boolean);
+    set font(font: string);
+    set clickEmitter(clickEmitter: EventEmitter<NgtThreeEvent<MouseEvent>>);
+    active: import("@angular/core").WritableSignal<boolean>;
+    readonly axisLabel: import("@angular/core").Signal<string>;
+    readonly texture: import("@angular/core").Signal<CanvasTexture>;
+    readonly scale: import("@angular/core").Signal<number>;
+    constructor();
+    onPointerOver(event: NgtThreeEvent<PointerEvent>): void;
+    onPointerOut(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewportAxisHead, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewportAxisHead, "ngts-gizmo-viewport-axis-head", never, { "arcStyle": { "alias": "arcStyle"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "axisHeadScale": { "alias": "axisHeadScale"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "font": { "alias": "font"; "required": false; }; "clickEmitter": { "alias": "clickEmitter"; "required": false; }; }, {}, never, never, true, never>;
+}

package/abstractions/gizmo-helper/gizmo-viewport/gizmo-viewport.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from '@angular/core';
+import { NgtSignalStore, NgtThreeEvent } from 'angular-three';
+import * as i0 from "@angular/core";
+export declare class NgtsGizmoViewport extends NgtSignalStore<{
+    axisColors: [string, string, string];
+    axisScale: [number, number, number];
+    labels: [string, string, string];
+    axisHeadScale: number;
+    labelColor: string;
+    hideNegativeAxes: boolean;
+    hideAxisHeads: boolean;
+    disabled: boolean;
+    font: string;
+}> {
+    #private;
+    readonly Math: Math;
+    set axisColors(axisColors: [string, string, string]);
+    set axisScale(axisScale: [number, number, number]);
+    set labels(labels: [string, string, string]);
+    set axisHeadScale(axisHeadScale: number);
+    set labelColor(labelColor: string);
+    set hideNegativeAxes(hideNegativeAxes: boolean);
+    set hideAxisHeads(hideAxisHeads: boolean);
+    set disabled(disabled: boolean);
+    set font(font: string);
+    clicked: EventEmitter<NgtThreeEvent<MouseEvent>>;
+    readonly viewportAxisColors: import("@angular/core").Signal<[string, string, string]>;
+    readonly viewportAxisScale: import("@angular/core").Signal<[number, number, number]>;
+    readonly viewportLabels: import("@angular/core").Signal<[string, string, string]>;
+    readonly viewportAxisHeadScale: import("@angular/core").Signal<number>;
+    readonly viewportLabelColor: import("@angular/core").Signal<string>;
+    readonly viewportHideNegativeAxes: import("@angular/core").Signal<boolean>;
+    readonly viewportHideAxisHeads: import("@angular/core").Signal<boolean>;
+    readonly viewportDisabled: import("@angular/core").Signal<boolean>;
+    readonly viewportFont: import("@angular/core").Signal<string>;
+    constructor();
+    onPointerDown(event: NgtThreeEvent<PointerEvent>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsGizmoViewport, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsGizmoViewport, "ngts-gizmo-viewport", never, { "axisColors": { "alias": "axisColors"; "required": false; }; "axisScale": { "alias": "axisScale"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "axisHeadScale": { "alias": "axisHeadScale"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "hideNegativeAxes": { "alias": "hideNegativeAxes"; "required": false; }; "hideAxisHeads": { "alias": "hideAxisHeads"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "font": { "alias": "font"; "required": false; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}

package/abstractions/index.d.ts

@@ -1,11 +1,11 @@
-export * from './lib/billboard/billboard';
-export * from './lib/catmull-rom-line/catmull-rom-line';
-export * from './lib/cubic-bezier-line/cubic-bezier-line';
-export * from './lib/edges/edges';
-export * from './lib/gizmo-helper/gizmo-helper';
-export * from './lib/gizmo-helper/gizmo-viewcube/gizmo-viewcube';
-export * from './lib/gizmo-helper/gizmo-viewport/gizmo-viewport';
-export * from './lib/line/line';
-export * from './lib/quadratic-bezier-line/quadratic-bezier-line';
-export * from './lib/text-3d/text-3d';
-export * from './lib/text/text';
+export * from './billboard/billboard';
+export * from './catmull-rom-line/catmull-rom-line';
+export * from './cubic-bezier-line/cubic-bezier-line';
+export * from './edges/edges';
+export * from './gizmo-helper/gizmo-helper';
+export * from './gizmo-helper/gizmo-viewcube/gizmo-viewcube';
+export * from './gizmo-helper/gizmo-viewport/gizmo-viewport';
+export * from './line/line';
+export * from './quadratic-bezier-line/quadratic-bezier-line';
+export * from './text-3d/text-3d';
+export * from './text/text';

package/abstractions/line/line-input.d.ts

@@ -0,0 +1,42 @@
+import { NgtSignalStore } from 'angular-three';
+import type { LineMaterialParameters } from 'three-stdlib';
+import * as i0 from "@angular/core";
+export interface NgtsLineState extends Omit<LineMaterialParameters, 'vertexColors' | 'color'> {
+    vertexColors?: Array<THREE.Color | [number, number, number]>;
+    lineWidth?: number;
+    segments: boolean | number | undefined;
+    color: THREE.ColorRepresentation;
+    points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>;
+}
+export declare abstract class NgtsLineInputs extends NgtSignalStore<NgtsLineState> {
+    #private;
+    set vertexColors(vertexColors: NgtsLineState['vertexColors']);
+    set lineWidth(lineWidth: NgtsLineState['lineWidth']);
+    set alphaToCoverage(alphaToCoverage: NgtsLineState['alphaToCoverage']);
+    set color(color: NgtsLineState['color']);
+    set dashed(dashed: NgtsLineState['dashed']);
+    set dashScale(dashScale: NgtsLineState['dashScale']);
+    set dashSize(dashSize: NgtsLineState['dashSize']);
+    set dashOffset(dashOffset: NgtsLineState['dashOffset']);
+    set gapSize(gapSize: NgtsLineState['gapSize']);
+    set resolution(resolution: NgtsLineState['resolution']);
+    set wireframe(wireframe: NgtsLineState['wireframe']);
+    set worldUnits(worldUnits: NgtsLineState['worldUnits']);
+    readonly lineParameters: import("@angular/core").Signal<{
+        color: import("three").ColorRepresentation;
+        vertexColors: (import("three").Color | [number, number, number])[] | undefined;
+        resolution: import("three").Vector2 | undefined;
+        linewidth: number | undefined;
+        alphaToCoverage: boolean | undefined;
+        dashed: boolean | undefined;
+        dashScale: number | undefined;
+        dashSize: number | undefined;
+        dashOffset: number | undefined;
+        gapSize: number | undefined;
+        wireframe: boolean | undefined;
+        worldUnits: boolean | undefined;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLineInputs, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtsLineInputs, never, never, { "vertexColors": { "alias": "vertexColors"; "required": false; }; "lineWidth": { "alias": "lineWidth"; "required": false; }; "alphaToCoverage": { "alias": "alphaToCoverage"; "required": false; }; "color": { "alias": "color"; "required": false; }; "dashed": { "alias": "dashed"; "required": false; }; "dashScale": { "alias": "dashScale"; "required": false; }; "dashSize": { "alias": "dashSize"; "required": false; }; "dashOffset": { "alias": "dashOffset"; "required": false; }; "gapSize": { "alias": "gapSize"; "required": false; }; "resolution": { "alias": "resolution"; "required": false; }; "wireframe": { "alias": "wireframe"; "required": false; }; "worldUnits": { "alias": "worldUnits"; "required": false; }; }, {}, never, never, false, never>;
+}

package/abstractions/line/line.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import { Line2, LineMaterial, LineSegments2, LineSegmentsGeometry } from 'three-stdlib';
+import { NgtsLineInputs, type NgtsLineState } from './line-input';
+import * as i0 from "@angular/core";
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-line': NgtsLineState;
+    }
+}
+export declare class NgtsLine extends NgtsLineInputs {
+    #private;
+    lineRef: import("angular-three").NgtInjectedRef<LineSegments2 | Line2>;
+    set points(points: Array<THREE.Vector3 | THREE.Vector2 | [number, number, number] | [number, number] | number>);
+    set segments(segments: boolean);
+    readonly lineGeometry: import("@angular/core").Signal<LineSegmentsGeometry>;
+    readonly lineMaterial: LineMaterial;
+    readonly line: import("@angular/core").Signal<LineSegments2>;
+    readonly lineMaterialParameters: import("@angular/core").Signal<{
+        vertexColors: boolean;
+        resolution: number[] | THREE.Vector2 | undefined;
+        dashScale: number;
+        dashSize: number;
+        dashOffset: number;
+        gapSize: number;
+        wireframe: boolean;
+        worldUnits: boolean;
+        color: THREE.ColorRepresentation;
+        linewidth: number | undefined;
+        alphaToCoverage: boolean | undefined;
+        dashed: boolean | undefined;
+    }>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsLine, "ngts-line", never, { "lineRef": { "alias": "lineRef"; "required": false; }; "points": { "alias": "points"; "required": true; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
+}

package/abstractions/quadratic-bezier-line/quadratic-bezier-line.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import { Line2 } from 'three-stdlib';
+import { NgtsLineInputs } from '../line/line-input';
+import * as i0 from "@angular/core";
+declare module '../line/line-input' {
+    interface NgtsLineState {
+        start: THREE.Vector3 | [number, number, number];
+        end: THREE.Vector3 | [number, number, number];
+        mid?: THREE.Vector3 | [number, number, number];
+    }
+}
+export declare class NgtsQuadraticBezierLine extends NgtsLineInputs {
+    #private;
+    lineRef: import("angular-three").NgtInjectedRef<Line2>;
+    set start(start: THREE.Vector3 | [number, number, number]);
+    set end(end: THREE.Vector3 | [number, number, number]);
+    set mid(mid: THREE.Vector3 | [number, number, number]);
+    set segments(segments: number);
+    readonly points: import("@angular/core").Signal<THREE.Vector3[]>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsQuadraticBezierLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsQuadraticBezierLine, "ngts-quadratic-bezier-line", never, { "lineRef": { "alias": "lineRef"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "mid": { "alias": "mid"; "required": false; }; "segments": { "alias": "segments"; "required": false; }; }, {}, never, never, true, never>;
+}

package/abstractions/text/text.d.ts

@@ -0,0 +1,77 @@
+import { EventEmitter } from '@angular/core';
+import { NgtSignalStore, type NgtMesh } from 'angular-three';
+import * as i0 from "@angular/core";
+export type NgtsTextState = {
+    text: string;
+    /** Font size, default: 1 */
+    fontSize: number;
+    anchorX: number | 'left' | 'center' | 'right';
+    anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom';
+    sdfGlyphSize: number;
+    font?: string;
+    characters?: string;
+    color?: THREE.ColorRepresentation;
+    maxWidth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    clipRect?: [number, number, number, number];
+    depthOffset?: number;
+    direction?: 'auto' | 'ltr' | 'rtl';
+    overflowWrap?: 'normal' | 'break-word';
+    whiteSpace?: 'normal' | 'overflowWrap' | 'nowrap';
+    outlineWidth?: number | string;
+    outlineOffsetX?: number | string;
+    outlineOffsetY?: number | string;
+    outlineBlur?: number | string;
+    outlineColor?: THREE.ColorRepresentation;
+    outlineOpacity?: number;
+    strokeWidth?: number | string;
+    strokeColor?: THREE.ColorRepresentation;
+    strokeOpacity?: number;
+    fillOpacity?: number;
+    debugSDF?: boolean;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-text': NgtsTextState & NgtMesh;
+    }
+}
+export declare class NgtsText extends NgtSignalStore<NgtsTextState> {
+    #private;
+    textRef: import("angular-three").NgtInjectedRef<Text>;
+    set text(text: string);
+    set font(font: string);
+    set fontSize(fontSize: number);
+    set anchorX(anchorX: number | 'left' | 'center' | 'right');
+    set anchorY(anchorY: number | 'top' | 'top-baseline' | 'middle' | 'bottom-baseline' | 'bottom');
+    set sdfGlyphSize(sdfGlyphSize: number);
+    set characters(characters: string);
+    set color(color: THREE.ColorRepresentation);
+    set maxWidth(maxWidth: number);
+    set lineHeight(lineHeight: number);
+    set letterSpacing(letterSpacing: number);
+    set textAlign(textAlign: 'left' | 'right' | 'center' | 'justify');
+    set clipRect(clipRect: [number, number, number, number]);
+    set depthOffset(depthOffset: number);
+    set direction(direction: 'auto' | 'ltr' | 'rtl');
+    set overflowWrap(overflowWrap: 'normal' | 'break-word');
+    set whiteSpace(whiteSpace: 'normal' | 'overflowWrap' | 'nowrap');
+    set outlineWidth(outlineWidth: number | string);
+    set outlineOffsetX(outlineOffsetX: number | string);
+    set outlineOffsetY(outlineOffsetY: number | string);
+    set outlineBlur(outlineBlur: number | string);
+    set outlineColor(outlineColor: THREE.ColorRepresentation);
+    set outlineOpacity(outlineOpacity: number);
+    set strokeWidth(strokeWidth: number | string);
+    set strokeColor(strokeColor: THREE.ColorRepresentation);
+    set strokeOpacity(strokeOpacity: number);
+    set fillOpacity(fillOpacity: number);
+    set debugSDF(debugSDF: boolean);
+    sync: EventEmitter<Text>;
+    readonly troikaText: any;
+    readonly state: import("@angular/core").Signal<NgtsTextState>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText, "ngts-text", never, { "textRef": { "alias": "textRef"; "required": false; }; "text": { "alias": "text"; "required": true; }; "font": { "alias": "font"; "required": false; }; "fontSize": { "alias": "fontSize"; "required": false; }; "anchorX": { "alias": "anchorX"; "required": false; }; "anchorY": { "alias": "anchorY"; "required": false; }; "sdfGlyphSize": { "alias": "sdfGlyphSize"; "required": false; }; "characters": { "alias": "characters"; "required": false; }; "color": { "alias": "color"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "letterSpacing": { "alias": "letterSpacing"; "required": false; }; "textAlign": { "alias": "textAlign"; "required": false; }; "clipRect": { "alias": "clipRect"; "required": false; }; "depthOffset": { "alias": "depthOffset"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "overflowWrap": { "alias": "overflowWrap"; "required": false; }; "whiteSpace": { "alias": "whiteSpace"; "required": false; }; "outlineWidth": { "alias": "outlineWidth"; "required": false; }; "outlineOffsetX": { "alias": "outlineOffsetX"; "required": false; }; "outlineOffsetY": { "alias": "outlineOffsetY"; "required": false; }; "outlineBlur": { "alias": "outlineBlur"; "required": false; }; "outlineColor": { "alias": "outlineColor"; "required": false; }; "outlineOpacity": { "alias": "outlineOpacity"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeOpacity": { "alias": "strokeOpacity"; "required": false; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; }; "debugSDF": { "alias": "debugSDF"; "required": false; }; }, { "sync": "sync"; }, never, ["*"], true, never>;
+}

package/abstractions/text-3d/text-3d.d.ts

@@ -0,0 +1,74 @@
+import { NgtSignalStore, type NgtMesh } from 'angular-three';
+import { Mesh } from 'three';
+import * as i0 from "@angular/core";
+declare type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+declare type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+export type NgtsText3DState = {
+    font: FontData | string;
+    text: string;
+    letterSpacing: number;
+    lineHeight: number;
+    size: number;
+    height: number;
+    bevelThickness: number;
+    bevelSize: number;
+    bevelEnabled: boolean;
+    bevelOffset: number;
+    bevelSegments: number;
+    curveSegments: number;
+    smooth?: number;
+};
+declare global {
+    interface HTMLElementTagNameMap {
+        'ngts-text-3d': NgtsText3DState & NgtMesh;
+    }
+}
+export declare class NgtsText3D extends NgtSignalStore<NgtsText3DState> {
+    #private;
+    textRef: import("angular-three").NgtInjectedRef<Mesh<import("three").BufferGeometry, import("three").Material | import("three").Material[]>>;
+    set font(font: FontData | string);
+    set text(text: string);
+    set bevelEnabled(bevelEnabled: boolean);
+    set bevelOffset(bevelOffset: number);
+    set bevelSize(bevelSize: number);
+    set bevelThickness(bevelThickness: number);
+    set curveSegments(curveSegments: number);
+    set bevelSegments(bevelSegments: number);
+    set height(height: number);
+    set size(size: number);
+    set lineHeight(lineHeight: number);
+    set letterSpacing(letterSpacing: number);
+    set smooth(smooth: number);
+    constructor();
+    readonly geometryArgs: import("@angular/core").Signal<(string | {
+        font: import("three-stdlib").Font;
+        size: number;
+        height: number;
+        bevelThickness: number;
+        bevelSize: number;
+        bevelSegments: number;
+        bevelEnabled: boolean;
+        bevelOffset: number;
+        curveSegments: number;
+        letterSpacing: number;
+        lineHeight: number;
+    })[] | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtsText3D, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtsText3D, "ngts-text-3d", never, { "textRef": { "alias": "textRef"; "required": false; }; "font": { "alias": "font"; "required": true; }; "text": { "alias": "text"; "required": true; }; "bevelEnabled": { "alias": "bevelEnabled"; "required": false; }; "bevelOffset": { "alias": "bevelOffset"; "required": false; }; "bevelSize": { "alias": "bevelSize"; "required": false; }; "bevelThickness": { "alias": "bevelThickness"; "required": false; }; "curveSegments": { "alias": "curveSegments"; "required": false; }; "bevelSegments": { "alias": "bevelSegments"; "required": false; }; "height": { "alias": "height"; "required": false; }; "size": { "alias": "size"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "letterSpacing": { "alias": "letterSpacing"; "required": false; }; "smooth": { "alias": "smooth"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+export {};