npm - @weborigami/origami - Versions diffs - 0.0.48 → 0.0.50 - Mend

@weborigami/origami 0.0.48 → 0.0.50

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/exports/buildExports.js +2 -2
package/exports/exports.js +29 -13
package/index.ts +0 -3
package/package.json +10 -10
package/src/builtins/@addNextPrevious.js +58 -0
package/src/builtins/{@arrows.js → @arrowsMap.js} +7 -7
package/src/builtins/@changes.js +46 -0
package/src/builtins/@clean.js +19 -0
package/src/builtins/@constructor.js +17 -0
package/src/builtins/@crawl.js +2 -2
package/src/builtins/@debug.js +17 -19
package/src/builtins/@deepMap.js +19 -0
package/src/builtins/@deepMapFn.js +25 -0
package/src/builtins/{@mergeDeep.js → @deepMerge.js} +7 -7
package/src/builtins/@deepTake.js +21 -0
package/src/builtins/@deepTakeFn.js +22 -0
package/src/builtins/{@valuesDeep.js → @deepValues.js} +6 -5
package/src/builtins/@document.js +1 -2
package/src/builtins/@files.js +14 -1
package/src/builtins/@group.js +20 -0
package/src/builtins/@groupFn.js +30 -0
package/src/builtins/@if.js +2 -1
package/src/builtins/@image/format.js +10 -31
package/src/builtins/@image/formatFn.js +15 -0
package/src/builtins/@image/resize.js +7 -28
package/src/builtins/@image/resizeFn.js +14 -0
package/src/builtins/@inline.js +8 -2
package/src/builtins/@invoke.js +1 -1
package/src/builtins/@json.js +5 -1
package/src/builtins/@jsonParse.js +9 -0
package/src/builtins/@map.js +10 -170
package/src/builtins/@mapFn.js +143 -0
package/src/builtins/@mdHtml.js +2 -0
package/src/builtins/@mdTree.js +69 -0
package/src/builtins/@naturalOrder.js +1 -0
package/src/builtins/@ori.js +1 -1
package/src/builtins/@paginate.js +18 -0
package/src/builtins/@paginateFn.js +61 -0
package/src/builtins/@perf.js +1 -1
package/src/builtins/@redirect.js +10 -1
package/src/builtins/@regexParse.js +5 -0
package/src/builtins/@regexParseFn.js +9 -0
package/src/builtins/@rss.js +8 -4
package/src/builtins/@sitemap.js +4 -4
package/src/builtins/@slug.js +15 -0
package/src/builtins/@sort.js +10 -7
package/src/builtins/@sortFn.js +58 -0
package/src/builtins/@take.js +3 -17
package/src/builtins/@takeFn.js +21 -0
package/src/builtins/@tree.js +2 -14
package/src/builtins/@yaml.js +4 -0
package/src/builtins/@yamlParse.js +10 -0
package/src/builtins/map.d.ts +6 -7
package/src/common/ExplorableSiteTransform.js +16 -10
package/src/common/ShuffleTransform.js +3 -3
package/src/common/{arrowFunctionsMap.js → arrowsMapFn.js} +3 -3
package/src/common/documentObject.js +18 -9
package/src/common/serialize.js +1 -10
package/src/common/utilities.js +5 -2
package/src/misc/OriCommandTransform.js +2 -7
package/src/misc/explore.ori +7 -7
package/src/server/constructResponse.js +3 -9
package/src/server/server.js +5 -2
package/src/builtins/@apply.js +0 -6
package/src/builtins/@groupBy.js +0 -37
package/src/builtins/@isAsyncTree.js +0 -17
package/src/builtins/@mapDeep.js +0 -22
package/src/builtins/@new.js +0 -6
package/src/builtins/@parse/json.js +0 -6
package/src/builtins/@parse/yaml.js +0 -8
package/src/builtins/@sortBy.js +0 -37
package/src/builtins/@with.js +0 -22

package/src/builtins/@paginate.js ADDED Viewed

@@ -0,0 +1,18 @@
+import getTreeArgument from "../misc/getTreeArgument.js";
+import paginateFn from "./@paginateFn.js";
+/**
+ * Return a new grouping of the treelike's values into chunks of the specified
+ * size.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {AsyncTree|null}
+ * @param {Treelike} [treelike]
+ * @param {number} [size=10]
+ */
+export default async function paginate(treelike, size = 10) {
+  const tree = await getTreeArgument(this, arguments, treelike, "@count");
+  return paginateFn.call(this, size)(tree);
+}

