angular-three 0.0.0-replace

package/lib/directives/args.d.ts

@@ -0,0 +1,11 @@
+import { NgtCommonDirective } from './common';
+import * as i0 from "@angular/core";
+export declare class NgtArgs<TArgs extends any[] = any[]> extends NgtCommonDirective {
+    args: import("@angular/core").InputSignal<TArgs | null>;
+    private injectedArgs;
+    constructor();
+    get value(): TArgs | null;
+    validate(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtArgs<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtArgs<any>, "ng-template[args]", never, { "args": { "alias": "args"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/directives/common.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+export declare const injectNodeType: {
+    (): "" | "parent" | "args";
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): "" | "parent" | "args";
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): "" | "parent" | "args" | null;
+}, provideNodeType: (() => import("@angular/core").Provider) & (((value: "" | (() => "")) => import("@angular/core").Provider) | ((value: "parent" | (() => "parent")) => import("@angular/core").Provider) | ((value: "args" | (() => "args")) => import("@angular/core").Provider));
+export declare abstract class NgtCommonDirective {
+    private vcr;
+    private zone;
+    private template;
+    private nodeType;
+    protected injected: boolean;
+    protected shouldCreateView: boolean;
+    private view?;
+    constructor();
+    abstract validate(): boolean;
+    protected createView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtCommonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgtCommonDirective, never, never, {}, {}, never, never, false, never>;
+}

package/lib/directives/parent.d.ts

@@ -0,0 +1,13 @@
+import type * as THREE from 'three';
+import type { NgtRef } from '../ref';
+import { NgtCommonDirective } from './common';
+import * as i0 from "@angular/core";
+export declare class NgtParent extends NgtCommonDirective {
+    parent: import("@angular/core").InputSignal<string | NgtRef<THREE.Object3D<THREE.Object3DEventMap>>>;
+    private injectedParent;
+    constructor();
+    get value(): string | NgtRef<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    validate(): boolean;
+    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/dom/events.d.ts

@@ -0,0 +1,5 @@
+import { type NgtEventManager } from '../events';
+import type { NgtState } from '../store';
+import type { NgtSignalStore } from '../utils/signal-store';
+export declare const supportedEvents: readonly ["click", "contextmenu", "dblclick", "pointerup", "pointerdown", "pointerover", "pointerout", "pointerenter", "pointerleave", "pointermove", "pointermissed", "pointercancel", "wheel"];
+export declare function createPointerEvents(store: NgtSignalStore<NgtState>): NgtEventManager<HTMLElement>;

package/lib/events.d.ts

@@ -0,0 +1,83 @@
+import * as THREE from 'three';
+import type { NgtState } from './store';
+import type { NgtProperties } from './types';
+import type { NgtSignalStore } from './utils/signal-store';
+export interface NgtIntersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+export interface NgtIntersectionEvent<TSourceEvent> extends NgtIntersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+    /** An array of intersections */
+    intersections: NgtIntersection[];
+    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
+    unprojectedPoint: THREE.Vector3;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: THREE.Ray;
+    /** The camera that was used by the raycaster */
+    camera: NgtCamera;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** The original host event */
+    nativeEvent: TSourceEvent;
+    /** If the event was stopped by calling stopPropagation */
+    stopped: boolean;
+}
+export type NgtCamera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export type NgtThreeEvent<TEvent> = NgtIntersectionEvent<TEvent> & NgtProperties<TEvent>;
+export type NgtDomEvent = PointerEvent | MouseEvent | WheelEvent;
+export type NgtEventHandlers = {
+    click?: (event: NgtThreeEvent<MouseEvent>) => void;
+    contextmenu?: (event: NgtThreeEvent<MouseEvent>) => void;
+    dblclick?: (event: NgtThreeEvent<MouseEvent>) => void;
+    pointerup?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerdown?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerover?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerout?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerenter?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointerleave?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermove?: (event: NgtThreeEvent<PointerEvent>) => void;
+    pointermissed?: (event: MouseEvent) => void;
+    pointercancel?: (event: NgtThreeEvent<PointerEvent>) => void;
+    wheel?: (event: NgtThreeEvent<WheelEvent>) => void;
+};
+export type NgtEvents = {
+    [TEvent in keyof NgtEventHandlers]-?: EventListener;
+};
+export type NgtFilterFunction = (items: THREE.Intersection[], store: NgtSignalStore<NgtState>) => THREE.Intersection[];
+export type NgtComputeFunction = (event: NgtDomEvent, root: NgtSignalStore<NgtState>, previous: NgtSignalStore<NgtState> | null) => void;
+export type NgtEventManager<TTarget> = {
+    /** Determines if the event layer is active */
+    enabled: boolean;
+    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
+    priority: number;
+    /** The compute function needs to set up the raycaster and an xy- pointer  */
+    compute?: NgtComputeFunction;
+    /** The filter can re-order or re-structure the intersections  */
+    filter?: NgtFilterFunction;
+    /** The target node the event layer is tied to */
+    connected?: TTarget;
+    /** All the pointer event handlers through which the host forwards native events */
+    handlers?: NgtEvents;
+    /** Allows re-connecting to another target */
+    connect?: (target: TTarget) => void;
+    /** Removes all existing events handlers from the target */
+    disconnect?: () => void;
+    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
+     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
+     */
+    update?: () => void;
+};
+export interface NgtPointerCaptureTarget {
+    intersection: NgtIntersection;
+    target: Element;
+}
+export declare function removeInteractivity(store: NgtSignalStore<NgtState>, object: THREE.Object3D): void;
+export declare function createEvents(store: NgtSignalStore<NgtState>): {
+    handlePointer: (name: string) => (event: NgtDomEvent) => void;
+};

package/lib/instance.d.ts

@@ -0,0 +1,46 @@
+import type { Signal } from '@angular/core';
+import type { ReplaySubject } from 'rxjs';
+import type { NgtEventHandlers } from './events';
+import type { NgtState } from './store';
+import type { NgtAnyRecord } from './types';
+import { type NgtSignalStore } from './utils/signal-store';
+export type NgtAttachFunction<TChild = any, TParent = any> = (parent: TParent, child: TChild, store: NgtSignalStore<NgtState>) => void | (() => void);
+export type NgtAfterAttach<TChild extends NgtInstanceNode = NgtInstanceNode, TParent extends NgtInstanceNode = NgtInstanceNode> = {
+    parent: TParent;
+    node: TChild;
+};
+export type NgtLocalInstanceState = {
+    objects: NgtInstanceNode[];
+    nonObjects: NgtInstanceNode[];
+    parent: NgtInstanceNode | null;
+    nativeProps: NgtAnyRecord;
+};
+export type NgtLocalState = {
+    /** the store of the canvas that the instance is being rendered to */
+    store: NgtSignalStore<NgtState>;
+    instanceStore: NgtSignalStore<NgtLocalInstanceState>;
+    parent: Signal<NgtLocalInstanceState['parent']>;
+    objects: Signal<NgtLocalInstanceState['objects']>;
+    nonObjects: Signal<NgtLocalInstanceState['nonObjects']>;
+    nativeProps: Signal<NgtLocalInstanceState['nativeProps']>;
+    add: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    remove: (instance: NgtInstanceNode, type: 'objects' | 'nonObjects') => void;
+    setNativeProps: (key: string, value: any) => void;
+    setParent: (parent: NgtInstanceNode | null) => void;
+    primitive?: boolean;
+    eventCount: number;
+    handlers: Partial<NgtEventHandlers>;
+    args?: unknown[];
+    attach?: string[] | NgtAttachFunction;
+    previousAttach?: unknown | (() => void);
+    isRaw?: boolean;
+    priority?: number;
+    afterUpdate?: ReplaySubject<NgtInstanceNode>;
+    afterAttach?: ReplaySubject<NgtAfterAttach>;
+};
+export type NgtInstanceNode<TNode = any> = {
+    __ngt__: NgtLocalState;
+} & NgtAnyRecord & TNode;
+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>;

package/lib/loader.d.ts

@@ -0,0 +1,32 @@
+import { Injector, type Signal } from '@angular/core';
+import type * as THREE from 'three';
+import { type NgtObjectMap } from './utils/make';
+export type NgtGLTFLike = {
+    scene: THREE.Object3D;
+};
+export interface NgtLoader<T> extends THREE.Loader {
+    load(url: string, onLoad?: (result: T) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: unknown) => void): unknown;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<T>;
+}
+export type NgtLoaderProto<T> = new (...args: any) => NgtLoader<T extends unknown ? any : T>;
+export type NgtLoaderReturnType<T, L extends NgtLoaderProto<T>> = T extends unknown ? Awaited<ReturnType<InstanceType<L>['loadAsync']>> : T;
+export type NgtLoaderExtensions<T extends {
+    prototype: NgtLoaderProto<any>;
+}> = (loader: T['prototype']) => void;
+export type NgtConditionalType<Child, Parent, Truthy, Falsy> = Child extends Parent ? Truthy : Falsy;
+export type NgtBranchingReturn<T, Parent, Coerced> = NgtConditionalType<T, Parent, Coerced, T>;
+export type NgtLoaderResults<TInput extends string | string[] | Record<string, string>, TReturn> = TInput extends string[] ? TReturn[] : TInput extends object ? {
+    [key in keyof TInput]: TReturn;
+} : TReturn;
+declare function _injectNgtLoader<TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>, TReturn = NgtLoaderReturnType<TData, TLoaderConstructor>>(loaderConstructorFactory: (inputs: string[]) => TLoaderConstructor, inputs: () => TUrl, { extensions, onProgress, injector, }?: {
+    extensions?: NgtLoaderExtensions<TLoaderConstructor>;
+    onProgress?: (event: ProgressEvent) => void;
+    injector?: Injector;
+}): Signal<NgtLoaderResults<TUrl, NgtBranchingReturn<TReturn, NgtGLTFLike, NgtGLTFLike & NgtObjectMap>> | null>;
+declare namespace _injectNgtLoader {
+    var preload: <TData, TUrl extends string | string[] | Record<string, string>, TLoaderConstructor extends NgtLoaderProto<TData>>(loaderConstructorFactory: (inputs: string[]) => TLoaderConstructor, inputs: () => TUrl, extensions?: NgtLoaderExtensions<TLoaderConstructor> | undefined) => void;
+    var destroy: () => void;
+}
+export type NgtInjectedLoader = typeof _injectNgtLoader;
+export declare const injectNgtLoader: NgtInjectedLoader;
+export {};

package/lib/loop.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="webxr" />
+import type { NgtState } from './store';
+import type { NgtSignalStore } from './utils/signal-store';
+export type NgtGlobalRenderCallback = (timeStamp: number) => void;
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export declare const addEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export declare const addAfterEffect: (callback: NgtGlobalRenderCallback) => () => void;
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+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 injectNgtLoop: {
+    (): {
+        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;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        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;
+    };
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): {
+        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;
+    } | null;
+};

