MCP 3D Printer Server
by DMontgomery40
Verified
import Node from '../core/Node.js';
import { property } from '../core/PropertyNode.js';
import { addMethodChaining, nodeProxy } from '../tsl/TSLCore.js';
/** @module ConditionalNode **/
/**
* Represents a logical `if/else` statement. Can be used as an alternative
* to the `If()`/`Else()` syntax.
*
* The corresponding TSL `select()` looks like so:
* ```js
* velocity = position.greaterThanEqual( limit ).select( velocity.negate(), velocity );
* ```
* The `select()` method is called in a chaining fashion on a condition. The parameter nodes of `select()`
* determine the outcome of the entire statement.
*
* @augments Node
*/
class ConditionalNode extends Node {
static get type() {
return 'ConditionalNode';
}
/**
* Constructs a new conditional node.
*
* @param {Node} condNode - The node that defines the condition.
* @param {Node} ifNode - The node that is evaluate when the condition ends up `true`.
* @param {Node?} [elseNode=null] - The node that is evaluate when the condition ends up `false`.
*/
constructor( condNode, ifNode, elseNode = null ) {
super();
/**
* The node that defines the condition.
*
* @type {Node}
*/
this.condNode = condNode;
/**
* The node that is evaluate when the condition ends up `true`.
*
* @type {Node}
*/
this.ifNode = ifNode;
/**
* The node that is evaluate when the condition ends up `false`.
*
* @type {Node?}
* @default null
*/
this.elseNode = elseNode;
}
/**
* This method is overwritten since the node type is inferred from the if/else
* nodes.
*
* @param {NodeBuilder} builder - The current node builder.
* @return {String} The node type.
*/
getNodeType( builder ) {
const { ifNode, elseNode } = builder.getNodeProperties( this );
if ( ifNode === undefined ) {
// fallback setup
this.setup( builder );
return this.getNodeType( builder );
}
const ifType = ifNode.getNodeType( builder );
if ( elseNode !== null ) {
const elseType = elseNode.getNodeType( builder );
if ( builder.getTypeLength( elseType ) > builder.getTypeLength( ifType ) ) {
return elseType;
}
}
return ifType;
}
setup( builder ) {
const condNode = this.condNode.cache();
const ifNode = this.ifNode.cache();
const elseNode = this.elseNode ? this.elseNode.cache() : null;
//
const currentNodeBlock = builder.context.nodeBlock;
builder.getDataFromNode( ifNode ).parentNodeBlock = currentNodeBlock;
if ( elseNode !== null ) builder.getDataFromNode( elseNode ).parentNodeBlock = currentNodeBlock;
//
const properties = builder.getNodeProperties( this );
properties.condNode = condNode;
properties.ifNode = ifNode.context( { nodeBlock: ifNode } );
properties.elseNode = elseNode ? elseNode.context( { nodeBlock: elseNode } ) : null;
}
generate( builder, output ) {
const type = this.getNodeType( builder );
const nodeData = builder.getDataFromNode( this );
if ( nodeData.nodeProperty !== undefined ) {
return nodeData.nodeProperty;
}
const { condNode, ifNode, elseNode } = builder.getNodeProperties( this );
const needsOutput = output !== 'void';
const nodeProperty = needsOutput ? property( type ).build( builder ) : '';
nodeData.nodeProperty = nodeProperty;
const nodeSnippet = condNode.build( builder, 'bool' );
builder.addFlowCode( `\n${ builder.tab }if ( ${ nodeSnippet } ) {\n\n` ).addFlowTab();
let ifSnippet = ifNode.build( builder, type );
if ( ifSnippet ) {
if ( needsOutput ) {
ifSnippet = nodeProperty + ' = ' + ifSnippet + ';';
} else {
ifSnippet = 'return ' + ifSnippet + ';';
}
}
builder.removeFlowTab().addFlowCode( builder.tab + '\t' + ifSnippet + '\n\n' + builder.tab + '}' );
if ( elseNode !== null ) {
builder.addFlowCode( ' else {\n\n' ).addFlowTab();
let elseSnippet = elseNode.build( builder, type );
if ( elseSnippet ) {
if ( needsOutput ) {
elseSnippet = nodeProperty + ' = ' + elseSnippet + ';';
} else {
elseSnippet = 'return ' + elseSnippet + ';';
}
}
builder.removeFlowTab().addFlowCode( builder.tab + '\t' + elseSnippet + '\n\n' + builder.tab + '}\n\n' );
} else {
builder.addFlowCode( '\n\n' );
}
return builder.format( nodeProperty, type, output );
}
}
export default ConditionalNode;
/**
* TSL function for creating a conditional node.
*
* @function
* @param {Node} condNode - The node that defines the condition.
* @param {Node} ifNode - The node that is evaluate when the condition ends up `true`.
* @param {Node?} [elseNode=null] - The node that is evaluate when the condition ends up `false`.
* @returns {ConditionalNode}
*/
export const select = /*@__PURE__*/ nodeProxy( ConditionalNode );
addMethodChaining( 'select', select );
// Deprecated
/**
* @function
* @deprecated since r168. Use {@link select} instead.
*
* @param {...any} params
* @returns {ConditionalNode}
*/
export const cond = ( ...params ) => { // @deprecated, r168
console.warn( 'TSL.ConditionalNode: cond() has been renamed to select().' );
return select( ...params );
};
addMethodChaining( 'cond', cond );