@weborigami/origami 0.5.5 → 0.5.6

package/main.js

@@ -1,29 +1,5 @@
 export { default as documentObject } from "./src/common/documentObject.js";
-export { toString } from "./src/common/utilities.js";
-export { default as handlerBuiltins } from "./src/handlers/handlerBuiltins.js";
-export * from "./src/handlers/handlers.js";
-export * from "./src/origami/origami.js";
+export * as Dev from "./src/dev/dev.js";
+export * as Origami from "./src/origami/origami.js";
 export { default as origamiHighlightDefinition } from "./src/origami/origamiHighlightDefinition.js";
-export { default as package } from "./src/protocols/package.js";
 export * from "./src/server/server.js";
-
-// Export only those dev exports that aren't tree exports
-export {
-  audit,
-  breakpoint,
-  changes,
-  code,
-  copy,
-  crawl,
-  debug,
-  explore,
-  help,
-  indexPage,
-  log,
-  serve,
-  stdin,
-  svg,
-  version,
-  watch,
-  yaml,
-} from "./src/dev/dev.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,12 +17,11 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.5",
+    "@weborigami/async-tree": "0.5.6",
     "@weborigami/json-feed-to-rss": "1.0.0",
-    "@weborigami/language": "0.5.5",
-    "@weborigami/types": "0.5.5",
+    "@weborigami/language": "0.5.6",
+    "@weborigami/types": "0.5.6",
     "css-tree": "3.1.0",
-    "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.1",
     "jsdom": "26.1.0",

package/src/cli/cli.js

@@ -1,26 +1,28 @@
 #!/usr/bin/env node
 
 import { Tree } from "@weborigami/async-tree";
-import { formatError } from "@weborigami/language";
+import { formatError, projectRoot } from "@weborigami/language";
 import path from "node:path";
 import process, { stdout } from "node:process";
 import help from "../dev/help.js";
+import initializeBuiltins from "../initializeBuiltins.js";
 import ori from "../origami/ori.js";
