@nice2dev/game-engine 1.3.13 → 1.3.14

package/dist/types/visual-scripting/VisualScriptDebugger.d.ts

@@ -1,145 +0,0 @@
-import { type DebuggerState, type Breakpoint, type DebuggerMode } from './types';
-export type DebuggerEventType = 'breakpoint_hit' | 'step_complete' | 'paused' | 'resumed' | 'error' | 'variable_changed' | 'call_stack_changed' | 'watch_value_changed';
-export interface DebuggerEvent {
-    type: DebuggerEventType;
-    graphId?: string;
-    nodeId?: string;
-    data?: unknown;
-}
-export type DebuggerEventHandler = (event: DebuggerEvent) => void;
-export interface WatchExpression {
-    id: string;
-    expression: string;
-    name?: string;
-    currentValue?: unknown;
-    lastError?: string;
-}
-export interface CallStackFrame {
-    graphId: string;
-    nodeId: string;
-    nodeName: string;
-    nodeType: string;
-    timestamp: number;
-}
-export declare class VisualScriptDebugger {
-    /** Debugger state */
-    private state;
-    /** Breakpoints by graph ID */
-    private breakpoints;
-    /** Conditional breakpoints */
-    private conditionalBreakpoints;
-    /** Watch expressions */
-    private watches;
-    /** Call stack */
-    private callStack;
-    /** Variable history (for undo/logging) */
-    private variableHistory;
-    /** Event handlers */
-    private eventHandlers;
-    /** Hit counts for breakpoints */
-    private hitCounts;
-    /** Skip counts for breakpoints */
-    private skipCounts;
-    /** Current node being debugged */
-    private currentNode;
-    /** Current graph being debugged */
-    private currentGraph;
-    constructor();
-    /** Get current debugger state */
-    getState(): DebuggerState;
-    /** Set debugger mode */
-    setMode(mode: DebuggerMode): void;
-    /** Enable debugger */
-    enable(): void;
-    /** Disable debugger */
-    disable(): void;
-    /** Check if debugger is active */
-    isActive(): boolean;
-    /** Check if paused */
-    isPaused(): boolean;
-    /** Pause execution */
-    pause(): void;
-    /** Resume execution */
-    resume(): void;
-    /** Step into next node */
-    stepInto(): void;
-    /** Step over (complete current node) */
-    stepOver(): void;
-    /** Step out (complete current execution path) */
-    stepOut(): void;
-    /** Check if should break at node */
-    shouldBreak(graphId: string, nodeId: string): boolean;
-    /** Add breakpoint */
-    addBreakpoint(graphId: string, nodeId: string, condition?: string): Breakpoint;
-    /** Remove breakpoint */
-    removeBreakpoint(graphId: string, nodeId: string): void;
-    /** Toggle breakpoint */
-    toggleBreakpoint(graphId: string, nodeId: string): boolean;
-    /** Check if breakpoint exists */
-    hasBreakpoint(graphId: string, nodeId: string): boolean;
-    /** Get all breakpoints */
-    getBreakpoints(): Breakpoint[];
-    /** Set skip count for breakpoint */
-    setBreakpointSkipCount(graphId: string, nodeId: string, count: number): void;
-    /** Clear all breakpoints */
-    clearAllBreakpoints(): void;
-    /** Add watch expression */
-    addWatch(expression: string, name?: string): WatchExpression;
-    /** Remove watch */
-    removeWatch(id: string): void;
-    /** Update watch value */
-    updateWatch(id: string, value: unknown): void;
-    /** Evaluate watch expressions with context */
-    evaluateWatches(context: Map<string, unknown>): void;
-    /** Get all watches */
-    getWatches(): WatchExpression[];
-    /** Push frame to call stack */
-    pushCallStack(frame: CallStackFrame): void;
-    /** Pop frame from call stack */
-    popCallStack(): CallStackFrame | undefined;
-    /** Get call stack */
-    getCallStack(): CallStackFrame[];
-    /** Clear call stack */
-    clearCallStack(): void;
-    /** Called when node execution starts */
-    onNodeEnter(graphId: string, nodeId: string): void;
-    /** Called when node execution ends */
-    onNodeExit(graphId: string, nodeId: string): void;
-    /** Called when an error occurs */
-    onError(graphId: string, nodeId: string, error: Error): void;
-    /** Called when a variable changes */
-    onVariableChange(graphId: string, name: string, oldValue: unknown, newValue: unknown): void;
-    /** Get variable history */
-    getVariableHistory(name: string): Array<{
-        value: unknown;
-        timestamp: number;
-    }>;
-    /** Add event handler */
-    addEventListener(handler: DebuggerEventHandler): void;
-    /** Remove event handler */
-    removeEventListener(handler: DebuggerEventHandler): void;
-    /** Emit event */
-    private emit;
-    /** Reset debugger state */
-    reset(): void;
-    /** Get debug info for a node */
-    getNodeDebugInfo(graphId: string, nodeId: string): NodeDebugInfo;
-    /** Serialize debugger state */
-    serialize(): SerializedDebuggerState;
-    /** Deserialize debugger state */
-    deserialize(data: SerializedDebuggerState): void;
-}
-export interface NodeDebugInfo {
-    isBreakpoint: boolean;
-    isCurrent: boolean;
-    hitCount: number;
-}
-export interface SerializedDebuggerState {
-    mode: DebuggerMode;
-    breakpoints: Breakpoint[];
-    watches: Array<{
-        expression: string;
-        name?: string;
-    }>;
-}
-export declare function createDebugger(): VisualScriptDebugger;

