angular-three 3.7.0 → 4.0.0-next.2

package/index.d.ts

@@ -1,4 +1,3 @@
-export * from './lib/canvas';
 export * from './lib/directives/args';
 export * from './lib/directives/parent';
 export * from './lib/directives/selection';
@@ -8,7 +7,10 @@ export * from './lib/loader';
 export * from './lib/loop';
 export * from './lib/pipes/hexify';
 export * from './lib/portal';
-export * from './lib/renderer';
+export * from './lib/events';
+export * from './lib/renderer/catalogue';
+export * from './lib/renderer/constants';
+export * from './lib/renderer/renderer';
 export * from './lib/roots';
 export * from './lib/routed-scene';
 export * from './lib/store';
@@ -21,7 +23,7 @@ export * from './lib/utils/object-events';
 export * from './lib/utils/output-ref';
 export * from './lib/utils/parameters';
 export * from './lib/utils/resolve-ref';
-export * from './lib/utils/signal-store';
+export * from './lib/utils/signal-state';
 export * from './lib/utils/update';
 export type * from './lib/three-types';
 export type * from './lib/types';

package/lib/directives/args.d.ts

@@ -1,15 +1,11 @@
+import { NgtCommonDirective } from './common';
 import * as i0 from "@angular/core";
-export declare class NgtArgs {
+export declare class NgtArgs extends NgtCommonDirective<any[]> {
     args: import("@angular/core").InputSignal<any[] | null>;
-    private vcr;
-    private template;
-    protected injected: boolean;
-    protected injectedArgs: any[] | null;
-    private view?;
+    protected linkedValue: import("@angular/core").WritableSignal<any[] | null>;
+    protected shouldSkipRender: import("@angular/core").Signal<boolean>;
     constructor();
-    get value(): any[] | null;
     validate(): boolean;
-    private createView;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtArgs, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs, "ng-template[args]", never, { "args": { "alias": "args"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/directives/common.d.ts

@@ -0,0 +1,20 @@
+import { Injector, Signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class NgtCommonDirective<TValue> {
+    private vcr;
+    private template;
+    protected injector: Injector;
+    protected injected: boolean;
+    protected injectedValue: TValue | null;
+    private view?;
+    protected get commentNode(): any;
+    abstract validate(): boolean;
+    protected abstract linkedValue: Signal<TValue | null>;
+    protected abstract shouldSkipRender: Signal<boolean>;
+    constructor();
+    get value(): TValue | null;
+    protected beforeCreateView(): void;
+    private createView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCommonDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtCommonDirective<any>, never, never, {}, {}, never, never, true, never>;
+}

package/lib/directives/parent.d.ts

@@ -1,21 +1,17 @@
 import { ElementRef } from '@angular/core';
-import { Object3D } from 'three';
+import type * as THREE from 'three';
 import { NgtNullish } from '../types';
+import { NgtCommonDirective } from './common';
 import * as i0 from "@angular/core";
-export declare class NgtParent {
-    parent: import("@angular/core").InputSignal<string | Object3D<import("three").Object3DEventMap> | ElementRef<Object3D<import("three").Object3DEventMap>> | (() => NgtNullish<ElementRef<Object3D> | Object3D | string>)>;
-    private vcr;
-    private template;
+export declare class NgtParent extends NgtCommonDirective<THREE.Object3D | null | undefined> {
+    parent: import("@angular/core").InputSignal<string | THREE.Object3D<THREE.Object3DEventMap> | ElementRef<THREE.Object3D<THREE.Object3DEventMap>> | (() => NgtNullish<ElementRef<THREE.Object3D> | THREE.Object3D | string>)>;
     private store;
-    private scene;
-    protected injected: boolean;
-    protected injectedParent: NgtNullish<Object3D>;
-    private view?;
     private _parent;
+    protected linkedValue: import("@angular/core").WritableSignal<THREE.Object3D<THREE.Object3DEventMap> | null | undefined>;
+    protected shouldSkipRender: import("@angular/core").Signal<boolean>;
     constructor();
-    get value(): NgtNullish<Object3D<import("three").Object3DEventMap>>;
     validate(): boolean;
-    private createView;
+    protected beforeCreateView(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtParent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtParent, "ng-template[parent]", never, { "parent": { "alias": "parent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/events.d.ts

@@ -1,7 +1,7 @@
-import { Object3D } from 'three';
-import { NgtDomEvent, NgtState } from './types';
-import { NgtSignalStore } from './utils/signal-store';
-export declare function removeInteractivity(store: NgtSignalStore<NgtState>, object: Object3D): void;
-export declare function createEvents(store: NgtSignalStore<NgtState>): {
+import * as THREE from 'three';
+import type { NgtDomEvent, NgtState } from './types';
+import { SignalState } from './utils/signal-state';
+export declare function removeInteractivity(store: SignalState<NgtState>, object: THREE.Object3D): void;
+export declare function createEvents(store: SignalState<NgtState>): {
     handlePointer: (name: string) => (event: NgtDomEvent) => void;
 };

package/lib/html.d.ts

@@ -1,5 +1,5 @@
-import { AbstractType, DestroyRef, ElementRef, InjectionToken, Provider, ProviderToken, Type } from '@angular/core';
-import { HTML } from './renderer';
+import { AbstractType, InjectionToken, Provider, ProviderToken, Type } from '@angular/core';
+import { NGT_HTML_FLAG } from './renderer/constants';
 import * as i0 from "@angular/core";
 export declare function provideHTMLDomElement(): Provider;
 export declare function provideHTMLDomElement(factory: () => HTMLElement): Provider;
@@ -7,10 +7,7 @@ export declare function provideHTMLDomElement<TDeps extends Array<ProviderToken<
     [K in keyof TDeps]: TDeps[K] extends Type<infer T> | AbstractType<infer T> | InjectionToken<infer T> ? T : never;
 }>(deps: TDeps, factory: (...args: TValues) => HTMLElement): Provider;
 export declare abstract class NgtHTML {
-    static [HTML]: boolean;
-    protected store: import("angular-three").NgtSignalStore<import("angular-three").NgtState>;
-    protected destroyRef: DestroyRef;
-    protected host: ElementRef<HTMLElement>;
+    static [NGT_HTML_FLAG]: boolean;
     protected domElement: HTMLElement | "gl" | null;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtHTML, never>;

package/lib/instance.d.ts

@@ -1,4 +1,8 @@
-import { NgtAnyRecord, NgtInstanceNode, NgtLocalState } from './types';
-export declare function getLocalState<TInstance extends object>(obj: TInstance | undefined): NgtLocalState | undefined;
-export declare function invalidateInstance<TInstance extends object>(instance: TInstance): void;
-export declare function prepare<TInstance extends object = NgtAnyRecord>(object: TInstance, localState?: Partial<NgtLocalState>): NgtInstanceNode<TInstance>;
+import type { NgtAnyRecord, NgtInstanceNode, NgtInstanceState } from './types';
+/**
+ * @deprecated: use `getInstanceState` instead. Will be removed in 5.0.0
+ */
+export declare function getLocalState<TInstance extends object>(obj: TInstance | undefined): NgtInstanceState | undefined;
+export declare function getInstanceState<TInstance extends NgtAnyRecord>(obj: TInstance | undefined): NgtInstanceState<TInstance> | undefined;
+export declare function invalidateInstance<TInstance extends NgtAnyRecord>(instance: NgtInstanceNode<TInstance>): void;
+export declare function prepare<TInstance extends NgtAnyRecord = NgtAnyRecord>(object: TInstance, type: string, instanceState?: Partial<NgtInstanceState>): NgtInstanceNode<TInstance>;

package/lib/loop.d.ts

@@ -1,6 +1,7 @@
-import { NgtCanvasElement, NgtGlobalRenderCallback, NgtState } from './types';
-import { NgtSignalStore } from './utils/signal-store';
-export declare const roots: Map<NgtCanvasElement, NgtSignalStore<NgtState>>;
+import { InjectionToken } from '@angular/core';
+import type { NgtCanvasElement, NgtGlobalRenderCallback, NgtState } from './types';
+import type { SignalState } from './utils/signal-state';
+export declare const roots: Map<NgtCanvasElement, SignalState<NgtState>>;
 /**
  * Adds a global render callback which is called each frame.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
@@ -18,26 +19,13 @@ export declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () =
 export declare const addTail: (callback: NgtGlobalRenderCallback) => () => 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;
+export declare const NGT_LOOP: InjectionToken<{
+    loop: (timestamp: number) => void;
+    invalidate: (store?: SignalState<NgtState>, frames?: number) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, store?: SignalState<NgtState>, frame?: XRFrame) => void;
+}>;
+export declare function injectLoop(): {
+    loop: (timestamp: number) => void;
+    invalidate: (store?: SignalState<NgtState>, frames?: number) => void;
+    advance: (timestamp: number, runGlobalEffects?: boolean, store?: SignalState<NgtState>, frame?: XRFrame) => void;
 };

package/lib/portal.d.ts

@@ -1,67 +1,48 @@
 import { Injector } from '@angular/core';
-import { Camera, Object3D, Scene } from 'three';
-import { NgtComputeFunction, NgtSize, NgtState } from './types';
+import * as THREE from 'three';
+import type { NgtComputeFunction, NgtState } from './types';
 import * as i0 from "@angular/core";
-export declare class NgtPortalBeforeRender {
+export declare class NgtPortalAutoRender {
     private portalStore;
-    renderPriority: import("@angular/core").InputSignal<number>;
-    parentScene: import("@angular/core").InputSignal<Scene>;
-    parentCamera: import("@angular/core").InputSignal<Camera>;
+    private parentStore;
+    private portal;
+    renderPriority: import("@angular/core").InputSignalWithTransform<number, unknown>;
     constructor();
-    onPointerOver(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalBeforeRender, 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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalAutoRender, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalAutoRender, "ngt-portal[autoRender]", never, { "renderPriority": { "alias": "autoRender"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 export declare class NgtPortalContent {
-    constructor();
     static ngTemplateContextGuard(_: NgtPortalContent, ctx: unknown): ctx is {
-        container: Object3D;
         injector: Injector;
     };
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortalContent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtPortalContent, "ng-template[portalContent]", never, {}, {}, never, never, true, never>;
 }
-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?: {
+export interface NgtPortalState extends Omit<NgtState, 'events'> {
+    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" | "events" | "size" | "invalidate" | "advance" | "setEvents" | "setSize" | "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>;
-    private portalContent;
-    private portalAnchor;
-    private injector;
+    container: import("@angular/core").InputSignal<THREE.Object3D<THREE.Object3DEventMap>>;
+    state: import("@angular/core").InputSignal<Partial<NgtPortalState>>;
+    private contentRef;
+    private anchorRef;
+    private previousStore;
     private portalStore;
-    private parentStore;
-    protected parentScene: import("@angular/core").Signal<Scene>;
-    protected parentCamera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
-    private raycaster;
-    private pointer;
-    private portalRendered;
-    protected shouldAutoRender: import("@angular/core").Signal<boolean>;
-    private portalView?;
+    private injector;
+    private size;
+    private events;
+    private restState;
+    private portalContentRendered;
+    portalRendered: import("@angular/core").Signal<boolean>;
+    private portalViewRef?;
     constructor();
-    private inject;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortal, 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>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, {}, ["contentRef", "anchorRef"], never, true, never>;
 }
+export declare const NgtPortalDeclarations: readonly [typeof NgtPortal, typeof NgtPortalContent];

package/lib/renderer/catalogue.d.ts

@@ -1,13 +1,5 @@
-export type NgtAnyConstructor = new (...args: any[]) => any;
+import { InjectionToken } from '@angular/core';
+import type { NgtConstructorRepresentation } from '../types';
 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;
-};
+export declare const NGT_CATALOGUE: InjectionToken<Record<string, NgtConstructorRepresentation>>;
+export declare function injectCatalogue(): Record<string, NgtConstructorRepresentation>;

package/lib/renderer/constants.d.ts

@@ -1,23 +1,12 @@
-export declare const ROUTED_SCENE = "__ngt_renderer_is_routed_scene__";
-export declare const HTML = "__ngt_renderer_is_html";
-export declare const NON_ROOT = "__ngt_renderer_is_non_root__";
-export declare const SPECIAL_INTERNAL_ADD_COMMENT = "__ngt_renderer_add_comment__";
-export declare const SPECIAL_INTERNAL_SET_PARENT_COMMENT = "__ngt_renderer_set_parent_comment__";
-export declare const DOM_PARENT = "__ngt_dom_parent__";
-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";
-};
+export declare const NGT_RENDERER_NODE_FLAG = "__ngt_renderer__";
+export declare const NGT_CANVAS_CONTENT_FLAG = "__ngt_renderer_canvas_content__";
+export declare const NGT_PORTAL_CONTENT_FLAG = "__ngt_renderer_portal_content__";
+export declare const NGT_ARGS_FLAG = "__ngt_renderer_args__";
+export declare const NGT_PARENT_FLAG = "__ngt_renderer_parent__";
+export declare const NGT_INTERNAL_ADD_COMMENT_FLAG = "__ngt_renderer_add_comment__";
+export declare const NGT_INTERNAL_SET_PARENT_COMMENT_FLAG = "__ngt_renderer_set_parent_comment__";
+export declare const NGT_GET_NODE_ATTRIBUTE_FLAG = "__ngt_get_node_attribute__";
+export declare const NGT_DOM_PARENT_FLAG = "__ngt_dom_parent__";
+export declare const NGT_DELEGATE_RENDERER_DESTROY_NODE_PATCHED_FLAG = "__ngt_delegate_renderer_destroy_node_patched__";
+export declare const NGT_HTML_FLAG = "__ngt_html__";
 export declare const THREE_NATIVE_EVENTS: string[];

package/lib/renderer/renderer.d.ts

@@ -0,0 +1,53 @@
+import { Renderer2, RendererFactory2, RendererType2 } from '@angular/core';
+import { NgtConstructorRepresentation } from '../types';
+import { NgtRendererNode } from './state';
+import * as i0 from "@angular/core";
+export declare class NgtRendererFactory2 implements RendererFactory2 {
+    private delegateRendererFactory;
+    private catalogue;
+    private document;
+    private rendererMap;
+    /**
+     * NOTE: We use `useFactory` to instantiate `NgtRendererFactory2`
+     */
+    constructor(delegateRendererFactory: RendererFactory2);
+    createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtRendererFactory2, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtRendererFactory2>;
+}
+export declare class NgtRenderer2 implements Renderer2 {
+    delegateRenderer: Renderer2;
+    private catalogue;
+    private document;
+    count: number;
+    private argsInjectors;
+    private parentInjectors;
+    private portalInjectors;
+    constructor(delegateRenderer: Renderer2, catalogue: Record<string, NgtConstructorRepresentation>, document: Document, count?: number);
+    get data(): {
+        [key: string]: any;
+    };
+    destroy(): void;
+    createElement(name: string, namespace?: string | null): NgtRendererNode<"three"> | NgtRendererNode<"platform"> | NgtRendererNode<"portal">;
+    createComment(value: string): NgtRendererNode<"comment">;
+    createText(value: string): NgtRendererNode<"text">;
+    destroyNode: (node: NgtRendererNode) => void;
+    appendChild(parent: NgtRendererNode, newChild: NgtRendererNode, refChild?: NgtRendererNode, isMove?: boolean): void;
+    insertBefore(parent: NgtRendererNode, newChild: NgtRendererNode, refChild: NgtRendererNode, isMove?: boolean): void;
+    removeChild(parent: NgtRendererNode, oldChild: NgtRendererNode, isHostElement?: boolean): void;
+    parentNode(node: NgtRendererNode): any;
+    removeAttribute(el: NgtRendererNode, name: string, namespace?: string | null): void;
+    setAttribute(el: NgtRendererNode, name: string, value: string, namespace?: string | null): void;
+    setProperty(el: NgtRendererNode, name: string, value: any): void;
+    listen(target: 'window' | 'document' | 'body' | NgtRendererNode, eventName: string, callback: (event: any) => boolean | void): () => void;
+    private appendThreeRendererNodes;
+    private setNodeRelationship;
+    private getNgtDirective;
+    addClass: (el: any, name: string) => void;
+    removeClass: (el: any, name: string) => 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;
+    selectRootElement: (selectorOrNode: string | any, preserveContent?: boolean) => any;
+    nextSibling: (node: any) => any;
+    setValue: (node: any, value: string) => void;
+}

package/lib/renderer/state.d.ts

@@ -1,25 +1,65 @@
-import { DebugNode } from '@angular/core';
-import { NgtAnyRecord } from '../types';
-import { NgtRendererClassId } from './utils';
-export type NgtRendererState = [
-    type: 'three' | 'portal' | 'comment' | 'dom',
-    parent: NgtRendererNode | null,
-    children: NgtRendererNode[],
+import { Injector } from '@angular/core';
+import type { NgtAnyRecord } from '../types';
+import { NGT_DOM_PARENT_FLAG, NGT_RENDERER_NODE_FLAG } from './constants';
+type ThreeRendererState = [
+    type: 'three',
     destroyed: boolean,
-    rawValue: any,
-    portalContainer: NgtRendererNode,
-    debugNode: DebugNode | undefined,
-    debugNodeFactory: () => DebugNode | undefined
+    rawValue: any | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode<'platform' | 'portal' | 'three'> | undefined,
+    children: Array<NgtRendererNode<'platform' | 'portal' | 'comment'>>
 ];
-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;
+type PortalRendererState = [
+    type: 'portal',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: NgtRendererNode<'three'> | undefined,
+    injector: Injector | undefined,
+    parent: any | undefined,
+    children: any[]
+];
+type PlatformRendererState = [
+    type: 'platform',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode<'three' | 'portal'> | undefined,
+    children: Array<NgtRendererNode<'three' | 'portal' | 'comment'>>
+];
+type CommentRendererState = [
+    type: 'comment',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: Injector | undefined,
+    parent: NgtRendererNode | undefined,
+    children: NgtRendererNode[]
+];
+type TextRendererState = [
+    type: 'text',
+    destroyed: boolean,
+    rawValue: never | undefined,
+    portalContainer: never | undefined,
+    injector: never | undefined,
+    parent: NgtRendererNode | undefined,
+    children: NgtRendererNode[]
+];
+type NgtRendererStateMap = {
+    three: ThreeRendererState;
+    portal: PortalRendererState;
+    platform: PlatformRendererState;
+    comment: CommentRendererState;
+    text: TextRendererState;
 };
-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;
+export type NgtRendererState = ThreeRendererState | PortalRendererState | PlatformRendererState | CommentRendererState | TextRendererState;
+export interface NgtRendererNode<TType extends keyof NgtRendererStateMap = keyof NgtRendererStateMap> extends NgtAnyRecord {
+    [NGT_RENDERER_NODE_FLAG]: NgtRendererStateMap[TType];
+    [NGT_DOM_PARENT_FLAG]?: HTMLElement;
+}
+export declare function isRendererNode(node: unknown): node is NgtRendererNode;
+export declare function createRendererNode<TType extends keyof NgtRendererStateMap>(type: TType, node: NgtAnyRecord, document: Document): NgtRendererNode<TType>;
+export declare function setRendererParentNode(node: NgtRendererNode, parent: NgtRendererNode): void;
+export declare function addRendererChildNode(node: NgtRendererNode, child: NgtRendererNode): void;
+export {};

package/lib/renderer/utils.d.ts

@@ -1,15 +1,15 @@
 import { NgtInstanceNode } from '../types';
+import { NgtRendererNode } from './state';
 export declare const enum NgtRendererClassId {
     type = 0,
-    parent = 1,
-    children = 2,
-    destroyed = 3,
-    rawValue = 4,
-    portalContainer = 5,
-    debugNode = 6,
-    debugNodeFactory = 7
+    destroyed = 1,
+    rawValue = 2,
+    portalContainer = 3,
+    injector = 4,
+    parent = 5,
+    children = 6
 }
 export declare function kebabToPascal(str: string): string;
-export declare function attachThreeChild(parent: NgtInstanceNode, child: NgtInstanceNode): void;
-export declare function removeThreeChild(child: NgtInstanceNode, parent?: NgtInstanceNode, dispose?: boolean): void;
-export declare function processThreeEvent(instance: NgtInstanceNode, priority: number, eventName: string, callback: (event: any) => void): () => void;
+export declare function attachThreeNodes(parent: NgtInstanceNode, child: NgtInstanceNode): void;
+export declare function removeThreeChild(child: NgtInstanceNode, parent: NgtInstanceNode, dispose?: boolean): void;
+export declare function internalDestroyNode(node: NgtRendererNode, removeChild: null | ((node: NgtRendererNode, child: NgtRendererNode) => void)): void;

package/lib/roots.d.ts

@@ -1,13 +1,9 @@
 import { Injector } from '@angular/core';
-import { NgtCanvasElement, NgtCanvasOptions } from './types';
+import type { NgtCanvasElement, NgtCanvasOptions, NgtDisposable } 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;
+export declare function dispose<T extends NgtDisposable>(obj: T): void;

package/lib/routed-scene.d.ts

@@ -1,15 +1,7 @@
-import { ChangeDetectorRef, EnvironmentInjector } from '@angular/core';
-import { ActivatedRoute, Router, RouterOutlet } from '@angular/router';
-import { ROUTED_SCENE } from './renderer/constants';
+import { ChangeDetectorRef } from '@angular/core';
+import { Router } from '@angular/router';
 import * as i0 from "@angular/core";
-export declare class NgtRouterOutlet extends RouterOutlet {
-    private environmentInjector;
-    activateWith(activatedRoute: ActivatedRoute, environmentInjector: EnvironmentInjector): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgtRouterOutlet, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtRouterOutlet, "ngt-router-outlet", never, {}, {}, never, never, true, never>;
-}
 export declare class NgtRoutedScene {
-    static [ROUTED_SCENE]: boolean;
     constructor(router: Router, cdr: ChangeDetectorRef);
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtRoutedScene, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtRoutedScene, "ngt-routed-scene", never, {}, {}, never, never, true, never>;

package/lib/store.d.ts

@@ -1,15 +1,10 @@
 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;
-};
+import type { NgtState } from './types';
+import { SignalState } from './utils/signal-state';
+export declare function storeFactory(): SignalState<NgtState>;
+export declare const NGT_STORE: InjectionToken<SignalState<NgtState>>;
 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 {};
+}): SignalState<NgtState>;
+export declare function injectStore(options: InjectOptions): SignalState<NgtState> | null;
+export declare function injectStore(): SignalState<NgtState>;