package/lib/portal.d.ts

@@ -0,0 +1,58 @@
+import { ElementRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import * as THREE from 'three';
+import type { NgtEventManager } from './events';
+import { type NgtSize, type NgtState } from './store';
+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 {
+    private portalStore;
+    private injector;
+    renderPriority: import("@angular/core").InputSignal<number>;
+    parentScene: import("@angular/core").InputSignal<THREE.Scene>;
+    parentCamera: import("@angular/core").InputSignal<THREE.Camera>;
+    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>;
+}
+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>;
+}
+export declare class NgtPortal {
+    options: import("@angular/core").InputSignalWithTransform<{
+        container: THREE.Object3D<THREE.Object3DEventMap> | ElementRef<THREE.Object3D<THREE.Object3DEventMap>>;
+        camera?: THREE.Camera | ElementRef<THREE.Camera> | undefined;
+        state?: Partial<Omit<NgtState, "setSize" | "set" | "viewport" | "events" | "size" | "invalidate" | "advance" | "setDpr" | "setFrameloop" | "get" | "select"> & {
+            events: Partial<Pick<NgtEventManager<any>, "enabled" | "priority" | "compute" | "connected">>;
+            size: NgtSize;
+        }> | undefined;
+    }, Partial<NgtPortalInputs>>;
+    autoRender: import("@angular/core").InputSignal<boolean>;
+    autoRenderPriority: import("@angular/core").InputSignal<number>;
+    portalContentTemplate: import("@angular/core").Signal<TemplateRef<any>>;
+    portalContentAnchor: import("@angular/core").Signal<ViewContainerRef>;
+    private destroyRef;
+    private autoEffect;
+    private parentStore;
+    private portalStore;
+    private portalRendered;
+    protected renderAutoBeforeRender: import("@angular/core").Signal<boolean>;
+    protected parentScene: THREE.Scene;
+    protected parentCamera: import("./store").NgtCameraManual;
+    constructor();
+    private inject;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtPortal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgtPortal, "ngt-portal", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "autoRender": { "alias": "autoRender"; "required": false; "isSignal": true; }; "autoRenderPriority": { "alias": "autoRenderPriority"; "required": false; "isSignal": true; }; }, {}, ["portalContentTemplate"], never, true, never>;
+}
+export {};

