@polygonjs/polygonjs/dist/src/core/Walker.d.ts

node-based WebGL 3D engine https://polygonjs.com

import { CoreGraphNode } from './graph/CoreGraphNode';
import { BaseNodeType } from '../engine/nodes/_Base';
import { BaseParamType } from '../engine/params/_Base';
import { DecomposedPath } from './DecomposedPath';
import { NodeContext, BaseNodeByContextMap } from '../engine/poly/NodeContext';
import { NodeErrorState } from '../engine/nodes/utils/states/Error';
import { ParamType } from '../engine/poly/ParamType';
import { ParamErrorState } from '../engine/params/utils/states/Error';
import { ParamConstructorMap } from '../engine/params/types/ParamConstructorMap';
type NodeOrParam = BaseNodeType | BaseParamType;
export declare const NODE_PATH_DEFAULT: {
    NODE: {
        EMPTY: string;
        UV: string;
        ENV_MAP: string;
        CUBE_MAP: string;
    };
};
declare abstract class GraphNodePathParamValue<T extends CoreGraphNode> {
    protected _path: string;
    protected _graphNode: T | null;
    constructor(_path?: string);
    graphNode(): T | null;
    private _setGraphNode;
    abstract graphNodePath(): string | undefined;
    path(): string;
    setPath(path: string): void;
    clone(): this;
}
export declare class TypedNodePathParamValue extends GraphNodePathParamValue<BaseNodeType> {
    setNode(node: BaseNodeType | null): void;
    node(): BaseNodeType | null;
    graphNodePath(): string | undefined;
    resolve(nodeStart: BaseNodeType, decomposedPath?: DecomposedPath): void;
    nodeWithContext<N extends NodeContext, K extends NodeContext>(context: N, errorState?: NodeErrorState<K>): BaseNodeByContextMap[N] | undefined;
}
export declare class TypedParamPathParamValue extends GraphNodePathParamValue<BaseParamType> {
    setParam(param: BaseParamType | null): void;
    param(): BaseParamType | null;
    graphNodePath(): string | undefined;
    resolve(nodeStart: BaseNodeType, decomposedPath?: DecomposedPath): void;
    paramWithType<T extends ParamType>(paramType: T, error_state?: ParamErrorState): ParamConstructorMap[T] | undefined;
}
export declare class CoreWalker {
    static readonly SEPARATOR = "/";
    static readonly DOT = ".";
    static readonly CURRENT = ".";
    static readonly PARENT = "..";
    static readonly CURRENT_WITH_SLASH: string;
    static readonly PARENT_WITH_SLASH: string;
    static readonly NON_LETTER_PREFIXES: string[];
    static splitParentChild(path: string): {
        parent: string;
        child: string | undefined;
    };
    static findNode(nodeSrc: BaseNodeType, path: string, decomposedPath?: DecomposedPath): BaseNodeType | null;
    static findParam(nodeSrc: BaseNodeType, path: string, decomposedPath?: DecomposedPath): BaseParamType | null;
    static relativePath(srcGraphNode: Readonly<BaseNodeType>, destGraphNode: Readonly<BaseNodeType>): string;
    static sanitizePath(path: string): string;
    static closestCommonParent(graphNode1: Readonly<BaseNodeType>, graphNode2: Readonly<BaseNodeType>): Readonly<BaseNodeType> | null;
    static parents(graphNode: Readonly<NodeOrParam>): Readonly<BaseNodeType>[];
    static distanceToParent(graphNode: Readonly<NodeOrParam>, dest: Readonly<BaseNodeType>): number;
    static makeAbsolutePath(nodeSrc: BaseNodeType | BaseParamType, path: string): string | null;
}
export {};