@types/three 0.156.0 → 0.157.1

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -1,15 +0,0 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { Node } from '../Nodes.js';
-
-export default class PointsNodeMaterial extends NodeMaterial {
-    isPointsNodeMateria: true;
-    colorNode: Node | null;
-    opacityNode: Node | null;
-    alphaTestNode: Node | null;
-    lightNode: Node | null;
-    sizeNode: Node | null;
-    positionNode: Node | null;
-    constructor(parameters?: ShaderMaterialParameters);
-    copy(source: PointsNodeMaterial): this;
-}

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -1,23 +0,0 @@
-import NodeMaterial from './NodeMaterial.js';
-import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { NodeBuilder } from '../Nodes.js';
-import Node from '../core/Node.js';
-
-export default class SpriteNodeMaterial extends NodeMaterial {
-    isSpriteNodeMaterial: true;
-
-    colorNode: Node | null;
-    opacityNode: Node | null;
-
-    alphaTestNode: Node | null;
-
-    lightNode: Node | null;
-
-    positionNode: Node | null;
-    rotationNode: Node | null;
-    scaleNode: Node | null;
-
-    constructor(parameters?: ShaderMaterialParameters);
-    generatePosition(builder: NodeBuilder): void;
-    copy(source: SpriteNodeMaterial): this;
-}

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -1,94 +0,0 @@
-import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
-import { UVNode, MathNode } from '../Nodes.js';
-import { NodeRepresentation } from '../shadernode/ShaderNode.js';
-
-export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
-
-export function mx_ramplr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
-export function mx_ramptb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
-
-export function mx_splitlr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
-export function mx_splittb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
-
-export function mx_transform_uv(
-    uv_scale?: NodeRepresentation,
-    uv_offset?: NodeRepresentation,
-    uv_geo?: Swizzable<UVNode>,
-): Swizzable;
-
-export function mx_noise_float(
-    texcoord?: Swizzable<UVNode>,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
-): Swizzable;
-export function mx_noise_vec2(
-    texcoord?: Swizzable<UVNode>,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
-): Swizzable;
-export function mx_noise_vec3(
-    texcoord?: Swizzable<UVNode>,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
-): Swizzable;
-export function mx_noise_vec4(
-    texcoord?: Swizzable<UVNode>,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
-): Swizzable;
-
-export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-
-export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
-
-export function mx_fractal_noise_float(
-    position?: Swizzable<UVNode>,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-): Swizzable;
-export function mx_fractal_noise_vec2(
-    position?: Swizzable<UVNode>,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-): Swizzable;
-export function mx_fractal_noise_vec3(
-    position?: Swizzable<UVNode>,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-): Swizzable;
-export function mx_fractal_noise_vec4(
-    position?: Swizzable<UVNode>,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-): Swizzable;
-
-export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,4 +0,0 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
-
-export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
-export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,6 +0,0 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
-
-export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -1,9 +0,0 @@
-import Node from '../core/Node.js';
-
-export default class CondNode extends Node {
-    condNode: Node;
-    ifNode: Node;
-    elseNode: Node;
-
-    constructor(condNode: Node, ifNode: Node, elseNode: Node);
-}

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -1,115 +0,0 @@
-import Node from '../core/Node.js';
-import TempNode from '../core/TempNode.js';
-
-export type MathNodeMethod1 =
-    | typeof MathNode.RADIANS
-    | typeof MathNode.DEGREES
-    | typeof MathNode.EXP
-    | typeof MathNode.EXP2
-    | typeof MathNode.LOG
-    | typeof MathNode.LOG2
-    | typeof MathNode.SQRT
-    | typeof MathNode.INVERSE_SQRT
-    | typeof MathNode.FLOOR
-    | typeof MathNode.CEIL
-    | typeof MathNode.NORMALIZE
-    | typeof MathNode.FRACT
-    | typeof MathNode.SIN
-    | typeof MathNode.COS
-    | typeof MathNode.TAN
-    | typeof MathNode.ASIN
-    | typeof MathNode.ACOS
-    | typeof MathNode.ATAN
-    | typeof MathNode.ABS
-    | typeof MathNode.SIGN
-    | typeof MathNode.LENGTH
-    | typeof MathNode.NEGATE
-    | typeof MathNode.ONE_MINUS
-    | typeof MathNode.DFDX
-    | typeof MathNode.DFDY
-    | typeof MathNode.ROUND;
-
-export type MathNodeMethod2 =
-    | typeof MathNode.ATAN2
-    | typeof MathNode.MIN
-    | typeof MathNode.MAX
-    | typeof MathNode.MOD
-    | typeof MathNode.STEP
-    | typeof MathNode.REFLECT
-    | typeof MathNode.DISTANCE
-    | typeof MathNode.DOT
-    | typeof MathNode.CROSS
-    | typeof MathNode.POW
-    | typeof MathNode.TRANSFORM_DIRECTION;
-
-export type MathNodeMethod3 =
-    | typeof MathNode.MIX
-    | typeof MathNode.CLAMP
-    | typeof MathNode.REFRACT
-    | typeof MathNode.SMOOTHSTEP
-    | typeof MathNode.FACEFORWARD;
-
-export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3;
-
-export default class MathNode extends TempNode {
-    // 1 input
-
-    static RADIANS: 'radians';
-    static DEGREES: 'degrees';
-    static EXP: 'exp';
-    static EXP2: 'exp2';
-    static LOG: 'log';
-    static LOG2: 'log2';
-    static SQRT: 'sqrt';
-    static INVERSE_SQRT: 'inversesqrt';
-    static FLOOR: 'floor';
-    static CEIL: 'ceil';
-    static NORMALIZE: 'normalize';
-    static FRACT: 'fract';
-    static SIN: 'sin';
-    static COS: 'cos';
-    static TAN: 'tan';
-    static ASIN: 'asin';
-    static ACOS: 'acos';
-    static ATAN: 'atan';
-    static ABS: 'abs';
-    static SIGN: 'sign';
-    static LENGTH: 'length';
-    static NEGATE: 'negate';
-    static ONE_MINUS: 'oneMinus';
-    static DFDX: 'dFdx';
-    static DFDY: 'dFdy';
-    static ROUND: 'round';
-    static RECIPROCAL: 'reciprocal';
-
-    // 2 inputs
-
-    static ATAN2: 'atan2';
-    static MIN: 'min';
-    static MAX: 'max';
-    static MOD: 'mod';
-    static STEP: 'step';
-    static REFLECT: 'reflect';
-    static DISTANCE: 'distance';
-    static DOT: 'dot';
-    static CROSS: 'cross';
-    static POW: 'pow';
-    static TRANSFORM_DIRECTION: 'transformDirection';
-
-    // 3 inputs
-
-    static MIX: 'mix';
-    static CLAMP: 'clamp';
-    static REFRACT: 'refract';
-    static SMOOTHSTEP: 'smoothstep';
-    static FACEFORWARD: 'faceforward';
-
-    method: MathNodeMethod;
-    aNode: Node;
-    bNode: Node | null;
-    cNode: Node | null;
-
-    constructor(method: MathNodeMethod1, aNode: Node);
-    constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
-    constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
-}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -1,31 +0,0 @@
-import TempNode from '../core/TempNode.js';
-import Node from '../core/Node.js';
-
-export type OperatorNodeOp =
-    | '='
-    | '%'
-    | '&'
-    | '|'
-    | '^'
-    | '>>'
-    | '<<'
-    | '=='
-    | '&&'
-    | '||'
-    | '^^'
-    | '<'
-    | '>'
-    | '<='
-    | '>='
-    | '+'
-    | '-'
-    | '*'
-    | '/';
-
-export default class OperatorNode extends TempNode {
-    aNode: Node;
-    bNode: Node;
-    op: OperatorNodeOp;
-
-    constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
-}

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,6 +0,0 @@
-import TempNode from '../core/TempNode.js';
-
-export default class CheckerNode extends TempNode {
-    uvNode: Node;
-    constructor(uvNode?: Node);
-}

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -1,156 +0,0 @@
-import { ConstNode, Node, NodeBuilder, NodeTypeOption, SwizzleOption } from '../Nodes.js';
-// lot of private typescript magic here
-export {};
-export type Swizzable<T extends Node = Node> = T & {
-    [key in SwizzleOption | number]: Swizzable;
-};
-
-/** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
-
-/** anything that can be passed to {@link nodeObject} */
-export type NodeObjectOption = NodeRepresentation | string;
-
-// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
-export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
-
-// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
-type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
-// https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
-export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
-export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
-type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
-type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
-
-/**
- * Temporary type to save signatures of 4 constructors. Each element may be tuple or undefined.
- *
- * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
- */
-interface Construtors<
-    A extends undefined | [...unknown[]],
-    B extends undefined | [...unknown[]],
-    C extends undefined | [...unknown[]],
-    D extends undefined | [...unknown[]],
-> {
-    a: A;
-    b: B;
-    c: C;
-    d: D;
-}
-
-/**
- * Returns all constructors
- *
- * <https://github.com/microsoft/TypeScript/issues/37079>
- * <https://stackoverflow.com/a/52761156/1623826>
- */
-type OverloadedConstructorsOf<T> = T extends {
-    new (...args: infer A1): unknown;
-    new (...args: infer A2): unknown;
-    new (...args: infer A3): unknown;
-    new (...args: infer A4): unknown;
-}
-    ? Construtors<A1, A2, A3, A4>
-    : T extends {
-          new (...args: infer A1): unknown;
-          new (...args: infer A2): unknown;
-          new (...args: infer A3): unknown;
-      }
-    ? Construtors<A1, A2, A3, undefined>
-    : T extends {
-          new (...args: infer A1): unknown;
-          new (...args: infer A2): unknown;
-      }
-    ? Construtors<A1, A2, undefined, undefined>
-    : T extends new (...args: infer A) => unknown
-    ? Construtors<A, undefined, undefined, undefined>
-    : Construtors<undefined, undefined, undefined, undefined>;
-
-type AnyConstructors = Construtors<any, any, any, any>;
-
-/**
- * Returns all constructors where the first paramter is assignable to given "scope"
- */
-// tslint:disable-next-line:interface-over-type-literal
-type FilterConstructorsByScope<T extends AnyConstructors, S> = {
-    a: S extends T['a'][0] ? T['a'] : undefined;
-    b: S extends T['b'][0] ? T['b'] : undefined;
-    c: S extends T['c'][0] ? T['c'] : undefined;
-    d: S extends T['d'][0] ? T['d'] : undefined;
-};
-/**
- * "flattens" the tuple into an union type
- */
-type ConstructorUnion<T extends AnyConstructors> =
-    | Exclude<T['a'], undefined>
-    | Exclude<T['b'], undefined>
-    | Exclude<T['c'], undefined>
-    | Exclude<T['d'], undefined>;
-
-/**
- * Extract list of possible scopes - union of the first paramter
- * of all constructors, should it be string
- */
-type ExtractScopes<T extends AnyConstructors> =
-    | (T['a'][0] extends string ? T['a'][0] : never)
-    | (T['b'][0] extends string ? T['b'][0] : never)
-    | (T['c'][0] extends string ? T['c'][0] : never)
-    | (T['d'][0] extends string ? T['d'][0] : never);
-
-type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<OverloadedConstructorsOf<T>, S>>;
-type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
-type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
-
-export type ConvertType = (...params: unknown[]) => Swizzable;
-
-export const ConvertType: {
-    new (type: NodeTypeOption, cacheMap?: Map<unknown, ConstNode>): ConvertType;
-};
-
-type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
-type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
-type ConstructedNode<T> = T extends new (...args: any[]) => infer R ? (R extends Node ? R : never) : never;
-
-export type NodeOrType = Node | NodeTypeOption;
-
-export function getConstNodeType(value: NodeOrType): NodeTypeOption | null;
-export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
-export function nodeObjects<T>(obj: T): NodeObjects<T>;
-
-export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
-
-export function nodeProxy<T>(
-    nodeClass: T,
-): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
-
-export function nodeProxy<T, S extends GetPossibleScopes<T>>(
-    nodeClass: T,
-    scope: S,
-): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
-
-export function nodeProxy<T, S extends GetPossibleScopes<T>>(
-    nodeClass: T,
-    scope: S,
-    factor: NodeObjectOption,
-): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
-
-export function nodeImmutable<T>(
-    nodeClass: T,
-    ...params: ProxiedTuple<GetConstructors<T>>
-): Swizzable<ConstructedNode<T>>;
-
-export class ShaderNode<T = {}, R extends Node = Node> {
-    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
-    call: (
-        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? Swizzable | Node : T[key] },
-        builder?: NodeBuilder,
-    ) => Swizzable<R>;
-}
-
-export const cacheMaps: {
-    bool: Map<boolean, ConstNode>;
-    uint: Map<number, ConstNode>;
-    int: Map<number, ConstNode>;
-    float: Map<number, ConstNode>;
-};