@weborigami/origami 0.0.45 → 0.0.47

package/src/common/serialize.js

@@ -5,7 +5,12 @@
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
-import { Tree, isPlainObject, isStringLike } from "@weborigami/async-tree";
+import {
+  Tree,
+  isPlainObject,
+  isStringLike,
+  isUnpackable,
+} from "@weborigami/async-tree";
 import { OrigamiTree } from "@weborigami/language";
 import * as YAMLModule from "yaml";
 import yamlOrigamiTag from "../misc/yamlOrigamiTag.js";
@@ -90,40 +95,76 @@ export async function toJson(obj) {
 }
 
 /**
- * Convert the given object to a corresponding JSON value that can be serialized
- * as JSON or YAML.
+ * Convert the given object to a corresponding JSON value that can be
+ * represented as JSON or YAML.
  *
- * If the object is already a JSON value, it is returned as is.
+ * @param {any} object
+ * @returns {Promise<JsonValue>}
+ */
+export async function toJsonValue(object) {
+  return toValue(object, true);
+}
+
+/**
+ * Convert the given input to the plainest possible JavaScript value. This
+ * helper is intended for functions that want to accept an argument from the ori
+ * CLI, which could a string, a file buffer, an ArrayBuffer from a URL, or some
+ * other kind of JavaScript object.
  *
- * If the object implements the `pack()` method, that method's result will be
- * returned.
+ * If the input implements the `unpack()` method, the input will be unpacked and
+ * before processing.
  *
- * If the object is treelike, it will be converted to a plain JavaScript
- * object, recursively traversing the tree and converting all values to native
- * types.
+ * If the input is treelike, it will be converted to a plain JavaScript object,
+ * recursively traversing the tree and converting all values to plain types.
  *
- * If the object has a `valueOf()` or `toString()` method, that method's result
- * will be returned.
+ * If the input is stringlike, its text will be returned.
  *
- * @param {any} object
- * @returns {Promise<JsonValue>}
+ * If the input is a Buffer or ArrayBuffer, it will be interpreted as UTF-8
+ * text.
+ *
+ * If the input has a custom class instance, its public properties will be
+ * returned as a plain object.
+ *
+ * The `jsonValuesOnly` parameter can be set to `true` to ensure that the
+ * returned value can be represented as JSON. If the input can't be represented
+ * as JSON, an error is thrown.
+ *
+ * @param {any} input
+ * @param {boolean} [jsonValuesOnly]
+ * @returns {Promise<any>}
  */
