@weborigami/language 0.5.7 → 0.6.0

package/index.ts

@@ -1,5 +1,4 @@
-import { UnpackFunction } from "@weborigami/async-tree";
-import { AsyncTree } from "@weborigami/types";
+import { SyncOrAsyncMap, UnpackFunction } from "@weborigami/async-tree";
 
 export * from "./main.js";
 
@@ -59,9 +58,9 @@ export type Position = {
 
 export type RuntimeState = {
   /** The container (e.g., file system) that holds the code */
-  container?: AsyncTree | null;
+  container?: SyncOrAsyncMap | null;
   /** The object to which this code is attached */
-  object?: AsyncTree | null;
+  object?: SyncOrAsyncMap | null;
   /** The current stack of function parameter assignments */
   stack?: Array<Record<string, any>>;
 }

package/main.js

@@ -12,14 +12,12 @@ export { formatError } from "./src/runtime/errors.js";
 export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
-export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";
 export * from "./src/runtime/handleExtension.js";
 export { default as handleExtension } from "./src/runtime/handleExtension.js";
 export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
-export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
 export * as moduleCache from "./src/runtime/moduleCache.js";
-export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
+export { default as OrigamiFileMap } from "./src/runtime/OrigamiFileMap.js";
 export * as symbols from "./src/runtime/symbols.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "24.3.0",
+    "@types/node": "24.10.1",
     "peggy": "5.0.6",
-    "typescript": "5.9.2"
+    "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.7",
-    "@weborigami/types": "0.5.7",
+    "@weborigami/async-tree": "0.6.0",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/handlers/csv_handler.js

@@ -34,11 +34,21 @@ function csvParse(text) {
   const rows = [];
   let currentRow = [];
   let currentField = "";
+  let wasQuoted = false; // True if the current field was quoted
 
   const pushField = () => {
-    // Push the completed field and reset for the next field.
-    currentRow.push(currentField);
+    /** @type {string|number} */
+    let parsedField = currentField;
+    if (!wasQuoted) {
+      // Field wasn't quoted: if it's a valid number, convert it
+      const n = Number(currentField);
+      if (!isNaN(n)) {
+        parsedField = n;
+      }
+    }
+    currentRow.push(parsedField);
     currentField = "";
+    wasQuoted = false; // Reset the flag for the next field
   };
 
   const pushRow = () => {
@@ -54,29 +64,24 @@ function csvParse(text) {
     const char = text[i];
 
     if (inQuotes) {
-      // In a quoted field
       if (char === '"') {
-        // Check if next character is also a quote
         if (i + 1 < text.length && text[i + 1] === '"') {
-          // Append a literal double quote and skip the next character
           currentField += '"';
           i += 2;
           continue;
         } else {
-          // End of the quoted field
           inQuotes = false;
           i++;
           continue;
         }
       } else {
-        // All other characters within quotes are taken literally.
         currentField += char;
         i++;
         continue;
       }
     } else if (char === '"') {
-      // Start of a quoted field
       inQuotes = true;
+      wasQuoted = true; // Mark the field as quoted
       i++;
       continue;
     } else if (char === ",") {

package/src/handlers/handlers.js

@@ -27,6 +27,8 @@ export { default as jpg_handler } from "./jpg_handler.js";
 export { default as json_handler } from "./json_handler.js";
 export { default as md_handler } from "./md_handler.js";
 export { default as mjs_handler } from "./mjs_handler.js";
+export { default as sh_handler } from "./sh_handler.js";
+export { default as tsv_handler } from "./tsv_handler.js";
 export { default as wasm_handler } from "./wasm_handler.js";
 export { default as xhtml_handler } from "./xhtml_handler.js";
 export { default as yaml_handler } from "./yaml_handler.js";

package/src/handlers/sh_handler.js

@@ -0,0 +1,65 @@
+import { toString } from "@weborigami/async-tree";
+import { spawn } from "node:child_process";
+
+/**
+ * Shell script file extension handler
+ */
+export default {
+  mediaType: "text/plain",
+
+  /** @type {import("@weborigami/async-tree").UnpackFunction} */
+  async unpack(packed) {
+    const scriptText = toString(packed);
+
+    if (scriptText === null) {
+      throw new Error(".sh handler: input isn't text");
+    }
+
+    return async (input) => {
+      return runShellScript(scriptText, input);
+    };
+  },
+};
+
+/**
+ * Run arbitrary shell script text in /bin/sh and feed it stdin.
+ * Supports multiple commands, pipelines, redirects, etc.
+ *
+ * @param {string} scriptText - Shell code (may contain newlines/side effects)
+ * @param {string} inputText  - Text to pipe to the script's stdin
+ * @returns {Promise<string>}
+ */
+function runShellScript(scriptText, inputText) {
+  return new Promise((resolve, reject) => {
+    // Use sh -c "<scriptText>" so stdin is free for inputText
+    const child = spawn("sh", ["-c", scriptText], {
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (c) => (stdout += c));
+    child.stderr.on("data", (c) => (stderr += c));
+
+    child.on("error", reject);
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        /** @type {any} */
+        const err = new Error(
+          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`
+        );
+        err.code = code;
+        err.stdout = stdout;
+        err.stderr = stderr;
+        return reject(err);
+      }
+      resolve(stdout);
+    });
+
+    // Feed the input to the script's stdin and close it
+    child.stdin.end(inputText);
+  });
+}

package/src/handlers/tsv_handler.js

@@ -0,0 +1,63 @@
+import { symbols, toString } from "@weborigami/async-tree";
+
+export default {
+  mediaType: "text/csv",
+
+  unpack(packed, options = {}) {
+    const parent = options.parent ?? null;
+    const text = toString(packed);
+    if (text === null) {
+      throw new TypeError(".tsv handler can only unpack text");
+    }
+    const data = tsvParse(text);
+    // Define `parent` as non-enumerable property
+    Object.defineProperty(data, symbols.parent, {
+      configurable: true,
+      enumerable: false,
+      value: parent,
+      writable: true,
+    });
+    return data;
+  },
+};
+
+/**
+ * Parse text as tab-separated values (TSV) format into an array of objects.
+ *
+ * This assumes the presence of a header row, and accepts both CRLF and LF line
+ * endings.
+ *
+ * Blank lines are ignored.
+ *
+ * @param {string} text
+ * @returns {any[]}
+ */
+function tsvParse(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim() !== "");
+  if (lines.length === 0) {
+    return [];
+  }
+
+  const headers = lines[0].split("\t");
+  const data = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split("\t");
+    const entry = {};
+    for (let j = 0; j < headers.length; j++) {
+      /** @type {string|number} */
+      let value = values[j];
+      if (value !== undefined) {
+        // Attempt to convert to number if possible
+        const n = Number(value);
+        if (!isNaN(n)) {
+          value = n;
+        }
+      }
+      entry[headers[j]] = value ?? "";
+    }
+    data.push(entry);
+  }
+
+  return data;
+}

package/src/project/jsGlobals.js

@@ -168,7 +168,11 @@ async function fetchWrapper(resource, options) {
   return response.ok ? await response.arrayBuffer() : undefined;
 }
 
-/** @this {import("@weborigami/types").AsyncTree|null|undefined} */
+/**
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ *
+ * @this {AsyncMap|null|undefined}
+ */
 async function importWrapper(modulePath) {
   // Walk up parent tree looking for a FileTree or other object with a `path`
   /** @type {any} */

package/src/project/projectConfig.js

@@ -1,4 +1,4 @@
-import { FileTree, toString } from "@weborigami/async-tree";
+import { FileMap, toString } from "@weborigami/async-tree";
 import ori_handler from "../handlers/ori_handler.js";
 import coreGlobals from "./coreGlobals.js";
 import projectRoot from "./projectRoot.js";
@@ -14,9 +14,9 @@ export default async function config(dir = process.cwd()) {
     return cached;
   }
 
-  // Use a plain FileTree to avoid loading extension handlers
-  const rootFileTree = new FileTree(rootPath);
-  const configBuffer = await rootFileTree.get("config.ori");
+  // Use a plain FileMap to avoid loading extension handlers
+  const rootFileMap = new FileMap(rootPath);
+  const configBuffer = await rootFileMap.get("config.ori");
   let configObject = {};
   if (configBuffer) {
     const configText = toString(configBuffer);

package/src/project/projectRoot.js

@@ -1,6 +1,6 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import path from "node:path";
-import OrigamiFiles from "../runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 
 const configFileName = "config.ori";
 const packageFileName = "package.json";
@@ -8,7 +8,7 @@ const packageFileName = "package.json";
 const mapPathToRoot = new Map();
 
 /**
- * Return an OrigamiFiles object for the current project.
+ * Return an OrigamiFileMap 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
@@ -17,7 +17,6 @@ const mapPathToRoot = new Map();
  * 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]
  */
@@ -29,19 +28,19 @@ export default async function projectRoot(dirname = process.cwd()) {
 
   let root;
   let value;
-  // Use a plain FileTree to avoid loading extension handlers
-  const currentTree = new FileTree(dirname);
+  // Use a plain FileMap to avoid loading extension handlers
+  const currentTree = new FileMap(dirname);
   // Try looking for config file
   value = await currentTree.get(configFileName);
   if (value) {
     // Found config file
-    root = new OrigamiFiles(currentTree.path);
+    root = new OrigamiFileMap(currentTree.path);
   } else {
     // Try looking for package.json
     value = await currentTree.get(packageFileName);
     if (value) {
       // Found package.json
-      root = new OrigamiFiles(currentTree.path);
+      root = new OrigamiFileMap(currentTree.path);
     } else {
       // Move up a folder and try again
       const parentPath = path.dirname(dirname);
@@ -49,7 +48,7 @@ export default async function projectRoot(dirname = process.cwd()) {
         root = await projectRoot(parentPath);
       } else {
         // At filesystem root, use current working directory
-        root = new OrigamiFiles(process.cwd());
+        root = new OrigamiFileMap(process.cwd());
       }
     }
   }

package/src/protocols/constructSiteTree.js

@@ -5,14 +5,14 @@ import constructHref from "./constructHref.js";
 /**
  * Given a protocol, a host, and a list of keys, construct an href.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
  *
  * @param {string} protocol
- * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
+ * @param {import("../../index.ts").Constructor<SyncOrAsyncMap>} mapClass
  * @param {string} host
  * @param  {string[]} keys
  */
-export default function constructSiteTree(protocol, treeClass, host, ...keys) {
+export default function constructSiteTree(protocol, mapClass, 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))) {
@@ -20,7 +20,7 @@ export default function constructSiteTree(protocol, treeClass, host, ...keys) {
   }
 
   const href = constructHref(protocol, host, ...keys);
-  let result = new (HandleExtensionsTransform(treeClass))(href);
+  let result = new (HandleExtensionsTransform(mapClass))(href);
 
   return lastKey ? result.get(lastKey) : result;
 }

package/src/protocols/explore.js

@@ -1,14 +1,13 @@
-import { ExplorableSiteTree } from "@weborigami/async-tree";
+import { ExplorableSiteMap } 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);
+  return constructSiteTree("https:", ExplorableSiteMap, host, ...keys);
 }

package/src/protocols/fetchAndHandleExtension.js

@@ -3,7 +3,6 @@ import handleExtension from "../runtime/handleExtension.js";
 /**
  * Fetch the resource at the given href.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} href
  */

package/src/protocols/files.js

@@ -1,10 +1,9 @@
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import OrigamiFiles from "../runtime/OrigamiFiles.js";
+import OrigamiFileMap from "../runtime/OrigamiFileMap.js";
 
 /**
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string[]} keys
  */
@@ -21,6 +20,6 @@ export default async function files(...keys) {
   }
   const resolved = path.resolve(basePath, relativePath);
 
-  const result = new OrigamiFiles(resolved);
+  const result = new OrigamiFileMap(resolved);
   return result;
 }

package/src/protocols/http.js

@@ -4,7 +4,6 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
 /**
  * Retrieve the indicated web resource via HTTP.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys

package/src/protocols/https.js

@@ -4,7 +4,6 @@ import fetchAndHandleExtension from "./fetchAndHandleExtension.js";
 /**
  * Retrieve the indicated web resource via HTTPS.
  *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @param {string} host
  * @param  {...string} keys

package/src/protocols/httpstree.js

@@ -1,14 +1,13 @@
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteMap } 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);
+  return constructSiteTree("https:", SiteMap, host, ...keys);
 }

package/src/protocols/httptree.js

@@ -1,14 +1,13 @@
-import { SiteTree } from "@weborigami/async-tree";
+import { SiteMap } 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);
+  return constructSiteTree("http:", SiteMap, host, ...keys);
 }

package/src/runtime/HandleExtensionsTransform.js

@@ -1,17 +1,41 @@
 import handleExtension from "./handleExtension.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @typedef {import("../../index.ts").Constructor<Map>} MapConstructor
  * @typedef {import("@weborigami/async-tree").UnpackFunction} FileUnpackFunction
  *
- * @param {AsyncTreeConstructor} Base
+ * @param {MapConstructor} Base
  */
 export default function HandleExtensionsTransform(Base) {
-  return class HandleExtensions extends Base {
-    async get(key) {
-      const value = await super.get(key);
-      return handleExtension(value, key, this);
+  class HandleExtensions extends Base {
+    // Implement delete (and set) to keep the Map read-write
+    delete(key) {
+      return super.delete(key);
     }
-  };
+
+    get(key) {
+      const value = super.get(key);
+      return value instanceof Promise
+        ? value.then((resolved) => handleExtension(resolved, key, this))
+        : handleExtension(value, key, this);
+    }
+
+    // See delete()
+    set(key, value) {
+      return super.set(key, value);
+    }
+  }
+
+  if (Base.prototype.readOnly) {
+    // Remove delete and set methods to keep the Map read-only. The base delete
+    // and set methods will exist (because it's a Map) but for our purposes the
+    // class is read-only.
+
+    // @ts-ignore
+    delete HandleExtensions.prototype.delete;
+    // @ts-ignore
+    delete HandleExtensions.prototype.set;
+  }
+
+  return HandleExtensions;
 }

package/src/runtime/ImportModulesMixin.js

@@ -5,8 +5,8 @@ import { maybeOrigamiSourceCode } from "./errors.js";
 import * as moduleCache from "./moduleCache.js";
 
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree & { dirname: string }>} BaseConstructor
+ * @typedef {import("@weborigami/async-tree").AsyncMap} AsyncMap
+ * @typedef {import("../../index.ts").Constructor<AsyncMap & { dirname: string }>} BaseConstructor
  * @param {BaseConstructor} Base
  */
 export default function ImportModulesMixin(Base) {

package/src/runtime/{OrigamiFiles.js → OrigamiFileMap.d.ts}

@@ -1,9 +1,9 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends HandleExtensionsTransform(
-  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
+export default class OrigamiFileMap extends HandleExtensionsTransform(
+  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileMap)))
 ) {}

package/src/runtime/{OrigamiFiles.d.ts → OrigamiFileMap.js}

@@ -1,11 +1,9 @@
-import { FileTree } from "@weborigami/async-tree";
+import { FileMap } from "@weborigami/async-tree";
 import EventTargetMixin from "./EventTargetMixin.js";
 import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import ImportModulesMixin from "./ImportModulesMixin.js";
 import WatchFilesMixin from "./WatchFilesMixin.js";
 
-export default class OrigamiFiles extends HandleExtensionsTransform(
-  (
-    ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileTree)))
-  )
+export default class OrigamiFileMap extends HandleExtensionsTransform(
+  ImportModulesMixin(WatchFilesMixin(EventTargetMixin(FileMap)))
 ) {}

package/src/runtime/expressionFunction.js

@@ -1,12 +1,12 @@
-/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-
 import { evaluate } from "./internal.js";
 
 /**
  * Given parsed Origami code, return a function that executes that code.
  *
+ * @typedef {import("@weborigami/async-tree").SyncOrAsyncMap} SyncOrAsyncMap
+ *
  * @param {import("../../index.js").AnnotatedCode} code - parsed Origami expression
- * @param {AsyncTree} parent - the parent tree in which the code is running
+ * @param {SyncOrAsyncMap} parent - the parent tree in which the code is running
  */
 export function createExpressionFunction(code, parent) {
   async function fn() {

package/src/runtime/expressionObject.js

@@ -1,6 +1,6 @@
 import {
   extension,
-  ObjectTree,
+  ObjectMap,
   setParent,
   symbols,
   trailingSlash,
@@ -30,14 +30,15 @@ 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`);
+  if (parent !== null && !Tree.isMap(parent)) {
+    throw new TypeError(`Parent must be a map or null`);
   }
   setParent(object, parent);
 
   let tree;
   const eagerProperties = [];
   const propertyIsEnumerable = {};
+  let hasLazyProperties = false;
   for (let [key, value] of entries) {
     // Determine if we need to define a getter or a regular property. If the key
     // has an extension, we need to define a getter. If the value is code (an
@@ -80,6 +81,7 @@ export default async function expressionObject(entries, state = {}) {
       // Property getter
       let code;
       if (value[0] === ops.getter) {
+        hasLazyProperties = true;
         code = value[1];
       } else {
         eagerProperties.push(key);
@@ -87,7 +89,7 @@ export default async function expressionObject(entries, state = {}) {
       }
 
       const get = async () => {
-        tree ??= new ObjectTree(object);
+        tree ??= new ObjectMap(object);
         const newState = Object.assign({}, state, { object: tree });
         const result = await evaluate(code, newState);
         return extname ? handleExtension(result, key, tree) : result;
@@ -113,8 +115,7 @@ export default async function expressionObject(entries, state = {}) {
   // and overwrite the property getter with the actual value.
   for (const key of eagerProperties) {
     const value = await object[key];
-    // @ts-ignore Unclear why TS thinks `object` might be undefined here
-    const enumerable = Object.getOwnPropertyDescriptor(object, key).enumerable;
+    const enumerable = Object.getOwnPropertyDescriptor(object, key)?.enumerable;
     Object.defineProperty(object, key, {
       configurable: true,
       enumerable,
@@ -123,6 +124,16 @@ export default async function expressionObject(entries, state = {}) {
     });
   }
 
+  // If there are any getters, mark the object as async
+  if (hasLazyProperties) {
+    Object.defineProperty(object, symbols.async, {
+      configurable: true,
+      enumerable: false,
+      value: true,
+      writable: true,
+    });
+  }
+
   return object;
 }
 
@@ -141,8 +152,8 @@ export function entryKey(entry, object = null, eagerProperties = []) {
     return key;
   }
 
-  // If eager property value is treelike, add slash to the key
-  if (eagerProperties.includes(key) && Tree.isTreelike(object?.[key])) {
+  // If eager property value is maplike, add slash to the key
+  if (eagerProperties.includes(key) && Tree.isMaplike(object?.[key])) {
     return trailingSlash.add(key);
   }