@weborigami/origami 0.0.59 → 0.0.60

package/src/builtins/@project.js

@@ -1,6 +1,7 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { OrigamiFiles, Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import { merge } from "@weborigami/async-tree";
+import { OrigamiFiles } from "@weborigami/language";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import builtins from "./@builtins.js";
 import fileTypeOrigami from "./ori_handler.js";
 
@@ -22,43 +23,48 @@ const configFileName = "config.ori";
  * @param {any} [key]
  */
 export default async function project(key) {
-  assertScopeIsDefined(this, "project");
+  assertTreeIsDefined(this, "project");
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
+  currentTree.parent = builtins;
 
   // Search up the tree for the configuration file or package.json to determine
   // the project root.
-  let rootTree =
+  const configContainer =
     (await findAncestorFile(currentTree, configFileName)) ??
     (await findAncestorFile(currentTree, "package.json"));
 
-  let config = null;
-  if (rootTree) {
-    // Load the configuration.
-    const configParent = Scope.treeWithScope(rootTree, builtins);
-    const buffer = await configParent.get(configFileName);
-    if (buffer) {
-      // Project has configuration file
-      config = await fileTypeOrigami.unpack(buffer, {
+  let projectRoot;
+  if (!configContainer) {
+    // No configuration file or package.json found; use the current directory.
+    projectRoot = currentTree;
+  } else {
+    // Load the configuration file if one exists.
+    const buffer = await configContainer.get(configFileName);
+    if (!buffer) {
+      // Project root defined by package.json
+      projectRoot = configContainer;
+    } else {
+      // Load Origami configuration file
+      const configTree = await fileTypeOrigami.unpack(buffer, {
         key: configFileName,
-        parent: configParent,
+        parent: configContainer,
       });
-      if (!config) {
-        const configPath = /** @type {any} */ (configParent).path;
+      if (!configTree) {
+        const configPath = /** @type {any} */ (configContainer).path;
         throw new Error(
           `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
         );
       }
+      projectRoot = merge(configTree, configContainer);
+      // HACK so cli.js can get a path
+      /** @type {any} */ (projectRoot).path = configContainer.path;
+      projectRoot.parent = builtins;
     }
-  } else {
-    rootTree = currentTree;
   }
 
-  // Add the configuration as the context for the project root.
-  const scope = new Scope(config, builtins);
-  const result = Scope.treeWithScope(rootTree, scope);
-  return key === undefined ? result : result.get(key);
+  return key === undefined ? projectRoot : projectRoot.get(key);
 }
 
 // Return the first ancestor of the given tree that contains a file with the
@@ -68,7 +74,10 @@ async function findAncestorFile(start, fileName) {
   while (current) {
     const value = await current.get(fileName);
     if (value) {
-      // Found the desired file; its container is the project root.
+      // Found the desired file; its container is the project root. Set the
+      // parent to the builtins; in the context of this project, there's nothing
+      // higher up.
+      current.parent = builtins;
       return current;
     }
     // Not found; try the parent.

package/src/builtins/@reverse.js

@@ -1,5 +1,4 @@
 import { reverse } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
@@ -13,8 +12,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  */
 export default async function reverseBuiltin(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@reverse");
-  let reversed = reverse(tree);
-  reversed = Scope.treeWithScope(reversed, this);
+  const reversed = reverse(tree);
   return reversed;
 }
 

package/src/builtins/@rss.js

@@ -1,5 +1,5 @@
 import { Tree } from "@weborigami/async-tree";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -8,7 +8,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {Treelike} jsonFeedTree
  */
 export default async function rss(jsonFeedTree) {
-  assertScopeIsDefined(this, "rss");
+  assertTreeIsDefined(this, "rss");
   const jsonFeed = await Tree.plain(jsonFeedTree);
   const { description, home_page_url, items, feed_url, title } = jsonFeed;
 

package/src/builtins/@serve.js

@@ -4,7 +4,7 @@ import { createServer } from "node:net";
 import process from "node:process";
 import ExplorableSiteTransform from "../common/ExplorableSiteTransform.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import { requestListener } from "../server/server.js";
 import debug from "./@debug.js";
 import watch from "./@watch.js";
@@ -22,7 +22,7 @@ const defaultPort = 5000;
  * @this {AsyncTree|null}
  */
 export default async function serve(treelike, port) {
-  assertScopeIsDefined(this, "serve");
+  assertTreeIsDefined(this, "serve");
   let tree;
   if (treelike) {
     tree = Tree.from(treelike);

package/src/builtins/@sitemap.js

@@ -1,3 +1,4 @@
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 import builtins from "./@builtins.js";
 import paths from "./@paths.js";
@@ -22,6 +23,7 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
  * @param {string} [baseHref ]
  */
 export default async function sitemap(treelike, baseHref = "") {
+  assertTreeIsDefined(this, "sitemap");
   const tree = await getTreeArgument(this, arguments, treelike, "@sitemap");
 
   // We're only interested in keys that end in .html or with no extension.
@@ -49,7 +51,8 @@ export default async function sitemap(treelike, baseHref = "") {
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
   const templateFn = await fileTypeOrigami.unpack(templateText);
-  const templateResult = await templateFn.call(builtins, htmlPaths);
+  const target = this ?? builtins;
+  const templateResult = await templateFn.call(target, htmlPaths);
   return String(templateResult);
 }
 

package/src/builtins/@sortFn.js

@@ -1,7 +1,6 @@
 import { sortFn } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import { toFunction } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Return a transform function that sorts a tree's keys using a comparison
@@ -23,8 +22,8 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {ValueKeyFn|SortOptions} [options]
  */
 export default function sortFnBuiltin(options) {
-  assertScopeIsDefined(this);
-  const scope = this;
+  assertTreeIsDefined(this, "sortFn");
+  const parent = this;
 
   if (typeof options === "function") {
     // Take the function as the `sortKey` option
@@ -37,7 +36,7 @@ export default function sortFnBuiltin(options) {
     const originalSortKey = toFunction(options?.sortKey);
     extendedSortKeyFn = async (key, tree) => {
       const value = await tree.get(key);
-      const sortKey = await originalSortKey.call(scope, value, key);
+      const sortKey = await originalSortKey.call(parent, value, key);
       return sortKey;
     };
   }
@@ -49,8 +48,8 @@ export default function sortFnBuiltin(options) {
 
   return (treelike) => {
     const sorted = fn(treelike);
-    const scoped = Scope.treeWithScope(sorted, scope);
-    return scoped;
+    sorted.parent = parent;
+    return sorted;
   };
 }
 

package/src/builtins/@string.js

@@ -1,5 +1,5 @@
 import { toString } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Convert an object to a string.
@@ -9,6 +9,6 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} object
  */
 export default function stringBuiltin(object) {
-  assertScopeIsDefined(this, "string");
+  assertTreeIsDefined(this, "string");
   return toString(object);
 }

package/src/builtins/@takeFn.js

@@ -1,6 +1,5 @@
 import { takeFn } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Limit the number of keys to the indicated count.
@@ -11,11 +10,11 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {number} count
  */
 export default function takeFnBuiltin(count) {
-  assertScopeIsDefined(this, "takeFn");
-  const scope = this;
+  assertTreeIsDefined(this, "takeFn");
+  const parent = this;
   return (treelike) => {
     const taken = takeFn(count)(treelike);
-    const scoped = Scope.treeWithScope(taken, scope);
-    return scoped;
+    taken.parent = parent;
+    return taken;
   };
 }

package/src/builtins/@treeHttp.js

@@ -1,5 +1,5 @@
 import { ops } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -11,7 +11,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param  {...string|Symbol} keys
  */
 export default function treeHttp(host, ...keys) {
-  assertScopeIsDefined(this, "treeHttp");
+  assertTreeIsDefined(this, "treeHttp");
   return ops.treeHttp.call(this, host, ...keys);
 }
 

package/src/builtins/@treeHttps.js

@@ -1,5 +1,5 @@
 import { ops } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -11,7 +11,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param  {...string|Symbol} keys
  */
 export default function treeHttps(host, ...keys) {
-  assertScopeIsDefined(this, "treeHttps");
+  assertTreeIsDefined(this, "treeHttps");
   return ops.treeHttps.call(this, host, ...keys);
 }
 

package/src/builtins/@unpack.js

@@ -1,4 +1,4 @@
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
@@ -9,6 +9,6 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} obj
  */
 export default function unpack(obj) {
-  assertScopeIsDefined(this, "unpack");
+  assertTreeIsDefined(this, "unpack");
   return obj?.unpack?.();
 }

package/src/builtins/@watch.js

@@ -1,5 +1,4 @@
 import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import ConstantTree from "../common/ConstantTree.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
@@ -21,16 +20,12 @@ export default async function watch(treelike, fn) {
   // Watch the indicated tree.
   await /** @type {any} */ (container).watch?.();
 
-  // // Watch trees in scope.
-  // const scope = /** @type {any} */ (container).scope;
-  // await scope?.watch?.();
-
   if (fn === undefined) {
     return container;
   }
 
   // The caller supplied a function to reevaluate whenever the tree changes.
-  let tree = await evaluateTree(container.scope, fn);
+  let tree = await evaluateTree(container, fn);
 
   // We want to return a stable reference to the tree, so we'll use a prototype
   // chain that will always point to the latest tree. We'll extend the tree's
@@ -40,19 +35,19 @@ export default async function watch(treelike, fn) {
 
   // Reevaluate the function whenever the tree changes.
   container.addEventListener?.("change", async () => {
-    const tree = await evaluateTree(container.scope, fn);
+    const tree = await evaluateTree(container, fn);
     updateIndirectPointer(handle, tree);
   });
 
   return handle;
 }
 
-async function evaluateTree(scope, fn) {
+async function evaluateTree(container, fn) {
   let tree;
   let message;
   let result;
   try {
-    result = await fn.call(scope);
+    result = await fn.call(container);
   } catch (error) {
     message = messageForError(error);
   }
@@ -65,9 +60,7 @@ async function evaluateTree(scope, fn) {
   }
   console.warn(message);
   tree = new ConstantTree(message);
-  if (scope) {
-    tree = Scope.treeWithScope(tree, scope);
-  }
+  tree.parent = container;
   return tree;
 }
 

package/src/builtins/@yaml.js

@@ -1,7 +1,7 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Render the object as text in YAML format.
@@ -10,14 +10,14 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} [obj]
  */
 export default async function toYaml(obj) {
-  assertScopeIsDefined(this, "yaml");
+  assertTreeIsDefined(this, "yaml");
   // A fragment of the logic from getTreeArgument.js
   if (arguments.length > 0 && obj === undefined) {
     throw new Error(
       "An Origami function was called with an initial argument, but its value is undefined."
     );
   }
-  obj = obj ?? (await this?.get("@current"));
+  obj = obj ?? this;
   if (obj === undefined) {
     return undefined;
   }

package/src/builtins/ori_handler.js

@@ -1,5 +1,5 @@
 import { symbols } from "@weborigami/async-tree";
-import { Scope, compile } from "@weborigami/language";
+import { compile } from "@weborigami/language";
 import processUnpackedContent from "../common/processUnpackedContent.js";
 import * as utilities from "../common/utilities.js";
 import builtins from "./@builtins.js";
@@ -40,8 +40,8 @@ export default {
     // Compile the source code as an Origami expression and evaluate it.
     const compiler = options.compiler ?? compile.expression;
     const fn = compiler(source);
-    const parentScope = parent ? Scope.getScope(parent) : builtins;
-    let content = await fn.call(parentScope);
+    const target = parent ?? builtins;
+    let content = await fn.call(target);
 
     return processUnpackedContent(content, parent, attachedData);
   },

package/src/builtins/~.js

@@ -1,9 +1,9 @@
-import { OrigamiFiles, Scope } from "@weborigami/language";
+import { OrigamiFiles } from "@weborigami/language";
 import os from "node:os";
 import builtins from "./@builtins.js";
 
 /** @type {import("@weborigami/types").AsyncTree} */
-let tree = new OrigamiFiles(os.homedir());
-tree = Scope.treeWithScope(tree, builtins);
+const tree = new OrigamiFiles(os.homedir());
+tree.parent = builtins;
 
 export default tree;

package/src/cli/cli.js

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 
-import { ObjectTree, Tree } from "@weborigami/async-tree";
-import { Scope, formatError } from "@weborigami/language";
+import { Tree } from "@weborigami/async-tree";
+import { formatError } from "@weborigami/language";
 import path from "node:path";
 import process, { stdout } from "node:process";
 import ori from "../builtins/@ori.js";
 import project from "../builtins/@project.js";
-import { keySymbol } from "../common/utilities.js";
 import showUsage from "./showUsage.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);
@@ -17,32 +16,20 @@ async function main(...args) {
   // Find the project root.
   const projectTree = await project.call(null);
 
-  // HACK: get the configuration via the project.
-  const config = new Scope(...projectTree.scope.trees.slice(1));
-
   // If no arguments were passed, show usage.
   if (!expression) {
+    // HACK: the config is the parent of the project tree.
+    const config = projectTree.parent;
     await showUsage(config);
     return;
   }
 
-  // Splice ambients tree into project tree scope.
-  const ambients = new ObjectTree({});
-  ambients[keySymbol] = "Origami CLI";
-  let tree = Scope.treeWithScope(projectTree, new Scope(ambients, config));
-
   // Traverse from the project root to the current directory.
   const currentDirectory = process.cwd();
   const relative = path.relative(projectTree.path, currentDirectory);
-  if (relative !== "") {
-    tree = await Tree.traversePath(tree, relative);
-  }
-
-  // Add ambient property for the current tree.
-  await ambients.set("@current", tree);
+  const tree = await Tree.traversePath(projectTree, relative);
 
-  const scope = Scope.getScope(tree);
-  const result = await ori.call(scope, expression);
+  const result = await ori.call(tree, expression);
   if (result !== undefined) {
     const output =
       result instanceof ArrayBuffer

package/src/common/ConstantTree.js

@@ -5,6 +5,7 @@
 export default class ConstantTree {
   constructor(value) {
     this.value = value;
+    this.parent = null;
   }
 
   async get(key) {

package/src/common/ExplorableSiteTransform.js

@@ -1,5 +1,4 @@
 import { Tree, keysJson } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import index from "../builtins/@index.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
 
@@ -33,16 +32,14 @@ export default function ExplorableSiteTransform(Base) {
 
       // Ask the tree if it has the key.
       let value = await super.get(key);
-      const scope = Scope.getScope(this);
 
       if (value === undefined) {
         // The tree doesn't have the key; try the defaults.
-        if (scope) {
-          if (key === "index.html") {
-            value = await index.call(scope, this);
-          } else if (key === ".keys.json") {
-            value = await keysJson.stringify(this);
-          }
+        if (key === "index.html") {
+          // This tree is both the function call target and the parameter.
+          value = await index.call(this, this);
+        } else if (key === ".keys.json") {
+          value = await keysJson.stringify(this);
         }
       }
 
@@ -55,12 +52,13 @@ export default function ExplorableSiteTransform(Base) {
 
         if (key.endsWith?.("/")) {
           // Instead of return the tree directly, return an index for it.
-          value = await index.call(scope, value);
+          value = await index.call(this, value);
         }
       } else if (value?.unpack) {
         // If the value isn't a tree, but has a tree attached via an `unpack`
         // method, wrap the unpack method to add this transform.
         const original = value.unpack.bind(value);
+        const parent = this;
         value.unpack = async () => {
           const content = await original();
           if (!Tree.isTraversable(content)) {
@@ -68,9 +66,8 @@ export default function ExplorableSiteTransform(Base) {
           }
           /** @type {any} */
           let tree = Tree.from(content);
-          if (!tree.parent && !tree.scope) {
-            const scope = Scope.getScope(this);
-            tree = Scope.treeWithScope(tree, scope);
+          if (!tree.parent) {
+            tree.parent = parent;
           }
           if (!isTransformApplied(ExplorableSiteTransform, tree)) {
             tree = transformObject(ExplorableSiteTransform, tree);

package/src/common/documentObject.js

@@ -1,4 +1,4 @@
-import { isPlainObject, isUnpackable } from "@weborigami/async-tree";
+import { isPlainObject, isUnpackable, toString } from "@weborigami/async-tree";
 // import txtHandler from "../builtins/txt_handler.js";
 
 /**
@@ -25,7 +25,7 @@ export default async function documentObject(input, data) {
     text = input["@text"];
     inputData = input;
   } else {
-    text = String(input);
+    text = toString(input);
     inputData = null;
   }
   // TODO: Either restore this code, or move responsibility for packing a

package/src/common/processUnpackedContent.js

@@ -1,5 +1,4 @@
 import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import builtins from "../builtins/@builtins.js";
 
 /**
@@ -15,23 +14,18 @@ import builtins from "../builtins/@builtins.js";
  */
 export default function processUnpackedContent(content, parent, attachedData) {
   if (typeof content === "function") {
-    // Wrap the function such to add ambients to the scope.
-    const fn = content;
-
-    // Use the parent's scope, adding any attached data.
-    const parentScope = parent ? Scope.getScope(parent) : builtins;
-
-    // If there's attached data, include it in the scope.
-    const extendedScope = attachedData
-      ? new Scope(attachedData, parentScope)
-      : parentScope;
-
-    const boundFn = fn.bind(extendedScope);
-    return boundFn;
-  } else if (
-    Tree.isAsyncTree(content) &&
-    !(/** @type {any} */ (content).scope)
-  ) {
+    // Bind the function to a target that's the attached data (if it exists) or
+    // the parent.
+    const base = parent ?? builtins;
+    let target;
+    if (attachedData) {
+      target = Tree.from(attachedData);
+      target.parent = base;
+    } else {
+      target = base;
+    }
+    return content.bind(target);
+  } else if (Tree.isAsyncTree(content) && !content.parent) {
     const result = Object.create(content);
     result.parent = parent;
     return result;

package/src/misc/OriCommandTransform.js

@@ -1,8 +1,5 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { ObjectTree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import ori from "../builtins/@ori.js";
-import { keySymbol } from "../common/utilities.js";
 
 /**
  * Add support for commands prefixed with `!`.
@@ -27,13 +24,8 @@ export default function OriCommandTransform(Base) {
           return undefined;
         }
         // Key is an Origami command; invoke it.
-        const ambientsTree = new ObjectTree({
-          "@current": this,
-        });
-        ambientsTree[keySymbol] = "ori command";
-        const extendedScope = new Scope(ambientsTree, Scope.getScope(this));
         const source = key.slice(1).trim();
-        value = await ori.call(extendedScope, source, { formatResult: false });
+        value = await ori.call(this, source, { formatResult: false });
       }
 
       return value;

package/src/misc/assertTreeIsDefined.d.ts

@@ -0,0 +1 @@
+export default function assertTreeIsDefined(tree: any, methodName: string): asserts tree is object

package/src/misc/assertTreeIsDefined.js

@@ -0,0 +1,7 @@
+export default function assertTreeIsDefined(tree, methodName) {
+  if (tree === undefined) {
+    throw new Error(
+      `${methodName} must be called with a tree target. If you don't want to pass a tree, invoke with: ${methodName}.call(null)`
+    );
+  }
+}