angular-three 2.0.0-beta.3 → 2.0.0-beta.300

package/lib/loop.d.ts

@@ -1,6 +1,6 @@
-import type { NgtSignalStore } from './stores/signal.store';
-import type { NgtState } from './types';
-export type NgtGlobalRenderCallback = (timestamp: number) => void;
+import { NgtCanvasElement, NgtGlobalRenderCallback, NgtState } from './types';
+import { NgtSignalStore } from './utils/signal-store';
+export declare const roots: Map<NgtCanvasElement, NgtSignalStore<NgtState>>;
 /**
  * Adds a global render callback which is called each frame.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
@@ -16,18 +16,28 @@ export declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () =
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
  */
 export declare const addTail: (callback: NgtGlobalRenderCallback) => () => void;
-export type GlobalEffectType = 'before' | 'after' | 'tail';
-export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
-export declare function createLoop<TCanvas>(roots: Map<TCanvas, NgtSignalStore<NgtState>>): {
-    loop: (timestamp: number) => void;
-    /**
-     * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
-     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
-     */
-    invalidate: (store?: NgtSignalStore<NgtState>, frames?: number) => void;
-    /**
-     * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
-     * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
-     */
-    advance: (timestamp: number, runGlobalEffects?: boolean, store?: NgtSignalStore<NgtState>, frame?: XRFrame) => void;
+export type NgtGlobalEffectType = 'before' | 'after' | 'tail';
+export declare function flushGlobalEffects(type: NgtGlobalEffectType, timestamp: number): void;
+export declare const injectLoop: {
+    (): {
+        loop: (timestamp: number) => void;
+        invalidate: (store?: NgtSignalStore<NgtState>, frames?: number) => void;
+        advance: (timestamp: number, runGlobalEffects?: boolean, store?: NgtSignalStore<NgtState>, frame?: XRFrame) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        loop: (timestamp: number) => void;
+        invalidate: (store?: NgtSignalStore<NgtState>, frames?: number) => void;
+        advance: (timestamp: number, runGlobalEffects?: boolean, store?: NgtSignalStore<NgtState>, frame?: XRFrame) => void;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector;
+    }): {
+        loop: (timestamp: number) => void;
+        invalidate: (store?: NgtSignalStore<NgtState>, frames?: number) => void;
+        advance: (timestamp: number, runGlobalEffects?: boolean, store?: NgtSignalStore<NgtState>, frame?: XRFrame) => void;
+    } | null;
 };

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/portal.d.ts

@@ -1,53 +1,67 @@
-import { EventEmitter, TemplateRef, ViewContainerRef, type ElementRef, type OnInit } from '@angular/core';
-import * as THREE from 'three';
-import { NgtSignalStore } from './stores/signal.store';
-import type { NgtEventManager, NgtRenderState, NgtSize, NgtState } from './types';
+import { Injector, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Camera, Object3D, Scene } from 'three';
+import { NgtComputeFunction, NgtSize, NgtState } from './types';
 import * as i0 from "@angular/core";
