angular-three 2.0.0-beta.286 → 2.0.0-beta.287

package/index.d.ts

@@ -1,9 +1,11 @@
 export * from './lib/canvas';
 export * from './lib/directives/args';
+export * from './lib/directives/selection';
 export * from './lib/html';
 export * from './lib/instance';
 export * from './lib/loader';
 export * from './lib/loop';
+export * from './lib/pipes/hexify';
 export * from './lib/portal';
 export * from './lib/renderer';
 export * from './lib/roots';

package/lib/directives/selection.d.ts

@@ -0,0 +1,109 @@
+import { ElementRef } from '@angular/core';
+import { Group, Object3D } from 'three';
+import * as i0 from "@angular/core";
+import * as i1 from "../utils/object-events";
+export declare class NgtSelection {
+    enabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    private selection;
+    collection: import("@angular/core").Signal<(Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>>)[]>;
+    select(...objects: Array<ElementRef<Object3D> | Object3D>): void;
+    unselect(...objects: Array<ElementRef<Object3D> | Object3D>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtSelection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtSelection, "[ngtSelection]", never, { "enabled": { "alias": "ngtSelection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class NgtSelect {
+    enabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    options: import("@angular/core").InputSignal<Partial<{
+        addEventListener: (<TEventKey extends keyof import("../three-types").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("../three-types").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("../three-types").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("../three-types").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("../three-types").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        removeEventListener: (<TEventKey extends keyof import("../three-types").NgtNodeEventMap<Group<import("three").Object3DEventMap>>>(type: TEventKey, listener: (this: import("../three-types").NgtNodeElement<Group<import("three").Object3DEventMap>, typeof Group>, ev: import("../three-types").NgtNodeEventMap<Group<import("three").Object3DEventMap>>[TEventKey]) => any) => void) & (<TEventKey extends keyof import("../three-types").NgtAllObject3DEventsMap>(type: TEventKey, listener: (this: any, ev: import("../three-types").NgtAllObject3DEventsMap[TEventKey]) => any) => void);
+        clone?: ((recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+        copy?: ((object: Object3D, recursive?: boolean) => Group<import("three").Object3DEventMap>) | undefined;
+        add?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        applyMatrix4?: ((matrix: import("three").Matrix4) => void) | undefined;
+        applyQuaternion?: ((quaternion: import("three").Quaternion) => Group<import("three").Object3DEventMap>) | undefined;
+        attach: string | string[] | import("angular-three").NgtAttachFunction;
+        __ngt_args__: [];
+        readonly type?: string | undefined;
+        readonly id?: number | undefined;
+        uuid?: string | undefined;
+        name?: string | undefined;
+        userData?: Record<string, any> | undefined;
+        rotateX?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateY?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateZ?: ((angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        lookAt?: {
+            (vector: import("three").Vector3): void;
+            (x: number, y: number, z: number): void;
+        } | undefined;
+        toJSON?: ((meta?: import("three").JSONMeta) => import("three").Object3DJSON) | undefined;
+        hasEventListener?: {
+            <T extends keyof import("three").Object3DEventMap>(type: T, listener: import("three").EventListener<import("three").Object3DEventMap[T], T, Group<import("three").Object3DEventMap>>): boolean;
+            <T extends string>(type: T, listener: import("three").EventListener<{}, T, Group<import("three").Object3DEventMap>>): boolean;
+        } | undefined;
+        dispatchEvent?: (<T extends keyof import("three").Object3DEventMap>(event: import("three").BaseEvent<T> & import("three").Object3DEventMap[T]) => void) | undefined;
+        visible?: boolean | undefined;
+        onBeforeRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+        readonly isObject3D?: true | undefined;
+        parent?: Object3D<import("three").Object3DEventMap> | null | undefined;
+        children?: Object3D<import("three").Object3DEventMap>[] | undefined;
+        readonly modelViewMatrix?: import("three").Matrix4 | undefined;
+        readonly normalMatrix?: import("three").Matrix3 | undefined;
+        matrixWorld?: import("three").Matrix4 | undefined;
+        matrixAutoUpdate?: boolean | undefined;
+        matrixWorldAutoUpdate?: boolean | undefined;
+        matrixWorldNeedsUpdate?: boolean | undefined;
+        castShadow?: boolean | undefined;
+        receiveShadow?: boolean | undefined;
+        frustumCulled?: boolean | undefined;
+        renderOrder?: number | undefined;
+        animations?: import("three").AnimationClip[] | undefined;
+        customDepthMaterial?: import("three").Material | undefined;
+        customDistanceMaterial?: import("three").Material | undefined;
+        onBeforeShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+        onAfterShadow?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, shadowCamera: import("three").Camera, geometry: import("three").BufferGeometry, depthMaterial: import("three").Material, group: Group) => void) | undefined;
+        onAfterRender?: ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: Group) => void) | undefined;
+        setRotationFromAxisAngle?: ((axis: import("three").Vector3, angle: number) => void) | undefined;
+        setRotationFromEuler?: ((euler: import("three").Euler) => void) | undefined;
+        setRotationFromMatrix?: ((m: import("three").Matrix4) => void) | undefined;
+        setRotationFromQuaternion?: ((q: import("three").Quaternion) => void) | undefined;
+        rotateOnAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        rotateOnWorldAxis?: ((axis: import("three").Vector3, angle: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateOnAxis?: ((axis: import("three").Vector3, distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateX?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateY?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        translateZ?: ((distance: number) => Group<import("three").Object3DEventMap>) | undefined;
+        localToWorld?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        worldToLocal?: ((vector: import("three").Vector3) => import("three").Vector3) | undefined;
+        remove?: ((...object: Object3D[]) => Group<import("three").Object3DEventMap>) | undefined;
+        removeFromParent?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        clear?: (() => Group<import("three").Object3DEventMap>) | undefined;
+        getObjectById?: ((id: number) => Object3D | undefined) | undefined;
+        getObjectByName?: ((name: string) => Object3D | undefined) | undefined;
+        getObjectByProperty?: ((name: string, value: any) => Object3D | undefined) | undefined;
+        getObjectsByProperty?: ((name: string, value: any, optionalTarget?: Object3D[]) => Object3D[]) | undefined;
+        getWorldPosition?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldQuaternion?: ((target: import("three").Quaternion) => import("three").Quaternion) | undefined;
+        getWorldScale?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        getWorldDirection?: ((target: import("three").Vector3) => import("three").Vector3) | undefined;
+        raycast?: ((raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void) | undefined;
+        traverse?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseVisible?: ((callback: (object: Object3D) => any) => void) | undefined;
+        traverseAncestors?: ((callback: (object: Object3D) => any) => void) | undefined;
+        updateMatrix?: (() => void) | undefined;
+        updateMatrixWorld?: ((force?: boolean) => void) | undefined;
+        updateWorldMatrix?: ((updateParents: boolean, updateChildren: boolean) => void) | undefined;
+        readonly isGroup?: true | undefined;
+        position: import("../three-types").NgtVector3;
+        up: import("../three-types").NgtVector3;
+        scale: import("../three-types").NgtVector3;
+        rotation: import("../three-types").NgtEuler;
+        matrix: import("../three-types").NgtMatrix4;
+        quaternion: import("../three-types").NgtQuaternion;
+        layers: import("../three-types").NgtLayers;
+        dispose: (() => void) | null;
+    }>>;
+    groupRef: import("@angular/core").Signal<ElementRef<Group<import("three").Object3DEventMap>>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtSelect, "ngt-select", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtObjectEvents; inputs: { "ngtObjectEvents": "ngtObjectEvents"; }; outputs: { "click": "click"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; "pointerup": "pointerup"; "pointerdown": "pointerdown"; "pointerover": "pointerover"; "pointerout": "pointerout"; "pointerenter": "pointerenter"; "pointerleave": "pointerleave"; "pointermove": "pointermove"; "pointermissed": "pointermissed"; "pointercancel": "pointercancel"; "wheel": "wheel"; }; }]>;
+}

package/lib/pipes/hexify.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+export declare class NgtHexify {
+    private document;
+    private ctx?;
+    /**
+     * transforms a:
+     * - hex string to a hex number
+     * - rgb string to a hex number
+     * - rgba string to a hex number
+     * - css color string to a hex number
+     *
+     * always default to black if failed
+     * @param value
+     */
+    transform(value: string): number;
+    private hexStringToNumber;
+    private componentToHex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtHexify, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NgtHexify, "hexify", true>;
+}

package/lib/utils/object-events.d.ts

@@ -2,6 +2,31 @@ import { ElementRef, Injector } from '@angular/core';
 import { Object3D } from 'three';
 import { supportedEvents } from '../dom/events';
 import { NgtDomEvent, NgtThreeEvent } from '../types';
+import * as i0 from "@angular/core";
+export declare class NgtObjectEvents {
+    click: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    dblclick: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    contextmenu: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointerup: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerdown: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerover: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerout: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerenter: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointerleave: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermove: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    pointermissed: import("@angular/core").OutputEmitterRef<NgtThreeEvent<MouseEvent>>;
+    pointercancel: import("@angular/core").OutputEmitterRef<NgtThreeEvent<PointerEvent>>;
+    wheel: import("@angular/core").OutputEmitterRef<NgtThreeEvent<WheelEvent>>;
+    ngtObjectEvents: import("@angular/core").ModelSignal<Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>> | null | undefined>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtObjectEvents, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtObjectEvents, "[ngtObjectEvents]", never, { "ngtObjectEvents": { "alias": "ngtObjectEvents"; "required": false; "isSignal": true; }; }, { "click": "click"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; "pointerup": "pointerup"; "pointerdown": "pointerdown"; "pointerover": "pointerover"; "pointerout": "pointerout"; "pointerenter": "pointerenter"; "pointerleave": "pointerleave"; "pointermove": "pointermove"; "pointermissed": "pointermissed"; "pointercancel": "pointercancel"; "wheel": "wheel"; "ngtObjectEvents": "ngtObjectEventsChange"; }, never, never, true, never>;
+}
+export declare const NgtObjectEventsHostDirective: {
+    directive: typeof NgtObjectEvents;
+    inputs: string[];
+    outputs: string[];
+};
 export declare function injectObjectEvents(target: () => ElementRef<Object3D> | Object3D | null | undefined, events: {
     [K in (typeof supportedEvents)[number]]?: (event: NgtThreeEvent<NgtDomEvent>) => void;
 }, { injector }?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three",
-  "version": "2.0.0-beta.286",
+  "version": "2.0.0-beta.287",
   "publishConfig": {
     "access": "public"
   },