package/src/builtins/@paginateFn.js ADDED Viewed

@@ -0,0 +1,61 @@
+import { Tree } from "@weborigami/async-tree";
+import { Scope } from "@weborigami/language";
+/**
+ * Return a new grouping of the treelike's values into "pages" of the specified
+ * size.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {AsyncTree|null}
+ * @param {number} [size=10]
+ */
+export default function paginateFn(size = 10) {
+  const scope = this;
+  /**
+   * @param {Treelike} [treelike]
+   */
+  return async function (treelike) {
+    const tree = Tree.from(treelike);
+    const keys = Array.from(await tree.keys());
+    const pageCount = Math.ceil(keys.length / size);
+    const result = {
+      async get(pageKey) {
+        // Note: page numbers are 1-based.
+        const pageNumber = Number(pageKey);
+        if (Number.isNaN(pageNumber)) {
+          return undefined;
+        }
+        const nextPage = pageNumber + 1 <= pageCount ? pageNumber + 1 : null;
+        const previousPage = pageNumber - 1 >= 1 ? pageNumber - 1 : null;
+        const items = {};
+        for (
+          let index = (pageNumber - 1) * size;
+          index < Math.min(keys.length, pageNumber * size);
+          index++
+        ) {
+          const key = keys[index];
+          items[key] = await tree.get(keys[index]);
+        }
+        return {
+          items,
+          nextPage,
+          pageCount,
+          pageNumber,
+          previousPage,
+        };
+      },
+      async keys() {
+        // Return an array from 1..totalPages
+        return Array.from({ length: pageCount }, (_, index) => index + 1);
+      },
+    };
+    const scoped = Scope.treeWithScope(result, scope);
+    return scoped;
+  };
+}

package/src/builtins/@perf.js CHANGED Viewed

@@ -7,7 +7,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @this {import("@weborigami/types").AsyncTree|null}
  * @param {Function} fn
  */