-declare const privateKeys: readonly ["get", "set", "select", "setSize", "setDpr", "setFrameloop", "events", "invalidate", "advance", "size", "viewport"];
-type PrivateKeys = (typeof privateKeys)[number];
-export interface NgtPortalInputs {
-    container: ElementRef<THREE.Object3D> | THREE.Object3D;
-    camera: ElementRef<THREE.Camera> | THREE.Camera;
-    state: Partial<Omit<NgtState, PrivateKeys> & {
-        events: Partial<Pick<NgtEventManager<any>, 'enabled' | 'priority' | 'compute' | 'connected'>>;
-        size: NgtSize;
-    }>;
-}
-export declare class NgtPortalBeforeRender implements OnInit {
-    #private;
-    renderPriority: number;
-    parentScene: THREE.Scene;
-    parentCamera: THREE.Camera;
-    beforeRender: EventEmitter<NgtRenderState>;
+export declare class NgtPortalBeforeRender {
+    private portalStore;
+    renderPriority: import("@angular/core").InputSignal<number>;
+    parentScene: import("@angular/core").InputSignal<Scene>;
+    parentCamera: import("@angular/core").InputSignal<Camera>;
     constructor();
-    ngOnInit(): void;
+    onPointerOver(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalBeforeRender, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalBeforeRender, "[ngtPortalBeforeRender]", never, { "renderPriority": { "alias": "renderPriority"; "required": false; }; "parentScene": { "alias": "parentScene"; "required": true; }; "parentCamera": { "alias": "parentCamera"; "required": true; }; }, { "beforeRender": "beforeRender"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortalBeforeRender, "ngt-portal-before-render", never, { "renderPriority": { "alias": "renderPriority"; "required": false; "isSignal": true; }; "parentScene": { "alias": "parentScene"; "required": true; "isSignal": true; }; "parentCamera": { "alias": "parentCamera"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class NgtPortalContent {
-    constructor(vcr: ViewContainerRef, parentVcr: ViewContainerRef);
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalContent, [null, { skipSelf: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalContent, "ng-template[ngtPortalContent]", never, {}, {}, never, never, true, never>;
+    constructor();
+    static ngTemplateContextGuard(_: NgtPortalContent, ctx: unknown): ctx is {
+        container: Object3D;
+        injector: Injector;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalContent, "ng-template[portalContent]", never, {}, {}, never, never, true, never>;
 }
-export declare class NgtPortal extends NgtSignalStore<NgtPortalInputs> implements OnInit {
-    #private;
-    set container(container: NgtPortalInputs['container']);
-    set state(state: NgtPortalInputs['state']);
-    autoRender: boolean;
-    autoRenderPriority: number;
-    beforeRender: EventEmitter<{
-        root: NgtRenderState;
-        portal: NgtRenderState;
-    }>;
-    readonly portalContentTemplate: TemplateRef<unknown>;
-    readonly portalContentAnchor: ViewContainerRef;
-    readonly parentScene: THREE.Scene;
-    readonly parentCamera: import("./types").NgtCameraManual;
-    portalContentRendered: boolean;
+export declare const privateKeys: readonly ["setSize", "setFrameloop", "setDpr", "events", "setEvents", "invalidate", "advance", "size", "viewport"];
+export type NgtPortalPrivateKeys = (typeof privateKeys)[number];
+export type NgtPortalInjectableState = Partial<Omit<NgtState, NgtPortalPrivateKeys> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: NgtComputeFunction;
+        connected?: any;
+    };
+    size?: NgtSize;
+}>;
+export declare class NgtPortal {
+    container: import("@angular/core").InputSignal<Object3D<import("three").Object3DEventMap>>;
+    state: import("@angular/core").InputSignal<Partial<Omit<NgtState, "viewport" | "size" | "setSize" | "events" | "invalidate" | "advance" | "setEvents" | "setDpr" | "setFrameloop"> & {
+        events?: {
+            enabled?: boolean;
+            priority?: number;
+            compute?: NgtComputeFunction;
+            connected?: any;
+        };
+        size?: NgtSize;
+    }>>;
+    /**
+     * @decsription turn this on to enable "HUD" like rendering
+     */
+    autoRender: import("@angular/core").InputSignal<boolean>;
+    autoRenderPriority: import("@angular/core").InputSignal<number>;
+    portalContent: import("@angular/core").Signal<TemplateRef<any>>;
+    portalAnchor: import("@angular/core").Signal<ViewContainerRef>;
+    private injector;
+    private portalStore;
+    private parentStore;
+    parentScene: import("@angular/core").Signal<Scene>;
+    parentCamera: import("@angular/core").Signal<import("./types").NgtCameraManual>;
+    private raycaster;
+    private pointer;
+    private portalRendered;
+    renderAutoBeforeRender: import("@angular/core").Signal<boolean>;
+    private portalView?;
     constructor();
-    ngOnInit(): void;
-    onBeforeRender(portal: NgtRenderState): void;
+    private inject;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortal, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": false; }; "state": { "alias": "state"; "required": false; }; "autoRender": { "alias": "autoRender"; "required": false; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; }; }, { "beforeRender": "beforeRender"; }, ["portalContentTemplate"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "autoRender": { "alias": "autoRender"; "required": false; "isSignal": true; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; "isSignal": true; }; }, {}, ["portalContent"], never, true, never>;
 }
-export {};

package/lib/renderer/catalogue.d.ts

@@ -0,0 +1,13 @@
+export type NgtAnyConstructor = new (...args: any[]) => any;
+export declare function extend(objects: object): void;
+export declare const injectCatalogue: {
+    (): Record<string, NgtAnyConstructor>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false;
+    } & {
+        injector?: import("@angular/core").Injector;
+    }): Record<string, NgtAnyConstructor>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector;
+    }): Record<string, NgtAnyConstructor> | null;
+};

package/lib/renderer/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const ROUTED_SCENE = "__ngt_renderer_is_routed_scene__";
+export declare const HTML = "__ngt_renderer_is_html";
+export declare const SPECIAL_INTERNAL_ADD_COMMENT = "__ngt_renderer_add_comment__";
+export declare const SPECIAL_DOM_TAG: {
+    readonly NGT_PORTAL: "ngt-portal";
+    readonly NGT_PRIMITIVE: "ngt-primitive";
+    readonly NGT_VALUE: "ngt-value";
+};
+export declare const SPECIAL_PROPERTIES: {
+    readonly RENDER_PRIORITY: "priority";
+    readonly ATTACH: "attach";
+    readonly RAW_VALUE: "rawValue";
+    readonly PARAMETERS: "parameters";
+};
+export declare const SPECIAL_EVENTS: {
+    readonly BEFORE_RENDER: "beforeRender";
+    readonly UPDATED: "updated";
+    readonly ATTACHED: "attached";
+};

package/lib/renderer/{renderer.d.ts → index.d.ts}

@@ -1,24 +1,30 @@
-import { ChangeDetectorRef, NgZone, Renderer2, RendererFactory2, type RendererType2 } from '@angular/core';
-import type { NgtAnyRecord } from '../types';
-import { NgtRendererStore, type NgtRendererNode, type NgtRendererState } from './store';
+import { Renderer2, RendererFactory2, RendererType2 } from '@angular/core';
+import { NgtAnyRecord, NgtState } from '../types';
+import { NgtSignalStore } from '../utils/signal-store';
+import { NgtAnyConstructor } from './catalogue';
+import { NgtRendererNode, NgtRendererState } from './state';
 import * as i0 from "@angular/core";
 export declare class NgtRendererFactory implements RendererFactory2 {
-    #private;
+    private delegateRendererFactory;
+    private document;
+    private catalogue;
+    private rootStore;
+    private portalCommentsNodes;
+    private rendererMap;
+    private routedSet;
     createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtRendererFactory, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgtRendererFactory>;
 }
-/**
- * Anything abbreviated with rS/RS stands for RendererState
- */
 export declare class NgtRenderer implements Renderer2 {
-    private readonly delegate;
-    private readonly store;
-    private readonly catalogue;
-    private readonly zone;
-    private readonly cdr;
-    private root;
-    constructor(delegate: Renderer2, store: NgtRendererStore, catalogue: Record<string, new (...args: any[]) => any>, zone: NgZone, cdr: ChangeDetectorRef, root?: boolean);
+    private delegate;
+    private rootStore;
+    private document;
+    private portalCommentsNodes;
+    private catalogue;
+    private isRoot;
+    private argsCommentNodes;
+    constructor(delegate: Renderer2, rootStore: NgtSignalStore<NgtState>, document: Document, portalCommentsNodes: Array<NgtRendererNode>, catalogue: Record<string, NgtAnyConstructor>, isRoot?: boolean);
     createElement(name: string, namespace?: string | null | undefined): NgtAnyRecord & {
         __ngt_renderer__: NgtRendererState;
     };
@@ -29,21 +35,31 @@ export declare class NgtRenderer implements Renderer2 {
     insertBefore(parent: NgtRendererNode, newChild: NgtRendererNode): void;
     removeChild(parent: NgtRendererNode, oldChild: NgtRendererNode, isHostElement?: boolean | undefined): void;
     parentNode(node: NgtRendererNode): any;
+    private setAttributeInternal;
     setAttribute(el: NgtRendererNode, name: string, value: string, namespace?: string | null | undefined): void;
+    removeAttribute(el: NgtRendererNode, name: string, namespace?: string | null | undefined): void;
     setProperty(el: NgtRendererNode, name: string, value: any): void;
     listen(target: NgtRendererNode, eventName: string, callback: (event: any) => boolean | void): () => void;
+    private destroyInternal;
+    private removeCommentNode;
+    private processPortalContainer;
+    private shouldFindGrandparentInstance;
+    private getNgtArgs;
+    private tryGetPortalStore;
     createText: (value: string) => any;
     destroy: () => void;
     destroyNode: ((node: any) => void) | null;
-    selectRootElement: (selectorOrNode: any, preserveContent?: boolean | undefined) => any;
+    selectRootElement: (selectorOrNode: string | any, preserveContent?: boolean) => any;
     nextSibling: (node: any) => any;
-    removeAttribute: (el: any, name: string, namespace?: string | null | undefined) => void;
     addClass: (el: any, name: string) => void;
     removeClass: (el: any, name: string) => void;
-    setStyle: (el: any, style: string, value: any, flags?: import("@angular/core").RendererStyleFlags2 | undefined) => void;
-    removeStyle: (el: any, style: string, flags?: import("@angular/core").RendererStyleFlags2 | undefined) => void;
+    setStyle: (el: any, style: string, value: any, flags?: import("@angular/core").RendererStyleFlags2) => void;
+    removeStyle: (el: any, style: string, flags?: import("@angular/core").RendererStyleFlags2) => void;
     setValue: (node: any, value: string) => void;
     get data(): {
         [key: string]: any;
     };
 }
+export declare function provideNgtRenderer(store: NgtSignalStore<NgtState>): import("@angular/core").EnvironmentProviders;
+export { extend } from './catalogue';
+export { HTML, ROUTED_SCENE } from './constants';

package/lib/renderer/state.d.ts

@@ -0,0 +1,24 @@
+import { Injector } from '@angular/core';
+import { NgtAnyRecord } from '../types';
+import { NgtRendererClassId } from './utils';
+export type NgtRendererState = [
+    type: 'three' | 'portal' | 'comment' | 'dom',
+    parent: NgtRendererNode | null,
+    children: NgtRendererNode[],
+    destroyed: boolean,
+    rawValue: any,
+    portalContainer: NgtRendererNode,
+    injectorFactory: () => Injector | undefined
+];
+export interface NgtRendererNode {
+    __ngt_renderer__: NgtRendererState;
+    __ngt_dom_parent__?: HTMLElement;
+}
+export declare function createNode(type: NgtRendererState[NgtRendererClassId.type], node: NgtAnyRecord, document: Document): NgtAnyRecord & {
+    __ngt_renderer__: NgtRendererState;
+};
+export declare function isDOM(node: NgtAnyRecord): boolean;
+export declare function getClosestParentWithInstance(node: NgtRendererNode): NgtRendererNode | null;
+export declare function setParent(node: NgtRendererNode, parent: NgtRendererNode): void;
+export declare function addChild(node: NgtRendererNode, child: NgtRendererNode): void;
+export declare function removeChild(node: NgtRendererNode, child: NgtRendererNode): void;

package/lib/renderer/utils.d.ts

@@ -1,22 +1,14 @@
-import { ChangeDetectorRef, NgZone } from '@angular/core';
-import { supportedEvents } from '../dom/events';
-import type { NgtEventHandlers, NgtInstanceNode } from '../types';
-export declare const ROUTED_SCENE = "__ngt_renderer_is_routed_scene__";
-export declare const SPECIAL_INTERNAL_ADD_COMMENT = "__ngt_renderer_add_comment__";
-export declare const SPECIAL_DOM_TAG: {
-    readonly NGT_PORTAL: "ngt-portal";
-    readonly NGT_PRIMITIVE: "ngt-primitive";
-    readonly NGT_VALUE: "ngt-value";
-};
-export declare const SPECIAL_PROPERTIES: {
-    readonly COMPOUND: "ngtCompound";
-    readonly RENDER_PRIORITY: "priority";
-    readonly ATTACH: "attach";
-    readonly VALUE: "rawValue";
-    readonly REF: "ref";
-};
+import { NgtInstanceNode } from '../types';
+export declare const enum NgtRendererClassId {
+    type = 0,
+    parent = 1,
+    children = 2,
+    destroyed = 3,
+    rawValue = 4,
+    portalContainer = 5,
+    injectorFactory = 6
+}
+export declare function kebabToPascal(str: string): string;
 export declare function attachThreeChild(parent: NgtInstanceNode, child: NgtInstanceNode): void;
 export declare function removeThreeChild(parent: NgtInstanceNode, child: NgtInstanceNode, dispose?: boolean): void;
-export declare function processThreeEvent(instance: NgtInstanceNode, priority: number, eventName: string, callback: (event: any) => void, zone: NgZone, cdr: ChangeDetectorRef, targetCdr?: ChangeDetectorRef | null): () => void;
-export declare function eventToHandler(callback: (event: any) => void): (event: Parameters<Exclude<NgtEventHandlers[(typeof supportedEvents)[number]], undefined>>[0]) => void;
-export declare function kebabToPascal(str: string): string;
+export declare function processThreeEvent(instance: NgtInstanceNode, priority: number, eventName: string, callback: (event: any) => void): () => void;

package/lib/roots.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { NgtCanvasElement, NgtCanvasOptions } from './types';
+export declare function injectCanvasRootInitializer(injector?: Injector): (canvas: NgtCanvasElement) => {
+    isConfigured: boolean;
+    destroy: (timeout?: number) => void;
+    configure: (inputs: NgtCanvasOptions) => void;
+};
+export type NgtCanvasConfigurator = ReturnType<ReturnType<typeof injectCanvasRootInitializer>>;
+export declare function dispose<TObj extends {
+    dispose?: () => void;
+    type?: string;
+    [key: string]: any;
+}>(obj: TObj): void;

package/lib/routed-scene.d.ts

@@ -1,6 +1,6 @@
 import { ChangeDetectorRef } from '@angular/core';
 import { Router } from '@angular/router';
-import { ROUTED_SCENE } from './renderer/utils';
+import { ROUTED_SCENE } from './renderer/constants';
 import * as i0 from "@angular/core";
 export declare class NgtRoutedScene {
     static [ROUTED_SCENE]: boolean;

package/lib/store.d.ts

@@ -0,0 +1,15 @@
+import { InjectOptions, InjectionToken } from '@angular/core';
+import { NgtState } from './types';
+import { NgtSignalStore } from './utils/signal-store';
+declare function storeFactory(previousStore: NgtSignalStore<NgtState> | null): NgtSignalStore<NgtState>;
+export declare const NGT_STORE: InjectionToken<NgtSignalStore<NgtState>>;
+export declare function provideStore(store?: () => NgtSignalStore<NgtState>): {
+    provide: InjectionToken<NgtSignalStore<NgtState>>;
+    useFactory: typeof storeFactory;
+};
+export declare function injectStore(options: InjectOptions & {
+    optional?: false;
+}): NgtSignalStore<NgtState>;
+export declare function injectStore(options: InjectOptions): NgtSignalStore<NgtState> | null;
+export declare function injectStore(): NgtSignalStore<NgtState>;
+export {};