@types/three 0.182.0 → 0.183.0

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

@@ -2,6 +2,7 @@ import { EventDispatcher } from "../../core/EventDispatcher.js";
 import { NodeUpdateType } from "./constants.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
+
 interface NodeJSONMeta {
     textures: {
         [key: string]: unknown;
@@ -13,11 +14,13 @@ interface NodeJSONMeta {
         [key: string]: NodeJSONIntermediateOutputData;
     };
 }
+
 interface NodeJSONMetadata {
     version: number;
     type: "Node";
     generator: "Node.toJSON";
 }
+
 interface NodeJSONInputNodes {
     [property: string]:
         | string[]
@@ -27,6 +30,7 @@ interface NodeJSONInputNodes {
         | string
         | undefined;
 }
+
 export interface NodeJSONInputData {
     inputNodes?: NodeJSONInputNodes | undefined;
     meta: {
@@ -38,6 +42,7 @@ export interface NodeJSONInputData {
         };
     };
 }
+
 export interface NodeJSONIntermediateOutputData {
     uuid: string;
     type: string | undefined;
@@ -48,6 +53,7 @@ export interface NodeJSONIntermediateOutputData {
     images?: unknown[];
     nodes?: NodeJSONIntermediateOutputData[];
 }
+
 interface NodeJSONOutputData {
     uuid: string;
     type: string | undefined;
@@ -57,40 +63,123 @@ interface NodeJSONOutputData {
     images?: unknown[];
     nodes?: NodeJSONOutputData[];
 }
+
 export interface NodeChild {
     property: string;
     index?: number | string;
     childNode: Node;
 }
+
 /**
  * Base class for all nodes.
  *
  * @augments EventDispatcher
  */
-declare class Node extends EventDispatcher<{
-    dispose: {};
-}> {
+declare class NodeClass extends EventDispatcher<{ dispose: {} }> {
     static get type(): string;
+    /**
+     * Constructs a new node.
+     *
+     * @param {?string} nodeType - The node type.
+     */
+    constructor(nodeType?: string | null);
+    /**
+     * The node type. This represents the result type of the node (e.g. `float` or `vec3`).
+     *
+     * @type {?string}
+     * @default null
+     */
     nodeType: string | null;
+    /**
+     * The update type of the node's {@link Node#update} method. Possible values are listed in {@link NodeUpdateType}.
+     *
+     * @type {string}
+     * @default 'none'
+     */
     updateType: NodeUpdateType;
+    /**
+     * The update type of the node's {@link Node#updateBefore} method. Possible values are listed in {@link NodeUpdateType}.
+     *
+     * @type {string}
+     * @default 'none'
+     */
     updateBeforeType: NodeUpdateType;
+    /**
+     * The update type of the node's {@link Node#updateAfter} method. Possible values are listed in {@link NodeUpdateType}.
+     *
+     * @type {string}
+     * @default 'none'
+     */
     updateAfterType: NodeUpdateType;
-    uuid: string;
-    version: number;
-    name: string | null;
-    _cacheKey: number | null;
-    _cacheKeyVersion: number;
+    /**
+     * The UUID of the node.
+     *
+     * @type {string}
+     * @readonly
+     */
+    readonly uuid: string;
+    /**
+     * The version of the node. The version automatically is increased when {@link Node#needsUpdate} is set to `true`.
+     *
+     * @type {number}
+     * @readonly
+     * @default 0
+     */
+    readonly version: number;
+    /**
+     * The name of the node.
+     *
+     * @type {string}
+     * @default ''
+     */
+    name: string;
+    /**
+     * Whether this node is global or not. This property is relevant for the internal
+     * node caching system. All nodes which should be declared just once should
+     * set this flag to `true` (a typical example is {@link AttributeNode}).
+     *
+     * @type {boolean}
+     * @default false
+     */
     global: boolean;
+    /**
+     * Create a list of parents for this node during the build process.
+     *
+     * @type {boolean}
+     * @default false
+     */
     parents: boolean;
-    readonly isNode: true;
-    readonly id: number;
-    self?: this;
     /**
-     * Constructs a new node.
+     * This flag can be used for type testing.
      *
-     * @param {?string} nodeType - The node type.
+     * @type {boolean}
+     * @readonly
+     * @default true
      */
-    constructor(nodeType?: string | null);
+    readonly isNode: boolean;
+    /**
+     * The cache key of this node.
+     *
+     * @private
+     * @type {?number}
+     * @default null
+     */
+    private _cacheKey;
+    /**
+     * The cache key's version.
+     *
+     * @private
+     * @type {number}
+     * @default 0
+     */
+    private _cacheKeyVersion;
+    /**
+     * The stack trace of the node for debugging purposes.
+     *
+     * @type {?string}
+     * @default null
+     */
+    stackTrace: string | null;
     /**
      * Set this property to `true` when the node should be regenerated.
      *
@@ -105,7 +194,7 @@ declare class Node extends EventDispatcher<{
      * @type {string}
      * @readonly
      */
-    get type(): string | undefined;
+    get type(): string;
     /**
      * Convenient method for defining {@link Node#update}.
      *
@@ -114,6 +203,15 @@ declare class Node extends EventDispatcher<{
      * @return {Node} A reference to this node.
      */
     onUpdate(callback: (this: this, frame: NodeFrame) => unknown, updateType: NodeUpdateType): this;
+    /**
+     * The method can be implemented to update the node's internal state when it is used to render an object.
+     * The {@link Node#updateType} property defines how often the update is executed.
+     *
+     * @abstract
+     * @param {NodeFrame} frame - A reference to the current node frame.
+     * @return {?boolean} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
+     */
+    update(frame: NodeFrame): boolean | undefined;
     /**
      * Convenient method for defining {@link Node#update}. Similar to {@link Node#onUpdate}, but
      * this method automatically sets the update type to `FRAME`.
@@ -168,18 +266,12 @@ declare class Node extends EventDispatcher<{
      * @generator
      * @yields {Node} A child node.
      */
-    getChildren(): Generator<Node, void, unknown>;
+    getChildren(): Generator<Node<unknown>, void, unknown>;
     /**
      * Calling this method dispatches the `dispose` event. This event can be used
      * to register event listeners for clean up tasks.
      */
     dispose(): void;
-    /**
-     * Callback for {@link Node#traverse}.
-     *
-     * @callback traverseCallback
-     * @param {Node} node - The current node.
-     */
     /**
      * Can be used to traverse through the node's hierarchy.
      *
@@ -193,7 +285,7 @@ declare class Node extends EventDispatcher<{
      * @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[];
+    private _getChildren;
     /**
      * Returns the cache key for this node.
      *
@@ -201,7 +293,7 @@ declare class Node extends EventDispatcher<{
      * @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, ignores?: Set<Node> | null): number;
+    getCacheKey(force?: boolean, ignores?: Set<Node>): number;
     /**
      * Generate a custom cache key for this node.
      *
@@ -249,7 +341,7 @@ declare class Node extends EventDispatcher<{
      * @param {NodeBuilder} builder - The current node builder.
      * @return {string} The type of the node.
      */
-    getElementType(builder: NodeBuilder): "bool" | "int" | "float" | "vec2" | "vec3" | "vec4" | "uint" | null;
+    getElementType(builder: NodeBuilder): string;
     /**
      * Returns the node member type for the given name.
      *
@@ -264,7 +356,7 @@ declare class Node extends EventDispatcher<{
      * @param {NodeBuilder} builder - The current node builder.
      * @return {string} The type of the node.
      */
-    getNodeType(builder: NodeBuilder): string | null;
+    getNodeType(builder: NodeBuilder): string;
     /**
      * This method is used during the build process of a node and ensures
      * equal nodes are not built multiple times but just once. For example if
@@ -290,7 +382,7 @@ declare class Node extends EventDispatcher<{
      * @param {NodeBuilder} builder - The current node builder.
      * @return {?Node} The output node.
      */
-    setup(builder: NodeBuilder): unknown;
+    setup(builder: NodeBuilder): Node | null | undefined;
     /**
      * Represents the analyze stage which is the second step of the build process, see {@link Node#build} method.
      * This stage analyzes the node hierarchy and ensures descendent nodes are built.
@@ -316,7 +408,7 @@ declare class Node extends EventDispatcher<{
      * @param {NodeFrame} frame - A reference to the current node frame.
      * @return {?boolean} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
      */
-    updateBefore(frame: NodeFrame): void;
+    updateBefore(frame: NodeFrame): boolean | undefined;
     /**
      * The method can be implemented to update the node's internal state after it was used to render an object.
      * The {@link Node#updateAfterType} property defines how often the update is executed.
@@ -325,16 +417,7 @@ declare class Node extends EventDispatcher<{
      * @param {NodeFrame} frame - A reference to the current node frame.
      * @return {?boolean} An optional bool that indicates whether the implementation actually performed an update or not (e.g. due to caching).
      */
-    updateAfter(frame: NodeFrame): void;
-    /**
-     * The method can be implemented to update the node's internal state when it is used to render an object.
-     * The {@link Node#updateType} property defines how often the update is executed.
-     *
-     * @abstract
-     * @param {NodeFrame} frame - A reference to the current node frame.
-     * @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;
+    updateAfter(frame: NodeFrame): boolean | undefined;
     before(node: Node): this;
     /**
      * This method performs the build of a node. The behavior and return value depend on the current build stage:
@@ -346,7 +429,7 @@ declare class Node extends EventDispatcher<{
      * @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;
+    build(builder: NodeBuilder, output?: (string | Node) | null): (Node | string) | null;
     /**
      * Returns the child nodes as a JSON object.
      *
@@ -373,4 +456,140 @@ declare class Node extends EventDispatcher<{
      */
     toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData;
 }
+
+declare const Node: {
+    new<TNodeType>(nodeType?: TNodeType | null): Node<TNodeType>;
+    new(nodeType?: string | null): Node;
+    /**
+     * Enables or disables the automatic capturing of stack traces for nodes.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    captureStackTrace: boolean;
+};
+
+export interface NodeElements {
+}
+
+export interface NodeExtensions<TNodeType> {
+}
+
+export type NumType = "float" | "int" | "uint";
+export type IntegerType = "int" | "uint";
+export type NumOrBoolType = NumType | "bool";
+export type FloatVecType = "vec2" | "vec3" | "vec4";
+export type MatType = "mat2" | "mat3" | "mat4";
+
+export interface FloatExtensions {
+}
+
+export interface IntExtensions {
+}
+
+export interface UintExtensions {
+}
+
+export interface BoolExtensions {
+}
+
+export interface NumExtensions<TNum extends NumType> {
+}
+
+export interface IntegerExtensions<TInteger extends IntegerType> {
+}
+
+export interface NumOrBoolExtensions<TNumOrBool extends NumOrBoolType> {
+}
+
+export interface NumVec2Extensions<TNum extends NumType> {
+}
+
+export interface NumVec3Extensions<TNum extends NumType> {
+}
+
+export interface NumVec4Extensions<TNum extends NumType> {
+}
+
+export interface NumOrBoolVec2Extensions<TNumOrBool extends NumOrBoolType> {
+}
+
+export interface NumOrBoolVec3Extensions<TNumOrBool extends NumOrBoolType> {
+}
+
+export interface NumOrBoolVec4Extensions<TNumOrBool extends NumOrBoolType> {
+}
+
+export interface Vec2Extensions {
+}
+
+export interface Vec3Extensions {
+}
+
+export interface Vec4Extensions {
+}
+
+export interface ColorExtensions {
+}
+
+export interface FloatVecExtensions<TVec extends FloatVecType> {
+}
+
+export interface Mat2Extensions {
+}
+
+export interface Mat3Extensions {
+}
+
+export interface Mat4Extensions {
+}
+
+export interface MatExtensions<TMat extends MatType> {
+}
+
+type Node<TNodeType = unknown> =
+    & NodeClass
+    & NodeElements
+    & (unknown extends TNodeType ? {} : NodeExtensions<TNodeType>)
+    & (TNodeType extends "float" ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float">
+        : TNodeType extends "int"
+            ? NumOrBoolExtensions<"int"> & IntExtensions & NumExtensions<"int"> & IntegerExtensions<"int">
+        : TNodeType extends "uint"
+            ? NumOrBoolExtensions<"uint"> & UintExtensions & NumExtensions<"uint"> & IntegerExtensions<"uint">
+        : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions
+        : TNodeType extends "vec2" ?
+                & NumOrBoolVec2Extensions<"float">
+                & Vec2Extensions
+                & NumVec2Extensions<"float">
+                & FloatVecExtensions<"vec2">
+        : TNodeType extends "ivec2" ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int">
+        : TNodeType extends "uvec2" ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint">
+        : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool">
+        : TNodeType extends "vec3" ?
+                & NumOrBoolVec3Extensions<"float">
+                & Vec3Extensions
+                & NumVec3Extensions<"float">
+                & FloatVecExtensions<"vec3">
+        : TNodeType extends "ivec3" ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int">
+        : TNodeType extends "uvec3" ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint">
+        : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool">
+        : TNodeType extends "vec4" ?
+                & NumOrBoolVec4Extensions<"float">
+                & Vec4Extensions
+                & NumVec4Extensions<"float">
+                & FloatVecExtensions<"vec4">
+        : TNodeType extends "ivec4" ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int">
+        : TNodeType extends "uvec4" ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint">
+        : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool">
+        : TNodeType extends "color" ? ColorExtensions
+        : TNodeType extends "mat2" ? Mat2Extensions & MatExtensions<"mat2">
+        : TNodeType extends "mat3" ? Mat3Extensions & MatExtensions<"mat3">
+        : TNodeType extends "mat4" ? Mat4Extensions & MatExtensions<"mat4">
+        : {})
+    & {
+        __TypeScript_NODE_TYPE__: TNodeType;
+    };
+
 export default Node;
+
+export {};

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

@@ -1,4 +1,5 @@
 import Node from "./Node.js";
+
 /**
  * {@link NodeBuilder} is going to create instances of this class during the build process
  * of nodes. They represent the final shader attributes that are going to be generated
@@ -6,10 +7,6 @@ import Node from "./Node.js";
  * and {@link NodeBuilder#bufferAttributes} for this purpose.
  */
 declare class NodeAttribute {
-    readonly isNodeAttribute: true;
-    name: string;
-    type: string | null;
-    node: Node | null;
     /**
      * Constructs a new node attribute.
      *
@@ -17,6 +14,34 @@ declare class NodeAttribute {
      * @param {string} type - The type of the attribute.
      * @param {?Node} node - An optional reference to the node.
      */
-    constructor(name: string, type: string | null, node?: Node | null);
+    constructor(name: string, type: string, node?: Node | null);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isNodeAttribute: boolean;
+    /**
+     * The name of the attribute.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The type of the attribute.
+     *
+     * @type {string}
+     */
+    type: string;
+    /**
+     * An optional reference to the node.
+     *
+     * @type {?Node}
+     * @default null
+     */
+    node: Node | null;
 }
+
 export default NodeAttribute;

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

@@ -26,7 +26,9 @@ export interface NodeData {
     compute: { [key: string]: unknown };
 }
 
-export type NodeBuilderContext = { [key: string]: unknown };
+export interface NodeBuilderContext {
+    [key: string]: unknown;
+}
 
 export default abstract class NodeBuilder {
     object: Object3D;
@@ -92,7 +94,7 @@ export default abstract class NodeBuilder {
 
     getAttribute(name: string, type: string): NodeAttribute;
 
-    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+    getPropertyName(node: NodeVar | NodeUniform<unknown, unknown>, shaderStage: NodeShaderStage): string;
     isVector(type: string): boolean;
 
     isMatrix(type: string): boolean;
@@ -110,7 +112,7 @@ export default abstract class NodeBuilder {
         type: string,
         shaderStage?: NodeShaderStage,
         name?: string | null,
-    ): NodeUniform<string>;
+    ): NodeUniform<unknown, string>;
     getVarFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): NodeVar;
     getVaryFromNode(node: Node, type: string): NodeVarying;
     getCodeFromNode(node: Node, type: string, shaderStage?: NodeShaderStage): string;

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

@@ -1,74 +1,50 @@
-import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
-import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
-import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
 import Node from "./Node.js";
-import NodeAttribute from "./NodeAttribute.js";
-import NodeCode from "./NodeCode.js";
-import NodeUniform from "./NodeUniform.js";
-import NodeVar from "./NodeVar.js";
-import NodeVarying from "./NodeVarying.js";
-import StructType from "./StructType.js";
-export interface ShaderStageNodeData {
-    properties?:
-        | (
-            & {
-                outputNode: Node | null;
-                initialized?: boolean | undefined;
-            }
-            & {
-                [K in `node${string}`]?: Node | undefined;
-            }
-        )
-        | undefined;
-    bufferAttribute?: NodeAttribute | undefined;
-    structType?: StructType | undefined;
-    uniform?: NodeUniform<unknown> | undefined;
-    variable?: NodeVar | undefined;
-    varying?: NodeVarying | undefined;
-    code?: NodeCode | undefined;
-    usageCount?: number | undefined;
-    snippet?: string | undefined;
-    propertyName?: string | undefined;
-    propertySizeName?: string | undefined;
-}
-interface NodeData {
-    vertex?: ShaderStageNodeData | undefined;
-    fragment?: ShaderStageNodeData | undefined;
-    compute?: ShaderStageNodeData | undefined;
-    any?: ShaderStageNodeData | undefined;
-}
-interface BufferAttributeData {
-    node: BufferAttributeNode;
-}
+
 /**
  * This utility class is used in {@link NodeBuilder} as an internal
  * cache data structure for node data.
  */
 declare class NodeCache {
-    id: number;
-    nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
-    parent: NodeCache | null;
     /**
      * Constructs a new node cache.
      *
      * @param {?NodeCache} parent - A reference to a parent cache.
      */
     constructor(parent?: NodeCache | null);
+    /**
+     * The id of the cache.
+     *
+     * @type {number}
+     * @readonly
+     */
+    readonly id: number;
+    /**
+     * A weak map for managing node data.
+     *
+     * @type {WeakMap<Node, Object>}
+     */
+    nodesData: WeakMap<Node, unknown>;
+    /**
+     * Reference to a parent node cache.
+     *
+     * @type {?NodeCache}
+     * @default null
+     */
+    parent: NodeCache | null;
     /**
      * Returns the data for the given node.
      *
      * @param {Node} node - The node.
      * @return {?Object} The data for the node.
      */
-    getData(node: Node): NodeData | undefined;
-    getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    getData(node: Node): unknown;
     /**
      * Sets the data for a given node.
      *
      * @param {Node} node - The node.
      * @param {Object} data - The data that should be cached.
      */
-    setData(node: Node, data: NodeData): void;
-    setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
+    setData(node: Node, data: unknown): void;
 }
+
 export default NodeCache;

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

@@ -0,0 +1,9 @@
+import StackTrace from "./StackTrace.js";
+
+declare class NodeError extends Error {
+    stackTrace: StackTrace | null;
+
+    constructor(message?: string, stackTrace?: StackTrace | null);
+}
+
+export default NodeError;

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

@@ -1,4 +1,5 @@
 import NodeFunction from "./NodeFunction.js";
+
 /**
  * Base class for node parsers. A derived parser must be implemented
  * for each supported native shader language.
@@ -13,4 +14,5 @@ declare abstract class NodeParser {
      */
     abstract parseFunction(source: string): NodeFunction;
 }
+
 export default NodeParser;