77 lines
2.4 KiB
TypeScript
77 lines
2.4 KiB
TypeScript
import ParseNode from '/imports/parser/parseTree/ParseNode';
|
|
import ResolvedResult from '../types/ResolvedResult';
|
|
import TraverseFunction from '/imports/parser/types/TraverseFunction';
|
|
import MapFunction from '/imports/parser/types/MapFunction';
|
|
import ResolveFunction from '/imports/parser/types/ResolveFunction';
|
|
import ToStringFunction from '/imports/parser/types/ToStringFunction';
|
|
|
|
export type IfNode = {
|
|
parseType: 'if';
|
|
condition: ParseNode;
|
|
consequent: ParseNode;
|
|
alternative: ParseNode;
|
|
}
|
|
|
|
type IfFactory = {
|
|
create(node: Partial<IfNode>): IfNode;
|
|
resolve: ResolveFunction<IfNode>;
|
|
toString: ToStringFunction<IfNode>;
|
|
traverse: TraverseFunction<IfNode>;
|
|
map: MapFunction<IfNode>;
|
|
}
|
|
|
|
const ifNode: IfFactory = {
|
|
create(
|
|
{ condition, consequent, alternative }:
|
|
{ condition: ParseNode, consequent: ParseNode, alternative: ParseNode }
|
|
) {
|
|
return {
|
|
parseType: 'if',
|
|
condition,
|
|
consequent,
|
|
alternative,
|
|
};
|
|
},
|
|
toString(node, stringOthers) {
|
|
const { condition, consequent, alternative } = node;
|
|
condition.parseType
|
|
return `${stringOthers(condition)} ? ${stringOthers(consequent)} : ${stringOthers(alternative)}`
|
|
},
|
|
async resolve(fn, node, scope, context, inputProvider, resolveOthers): Promise<ResolvedResult> {
|
|
const { result: condition } = await resolveOthers(fn, node.condition, scope, context, inputProvider);
|
|
if (condition.parseType === 'constant') {
|
|
if (condition.value) {
|
|
return resolveOthers(fn, node.consequent, scope, context, inputProvider);
|
|
} else {
|
|
return resolveOthers(fn, node.alternative, scope, context, inputProvider);
|
|
}
|
|
} else {
|
|
return {
|
|
result: ifNode.create({
|
|
condition: condition,
|
|
consequent: node.consequent,
|
|
alternative: node.alternative,
|
|
}),
|
|
context,
|
|
};
|
|
}
|
|
},
|
|
traverse(node, fn, traverseOthers) {
|
|
fn(node);
|
|
traverseOthers(node.condition, fn);
|
|
traverseOthers(node.consequent, fn);
|
|
traverseOthers(node.alternative, fn);
|
|
},
|
|
async map(node, fn, mapOthers) {
|
|
const resultingNode = await fn(node);
|
|
if (resultingNode === node) {
|
|
node.condition = await mapOthers(node.condition, fn);
|
|
node.consequent = await mapOthers(node.consequent, fn);
|
|
node.alternative = await mapOthers(node.alternative, fn);
|
|
}
|
|
return resultingNode;
|
|
},
|
|
}
|
|
|
|
export default ifNode;
|