package/lib/ref.d.ts

@@ -0,0 +1,7 @@
+import { ElementRef, type Injector, type Signal } from '@angular/core';
+import { type NgtInstanceNode } from './instance';
+export type NgtInjectedRef<TElement> = ElementRef<TElement> & {
+    children: (type?: 'objects' | 'nonObjects' | 'both') => Signal<NgtInstanceNode[]>;
+};
+export type NgtRef<TElement> = TElement | NgtInjectedRef<TElement>;
+export declare function injectNgtRef<TElement>(initial?: ElementRef<TElement> | TElement, injector?: Injector): NgtInjectedRef<TElement>;

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 injectNgtCatalogue: {
+    (): Record<string, NgtAnyConstructor>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        optional?: false | undefined;
+    } & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): Record<string, NgtAnyConstructor>;
+    (injectOptions: import("@angular/core").InjectOptions & {
+        injector?: import("@angular/core").Injector | undefined;
+    }): Record<string, NgtAnyConstructor> | null;
+};

package/lib/renderer/constants.d.ts

@@ -0,0 +1,20 @@
+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 COMPOUND: "ngtCompound";
+    readonly RENDER_PRIORITY: "priority";
+    readonly ATTACH: "attach";
+    readonly RAW_VALUE: "rawValue";
+    readonly REF: "ref";
+};
+export declare const SPECIAL_EVENTS: {
+    readonly BEFORE_RENDER: "beforeRender";
+    readonly AFTER_UPDATE: "afterUpdate";
+    readonly AFTER_ATTACH: "afterAttach";
+};

