Moved parser to typescript

app/imports/parser/parseTree/rollArray.ts

@@ -0,0 +1,80 @@
+import constant from './constant';
+import NodeFactory from '/imports/parser/parseTree/NodeFactory';
+import { Context, ResolvedResult } from '/imports/parser/resolve';
+
+type RollValue = {
+  value: number,
+  disabled?: true,
+  italics?: true,
+  bold?: true,
+  underline?: true,
+}
+
+export type RollArrayNode = {
+  parseType: 'rollArray';
+  values: RollValue[];
+  diceSize: number,
+  diceNum: number,
+}
+
+interface RollArrayFactory extends NodeFactory {
+  create(input: { values: number[], diceSize: number, diceNum: number }): RollArrayNode;
+  compile(
+    node: RollArrayNode, scope: Record<string, any>, context: Context
+  ): ResolvedResult;
+  roll?: undefined;
+  reduce(
+    node: RollArrayNode, scope: Record<string, any>, context: Context
+  ): ResolvedResult;
+  resolve?: undefined;
+  toString(node: RollArrayNode): string;
+  traverse?: undefined;
+  map?: undefined;
+}
+
+const rollArray: RollArrayFactory = {
+  create({
+    values, diceSize, diceNum
+  }) {
+    return {
+      parseType: 'rollArray',
+      values: values.map(v => ({ value: v })),
+      diceSize,
+      diceNum,
+    };
+  },
+  compile(node, scope, context) {
+    return {
+      result: node,
+      context
+    };
+  },
+  toString(node) {
+    return `${node.diceNum || ''}d${node.diceSize} [${valuesToString(node.values)}]`;
+  },
+  reduce(node, scope, context) {
+    const total = node.values.reduce((a, b) => {
+      if (b.disabled) return a;
+      return a + b.value;
+    }, 0);
+    return {
+      result: constant.create({
+        value: total,
+      }),
+      context,
+    };
+  },
+}
+
+function valuesToString(values: RollValue[]) {
+  return values.map(v => {
+    let text = `${v.value}`;
+    if (v.disabled) text = `~~${text}~~`;
+    if (v.italics) text = `*${text}*`;
+    if (v.bold) text = `**${text}**`;
+    if (v.underline) text = `__${text}__`;
+    return text;
+  }).join(', ');
+}
+
+export default rollArray;