-export async function toJsonValue(object) {
-  if (isJsonValue(object)) {
-    return object;
-  } else if (object && typeof object.pack === "function") {
-    return object.pack();
-  } else if (isStringLike(object) && !(object instanceof Array)) {
-    return String(object);
-  } else if (Tree.isTreelike(object)) {
-    const mapped = await Tree.map(object, (value) => toJsonValue(value));
+export async function toValue(input, jsonValuesOnly = false) {
+  if (input instanceof Promise) {
+    // Resolve promise before processing.
+    return toValue(await input, jsonValuesOnly);
+  } else if (isJsonValue(input)) {
+    return input;
+  } else if (typeof input !== "object") {
+    if (jsonValuesOnly) {
+      throw new TypeError(`Couldn't serialize value to JSON: ${input}`);
+    } else {
+      return input;
+    }
+  } else if (isUnpackable(input)) {
+    // Unpack first, then convert to JSON value.
+    const unpacked = await input.unpack();
+    return toValue(unpacked);
+  } else if (isStringLike(input) && !(input instanceof Array)) {
+    return String(input);
+  } else if (Tree.isTreelike(input)) {
+    const mapped = await Tree.map(input, (value) => toValue(value));
     return Tree.plain(mapped);
-  } else if (object instanceof ArrayBuffer || object instanceof TypedArray) {
-    // Serialize data as UTF-8.
-    return textDecoder.decode(object);
+  } else if (input instanceof ArrayBuffer || input instanceof TypedArray) {
+    // Interpret input as UTF-8 text.
+    return textDecoder.decode(input);
+  } else {
+    // Some other kind of class instance; return its public properties.
+    const plain = {};
+    for (const [key, value] of Object.entries(input)) {
+      plain[key] = await toValue(value);
+    }
+    return plain;
   }
-
-  throw new TypeError("Couldn't serialize object");
 }
 
 /**

package/src/common/utilities.js

@@ -1,4 +1,9 @@
-import { Tree, isPlainObject, isStringLike } from "@weborigami/async-tree";
+import {
+  Tree,
+  isPlainObject,
+  isStringLike,
+  isUnpackable,
+} from "@weborigami/async-tree";
 
 const textDecoder = new TextDecoder();
 const TypedArray = Object.getPrototypeOf(Uint8Array);
@@ -57,16 +62,13 @@ export function toFunction(obj) {
   if (typeof obj === "function") {
     // Return a function as is.
     return obj;
-  } else if (
-    typeof obj === "object" &&
-    typeof (/** @type {any} */ (obj)?.unpack) === "function"
-  ) {
+  } else if (isUnpackable(obj)) {
     // Extract the contents of the object and convert that to a function.
     let fn;
     /** @this {any} */
     return async function (...args) {
       if (!fn) {
-        const content = await /** @type {any} */ (obj).unpack();
+        const content = await obj.unpack();
         fn = toFunction(content);
       }
       return fn.call(this, ...args);
@@ -100,7 +102,7 @@ export function toString(object) {
   if (isPlainObject(object) && "@text" in object) {
     return object["@text"];
   } else if (object instanceof ArrayBuffer || object instanceof TypedArray) {
-    // Serialize data as UTF-8.
+    // Treat the buffer as UTF-8 text.
     const decoded = textDecoder.decode(object);
     // If the result has non-printable characters, it's probably not a string.
     return hasNonPrintableCharacters(decoded) ? null : decoded;

package/src/misc/getTreeArgument.js

@@ -1,5 +1,6 @@
-import { Tree } from "@weborigami/async-tree";
+import { Tree, isUnpackable } from "@weborigami/async-tree";
 import { isTreelike } from "@weborigami/async-tree/src/Tree.js";
+import { Scope } from "@weborigami/language";
 import assertScopeIsDefined from "./assertScopeIsDefined.js";
 
 /**
@@ -29,8 +30,17 @@ export default async function getTreeArgument(
   assertScopeIsDefined(scope);
 
   if (treelike !== undefined) {
+    if (isUnpackable(treelike)) {
+      treelike = await treelike.unpack();
+    }
     if (isTreelike(treelike)) {
-      return Tree.from(treelike);
+      let tree = Tree.from(treelike);
+      // If the tree was created from a treelike object and does not yet have a
+      // parent or scope, put it in the current scope.
+      if (!tree.parent && !(/** @type {any} */ (tree).scope)) {
+        tree = Scope.treeWithScope(tree, scope);
+      }
+      return tree;
     }
     throw new Error(
       `${methodName}: The first argument must be a tree, like an array, object, or files.`

package/src/misc/treeDot.js

@@ -78,7 +78,12 @@ async function statements(tree, nodePath, nodeLabel, options) {
     } else {
       const label = isStringLike(value)
         ? String(value)
-        : await serialize.toYaml(value);
+        : value != null
+        ? await serialize.toYaml(value)
+        : "";
+      if (value == null) {
+        isError = true;
+      }
       nodes[key] = { label };
       if (isError) {
         nodes[key].isError = true;

package/src/server/constructResponse.js

@@ -1,6 +1,7 @@
 import {
   SiteTree,
   Tree,
+  isPacked,
   isPlainObject,
   isStringLike,
 } from "@weborigami/async-tree";
@@ -30,8 +31,16 @@ export default async function constructResponse(request, resource) {
 
   // Determine media type, what data we'll send, and encoding.
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
-  const extension = extname(url.pathname).toLowerCase();
-  let mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+
+  let mediaType;
+  if (resource.mediaType) {
+    // Resource indicates its own media type.
+    mediaType = resource.mediaType;
+  } else {
+    // Infer expected media type from file extension on request URL.
+    const extension = extname(url.pathname).toLowerCase();
+    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+  }
 
   if (
     mediaType === undefined &&
@@ -50,12 +59,16 @@ export default async function constructResponse(request, resource) {
     });
   }
 
-  // If the request is for a JSON or YAML result, and the resource we got
-  // isn't yet a string or Buffer, convert the resource to JSON or YAML now.
+  if (!isPacked(resource) && typeof resource.pack === "function") {
+    resource = await resource.pack();
+  }
+
   if (
     (mediaType === "application/json" || mediaType === "text/yaml") &&
     !isStringLike(resource)
   ) {
+    // The request is for a JSON or YAML result, and the resource we got isn't
+    // yet a string or Buffer: convert the resource to JSON or YAML now.
     const tree = Tree.from(resource);
     resource =
       mediaType === "text/yaml"
@@ -92,7 +105,7 @@ export default async function constructResponse(request, resource) {
 
   // If we didn't get back some kind of data that response.write() accepts,
   // assume it was an error.
-  const validResponse = typeof body === "string" || body instanceof TypedArray;
+  const validResponse = isPacked(body);
   if (!validResponse) {
     const typeName = body?.constructor?.name ?? typeof body;
     console.error(

package/src/server/server.js

@@ -1,4 +1,4 @@
-import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
+import { DeepObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
 import { Scope, formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
@@ -50,15 +50,16 @@ function extendTreeScopeWithParams(tree, url) {
     return tree;
   }
 
-  const paramTree = new ObjectTree({
+  const paramTree = new DeepObjectTree({
     "@params": params,
   });
 
   // Create a new scope that includes search parameter tree.
-  const newScope = new Scope(paramTree, tree.parent);
+  const scope = Scope.getScope(tree);
+  const extendedScope = new Scope(paramTree, scope);
 
   // Create a new tree that extends the prototype chain of the supplied tree.
-  const extendedTree = Scope.treeWithScope(tree, newScope);
+  const extendedTree = Scope.treeWithScope(tree, extendedScope);
 
   return extendedTree;
 }

package/src/builtins/!.js

@@ -1,21 +0,0 @@
-/**
- * The `!` built-in returns `undefined`, and is intended for force function
- * invocation in the shell without requiring the use of parentheses. Parentheses
- * can't be used in the shell without quoting them, which is inconvenient.
- *
- * This parentheses form:
- *
- * ```
- * $ ori "fn1.js(fn2.js())"
- * ```
- *
- * Can be written as:
- *
- * ```
- * $ ori fn1.js fn2.js !
- * ```
- *
- * This forces the invocation of `fn2.js`, passing `undefined` as the argument.
- * The result of that invocation is then passed to `fn1.js`.
- */
-export default undefined;

package/src/builtins/@loaders/css.js

@@ -1,2 +0,0 @@
-// .css files use the .txt loader
-export { default } from "./txt.js";

package/src/builtins/@loaders/htm.js

@@ -1,2 +0,0 @@
-// .htm files use the .txt loader
-export { default } from "./txt.js";

package/src/builtins/@loaders/html.js

@@ -1,2 +0,0 @@
-// .html files use the .txt loader
-export { default } from "./txt.js";

package/src/builtins/@loaders/jpeg.js

@@ -1,55 +0,0 @@
-import exifParser from "exif-parser";
-
-const exifDateTags = [
-  "ModifyDate",
-  "MDPrepDate",
-  "DateTimeOriginal",
-  "CreateDate",
-  "PreviewDateTime",
-  "GPSDateStamp",
-];
-
-/**
- * Load Exif data from a JPEG file.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackJpeg(buffer, options) {
-  const parser = exifParser.create(buffer);
-  parser.enableTagNames(true);
-  parser.enableSimpleValues(true);
-  const parsed = await parser.parse();
-
-  // The exif-parser `enableSimpleValues` option should convert dates to
-  // JavaScript Date objects, but that doesn't seem to work. Ensure dates are
-  // Date objects.
-  const exif = parsed.tags;
-  for (const tag of exifDateTags) {
-    if (typeof exif[tag] === "number") {
-      exif[tag] = new Date(exif[tag] * 1000);
-    }
-  }
-
-  const result = {
-    height: parsed.imageSize.height,
-    width: parsed.imageSize.width,
-    exif,
-  };
-
-  // Promote some Exif properties to the top level.
-  const tagsToPromote = {
-    ImageDescription: "caption",
-    ModifyDate: "modified",
-    Orientation: "orientation",
-  };
-  for (const [tag, key] of Object.entries(tagsToPromote)) {
-    if (exif[tag] !== undefined) {
-      result[key] = exif[tag];
-    }
-  }
-
-  // Add aspect ratio for use with `aspect-ratio` CSS.
-  result.aspectRatio = result.width / result.height;
-
-  return result;
-}

package/src/builtins/@loaders/jpg.js

@@ -1,2 +0,0 @@
-// .jpg extension is a synonym for .jpeg
-export { default } from "./jpeg.js";

package/src/builtins/@loaders/js.js

@@ -1,14 +0,0 @@
-import processUnpackedContent from "../../common/processUnpackedContent.js";
-
-/**
- * Load a .js file as module's default export or exports.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackModule(input, options = {}) {
-  const { key, parent } = options;
-  if (parent && "import" in parent) {
-    const content = await /** @type {any} */ (parent).import?.(key);
-    return processUnpackedContent(content, parent);
-  }
-}

package/src/builtins/@loaders/json.js

@@ -1,14 +0,0 @@
-import * as utilities from "../../common/utilities.js";
-
-/**
- * Load a file as JSON.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default function unpackJson(input) {
-  const json = utilities.toString(input);
-  if (!json) {
-    throw new Error("Tried to parse something as JSON but it wasn't text.");
-  }
-  return JSON.parse(json);
-}

package/src/builtins/@loaders/md.js

@@ -1,2 +0,0 @@
-// .md files use the .txt loader
-export { default } from "./txt.js";

package/src/builtins/@loaders/mjs.js

@@ -1,2 +0,0 @@
-// .mjs files use the .js loader
-export { default } from "./js.js";

package/src/builtins/@loaders/ori.js

@@ -1,45 +0,0 @@
-import { Scope, compile, symbols } from "@weborigami/language";
-import processUnpackedContent from "../../common/processUnpackedContent.js";
-import * as utilities from "../../common/utilities.js";
-import builtins from "../@builtins.js";
-
-/**
- * Load and evaluate an Origami expression from a file.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackOrigamiExpression(
-  inputDocument,
-  options = {}
-) {
-  const attachedData = options.attachedData;
-  const parent =
-    options.parent ??
-    /** @type {any} */ (inputDocument).parent ??
-    /** @type {any} */ (inputDocument)[symbols.parent];
-
-  // Construct an object to represent the source code.
-  const sourceName = options.key;
-  let url;
-  if (sourceName && parent?.url) {
-    let parentHref = parent.url.href;
-    if (!parentHref.endsWith("/")) {
-      parentHref += "/";
-    }
-    url = new URL(sourceName, parentHref);
-  }
-
-  const source = {
-    text: utilities.toString(inputDocument),
-    name: options.key,
-    url,
-  };
-
-  // Compile the source code as an Origami expression and evaluate it.
-  const compiler = options.compiler ?? compile.expression;
-  const fn = compiler(source);
-  const parentScope = parent ? Scope.getScope(parent) : builtins;
-  let content = await fn.call(parentScope);
-
-  return processUnpackedContent(content, parent, attachedData);
-}

package/src/builtins/@loaders/txt.js

@@ -1,37 +0,0 @@
-import TextDocument from "../../common/TextDocument.js";
-import { evaluateYaml } from "../../common/serialize.js";
-import * as utilities from "../../common/utilities.js";
-
-/**
- * Load a file as text document with possible front matter.
- *
- * This process will parse out any YAML or JSON front matter and attach it to
- * the document as data. The first line of the text must be "---", followed by a
- * block of JSON or YAML, followed by another line of "---". Any lines following
- * will be treated as the document text.
- *
- * Any Origami expressions in the front matter will be evaluated and the results
- * incorporated into the document data.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackText(input, options = {}) {
-  const parent = options.parent ?? null;
-  const text = utilities.toString(input);
-  if (!text) {
-    throw new Error("Tried to treat something as text but it wasn't text.");
-  }
-  const regex =
-    /^(---\r?\n(?<frontText>[\s\S]*?\r?\n)---\r?\n)(?<body>[\s\S]*$)/;
-  const match = regex.exec(text);
-
-  const body = match?.groups?.body ?? text;
-
-  const frontData = match?.groups
-    ? await evaluateYaml(match.groups.frontText, parent)
-    : null;
-
-  const object = Object.assign({}, frontData, { "@text": body });
-
-  return new TextDocument(object, options.parent);
-}

package/src/builtins/@loaders/wasm.js

@@ -1,11 +0,0 @@
-import processUnpackedContent from "../../common/processUnpackedContent.js";
-
-/**
- * Load a .js file as module's default export or exports.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackWasm(buffer, options = {}) {
-  const wasmModule = await WebAssembly.instantiate(buffer);
-  return processUnpackedContent(wasmModule.instance.exports, options.parent);
-}

package/src/builtins/@loaders/xhtml.js

@@ -1,2 +0,0 @@
-// .xhtml files use the .txt loader
-export { default } from "./txt.js";

package/src/builtins/@loaders/yaml.js

@@ -1,23 +0,0 @@
-import * as YAMLModule from "yaml";
-import processUnpackedContent from "../../common/processUnpackedContent.js";
-import { evaluateYaml } from "../../common/serialize.js";
-import * as utilities from "../../common/utilities.js";
-
-// See notes at serialize.js
-// @ts-ignore
-const YAML = YAMLModule.default ?? YAMLModule.YAML;
-
-/**
- * Load a file as YAML.
- *
- * @type {import("@weborigami/language").FileUnpackFunction}
- */
-export default async function unpackYaml(input, options = {}) {
-  const parent = options.parent ?? null;
-  const yaml = utilities.toString(input);
-  if (!yaml) {
-    throw new Error("Tried to parse something as YAML but it wasn't text.");
-  }
-  const data = await evaluateYaml(yaml, options.parent);
-  return processUnpackedContent(data, parent);
-}

package/src/builtins/@loaders/yml.js

@@ -1,2 +0,0 @@
-// .yml extension is a synonym for .yaml
-export { default } from "./yaml.js";

package/src/common/TextDocument.js

@@ -1,58 +0,0 @@
-import { isStringLike } from "@weborigami/async-tree";
-import { symbols } from "@weborigami/language";
-import { toYaml } from "./serialize.js";
-import * as utilities from "./utilities.js";
-
-/**
- * A text document is any object with a `@text` property and a `toString()`
- * method that returns that text. This class is a helper for constructing such
- * text documents.
- */
-export default class TextDocument {
-  /**
-   * The `input` parameter can be anything that can be converted to a string.
-   * The optional `data` parameter can be any object; if the object is a plain
-   * object, its properties will be copied to the new document; otherwise, that
-   * parameter is ignored.
-   *
-   * @typedef {import("@weborigami/types").AsyncTree|null} AsyncTree
-   *
-   * @param {any} [data]
-   * @param {AsyncTree} [parent]
-   */
-  constructor(data, parent) {
-    Object.assign(this, data);
-    if (parent) {
-      this[symbols.parent] = parent;
-    }
-  }
-
-  static from(input, parent) {
-    if (input["@text"]) {
-      return input;
-    } else if (isStringLike(input)) {
-      const text = utilities.toString(input);
-      return new TextDocument({ "@text": text }, parent);
-    }
-  }
-
-  /**
-   * Render the text and data as a document with YAML front matter.
-   */
-  async pack() {
-    const text = this["@text"];
-    /** @type {any} */
-    const dataWithoutText = Object.assign({}, this);
-    delete dataWithoutText["@text"];
-    if (Object.keys(dataWithoutText).length > 0) {
-      const frontMatter = (await toYaml(dataWithoutText)).trimEnd();
-      return `---\n${frontMatter}\n---\n${text}`;
-    } else {
-      return text;
-    }
-  }
-
-  toString() {
-    return this["@text"];
-  }
-}