@weborigami/language 0.0.35

package/src/compiler/parserHelpers.js

@@ -0,0 +1,26 @@
+import * as ops from "../runtime/ops.js";
+
+// Parser helpers
+
+export function makeFunctionCall(target, chain) {
+  let value = target;
+  // The chain is an array of arguments (which are themselves arrays). We
+  // successively apply the top-level elements of that chain to build up the
+  // function composition.
+  for (const args of chain) {
+    value = [value, ...args];
+  }
+  return value;
+}
+
+export function makeTemplate(parts) {
+  // Drop empty/null strings.
+  const filtered = parts.filter((part) => part);
+  // Return a concatenation of the parts. If there are no parts, return the
+  // empty string. If there's just one string, return that directly.
+  return filtered.length === 0
+    ? ""
+    : filtered.length === 1 && typeof filtered[0] === "string"
+    ? filtered[0]
+    : [ops.concat, ...filtered];
+}

package/src/runtime/EventTargetMixin.d.ts

@@ -0,0 +1,9 @@
+import { Mixin } from "../../index.ts";
+
+declare const EventTargetMixin: Mixin<{
+  addEventListener(type: string, listener: EventListener): void;
+  dispatchEvent(event: Event): boolean;
+  removeEventListener(type: string, listener: EventListener): void;
+}>;
+
+export default EventTargetMixin;

package/src/runtime/EventTargetMixin.js

@@ -0,0 +1,117 @@
+const listenersKey = Symbol("listeners");
+
+export default function EventTargetMixin(Base) {
+  // Based on https://github.com/piranna/EventTarget.js
+  return class EventTarget extends Base {
+    constructor(...args) {
+      super(...args);
+      this[listenersKey] = {};
+    }
+
+    addEventListener(type, callback) {
+      if (!callback) {
+        return;
+      }
+
+      let listenersOfType = this[listenersKey][type];
+      if (!listenersOfType) {
+        this[listenersKey][type] = [];
+        listenersOfType = this[listenersKey][type];
+      }
+
+      // Don't add the same callback twice.
+      if (listenersOfType.includes(callback)) {
+        return;
+      }
+
+      listenersOfType.push(callback);
+    }
+
+    dispatchEvent(event) {
+      if (!(event instanceof Event)) {
+        throw TypeError("Argument to dispatchEvent must be an Event");
+      }
+
+      let stopImmediatePropagation = false;
+      let defaultPrevented = false;
+
+      if (!event.cancelable) {
+        Object.defineProperty(event, "cancelable", {
+          value: true,
+          enumerable: true,
+        });
+      }
+      if (!event.defaultPrevented) {
+        Object.defineProperty(event, "defaultPrevented", {
+          get: () => defaultPrevented,
+          enumerable: true,
+        });
+      }
+      // 2023-09-11: Setting isTrusted causes exception on Glitch
+      // if (!event.isTrusted) {
+      //   Object.defineProperty(event, "isTrusted", {
+      //     value: false,
+      //     enumerable: true,
+      //   });
+      // }
+      if (!event.target) {
+        Object.defineProperty(event, "target", {
+          value: this,
+          enumerable: true,
+        });
+      }
+      if (!event.timeStamp) {
+        Object.defineProperty(event, "timeStamp", {
+          value: new Date().getTime(),
+          enumerable: true,
+        });
+      }
+
+      event.preventDefault = function () {
+        if (this.cancelable) {
+          defaultPrevented = true;
+        }
+      };
+      event.stopImmediatePropagation = function () {
+        stopImmediatePropagation = true;
+      };
+      event.stopPropagation = function () {
+        // This is a no-op because we don't support event bubbling.
+      };
+
+      const type = event.type;
+      const listenersOfType = this[listenersKey][type] || [];
+      for (const listener of listenersOfType) {
+        if (stopImmediatePropagation) {
+          break;
+        }
+        listener.call(this, event);
+      }
+
+      return !event.defaultPrevented;
+    }
+
+    removeEventListener(type, callback) {
+      if (!callback) {
+        return;
+      }
+
+      let listenersOfType = this[listenersKey][type];
+      if (!listenersOfType) {
+        return;
+      }
+
+      // Remove callback from listeners.
+      listenersOfType = listenersOfType.filter(
+        (listener) => listener !== callback
+      );
+
+      // If there are no more listeners for this type, remove the type.
+      if (listenersOfType.length === 0) {
+        delete this[listenersKey][type];
+      } else {
+        this[listenersKey][type] = listenersOfType;
+      }
+    }
+  };
+}

package/src/runtime/ExpressionTree.js

