@weborigami/origami 0.5.4 → 0.5.6

package/src/origami/ori.js

@@ -1,13 +1,13 @@
 import {
   Tree,
   getRealmObjectPrototype,
+  isStringlike,
   toString,
 } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
-import builtinsShell from "../builtinsShell.js";
-import getConfig from "../cli/getConfig.js";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+import projectGlobals from "@weborigami/language/src/project/projectGlobals.js";
 import { toYaml } from "../common/serialize.js";
+import * as dev from "../dev/dev.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 
@@ -17,50 +17,47 @@ const TypedArray = Object.getPrototypeOf(Uint8Array);
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @this {AsyncTree|null}
  * @param {string} expression
  */
-export default async function ori(
-  expression,
-  options = { formatResult: true }
-) {
-  assertTreeIsDefined(this, "ori");
+export default async function ori(expression, options = {}) {
+  const parent = options.parent ?? null;
+  const formatResult = options.formatResult ?? true;
 
   // In case expression has come from a file, cast it to a string.
+  if (!isStringlike(expression)) {
+    throw new TypeError("ori: The expression is not text.");
+  }
+  // @ts-ignore
   expression = toString(expression);
 
-  // Run in the context of `this` if defined
-  const tree = this;
-
-  const config = getConfig(tree);
-  const globals = config
-    ? {
-        ...builtinsShell(),
-        ...config,
-      }
-    : builtinsShell();
+  // Add Dev builtins as top-level globals
+  const globals = {
+    ...(await projectGlobals()),
+    ...dev,
+  };
 
   // 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, {
     globals,
-    mode: "shell",
     enableCaching: false,
+    mode: "shell",
+    parent,
   });
 
   // Execute
-  let result = await fn.call(tree);
+  let result = await fn();
 
   // If result was a function, execute it.
   if (typeof result === "function") {
-    result = await result.call(tree);
+    result = await result();
   }
 
-  return options.formatResult ? await formatResult(result) : result;
+  return formatResult ? await format(result) : result;
 }
 
