@weborigami/language 0.5.8 → 0.6.1

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

@@ -8,18 +8,16 @@ export { default as jsGlobals } from "./src/project/jsGlobals.js";
 export { default as projectGlobals } from "./src/project/projectGlobals.js";
 export { default as projectRoot } from "./src/project/projectRoot.js";
 export * as Protocols from "./src/protocols/protocols.js";
-export { formatError } from "./src/runtime/errors.js";
+export { formatError, highlightError } 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.8",
+  "version": "0.6.1",
   "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.8",
-    "@weborigami/types": "0.5.8",
+    "@weborigami/async-tree": "0.6.1",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -2,7 +2,7 @@ import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
 import jsGlobals from "../project/jsGlobals.js";
 import { entryKey } from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
-import { annotate, markers } from "./parserHelpers.js";
+import { annotate, markers, spanLocations } from "./parserHelpers.js";
 
 export const REFERENCE_PARAM = 1;
 export const REFERENCE_INHERITED = 2;
@@ -334,6 +334,8 @@ function resolvePath(code, globals, parent, locals, cache) {
         result[0][0] === ops.inherited);
     if (extendResult) {
       result.push(...tail);
+      result.location = spanLocations(args);
+      result.source = code.source;
     } else {
       result = annotate([result, ...tail], code.location);
     }

package/src/compiler/parserHelpers.js

@@ -1,4 +1,3 @@
-import { trailingSlash } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 import codeFragment from "../runtime/codeFragment.js";
 import * as ops from "../runtime/ops.js";
@@ -380,11 +379,6 @@ export function makePath(keys) {
   const location = spanLocations(code);
   code = annotate(code, location);
 
-  // Last key has trailing slash implies unpack operation
-  if (trailingSlash.has(args.at(-1)[1])) {
-    code = annotate([ops.unpack, code], location);
-  }
-
   return code;
 }
 
