@weborigami/origami 0.0.65 → 0.0.66-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.65",
+  "version": "0.0.66-beta.1",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
     "typescript": "5.5.4"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.65",
-    "@weborigami/language": "0.0.65",
-    "@weborigami/types": "0.0.65",
+    "@weborigami/async-tree": "0.0.66-beta.1",
+    "@weborigami/language": "0.0.66-beta.1",
+    "@weborigami/types": "0.0.66-beta.1",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.10.0",

package/src/builtins/@cache.js

@@ -19,7 +19,9 @@ export default async function cacheBuiltin(
 ) {
   assertTreeIsDefined(this, "cache");
   /** @type {any} */
-  const cacheTree = cacheTreelike ? Tree.from(cacheTreelike) : undefined;
+  const cacheTree = cacheTreelike
+    ? Tree.from(cacheTreelike, { parent: this })
+    : undefined;
   const result = cache(sourceTreelike, cacheTree, filterTreelike);
   return result;
 }

package/src/builtins/@changes.js

@@ -1,10 +1,18 @@
 import { Tree } from "@weborigami/async-tree";
 
-// Given an old tree and a new tree, return a tree of changes indicated
-// by the values: "added", "changed", or "deleted".
+/**
+ * Given an old tree and a new tree, return a tree of changes indicated
+ * by the values: "added", "changed", or "deleted".
+ *
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {Treelike} oldTreelike
+ * @param {Treelike} newTreelike
+ */
 export default async function changes(oldTreelike, newTreelike) {
-  const oldTree = Tree.from(oldTreelike, { deep: true });
-  const newTree = Tree.from(newTreelike, { deep: true });
+  const oldTree = Tree.from(oldTreelike, { deep: true, parent: this });
+  const newTree = Tree.from(newTreelike, { deep: true, parent: this });
 
   const oldKeys = Array.from(await oldTree.keys());
   const newKeys = Array.from(await newTree.keys());
@@ -21,7 +29,7 @@ export default async function changes(oldTreelike, newTreelike) {
     const newValue = await newTree.get(key);
 
     if (Tree.isAsyncTree(oldValue) && Tree.isAsyncTree(newValue)) {
-      const treeChanges = await changes(oldValue, newValue);
+      const treeChanges = await changes.call(this, oldValue, newValue);
       if (Object.keys(treeChanges).length > 0) {
         result[key] = treeChanges;
       }

package/src/builtins/@concat.js

@@ -12,7 +12,7 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  */
 export default async function concat(...args) {
   assertTreeIsDefined(this, "concat");
-  const tree = args.length === 0 ? this : Tree.from(args);
+  const tree = args.length === 0 ? this : Tree.from(args, { parent: this });
   return ops.concat.call(this, tree);
 }
 

package/src/builtins/@copy.js

@@ -16,8 +16,8 @@ import setDeep from "./@setDeep.js";
 export default async function copy(source, target) {
   assertTreeIsDefined(this, "copy");
   // const start = performance.now();
-  const sourceTree = Tree.from(source);
-  /** @type {any} */ let targetTree = Tree.from(target);
+  const sourceTree = Tree.from(source, { parent: this });
+  /** @type {any} */ let targetTree = Tree.from(target, { parent: this });
 
   if (stdout.isTTY) {
     targetTree = transformObject(ProgressTransform, targetTree);
@@ -26,7 +26,7 @@ export default async function copy(source, target) {
     countCopied = 0;
   }
 
-  await setDeep(targetTree, sourceTree);
+  await setDeep.call(this, targetTree, sourceTree);
 
   if (stdout.isTTY) {
     process.stdout.clearLine(0);

package/src/builtins/@crawl.js

@@ -34,7 +34,7 @@ export default async function crawl(treelike, baseHref) {
   const tree =
     typeof treelike === "string"
       ? treeHttps.call(this, treelike)
-      : Tree.from(treelike);
+      : Tree.from(treelike, { parent: this });
 
   if (baseHref === undefined) {
     // Ask tree or original treelike if it has an `href` property we can use as

package/src/builtins/@debug.js

@@ -41,10 +41,7 @@ function DebugTransform(Base) {
       // Since this transform is for diagnostic purposes, cast any treelike
       // result to a tree so we can debug the result too.
       if (Tree.isTreelike(value)) {
-        value = Tree.from(value);
-        if (!value.parent) {
-          value.parent = parent;
-        }
+        value = Tree.from(value, { parent });
         if (!isTransformApplied(DebugTransform, value)) {
           value = transformObject(DebugTransform, value);
         }
@@ -58,10 +55,7 @@ function DebugTransform(Base) {
             return content;
           }
           /** @type {any} */
-          let tree = Tree.from(content);
-          if (!tree.parent) {
-            tree.parent = parent;
-          }
+          let tree = Tree.from(content, { parent });
           if (!isTransformApplied(DebugTransform, tree)) {
             tree = transformObject(DebugTransform, tree);
           }

package/src/builtins/@filter.js

@@ -1,3 +1,4 @@
+import { Tree } from "@weborigami/async-tree";
 import FilterTree from "../common/FilterTree.js";
 import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
@@ -7,12 +8,15 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param {Treelike} filterVariant
+ * @param {Treelike} sourceTreelike
+ * @param {Treelike} filterTreelike
  */
-export default async function filter(treelike, filterVariant) {
+export default async function filter(sourceTreelike, filterTreelike) {
   assertTreeIsDefined(this, "filter");
-  const result = new FilterTree(treelike, filterVariant);
+  const sourceTree = Tree.from(sourceTreelike, { parent: this });
+  const filterTree = Tree.from(filterTreelike, { deep: true, parent: this });
+  const result = new FilterTree(sourceTree, filterTree);
+  result.parent = this;
   return result;
 }
 

package/src/builtins/@jsonKeys.js

@@ -28,7 +28,7 @@ function KeysJsonTransform(Base) {
       if (value === undefined && key === ".keys.json") {
         value = await jsonKeys.stringify(this);
       } else if (Tree.isTreelike(value)) {
-        const tree = Tree.from(value, { deep: true });
+        const tree = Tree.from(value, { deep: true, parent: this });
         value = transformObject(KeysJsonTransform, tree);
       }
       return value;

package/src/builtins/@mdHtml.js

@@ -38,7 +38,7 @@ marked.use(
  * @param {StringLike|UnpackableStringlike} input
  */
 export default async function mdHtml(input) {
-  if (!input) {
+  if (input == null) {
     const error = new TypeError("@mdHtml: The input is not defined.");
     /** @type {any} */ (error).position = 0;
     throw error;

package/src/builtins/@paginateFn.js

@@ -11,11 +11,13 @@ import { Tree } from "@weborigami/async-tree";
  * @param {number} [size=10]
  */
 export default function paginateFn(size = 10) {
+  const parent = this;
+
   /**
    * @param {Treelike} [treelike]
    */
   return async function (treelike) {
-    const tree = Tree.from(treelike);
+    const tree = Tree.from(treelike, { parent });
     const keys = Array.from(await tree.keys());
     const pageCount = Math.ceil(keys.length / size);
 

package/src/builtins/@serve.js

@@ -25,7 +25,7 @@ export default async function serve(treelike, port) {
   assertTreeIsDefined(this, "serve");
   let tree;
   if (treelike) {
-    tree = Tree.from(treelike);
+    tree = Tree.from(treelike, { parent: this });
 
     // TODO: Instead of applying ExplorableSiteTransform, apply a transform
     // that just maps the empty string to index.html.

package/src/builtins/@setDeep.js

@@ -1,8 +1,15 @@
 import { Tree } from "@weborigami/async-tree";
 
+/**
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {Treelike} target
+ * @param {Treelike} source
+ */
 export default async function setDeep(target, source) {
-  const targetTree = Tree.from(target);
-  const sourceTree = Tree.from(source);
+  const targetTree = Tree.from(target, { parent: this });
+  const sourceTree = Tree.from(source, { parent: this });
   await applyUpdates(sourceTree, targetTree);
 }
 

package/src/builtins/@static.js

@@ -14,6 +14,7 @@ import index from "./@index.js";
 export default async function staticTree(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@static");
   const result = transformObject(StaticTransform, tree);
+  result.parent = this;
   return result;
 }
 
@@ -22,11 +23,12 @@ function StaticTransform(Base) {
     async get(key) {
       let value = await super.get(key);
       if (value === undefined && key === "index.html") {
-        value = index.call(this, this);
+        value = await index.call(this, this);
       } else if (value === undefined && key === ".keys.json") {
-        value = jsonKeys.stringify(this);
-      } else if (Tree.isAsyncTree(value)) {
-        value = transformObject(StaticTransform, value);
+        value = await jsonKeys.stringify(this);
+      } else if (Tree.isTreelike(value)) {
+        const tree = Tree.from(value, { parent: this });
+        value = transformObject(StaticTransform, tree);
       }
       return value;
     }

package/src/builtins/@watch.js

@@ -42,16 +42,16 @@ export default async function watch(treelike, fn) {
   return handle;
 }
 
-async function evaluateTree(container, fn) {
+async function evaluateTree(parent, fn) {
   let tree;
   let message;
   let result;
   try {
-    result = await fn.call(container);
+    result = await fn.call(parent);
   } catch (error) {
     message = messageForError(error);
   }
-  tree = result ? Tree.from(result) : undefined;
+  tree = result ? Tree.from(result, { parent }) : undefined;
   if (tree) {
     return tree;
   }
@@ -60,7 +60,7 @@ async function evaluateTree(container, fn) {
   }
   console.warn(message);
   tree = new ConstantTree(message);
-  tree.parent = container;
+  tree.parent = parent;
   return tree;
 }
 

package/src/common/FilterTree.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, Tree, isPlainObject } from "@weborigami/async-tree";
+import { Tree } from "@weborigami/async-tree";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -7,9 +7,8 @@ import { DeepObjectTree, Tree, isPlainObject } from "@weborigami/async-tree";
 export default class FilterTree {
   constructor(tree, filter) {
     this.tree = Tree.from(tree);
-    this.filter = isPlainObject(filter)
-      ? new DeepObjectTree(filter)
-      : Tree.from(filter);
+    this.filter = Tree.from(filter, { deep: true });
+    this.parent = null;
   }
 
   async get(key) {
@@ -50,12 +49,12 @@ export default class FilterTree {
     // Also include any keys in the filter that are found in the tree. This
     // lets the filter "pull" values from a tree that, e.g., is defined by a
     // function without an explicit domain.
-    for (const key of await this.filter.keys()) {
-      const value = await this.tree.get(key);
-      if (value !== undefined) {
-        keys.add(key);
-      }
-    }
+    // for (const key of await this.filter.keys()) {
+    //   const value = await this.tree.get(key);
+    //   if (value !== undefined) {
+    //     keys.add(key);
+    //   }
+    // }
 
     return keys;
   }