package/dist/types/visual-scripting/VisualScriptExecutor.d.ts

@@ -1,100 +0,0 @@
-import { type ExecutionContext, type VisualScriptEvent } from './types';
-import { VisualScriptDebugger } from './VisualScriptDebugger';
-import { VisualScriptGraph } from './VisualScriptGraph';
-import { LatentNode } from './VisualScriptNode';
-export interface ExecutorConfig {
-    /** Maximum nodes to execute per update (prevents infinite loops) */
-    maxNodesPerUpdate: number;
-    /** Enable profiling */
-    profiling: boolean;
-    /** Debugger instance */
-    debugger?: VisualScriptDebugger;
-}
-export interface ExecutionStats {
-    /** Total nodes executed */
-    nodesExecuted: number;
-    /** Execution time in ms */
-    totalTime: number;
-    /** Per-node timing */
-    nodeTiming: Map<string, number>;
-    /** Errors encountered */
-    errors: Error[];
-}
-export declare class VisualScriptExecutor {
-    /** Configuration */
-    private config;
-    /** Active graph being executed */
-    private graph;
-    /** Execution context */
-    private context;
-    /** Currently executing latent nodes */
-    private latentNodes;
-    /** Pending execution queue */
-    private executionQueue;
-    /** Is currently executing? */
-    private isExecuting;
-    /** Execution stats */
-    private stats;
-    /** Debugger reference */
-    private debugger?;
-    constructor(config?: Partial<ExecutorConfig>);
-    private createDefaultContext;
-    /** Set the execution context */
-    setContext(context: Partial<ExecutionContext>): void;
-    /** Get current context */
-    getContext(): ExecutionContext;
-    /** Update context for new frame */
-    updateContext(deltaTime: number): void;
-    /** Set a global variable */
-    setGlobal(name: string, value: unknown): void;
-    /** Get a global variable */
-    getGlobal(name: string): unknown;
-    /** Bind a graph for execution */
-    bindGraph(graph: VisualScriptGraph): void;
-    /** Get bound graph */
-    getGraph(): VisualScriptGraph | null;
-    /** Trigger a visual script event */
-    triggerEvent(event: VisualScriptEvent): void;
-    /** Check if event node matches the event */
-    private matchesEvent;
-    /** Process event data into node outputs */
-    private processEventNode;
-    /** Queue a node for execution */
-    private queueExecution;
-    /** Process execution queue */
-    private processExecutionQueue;
-    /** Execute a single node */
-    private executeNode;
-    /** Resolve input values from connected nodes */
-    private resolveInputs;
-    /** Recursively resolve pure nodes */
-    private resolvePureNode;
-    /** Handle execution result and queue next nodes */
-    private handleExecutionResult;
-    /** Update latent nodes */
-    updateLatentNodes(): void;
-    /** Register a latent node */
-    registerLatentNode(nodeId: string, node: LatentNode): void;
-    /** Cancel all latent nodes */
-    cancelAllLatent(): void;
-    /** Get a local variable value */
-    getVariable(name: string): unknown;
-    /** Set a local variable value */
-    setVariable(name: string, value: unknown): void;
-    /** Get execution stats */
-    getStats(): ExecutionStats;
-    private createEmptyStats;
-    /** Set debugger */
-    setDebugger(debugger_: VisualScriptDebugger): void;
-    /** Step execution (debug mode) */
-    stepExecution(): void;
-    /** Continue execution (debug mode) */
-    continueExecution(): void;
-    /** Is there pending execution? */
-    hasPendingExecution(): boolean;
-    /** Stop all execution */
-    stop(): void;
-    /** Reset executor state */
-    reset(): void;
-}
-export declare function createExecutor(config?: Partial<ExecutorConfig>): VisualScriptExecutor;