@@ -518,7 +512,7 @@ export function makeYamlObject(text, location) {
 
 // Create a locations that spans those in the array. This assumes the locations
 // are in order and non-overlapping.
-function spanLocations(code) {
+export function spanLocations(code) {
   const first = code.find((item) => item.location).location;
   const last = code[code.findLastIndex((item) => item.location)].location;
   return {

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

@@ -0,0 +1,36 @@
+import { getParent, toString } from "@weborigami/async-tree";
+
+/**
+ * Given packed source text and a handler's options, return a source
+ * object that can be passed to the compiler.
+ */
+export default function getSource(packed, options = {}) {
+  const parent = getParent(packed, options);
+
+  // Try to determine a URL for error messages
+  const sourceName = options.key;
+  let url;
+  if (sourceName) {
+    if (/** @type {any} */ (parent)?.url) {
+      let parentHref = /** @type {any} */ (parent).url.href;
+      if (!parentHref.endsWith("/")) {
+        parentHref += "/";
+      }
+      url = new URL(sourceName, parentHref);
+    } else if (/** @type {any} */ (parent)?.path) {
+      let parentHref = new URL(/** @type {any} */ (parent).path, "file:///")
+        .href;
+      if (!parentHref.endsWith("/")) {
+        parentHref += "/";
+      }
+      url = new URL(sourceName, parentHref);
+    }
+  }
+
+  const source = {
+    text: toString(packed),
+    name: options.key,
+    url,
+  };
+  return source;
+}

package/src/handlers/ori_handler.js

@@ -1,6 +1,7 @@
-import { getParent, setParent, toString } from "@weborigami/async-tree";
+import { getParent, setParent } from "@weborigami/async-tree";
 import * as compile from "../compiler/compile.js";
 import projectGlobals from "../project/projectGlobals.js";
+import getSource from "./getSource.js";
 
 /**
  * An Origami expression file
@@ -13,34 +14,18 @@ export default {
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
   async unpack(packed, options = {}) {
     const parent = getParent(packed, options);
+    const source = getSource(packed, options);
 
-    // Construct an object to represent the source code.
-    const sourceName = options.key;
-    let url;
-    if (sourceName && /** @type {any} */ (parent)?.url) {
-      let parentHref = /** @type {any} */ (parent).url.href;
-      if (!parentHref.endsWith("/")) {
-        parentHref += "/";
-      }
-      url = new URL(sourceName, parentHref);
-    }
-
-    const source = {
-      text: toString(packed),
-      name: options.key,
-      url,
-    };
-
-    // Compile the source code as an Origami program and evaluate it.
+    // Compile the source code as an Origami program
     const compiler = options.compiler ?? compile.program;
     const globals = options.globals ?? (await projectGlobals());
-
     const fn = compiler(source, {
       globals,
       mode: "program",
       parent,
     });
 
+    // Evaluate the program
     const result = await fn();
 
     if (parent) {

package/src/handlers/oridocument_handler.js

@@ -1,11 +1,7 @@
-import {
-  extension,
-  getParent,
-  toString,
-  trailingSlash,
-} from "@weborigami/async-tree";
+import { extension, getParent, trailingSlash } from "@weborigami/async-tree";
 import * as compile from "../compiler/compile.js";
 import projectGlobals from "../project/projectGlobals.js";
+import getSource from "./getSource.js";
 
 /**
  * An Origami template document: a plain text file that contains Origami
@@ -17,30 +13,10 @@ export default {
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
   async unpack(packed, options = {}) {
     const parent = getParent(packed, options);
+    const source = getSource(packed, options);
 
-    // Unpack as a text document
-    const text = toString(packed);
-
-    // See if we can construct a URL to use in error messages
-    const key = options.key;
-    let url;
-    if (key && /** @type {any} */ (parent)?.url) {
-      let parentHref = /** @type {any} */ (parent).url.href;
-      if (!parentHref.endsWith("/")) {
-        parentHref += "/";
-      }
-      url = new URL(key, parentHref);
-    }
-
-    // Compile the text as an Origami template document
-    const source = {
-      name: key,
-      text,
-      url,
-    };
-
+    // Compile the source code as an Origami template document
     const globals = options.globals ?? (await projectGlobals());
-
     const defineFn = compile.templateDocument(source, {
       front: options.front,
       globals,
@@ -51,6 +27,7 @@ export default {
     // Invoke the definition to get back the template function
     const result = await defineFn();
 
+    const key = options.key;
     const resultExtension = key ? extension.extname(key) : null;
     if (resultExtension && Object.isExtensible(result)) {
       // Add sidecar function so this template can be used in a map.

package/src/handlers/tsv_handler.js

@@ -45,7 +45,16 @@ function tsvParse(text) {
     const values = lines[i].split("\t");
     const entry = {};
     for (let j = 0; j < headers.length; j++) {
-      entry[headers[j]] = values[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);
   }

package/src/handlers/yaml_handler.js

@@ -1,5 +1,14 @@
-import { symbols, toString } from "@weborigami/async-tree";
+import {
+  getParent,
+  isUnpackable,
+  symbols,
+  toString,
+} from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
+import * as compile from "../compiler/compile.js";
+import projectGlobals from "../project/projectGlobals.js";
+import * as expressionFunction from "../runtime/expressionFunction.js";
+import getSource from "./getSource.js";
 
 // The "yaml" package doesn't seem to provide a default export that the browser can
 // recognize, so we have to handle two ways to accommodate Node and the browser.
@@ -16,12 +25,20 @@ export default {
   mediaType: "application/yaml",
 
   /** @type {import("@weborigami/async-tree").UnpackFunction} */
-  unpack(packed) {
+  async unpack(packed, options = {}) {
     const yaml = toString(packed);
     if (!yaml) {
       throw new Error("Tried to parse something as YAML but it wasn't text.");
     }
-    const data = YAML.parse(yaml);
+    const parent = getParent(packed, options);
+    const oriCallTag = await oriCallTagForParent(parent, options);
+    const oriTag = await oriTagForParent(parent, options);
+    // YAML parser is sync, but top-level !ori or !ori.call tags will return a
+    // promise.
+    // @ts-ignore TypeScript complains customTags isn't valid here but it is.
+    const data = await YAML.parse(yaml, {
+      customTags: [oriCallTag, oriTag],
+    });
     if (data && typeof data === "object" && Object.isExtensible(data)) {
       Object.defineProperty(data, symbols.deep, {
         enumerable: false,
@@ -31,3 +48,58 @@ export default {
     return data;
   },
 };
+
+async function oriCallTagForParent(parent, options) {
+  const globals = await projectGlobals();
+  return {
+    collection: "seq",
+
+    tag: "!ori.call",
+
+    identify: (value) => false,
+
+    async resolve(value) {
+      /** @type {any[]} */
+      const args = typeof value?.toJSON === "function" ? value.toJSON() : value;
+
+      // First arg is Origami source
+      const text = args.shift();
+      const source = getSource(text, options);
+
+      const codeFn = compile.expression(source, {
+        globals,
+        parent,
+      });
+
+      // Evaluate the code to get a function
+      let fn = await codeFn.call(parent);
+
+      // Call the function with the rest of the args
+      if (isUnpackable(fn)) {
+        fn = await fn.unpack();
+      }
+
+      return fn.call(null, ...args);
+    },
+  };
+}
+
+// Define the !ori tag for YAML parsing. This will run in the context of the
+// supplied parent.
+async function oriTagForParent(parent, options) {
+  const globals = await projectGlobals();
+  return {
+    identify: expressionFunction.isExpressionFunction,
+
+    resolve(text) {
+      const source = getSource(text, options);
+      const fn = compile.expression(source, {
+        globals,
+        parent,
+      });
+      return fn.call(parent);
+    },
+
+    tag: "!ori",
+  };
+}

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);
 }