@weborigami/origami 0.0.58 → 0.0.60

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/common/serialize.d.ts

@@ -4,6 +4,4 @@ import type { JsonValue } from "../../index.ts";
 export function evaluateYaml(text: string, parent?: AsyncTree|null): Promise<JsonValue>;
 export function parseYaml(text: string): JsonValue|AsyncTree;
 export function toJson(obj: JsonValue | AsyncTree): Promise<string>;
-export function toJsonValue(obj: any): Promise<JsonValue>;
-export function toValue(obj: any, jsonValuesOnly?: boolean): Promise<JsonValue>;
 export function toYaml(obj: JsonValue | AsyncTree): Promise<string>;

package/src/common/serialize.js

@@ -5,12 +5,9 @@
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
-import { Tree, isStringLike } from "@weborigami/async-tree";
+import { Tree, toPlainValue } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 
-const textDecoder = new TextDecoder();
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-
 // The "yaml" package doesn't seem to provide a default export that the browser can
 // recognize, so we have to handle two ways to accommodate Node and the browser.
 // @ts-ignore
@@ -31,21 +28,6 @@ export async function evaluateYaml(text, parent) {
   }
 }
 
-/**
- * @param {any} obj
- * @returns {obj is JsonValue}
- */
-function isJsonValue(obj) {
-  const t = typeof obj;
-  return (
-    t === "boolean" ||
-    t === "number" ||
-    t === "string" ||
-    obj instanceof Date ||
-    obj === null
-  );
-}
-
 /**
  * @param {string} text
  * @returns {JsonValue|AsyncTree}
@@ -60,79 +42,10 @@ export function parseYaml(text) {
  * @param {any} obj
  */
 export async function toJson(obj) {
-  const serializable = await toJsonValue(obj);
+  const serializable = await toPlainValue(obj);
   return JSON.stringify(serializable, null, 2);
 }
 
-/**
- * Convert the given object to a corresponding JSON value that can be
- * represented as JSON or YAML.
- *
- * @param {any} object
- * @returns {Promise<JsonValue>}
- */
-export async function toJsonValue(object) {
-  return toValue(object, true);
-}
-
-/**
- * Convert the given input to the plainest possible JavaScript value. This
- * helper is intended for functions that want to accept an argument from the ori
- * CLI, which could a string, a file buffer, an ArrayBuffer from a URL, or some
- * other kind of JavaScript object.
- *
- * If the input implements the `unpack()` method, the input will be unpacked and
- * before processing.
- *
- * If the input is treelike, it will be converted to a plain JavaScript object,
- * recursively traversing the tree and converting all values to plain types.
- *
- * If the input is stringlike, its text will be returned.
- *
- * If the input is a Buffer or ArrayBuffer, it will be interpreted as UTF-8
- * text.
- *
- * If the input has a custom class instance, its public properties will be
- * returned as a plain object.
- *
- * The `jsonValuesOnly` parameter can be set to `true` to ensure that the
- * returned value can be represented as JSON. If the input can't be represented
- * as JSON, an error is thrown.
- *
- * @param {any} input
- * @param {boolean} [jsonValuesOnly]
- * @returns {Promise<any>}
- */
-export async function toValue(input, jsonValuesOnly = false) {
-  if (input instanceof Promise) {
-    // Resolve promise before processing.
-    return toValue(await input, jsonValuesOnly);
-  } else if (isJsonValue(input)) {
-    return input;
-  } else if (typeof input !== "object") {
-    if (jsonValuesOnly) {
-      throw new TypeError(`Couldn't serialize value to JSON: ${input}`);
-    } else {
-      return input;
-    }
-  } else if (isStringLike(input) && !(input instanceof Array)) {
-    return String(input);
-  } else if (Tree.isTreelike(input)) {
-    const mapped = await Tree.map(input, (value) => toValue(value));
-    return Tree.plain(mapped);
-  } else if (input instanceof ArrayBuffer || input instanceof TypedArray) {
-    // Interpret input as UTF-8 text.
-    return textDecoder.decode(input);
-  } else {
-    // Some other kind of class instance; return its public properties.
-    const plain = {};
-    for (const [key, value] of Object.entries(input)) {
-      plain[key] = await toValue(value);
-    }
-    return plain;
-  }
-}
-
 /**
  * Serializes an object as a JSON string.
  *
@@ -140,6 +53,6 @@ export async function toValue(input, jsonValuesOnly = false) {
  * @returns {Promise<string>}
  */
 export async function toYaml(obj) {
-  const serializable = await toJsonValue(obj);
+  const serializable = await toPlainValue(obj);
   return YAML.stringify(serializable);
 }

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/server/constructResponse.js

@@ -62,7 +62,7 @@ export default async function constructResponse(request, resource) {
     !isStringLike(resource)
   ) {
     // The request is for a JSON or YAML result, and the resource we got isn't
-    // yet a string or Buffer: convert the resource to JSON or YAML now.
+    // yet a string: convert the resource to JSON or YAML now.
     const tree = Tree.from(resource);
     resource =
       mediaType === "text/yaml"
@@ -103,7 +103,7 @@ export default async function constructResponse(request, resource) {
   if (!validResponse) {
     const typeName = body?.constructor?.name ?? typeof body;
     console.error(
-      `A served tree must return a string or a TypedArray (such as a Buffer) but returned an instance of ${typeName}.`
+      `A served tree must return a string or a TypedArray but returned an instance of ${typeName}.`
     );
     return null;
   }
@@ -123,8 +123,8 @@ export default async function constructResponse(request, resource) {
  */
 function textOrObject(object) {
   if (object instanceof ArrayBuffer) {
-    // Convert to Buffer.
-    return Buffer.from(object);
+    // Convert to Uint8Array so we can write it to the Response.
+    return new Uint8Array(object);
   } else if (object instanceof TypedArray) {
     // Return typed arrays as is.
     return object;

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