@weborigami/language 0.5.5 → 0.5.7

package/src/project/coreGlobals.js

@@ -0,0 +1,17 @@
+import { Tree } from "@weborigami/async-tree";
+import protocolGlobals from "../protocols/protocolGlobals.js";
+import * as protocols from "../protocols/protocols.js";
+import builtins from "./builtins.js";
+import jsGlobals from "./jsGlobals.js";
+
+export default async function coreGlobals() {
+  const handlerGlobals = await import("../handlers/handlers.js");
+  return {
+    ...jsGlobals,
+    Tree,
+    Protocol: protocols,
+    ...protocolGlobals,
+    ...handlerGlobals,
+    ...builtins,
+  };
+}

package/src/{runtime → project}/jsGlobals.js

@@ -184,6 +184,7 @@ async function importWrapper(modulePath) {
   const filePath = path.resolve(current.path, modulePath);
   return import(filePath);
 }
+importWrapper.containerAsTarget = true;
 
 /**
  * Some JavaScript globals like Promise have static methods like Promise.all
@@ -219,10 +220,11 @@ function bindStaticMethods(obj) {
   }
 
   let extended;
-  // A regular object or an oddball like Proxy with no prototype
   if (typeof obj === "object" || !obj.prototype) {
+    // A regular object or an oddball like Proxy with no prototype
     extended = Object.create(obj);
   } else {
+    // A function, possibly a constructor called with or without `new`
     /** @this {any} */
     extended = function (...args) {
       const calledWithNew = this instanceof extended;

package/src/project/projectConfig.js

@@ -0,0 +1,36 @@
+import { FileTree, toString } from "@weborigami/async-tree";
+import ori_handler from "../handlers/ori_handler.js";
+import coreGlobals from "./coreGlobals.js";
+import projectRoot from "./projectRoot.js";
+
+const mapPathToConfig = new Map();
+
+export default async function config(dir = process.cwd()) {
+  const root = await projectRoot(dir);
+
+  const rootPath = root.path;
+  const cached = mapPathToConfig.get(rootPath);
+  if (cached) {
+    return cached;
+  }
+
+  // Use a plain FileTree to avoid loading extension handlers
+  const rootFileTree = new FileTree(rootPath);
+  const configBuffer = await rootFileTree.get("config.ori");
+  let configObject = {};
+  if (configBuffer) {
+    const configText = toString(configBuffer);
+    if (configText) {
+      // Config uses only core globals (we're defining the config)
+      const globals = await coreGlobals();
+      // Evaluate the config file to obtain the configuration object
+      configObject = await ori_handler.unpack(configText, {
+        globals,
+        parent: root,
+      });
+    }
+  }
+
+  mapPathToConfig.set(rootPath, configObject);
+  return configObject;
+}

package/src/project/projectGlobals.js

@@ -0,0 +1,19 @@
+import coreGlobals from "./coreGlobals.js";
+import projectConfig from "./projectConfig.js";
+
+let globals;
+
+// Core globals plus project config
+export default async function projectGlobals() {
+  if (!globals) {
+    // Start with core globals
+    globals = await coreGlobals();
+    // Now get config. The config.ori file may require access to globals,
+    // which will obtain the core globals set above. Once we've got the
+    // config, we add it to the globals.
+    const config = await projectConfig();
+    Object.assign(globals, config);
+  }
+
+  return globals;
+}

package/src/project/projectRoot.js

@@ -0,0 +1,59 @@
+import { FileTree } from "@weborigami/async-tree";
+import path from "node:path";
+import OrigamiFiles from "../runtime/OrigamiFiles.js";
+
+const configFileName = "config.ori";
+const packageFileName = "package.json";
+
+const mapPathToRoot = new Map();
+
+/**
+ * Return an OrigamiFiles object for the current project.
+ *
+ * This searches the current directory and its ancestors for an Origami file
+ * called `config.ori`. If an Origami configuration file is found, the
+ * containing folder is considered to be the project root.
+ *
+ * Otherwise, this looks for a package.json file to determine the project root.
+ * If no package.json is found, the current folder is used as the project root.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} [dirname]
+ */
+export default async function projectRoot(dirname = process.cwd()) {
+  const cached = mapPathToRoot.get(dirname);
+  if (cached) {
+    return cached;
+  }
+
+  let root;
+  let value;
+  // Use a plain FileTree to avoid loading extension handlers
+  const currentTree = new FileTree(dirname);
+  // Try looking for config file
+  value = await currentTree.get(configFileName);
+  if (value) {
+    // Found config file
+    root = new OrigamiFiles(currentTree.path);
+  } else {
+    // Try looking for package.json
+    value = await currentTree.get(packageFileName);
+    if (value) {
+      // Found package.json
+      root = new OrigamiFiles(currentTree.path);
+    } else {
+      // Move up a folder and try again
+      const parentPath = path.dirname(dirname);
+      if (parentPath !== dirname) {
+        root = await projectRoot(parentPath);
+      } else {
+        // At filesystem root, use current working directory
+        root = new OrigamiFiles(process.cwd());
+      }
+    }
+  }
+
+  mapPathToRoot.set(dirname, root);
+  return root;
+}

package/src/protocols/constructHref.js

@@ -0,0 +1,20 @@
+import { pathFromKeys } from "@weborigami/async-tree";
+
+/**
+ * Given a protocol, a host, and a list of keys, construct an href.
+ *
+ * @param {string} protocol
+ * @param {string} host
+ * @param  {string[]} keys
+ */
+export default function constructHref(protocol, host, ...keys) {
+  const path = pathFromKeys(keys);
+  let href = [host, path].join("/");
+  if (!href.startsWith(protocol)) {
+    if (!href.startsWith("//")) {
+      href = `//${href}`;
+    }
+    href = `${protocol}${href}`;
+  }
+  return href;
+}

package/src/protocols/constructSiteTree.js

@@ -0,0 +1,26 @@
+import { trailingSlash } from "@weborigami/async-tree";
+import HandleExtensionsTransform from "../runtime/HandleExtensionsTransform.js";
+import constructHref from "./constructHref.js";
+
+/**
+ * Given a protocol, a host, and a list of keys, construct an href.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} protocol
+ * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
+ * @param {string} host
+ * @param  {string[]} keys
+ */
+export default function constructSiteTree(protocol, treeClass, host, ...keys) {
+  // If the last key doesn't end in a slash, remove it for now.
+  let lastKey;
+  if (keys.length > 0 && keys.at(-1) && !trailingSlash.has(keys.at(-1))) {
+    lastKey = keys.pop();
+  }
+
+  const href = constructHref(protocol, host, ...keys);
+  let result = new (HandleExtensionsTransform(treeClass))(href);
+
+  return lastKey ? result.get(lastKey) : result;
+}

package/src/protocols/explore.js

@@ -0,0 +1,14 @@
+import { ExplorableSiteTree } from "@weborigami/async-tree";
+import constructSiteTree from "./constructSiteTree.js";
+
+/**
+ * A site tree with JSON Keys via HTTPS.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function explore(host, ...keys) {
+  return constructSiteTree("https:", ExplorableSiteTree, host, ...keys);
+}

package/src/protocols/fetchAndHandleExtension.js

@@ -0,0 +1,25 @@
+import handleExtension from "../runtime/handleExtension.js";
+
+/**
+ * Fetch the resource at the given href.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} href
+ */
+export default async function fetchAndHandleExtension(href) {
+  const response = await fetch(href);
+  if (!response.ok) {
+    return undefined;
+  }
+  let buffer = await response.arrayBuffer();
+
+  // Attach any loader defined for the file type.
+  const url = new URL(href);
+  const filename = url.pathname.split("/").pop();
+  if (filename) {
+    buffer = await handleExtension(buffer, filename);
+  }
+
+  return buffer;
+}

package/src/protocols/files.js

@@ -0,0 +1,26 @@
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import OrigamiFiles from "../runtime/OrigamiFiles.js";
+
+/**
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string[]} keys
+ */
+export default async function files(...keys) {
+  // If path begins with `~`, treat it relative to the home directory.
+  // Otherwise, treat it relative to the current working directory.
+  let relativePath = keys.join(path.sep);
+  let basePath;
+  if (relativePath.startsWith("~")) {
+    basePath = os.homedir();
+    relativePath = relativePath.slice(2);
+  } else {
+    basePath = process.cwd();
+  }
+  const resolved = path.resolve(basePath, relativePath);
+
+  const result = new OrigamiFiles(resolved);
+  return result;
+}

package/src/protocols/http.js

@@ -0,0 +1,15 @@
+import constructHref from "./constructHref.js";
+import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
+
+/**
+ * Retrieve the indicated web resource via HTTP.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default async function http(host, ...keys) {
+  const href = constructHref("http:", host, ...keys);
+  return fetchAndHandleExtension(href);
+}

package/src/protocols/https.js

@@ -0,0 +1,15 @@
+import constructHref from "./constructHref.js";
+import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
+
+/**
+ * Retrieve the indicated web resource via HTTPS.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default async function https(host, ...keys) {
+  const href = constructHref("https:", host, ...keys);
+  return fetchAndHandleExtension(href);
+}

package/src/protocols/httpstree.js

@@ -0,0 +1,14 @@
+import { SiteTree } from "@weborigami/async-tree";
+import constructSiteTree from "./constructSiteTree.js";
+
+/**
+ * Return a website tree via HTTPS.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function httpstree(host, ...keys) {
+  return constructSiteTree("https:", SiteTree, host, ...keys);
+}

package/src/protocols/httptree.js

@@ -0,0 +1,14 @@
+import { SiteTree } from "@weborigami/async-tree";
+import constructSiteTree from "./constructSiteTree.js";
+
+/**
+ * Return a website tree via HTTP.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @param {string} host
+ * @param  {...string} keys
+ */
+export default function httptree(host, ...keys) {
+  return constructSiteTree("http:", SiteTree, host, ...keys);
+}

package/src/protocols/node.js

@@ -0,0 +1,13 @@
+import { trailingSlash, Tree } from "@weborigami/async-tree";
+
+/**
+ * The node: protocol does a dynamic import from the `node:` namespace.
+ *
+ * @param {string[]} keys
+ */
+export default async function node(...keys) {
+  const key = keys.shift();
+  const normalized = trailingSlash.remove(key);
+  const module = await import(`node:${normalized}`);
+  return keys.length > 0 ? Tree.traverse(module, ...keys) : module;
+}

package/src/protocols/package.js

@@ -0,0 +1,67 @@
+import { Tree, keysFromPath } from "@weborigami/async-tree";
+import projectRoot from "../project/projectRoot.js";
+
+/**
+ * @param {string[]} keys
+ */
+export default async function packageNamespace(...keys) {
+  const parent = await projectRoot();
+
+  let name = keys.shift();
+  let organization;
+  if (name?.startsWith("@")) {
+    // First key is an npm organization
+    organization = name;
+    if (keys.length === 0) {
+      // Return a function that will process the next key
+      return async (name, ...keys) =>
+        getPackage(parent, organization, name, keys);
+    }
+    name = keys.shift();
+  }
+
+  return getPackage(parent, organization, name, keys);
+}
+
+async function getPackage(parent, organization, name, keys) {
+  const packagePath = ["node_modules"];
+  if (organization) {
+    packagePath.push(organization);
+  }
+  packagePath.push(name);
+
+  const parentScope = await Tree.scope(parent);
+  const packageRoot = await Tree.traverse(
+    // @ts-ignore
+    parentScope,
+    ...packagePath
+  );
+
+  if (!packageRoot) {
+    throw new Error(`Can't find ${packagePath.join("/")}`);
+  }
+
+  const mainPath = await Tree.traverse(packageRoot, "package.json", "main");
+  if (!mainPath) {
+    throw new Error(
+      `node_modules/${keys.join(
+        "/"
+      )} doesn't contain a package.json with a "main" entry.`
+    );
+  }
+
+  const mainKeys = keysFromPath(mainPath);
+  const mainContainerKeys = mainKeys.slice(0, -1);
+  const mainFileName = mainKeys[mainKeys.length - 1];
+  const mainContainer = await Tree.traverse(packageRoot, ...mainContainerKeys);
+  const packageExports = await mainContainer.import(mainFileName);
+
+  let result =
+    "default" in packageExports ? packageExports.default : packageExports;
+
+  if (keys.length > 0) {
+    result = await Tree.traverse(result, ...keys);
+  }
+
+  return result;
+}

package/src/protocols/protocolGlobals.js

@@ -0,0 +1,12 @@
+import * as protocols from "./protocols.js";
+
+export default {
+  "explore:": protocols.explore,
+  "files:": protocols.files,
+  "http:": protocols.http,
+  "https:": protocols.https,
+  "httpstree:": protocols.httpstree,
+  "httptree:": protocols.httptree,
+  "node:": protocols.node,
+  "package:": protocols.package,
+};

package/src/protocols/protocols.js

@@ -0,0 +1,8 @@
+export { default as explore } from "./explore.js";
+export { default as files } from "./files.js";
+export { default as http } from "./http.js";
+export { default as https } from "./https.js";
+export { default as httpstree } from "./httpstree.js";
+export { default as httptree } from "./httptree.js";
+export { default as node } from "./node.js";
+export { default as package } from "./package.js";

package/src/runtime/EventTargetMixin.js

@@ -85,7 +85,7 @@ export default function EventTargetMixin(Base) {
         if (stopImmediatePropagation) {
           break;
         }
-        listener.call(this, event);
+        listener(event);
       }
 
       return !event.defaultPrevented;

package/src/runtime/HandleExtensionsTransform.js

@@ -1,5 +1,4 @@
-import getHandlers from "./getHandlers.js";
-import { handleExtension } from "./handlers.js";
+import handleExtension from "./handleExtension.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -9,18 +8,10 @@ import { handleExtension } from "./handlers.js";
  * @param {AsyncTreeConstructor} Base
  */
 export default function HandleExtensionsTransform(Base) {
-  return class FileLoaders extends Base {
-    constructor(...args) {
-      super(...args);
-
-      // Callers should set this to the set of supported extension handlers
-      this.handlers = null;
-    }
-
+  return class HandleExtensions extends Base {
     async get(key) {
       const value = await super.get(key);
-      const handlers = getHandlers(this);
-      return handleExtension(this, value, key, handlers);
+      return handleExtension(value, key, this);
     }
   };
 }

package/src/runtime/ImportModulesMixin.js

@@ -20,9 +20,9 @@ export default function ImportModulesMixin(Base) {
         fileUrl.href + `?cacheBust=${moduleCache.getTimestamp()}`;
 
       // Try to load the module.
-      let obj;
+      let object;
       try {
-        obj = await import(modulePath);
+        object = await import(modulePath);
       } catch (/** @type {any} */ error) {
         if (error.code !== "ERR_MODULE_NOT_FOUND") {
           throw error;
@@ -48,14 +48,8 @@ export default function ImportModulesMixin(Base) {
         throw new SyntaxError(message);
       }
 
-      if ("default" in obj) {
-        // Module with a default export; return that.
-        return obj.default;
-      } else {
-        // Module with multiple named exports. Cast from a module namespace
-        // object to a plain object.
-        return { ...obj };
-      }
+      // Cast from an exotic module namespace object to a plain object.
+      return { ...object };
     }
   };
 }

package/src/runtime/InvokeFunctionsTransform.js

@@ -13,7 +13,7 @@ export default function InvokeFunctionsTransform(Base) {
     async get(key) {
       let value = await super.get(key);
       if (typeof value === "function") {
-        value = await value.call(this);
+        value = await value();
 
         if (Tree.isAsyncTree(value) && !value.parent) {
           value.parent = this;

package/src/runtime/evaluate.js

@@ -1,18 +1,17 @@
 import { Tree, isUnpackable } from "@weborigami/async-tree";
-import { displayWarning, symbols } from "@weborigami/language";
 import codeFragment from "./codeFragment.js";
+import { displayWarning } from "./errors.js";
+import * as symbols from "./symbols.js";
 
 /**
  * Evaluate the given code and return the result.
  *
  * `this` should be the tree used as the context for the evaluation.
  *
- * @this {import("@weborigami/types").AsyncTree|null}
  * @param {import("../../index.ts").AnnotatedCode} code
+ * @param {import("../../index.ts").RuntimeState} [state]
  */
-export default async function evaluate(code) {
-  const tree = this;
-
+export default async function evaluate(code, state = {}) {
   if (!(code instanceof Array)) {
     // Simple scalar; return as is.
     return code;
@@ -25,7 +24,7 @@ export default async function evaluate(code) {
   } else {
     // Evaluate each instruction in the code.
     evaluated = await Promise.all(
-      code.map((instruction) => evaluate.call(tree, instruction))
+      code.map((instruction) => evaluate(instruction, state))
     );
   }
 
@@ -46,13 +45,21 @@ export default async function evaluate(code) {
     fn = await fn.unpack();
   }
 
+  if (fn.needsState) {
+    // The function is an op that wants the runtime state
+    args.push(state);
+  } else if (fn.containerAsTarget && state.container) {
+    // The function wants the code's container as the `this` target
+    fn = fn.bind(state.container);
+  }
+
   // Execute the function or traverse the tree.
   let result;
   try {
     result =
       fn instanceof Function
-        ? await fn.call(tree, ...args) // Invoke the function
-        : await Tree.traverseOrThrow.call(tree, fn, ...args); // Traverse the tree.
+        ? await fn(...args) // Invoke the function
+        : await Tree.traverseOrThrow(fn, ...args); // Traverse the tree.
   } catch (/** @type {any} */ error) {
     if (!error.location) {
       // Attach the location of the code we tried to evaluate.

package/src/runtime/expressionFunction.js

@@ -6,15 +6,13 @@ import { evaluate } from "./internal.js";
  * Given parsed Origami code, return a function that executes that code.
  *
  * @param {import("../../index.js").AnnotatedCode} code - parsed Origami expression
- * @param {string} [name] - optional name of the function
+ * @param {AsyncTree} parent - the parent tree in which the code is running
  */
-export function createExpressionFunction(code, name) {
-  /** @this {AsyncTree|null} */
+export function createExpressionFunction(code, parent) {
   async function fn() {
-    return evaluate.call(this, code);
-  }
-  if (name) {
-    Object.defineProperty(fn, "name", { value: name });
+    return evaluate(code, {
+      container: parent,
+    });
   }
   fn.code = code;
   fn.toString = () => code.location.source.text;

package/src/runtime/expressionObject.js

@@ -6,8 +6,7 @@ import {
   trailingSlash,
   Tree,
 } from "@weborigami/async-tree";
-import getHandlers from "./getHandlers.js";
-import { handleExtension } from "./handlers.js";
+import handleExtension from "./handleExtension.js";
 import { evaluate, ops } from "./internal.js";
 
 /**
@@ -25,11 +24,12 @@ import { evaluate, ops } from "./internal.js";
  *    property getter on the object.
  *
  * @param {*} entries
- * @param {import("@weborigami/types").AsyncTree | null} parent
+ * @param {import("../../index.ts").RuntimeState} [state]
  */
-export default async function expressionObject(entries, parent) {
+export default async function expressionObject(entries, state = {}) {
   // Create the object and set its parent
   const object = {};
+  const parent = state?.object ?? null;
   if (parent !== null && !Tree.isAsyncTree(parent)) {
     throw new TypeError(`Parent must be an AsyncTree or null`);
   }
@@ -86,22 +86,12 @@ export default async function expressionObject(entries, parent) {
         code = value;
       }
 
-      let get;
-      if (extname) {
-        // Key has extension, getter will invoke code then attach unpack method
-        get = async () => {
-          tree ??= new ObjectTree(object);
-          const result = await evaluate.call(tree, code);
-          const handlers = getHandlers(tree);
-          return handleExtension(tree, result, key, handlers);
-        };
-      } else {
-        // No extension, so getter just invokes code.
-        get = async () => {
-          tree ??= new ObjectTree(object);
-          return evaluate.call(tree, code);
-        };
-      }
+      const get = async () => {
+        tree ??= new ObjectTree(object);
+        const newState = Object.assign({}, state, { object: tree });
+        const result = await evaluate(code, newState);
+        return extname ? handleExtension(result, key, tree) : result;
+      };
 
       Object.defineProperty(object, key, {
         configurable: true,

package/src/runtime/functionResultsMap.js

@@ -10,9 +10,7 @@ export default async function functionResultsMap(treelike) {
 
     value: async (sourceValue, sourceKey, tree) => {
       const resultValue =
-        typeof sourceValue === "function"
-          ? await sourceValue.call(tree)
-          : sourceValue;
+        typeof sourceValue === "function" ? await sourceValue() : sourceValue;
       return resultValue;
     },
   });