package/lib/renderer/index.d.ts

@@ -0,0 +1,56 @@
+import { RendererFactory2, type Renderer2, type RendererType2 } from '@angular/core';
+import { type NgtState } from '../store';
+import type { NgtAnyRecord } from '../types';
+import { type NgtSignalStore } from '../utils/signal-store';
+import { type NgtAnyConstructor } from './catalogue';
+import { NgtRendererStore, type NgtRendererNode, type NgtRendererState } from './store';
+import * as i0 from "@angular/core";
+export declare class NgtRendererFactory implements RendererFactory2 {
+    private delegateRendererFactory;
+    private catalogue;
+    private rendererMap;
+    private routedSet;
+    private rendererStore;
+    createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgtRendererFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgtRendererFactory>;
+}
+export declare class NgtRenderer implements Renderer2 {
+    private delegate;
+    private store;
+    private catalogue;
+    private isRoot;
+    constructor(delegate: Renderer2, store: NgtRendererStore, catalogue: Record<string, NgtAnyConstructor>, isRoot?: boolean);
+    createElement(name: string, namespace?: string | null | undefined): NgtAnyRecord & {
+        __ngt_renderer__: NgtRendererState;
+    };
+    createComment(value: string): NgtAnyRecord & {
+        __ngt_renderer__: NgtRendererState;
+    };
+    appendChild(parent: NgtRendererNode, newChild: NgtRendererNode): void;
+    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 shouldFindGrandparentInstance;
+    createText: (value: string) => any;
+    destroy: () => void;
+    destroyNode: ((node: any) => void) | null;
+    selectRootElement: (selectorOrNode: any, preserveContent?: boolean | undefined) => any;
+    nextSibling: (node: any) => any;
+    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;
+    setValue: (node: any, value: string) => void;
+    get data(): {
+        [key: string]: any;
+    };
+}
+export declare function provideNgtRenderer(store: NgtSignalStore<NgtState>, compoundPrefixes: string[]): import("@angular/core").EnvironmentProviders;
+export { extend } from './catalogue';
+export { HTML, ROUTED_SCENE } from './constants';

package/lib/renderer/store.d.ts