@@ -0,0 +1,20 @@
+import { ObjectTree } from "@weborigami/async-tree";
+import InvokeFunctionsTransform from "./InvokeFunctionsTransform.js";
+import { expressionFunction } from "./internal.js";
+
+export default class ExpressionTree extends InvokeFunctionsTransform(
+  ObjectTree
+) {
+  // Return the unevaluated expressions in the original object.
+  expressions() {
+    const obj = /** @type {any} */ (this).object;
+    const result = {};
+    for (const key in obj) {
+      const value = obj[key];
+      if (expressionFunction.isExpressionFunction(value)) {
+        result[key] = value.code;
+      }
+    }
+    return result;
+  }
+}

package/src/runtime/FileLoadersTransform.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "../../index.ts";
+
+declare const FileLoadersTransform: Mixin<{}>;
+
+export default FileLoadersTransform;

package/src/runtime/FileLoadersTransform.js

@@ -0,0 +1,43 @@
+import { Tree, isStringLike } from "@weborigami/async-tree";
+import Scope from "./Scope.js";
+import extname from "./extname.js";
+
+/**
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @typedef {import("../../index.js").FileUnpackFunction} FileUnpackFunction
+ *
+ * @param {AsyncTreeConstructor} Base
+ */
+export default function FileLoadersTransform(Base) {
+  return class FileLoaders extends Base {
+    async get(key) {
+      let value = await super.get(key);
+
+      // If the value is string-like and the key has an extension, look for a
+      // loader that handles that extension and call it. The value will
+      // typically be a Buffer loaded from the file system, but could also be a
+      // string-like object defined by a user function.
+      if (isStringLike(value) && isStringLike(key)) {
+        const extension = extname(String(key)).toLowerCase().slice(1);
+        if (extension) {
+          /** @type {any} */
+          const scope = Scope.getScope(this);
+          /** @type {FileUnpackFunction} */
+          const unpackFn = await Tree.traverse(scope, "@loaders", extension);
+          if (unpackFn) {
+            const input = value;
+            // If the input is a plain string, convert it to a String so we can
+            // attach data to it.
+            value = new String(input);
+            const parent = this;
+            value.parent = parent;
+            value.unpack = () => unpackFn(input, { key, parent });
+          }
+        }
+      }
+
+      return value;
+    }
+  };
+}

package/src/runtime/ImportModulesMixin.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "../../index.ts";
+
+declare const ImportModulesMixin: Mixin<{}>;
+
+export default ImportModulesMixin;

package/src/runtime/ImportModulesMixin.js

@@ -0,0 +1,48 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+/**
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").Constructor<AsyncTree & { dirname: string }>} BaseConstructor
+ * @param {BaseConstructor} Base
+ */
+export default function ImportModulesMixin(Base) {
+  return class ImportModules extends Base {
+    async import(...keys) {
+      const filePath = path.join(this.dirname, ...keys);
+      // On Windows, absolute paths must be valid file:// URLs.
+      const fileUrl = pathToFileURL(filePath);
+      const modulePath = fileUrl.href;
+
+      // Try to load the module.
+      let obj;
+      try {
+        obj = await import(modulePath);
+      } catch (/** @type {any} */ error) {
+        if (error.code !== "ERR_MODULE_NOT_FOUND") {
+          throw error;
+        }
+
+        // Does the module exist as a file?
+        let stats;
+        try {
+          stats = await fs.stat(filePath);
+        } catch (error) {
+          // Ignore errors.
+        }
+        if (stats) {
+          // Module exists, but we can't load it, probably due to a syntax error.
+          throw new SyntaxError(`Error loading ${filePath}`);
+        }
+
+        // Module doesn't exist.
+        return undefined;
+      }
+
+      // If the module loaded and defines a default export, return that, otherwise
+      // return the overall module.
+      return typeof obj === "object" && "default" in obj ? obj.default : obj;
+    }
+  };
+}

package/src/runtime/InheritScopeMixin.js

@@ -0,0 +1,34 @@
+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/InheritScopeMixin.ts

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

package/src/runtime/InvokeFunctionsTransform.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "../../index.ts";
+
+declare const InvokeFunctionsTransform: Mixin<{}>;
+
+export default InvokeFunctionsTransform;

package/src/runtime/InvokeFunctionsTransform.js

@@ -0,0 +1,27 @@
+import { Tree } from "@weborigami/async-tree";
+import Scope from "./Scope.js";
+
+/**
+ * When using `get` to retrieve a value from a tree, if the value is a
+ * function, invoke it and return the result.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @param {AsyncTreeConstructor} Base
+ */
+export default function InvokeFunctionsTransform(Base) {
+  return class InvokeFunctions extends Base {
+    async get(key) {
+      let value = await super.get(key);
+      if (typeof value === "function") {
+        const scope = Scope.getScope(this);
+        value = await value.call(scope);
+
+        if (Tree.isAsyncTree(value)) {
+          value.parent = this;
+        }
+      }
+      return value;
+    }
+  };
+}

package/src/runtime/OrigamiFiles.d.ts