-export default async function perf(fn, count = 10000) {
+export default async function perf(fn, count = 1) {
   assertScopeIsDefined(this, "perf");
   const start = performance.now();
   for (let i = 0; i < count; i++) {

package/src/builtins/@redirect.js CHANGED Viewed

@@ -1,8 +1,17 @@
 export default function redirect(url, options = { permanent: false }) {
-  return new Response("ok", {
+  const response = new Response("ok", {
     headers: {
       Location: url,
     },
     status: options.permanent ? 301 : 307,
   });
+  /** @type {any} */ (response).pack = () => `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="refresh" content="0;url=${url}" />
+  </head>
+</html>
+`;
+  return response;
 }

package/src/builtins/@regexParse.js ADDED Viewed

@@ -0,0 +1,5 @@
+import regexParser from "./@regexParseFn.js";
+export default function regexParse(text, regex) {
+  return regexParser(regex)(text);
+}

package/src/builtins/@regexParseFn.js ADDED Viewed

@@ -0,0 +1,9 @@
+const parsers = {};
+export default function regexParseFn(text) {
+  if (!parsers[text]) {
+    const regexp = new RegExp(text);
+    parsers[text] = (input) => input.match(regexp)?.groups;
+  }
+  return parsers[text];
+}

package/src/builtins/@rss.js CHANGED Viewed

@@ -24,7 +24,7 @@ export default async function rss(jsonFeedTree) {
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <atom:link href="${rssUrl}" rel="self" type="application/rss+xml"/>
-    <title>${title}</title>
+    <title><![CDATA[${title}]]></title>
     <link>${home_page_url}</link>
     <description>${description}</description>
 ${itemsRss}</channel>
@@ -33,15 +33,19 @@ ${itemsRss}</channel>
 function itemRss(jsonFeedItem) {
   const { content_html, date_published, id, title, url } = jsonFeedItem;
-  // RSS wants dates in RFC-822.
-  const date = date_published?.toUTCString() ?? null;
+  // RSS wants dates in RFC-822, essentially the same as ISO 8601.
+  const date =
+    date_published instanceof Date
+      ? date_published.toUTCString()
+      : date_published;
   const dateElement = date ? `      <pubDate>${date}</pubDate>\n` : "";
   const guidElement = id ? `      <guid>${id}</guid>\n` : "";
   const contentElement = content_html
     ? `      <description><![CDATA[${content_html}]]></description>\n`
     : "";
+  const titleElement = `<![CDATA[${title}]]>`;
   return `    <item>
-${dateElement}      <title>${title}</title>
+${dateElement}      <title>${titleElement}</title>
       <link>${url}</link>
 ${guidElement}${contentElement}    </item>
 `;

package/src/builtins/@sitemap.js CHANGED Viewed

@@ -3,13 +3,13 @@ import builtins from "./@builtins.js";
 import paths from "./@paths.js";
 import fileTypeOrigami from "./ori_handler.js";
-const templateText = `=\`<?xml version="1.0" encoding="UTF-8"?>
+const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-\${ @map(=\`
+\${ @map(urls, (url) => \`
   <url>
-    <loc>\${ _ }</loc>
+    <loc>\${ url }</loc>
   </url>
-\`)(_) }
+\`) }
 </urlset>
 \`
 `;

package/src/builtins/@slug.js ADDED Viewed

@@ -0,0 +1,15 @@
+export default function slug(filename) {
+  let slug = filename.toLowerCase();
+  // Convert spaces to dashes
+  slug = slug.replace(/\s+/g, "-");
+  // Remove special characters except dashes, letters, numbers, and periods.
+  slug = slug.replace(/[^\w\-\.]/g, "");
+  // Trim leading or trailing dashes.
+  slug = slug.replace(/^-+/, "");
+  slug = slug.replace(/-+$/, "");
+  return slug;
+}

package/src/builtins/@sort.js CHANGED Viewed

@@ -1,20 +1,23 @@
-import { sortNatural } from "@weborigami/async-tree";
 import getTreeArgument from "../misc/getTreeArgument.js";
+import sortFn from "./@sortFn.js";
 /**
- * Return a new tree with the original's keys sorted in natural sort order.
+ * Return a new tree with the original's keys sorted.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("../../index.ts").Invocable} Invocable
+ * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
+ * @typedef {{ compare?: (a: any, b: any) => number, sortKey?: ValueKeyFn }}
+ * SortOptions
  *
  * @this {AsyncTree|null}
  * @param {Treelike} [treelike]
+ * @param {ValueKeyFn|SortOptions} [options]
  */
-export default async function sort(treelike) {
+export default async function sortBuiltin(treelike, options) {
   const tree = await getTreeArgument(this, arguments, treelike, "@sort");
-  return sortNatural()(tree);
+  return sortFn.call(this, options)(tree);
 }
-sort.usage = `@sort <tree>\tReturn a new tree with the original's keys sorted`;
-sort.documentation = "https://weborigami.org/cli/builtins.html#@sort";
+sortBuiltin.usage = `@sort <tree>, [options]\tReturn a new tree with the original's keys sorted`;
+sortBuiltin.documentation = "https://weborigami.org/builtins/@sort.html";

package/src/builtins/@sortFn.js ADDED Viewed

@@ -0,0 +1,58 @@
+import { sortFn } from "@weborigami/async-tree";
+import { Scope } from "@weborigami/language";
+import { toFunction } from "../common/utilities.js";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+/**
+ * Return a transform function that sorts a tree's keys using a comparison
+ * function.
+ *
+ * If the `options` include a `sortKey` function, that will be invoked for each
+ * key in the tree to produce a sort key. If no `sortKey` function is provided,
+ * the original keys will be used as sort keys.
+ *
+ * If the `options` include a `compare` function, that will be used to compare
+ * sort keys.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
+ * @typedef {{ compare?: (a: any, b: any) => number, sortKey?: ValueKeyFn }}
+ * SortOptions
+ *
+ * @this {AsyncTree|null}
+ * @param {ValueKeyFn|SortOptions} [options]
+ */
+export default function sortFnBuiltin(options) {
+  assertScopeIsDefined(this);
+  const scope = this;
+  if (typeof options === "function") {
+    // Take the function as the `sortKey` option
+    options = { sortKey: options };
+  }
+  const compare = options?.compare;
+  let extendedSortKeyFn;
+  if (options?.sortKey) {
+    const originalSortKey = toFunction(options?.sortKey);
+    extendedSortKeyFn = async (key, tree) => {
+      const value = await tree.get(key);
+      const sortKey = await originalSortKey.call(scope, value, key);
+      return sortKey;
+    };
+  }
+  const fn = sortFn({
+    compare,
+    sortKey: extendedSortKeyFn,
+  });
+  return (treelike) => {
+    const sorted = fn(treelike);
+    const scoped = Scope.treeWithScope(sorted, scope);
+    return scoped;
+  };
+}
+sortFnBuiltin.usage = `@sortFn [sortFn]\tReturn a function that sorts a tree`;
+sortFnBuiltin.documentation = "https://weborigami.org/builtins/@sortFn.html";

package/src/builtins/@take.js CHANGED Viewed

@@ -1,33 +1,19 @@
-import { Scope } from "@weborigami/language";
 import getTreeArgument from "../misc/getTreeArgument.js";
+import takeFn from "./@takeFn.js";
 /**
  * Given a tree, take the first n items from it.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
  * @this {AsyncTree|null}
  * @param {Treelike} treelike
  * @param {number} n
  */
 export default async function take(treelike, n) {
   const tree = await getTreeArgument(this, arguments, treelike, "@take");
-  /** @type {AsyncTree} */
-  let takeTree = {
-    async keys() {
-      const keys = Array.from(await tree.keys());
-      return keys.slice(0, n);
-    },
-    async get(key) {
-      return tree.get(key);
-    },
-  };
-  takeTree = Scope.treeWithScope(takeTree, this);
-  return takeTree;
+  return takeFn.call(this, n)(tree);
 }
 take.usage = `@take tree, n\tReturn the first n items from tree`;

package/src/builtins/@takeFn.js ADDED Viewed

@@ -0,0 +1,21 @@
+import { takeFn } from "@weborigami/async-tree";
+import { Scope } from "@weborigami/language";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+/**
+ * Limit the number of keys to the indicated count.
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {number} count
+ */
+export default function takeFnBuiltin(count) {
+  assertScopeIsDefined(this, "takeFn");
+  const scope = this;
+  return (treelike) => {
+    const taken = takeFn(count)(treelike);
+    const scoped = Scope.treeWithScope(taken, scope);
+    return scoped;
+  };
+}

package/src/builtins/@tree.js CHANGED Viewed

@@ -1,16 +1,4 @@
-import getTreeArgument from "../misc/getTreeArgument.js";
 /**
- * Cast the indicated treelike to a tree.
- *
- * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @this {AsyncTree|null}
- * @param {Treelike} [treelike]
+ * Tree utilities functions
  */
-export default async function tree(treelike) {
-  return getTreeArgument(this, arguments, treelike, "@tree");
-}
-tree.usage = `@tree <treelike>\tConvert JSON, YAML, function, or plain object to a tree`;
-tree.documentation = "https://weborigami.org/cli/builtins.html#tree";
+export { Tree as default } from "@weborigami/async-tree";

package/src/builtins/@yaml.js CHANGED Viewed

@@ -1,4 +1,5 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
+import { isUnpackable } from "@weborigami/async-tree";
 import YAML from "yaml";
 import * as serialize from "../common/serialize.js";
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
@@ -21,6 +22,9 @@ export default async function toYaml(obj) {
   if (obj === undefined) {
     return undefined;
   }
+  if (isUnpackable(obj)) {
+    obj = await obj.unpack();
+  }
   const value = await serialize.toJsonValue(obj);
   return YAML.stringify(value);
 }

package/src/builtins/@yamlParse.js ADDED Viewed

@@ -0,0 +1,10 @@
+import * as serialize from "../common/serialize.js";
+import { toString } from "../common/utilities.js";
+export default async function yamlParse(input) {
+  const text = toString(input);
+  return text ? serialize.parseYaml(text) : undefined;
+}
+yamlParse.usage = `@yamlParse <text>\tParse text as YAML`;
+yamlParse.documentation = "https://weborigami.org/builtins/@yamlParse.html";

package/src/builtins/map.d.ts CHANGED Viewed

@@ -1,17 +1,16 @@
-import { KeyFn, Treelike, ValueKeyFn } from "@weborigami/async-tree";
+import { KeyFn, Treelike, TreeTransform, ValueKeyFn } from "@weborigami/async-tree";
 import { AsyncTree } from "@weborigami/types";
-import { TreelikeTransform } from "../../index.ts";
 type TreeMapOptions = {
   deep?: boolean;
   description?: string;
-  extensions?: string;
+  extension?: string;
   inverseKey?: KeyFn;
   key?: ValueKeyFn;
+  needsSourceValue?: boolean;
   value?: ValueKeyFn;
 };
-export default function treeMap(value: ValueKeyFn): TreelikeTransform;
-export default function treeMap(options: TreeMapOptions): TreelikeTransform;
-export default function treeMap(treelike: Treelike, value: ValueKeyFn): AsyncTree;
-export default function treeMap(treelike: Treelike, options: TreeMapOptions): AsyncTree;
+export default function treeMap(options: ValueKeyFn | TreeMapOptions): TreeTransform;
+export default function treeMap(treelike: Treelike, options: ValueKeyFn | TreeMapOptions): AsyncTree;
+export default function treeMap(param1: Treelike | ValueKeyFn | TreeMapOptions, param2?: ValueKeyFn | TreeMapOptions): AsyncTree | TreeTransform;

package/src/common/ExplorableSiteTransform.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import { Tree, keysJson } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import index from "../builtins/@index.js";
-import { transformObject } from "../common/utilities.js";
+import { isTransformApplied, transformObject } from "../common/utilities.js";
 /**
  * Wraps a tree (typically a SiteTree) to turn a standard site into an
@@ -33,10 +33,10 @@ export default function ExplorableSiteTransform(Base) {
       // Ask the tree if it has the key.
       let value = await super.get(key);
+      const scope = Scope.getScope(this);
       if (value === undefined) {
         // The tree doesn't have the key; try the defaults.
-        const scope = Scope.getScope(this);
         if (scope) {
           if (key === "index.html") {
             value = await index.call(scope, this);
@@ -46,15 +46,19 @@ export default function ExplorableSiteTransform(Base) {
         }
       }
-      // Ensure this transform is applied to any explorable result. This lets
-      // the user browse into data and explorable trees of types other than the
-      // current class.
       if (Tree.isAsyncTree(value)) {
-        value = transformObject(ExplorableSiteTransform, value);
-      }
+        // Ensure this transform is applied to any tree result so the user
+        // browse into data and trees of classes other than the current class.
+        if (!isTransformApplied(ExplorableSiteTransform, value)) {
+          value = transformObject(ExplorableSiteTransform, value);
+        }
-      if (value?.unpack) {
-        // If the value isn't a tree, but has a tree attached via a `unpack`
+        if (key.endsWith?.("/")) {
+          // Instead of return the tree directly, return an index for it.
+          value = await index.call(scope, value);
+        }
+      } else if (value?.unpack) {
+        // If the value isn't a tree, but has a tree attached via an `unpack`
         // method, wrap the unpack method to add this transform.
         const original = value.unpack.bind(value);
         value.unpack = async () => {
@@ -68,7 +72,9 @@ export default function ExplorableSiteTransform(Base) {
             const scope = Scope.getScope(this);
             tree = Scope.treeWithScope(tree, scope);
           }
-          tree = transformObject(ExplorableSiteTransform, tree);
+          if (!isTransformApplied(ExplorableSiteTransform, tree)) {
+            tree = transformObject(ExplorableSiteTransform, tree);
+          }
           return tree;
         };
       }

package/src/common/ShuffleTransform.js CHANGED Viewed

@@ -19,10 +19,10 @@ export default function ShuffleTransform(Base) {
  * Performs a Fisher-Yates shuffle. From http://sedition.com/perl/javascript-fy.html
  */
 function shuffle(array) {
-  var i = array.length;
+  let i = array.length;
   while (--i >= 0) {
-    var j = Math.floor(Math.random() * (i + 1));
-    var temp = array[i];
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = array[i];
     array[i] = array[j];
     array[j] = temp;
   }

package/src/common/{arrowFunctionsMap.js → arrowsMapFn.js} RENAMED Viewed

@@ -1,9 +1,9 @@
-import { cachedKeyFunctions, map } from "@weborigami/async-tree";
+import { cachedKeyFunctions, mapFn } from "@weborigami/async-tree";
 import { toFunction } from "./utilities.js";
-export default function arrowFunctionsMap() {
+export default function arrowsMapFn() {
   const deep = true;
-  return map({
+  return mapFn({
     deep,
     description: "arrowFunctions",
     value: valueFn,

package/src/common/documentObject.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { isPlainObject } from "@weborigami/async-tree";
-import txtHandler from "../builtins/txt_handler.js";
+import { isPlainObject, isUnpackable } 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
@@ -12,9 +12,15 @@ import txtHandler from "../builtins/txt_handler.js";
  * @param {StringLike|PlainObject} input
  * @param {any} [data]
  */
-export default function documentObject(input, data) {
+export default async function documentObject(input, data) {
   let text;
   let inputData;
+  if (isUnpackable(input)) {
+    // Unpack the input first, might already be a document object.
+    input = await input.unpack();
+  }
   if (isPlainObject(input)) {
     text = input["@text"];
     inputData = input;
@@ -22,12 +28,15 @@ export default function documentObject(input, data) {
     text = String(input);
     inputData = null;
   }
-  const base = {
-    pack() {
-      return txtHandler.pack(this);
-    },
-  };
-  const result = Object.create(base);
+  // TODO: Either restore this code, or move responsibility for packing a
+  // document to HandleExtensionsTransform set().
+  // const base = {
+  //   pack() {
+  //     return txtHandler.pack(this);
+  //   },
+  // };
+  // const result = Object.create(base);
+  const result = {};
   Object.assign(result, inputData, data, { "@text": text });
   return result;
 }

package/src/common/serialize.js CHANGED Viewed

@@ -5,12 +5,7 @@
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
-import {
-  Tree,
-  isPlainObject,
-  isStringLike,
-  isUnpackable,
-} from "@weborigami/async-tree";
+import { Tree, isPlainObject, isStringLike } from "@weborigami/async-tree";
 import { OrigamiTree } from "@weborigami/language";
 import * as YAMLModule from "yaml";
 import yamlOrigamiTag from "../misc/yamlOrigamiTag.js";
@@ -145,10 +140,6 @@ export async function toValue(input, jsonValuesOnly = false) {
     } 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)) {

package/src/common/utilities.js CHANGED Viewed

@@ -45,10 +45,13 @@ export const keySymbol = Symbol("key");
  * @param {string} resultExtension
  */
 export function replaceExtension(key, sourceExtension, resultExtension) {
-  if (!key.endsWith(sourceExtension)) {
+  if (!key) {
+    return undefined;
+  } else if (!key.endsWith(sourceExtension)) {
     return key;
+  } else {
+    return key.slice(0, -sourceExtension.length) + resultExtension;
   }
-  return key.slice(0, -sourceExtension.length) + resultExtension;
 }
 /**

package/src/misc/OriCommandTransform.js CHANGED Viewed

@@ -1,8 +1,8 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectTree } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import ori from "../builtins/@ori.js";
-import { keySymbol, transformObject } from "../common/utilities.js";
+import { keySymbol } from "../common/utilities.js";
 /**
  * Add support for commands prefixed with `!`.
@@ -34,11 +34,6 @@ export default function OriCommandTransform(Base) {
         const extendedScope = new Scope(ambientsTree, Scope.getScope(this));
         const source = key.slice(1).trim();
         value = await ori.call(extendedScope, source, { formatResult: false });
-        // Ensure this transform is applied to any subtree.
-        if (Tree.isAsyncTree(value)) {
-          value = transformObject(OriCommandTransform, value);
-        }
       }
       return value;

package/src/misc/explore.ori CHANGED Viewed

@@ -1,4 +1,4 @@
-=`<!DOCTYPE html>
+(scope) => `<!DOCTYPE html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
@@ -16,16 +16,16 @@
       <button id="buttonSVG">SVG</button>
       <button id="buttonYAML">YAML</button>
     </div>
-    {{ @map(=`
+    ${ @map(scope, (scopeTree) => `
       <ul>
-        <h2>${ _/name }</h2>
-        {{ @map(=`
+        <h2>${ scopeTree/name }</h2>
+        ${ @map(scopeTree/keys, (key) => `
         <li>
-          <a href="./!@explore/${ _ }" target="frame">${ _ }</a>
+          <a href="./!@explore/${ key }" target="frame">${ key }</a>
         </li>
-        `)(_/keys) }}
+        `) }
       </ul>
-    `)(_) }}
+    `) }
     </nav>
     <iframe id="frame" name="frame"></iframe>
   </body>