-async function formatResult(result) {
+async function format(result) {
   if (
     typeof result === "string" ||
     result instanceof ArrayBuffer ||

package/src/origami/origami.js

@@ -1,8 +1,7 @@
 export { extension } from "@weborigami/async-tree";
-export { toFunction } from "../common/utilities.js";
 export { default as help } from "../dev/help.js"; // Alias
 export { default as document } from "../origami/document.js";
-export { default as htmlDom } from "../origami/htmlDom.js";
+// export { default as htmlDom } from "../origami/htmlDom.js";
 export { default as indexPage } from "../origami/indexPage.js";
 export { default as inline } from "../origami/inline.js";
 export { default as jsonKeys } from "../origami/jsonKeys.js";
@@ -13,7 +12,6 @@ export { default as sitemap } from "../origami/sitemap.js";
 export { default as slug } from "../origami/slug.js";
 export { default as static } from "../origami/static.js";
 export { default as basename } from "./basename.js";
-export { default as config } from "./config.js";
 export { default as csv } from "./csv.js";
 export { default as fetch } from "./fetch.js";
 export { default as format } from "./image/format.js";
@@ -27,7 +25,6 @@ export { default as once } from "./once.js";
 export { default as ori } from "./ori.js";
 export { default as pack } from "./pack.js";
 export { default as post } from "./post.js";
-export { default as project } from "./project.js";
 export { default as repeat } from "./repeat.js";
 export { default as shell } from "./shell.js";
 export { default as slash } from "./slash.js";

package/src/origami/pack.js

@@ -1,13 +1,8 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
- * @this {AsyncTree|null}
  * @param {any} obj
- * @returns
  */
 export default function pack(obj) {
-  assertTreeIsDefined(this, "pack");
   return obj?.pack?.();
 }

package/src/origami/post.js

@@ -1,5 +1,5 @@
 import {
-  isStringLike,
+  isStringlike,
   isUnpackable,
   toPlainValue,
   toString,
@@ -7,7 +7,8 @@ import {
 } from "@weborigami/async-tree";
 
 /**
- * @this {import("@weborigami/types").AsyncTree|null}
+ * POST data to the indicated URL.
+ *
  * @param {string} url
  * @param {any} data
  */
@@ -23,7 +24,7 @@ export default async function post(url, data) {
     headers = {
       "Content-Type": "application/json",
     };
-  } else if (isStringLike(data)) {
+  } else if (isStringlike(data)) {
     body = toString(data);
     headers = {
       "Content-Type": "text/plain",

package/src/origami/rss.js

@@ -1,16 +1,15 @@
-import { Tree } from "@weborigami/async-tree";
+import { getTreeArgument, Tree } from "@weborigami/async-tree";
 import jsonFeedToRss from "@weborigami/json-feed-to-rss";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} jsonFeedTree
+ *
+ * @param {Treelike} jsonFeed
  * @param {any} options
  */
-export default async function rss(jsonFeedTree, options = {}) {
-  assertTreeIsDefined(this, "rss");
-  const jsonFeed = await Tree.plain(jsonFeedTree);
-  return jsonFeedToRss(jsonFeed, options);
+export default async function rss(jsonFeed, options = {}) {
+  const tree = await getTreeArgument(jsonFeed, "rss");
+  const jsonFeedPlain = await Tree.plain(tree);
+  return jsonFeedToRss(jsonFeedPlain, options);
 }

package/src/origami/sitemap.js

@@ -1,7 +1,5 @@
-import { Tree } from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import getTreeArgument from "../common/getTreeArgument.js";
-import { oriHandler } from "../handlers/handlers.js";
+import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { ori_handler } from "@weborigami/language/src/handlers/handlers.js";
 
 const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
@@ -15,13 +13,13 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
+ *
  * @param {Treelike} treelike
  * @param {{ assumeSlashes?: boolean, base?: string }} options
+ * @returns {Promise<string>}
  */
 export default async function sitemap(treelike, options = {}) {
-  assertTreeIsDefined(this, "sitemap");
-  const tree = await getTreeArgument(this, arguments, treelike, "sitemap");
+  const tree = await getTreeArgument(treelike, "sitemap");
 
   // We're only interested in keys that end in .html or with no extension.
   function test(key) {
@@ -47,7 +45,7 @@ export default async function sitemap(treelike, options = {}) {
     .filter((path) => path.endsWith(".html"))
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
-  const templateFn = await oriHandler.unpack(templateText);
-  const templateResult = await templateFn.call(this, htmlPaths);
+  const templateFn = await ori_handler.unpack(templateText);
+  const templateResult = await templateFn(htmlPaths);
   return String(templateResult);
 }

package/src/origami/static.js

@@ -1,20 +1,18 @@
-import { Tree, jsonKeys } from "@weborigami/async-tree";
-import getTreeArgument from "../common/getTreeArgument.js";
-import index from "./indexPage.js";
+import { Tree, getTreeArgument, jsonKeys } from "@weborigami/async-tree";
+import indexPage from "./indexPage.js";
 
 /**
  * Expose common static keys (index.html, .keys.json) for a tree.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
+ *
  * @param {Treelike} treelike
+ * @returns {Promise<AsyncTree>}
  */
 export default async function staticBuiltin(treelike) {
-  const tree = await getTreeArgument(this, arguments, treelike, "static");
-  const result = staticTree(tree);
-  result.parent = this;
-  return result;
+  const tree = await getTreeArgument(treelike, "static");
+  return staticTree(tree);
 }
 
 // The name we'll register as a builtin
@@ -25,7 +23,7 @@ function staticTree(tree) {
     async get(key) {
       let value = await tree.get(key);
       if (value === undefined && key === "index.html") {
-        value = await index.call(this, this);
+        value = await indexPage(this);
       } else if (value === undefined && key === ".keys.json") {
         value = await jsonKeys.stringify(this);
       } else if (Tree.isTreelike(value)) {

package/src/origami/string.js

@@ -1,14 +1 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import { toString } from "../common/utilities.js";
-
-/**
- * Convert an object to a string.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @this {AsyncTree|null}
- * @param {any} object
- */
-export default function stringBuiltin(object) {
-  assertTreeIsDefined(this, "string");
-  return toString(object);
-}
+export { toString as default } from "@weborigami/async-tree";

package/src/origami/unpack.js

@@ -1,14 +1,9 @@
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
 /**
  * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
  * text or a plain JavaScript object.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @this {AsyncTree|null}
  * @param {any} obj
  */
 export default function unpack(obj) {
-  assertTreeIsDefined(this, "unpack");
   return obj?.unpack?.() ?? obj;
 }

package/src/origami/yaml.js

@@ -1,23 +1,19 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
  * Render the object as text in YAML format.
  *
- * @this {AsyncTree|null}
  * @param {any} [obj]
  */
-export default async function toYaml(obj) {
-  assertTreeIsDefined(this, "yaml");
+export default async function yamlBuiltin(obj) {
   // 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 ?? this;
   if (obj === undefined) {
     return undefined;
   }

package/src/origami/yamlParse.js

@@ -1,5 +1,5 @@
+import { toString } from "@weborigami/async-tree";
 import * as serialize from "../common/serialize.js";
-import { toString } from "../common/utilities.js";
 
 export default async function yamlParse(input) {
   const text = toString(input);

package/src/server/constructResponse.js

@@ -2,12 +2,12 @@ import {
   extension,
   isPacked,
   isPlainObject,
-  isStringLike,
+  isStringlike,
   SiteTree,
+  toString,
   Tree,
 } from "@weborigami/async-tree";
 import * as serialize from "../common/serialize.js";
-import { toString } from "../common/utilities.js";
 import { mediaTypeForExtension } from "./mediaTypes.js";
 
 /**
@@ -63,7 +63,7 @@ export default async function constructResponse(request, resource) {
 
   if (
     (mediaType === "application/json" || mediaType === "text/yaml") &&
-    !isStringLike(resource)
+    !isStringlike(resource)
   ) {
     // The request is for a JSON or YAML result, and the resource we got isn't
     // yet a string: convert the resource to JSON or YAML now.

package/src/server/server.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
+import { Tree, keysFromPath } from "@weborigami/async-tree";
 import { formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
@@ -39,32 +39,6 @@ async function copyResponse(constructed, response) {
   return true;
 }
 
-// Extend the tree's scope with the URL's search parameters.
-function extendTreeScopeWithParams(tree, url) {
-  // Create a tree that includes the URL's search parameters.
-  const params = {};
-  for (const [key, value] of url.searchParams) {
-    params[key] = value;
-  }
-
-  if (Object.keys(params).length === 0) {
-    // No search parameters, so return the tree as is.
-    return tree;
-  }
-
-  const paramTree = new ObjectTree({
-    "@params": params,
-  });
-
-  // Create a new tree that's like the original one, but has the parameters in
-  // its parent hierarchy.
-  const extendedTree = Object.create(tree);
-  const realParent = tree.parent;
-  paramTree.parent = realParent;
-  extendedTree.parent = paramTree;
-  return extendedTree;
-}
-
 /**
  * Handle a client request.
  *
@@ -77,17 +51,12 @@ export async function handleRequest(request, response, tree) {
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
   const keys = keysFromUrl(url);
 
-  const extendedTree =
-    url.searchParams && "parent" in tree
-      ? extendTreeScopeWithParams(tree, url)
-      : tree;
-
   const data = request.method === "POST" ? await parsePostData(request) : null;
 
   // Ask the tree for the resource with those keys.
   let resource;
   try {
-    resource = await Tree.traverseOrThrow(extendedTree, ...keys);
+    resource = await Tree.traverseOrThrow(tree, ...keys);
 
     // If resource is a function, invoke to get the object we want to return.
     // For a POST request, pass the data to the function.
@@ -112,35 +81,15 @@ export async function handleRequest(request, response, tree) {
 }
 
 function keysFromUrl(url) {
-  // Split on occurrences of `/!`, which represent Origami debug commands.
-  // Command arguments can contain slashes; don't treat those as path keys.
-  const parts = url.pathname.split(/\/!/);
-
-  // Split everything before the first command by slashes and decode those.
-  let path = parts.shift();
-  if (parts.length > 0) {
-    // HACK: Add back trailing slash that was removed by split
-    path += "/";
-  }
-  const pathKeys = keysFromPath(path).map((key) => decodeURIComponent(key));
-  if (parts.length > 0 && pathKeys.at(-1) === "") {
-    // HACK part 2: Remove empty string that was added for trailing slash
-    pathKeys.pop();
-  }
+  const encodedKeys = keysFromPath(url.pathname);
+  const keys = encodedKeys.map((key) => decodeURIComponent(key));
 
-  // If there are no commands, and the path ends with a trailing slash, the
-  // final key will be an empty string. Change that to "index.html".
-  if (parts.length === 0 && pathKeys[pathKeys.length - 1] === "") {
-    pathKeys[pathKeys.length - 1] = "index.html";
+  // If the path ends with a trailing slash, the final key will be an empty
+  // string. Change that to "index.html".
+  if (keys.at(-1) === "") {
+    keys[keys.length - 1] = "index.html";
   }
 
-  // Decode the text of the commands, prefix spaces with a backslash, and add
-  // back the `!` character.
-  const commandKeys = parts.map(
-    (command) => `!${decodeURIComponent(command).replace(/ /g, "\\ ")}`
-  );
-
-  const keys = [...pathKeys, ...commandKeys];
   return keys;
 }
 

package/src/builtinsProgram.js

@@ -1,65 +0,0 @@
-import { deepText, indent, json, text } from "@weborigami/async-tree";
-import { jsGlobals } from "@weborigami/language";
-import * as dev from "./dev/dev.js";
-import help from "./dev/help.js";
-import handlerBuiltins from "./handlers/handlerBuiltins.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 node from "./protocols/node.js";
-import packageNamespace from "./protocols/package.js";
-import * as tree from "./tree/tree.js";
-
-let builtins;
-
-export default function builtinsProgram() {
-  if (!builtins) {
-    const Tree = {
-      ...tree,
-      deepText,
-      indent,
-      json,
-      text,
-    };
-
-    const Protocol = {
-      explore,
-      files,
-      http,
-      https,
-      httpstree,
-      httptree,
-      node,
-      package: packageNamespace,
-    };
-
-    /** @type {any} */
-    builtins = {
-      ...jsGlobals,
-
-      "explore:": explore,
-      "files:": files,
-      "help:": help,
-      "http:": http,
-      "https:": https,
-      "httpstree:": httpstree,
-      "httptree:": httptree,
-      "node:": node,
-      "package:": packageNamespace,
-
-      Dev: dev,
-      Tree,
-      Origami: origami,
-      Protocol,
-
-      // Handlers need to be exposed at top level
-      ...handlerBuiltins(),
-    };
-  }
-
-  return builtins;
-}

package/src/builtinsShell.js

@@ -1,18 +0,0 @@
-import builtinsProgram from "./builtinsProgram.js";
-import * as dev from "./dev/dev.js";
-
-let builtins;
-
-export default function builtinsShell() {
-  if (!builtins) {
-    builtins = {
-      // All program builtins
-      ...builtinsProgram(),
-
-      // Dev builtins exposed at the top level in shell
-      ...dev,
-    };
-  }
-
-  return builtins;
-}

package/src/cli/getConfig.js

@@ -1,11 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-// Return the config for the given tree
-export default function getConfig(tree) {
-  if (!tree) {
-    return null;
-  }
-  /** @type {any} */
-  const root = Tree.root(tree);
-  return root.config;
-}

package/src/common/ConstantTree.js

@@ -1,18 +0,0 @@
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @implements {AsyncTree}
- */
-export default class ConstantTree {
-  constructor(value) {
-    this.value = value;
-    this.parent = null;
-  }
-
-  async get(key) {
-    return this.value;
-  }
-
-  async keys() {
-    return [];
-  }
-}

package/src/common/constructHref.js

@@ -1,20 +0,0 @@
-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/common/constructSiteTree.js

@@ -1,34 +0,0 @@
-import { trailingSlash } from "@weborigami/async-tree";
-import { HandleExtensionsTransform } from "@weborigami/language";
-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 {AsyncTree|null} parent
- * @param {string} host
- * @param  {string[]} keys
- */
-export default function constructSiteTree(
-  protocol,
-  treeClass,
-  parent,
-  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);
-  result.parent = parent;
-
-  return lastKey ? result.get(lastKey) : result;
-}

package/src/common/fetchAndHandleExtension.js

@@ -1,27 +0,0 @@
-import { getHandlers, handleExtension } from "@weborigami/language";
-
-/**
- * Fetch the resource at the given href.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- *
- * @this {AsyncTree|null}
- * @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 (this && filename) {
-    const handlers = getHandlers(this);
-    buffer = await handleExtension(this, buffer, filename, handlers);
-  }
-
-  return buffer;
-}

package/src/handlers/css.handler.js

@@ -1,7 +0,0 @@
-// .css files use the .txt loader
-import { txtHandler } from "./handlers.js";
-
-export default {
-  ...txtHandler,
-  mediaType: "text/css",
-};