feat: New Deno runtime

.eslintignore

@@ -4,3 +4,5 @@
 /docs
 /server
 /lib
+/deno-runtime
+/.deno

.github/workflows/build_and_test.yml

@@ -8,6 +8,10 @@ on:
         branches:
             - 'alpha'
             - 'beta'
+            - 'feat/deno-runtime'
+
+env:
+    DENO_DIR: .deno
 
 jobs:
     prepare:
@@ -45,13 +49,18 @@ jobs:
               id: cache-nodemodules
               uses: actions/cache@v2
               with:
-                  path: ./node_modules
-                  key: ${{ runner.OS }}-node_modules-4-${{ hashFiles('./package-lock.json', '.github/workflows/build_and_test.yml') }}
+                  path: |
+                      ./node_modules
+                      ./deno-runtime/${{ env.DENO_DIR }}
+                  key: ${{ runner.OS }}-node_modules-deno-cache-5-${{ hashFiles('./package-lock.json', './deno-runtime/deno.lock', '.github/workflows/build_and_test.yml') }}
 
             - name: npm install
               if: steps.cache-nodemodules.outputs.cache-hit != 'true'
               run: npm install
 
+            - name: Deno Info
+              run: npx deno-bin info
+
             - name: Prepare workspace
               run: |
                   tar czf /tmp/workspace.tar.gz .
@@ -85,7 +94,7 @@ jobs:
 
     test:
         runs-on: ubuntu-latest
-        needs: prepare
+        needs: build
 
         steps:
             - name: Use Node.js 14.19.3
@@ -103,13 +112,11 @@ jobs:
                   tar xzf /tmp/workspace.tar.gz .
 
             - name: Test TypeScript Code
-              run: npm run unit-tests
+              run: npm run test
 
     build:
         runs-on: ubuntu-latest
-        needs:
-            - lint
-            - test
+        needs: lint
 
         steps:
             - name: Use Node.js 14.19.3
@@ -140,8 +147,8 @@ jobs:
 
     publish:
         runs-on: ubuntu-latest
-        if: github.event_name == 'release' || github.ref == 'refs/heads/alpha' || github.ref == 'refs/heads/beta'
-        needs: build
+        if: github.event_name == 'release' || github.ref == 'refs/heads/alpha' || github.ref == 'refs/heads/beta' || github.ref == 'refs/heads/feat/deno-runtime'
+        needs: test
 
         steps:
             - name: Use Node.js 14.19.3
@@ -175,6 +182,8 @@ jobs:
                       GIT_BRANCH="${GITHUB_REF#*heads/}"
                       if [[ $GIT_BRANCH == 'alpha' ]]; then
                           npm run go-publish-alpha
+                      elif [[ $GIT_BRANCH == 'feat/deno-runtime' ]]; then
+                          npm publish --access public --tag deno
                       else
                           npm run go-publish-beta
                       fi;

.gitignore

@@ -37,6 +37,8 @@ jspm_packages
 # Optional npm cache directory
 .npm
 
+.deno
+
 # Optional REPL history
 .node_repl_history
 

deno-runtime/.gitignore

@@ -0,0 +1 @@
+.deno/

deno-runtime/AppObjectRegistry.ts

@@ -0,0 +1,26 @@
+export type Maybe<T> = T | null | undefined;
+
+export const AppObjectRegistry = new class {
+    registry: Record<string, unknown> = {};
+
+    public get<T>(key: string): Maybe<T> {
+        return this.registry[key] as Maybe<T>;
+    }
+
+    public set(key: string, value: unknown): void {
+        this.registry[key] = value;
+    }
+
+    public has(key: string): boolean {
+        return key in this.registry;
+    }
+
+    public delete(key: string): void {
+        delete this.registry[key];
+    }
+
+    public clear(): void {
+        this.registry = {};
+    }
+}
+

deno-runtime/acorn-walk.d.ts