@@ -0,0 +1,11 @@
+import { FileTree } from "@weborigami/async-tree";
+import EventTargetMixin from "./EventTargetMixin.js";
+import ImportModulesMixin from "./ImportModulesMixin.js";
+import OrigamiTransform from "./OrigamiTransform.js";
+import WatchFilesMixin from "./WatchFilesMixin.js";
+
+export default class OrigamiFiles extends OrigamiTransform(
+  (
+    ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
+  )
+) {}

package/src/runtime/OrigamiFiles.js

@@ -0,0 +1,9 @@
+import { FileTree } from "@weborigami/async-tree";
+import EventTargetMixin from "./EventTargetMixin.js";
+import ImportModulesMixin from "./ImportModulesMixin.js";
+import OrigamiTransform from "./OrigamiTransform.js";
+import WatchFilesMixin from "./WatchFilesMixin.js";
+
+export default class OrigamiFiles extends OrigamiTransform(
+  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
+) {}

package/src/runtime/OrigamiTransform.d.ts

@@ -0,0 +1,11 @@
+import { Mixin } from "../../index.ts";
+
+import type { AsyncTree } from "@weborigami/types";
+
+// TODO: Figure out how to import declarations from InheritScopeMixin and
+// FileLoadersTransform and apply them here.
+declare const OrigamiTransform: Mixin<{
+  scope: AsyncTree|null;
+}>;
+
+export default OrigamiTransform;

package/src/runtime/OrigamiTransform.js

@@ -0,0 +1,11 @@
+import FileLoadersTransform from "./FileLoadersTransform.js";
+import InheritScopeMixin from "./InheritScopeMixin.js";
+
+/**
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @param {AsyncTreeConstructor} Base
+ */
+export default function OrigamiTransform(Base) {
+  return class Origami extends InheritScopeMixin(FileLoadersTransform(Base)) {};
+}

package/src/runtime/OrigamiTree.js

@@ -0,0 +1,4 @@
+import { ExpressionTree } from "./internal.js";
+import OrigamiTransform from "./OrigamiTransform.js";
+
+export default class OrigamiTree extends OrigamiTransform(ExpressionTree) {}

package/src/runtime/ReadMe.md

@@ -0,0 +1 @@
+Modules necessary to evaluate Origami expressions

package/src/runtime/Scope.js

@@ -0,0 +1,89 @@
+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 ("scope" in tree) {
+      return /** @type {any} */ (tree).scope;
+    } else if (Tree.isAsyncTree(tree)) {
+      return new Scope(tree, this.getScope(tree.parent));
+    } else {
+      return tree;
+    }
+  }
+
+  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/TreeEvent.js

@@ -0,0 +1,6 @@
+export default class TreeEvent extends Event {
+  constructor(type, options = {}) {
+    super(type, options);
+    this.options = options;
+  }
+}

package/src/runtime/WatchFilesMixin.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "../../index.ts";
+
+declare const WatchFilesMixin: Mixin<{}>;
+
+export default WatchFilesMixin;

package/src/runtime/WatchFilesMixin.js

@@ -0,0 +1,58 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import Watcher from "watcher";
+import TreeEvent from "./TreeEvent.js";
+
+// Map of paths to trees used by watcher
+const pathTreeMap = new Map();
+
+export default function WatchFilesMixin(Base) {
+  return class WatchFiles extends Base {
+    addEventListener(type, listener) {
+      super.addEventListener(type, listener);
+      if (type === "change") {
+        this.watch();
+      }
+    }
+
+    onChange(key) {
+      // Reset cached values.
+      this.subfoldersMap = new Map();
+      this.dispatchEvent(new TreeEvent("change", { key }));
+    }
+
+    async unwatch() {
+      if (!this.watching) {
+        return;
+      }
+
+      this.watcher?.close();
+      this.watching = false;
+    }
+
+    // Turn on watching for the directory.
+    async watch() {
+      if (this.watching) {
+        return;
+      }
+      this.watching = true;
+
+      // Ensure the directory exists.
+      await fs.mkdir(this.dirname, { recursive: true });
+
+      this.watcher = new Watcher(this.dirname, {
+        ignoreInitial: true,
+        persistent: false,
+      });
+      this.watcher.on("all", (event, filePath) => {
+        const key = path.basename(filePath);
+        this.onChange(key);
+      });
+
+      // Add to the list of FileTree instances watching this directory.
+      const treeRefs = pathTreeMap.get(this.dirname) ?? [];
+      treeRefs.push(new WeakRef(this));
+      pathTreeMap.set(this.dirname, treeRefs);
+    }
+  };
+}

package/src/runtime/concatTreeValues.js

@@ -0,0 +1,46 @@
+import { Tree, getRealmObjectPrototype } from "@weborigami/async-tree";
+
+/**
+ * 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);
+  }
+
+  // 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) {
+    // Treat falsy values as the empty string.
+    text = "";
+  } else if (typeof value === "string") {
+    text = 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;
+}