-import project from "../origami/project.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 
 async function main(...args) {
   const expression = args.join(" ");
 
+  // Need to initialize builtins before calling projectRoot, which instantiates
+  // an OrigamiFiles object that handles extensions, which requires builtins.
+  initializeBuiltins();
+
   // Find the project root.
-  const projectTree = await project.call(null);
+  const projectTree = await projectRoot();
 
   // If no arguments were passed, show usage.
   if (!expression) {
-    // HACK: the config is the parent of the project tree.
-    const config = projectTree.parent;
-    const usage = await help.call(config);
+    const usage = await help();
     console.log(usage);
     return;
   }
@@ -28,9 +30,9 @@ async function main(...args) {
   // Traverse from the project root to the current directory.
   const currentDirectory = process.cwd();
   const relative = path.relative(projectTree.path, currentDirectory);
-  const tree = await Tree.traversePath(projectTree, relative);
+  const parent = await Tree.traversePath(projectTree, relative);
 
-  const result = await ori.call(tree, expression);
+  const result = await ori(expression, { parent });
 
   if (result !== undefined) {
     const output =

package/src/common/documentObject.js

@@ -30,7 +30,7 @@ export default async function documentObject(input, data) {
   // document to HandleExtensionsTransform set().
   // const base = {
   //   pack() {
-  //     return txtHandler.pack(this);
+  //     return txt_handler.pack(this);
   //   },
   // };
   // const result = Object.create(base);

package/src/common/utilities.d.ts

@@ -2,5 +2,4 @@
 export function getDescriptor(object: any): string;
 export function hasNonPrintableCharacters(text: string): boolean;
 export function isTransformApplied(Transform: Function, object: any): boolean;
-export function toString(object: any): string|null;
 export function transformObject(Transform: Function, object: any): any;

package/src/common/utilities.js

@@ -1,8 +1,4 @@
-import {
-  toString as asyncTreeToString,
-  isPlainObject,
-  trailingSlash,
-} from "@weborigami/async-tree";
+import { trailingSlash } from "@weborigami/async-tree";
 import { symbols } from "@weborigami/language";
 import { basename } from "node:path";
 
@@ -50,20 +46,6 @@ export function isTransformApplied(Transform, obj) {
   return false;
 }
 
-/**
- * Extend the async-tree toString method: objects that have a `_body` property
- * will return the value of that property as a string.
- *
- * @param {any} object
- * @returns {string|null}
- */
-export function toString(object) {
-  if (isPlainObject(object) && "_body" in object) {
-    object = object._body;
-  }
-  return asyncTreeToString(object);
-}
-
 /**
  * Apply a functional class mixin to an individual object instance.
  *

package/src/dev/ExplorableSiteTransform.js

@@ -31,8 +31,8 @@ export default function ExplorableSiteTransform(Base) {
       if (value === undefined) {
         // The tree doesn't have the key; try the defaults.
         if (key === "index.html") {
-          // This tree is both the function call target and the parameter.
-          value = await indexPage.call(this, this);
+          // Generate an index page for this site
+          value = await indexPage(this);
         } else if (key === ".keys.json") {
           value = await jsonKeys.stringify(this);
         }

package/src/dev/OriCommandTransform.js

@@ -1,13 +1,16 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import ori from "../origami/ori.js";
+import { scope, trailingSlash } from "@weborigami/async-tree";
+import { projectGlobals } from "@weborigami/language";
 
 /**
  * Add support for commands prefixed with `!`.
  *
- * E.g., asking this tree for `!yaml` will invoke the yaml() builtin function
- * in the context of this tree.
+ * E.g., asking this tree for `!yaml` will invoke the yaml() builtin function,
+ * passing the current tree as the first argument.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").Constructor<AsyncTree>}
+ * AsyncTreeConstructor
  *
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
  * @param {AsyncTreeConstructor} Base
  */
 export default function OriCommandTransform(Base) {
@@ -23,9 +26,24 @@ export default function OriCommandTransform(Base) {
         ) {
           return undefined;
         }
+
         // Key is an Origami command; invoke it.
-        const source = key.slice(1).trim();
-        value = await ori.call(this, source, { formatResult: false });
+        const globals = await projectGlobals();
+        const commandName = trailingSlash.remove(key.slice(1).trim());
+
+        // Look for command as a global or Dev command
+        const command = globals[commandName] ?? globals.Dev?.[commandName];
+        if (command) {
+          value = await command(this);
+        } else {
+          // Look for command in scope
+          const parentScope = await scope(this);
+          value = await parentScope.get(commandName);
+        }
+
+        if (value === undefined) {
+          throw new Error(`Unknown Origami command: ${commandName}`);
+        }
       }
 
       return value;

package/src/dev/explore.js

@@ -1,55 +1,30 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { Tree } from "@weborigami/async-tree";
-import { OrigamiFiles } from "@weborigami/language";
+import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { Handlers, OrigamiFiles } from "@weborigami/language";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 import { getDescriptor } from "../common/utilities.js";
-import { oriHandler } from "../handlers/handlers.js";
 import debug from "./debug.js";
 
 let templatePromise;
 
 /**
- * @this {AsyncTree|null}
+ * Display a debug/explore page for the current tree.
  */
-export default async function explore(...keys) {
-  assertTreeIsDefined(this, "explore");
-  if (!this) {
-    return undefined;
-  }
+export default async function explore(treelike) {
+  const tree = await getTreeArgument(treelike, "explore");
 
-  const tree = Tree.from(this);
+  // Construct the template page
+  const scope = await Tree.scope(tree);
+  const data = await getScopeData(scope);
+  templatePromise ??= loadTemplate();
+  const template = await templatePromise;
+  const text = await template(data);
 
+  // If the user navigates inside this page, unpack back to the original tree.
   /** @type {any} */
-  let result;
-  if (keys.length > 0) {
-    // Traverse the scope using the given keys.
-    const debugTree = await debug.call(tree, this);
-    if (!debugTree) {
-      return undefined;
-    }
-    const debugScope = await Tree.scope(debugTree);
-    // HACK: reproduce logic of ExplorableSiteTransform that turns a trailing
-    // slash into index.html. Calling `debug` applies that transform and the
-    // transform should handle that logic, but unfortunately the `traverse`
-    // operation has special casing to treat a trailing slash, and never gives
-    // ExplorableSiteTransform a chance.
-    if (keys.at(-1) === "") {
-      keys[keys.length - 1] = "index.html";
-    }
-    result = await Tree.traverse(debugScope, ...keys);
-  } else {
-    // Return the Explore page for the current scope.
-    const scope = await Tree.scope(tree);
-    const data = await getScopeData(scope);
-    templatePromise ??= loadTemplate();
-    const template = await templatePromise;
-    const text = await template.call(this, data);
-
-    result = new String(text);
-    result.unpack = () => debug.call(tree, tree);
-  }
+  const result = new String(text);
+  result.unpack = () => debug(tree);
 
   return result;
 }
@@ -71,6 +46,8 @@ async function loadTemplate() {
   const folderPath = path.resolve(fileURLToPath(import.meta.url), "..");
   const folder = new OrigamiFiles(folderPath);
   const templateFile = await folder.get("explore.ori");
-  const template = await oriHandler.unpack(templateFile, { parent: folder });
+  const template = await Handlers.ori_handler.unpack(templateFile, {
+    parent: folder,
+  });
   return template;
 }

package/src/dev/help.yaml

@@ -223,7 +223,7 @@ Tree:
     globKeys:
       args: (patterns)
       description: A tree whose keys can include glob wildcard patterns
-    group:
+    groupBy:
       args: (tree, fn)
       description: A new tree with values grouped by the function
     has:
@@ -259,6 +259,9 @@ Tree:
     map:
       args: (tree, options)
       description: Create a new tree by mapping keys and/or values
+    mapExtension:
+      args: (tree, ext, options)
+      description: Map extensions and values
     mapReduce:
       args: (tree, mapFn, reduceFn)
       description: Map values and reduce them

package/src/dev/log.js

@@ -8,7 +8,7 @@ import yaml from "../origami/yaml.js";
  * @param {any} [result]
  */
 export default async function log(result, object = result) {
-  let text = object !== undefined ? await yaml.call(null, object) : "undefined";
+  let text = object !== undefined ? await yaml(object) : "undefined";
   text = text?.trim();
   console.log(text);
   return result;

package/src/dev/svg.js

@@ -1,5 +1,6 @@
+import { getTreeArgument } from "@weborigami/async-tree";
 import graphviz from "graphviz-wasm";
-import getTreeArgument from "../common/getTreeArgument.js";
+
 import dot from "./treeDot.js";
 
 let graphvizLoaded = false;
@@ -11,8 +12,7 @@ let graphvizLoaded = false;
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  *
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ * @param {Treelike} treelike
  * @param {PlainObject} [options]
  */
 export default async function svg(treelike, options = {}) {
@@ -20,8 +20,8 @@ export default async function svg(treelike, options = {}) {
     await graphviz.loadWASM();
     graphvizLoaded = true;
   }
-  const tree = await getTreeArgument(this, arguments, treelike, "svg", true);
-  const dotText = await dot.call(this, tree, options);
+  const tree = await getTreeArgument(treelike, "svg", { deep: true });
+  const dotText = await dot(tree, options);
   if (dotText === undefined) {
     return undefined;
   }

package/src/initializeBuiltins.js

@@ -0,0 +1,23 @@
+import { builtins } from "@weborigami/language";
+import * as dev from "./dev/dev.js";
+import help from "./dev/help.js";
+import * as origami from "./origami/origami.js";
+
+let initialized = false;
+
+/**
+ * Pass the Origami builtins to the compiler.
+ */
+export default function initializeBuiltins() {
+  if (!initialized) {
+    const origamiBuiltins = {
+      Dev: dev,
+      Origami: origami,
+      "help:": help,
+    };
+
+    Object.assign(builtins, origamiBuiltins);
+  }
+
+  initialized = true;
+}

package/src/origami/fetch.js

@@ -1,7 +1,8 @@
-import { getHandlers, handleExtension } from "@weborigami/language";
+import { handleExtension } from "@weborigami/language";
 
 /**
- * @this {import("@weborigami/types").AsyncTree|null|undefined}
+ * Extend the JavaScript `fetch` function to implicity return an ArrayBuffer
+ * with an unpack() method if the resource has a known file extension.
  */
 export default async function fetchBuiltin(resource, options) {
   const response = await fetch(resource, options);
@@ -10,13 +11,8 @@ export default async function fetchBuiltin(resource, options) {
   }
 
   const value = await response.arrayBuffer();
-  if (!this) {
-    // Can't get extension handlers
-    return value;
-  }
 
-  const handlers = getHandlers(this);
   const url = new URL(resource);
   const key = url.pathname;
-  return handleExtension(this, value, key, handlers);
+  return handleExtension(value, key);
 }

package/src/origami/indexPage.js

@@ -1,4 +1,4 @@
-import getTreeArgument from "../common/getTreeArgument.js";
+import { getTreeArgument } from "@weborigami/async-tree";
 import { getDescriptor } from "../common/utilities.js";
 
 /**
@@ -6,12 +6,12 @@ import { getDescriptor } from "../common/utilities.js";
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ *
+ * @param {Treelike} treelike
  * @param {string} [basePath]
  */
 export default async function indexPage(treelike, basePath) {
-  const tree = await getTreeArgument(this, arguments, treelike, "indexPage");
+  const tree = await getTreeArgument(treelike, "svg");
   const keys = Array.from(await tree.keys());
 
   // Skip system-ish files that start with a period. Also skip `index.html`.

package/src/origami/inline.js

@@ -1,15 +1,14 @@
 import { isUnpackable, symbols, toString } from "@weborigami/async-tree";
+import { oridocument_handler } from "@weborigami/language/src/handlers/handlers.js";
 import documentObject from "../common/documentObject.js";
-import { oridocumentHandler } from "../handlers/handlers.js";
 
 /**
  * Inline any Origami expressions found inside ${...} placeholders in the input
  * text.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
  *
- * @param {Stringlike & {_body?: Stringlike}} input
+ * @param {any} input
  */
 export default async function inline(input) {
   // Get the input text and any attached front matter.
@@ -37,7 +36,7 @@ export default async function inline(input) {
   }
 
   // @ts-ignore
-  let result = await oridocumentHandler.unpack(origami, {
+  let result = await oridocument_handler.unpack(origami, {
     front,
     parent,
   });

package/src/origami/jsonParse.js

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

package/src/origami/mdHtml.js

@@ -1,11 +1,10 @@
-import { extension, isUnpackable } from "@weborigami/async-tree";
+import { extension, isUnpackable, toString } from "@weborigami/async-tree";
 import highlight from "highlight.js";
 import { Marked } from "marked";
 import { gfmHeadingId as markedGfmHeadingId } from "marked-gfm-heading-id";
 import { markedHighlight } from "marked-highlight";
 import { markedSmartypants } from "marked-smartypants";
 import documentObject from "../common/documentObject.js";
-import { toString } from "../common/utilities.js";
 import origamiHighlightDefinition from "./origamiHighlightDefinition.js";
 
 highlight.registerLanguage("ori", origamiHighlightDefinition);
@@ -32,10 +31,7 @@ marked.use(
 /**
  * Transform markdown to HTML.
  *
- * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
- * @typedef {import("@weborigami/async-tree").Unpackable} Unpackable
- *
- * @param {Stringlike|Unpackable} input
+ * @param {any} input
  */
 export default async function mdHtml(input) {
   if (input == null) {
@@ -47,7 +43,7 @@ export default async function mdHtml(input) {
     input = await input.unpack();
   }
   const inputIsDocument = typeof input === "object" && "_body" in input;
-  const markdown = toString(input);
+  const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
     throw new Error("mdHtml: The provided input couldn't be treated as text.");
   }

package/src/origami/mdOutline.js

@@ -1,12 +1,12 @@
-import { isUnpackable } from "@weborigami/async-tree";
+import { isUnpackable, toString } from "@weborigami/async-tree";
 import { Marked } from "marked";
-import { toString } from "../common/utilities.js";
 
 export default async function mdOutline(input) {
   if (isUnpackable(input)) {
     input = await input.unpack();
   }
-  const markdown = toString(input);
+  const inputIsDocument = typeof input === "object" && "_body" in input;
+  const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
     throw new Error("mdHtml: The provided input couldn't be treated as text.");
   }

package/src/origami/ori.js

@@ -5,10 +5,9 @@ import {
   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);
 
@@ -18,14 +17,11 @@ 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)) {
@@ -34,38 +30,34 @@ export default async function ori(
   // @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

@@ -12,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";
@@ -26,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/sitemap.js

@@ -1,5 +1,5 @@
 import { getTreeArgument, Tree } from "@weborigami/async-tree";
-import { oriHandler } from "../handlers/handlers.js";
+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">
@@ -45,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 templateFn = await ori_handler.unpack(templateText);
   const templateResult = await templateFn(htmlPaths);
   return String(templateResult);
 }

package/src/origami/static.js

@@ -1,5 +1,5 @@
 import { Tree, getTreeArgument, jsonKeys } from "@weborigami/async-tree";
-import index from "./indexPage.js";
+import indexPage from "./indexPage.js";
 
 /**
  * Expose common static keys (index.html, .keys.json) for a tree.
@@ -23,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,10 +1 @@
-import { toString } from "../common/utilities.js";
-
-/**
- * Convert an object to a string.
- *
- * @param {any} object
- */
-export default function stringBuiltin(object) {
-  return toString(object);
-}
+export { toString as default } from "@weborigami/async-tree";