@@ -0,0 +1,64 @@
+import { InjectionToken, Injector } from '@angular/core';
+import type { NgtRef } from '../ref';
+import { type NgtState } from '../store';
+import type { NgtAnyRecord } from '../types';
+import type { NgtSignalStore } from '../utils/signal-store';
+import { NgtRendererClassId } from './utils';
+export declare const NGT_COMPOUND_PREFIXES: InjectionToken<string[]>;
+type NgtQueueOp = [type: 'op' | 'cleanUp', op: () => void, done?: true];
+export type NgtRendererState = [
+    type: 'three' | 'compound' | 'portal' | 'comment' | 'dom',
+    parent: NgtRendererNode | null,
+    injectedParent: NgtRef<NgtRendererNode> | null,
+    children: NgtRendererNode[],
+    destroyed: boolean,
+    compound: [applyFirst: boolean, props: NgtAnyRecord],
+    compoundParent: NgtRendererNode,
+    compounded: NgtRendererNode,
+    queueOps: Set<NgtQueueOp>,
+    attributes: NgtAnyRecord,
+    properties: NgtAnyRecord,
+    rawValue: any,
+    ref: any,
+    portalContainer: NgtRendererNode,
+    injectorFactory: () => Injector | undefined
+];
+export type NgtRendererNode = {
+    __ngt_renderer__: NgtRendererState;
+};
+type NgtRendererRootState = {
+    store: NgtSignalStore<NgtState>;
+    compoundPrefixes: string[];
+    document: Document;
+};
+export declare class NgtRendererStore {
+    private rootState;
+    private argsCommentNodes;
+    private parentCommentNodes;
+    private portalCommentsNodes;
+    constructor(rootState: NgtRendererRootState);
+    createNode(type: NgtRendererState[NgtRendererClassId.type], node: NgtAnyRecord): NgtAnyRecord & {
+        __ngt_renderer__: NgtRendererState;
+    };
+    isCompound(name: string): boolean;
+    isDOM(node: NgtAnyRecord): boolean;
+    getClosestParentWithInstance(node: NgtRendererNode): NgtRendererNode | null;
+    getClosestParentWithCompound(node: NgtRendererNode): NgtRendererNode | null;
+    processPortalContainer(portal: NgtRendererNode): void;
+    getCreationState(): readonly [any[], string | NgtRef<import("three").Object3D<import("three").Object3DEventMap>> | null, NgtSignalStore<NgtState>];
+    setParent(node: NgtRendererNode, parent: NgtRendererNode): void;
+    addChild(node: NgtRendererNode, child: NgtRendererNode): void;
+    removeChild(node: NgtRendererNode, child: NgtRendererNode): void;
+    setCompound(compound: NgtRendererNode, instance: NgtRendererNode): void;
+    queueOperation(node: NgtRendererNode, op: NgtQueueOp): void;
+    private executeOperation;
+    applyAttribute(node: NgtRendererNode, name: string, value: string): void;
+    applyProperty(node: NgtRendererNode, name: string, value: any): void;
+    get rootScene(): import("three").Scene;
+    destroy(node: NgtRendererNode, parent?: NgtRendererNode): void;
+    private removeCommentNode;
+    private updateNativeProps;
+    private firstNonInjectedDirective;
+    private tryGetPortalStore;
+}
+export {};

package/lib/renderer/utils.d.ts

@@ -0,0 +1,31 @@
+import { type NgtInstanceNode } from '../instance';
+export declare const enum NgtRendererClassId {
+    type = 0,
+    parent = 1,
+    injectedParent = 2,
+    children = 3,
+    destroyed = 4,
+    compound = 5,
+    compoundParent = 6,
+    compounded = 7,
+    queueOps = 8,
+    attributes = 9,
+    properties = 10,
+    rawValue = 11,
+    ref = 12,
+    portalContainer = 13,
+    injectorFactory = 14
+}
+export declare const enum NgtCompoundClassId {
+    applyFirst = 0,
+    props = 1
+}
+export declare const enum NgtQueueOpClassId {
+    type = 0,
+    op = 1,
+    done = 2
+}
+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): () => void;

package/lib/roots.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@angular/core';
+import type { NgtCanvasInputs } from './canvas';
+import { type NgtState } from './store';
+import type { NgtSignalStore } from './utils/signal-store';
+export type NgtCanvasElement = HTMLCanvasElement | OffscreenCanvas;
+export declare const roots: Map<NgtCanvasElement, NgtSignalStore<NgtState>>;
+export declare function injectCanvasRootInitializer(injector?: Injector): (canvas: NgtCanvasElement) => {
+    isConfigured: boolean;
+    destroy: (timeout?: number) => void;
+    configure: (inputs: NgtCanvasInputs) => void;
+};
+export type NgtCanvasConfigurator = ReturnType<ReturnType<typeof injectCanvasRootInitializer>>;

package/lib/routed-scene.d.ts

@@ -0,0 +1,10 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { Router } from '@angular/router';
+import { ROUTED_SCENE } from './renderer/constants';
+import * as i0 from "@angular/core";
+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>;
+}