@@ -0,0 +1,170 @@
+import type acorn from "./acorn.d.ts";
+
+export type FullWalkerCallback<TState> = (
+  node: acorn.AnyNode,
+  state: TState,
+  type: string
+) => void
+
+export type FullAncestorWalkerCallback<TState> = (
+  node: acorn.AnyNode,
+  state: TState,
+  ancestors: acorn.AnyNode[],
+  type: string
+) => void
+
+type AggregateType = {
+  Expression: acorn.Expression,
+  Statement: acorn.Statement,
+  Pattern: acorn.Pattern,
+  ForInit: acorn.VariableDeclaration | acorn.Expression
+}
+
+export type SimpleVisitors<TState> = {
+  [type in acorn.AnyNode["type"]]?: (node: Extract<acorn.AnyNode, { type: type }>, state: TState) => void
+} & {
+  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState) => void
+}
+
+export type AncestorVisitors<TState> = {
+  [type in acorn.AnyNode["type"]]?: ( node: Extract<acorn.AnyNode, { type: type }>, state: TState, ancestors: acorn.Node[]
+) => void
+} & {
+  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, ancestors: acorn.Node[]) => void
+}
+
+export type WalkerCallback<TState> = (node: acorn.Node, state: TState) => void
+
+export type RecursiveVisitors<TState> = {
+  [type in acorn.AnyNode["type"]]?: ( node: Extract<acorn.AnyNode, { type: type }>, state: TState, callback: WalkerCallback<TState>) => void
+} &  {
+  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, callback: WalkerCallback<TState>) => void
+}
+
+export type FindPredicate = (type: string, node: acorn.Node) => boolean
+
+export interface Found<TState> {
+  node: acorn.Node,
+  state: TState
+}
+
+/**
+ * does a 'simple' walk over a tree
+ * @param node the AST node to walk
+ * @param visitors an object with properties whose names correspond to node types in the {@link https://github.com/estree/estree | ESTree spec}. The properties should contain functions that will be called with the node object and, if applicable the state at that point.
+ * @param base a walker algorithm
+ * @param state a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.)
+ */
+export function simple<TState>(
+  node: acorn.Node,
+  visitors: SimpleVisitors<TState>,
+  base?: RecursiveVisitors<TState>,
+  state?: TState
+): void
+
+/**
+ * does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+ * @param node
+ * @param visitors
+ * @param base
+ * @param state
+ */
+export function ancestor<TState>(
+    node: acorn.Node,
+    visitors: AncestorVisitors<TState>,
+    base?: RecursiveVisitors<TState>,
+    state?: TState
+  ): void
+
+/**
+ * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node.
+ * @param node
+ * @param state the start state
+ * @param functions contain an object that maps node types to walker functions
+ * @param base provides the fallback walker functions for node types that aren't handled in the {@link functions} object. If not given, the default walkers will be used.
+ */
+export function recursive<TState>(
+  node: acorn.Node,
+  state: TState,
+  functions: RecursiveVisitors<TState>,
+  base?: RecursiveVisitors<TState>
+): void
+
+/**
+ * does a 'full' walk over a tree, calling the {@link callback} with the arguments (node, state, type) for each node
+ * @param node
+ * @param callback
+ * @param base
+ * @param state
+ */
+export function full<TState>(
+  node: acorn.Node,
+  callback: FullWalkerCallback<TState>,
+  base?: RecursiveVisitors<TState>,
+  state?: TState
+): void
+
+/**
+ * does a 'full' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+ * @param node
+ * @param callback
+ * @param base
+ * @param state
+ */
+export function fullAncestor<TState>(
+  node: acorn.AnyNode,
+  callback: FullAncestorWalkerCallback<TState>,
+  base?: RecursiveVisitors<TState>,
+  state?: TState
+): void
+
+/**
+ * builds a new walker object by using the walker functions in {@link functions} and filling in the missing ones by taking defaults from {@link base}.
+ * @param functions
+ * @param base
+ */
+export function make<TState>(
+  functions: RecursiveVisitors<TState>,
+  base?: RecursiveVisitors<TState>
+): RecursiveVisitors<TState>
+
+/**
+ * tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate test. {@link start} and {@link end} can be either `null` (as wildcard) or a `number`. {@link test} may be a string (indicating a node type) or a function that takes (nodeType, node) arguments and returns a boolean indicating whether this node is interesting. {@link base} and {@link state} are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred.
+ * @param node
+ * @param start
+ * @param end
+ * @param type
+ * @param base
+ * @param state
+ */
+export function findNodeAt<TState>(
+  node: acorn.AnyNode,
+  start: number | undefined,
+  end?: number | undefined,
+  type?: FindPredicate | string,
+  base?: RecursiveVisitors<TState>,
+  state?: TState
+): Found<TState> | undefined
+
+/**
+ * like {@link findNodeAt}, but will match any node that exists 'around' (spanning) the given position.
+ * @param node
+ * @param start
+ * @param type
+ * @param base
+ * @param state
+ */
+export function findNodeAround<TState>(
+  node: acorn.AnyNode,
+  start: number | undefined,
+  type?: FindPredicate | string,
+  base?: RecursiveVisitors<TState>,
+  state?: TState
+): Found<TState> | undefined
+
+/**
+ * similar to {@link findNodeAround}, but will match all nodes after the given position (testing outer nodes before inner nodes).
+ */
+export const findNodeAfter: typeof findNodeAround
+
+export const base: RecursiveVisitors<unknown>