@weborigami/origami 0.3.3 → 0.3.4-jse.4

package/src/handlers/ts.handler.js

@@ -1 +1 @@
-export { default as default } from "./js.handler.js";
+export { jsHandler as default } from "./handlers.js";

package/src/handlers/txt.handler.js

@@ -39,7 +39,8 @@ export default {
       throw new TypeError("The input to pack must be a JavaScript object.");
     }
 
-    const text = object["@text"] ?? "";
+    // TODO: Deprecate @text
+    const text = object._body ?? object["@text"] ?? "";
 
     /** @type {any} */
     const dataWithoutText = Object.assign({}, object);
@@ -72,7 +73,14 @@ export default {
       } else {
         frontData = parseYaml(frontText);
       }
+      // TODO: Deprecate @text
       unpacked = Object.assign({}, frontData, { "@text": body });
+      Object.defineProperty(unpacked, "_body", {
+        configurable: true,
+        value: body,
+        enumerable: false, // TODO: Make enumerable
+        writable: true,
+      });
     } else {
       // Plain text
       unpacked = new String(text);

package/src/handlers/wasm.handler.js

@@ -1,4 +1,4 @@
-import { processUnpackedContent } from "../internal.js";
+import processUnpackedContent from "./processUnpackedContent.js";
 
 /**
  * A WebAssembly module

package/src/handlers/yaml.handler.js

@@ -2,7 +2,7 @@ import { symbols } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 import { parseYaml } from "../common/serialize.js";
 import * as utilities from "../common/utilities.js";
-import { processUnpackedContent } from "../internal.js";
+import processUnpackedContent from "./processUnpackedContent.js";
 
 // See notes at serialize.js
 // @ts-ignore

package/src/handlers/yml.handler.js

@@ -1,2 +1,2 @@
 // .yml is a synonym for .yaml
-export { yamlHandler as default } from "../internal.js";
+export { default } from "./yaml.handler.js";

package/src/help/help.yaml

@@ -135,17 +135,7 @@ new:
   description: Create instances of JavaScript classes
 
 node:
-  description: Node.js classes and modules
-  collection: true
-  commands:
-    Buffer:
-      description: Node.js Buffer class
-    path:
-      description: Node.js path module
-    process:
-      description: Node.js process object
-    url:
-      description: Node.js URL module
+  description: Node.js modules
 
 origami:
   description: Perform general Origami language functions

package/src/origami/config.js

@@ -13,8 +13,6 @@ import project from "./project.js";
  */
 export default async function config(key) {
   const projectTree = await project.call(this);
-  // HACK: We use specific knowledge of how @project returns a tree to get the
-  // config. The config is always the parent of the project folder.
-  const parent = projectTree.parent;
-  return key === undefined ? parent : parent.get(key);
+  const projectConfig = projectTree.config;
+  return key === undefined ? projectConfig : projectConfig[key];
 }

package/src/origami/ori.js

@@ -4,7 +4,8 @@ import {
   toString,
 } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
-import builtinsTree from "../builtinsTree.js";
+import builtinsShell from "../builtinsShell.js";
+import getConfig from "../cli/getConfig.js";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import { toYaml } from "../common/serialize.js";
 
@@ -28,13 +29,25 @@ export default async function ori(
   // In case expression has come from a file, cast it to a string.
   expression = toString(expression);
 
-  // Run in the context of `this` if defined, otherwise use the builtins.
-  const tree = this ?? builtinsTree;
+  // Run in the context of `this` if defined
+  const tree = this;
+
+  const config = getConfig(tree);
+  const globals = config
+    ? {
+        ...builtinsShell(),
+        ...config,
+      }
+    : builtinsShell();
 
   // Compile the expression. Avoid caching scope references so that, e.g.,
   // passing a function to the `watch` builtin will always look the current
   // value of things in scope.
-  const fn = compile.expression(expression, { scopeCaching: false });
+  const fn = compile.expression(expression, {
+    globals,
+    mode: "shell",
+    scopeCaching: false,
+  });
 
   // Execute
   let result = await fn.call(tree);

package/src/origami/origami.js

@@ -1,8 +1,3 @@
-// Use a dynamic import to avoid circular dependencies
-export const builtins = import("../internal.js").then(
-  (internal) => internal.builtinsTree
-);
-
 export { extension } from "@weborigami/async-tree";
 export { toFunction } from "../common/utilities.js";
 

package/src/origami/project.js

@@ -1,13 +1,16 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { Tree } from "@weborigami/async-tree";
 import { OrigamiFiles } from "@weborigami/language";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import { builtinsTree, oriHandler } from "../internal.js";
+import handlerBuiltins from "../handlers/handlerBuiltins.js";
+import { oriHandler } from "../handlers/handlers.js";
 
 const configFileName = "config.ori";
 
 /**
- * Return the tree for the current project's root folder.
+ * Return an object for the current project including
+ *
+ * `config`: the evaluated config.ori file
+ * `root`: the project's root folder
  *
  * This searches the current directory and its ancestors for an Origami file
  * called `config.ori`. If an Origami configuration file is found, the
@@ -19,81 +22,88 @@ const configFileName = "config.ori";
  * returned as a tree, with the builtins as its parent.
  *
  * @this {AsyncTree|null}
- * @param {any} [key]
  */
-export default async function project(key) {
+export default async function project() {
   assertTreeIsDefined(this, "origami:project");
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
-  currentTree.parent = builtinsTree;
+  let config;
 
   // Search up the tree for the configuration file or package.json to determine
   // the project root.
-  const configContainer =
-    (await findAncestorFile(currentTree, configFileName)) ??
-    (await findAncestorFile(currentTree, "package.json"));
-
-  let projectRoot;
-  if (!configContainer) {
-    // No configuration file or package.json found; use the current directory.
-    projectRoot = currentTree;
+  let root;
+  const foundConfig = await findAncestorFile(currentTree, configFileName);
+  if (foundConfig) {
+    root = foundConfig.container;
+    // Unpack Origami configuration file
+    const buffer = foundConfig.value;
+    config = await oriHandler.unpack(buffer, {
+      key: configFileName,
+      parent: root,
+    });
+    root.config = config;
   } else {
-    // Load the configuration file if one exists.
-    const buffer = await configContainer.get(configFileName);
-    if (!buffer) {
-      // Project root defined by package.json
-      projectRoot = configContainer;
+    // No Origami configuration file, look for package.json
+    const foundPackageJson = await findAncestorFile(
+      currentTree,
+      "package.json"
+    );
+    if (foundPackageJson) {
+      // Found package.json; use its parent as the project root
+      root = foundPackageJson.container;
     } else {
-      // Load Origami configuration file
-      const config = await oriHandler.unpack(buffer, {
-        key: configFileName,
-        parent: configContainer,
-      });
-      if (!config) {
-        const configPath = /** @type {any} */ (configContainer).path;
-        throw new Error(
-          `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
-        );
-      }
-
-      // The config tree may refer to the container tree *and vice versa*. To
-      // support this, we put the container in the tree twice. The chain will
-      // be: projectRoot -> configTree -> configContainer -> builtins, where
-      // the projectRoot and configContainer are the same folder.
-      const configTree = Tree.from(config);
-      projectRoot = new OrigamiFiles(configContainer.path);
-      projectRoot.parent = configTree;
-      configTree.parent = configContainer;
-      configContainer.parent = builtinsTree;
+      // No package.json found; use the current directory as root
+      root = currentTree;
     }
   }
 
-  return key === undefined ? projectRoot : projectRoot.get(key);
+  // Merge config if present into handlers
+  root.handlers = config
+    ? {
+        ...handlerBuiltins(),
+        ...configHandlers(config),
+      }
+    : handlerBuiltins();
+
+  return root;
 }
 
-// Return the first ancestor of the given tree that contains a file with the
-// given name.
+// Find the first ancestor of the given folder that contains a file with the
+// given name. Return the container and the file contents.
 async function findAncestorFile(start, fileName) {
-  let current = start;
-  while (current) {
-    const value = await current.get(fileName);
+  let container = start;
+  while (container) {
+    const value = await container.get(fileName);
     if (value) {
-      // 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 = builtinsTree;
-      return current;
+      // Found the desired file
+      return {
+        container,
+        value,
+      };
     }
-    // Not found; try the parent.
-    const parent = await current.get("..");
+    // Not found; try the parent
+    const parent = await container.get("..");
     if (
       !parent ||
-      (parent.path && current.path && parent.path === current.path)
+      (parent.path && container.path && parent.path === container.path)
     ) {
       break;
     }
-    current = parent;
+    container = parent;
+  }
+
+  // Not found
+  return null;
+}
+
+// Return an object with all `.handler` keys from the config
+function configHandlers(config) {
+  const handlers = {};
+  for (const key in config) {
+    if (key.endsWith(".handler")) {
+      handlers[key] = config[key];
+    }
   }
-  return undefined;
+  return handlers;
 }

package/src/origami/regexMatch.js

@@ -1,6 +1,10 @@
 const parsers = {};
 
+// TODO: Remove this deprecated function
 export default function regexMatch(text, regex) {
+  console.warn(
+    "warning: regexMatch is deprecated, use a JavaScript regular expression instead."
+  );
   if (!parsers[regex]) {
     const regexp = new RegExp(regex);
     parsers[regex] = (input) => input.match(regexp)?.groups;

package/src/protocols/files.js

@@ -1,4 +1,4 @@
-import { OrigamiFiles } from "@weborigami/language";
+import { OrigamiFiles, getHandlers } from "@weborigami/language";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -26,5 +26,6 @@ export default async function files(...keys) {
   const resolved = path.resolve(basePath, relativePath);
 
   const result = new OrigamiFiles(resolved);
+  result.handlers = getHandlers(this);
   return result;
 }

package/src/protocols/inherited.js

@@ -1,5 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
-import { ops } from "@weborigami/language";
+import { scope, Tree } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
@@ -13,6 +12,10 @@ import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 export default async function inherited(...keys) {
   assertTreeIsDefined(this, "inherited:");
   const key = keys.shift();
-  const value = await ops.inherited.call(this, key);
+  if (!this?.parent) {
+    return undefined;
+  }
+  const parentScope = scope(this.parent);
+  const value = await parentScope.get(key);
   return keys.length > 0 ? await Tree.traverse(value, ...keys) : value;
 }

package/src/protocols/new.js

@@ -13,12 +13,16 @@ import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 export default async function instantiate(...keys) {
   assertTreeIsDefined(this, "new:");
   let constructor;
+
   const scope = this ? scopeFn(this) : null;
   if (
     keys.length === 1 &&
     (typeof keys[0] === "object" || typeof keys[0] === "function")
   ) {
     constructor = keys[0];
+  } else if (globalThis[keys[0]]) {
+    // Backward compat
+    constructor = globalThis[keys[0]];
   } else if (scope) {
     constructor = await Tree.traverseOrThrow(scope, ...keys);
   } else {

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/scope.js

@@ -1,5 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
-import { ops } from "@weborigami/language";
+import { Tree, scope as scopeFn } from "@weborigami/async-tree";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -12,7 +11,8 @@ export default async function scope(...keys) {
   let value;
   try {
     // Look up key in scope but don't throw if it's undefined
-    value = await ops.scope.call(this, key);
+    const thisScope = scopeFn(this);
+    value = await thisScope.get(key);
   } catch (error) {
     if (error instanceof ReferenceError) {
       value = undefined;

package/src/site/{index.js → indexPage.js}

@@ -10,7 +10,7 @@ import { getDescriptor } from "../common/utilities.js";
  * @param {Treelike} [treelike]
  * @param {string} [basePath]
  */
-export default async function index(treelike, basePath) {
+export default async function indexPage(treelike, basePath) {
   const tree = await getTreeArgument(this, arguments, treelike, "site:index");
   const keys = Array.from(await tree.keys());
 

package/src/site/site.js

@@ -1,4 +1,4 @@
-export { default as index } from "./index.js";
+export { default as indexPage } from "./indexPage.js";
 export { default as jsonKeys } from "./jsonKeys.js";
 export { default as redirect } from "./redirect.js";
 export { default as rss } from "./rss.js";

package/src/site/sitemap.js

@@ -1,11 +1,11 @@
 import { Tree } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import getTreeArgument from "../common/getTreeArgument.js";
-import { builtinsTree, oriHandler } from "../internal.js";
+import { oriHandler } from "../handlers/handlers.js";
 
 const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-\${ map(urls, (url) => \`  <url>
+\${ Tree.map(urls, (url) => \`  <url>
     <loc>\${ url }</loc>
   </url>
 \`) }</urlset>
@@ -48,7 +48,6 @@ export default async function sitemap(treelike, baseHref = "") {
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
   const templateFn = await oriHandler.unpack(templateText);
-  const target = this ?? builtinsTree;
-  const templateResult = await templateFn.call(target, htmlPaths);
+  const templateResult = await templateFn.call(this, htmlPaths);
   return String(templateResult);
 }

package/src/site/static.js

@@ -1,7 +1,7 @@
 import { Tree, jsonKeys } from "@weborigami/async-tree";
 import getTreeArgument from "../common/getTreeArgument.js";
 import { transformObject } from "../common/utilities.js";
-import index from "./index.js";
+import index from "./indexPage.js";
 
 /**
  * Expose common static keys (index.html, .keys.json) for a tree.

package/src/text/inline.js

@@ -1,12 +1,7 @@
-import {
-  isUnpackable,
-  ObjectTree,
-  symbols,
-  toString,
-} from "@weborigami/async-tree";
+import { isUnpackable, symbols, toString } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import documentObject from "../common/documentObject.js";
-import { oridocumentHandler } from "../internal.js";
+import { jsedocumentHandler } from "../handlers/handlers.js";
 
 /**
  * Inline any Origami expressions found inside ${...} placeholders in the input
@@ -25,8 +20,11 @@ export default async function inline(input) {
   if (isUnpackable(input)) {
     input = await input.unpack();
   }
-  const inputIsDocument = input["@text"] !== undefined;
-  const origami = inputIsDocument ? input["@text"] : toString(input);
+  const inputIsDocument =
+    input["@text"] !== undefined || input._body !== undefined;
+  const origami = inputIsDocument
+    ? input["@text"] ?? input._body
+    : toString(input);
   if (origami === null) {
     return undefined;
   }
@@ -36,15 +34,22 @@ export default async function inline(input) {
     /** @type {any} */ (input)[symbols.parent] ??
     this;
 
-  let extendedParent = parent;
+  let front;
   if (inputIsDocument) {
-    extendedParent = new ObjectTree(input);
-    extendedParent.parent = parent;
+    // Collect all document properties except the body
+    front = Object.fromEntries(
+      Object.entries(input).filter(
+        ([key]) => key !== "@text" && key !== "_body"
+      )
+    );
+  } else {
+    front = null;
   }
 
   // @ts-ignore
-  let result = await oridocumentHandler.unpack(input, {
-    parent: extendedParent,
+  let result = await jsedocumentHandler.unpack(origami, {
+    front,
+    parent,
   });
 
   if (result instanceof Function) {

package/src/text/mdHtml.js

@@ -47,7 +47,8 @@ export default async function mdHtml(input) {
   if (isUnpackable(input)) {
     input = await input.unpack();
   }
-  const inputIsDocument = input["@text"] !== undefined;
+  const inputIsDocument =
+    input["@text"] !== undefined || input._body !== undefined;
   const markdown = toString(input);
   if (markdown === null) {
     throw new Error("mdHtml: The provided input couldn't be treated as text.");

package/src/tree/map.js

@@ -69,7 +69,7 @@ function extendedOptions(context, operation) {
     options = {};
   } else {
     throw new TypeError(
-      `map: You must specify a value function or options dictionary as the first parameter.`
+      `map: You must specify a value function or options dictionary as the second parameter.`
     );
   }
 

package/src/builtins.js

@@ -1,58 +0,0 @@
-import * as calc from "./calc/calc.js";
-import * as dev from "./dev/dev.js";
-import * as handlers from "./handlers/handlers.js";
-import help from "./help/help.js";
-import * as image from "./image/image.js";
-import js from "./js.js";
-import node from "./node.js";
-import * as origami from "./origami/origami.js";
-import explore from "./protocols/explore.js";
-import files from "./protocols/files.js";
-import http from "./protocols/http.js";
-import https from "./protocols/https.js";
-import httpstree from "./protocols/httpstree.js";
-import httptree from "./protocols/httptree.js";
-import inherited from "./protocols/inherited.js";
-import instantiate from "./protocols/new.js";
-import packageNamespace from "./protocols/package.js";
-import scope from "./protocols/scope.js";
-import * as site from "./site/site.js";
-import * as text from "./text/text.js";
-import * as tree from "./tree/tree.js";
-
-/** @type {any} */
-export default {
-  "calc:": adjustReservedWords(calc),
-  "dev:": dev,
-  "explore:": explore,
-  "files:": files,
-  "help:": help,
-  "http:": http,
-  "https:": https,
-  "httpstree:": httpstree,
-  "httptree:": httptree,
-  "image:": image,
-  "inherited:": inherited,
-  "js:": js,
-  "new:": instantiate,
-  "node:": node,
-  "origami:": origami,
-  "package:": packageNamespace,
-  "scope:": scope,
-  "site:": adjustReservedWords(site),
-  "text:": text,
-  "tree:": tree,
-
-  // Some builtins need to be exposed at top level
-  ...handlers.default,
-};
-
-// Handle cases where a builtin name conflicts with a JS reserved word
-function adjustReservedWords(obj) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const name = value.key ?? key;
-    result[name] = value;
-  }
-  return result;
-}

package/src/builtinsTree.js

@@ -1,36 +0,0 @@
-import { trailingSlash } from "@weborigami/async-tree";
-import builtins from "./builtins.js";
-
-const expanded = { ...builtins };
-
-// For all builtins like `tree:keys`, add a shorthand `keys`.
-for (const [key, value] of Object.entries(expanded)) {
-  const isNamespace = key.endsWith(":");
-  if (isNamespace) {
-    for (const [subKey, subValue] of Object.entries(value)) {
-      // HACK: Skip description keys until we can make them all non-enumerable.
-      if (subKey === "description") {
-        continue;
-      }
-      if (subKey in expanded) {
-        throw new Error(`Internal Origami error: Duplicate key: ${subKey}`);
-      }
-      expanded[subKey] = subValue;
-    }
-  }
-}
-
-// We create our own tree instead of using ObjectTree, since that binds the
-// functions would be bound to the object. We want to leave them unbound.
-class BuiltinsTree {
-  async get(key) {
-    const normalizedKey = trailingSlash.remove(key);
-    return expanded[normalizedKey];
-  }
-
-  async keys() {
-    return Object.keys(expanded);
-  }
-}
-
-export default new BuiltinsTree();