package/dist/types/visual-scripting/VisualScriptGraph.d.ts

@@ -1,173 +0,0 @@
-import { type VisualScriptGraphData, type PinConnection, type VariableDefinition, type GraphComment } from './types';
-import { VisualScriptNode } from './VisualScriptNode';
-export declare class VisualScriptGraph {
-    /** Graph ID */
-    readonly id: string;
-    /** Graph name */
-    name: string;
-    /** Description */
-    description: string;
-    /** Graph type */
-    type: 'event' | 'function' | 'macro';
-    /** All nodes in graph */
-    private nodes;
-    /** All connections */
-    private connections;
-    /** Local variables */
-    private variables;
-    /** Comments/annotations */
-    private comments;
-    /** Node ID counter */
-    private nodeIdCounter;
-    /** Connection ID counter */
-    private connectionIdCounter;
-    /** Change listeners */
-    private changeListeners;
-    constructor(id: string, name?: string, type?: 'event' | 'function' | 'macro');
-    /** Add a new node to the graph */
-    addNode(typeId: string, position: {
-        x: number;
-        y: number;
-    }): VisualScriptNode | null;
-    /** Remove a node and all its connections */
-    removeNode(nodeId: string): boolean;
-    /** Get a node by ID */
-    getNode(nodeId: string): VisualScriptNode | undefined;
-    /** Get all nodes */
-    getAllNodes(): VisualScriptNode[];
-    /** Get nodes by type */
-    getNodesByType(typeId: string): VisualScriptNode[];
-    /** Get event nodes (entry points) */
-    getEventNodes(): VisualScriptNode[];
-    /** Move a node to a new position */
-    moveNode(nodeId: string, position: {
-        x: number;
-        y: number;
-    }): void;
-    /** Duplicate a node */
-    duplicateNode(nodeId: string, offset?: {
-        x: number;
-        y: number;
-    }): VisualScriptNode | null;
-    /** Create a connection between two pins */
-    connect(sourceNodeId: string, sourcePinId: string, targetNodeId: string, targetPinId: string): PinConnection | null;
-    /** Remove a connection */
-    removeConnection(connectionId: string): boolean;
-    /** Get a connection by ID */
-    getConnection(connectionId: string): PinConnection | undefined;
-    /** Get all connections */
-    getAllConnections(): PinConnection[];
-    /** Get connections for a specific node */
-    getNodeConnections(nodeId: string): PinConnection[];
-    /** Get connections coming into a pin */
-    getInputConnections(nodeId: string, pinId: string): PinConnection[];
-    /** Get connections going out of a pin */
-    getOutputConnections(nodeId: string, pinId: string): PinConnection[];
-    /** Check if connecting would create a cycle */
-    wouldCreateCycle(sourceNodeId: string, targetNodeId: string): boolean;
-    /** Add a variable */
-    addVariable(variable: Omit<VariableDefinition, 'id'>): VariableDefinition;
-    /** Remove a variable */
-    removeVariable(variableId: string): boolean;
-    /** Get a variable */
-    getVariable(variableId: string): VariableDefinition | undefined;
-    /** Get variable by name */
-    getVariableByName(name: string): VariableDefinition | undefined;
-    /** Get all variables */
-    getAllVariables(): VariableDefinition[];
-    /** Update a variable */
-    updateVariable(variableId: string, updates: Partial<VariableDefinition>): boolean;
-    /** Add a comment */
-    addComment(comment: Omit<GraphComment, 'id'>): GraphComment;
-    /** Remove a comment */
-    removeComment(commentId: string): boolean;
-    /** Get all comments */
-    getAllComments(): GraphComment[];
-    /** Update a comment */
-    updateComment(commentId: string, updates: Partial<GraphComment>): boolean;
-    /** Validate the entire graph */
-    validate(): GraphValidationResult;
-    /** Check for cycles in execution flow */
-    private hasCycles;
-    /** Serialize graph to data */
-    toData(): VisualScriptGraphData;
-    /** Load graph from data */
-    static fromData(data: VisualScriptGraphData): VisualScriptGraph;
-    /** Subscribe to graph changes */
-    onChange(listener: (event: GraphChangeEvent) => void): () => void;
-    /** Emit a change event */
-    private emitChange;
-    /** Clear the graph */
-    clear(): void;
-    /** Get graph statistics */
-    getStats(): GraphStats;
-}
-export type GraphChangeEvent = {
-    type: 'node_added';
-    nodeId: string;
-    node: VisualScriptNode;
-} | {
-    type: 'node_removed';
-    nodeId: string;
-} | {
-    type: 'node_moved';
-    nodeId: string;
-    position: {
-        x: number;
-        y: number;
-    };
-} | {
-    type: 'connection_added';
-    connectionId: string;
-    connection: PinConnection;
-} | {
-    type: 'connection_removed';
-    connectionId: string;
-} | {
-    type: 'variable_added';
-    variableId: string;
-    variable: VariableDefinition;
-} | {
-    type: 'variable_removed';
-    variableId: string;
-} | {
-    type: 'variable_updated';
-    variableId: string;
-    variable: VariableDefinition;
-} | {
-    type: 'comment_added';
-    commentId: string;
-    comment: GraphComment;
-} | {
-    type: 'comment_removed';
-    commentId: string;
-} | {
-    type: 'comment_updated';
-    commentId: string;
-    comment: GraphComment;
-} | {
-    type: 'graph_cleared';
-};
-export interface GraphValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationWarning[];
-}
-export interface ValidationError {
-    type: string;
-    nodeId?: string;
-    pinId?: string;
-    message: string;
-}
-export interface ValidationWarning {
-    type: string;
-    nodeId?: string;
-    pinId?: string;
-    message: string;
-}
-export interface GraphStats {
-    nodeCount: number;
-    connectionCount: number;
-    variableCount: number;
-    eventNodeCount: number;
-}

