Update JS to newest standard

.gitignore

@@ -135,3 +135,6 @@ dmypy.json
 
 # Ignored
 ignored
+
+# Examples
+examples/

js/.prettierrc.yml

@@ -1,2 +1,3 @@
 trailingComma: all
 arrowParens: avoid
+singleQuote: true

js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n-lang",
-  "version": "1.3.2",
+  "version": "0.1.0",
   "description": "A programming language for N Building.",
   "main": "src/index.js",
   "scripts": {

js/scripts/js-to-lines.js

@@ -77,7 +77,9 @@ async function jsFileToLines (path, requirableNames = []) {
           : JSON.stringify(line)
       })
       .join(',')
-    ts += `${exportName}: (name${
+    // __ is replaced with . for internal traits
+    const needsQuotes = exportName.indexOf('__') !== -1
+    ts += `${needsQuotes ? "'" : ''}${exportName.replace('__', '.')}${needsQuotes ? "'" : ''}: (name${
       requiresRequire ? ', require' : ''
     }) => [${lines}],\n\n`
   }

js/src/ast/base.ts

@@ -1,123 +1,124 @@
-import colours from 'colors/safe'
-import util from 'util'
+import colours from 'colors/safe';
+import util from 'util';
 
-import { displayType } from '../utils/display-type'
+import { displayType } from '../utils/display-type';
 
 export interface BasePosition {
-  line: number
-  col: number
-  endLine: number
-  endCol: number
+  line: number;
+  col: number;
+  endLine: number;
+  endCol: number;
 }
-function posHas (
+function posHas(
   { line: startLine, col: startCol, endLine, endCol }: BasePosition,
   line: number,
   col: number,
 ): boolean {
   if (line > startLine && line < endLine) {
-    return true
+    return true;
   } else if (line === startLine) {
-    if (col < startCol) return false
-    return line === endLine ? col <= endCol : true
+    if (col < startCol) return false;
+    return line === endLine ? col <= endCol : true;
   } else if (line === endLine) {
-    return col <= endCol
+    return col <= endCol;
   } else {
-    return false
+    return false;
   }
 }
 
 export class Base {
-  line: number
-  col: number
-  endLine: number
-  endCol: number
+  line: number;
+  col: number;
+  endLine: number;
+  endCol: number;
 
   /**
    * Should contain every Base kept by the class.
    */
-  children: Base[]
+  children: Base[];
 
-  constructor (
+  constructor(
     { line, col, endLine, endCol }: BasePosition,
     children: (Base | null)[] = [],
   ) {
-    this.line = line
-    this.col = col
-    this.endLine = endLine
-    this.endCol = endCol
-    this.children = children.filter((item): item is Base => item !== null)
+    this.line = line;
+    this.col = col;
+    this.endLine = endLine;
+    this.endCol = endCol;
+    this.children = children.filter((item): item is Base => item !== null);
   }
 
-  find (line: number, col: number): Base[] {
+  find(line: number, col: number): Base[] {
     if (posHas(this, line, col)) {
-      const bases: Base[] = []
+      const bases: Base[] = [];
       for (const base of this.children) {
         if (posHas(base, line, col)) {
-          bases.push(...base.find(line, col))
+          bases.push(...base.find(line, col));
         }
       }
-      bases.push(this)
-      return bases
+      bases.push(this);
+      return bases;
     } else {
-      return []
+      return [];
     }
   }
 
-  diff (other: this, path = '.'): BaseDiff[] {
+  diff(other: this, path = '.'): BaseDiff[] {
     if (this.constructor !== other.constructor) {
-      return [{ path, this: this.toString(), other: other.toString() }]
+      return [{ path, this: this.toString(), other: other.toString() }];
     }
-    const issues = []
+    const issues = [];
     for (const key in this) {
-      if (ignoredDiffKeys.includes(key)) continue
-      const propPath = `${path}/${this.constructor.name}.${key}`
-      const value = this[key]
-      const otherValue = other[key]
-      issues.push(...diffValues(propPath, value, otherValue))
+      if (ignoredDiffKeys.includes(key)) continue;
+      const propPath = `${path}/${this.constructor.name}.${key}`;
+      const value = this[key];
+      const otherValue = other[key];
+      issues.push(...diffValues(propPath, value, otherValue));
     }
-    return issues
+    return issues;
   }
 
-  toString (): string {
-    return `[undisplayable ${this.constructor.name}]`
+  toString(): string {
+    return `[undisplayable ${this.constructor.name}]`;
   }
 
   // Make the output of util.inspect cleaner
-  [util.inspect.custom] (): unknown {
-    const obj = { ...(this as Record<string, unknown>) }
+  // Is ? because if it is not in the node env it will cause errors
+  [util?.inspect?.custom]?(): unknown {
+    const obj = { ...(this as Record<string, unknown>) };
     // Sets a hidden value
     Object.defineProperty(obj, 'constructor', {
       value: this.constructor,
-    })
-    delete obj.line
-    delete obj.col
-    delete obj.endLine
-    delete obj.endCol
-    delete obj.children
-    return obj
+    });
+    delete obj.line;
+    delete obj.col;
+    delete obj.endLine;
+    delete obj.endCol;
+    delete obj.children;
+    return obj;
   }
 }
 
 export interface BaseDiff {
-  path: string
-  this: string
-  other: string
+  path: string;
+  this: string;
+  other: string;
 }
 
-const ignoredDiffKeys = ['line', 'col', 'endLine', 'endCol', 'children']
+const ignoredDiffKeys = ['line', 'col', 'endLine', 'endCol', 'children'];
 
-function diffValues (path: string, one: unknown, other: unknown): BaseDiff[] {
-  const issues = []
+function diffValues(path: string, one: unknown, other: unknown): BaseDiff[] {
+  const issues = [];
   if (typeof one === 'string' && typeof other === 'string') {
     if (one !== other) {
-      return [{ path, this: one, other }]
+      return [{ path, this: one, other }];
     }
   } else if (
     (typeof one === 'boolean' && typeof other === 'boolean') ||
     (typeof one === 'number' && typeof other === 'number')
   ) {
     if (one !== other) {
-      return [{ path, this: one.toString(), other: other.toString() }]
+      return [{ path, this: one.toString(), other: other.toString() }];
     }
   } else if (Array.isArray(one) && Array.isArray(other)) {
     if (one.length !== other.length) {
@@ -127,36 +128,36 @@ function diffValues (path: string, one: unknown, other: unknown): BaseDiff[] {
           this: `${one.length} item(s):\n${one.join('\n')}`,
           other: `${other.length} item(s):\n${other.join('\n')}`,
         },
-      ]
+      ];
     }
     for (let i = 0; i < one.length; i++) {
-      issues.push(...diffValues(`${path}[${i}]`, one[i], other[i]))
+      issues.push(...diffValues(`${path}[${i}]`, one[i], other[i]));
     }
   } else if (one instanceof Base && other instanceof Base) {
-    return one.diff(other)
+    return one.diff(other);
   } else if (typeof one === 'function' && typeof other === 'function') {
-    return []
+    return [];
   } else {
     throw new TypeError(
       `I do not know how to diff these types: ${displayType(
         one,
       )} vs ${displayType(other)}`,
-    )
+    );
   }
-  return issues
+  return issues;
 }
 
 export class DiffError extends Error {
-  constructor (diffs: BaseDiff[]) {
-    super(diffs.map(DiffError.display).join('\n\n'))
-    this.name = this.constructor.name
+  constructor(diffs: BaseDiff[]) {
+    super(diffs.map(DiffError.display).join('\n\n'));
+    this.name = this.constructor.name;
   }
 
-  static display (diff: BaseDiff): string {
+  static display(diff: BaseDiff): string {
     return [
       colours.bold(colours.white(diff.path)),
       colours.cyan(diff.this),
       colours.magenta(diff.other),
-    ].join('\n')
+    ].join('\n');
   }
 }

js/src/ast/condition/Condition.ts

@@ -1,60 +1,59 @@
-import { CompilationScope } from '../../compiler/CompilationScope'
-import { ErrorType } from '../../type-checker/errors/Error'
-import { Scope } from '../../type-checker/Scope'
-import { ScopeBaseContext } from '../../type-checker/ScopeBaseContext'
-import { bool } from '../../type-checker/types/builtins'
+import { CompilationScope } from '../../compiler/CompilationScope';
+import { ErrorType } from '../../type-checker/errors/Error';
+import { Scope } from '../../type-checker/Scope';
+import { ScopeBaseContext } from '../../type-checker/ScopeBaseContext';
+import { bool } from '../../type-checker/types/builtins';
 import {
   CompilationResult,
   Expression,
   isExpression,
-} from '../expressions/Expression'
-import { Return } from '../expressions/Return'
-import { IfLet } from './IfLet'
+} from '../expressions/Expression';
+import { Return } from '../expressions/Return';
+import { IfLet } from './IfLet';
 
-export type Condition = Expression | IfLet
+export type Condition = Expression | IfLet;
 
-export function isCondition (value: unknown): value is Condition {
-  return value instanceof IfLet || isExpression(value)
+export function isCondition(value: unknown): value is Condition {
+  return value instanceof IfLet || isExpression(value);
 }
 
 export interface ConditionResult {
-  scope: Scope
-  exitPoint?: Return
+  scope: Scope;
+  exitPoint?: Return;
 }
 
-export function checkCondition (
+export function checkCondition(
   context: ScopeBaseContext,
   condition: Condition,
 ): ConditionResult {
   if (condition instanceof IfLet) {
-    return condition.checkIfLet(context)
+    return condition.checkIfLet(context);
   } else {
-    const { type, exitPoint } = context.scope.typeCheck(condition)
-    context.isTypeError(ErrorType.CONDITION_NOT_BOOL, bool, type)
-    return { scope: context.scope.inner(), exitPoint }
+    const { type, exitPoint } = context.scope.typeCheck(condition);
+    context.isTypeError(ErrorType.CONDITION_NOT_BOOL, bool, type);
+    return { scope: context.scope.inner(), exitPoint };
   }
 }
 
 export type ConditionCompilationResult = {
-  statements: string[]
-  result: string
-}
+  statements: string[];
+  result: string;
+};
 
 /**
  * `scope` is the scope specifically for the "then" branch of the if
  * statement/expression. Unlike `checkCondition`, this function won't create an
  * inner scope for you.
  */
-export function compileCondition (
+export function compileCondition(
   scope: CompilationScope,
   condition: Condition,
 ): ConditionCompilationResult {
   if (condition instanceof IfLet) {
-    const { statements: exprS, expression } = condition.expression.compile(
-      scope,
-    )
-    const expressionName = scope.context.genVarName('ifLetValue')
-    const resultName = scope.context.genVarName('ifLetResult')
+    const { statements: exprS, expression } =
+      condition.expression.compile(scope);
+    const expressionName = scope.context.genVarName('ifLetValue');
+    const resultName = scope.context.genVarName('ifLetResult');
     return {
       statements: [
         ...exprS,
@@ -66,12 +65,12 @@ export function compileCondition (
         ),
       ],
       result: resultName,
-    }
+    };
   } else {
-    const { statements, expression } = condition.compile(scope)
+    const { statements, expression } = condition.compile(scope);
     return {
       statements,
       result: expression,
-    }
+    };
   }
 }