@weborigami/origami 0.0.45 → 0.0.47

package/src/builtins/@mkdir.js

@@ -0,0 +1,3 @@
+// For now this is a synonym for @files.
+// If we like it, it might replace @files.
+export { default } from "./@files.js";

package/src/builtins/@node.js

@@ -7,7 +7,8 @@ import url from "node:url";
 const patchedProcess = Object.create(null, {
   ...Object.getOwnPropertyDescriptors(process),
   env: {
-    value: function () {
+    enumerable: true,
+    get: function () {
       return Object.assign({}, process.env);
     },
   },

package/src/builtins/@project.js

@@ -2,17 +2,18 @@
 import { OrigamiFiles, Scope } from "@weborigami/language";
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 import builtins from "./@builtins.js";
+import fileTypeOrigami from "./ori_handler.js";
 
-const configFileName = "ori.config.js";
+const configFileName = "config.ori";
 
 /**
  * Return the tree for the current project's root folder.
  *
- * This searches the current directory and its ancestors for an Origami
- * configuration file. If an Origami configuration file is found, the containing
- * folder is considered to be the project root. This returns a tree for that
- * folder, with the exported configuration as the context for that folder — that
- * is, the tree exported by the configuration will be the scope.
+ * This searches the current directory and its ancestors for an Origami file
+ * called `config.ori`. If an Origami configuration file is found, the
+ * containing folder is considered to be the project root. This returns a tree
+ * for that folder, with the exported configuration as the context for that
+ * folder — that is, the tree exported by the configuration will be the scope.
  *
  * If no Origami configuration file is found, the current folder will be
  * returned as a tree, with the builtins as its parent.
@@ -25,24 +26,31 @@ export default async function project(key) {
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
-  let projectTree = await findConfigContainer(currentTree);
+  let containerTree = await findConfigContainer(currentTree);
 
   let config;
-  if (projectTree) {
+  if (containerTree) {
     // Load the configuration.
-    config = await projectTree.import(configFileName);
+    const configParent = Scope.treeWithScope(containerTree, builtins);
+    const buffer = await configParent.get(configFileName);
+    config = await fileTypeOrigami.unpack(buffer, {
+      key: configFileName,
+      parent: configParent,
+    });
     if (!config) {
+      const configPath = /** @type {any} */ (configParent).path;
       throw new Error(
-        `Couldn't load the Origami configuration in ${projectTree.path}`
+        `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
       );
     }
   } else {
-    projectTree = currentTree;
-    config = builtins;
+    containerTree = currentTree;
+    config = null;
   }
 
   // Add the configuration as the context for the project root.
-  const result = Scope.treeWithScope(projectTree, config);
+  const scope = new Scope(config, builtins);
+  const result = Scope.treeWithScope(containerTree, scope);
   return key === undefined ? result : result.get(key);
 }
 
@@ -67,5 +75,5 @@ async function findConfigContainer(start) {
   return undefined;
 }
 
-project.usage = `@project\tThe root of the current Tree Origami project`;
+project.usage = `@project\tThe root of the current Origami project`;
 project.documentation = "https://weborigami.org/language/@project.html";

package/src/builtins/@shuffle.js

@@ -1,4 +1,3 @@
-import { Scope } from "@weborigami/language";
 import ShuffleTransform from "../common/ShuffleTransform.js";
 import { transformObject } from "../common/utilities.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
@@ -14,11 +13,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  */
 export default async function shuffle(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@shuffle");
-
-  /** @type {AsyncTree} */
-  let shuffled = transformObject(ShuffleTransform, tree);
-  shuffled = Scope.treeWithScope(shuffled, this);
-  return shuffled;
+  return transformObject(ShuffleTransform, tree);
 }
 
 shuffle.usage = `@shuffle <tree>\tReturn a new tree with the original's keys shuffled`;

package/src/builtins/@sitemap.js

@@ -1,7 +1,7 @@
 import getTreeArgument from "../misc/getTreeArgument.js";
 import builtins from "./@builtins.js";
-import unpackOrigamiExpression from "./@loaders/ori.js";
 import paths from "./@paths.js";
+import fileTypeOrigami from "./ori_handler.js";
 
 const templateText = `=\`<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
@@ -48,7 +48,7 @@ export default async function sitemap(treelike, baseHref = "") {
     .filter((path) => path.endsWith(".html"))
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
-  const templateFn = await unpackOrigamiExpression(templateText);
+  const templateFn = await fileTypeOrigami.unpack(templateText);
   const templateResult = await templateFn.call(builtins, htmlPaths);
   return String(templateResult);
 }

package/src/builtins/@sort.js

@@ -1,5 +1,4 @@
 import { sortNatural } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
@@ -14,9 +13,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  */
 export default async function sort(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@sort");
-  const sorted = sortNatural()(tree);
-  const scoped = Scope.treeWithScope(sorted, this);
-  return scoped;
+  return sortNatural()(tree);
 }
 
 sort.usage = `@sort <tree>\tReturn a new tree with the original's keys sorted`;

package/src/builtins/@static.js

@@ -1,5 +1,4 @@
 import { Tree, keysJson } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import { transformObject } from "../common/utilities.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 import index from "./@index.js";
@@ -14,8 +13,7 @@ import index from "./@index.js";
  */
 export default async function staticTree(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@static");
-  let result = transformObject(StaticTransform, tree);
-  result = Scope.treeWithScope(result, this);
+  const result = transformObject(StaticTransform, tree);
   return result;
 }
 

package/src/builtins/@tree.js

@@ -1,4 +1,3 @@
-import { Scope } from "@weborigami/language";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
@@ -10,9 +9,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  * @param {Treelike} [treelike]
  */
 export default async function tree(treelike) {
-  let tree = await getTreeArgument(this, arguments, treelike, "@tree");
-  tree = Scope.treeWithScope(tree, this);
-  return tree;
+  return getTreeArgument(this, arguments, treelike, "@tree");
 }
 
 tree.usage = `@tree <treelike>\tConvert JSON, YAML, function, or plain object to a tree`;

package/src/builtins/@yaml.js

@@ -21,9 +21,6 @@ export default async function toYaml(obj) {
   if (obj === undefined) {
     return undefined;
   }
-  if (typeof obj.unpack === "function") {
-    obj = await obj.unpack();
-  }
   const value = await serialize.toJsonValue(obj);
   return YAML.stringify(value);
 }

package/src/builtins/css_handler.js

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

package/src/builtins/htm_handler.js

@@ -0,0 +1,2 @@
+// .htm is a synonynm for .html
+export { default } from "./html_handler.js";

package/src/builtins/html_handler.js

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

package/src/builtins/jpeg_handler.js

@@ -0,0 +1,58 @@
+import exifParser from "exif-parser";
+
+const exifDateTags = [
+  "ModifyDate",
+  "MDPrepDate",
+  "DateTimeOriginal",
+  "CreateDate",
+  "PreviewDateTime",
+  "GPSDateStamp",
+];
+
+/**
+ * A JPEG file with possible Exif metadata
+ */
+export default {
+  mediaType: "image/jpeg",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, options) {
+    const parser = exifParser.create(packed);
+    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/jpg_handler.js

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

package/src/builtins/js_handler.js

@@ -0,0 +1,20 @@
+import processUnpackedContent from "../common/processUnpackedContent.js";
+
+/**
+ * A JavaScript file
+ *
+ * Unpacking a JavaScript file returns its default export, or its set of exports
+ * if there is more than one.
+ */
+export default {
+  mediaType: "application/javascript",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, 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/json_handler.js

@@ -0,0 +1,19 @@
+import * as utilities from "../common/utilities.js";
+
+/**
+ * A JSON file
+ *
+ * Unpacking a JSON file returns the parsed data.
+ */
+export default {
+  mediaType: "application/json",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  unpack(packed) {
+    const json = utilities.toString(packed);
+    if (!json) {
+      throw new Error("Tried to parse something as JSON but it wasn't text.");
+    }
+    return JSON.parse(json);
+  },
+};

package/src/builtins/map.d.ts

@@ -6,12 +6,12 @@ type TreeMapOptions = {
   deep?: boolean;
   description?: string;
   extensions?: string;
-  inverseKeyMap?: KeyFn;
-  keyMap?: ValueKeyFn;
-  valueMap?: ValueKeyFn;
+  inverseKey?: KeyFn;
+  key?: ValueKeyFn;
+  value?: ValueKeyFn;
 };
 
-export default function treeMap(valueMap: ValueKeyFn): TreelikeTransform;
+export default function treeMap(value: ValueKeyFn): TreelikeTransform;
 export default function treeMap(options: TreeMapOptions): TreelikeTransform;
-export default function treeMap(treelike: Treelike, valueMap: ValueKeyFn): AsyncTree;
+export default function treeMap(treelike: Treelike, value: ValueKeyFn): AsyncTree;
 export default function treeMap(treelike: Treelike, options: TreeMapOptions): AsyncTree;

package/src/builtins/md_handler.js

@@ -0,0 +1,7 @@
+// .md files use the .txt loader
+import fileTypeText from "./txt_handler.js";
+
+export default {
+  ...fileTypeText,
+  mediaType: "text/markdown",
+};

package/src/builtins/mjs_handler.js

@@ -0,0 +1,2 @@
+// .mjs is a synonynm for .js
+export { default } from "./js_handler.js";

package/src/builtins/ori_handler.js

@@ -0,0 +1,48 @@
+import { symbols } from "@weborigami/async-tree";
+import { Scope, compile } from "@weborigami/language";
+import processUnpackedContent from "../common/processUnpackedContent.js";
+import * as utilities from "../common/utilities.js";
+import builtins from "./@builtins.js";
+
+/**
+ * An Origami expression file
+ *
+ * Unpacking an Origami file returns the result of evaluating the expression.
+ */
+export default {
+  mediaType: "text/plain",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, options = {}) {
+    const attachedData = options.attachedData;
+    const parent =
+      options.parent ??
+      /** @type {any} */ (packed).parent ??
+      /** @type {any} */ (packed)[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(packed),
+      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/txt_handler.js

@@ -0,0 +1,78 @@
+import { isPacked, symbols } from "@weborigami/async-tree";
+import { evaluateYaml, toYaml } from "../common/serialize.js";
+import * as utilities from "../common/utilities.js";
+
+/**
+ * A text file with possible front matter
+ *
+ * The unpacking 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.
+ *
+ * If there is no front matter, the document will be treated as plain text and
+ * returned as a String object.
+ *
+ * If there is front matter, any Origami expressions in the front matter will be
+ * evaluated. The result will be a plain JavaScript object with the evaluated
+ * data and a `@text` property containing the document text.
+ */
+export default {
+  mediaType: "text/plain",
+
+  /**
+   * If the input is already in some packed format, it will be returned as is.
+   *
+   * Otherwise, the properties of the object will be formatted as YAML. If the
+   * object has a `@text` property, that will be used as the body of the text
+   * document; otherwise, an empty string will be used.
+   *
+   * @param {any} object
+   * @returns {Promise<import("@weborigami/async-tree").Packed>}
+   */
+  async pack(object) {
+    if (isPacked(object)) {
+      return object;
+    } else if (!object || typeof object !== "object") {
+      throw new TypeError("The input to pack must be a JavaScript object.");
+    }
+
+    const text = object["@text"] ?? "";
+
+    /** @type {any} */
+    const dataWithoutText = Object.assign({}, object);
+    delete dataWithoutText["@text"];
+    if (Object.keys(dataWithoutText).length > 0) {
+      const frontMatter = (await toYaml(dataWithoutText)).trimEnd();
+      return `---\n${frontMatter}\n---\n${text}`;
+    } else {
+      return text;
+    }
+  },
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, options = {}) {
+    const parent = options.parent ?? null;
+    const text = utilities.toString(packed);
+    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);
+    let unpacked;
+    if (match) {
+      // Document object with front matter
+      const { body, frontText } = /** @type {any} */ (match.groups);
+      const frontData = await evaluateYaml(frontText, parent);
+      unpacked = Object.assign({}, frontData, { "@text": body });
+    } else {
+      // Plain text
+      unpacked = new String(text);
+    }
+
+    unpacked[symbols.parent] = parent;
+    return unpacked;
+  },
+};

package/src/builtins/wasm_handler.js

@@ -0,0 +1,17 @@
+import processUnpackedContent from "../common/processUnpackedContent.js";
+
+/**
+ * A WebAssembly module
+ *
+ * Unpacking a WebAssembly module returns its exports.
+ */
+export default {
+  mediaType: "application/wasm",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, options = {}) {
+    const wasmModule = await WebAssembly.instantiate(packed);
+    // @ts-ignore TypeScript thinks wasmModule is already an Instance.
+    return processUnpackedContent(wasmModule.instance.exports, options.parent);
+  },
+};

package/src/builtins/xhtml_handler.js

@@ -0,0 +1,2 @@
+// .xhtml is a synonynm for .html
+export { default } from "./html_handler.js";

package/src/builtins/yaml_handler.js

@@ -0,0 +1,29 @@
+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;
+
+/**
+ * A YAML file
+ *
+ * Unpacking a YAML file returns the parsed data.
+ *
+ */
+export default {
+  mediaType: "application/yaml",
+
+  /** @type {import("@weborigami/language").UnpackFunction} */
+  async unpack(packed, options = {}) {
+    const parent = options.parent ?? null;
+    const yaml = utilities.toString(packed);
+    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/yml_handler.js

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

package/src/common/ExplorableSiteTransform.js

@@ -59,11 +59,15 @@ export default function ExplorableSiteTransform(Base) {
         const original = value.unpack.bind(value);
         value.unpack = async () => {
           const content = await original();
-          if (!Tree.isTreelike(content)) {
+          if (!Tree.isTraversable(content)) {
             return content;
           }
           /** @type {any} */
           let tree = Tree.from(content);
+          if (!tree.parent && !tree.scope) {
+            const scope = Scope.getScope(this);
+            tree = Scope.treeWithScope(tree, scope);
+          }
           tree = transformObject(ExplorableSiteTransform, tree);
           return tree;
         };

package/src/common/addValueKeyToScope.js

@@ -1,3 +1,4 @@
+import { ObjectTree } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 
 /**
@@ -14,9 +15,9 @@ import { Scope } from "@weborigami/language";
  */
 export default function addValueKeyToScope(scope, value, key) {
   // Add the key and value to the scope as ambients.
-  const ambients = {
+  const ambients = new ObjectTree({
     "@key": key,
     _: value,
-  };
+  });
   return new Scope(ambients, scope);
 }

package/src/common/arrowFunctionsMap.js

@@ -1,4 +1,4 @@
-import { cachedKeyMaps, map } from "@weborigami/async-tree";
+import { cachedKeyFunctions, map } from "@weborigami/async-tree";
 import { toFunction } from "./utilities.js";
 
 export default function arrowFunctionsMap() {
@@ -6,12 +6,12 @@ export default function arrowFunctionsMap() {
   return map({
     deep,
     description: "arrowFunctions",
-    valueMap,
-    ...cachedKeyMaps(keyMap, deep),
+    value: valueFn,
+    ...cachedKeyFunctions(keyFn, deep),
   });
 }
 
-function keyMap(sourceKey, tree) {
+function keyFn(sourceKey, tree) {
   return parseArrowKey(sourceKey) ?? sourceKey;
 }
 
@@ -23,7 +23,7 @@ function parseArrowKey(sourceKey) {
   return match?.groups.lhs;
 }
 
-function valueMap(sourceValue, sourceKey, tree) {
+function valueFn(sourceValue, sourceKey, tree) {
   let resultValue;
   if (parseArrowKey(sourceKey)) {
     // Treat the value as a function to be invoked.

package/src/common/documentObject.js

@@ -0,0 +1,33 @@
+import { isPlainObject } from "@weborigami/async-tree";
+import txtHandler from "../builtins/txt_handler.js";
+
+/**
+ * In Origami, a text document object is any object with a `@text` property and
+ * a pack() method that formats that object as text with YAML front matter. This
+ * function is a helper for constructing such text document objects.
+ *
+ * @typedef {import("@weborigami/async-tree").StringLike} StringLike
+ * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
+ *
+ * @param {StringLike|PlainObject} input
+ * @param {any} [data]
+ */
+export default function documentObject(input, data) {
+  let text;
+  let inputData;
+  if (isPlainObject(input)) {
+    text = input["@text"];
+    inputData = input;
+  } else {
+    text = String(input);
+    inputData = null;
+  }
+  const base = {
+    pack() {
+      return txtHandler.pack(this);
+    },
+  };
+  const result = Object.create(base);
+  Object.assign(result, inputData, data, { "@text": text });
+  return result;
+}

package/src/common/serialize.d.ts

@@ -5,4 +5,5 @@ export function evaluateYaml(text: string, parent?: AsyncTree|null): Promise<Jso
 export function parseYaml(text: string): JsonValue|AsyncTree;
 export function toJson(obj: JsonValue | AsyncTree): Promise<string>;
 export function toJsonValue(obj: any): Promise<JsonValue>;
+export function toValue(obj: any, jsonValuesOnly?: boolean): Promise<JsonValue>;
 export function toYaml(obj: JsonValue | AsyncTree): Promise<string>;