@types/three 0.179.0 → 0.181.0

three/src/nodes/accessors/TextureNode.d.ts

@@ -1,14 +1,13 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class TextureNode extends UniformNode<Texture> {
     readonly isTextureNode: true;
 
-    uvNode: ShaderNodeObject<Node> | null;
-    levelNode: ShaderNodeObject<Node> | null;
-    biasNode: ShaderNodeObject<Node> | null;
+    uvNode: Node | null;
+    levelNode: Node | null;
+    biasNode: Node | null;
     compareNode: Node | null;
     depthNode: Node | null;
     gradNode: Node | null;
@@ -20,9 +19,9 @@ export default class TextureNode extends UniformNode<Texture> {
 
     constructor(
         value?: Texture,
-        uvNode?: ShaderNodeObject<Node> | null,
-        levelNode?: ShaderNodeObject<Node> | null,
-        biasNode?: ShaderNodeObject<Node> | null,
+        uvNode?: Node | null,
+        levelNode?: Node | null,
+        biasNode?: Node | null,
     );
 
     getDefaultUV(): Node;
@@ -34,47 +33,55 @@ export default class TextureNode extends UniformNode<Texture> {
     /**
      * @deprecated
      */
-    uv(uvNode: Node): ShaderNodeObject<Node>;
+    uv(uvNode: Node): Node;
 
-    sample(uvNode: Node): ShaderNodeObject<Node>;
+    sample(uvNode: Node): Node;
 
-    load(uvNode: Node): ShaderNodeObject<Node>;
+    load(uvNode: Node): Node;
 
-    blur(amountNode: Node): ShaderNodeObject<Node>;
+    blur(amountNode: Node): Node;
 
-    level(levelNode: Node): ShaderNodeObject<Node>;
+    level(levelNode: Node): Node;
 
-    size(levelNode: Node): ShaderNodeObject<Node>;
+    size(levelNode: Node): Node;
 
-    bias(biasNode: Node): ShaderNodeObject<Node>;
+    bias(biasNode: Node): Node;
 
-    compare(compareNode: Node): ShaderNodeObject<Node>;
+    getBase(): TextureNode;
 
-    grad(gradeNodeX: Node, gradeNodeY: Node): ShaderNodeObject<Node>;
+    compare(compareNode: Node): Node;
 
-    depth(depthNode: Node): ShaderNodeObject<Node>;
+    grad(gradeNodeX: Node, gradeNodeY: Node): Node;
+
+    depth(depthNode: Node): Node;
 
     clone(): this;
 }
 
 export const texture: (
-    value?: Texture,
+    value?: Texture | TextureNode,
     uvNode?: Node | null,
     levelNode?: Node | number | null,
     biasNode?: Node | null,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
 
 export const uniformTexture: (
     value?: Texture,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
 
 export const textureLoad: (
-    value?: Texture,
+    value?: Texture | TextureNode,
     uvNode?: Node,
     levelNode?: Node | number,
     biasNode?: Node,
-) => ShaderNodeObject<TextureNode>;
+) => TextureNode;
+
+export const textureLevel: (
+    value: Texture | TextureNode,
+    uv: Node,
+    level: Node,
+) => TextureNode;
 
-export const sampler: (value: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const sampler: (value: Texture | TextureNode) => Node;
 
-export const samplerComparison: (value: Texture | TextureNode) => ShaderNodeObject<Node>;
+export const samplerComparison: (value: Texture | TextureNode) => Node;

three/src/nodes/accessors/TextureSizeNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class TextureSizeNode extends Node {
     readonly isTextureSizeNode: true;
@@ -15,4 +14,4 @@ export default TextureSizeNode;
 export const textureSize: (
     textureNode: Node,
     levelNode?: Node | null,
-) => ShaderNodeObject<TextureSizeNode>;
+) => TextureSizeNode;

three/src/nodes/accessors/UV.d.ts

@@ -1,4 +1,3 @@
 import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const uv: (index?: number) => ShaderNodeObject<AttributeNode>;
+export const uv: (index?: number) => AttributeNode;

three/src/nodes/accessors/UniformArrayNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "../utils/ArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
@@ -18,9 +17,9 @@ declare class UniformArrayNode extends BufferNode<unknown[]> {
 
     getPaddedType(): string;
 
-    element(indexNode: Node): ShaderNodeObject<UniformArrayElementNode>;
+    element: (indexNode: Node) => UniformArrayElementNode;
 }
 
 export default UniformArrayNode;
 
-export const uniformArray: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformArrayNode>;
+export const uniformArray: (values: unknown[], nodeType?: string | null) => UniformArrayNode;

three/src/nodes/accessors/UserDataNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ReferenceNode from "./ReferenceNode.js";
 
 export type NodeUserData = Record<string, any>;
@@ -12,4 +11,4 @@ export const userData: (
     name: string,
     inputType: string,
     userData?: NodeUserData,
-) => ShaderNodeObject<UserDataNode>;
+) => UserDataNode;

three/src/nodes/accessors/VelocityNode.d.ts

@@ -1,7 +1,6 @@
 import { Matrix4 } from "../../math/Matrix4.js";
 import TempNode from "../core/TempNode.js";
 import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class VelocityNode extends TempNode {
     projectionMatrix: Matrix4 | null;
@@ -17,4 +16,4 @@ declare class VelocityNode extends TempNode {
 
 export default VelocityNode;
 
-export const velocity: ShaderNodeObject<VelocityNode>;
+export const velocity: VelocityNode;

three/src/nodes/accessors/VertexColorNode.d.ts

@@ -1,5 +1,4 @@
 import AttributeNode from "../core/AttributeNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class VertexColorNode extends AttributeNode {
     readonly isVertexColorNode: true;
@@ -9,4 +8,4 @@ export default class VertexColorNode extends AttributeNode {
     constructor(index: number);
 }
 
-export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;
+export const vertexColor: (index?: number) => VertexColorNode;

three/src/nodes/code/CodeNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;
@@ -17,7 +16,7 @@ export default class CodeNode extends Node {
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
 
-export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => ShaderNodeObject<CodeNode>;
-export const js: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
-export const wgsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
-export const glsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => CodeNode;
+export const js: (src: string, includes?: CodeNodeInclude[]) => CodeNode;
+export const wgsl: (src: string, includes?: CodeNodeInclude[]) => CodeNode;
+export const glsl: (src: string, includes?: CodeNodeInclude[]) => CodeNode;

three/src/nodes/code/ExpressionNode.d.ts

@@ -1,5 +1,4 @@
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ExpressionNode extends TempNode {
     snipped: string;
@@ -7,4 +6,4 @@ export default class ExpressionNode extends TempNode {
     constructor(snipped?: string, nodeType?: string);
 }
 
-export const expression: (snipped: string, nodeType?: string) => ShaderNodeObject<ExpressionNode>;
+export const expression: (snipped: string, nodeType?: string) => ExpressionNode;

three/src/nodes/code/FunctionCallNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ProxiedObject, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ProxiedObject } from "../tsl/TSLCore.js";
 import FunctionNode, { FunctionNodeArguments } from "./FunctionNode.js";
 
 export default class FunctionCallNode<P extends Array<Node | number> | { [name: string]: Node | number }>
@@ -18,10 +18,11 @@ export default class FunctionCallNode<P extends Array<Node | number> | { [name:
 export const call: <P extends FunctionNodeArguments>(
     functionNode?: FunctionNode<P>,
     parameters?: ProxiedObject<P>,
-) => ShaderNodeObject<FunctionCallNode<P>>;
+) => FunctionCallNode<P>;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        call: typeof call;
+declare module "../Nodes.js" {
+    interface FunctionNode<P extends FunctionNodeArguments> {
+        call: (parameters?: ProxiedObject<P>) => FunctionCallNode<P>;
+        callAssign: (parameters?: ProxiedObject<P>) => this;
     }
 }

three/src/nodes/code/FunctionNode.d.ts

@@ -2,9 +2,8 @@ import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import NodeFunction from "../core/NodeFunction.js";
 import NodeFunctionInput from "../core/NodeFunctionInput.js";
-import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ProxiedObject, ProxiedTuple } from "../tsl/TSLCore.js";
 import CodeNode, { CodeNodeInclude } from "./CodeNode.js";
-import FunctionCallNode from "./FunctionCallNode.js";
 
 export type FunctionNodeArguments = Array<Node | number> | { [name: string]: Node | number };
 
@@ -13,7 +12,6 @@ export default class FunctionNode<P extends Array<Node | number> | { [name: stri
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
     getNodeFunction(builder: NodeBuilder): NodeFunction;
-    call(parameters: P): FunctionCallNode<P>;
 }
 
 type FnParameters<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
@@ -24,15 +22,15 @@ export const nativeFn: <P extends FunctionNodeArguments>(
     includes?: CodeNodeInclude[],
     language?: string,
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;
 
 export const glslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;
 export const wgslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => (...params: FnParameters<P>) => ShaderNodeObject<Node>;
+) => (...params: FnParameters<P>) => Node;

three/src/nodes/code/ScriptableNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class Resources extends Map<string, unknown> {
     get<TArgs extends unknown[]>(key: string, callback?: ((...args: TArgs) => void) | null, ...params: TArgs): unknown;
@@ -19,4 +18,4 @@ export default ScriptableNode;
 export const scriptable: (
     codeNode: Node,
     parameters?: Record<string, unknown>,
-) => ShaderNodeObject<ScriptableNode>;
+) => ScriptableNode;

three/src/nodes/code/ScriptableValueNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ScriptableValueNode extends Node {
     constructor(value: unknown);
@@ -7,4 +6,4 @@ declare class ScriptableValueNode extends Node {
 
 export default ScriptableValueNode;
 
-export const scriptableValue: (value: unknown) => ShaderNodeObject<ScriptableValueNode>;
+export const scriptableValue: (value: unknown) => ScriptableValueNode;

three/src/nodes/core/ArrayNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import TempNode from "./TempNode.js";
 
@@ -13,14 +12,15 @@ declare class ArrayNode extends TempNode {
 export default ArrayNode;
 
 interface ArrayFunction {
-    (values: Node[]): ShaderNodeObject<ArrayNode>;
-    (nodeType: string, count: number): ShaderNodeObject<ArrayNode>;
+    (values: Node[]): ArrayNode;
+    (nodeType: string, count: number): ArrayNode;
 }
 
 export const array: ArrayFunction;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        toArray: typeof array;
+declare module "../Nodes.js" {
+    interface Node {
+        toArray: (count: number) => ArrayNode;
+        toArrayAssign: (count: number) => this;
     }
 }

three/src/nodes/core/AssignNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import TempNode from "./TempNode.js";
@@ -13,10 +12,4 @@ declare class AssignNode extends TempNode {
 
 export default AssignNode;
 
-export const assign: (targetNode: Node, sourceNode: Node | number) => ShaderNodeObject<AssignNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        assign: typeof assign;
-    }
-}
+export const assign: (targetNode: Node, sourceNode: Node | number) => AssignNode;

three/src/nodes/core/AttributeNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
@@ -13,4 +12,4 @@ export default class AttributeNode extends Node {
 export const attribute: (
     name: string,
     nodeType?: string | null,
-) => ShaderNodeObject<AttributeNode>;
+) => AttributeNode;

three/src/nodes/core/BypassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export default class BypassNode extends Node {
@@ -9,10 +8,11 @@ export default class BypassNode extends Node {
     constructor(returnNode: Node, callNode: Node);
 }
 
-export const bypass: (returnNode: Node, callNode: Node) => ShaderNodeObject<BypassNode>;
+export const bypass: (returnNode: Node, callNode: Node) => BypassNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        bypass: typeof bypass;
+declare module "../Nodes.js" {
+    interface Node {
+        bypass: (callNode: Node) => BypassNode;
+        bypassAssign: (callNode: Node) => this;
     }
 }

three/src/nodes/core/ContextNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
@@ -13,18 +12,35 @@ declare class ContextNode extends Node {
 
 export default ContextNode;
 
-export const context: (node: Node, context?: NodeBuilderContext) => ShaderNodeObject<ContextNode>;
-export const setName: (node: Node, label: string) => ShaderNodeObject<ContextNode>;
+export const context: (node: Node, context?: NodeBuilderContext) => ContextNode;
+
+export const uniformFlow: (node: Node) => ContextNode;
+
+export const setName: (node: Node, label: string) => Node;
 
 /**
  * @deprecated "label()" has been deprecated. Use "setName()" instead.
  */
-export function label(node: Node, label: string): ShaderNodeObject<ContextNode>;
+export function label(node: Node, label: string): Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        context: (context?: NodeBuilderContext) => ContextNode;
+        contextAssign: (context?: NodeBuilderContext) => this;
+
+        /**
+         * @deprecated "label()" has been deprecated. Use "setName()" instead.
+         */
+        label: (label: string) => Node;
+        /**
+         * @deprecated "label()" has been deprecated. Use "setName()" instead.
+         */
+        labelAssign: (label: string) => this;
+
+        uniformFlow: () => ContextNode;
+        uniformFlowAssign: () => this;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        context: typeof context;
-        label: typeof label;
-        setName: typeof setName;
+        setName: (label: string) => Node;
+        setNameAssign: (label: string) => this;
     }
 }

three/src/nodes/core/IndexNode.d.ts

@@ -1,10 +1,11 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 export type IndexNodeScope =
     | typeof IndexNode.VERTEX
     | typeof IndexNode.INSTANCE
+    | typeof IndexNode.SUBGROUP
     | typeof IndexNode.INVOCATION_LOCAL
+    | typeof IndexNode.INVOCATION_SUBGROUP
     | typeof IndexNode.DRAW;
 
 declare class IndexNode extends Node {
@@ -16,15 +17,17 @@ declare class IndexNode extends Node {
 
     static VERTEX: "vertex";
     static INSTANCE: "instance";
+    static SUBGROUP: "subgroup";
     static INVOCATION_LOCAL: "invocationLocal";
+    static INVOCATION_SUBGROUP: "invocationSubgroup";
     static DRAW: "draw";
 }
 
 export default IndexNode;
 
-export const vertexIndex: ShaderNodeObject<IndexNode>;
-export const instanceIndex: ShaderNodeObject<IndexNode>;
-export const subgroupIndex: ShaderNodeObject<IndexNode>;
-export const invocationSubgroupIndex: ShaderNodeObject<IndexNode>;
-export const invocationLocalIndex: ShaderNodeObject<IndexNode>;
-export const drawIndex: ShaderNodeObject<IndexNode>;
+export const vertexIndex: IndexNode;
+export const instanceIndex: IndexNode;
+export const subgroupIndex: IndexNode;
+export const invocationSubgroupIndex: IndexNode;
+export const invocationLocalIndex: IndexNode;
+export const drawIndex: IndexNode;

three/src/nodes/core/InspectorNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "./Node.js";
+
+declare class InspectorNode extends Node {
+    constructor(node: Node, name?: string, callback?: (node: Node) => Node);
+}
+
+export default InspectorNode;
+
+export function inspector<T extends Node>(node: T, name?: string, callback?: (node: T) => Node): T;
+
+declare module "../Nodes.js" {
+    interface Node {
+        toInspector: (name?: string, callback?: (node: this) => Node) => this;
+        toInspectorAssign: (name?: string, callback?: (node: this) => Node) => this;
+    }
+}

three/src/nodes/core/IsolateNode.d.ts

@@ -0,0 +1,36 @@
+import Node from "./Node.js";
+import NodeCache from "./NodeCache.js";
+
+declare class IsolateNode extends Node {
+    node: Node;
+    parent: boolean;
+
+    readonly isIsolateNode: true;
+
+    constructor(node: Node, parent?: boolean);
+}
+
+export default IsolateNode;
+
+export const isolate: (node: Node) => IsolateNode;
+
+/**
+ * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+ */
+export const cache: (node: Node, cache?: NodeCache) => IsolateNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        /**
+         * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+         */
+        cache: (cache?: NodeCache) => IsolateNode;
+        /**
+         * @deprecated "cache()" has been deprecated. Use "isolate()" instead.
+         */
+        cacheAssign: (cache?: NodeCache) => this;
+
+        isolate: () => IsolateNode;
+        isolateAssign: () => this;
+    }
+}

three/src/nodes/core/MRTNode.d.ts

@@ -1,6 +1,5 @@
 import { Texture } from "../../textures/Texture.js";
 import { Node } from "../Nodes.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import OutputStructNode from "./OutputStructNode.js";
 
 export function getTextureIndex(textures: ReadonlyArray<Texture>, name: string): number;
@@ -14,11 +13,11 @@ declare class MRTNode extends OutputStructNode {
 
     has(name: string): boolean;
 
-    get(name: string): Node;
+    get: (name: string) => Node;
 
-    merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
+    merge(mrtNode: MRTNode): MRTNode;
 }
 
 export default MRTNode;
 
-export const mrt: (outputNodes: { [name: string]: Node }) => ShaderNodeObject<MRTNode>;
+export const mrt: (outputNodes: { [name: string]: Node }) => MRTNode;

three/src/nodes/core/Node.d.ts

@@ -57,6 +57,11 @@ interface NodeJSONOutputData {
     images?: unknown[];
     nodes?: NodeJSONOutputData[];
 }
+export interface NodeChild {
+    property: string;
+    index?: number | string;
+    childNode: Node;
+}
 /**
  * Base class for all nodes.
  *
@@ -72,6 +77,7 @@ declare class Node extends EventDispatcher<{
     updateAfterType: NodeUpdateType;
     uuid: string;
     version: number;
+    name: string | null;
     _cacheKey: number | null;
     _cacheKeyVersion: number;
     global: boolean;
@@ -139,13 +145,6 @@ declare class Node extends EventDispatcher<{
      * @return {Node} A reference to this node.
      */
     onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
-    /**
-     * The `this` reference might point to a Proxy so this method can be used
-     * to get the reference to the actual node instance.
-     *
-     * @return {Node} A reference to the node.
-     */
-    getSelf(): this;
     /**
      * Nodes might refer to other objects like materials. This method allows to dynamically update the reference
      * to such objects based on a given state (e.g. the current node frame or builder).
@@ -187,13 +186,22 @@ declare class Node extends EventDispatcher<{
      * @param {traverseCallback} callback - A callback that is executed per node.
      */
     traverse(callback: (node: Node) => void): void;
+    /**
+     * Returns the child nodes of this node.
+     *
+     * @private
+     * @param {Set<Node>} [ignores=new Set()] - A set of nodes to ignore during the search to avoid circular references.
+     * @returns {Array<Object>} An array of objects describing the child nodes.
+     */
+    _getChildren(ignores?: Set<Node>): NodeChild[];
     /**
      * Returns the cache key for this node.
      *
      * @param {boolean} [force=false] - When set to `true`, a recomputation of the cache key is forced.
+     * @param {Set<Node>} [ignores=null] - A set of nodes to ignore during the computation of the cache key.
      * @return {number} The cache key of the node.
      */
-    getCacheKey(force?: boolean): number;
+    getCacheKey(force?: boolean, ignores?: Set<Node> | null): number;
     /**
      * Generate a custom cache key for this node.
      *
@@ -296,7 +304,7 @@ declare class Node extends EventDispatcher<{
      * This state builds the output node and returns the resulting shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {?string} output - Can be used to define the output type.
+     * @param {?string} [output] - Can be used to define the output type.
      * @return {?string} The generated shader string.
      */
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
@@ -327,6 +335,7 @@ declare class Node extends EventDispatcher<{
      * @return {?boolean} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
      */
     update(frame: NodeFrame): void;
+    before(node: Node): this;
     /**
      * This method performs the build of a node. The behavior and return value depend on the current build stage:
      * - **setup**: Prepares the node and its children for the build process. This process can also create new nodes. Returns the node itself or a variant.
@@ -334,16 +343,16 @@ declare class Node extends EventDispatcher<{
      * - **generate**: Generates the shader code for the node. Returns the generated shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {string|Node|null} [output=null] - Can be used to define the output type.
-     * @return {Node|string|null} The result of the build process, depending on the build stage.
+     * @param {?(string|Node)} [output=null] - Can be used to define the output type.
+     * @return {?(Node|string)} The result of the build process, depending on the build stage.
      */
     build(builder: NodeBuilder, output?: string | Node | null): Node | string | null;
     /**
      * Returns the child nodes as a JSON object.
      *
-     * @return {Array<Object>} An iterable list of serialized child objects as JSON.
+     * @return {Generator<Object>} An iterable list of serialized child objects as JSON.
      */
-    getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
+    getSerializeChildren(): NodeChild[];
     /**
      * Serializes the node to JSON.
      *

three/src/nodes/core/NodeUtils.d.ts

@@ -6,20 +6,10 @@ import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Node from "./Node.js";
 
-export interface NodeChild {
-    property: string;
-    index?: number | string;
-    childNode: Node;
-}
-
 export const hashString: (str: string) => number;
 export const hashArray: (array: number[]) => number;
 export const hash: (...params: number[]) => number;
 
-export function getCacheKey(object: Node, force?: boolean): number;
-
-export function getNodeChildren(object: Node): Generator<NodeChild, void>;
-
 export function getTypeFromLength(length: number): string | undefined;
 
 export function getLengthFromType(type: string): number | undefined;