jschaufuss/DiceCloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed .js from all imports to smooth ts migration

Browse Source
This commit is contained in:
ThaumRystra
2023-09-28 21:27:05 +02:00
parent 97790264d3
commit ece4a9391a
485 changed files with 1844 additions and 1843 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
app/imports/parser/parseTree/_index.js
View File

@@ -1,17 +1,17 @@
import accessor from './accessor.js';
import array from './array.js';
import call from './call.js';
import constant from './constant.js';
import error from './error.js';
import ifNode from './if.js';
import index from './index.js';
import not from './not.js';
import operator from './operator.js';
import parenthesis from './parenthesis.js';
import roll from './roll.js';
import rollArray from './rollArray.js';
import symbol from './symbol.js';
import unaryOperator from './unaryOperator.js';
import accessor from './accessor';
import array from './array';
import call from './call';
import constant from './constant';
import error from './error';
import ifNode from './if';
import index from './index';
import not from './not';
import operator from './operator';
import parenthesis from './parenthesis';
import roll from './roll';
import rollArray from './rollArray';
import symbol from './symbol';
import unaryOperator from './unaryOperator';
export default Object.freeze({
accessor,

6
app/imports/parser/parseTree/accessor.js
View File

@@ -1,6 +1,6 @@
import constant from './constant.js';
// import array from './array.js';
import { toString } from '../resolve.js';
import constant from './constant';
// import array from './array';
import { toString } from '../resolve';
const accessor = {
create({ name, path }) {

28
app/imports/parser/parseTree/array.js
View File

@@ -1,49 +1,49 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const array = {
create({values}) {
create({ values }) {
return {
parseType: 'array',
values,
};
},
fromConstantArray(array){
let values = array.map( value => {
fromConstantArray(array) {
let values = array.map(value => {
let valueType = typeof value;
if (
valueType === 'string' ||
valueType === 'number' ||
valueType === 'boolean' ||
valueType === 'undefined'
){
return constant.create({value, valueType});
) {
return constant.create({ value, valueType });
} else {
throw `Unexpected type in constant array: ${valueType}`
}
});
return array.create({values});
return array.create({ values });
},
resolve(fn, node, scope, context){
resolve(fn, node, scope, context) {
let values = node.values.map(node => {
let { result } = resolve(fn, node, scope, context);
return result;
});
return {
result: array.create({values}),
result: array.create({ values }),
context,
};
},
toString(node){
toString(node) {
return `[${node.values.map(value => toString(value)).join(', ')}]`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
node.values.forEach(value => traverse(value, fn));
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.values = node.values.map(value => map(value, fn));
}
return resultingNode;

8
app/imports/parser/parseTree/call.js
View File

@@ -1,7 +1,7 @@
import error from './error.js';
import constant from './constant.js';
import functions from '/imports/parser/functions.js';
import resolve, { toString, traverse, map } from '../resolve.js';
import error from './error';
import constant from './constant';
import functions from '/imports/parser/functions';
import resolve, { toString, traverse, map } from '../resolve';
const call = {
create({ functionName, args }) {

20
app/imports/parser/parseTree/not.js
View File

@@ -1,16 +1,16 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const not = {
create({right}) {
create({ right }) {
return {
parseType: 'not',
right,
}
},
resolve(fn, node, scope, context){
const {result: right} = resolve(fn, node.right, scope, context);
if (right.parseType !== 'constant'){
resolve(fn, node, scope, context) {
const { result: right } = resolve(fn, node.right, scope, context);
if (right.parseType !== 'constant') {
return {
result: not.create({
right: right,
@@ -25,16 +25,16 @@ const not = {
context,
};
},
toString(node){
toString(node) {
return `!${toString(node.right)}`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.right = map(node.right, fn);
}
return resultingNode;

32
app/imports/parser/parseTree/operator.js
View File

@@ -1,8 +1,8 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const operator = {
create({left, right, operator, fn}) {
create({ left, right, operator, fn }) {
return {
parseType: 'operator',
left,
@@ -11,11 +11,11 @@ const operator = {
fn
};
},
resolve(fn, node, scope, context){
const {result: leftNode} = resolve(fn, node.left, scope, context);
const {result: rightNode} = resolve(fn, node.right, scope, context);
resolve(fn, node, scope, context) {
const { result: leftNode } = resolve(fn, node.left, scope, context);
const { result: rightNode } = resolve(fn, node.right, scope, context);
let left, right;
if (leftNode.parseType !== 'constant' || rightNode.parseType !== 'constant'){
if (leftNode.parseType !== 'constant' || rightNode.parseType !== 'constant') {
return {
result: operator.create({
left: leftNode,
@@ -30,7 +30,7 @@ const operator = {
right = rightNode.value;
}
let result;
switch(node.operator){
switch (node.operator) {
case '+': result = left + right; break;
case '-': result = left - right; break;
case '*': result = left * right; break;
@@ -42,9 +42,9 @@ const operator = {
case '|':
case '||': result = left || right; break;
case '=':
case '==': result = left == right; break;
case '==': result = left == right; break;
case '===': result = left === right; break;
case '!=': result = left != right; break;
case '!=': result = left != right; break;
case '!==': result = left !== right; break;
case '>': result = left > right; break;
case '<': result = left < right; break;
@@ -58,22 +58,22 @@ const operator = {
context,
};
},
toString(node){
let {left, right, operator} = node;
toString(node) {
let { left, right, operator } = node;
// special case of adding a negative number
if (operator === '+' && right.valueType === 'number' && right.value < 0){
if (operator === '+' && right.valueType === 'number' && right.value < 0) {
return `${toString(left)} - ${-right.value}`
}
return `${toString(left)} ${operator} ${toString(right)}`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.left, fn);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.left = map(node.left, fn);
node.right = map(node.right, fn);
}

22
app/imports/parser/parseTree/parenthesis.js
View File

@@ -1,37 +1,37 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import resolve, { toString, traverse, map } from '../resolve';
const parenthesis = {
create({content}) {
create({ content }) {
return {
parseType: 'parenthesis',
content,
};
},
resolve(fn, node, scope, context){
const {result: content} = resolve(fn, node.content, scope, context);
resolve(fn, node, scope, context) {
const { result: content } = resolve(fn, node.content, scope, context);
if (
fn === 'reduce' ||
content.parseType === 'constant' ||
content.parseType === 'error'
){
return {result: content, context};
) {
return { result: content, context };
} else {
return {
result: parenthesis.create({content}),
result: parenthesis.create({ content }),
context
};
}
},
toString(node){
toString(node) {
return `(${toString(node.content)})`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.content, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.content = map(node.content, fn);
}
return resultingNode;

54
app/imports/parser/parseTree/roll.js
View File

@@ -1,55 +1,55 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import error from './error.js';
import rollArray from './rollArray.js';
import rollDice from '/imports/parser/rollDice.js';
import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
import resolve, { toString, traverse, map } from '../resolve';
import error from './error';
import rollArray from './rollArray';
import rollDice from '/imports/parser/rollDice';
import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS';
const rollNode = {
create({left, right}) {
create({ left, right }) {
return {
parseType: 'roll',
left,
right,
};
},
compile(node, scope, context){
const {result: left} = resolve('compile', node.left, scope, context);
const {result: right} = resolve('compile', node.right, scope, context);
compile(node, scope, context) {
const { result: left } = resolve('compile', node.left, scope, context);
const { result: right } = resolve('compile', node.right, scope, context);
return {
result: rollNode.create({left, right}),
result: rollNode.create({ left, right }),
context,
};
},
toString(node){
toString(node) {
if (
node.left.valueType === 'number' && node.left.value === 1
){
) {
return `d${toString(node.right)}`;
} else {
return `${toString(node.left)}d${toString(node.right)}`;
}
},
roll(node, scope, context){
const {result: left} = resolve('reduce', node.left, scope, context);
const {result: right} = resolve('reduce', node.right, scope, context);
if (left.valueType !== 'number' && !Number.isInteger(left.value)){
roll(node, scope, context) {
const { result: left } = resolve('reduce', node.left, scope, context);
const { result: right } = resolve('reduce', node.right, scope, context);
if (left.valueType !== 'number' && !Number.isInteger(left.value)) {
return errorResult('Number of dice is not an integer', node, context);
}
if (right.valueType !== 'number' && !Number.isInteger(right.value)){
if (right.valueType !== 'number' && !Number.isInteger(right.value)) {
return errorResult('Dice size is not an integer', node, context);
}
let number = left.value;
if (context.options.doubleRolls){
if (context.options.doubleRolls) {
number *= 2;
}
if (number > STORAGE_LIMITS.diceRollValuesCount){
if (number > STORAGE_LIMITS.diceRollValuesCount) {
const message = `Can't roll more than ${STORAGE_LIMITS.diceRollValuesCount} dice at once`;
return errorResult(message, node, context);
}
let diceSize = right.value;
let values = rollDice(number, diceSize);
if (context){
context.rolls.push({number, diceSize, values});
if (context) {
context.rolls.push({ number, diceSize, values });
}
return {
result: rollArray.create({
@@ -60,18 +60,18 @@ const rollNode = {
context
};
},
reduce(node, scope, context){
const {result} = rollNode.roll(node, scope, context);
reduce(node, scope, context) {
const { result } = rollNode.roll(node, scope, context);
return resolve('reduce', result, scope, context);
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.left, fn);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.left = map(node.left, fn);
node.right = map(node.right, fn);
}
@@ -79,7 +79,7 @@ const rollNode = {
},
}
function errorResult(message, node, context){
function errorResult(message, node, context) {
context.error(message);
return {
result: error.create({ node, error: message }),

2
app/imports/parser/parseTree/rollArray.js
View File

@@ -1,4 +1,4 @@
import constant from './constant.js';
import constant from './constant';
const rollArray = {
create({ values, diceSize, diceNum }) {

4
app/imports/parser/parseTree/symbol.js
View File

@@ -1,5 +1,5 @@
import resolve, { toString } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString } from '../resolve';
import constant from './constant';
const symbol = {
create({ name }) {

22
app/imports/parser/parseTree/unaryOperator.js
View File

@@ -1,17 +1,17 @@
import resolve, { toString, traverse, map } from '../resolve.js';
import constant from './constant.js';
import resolve, { toString, traverse, map } from '../resolve';
import constant from './constant';
const unaryOperator = {
create({operator, right}) {
create({ operator, right }) {
return {
parseType: 'unaryOperator',
operator,
right,
};
},
resolve(fn, node, scope, context){
const {result: rightNode} = resolve(fn, node.right, scope, context);
if (rightNode.valueType !== 'number'){
resolve(fn, node, scope, context) {
const { result: rightNode } = resolve(fn, node.right, scope, context);
if (rightNode.valueType !== 'number') {
return {
result: unaryOperator.create({
operator: node.operator,
@@ -22,7 +22,7 @@ const unaryOperator = {
}
let right = rightNode.value;
let result;
switch(node.operator){
switch (node.operator) {
case '-': result = -right; break;
case '+': result = +right; break;
}
@@ -34,16 +34,16 @@ const unaryOperator = {
context,
};
},
toString(node){
toString(node) {
return `${node.operator}${toString(node.right)}`;
},
traverse(node, fn){
traverse(node, fn) {
fn(node);
traverse(node.right, fn);
},
map(node, fn){
map(node, fn) {
const resultingNode = fn(node);
if (resultingNode === node){
if (resultingNode === node) {
node.right = map(node.right, fn);
}
return resultingNode;