@weborigami/language 0.0.58 → 0.0.60

package/test/runtime/ops.test.js

@@ -1,7 +1,6 @@
 import { ObjectTree, Tree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import Scope from "../../src/runtime/Scope.js";
 
 import {
   OrigamiTree,
@@ -100,25 +99,27 @@ describe("ops", () => {
         ]),
       ],
     ];
-    const result = await evaluate.call({}, code);
+    const parent = new ObjectTree({});
+    const result = await evaluate.call(parent, code);
     assert(result instanceof OrigamiTree);
     assert.deepEqual(await Tree.plain(result), {
       name: "world",
       message: "Hello, world!",
     });
+    assert.equal(result.parent, parent);
   });
 
   test("can search inherited scope", async () => {
-    const a = new ObjectTree({
+    const parent = new ObjectTree({
       a: 1, // This is the inherited value we want
     });
     /** @type {any} */
-    const b = new ObjectTree({
+    const child = new ObjectTree({
       a: 2, // Should be ignored
     });
-    b.scope = new Scope(b, a);
+    child.parent = parent;
     const code = [ops.inherited, "a"];
-    const result = await evaluate.call(b.scope, code);
+    const result = await evaluate.call(child, code);
     assert.equal(result, 1);
   });
 

package/src/runtime/InheritScopeMixin.d.ts

@@ -1,9 +0,0 @@
-import { Mixin } from "../../index.ts";
-
-import type { AsyncTree } from "@weborigami/types";
-
-declare const InheritScopeMixin: Mixin<{
-  scope: AsyncTree|null;
-}>;
-
-export default InheritScopeMixin;

package/src/runtime/InheritScopeMixin.js

@@ -1,34 +0,0 @@
-import Scope from "./Scope.js";
-
-const scopeKey = Symbol("scope");
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function InheritScopeMixin(Base) {
-  return class InheritScope extends Base {
-    constructor(...args) {
-      super(...args);
-      this[scopeKey] = null;
-    }
-
-    /** @type {import("@weborigami/types").AsyncTree} */
-    get scope() {
-      if (this[scopeKey] === null) {
-        if (this.parent) {
-          // Add parent to this tree's scope.
-          this[scopeKey] = new Scope(this, Scope.getScope(this.parent));
-        } else {
-          // Scope is just the tree itself.
-          this[scopeKey] = this;
-        }
-      }
-      return this[scopeKey];
-    }
-    set scope(scope) {
-      this[scopeKey] = scope;
-    }
-  };
-}

package/src/runtime/Scope.js

@@ -1,96 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class Scope {
-  constructor(...treelikes) {
-    const filtered = treelikes.filter((treelike) => treelike != undefined);
-    const trees = filtered.map((treelike) => Tree.from(treelike));
-
-    // If a tree argument has a `trees` property, use that instead.
-    const scopes = trees.flatMap(
-      (tree) => /** @type {any} */ (tree).trees ?? tree
-    );
-
-    this.trees = scopes;
-  }
-
-  async get(key) {
-    for (const tree of this.trees) {
-      const value = await tree.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return undefined;
-  }
-
-  /**
-   * If the given tree has a `scope` property, return that. If the tree has a
-   * `parent` property, construct a scope for the tree and its parent.
-   * Otherwise, return the tree itself.
-   *
-   * @param {AsyncTree|null|undefined} tree
-   * @returns {AsyncTree|null}
-   */
-  static getScope(tree) {
-    if (!tree) {
-      return null;
-    } else if (!Tree.isAsyncTree(tree)) {
-      throw new Error("Tried to get the scope of something that's not a tree.");
-    }
-
-    if ("scope" in tree) {
-      // Ask tree for its scope, use that if defined.
-      const scope = /** @type {any} */ (tree).scope;
-      if (scope) {
-        return scope;
-      }
-    }
-
-    // Default scope is tree plus its parent scope.
-    return new Scope(tree, this.getScope(tree.parent));
-  }
-
-  async keys() {
-    const keys = new Set();
-    for (const tree of this.trees) {
-      for (const key of await tree.keys()) {
-        keys.add(key);
-      }
-    }
-    return keys;
-  }
-
-  /**
-   * Return a new tree equivalent to the given tree, but with the given scope.
-   *
-   * The tree itself will be automatically included at the front of the scope.
-   *
-   * @typedef {import("@weborigami/async-tree").Treelike} Treelike
-   * @param {Treelike} treelike
-   * @param {Treelike|null} scope
-   * @returns {AsyncTree & { scope: AsyncTree }}
-   */
-  static treeWithScope(treelike, scope) {
-    // If the treelike was already a tree, create a copy of it.
-    const tree = Tree.isAsyncTree(treelike)
-      ? Object.create(treelike)
-      : Tree.from(treelike);
-    tree.scope = new Scope(tree, scope);
-    return tree;
-  }
-
-  async unwatch() {
-    for (const tree of this.trees) {
-      await /** @type {any} */ (tree).unwatch?.();
-    }
-  }
-  async watch() {
-    for (const tree of this.trees) {
-      await /** @type {any} */ (tree).watch?.();
-    }
-  }
-}

package/src/runtime/concatTreeValues.js

@@ -1,59 +0,0 @@
-import { Tree, getRealmObjectPrototype } from "@weborigami/async-tree";
-
-const textDecoder = new TextDecoder();
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-
-/**
- * Concatenate the text values in a tree.
- *
- * This is a map-reduce operation: convert everything to strings, then
- * concatenate the strings.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
- * @this {AsyncTree|null}
- * @param {import("@weborigami/async-tree").Treelike} treelike
- */
-export default async function concatTreeValues(treelike) {
-  const scope = this;
-  const mapFn = async (value) => getText(value, scope);
-  const reduceFn = (values) => values.join("");
-  return Tree.mapReduce(treelike, mapFn, reduceFn);
-}
-
-async function getText(value, scope) {
-  // If the value is a function (e.g., a lambda), call it and use its result.
-  if (typeof value === "function") {
-    value = await value.call(scope);
-  }
-
-  if (Tree.isTreelike(value)) {
-    // The mapReduce operation above only implicit casts its top-level input to
-    // a tree. If we're asked for the text of a treelike value, we need to
-    // explicitly recurse.
-    return concatTreeValues.call(scope, value);
-  }
-
-  // Convert to text, preferring .toString but avoiding dumb Object.toString.
-  // Exception: if the result is an array, we'll concatenate the values.
-  let text;
-  if (value == null || value === false) {
-    // Treat falsy values (but not zero) as the empty string.
-    text = "";
-  } else if (typeof value === "string") {
-    text = value;
-  } else if (value instanceof ArrayBuffer || value instanceof TypedArray) {
-    // Serialize data as UTF-8.
-    text = textDecoder.decode(value);
-  } else if (
-    !(value instanceof Array) &&
-    value.toString !== getRealmObjectPrototype(value)?.toString
-  ) {
-    text = value.toString();
-  } else {
-    // Anything else maps to the empty string.
-    text = "";
-  }
-
-  return text;
-}

package/test/runtime/InheritScopeMixin.test.js

@@ -1,29 +0,0 @@
-import { DeepObjectTree, ObjectTree } from "@weborigami/async-tree";
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import InheritScopeMixin from "../../src/runtime/InheritScopeMixin.js";
-
-describe("InheritScopeMixin", () => {
-  test("creates a scope that includes a tree and its parent", async () => {
-    const fixture = new (InheritScopeMixin(ObjectTree))({
-      b: 2,
-    });
-    fixture.parent = new ObjectTree({
-      a: 1,
-    });
-    assert.deepEqual(await fixture.scope?.get("b"), 2);
-    assert.deepEqual(await fixture.scope?.get("a"), 1);
-  });
-
-  test("adds a subtree's parent to the subtrees's scope", async () => {
-    const fixture = new (InheritScopeMixin(DeepObjectTree))({
-      a: 1,
-      subtree: {
-        b: 2,
-      },
-    });
-    const subtree = await fixture.get("subtree");
-    assert.deepEqual(await subtree.scope.get("b"), 2);
-    assert.deepEqual(await subtree.scope.get("a"), 1);
-  });
-});

package/test/runtime/Scope.test.js

@@ -1,37 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import Scope from "../../src/runtime/Scope.js";
-
-describe("Scope", () => {
-  test("composes and flattens scopes and trees passed to it", async () => {
-    const treeA = {
-      a: 1,
-    };
-    const treeB = {
-      b: 2,
-    };
-    const treeC = {
-      c: 3,
-    };
-    const scope1 = new Scope(treeA, treeB);
-    const scope2 = new Scope(scope1, treeC);
-    const objects = scope2.trees.map(
-      (tree) => /** @type {any} */ (tree).object
-    );
-    assert.deepEqual(objects, [treeA, treeB, treeC]);
-  });
-
-  test("gets the first defined value from the scope trees", async () => {
-    const scope = new Scope(
-      {
-        a: 1,
-      },
-      {
-        a: 2,
-        b: 3,
-      }
-    );
-    assert.equal(await scope.get("a"), 1);
-    assert.equal(await scope.get("b"), 3);
-  });
-});

package/test/runtime/concatTreeValues.test.js

@@ -1,33 +0,0 @@
-import { FunctionTree, Tree } from "@weborigami/async-tree";
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import concatTreeValues from "../../src/runtime/concatTreeValues.js";
-
-describe("concatTreeValues", () => {
-  test("concatenates deep tree values", async () => {
-    const tree = Tree.from({
-      a: "A",
-      b: "B",
-      c: "C",
-      more: {
-        d: "D",
-        e: "E",
-      },
-    });
-    const result = await concatTreeValues.call(null, tree);
-    assert.equal(result, "ABCDE");
-  });
-
-  test("concatenates deep tree-like values", async () => {
-    const letters = ["a", "b", "c"];
-    const specimens = new FunctionTree(
-      (letter) => ({
-        lowercase: letter,
-        uppercase: letter.toUpperCase(),
-      }),
-      letters
-    );
-    const result = await concatTreeValues.call(null, specimens);
-    assert.equal(result, "aAbBcC");
-  });
-});