@weborigami/origami 0.0.59 → 0.0.61

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/common/utilities.js

@@ -91,10 +91,9 @@ export function toFunction(obj) {
  */
 export function toString(object) {
   if (isPlainObject(object) && "@text" in object) {
-    return object["@text"];
-  } else {
-    return asyncTreeToString(object);
+    object = object["@text"];
   }
+  return asyncTreeToString(object);
 }
 
 /**

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)`
+    );
+  }
+}

package/src/misc/getTreeArgument.js

@@ -1,7 +1,6 @@
 import { Tree, isUnpackable } from "@weborigami/async-tree";
 import { isTreelike } from "@weborigami/async-tree/src/Tree.js";
-import { Scope } from "@weborigami/language";
-import assertScopeIsDefined from "./assertScopeIsDefined.js";
+import assertTreeIsDefined from "./assertTreeIsDefined.js";
 
 /**
  * Many Origami built-in functions accept an optional treelike object as their
@@ -15,19 +14,19 @@ import assertScopeIsDefined from "./assertScopeIsDefined.js";
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  *
- * @param {AsyncTree|null} scope
+ * @param {AsyncTree|null} parent
  * @param {IArguments} args
  * @param {Treelike|undefined} treelike
  * @param {string} methodName
  * @returns {Promise<AsyncTree>}
  */
 export default async function getTreeArgument(
-  scope,
+  parent,
   args,
   treelike,
   methodName
 ) {
-  assertScopeIsDefined(scope);
+  assertTreeIsDefined(parent, methodName);
 
   if (treelike !== undefined) {
     if (isUnpackable(treelike)) {
@@ -36,9 +35,9 @@ export default async function getTreeArgument(
     if (isTreelike(treelike)) {
       let tree = Tree.from(treelike);
       // If the tree was created from a treelike object and does not yet have a
-      // parent or scope, put it in the current scope.
-      if (!tree.parent && !(/** @type {any} */ (tree).scope)) {
-        tree = Scope.treeWithScope(tree, scope);
+      // parent, make the current tree its parent.
+      if (!tree.parent) {
+        tree.parent = parent;
       }
       return tree;
     }
@@ -48,13 +47,13 @@ export default async function getTreeArgument(
   }
 
   if (args.length === 0) {
-    if (!scope) {
-      // Should never happen because assertScopeIsDefined throws an exception.
+    if (!parent) {
+      // Should never happen because assertTreeIsDefined throws an exception.
       throw new Error(
-        `${methodName} was called with no tree argument and no scope.`
+        `${methodName} was called with no tree argument and no parent.`
       );
     }
-    return scope.get("@current");
+    return parent;
   }
 
   throw new Error(`${methodName}: The first argument was undefined.`);

package/src/misc/origamiHighlightDefinition.js

@@ -0,0 +1,36 @@
+/**
+ * Origami language definition for highlight.js
+ */
+export default function origamiHighlightDefinition(hljs) {
+  return {
+    name: "Origami",
+    contains: [
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      hljs.BACKSLASH_ESCAPE,
+      {
+        // Backtick template strings
+        className: "string",
+        begin: "`",
+        end: "`",
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          {
+            className: "subst",
+            begin: "\\$\\{",
+            end: "\\}",
+            contains: [hljs.C_NUMBER_MODE, hljs.QUOTE_STRING_MODE],
+          },
+        ],
+      },
+      {
+        // Treat all `@` builtins as keywords.
+        className: "keyword",
+        begin: /@\w+\b/,
+      },
+    ],
+  };
+}

package/src/server/server.js

@@ -1,5 +1,5 @@
 import { DeepObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
-import { Scope, formatError } from "@weborigami/language";
+import { formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
 
@@ -53,15 +53,8 @@ function extendTreeScopeWithParams(tree, url) {
   const paramTree = new DeepObjectTree({
     "@params": params,
   });
-
-  // Create a new scope that includes search parameter tree.
-  const scope = Scope.getScope(tree);
-  const extendedScope = new Scope(paramTree, scope);
-
-  // Create a new tree that extends the prototype chain of the supplied tree.
-  const extendedTree = Scope.treeWithScope(tree, extendedScope);
-
-  return extendedTree;
+  paramTree.parent = tree;
+  return paramTree;
 }
 
 /**

package/src/builtins/@arrowsMap.js

@@ -1,25 +0,0 @@
-import { Scope, functionResultsMap } from "@weborigami/language";
-import arrowsMapFn from "../common/arrowsMapFn.js";
-import { keySymbol } from "../common/utilities.js";
-import getTreeArgument from "../misc/getTreeArgument.js";
-import builtins from "./@builtins.js";
-
-/**
- * Interpret arrow keys in the tree as function calls.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
- */
-export default async function arrowsMap(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "arrowsMap");
-  const mapped = functionResultsMap(arrowsMapFn()(tree));
-  const scope = this ?? builtins;
-  const scoped = Scope.treeWithScope(mapped, scope);
-  scoped[keySymbol] = "@arrowsMap";
-  return scoped;
-}
-
-arrowsMap.usage = `@arrowsMap <obj>\tInterpret arrow keys in the tree as function calls`;
-arrowsMap.documentation = "https://weborigami.org/language/@arrowsMap.html";

package/src/builtins/@scope/extend.js

@@ -1,22 +0,0 @@
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-import scopeSet from "./set.js";
-
-/**
- * Return a copy of the given tree whose scope includes the given trees *and*
- * the current scope.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param  {...Treelike} scopeTrees
- * @this {AsyncTree|null}
- */
-export default function scopeExtend(treelike, ...scopeTrees) {
-  assertScopeIsDefined(this, "scopeExtend");
-  const scope = this;
-  return scopeSet.call(scope, treelike, ...scopeTrees, scope);
-}
-
-scopeExtend.usage = `@scope/extend <tree>, <...trees>\tExtends tree's scope with the given trees`;
-scopeExtend.documentation = "https://weborigami.org/cli/builtins.html#@scope";

package/src/builtins/@scope/get.js

@@ -1,25 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * Returns the scope of the indicated tree or the current scope.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {any} [obj]
- */
-export default async function getScope(obj) {
-  assertScopeIsDefined(this, "getScope");
-  if (obj) {
-    /** @type {any}  */
-    const tree = Tree.from(obj);
-    return Scope.getScope(tree);
-  } else {
-    return this;
-  }
-}
-
-getScope.usage = `@scope/get [<tree>]\tReturns the scope of the tree or the current scope`;
-getScope.documentation = "https://weborigami.org/cli/builtins.html#@scope";

package/src/builtins/@scope/invoke.js

@@ -1,22 +0,0 @@
-import { Scope } from "@weborigami/language";
-import { toFunction } from "../../common/utilities.js";
-
-/**
- * Invokes the given function in the context of the current scope.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../../index.ts").Invocable} Invocable
- *
- * @this {AsyncTree|null}
- * @param {AsyncTree} context
- * @param {Invocable} invocable
- */
-export default async function invoke(context, invocable, ...args) {
-  const scope = Scope.getScope(context);
-  const fn = toFunction(invocable);
-  const result = await fn.call(scope, ...args);
-  return result;
-}
-
-invoke.usage = `@scope/invoke fn, <...args>\tInvoke the function in the current scope`;
-invoke.documentation = "https://weborigami.org/cli/builtins.html#@scope";

package/src/builtins/@scope/set.js

@@ -1,25 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import { keySymbol } from "../../common/utilities.js";
-import assertScopeIsDefined from "../../misc/assertScopeIsDefined.js";
-
-/**
- * Return a copy of the given tree that has the indicated trees as its scope.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @param {Treelike} treelike
- * @param  {...(Treelike|null)} scopeTrees
- * @this {AsyncTree|null}
- */
-export default function scopeSet(treelike, ...scopeTrees) {
-  assertScopeIsDefined(this, "scopeSet");
-  const tree = Tree.from(treelike);
-  const scope = scopeTrees.length === 0 ? this : new Scope(...scopeTrees);
-  const result = Scope.treeWithScope(tree, scope);
-  result[keySymbol] = tree[keySymbol];
-  return result;
-}
-
-scopeSet.usage = `@scope/set <tree>, <...trees>\tReturns a tree copy with the given scope`;
-scopeSet.documentation = "https://weborigami.org/cli/builtins.html#@scope";

package/src/common/addValueKeyToScope.js

@@ -1,23 +0,0 @@
-import { ObjectTree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-
-/**
- * A number of transforms accept functions that can accept a single value. This
- * helper adds the value and key to the scope as ambients.
- *
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.js").Invocable} Invocable
- *
- * @param {AsyncTree|null} scope
- * @param {any} value
- * @param {any} key
- */
-export default function addValueKeyToScope(scope, value, key) {
-  // Add the key and value to the scope as ambients.
-  const ambients = new ObjectTree({
-    "@key": key,
-    _: value,
-  });
-  return new Scope(ambients, scope);
-}

package/src/misc/assertScopeIsDefined.js

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