package/dist/types/visual-scripting/VisualScriptNode.d.ts

@@ -1,157 +0,0 @@
-import { type NodeMetadata, type NodeState as _NodeState, type Pin, type PinDefinition, type ExecutionContext, type ExecutionResult } from './types';
-export type { NodeMetadata, PinDefinition } from './types';
-export declare abstract class VisualScriptNode {
-    /** Node instance ID */
-    readonly id: string;
-    /** Node type metadata. Subclasses may set via constructor(metadata) or assign as a property. */
-    metadata: NodeMetadata;
-    /** Input pin definitions (mutable so subclasses can call addInputPin). */
-    inputPins: PinDefinition[];
-    /** Output pin definitions (mutable so subclasses can call addOutputPin). */
-    outputPins: PinDefinition[];
-    /** Position in graph */
-    position: {
-        x: number;
-        y: number;
-    };
-    /** Is node visually collapsed? */
-    collapsed: boolean;
-    /** User comment */
-    comment?: string;
-    /** Has breakpoint */
-    hasBreakpoint: boolean;
-    /** Custom property values */
-    properties: Record<string, unknown>;
-    /** Input pin values (overrides/defaults) */
-    inputValues: Map<string, unknown>;
-    /** Runtime input pins */
-    private _inputPinInstances;
-    /** Runtime output pins */
-    private _outputPinInstances;
-    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
-    /** Add a single input pin definition. Used by node subclasses in setupPins(). */
-    addInputPin(def: PinDefinition): void;
-    /** Add a single output pin definition. Used by node subclasses in setupPins(). */
-    addOutputPin(def: PinDefinition): void;
-    /** Initialize pin instances from definitions */
-    initializePins(): void;
-    private createPinInstance;
-    /** Get input pin by ID */
-    getInputPin(pinId: string): Pin | undefined;
-    /** Get output pin by ID */
-    getOutputPin(pinId: string): Pin | undefined;
-    /** Get all input pins */
-    getInputPins(): Pin[];
-    /** Get all output pins */
-    getOutputPins(): Pin[];
-    /** Set input pin value */
-    setInputValue(pinId: string, value: unknown): void;
-    /** Get input pin value */
-    getInputValue(pinId: string): unknown;
-    /** Set output pin value */
-    setOutputValue(pinId: string, value: unknown): void;
-    /** Get output pin value */
-    getOutputValue(pinId: string): unknown;
-    /** Has execution input pin? */
-    hasExecutionInput(): boolean;
-    /** Has execution output pin? */
-    hasExecutionOutput(): boolean;
-    /** Get execution input pin */
-    getExecutionInput(): Pin | undefined;
-    /** Get execution output pins */
-    getExecutionOutputs(): Pin[];
-    /**
-     * Execute this node.
-     * Override in subclasses to implement node-specific logic.
-     */
-    execute(_context: ExecutionContext): ExecutionResult | Promise<ExecutionResult>;
-    /**
-     * Get the ID of the next execution pin to follow.
-     * Override for nodes with multiple execution outputs (like Branch).
-     */
-    getNextExecutionPin(result: ExecutionResult): string | null;
-    /** Serialize node to state */
-    toState(): _NodeState;
-    /** Restore node from state */
-    fromState(state: _NodeState): void;
-    /** Validate node configuration */
-    validate(): string[];
-    /** Get display title */
-    getTitle(): string;
-    /** Get tooltip text */
-    getTooltip(): string;
-    /** Get node color */
-    getColor(): string;
-    /** Get icon */
-    getIcon(): string | undefined;
-}
-/**
- * Base class for pure function nodes.
- * Pure nodes have no execution pins and produce outputs from inputs.
- */
-export declare abstract class PureFunctionNode extends VisualScriptNode {
-    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
-    /** Override to define data input pins */
-    getDataInputPins(): PinDefinition[];
-    /** Override to define data output pins */
-    getDataOutputPins(): PinDefinition[];
-    /** Calculate outputs from inputs */
-    compute(_inputs: Record<string, unknown>): Record<string, unknown>;
-    execute(context: ExecutionContext): ExecutionResult;
-}
-/**
- * Base class for event nodes.
- * Event nodes are entry points with only output execution pins.
- */
-export declare abstract class EventNode extends VisualScriptNode {
-    constructor(idOrMetadata?: string | NodeMetadata, id?: string);
-    /** Data inputs for the event (usually none or few) */
-    getEventInputPins(): PinDefinition[];
-    /** Additional data outputs (event-specific data) */
-    getEventOutputPins(): PinDefinition[];
-    /** Process event and set output values */
-    processEvent(_event: unknown, _context: ExecutionContext): void;
-    execute(context: ExecutionContext): ExecutionResult;
-    getNextExecutionPin(_result?: ExecutionResult): string | null;
-}
-/**
- * Base class for flow control nodes.
- * These nodes control execution flow (Branch, Sequence, ForLoop, etc.)
- */
-export declare abstract class FlowControlNode extends VisualScriptNode {
-    /** Determine which execution pin to follow based on state */
-    determineNextPin(_context: ExecutionContext): string | null;
-    getNextExecutionPin(result: ExecutionResult): string | null;
-}
-/**
- * Base class for latent/async nodes.
- * These nodes can pause execution and resume later (Delay, Wait, etc.)
- */
-export declare abstract class LatentNode extends VisualScriptNode {
-    /** Is this node currently executing? */
-    isExecuting: boolean;
-    /** Start async execution */
-    startAsync(_context?: ExecutionContext): void | Promise<void>;
-    /** Called each frame while executing */
-    updateAsync(_context: ExecutionContext): boolean;
-    /** Cancel async execution */
-    cancelAsync(): void;
-    execute(context: ExecutionContext): ExecutionResult | Promise<ExecutionResult>;
-}
-export type NodeConstructor = new (id: string) => VisualScriptNode;
-/** Register a node type */
-export declare function registerNodeType(typeId: string, constructor: NodeConstructor): void;
-/** Get the underlying node registry map */
-export declare function getNodeRegistry(): Map<string, NodeConstructor>;
-/** Convenience alias for registerNodeType that also accepts no-arg classes (used by node subclasses).
- *  When the class has a no-arg constructor, it's wrapped to satisfy the (id) => Node signature.
- */
-export declare function registerNode(typeId: string, ctor: NodeConstructor | (new () => VisualScriptNode)): void;
-/** Create a node instance by type ID */
-export declare function createNode(typeId: string, id: string): VisualScriptNode | null;
-/** Get all registered node types */
-export declare function getRegisteredNodeTypes(): string[];
-/** Get node metadata by type ID */
-export declare function getNodeMetadata(typeId: string): NodeMetadata | null;
-/** Search nodes by keyword */
-export declare function searchNodes(query: string): NodeMetadata[];

package/dist/types/visual-scripting/index.d.ts

@@ -1,6 +0,0 @@
-export * from './types';
-export * from './VisualScriptNode';
-export * from './VisualScriptGraph';
-export * from './VisualScriptExecutor';
-export * from './VisualScriptDebugger';
-export * from './nodes/index';