@weborigami/origami 0.2.8 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,22 +13,22 @@
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.10.2",
-    "typescript": "5.7.2"
+    "@types/node": "22.13.5",
+    "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.8",
-    "@weborigami/language": "0.2.8",
-    "@weborigami/types": "0.2.8",
+    "@weborigami/async-tree": "0.2.9",
+    "@weborigami/language": "0.2.9",
+    "@weborigami/types": "0.2.9",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
-    "highlight.js": "11.11.0",
-    "marked": "15.0.4",
+    "highlight.js": "11.11.1",
+    "marked": "15.0.7",
     "marked-gfm-heading-id": "4.1.1",
     "marked-highlight": "2.2.1",
     "marked-smartypants": "1.1.9",
     "sharp": "0.33.5",
-    "yaml": "2.6.1"
+    "yaml": "2.7.0"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/src/image/resize.js

@@ -1,5 +1,5 @@
+import sharp from "sharp";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import imageResizeFn from "./resizeFn.js";
 
 /**
  * Resize an image.
@@ -10,5 +10,7 @@ import imageResizeFn from "./resizeFn.js";
  */
 export default async function resize(input, options) {
   assertTreeIsDefined(this, "image:resize");
-  return imageResizeFn.call(this, options)(input);
+  return input instanceof Uint8Array || input instanceof ArrayBuffer
+    ? sharp(input).rotate().resize(options).toBuffer()
+    : undefined;
 }

package/src/origami/regexMatch.js

@@ -1,5 +1,9 @@
-import regexMatchFn from "./regexMatchFn.js";
+const parsers = {};
 
 export default function regexMatch(text, regex) {
-  return regexMatchFn(regex)(text);
+  if (!parsers[regex]) {
+    const regexp = new RegExp(regex);
+    parsers[regex] = (input) => input.match(regexp)?.groups;
+  }
+  return parsers[regex](text);
 }

package/src/site/index.js

@@ -8,8 +8,9 @@ import { getDescriptor } from "../common/utilities.js";
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @this {AsyncTree|null}
  * @param {Treelike} [treelike]
+ * @param {string} [basePath]
  */
-export default async function index(treelike) {
+export default async function index(treelike, basePath) {
   const tree = await getTreeArgument(this, arguments, treelike, "site:index");
   const keys = Array.from(await tree.keys());
 
@@ -21,8 +22,9 @@ export default async function index(treelike) {
   const links = [];
   for (const key of filtered) {
     const keyText = String(key);
+    const path = basePath ? [basePath, keyText].join("/") : keyText;
     // Simple key.
-    const link = `      <li><a href="${keyText}">${keyText}</a></li>`;
+    const link = `      <li><a href="${path}">${keyText}</a></li>`;
     links.push(link);
   }
 

package/src/tree/parseExtensions.js

@@ -6,6 +6,7 @@
  *   .foo           source and result extension are the same
  *   .foo→.bar      Unicode Rightwards Arrow
  *   .foo→          Unicode Rightwards Arrow, no result extension
+ *   →.bar          Unicode Rightwards Arrow, no source extension
  *   .foo->.bar     hyphen and greater-than sign
  *
  * @param {string} specifier

package/src/tree/shuffle.js

@@ -1,6 +1,4 @@
 import getTreeArgument from "../common/getTreeArgument.js";
-import { transformObject } from "../common/utilities.js";
-import { default as ShuffleTransform, shuffle } from "./ShuffleTransform.js";
 
 /**
  * Return a new tree with the original's keys shuffled
@@ -10,8 +8,9 @@ import { default as ShuffleTransform, shuffle } from "./ShuffleTransform.js";
  *
  * @this {AsyncTree|null}
  * @param {Treelike} [treelike]
+ * @param {boolean} [reshuffle]
  */
-export default async function shuffleTree(treelike) {
+export default async function shuffleTree(treelike, reshuffle = false) {
   // Special case: If the treelike is an array, shuffle it directly. Otherwise
   // we'll end up shuffling the array's indexes, and if this is directly
   // displayed by the ori CLI, this will end up creating a plain object. Even
@@ -23,6 +22,36 @@ export default async function shuffleTree(treelike) {
     shuffle(array);
     return array;
   }
+
   const tree = await getTreeArgument(this, arguments, treelike, "tree:shuffle");
-  return transformObject(ShuffleTransform, tree);
+
+  let keys;
+  return {
+    async get(key) {
+      return tree.get(key);
+    },
+
+    async keys() {
+      if (!keys || reshuffle) {
+        keys = Array.from(await tree.keys());
+        shuffle(keys);
+      }
+      return keys;
+    },
+  };
+}
+
+/*
+ * Shuffle an array.
+ *
+ * Performs a Fisher-Yates shuffle. From http://sedition.com/perl/javascript-fy.html
+ */
+export function shuffle(array) {
+  let i = array.length;
+  while (--i >= 0) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
 }

package/src/image/resizeFn.js

@@ -1,17 +0,0 @@
-import sharp from "sharp";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-
-/**
- * Return a function that resizes an image.
- *
- * @this {import("@weborigami/types").AsyncTree|null}
- * @param {import("sharp").ResizeOptions} options
- */
-export default function imageResizeFn(options) {
-  assertTreeIsDefined(this, "image/resizeFn");
-  // Include `rotate()` to auto-rotate according to EXIF data.
-  return (buffer) =>
-    buffer instanceof Uint8Array || buffer instanceof ArrayBuffer
-      ? sharp(buffer).rotate().resize(options).toBuffer()
-      : undefined;
-}

package/src/origami/regexMatchFn.js

@@ -1,9 +0,0 @@
-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/tree/ShuffleTransform.js

@@ -1,29 +0,0 @@
-/**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("../../index.ts").Constructor<AsyncTree>} AsyncTreeConstructor
- * @param {AsyncTreeConstructor} Base
- */
-export default function ShuffleTransform(Base) {
-  return class Shuffle extends Base {
-    async keys() {
-      const keys = Array.from(await super.keys());
-      shuffle(keys);
-      return keys;
-    }
-  };
-}
-
-/*
- * Shuffle an array.
- *
- * Performs a Fisher-Yates shuffle. From http://sedition.com/perl/javascript-fy.html
- */
-export function shuffle(array) {
-  let i = array.length;
-  while (--i >= 0) {
-    const j = Math.floor(Math.random() * (i + 1));
-    const temp = array[i];
-    array[i] = array[j];
-    array[j] = temp;
-  }
-}

package/src/tree/mapFn.js

@@ -1,126 +0,0 @@
-import {
-  cachedKeyFunctions,
-  isPlainObject,
-  keyFunctionsForExtensions,
-  map,
-} from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import { toFunction } from "../common/utilities.js";
-import parseExtensions from "./parseExtensions.js";
-
-/**
- * Return a function that transforms a tree of keys and values to a new tree of
- * keys and values.
- *
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
- * @typedef {import("@weborigami/async-tree").Treelike} Treelike
- * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
- * @typedef {import("./map.js").TreeMapOptions} TreeMapOptions
- *
- * @this {AsyncTree|null}
- * @param {ValueKeyFn|TreeMapOptions} operation
- */
-export default function mapFnBuiltin(operation) {
-  assertTreeIsDefined(this, "map");
-  const tree = this;
-
-  // Identify whether the map instructions take the form of a value function or
-  // a dictionary of options.
-  /** @type {TreeMapOptions} */
-  let options;
-  /** @type {ValueKeyFn|undefined} */
-  let valueFn;
-  if (isPlainObject(operation)) {
-    // @ts-ignore
-    options = operation;
-    if (`value` in options && !options.value) {
-      throw new TypeError(`@mapFn: The value function is not defined.`);
-    }
-    valueFn = options?.value;
-  } else if (
-    typeof operation === "function" ||
-    typeof (/** @type {any} */ (operation)?.unpack) === "function"
-  ) {
-    valueFn = operation;
-    options = {};
-  } else {
-    throw new TypeError(
-      `@mapFn: You must specify a value function or options dictionary as the first parameter.`
-    );
-  }
-
-  const { deep, extension, needsSourceValue } = options;
-  const description = options.description ?? `@mapFn ${extension ?? ""}`;
-  const keyFn = options.key;
-  const inverseKeyFn = options.inverseKey;
-
-  if (extension && (keyFn || inverseKeyFn)) {
-    throw new TypeError(
-      `@mapFn: You can't specify extensions and also a key or inverseKey function`
-    );
-  }
-
-  let extendedValueFn;
-  if (valueFn) {
-    const resolvedValueFn = toFunction(valueFn);
-    // Have the value function run in this tree.
-    extendedValueFn = resolvedValueFn.bind(tree);
-  }
-
-  // Extend the key functions to run in this tree.
-  let extendedKeyFn;
-  let extendedInverseKeyFn;
-  if (extension) {
-    let { resultExtension, sourceExtension } = parseExtensions(extension);
-    const keyFns = keyFunctionsForExtensions({
-      resultExtension,
-      sourceExtension,
-    });
-    extendedKeyFn = keyFns.key;
-    extendedInverseKeyFn = keyFns.inverseKey;
-  } else if (keyFn) {
-    const resolvedKeyFn = toFunction(keyFn);
-    async function scopedKeyFn(sourceKey, sourceTree) {
-      const sourceValue = await sourceTree.get(sourceKey);
-      // The key function will be given the source tree, but will run with the
-      // scope of this tree.
-      const resultKey = await resolvedKeyFn.call(
-        tree,
-        sourceValue,
-        sourceKey,
-        sourceTree
-      );
-      return resultKey;
-    }
-    const keyFns = cachedKeyFunctions(scopedKeyFn, deep);
-    extendedKeyFn = keyFns.key;
-    extendedInverseKeyFn = keyFns.inverseKey;
-  } else {
-    // Use sidecar keyFn/inverseKey functions if the valueFn defines them.
-    extendedKeyFn = /** @type {any} */ (valueFn)?.key;
-    extendedInverseKeyFn = /** @type {any} */ (valueFn)?.inverseKey;
-  }
-
-  // const fn = mapFn({
-  //   deep,
-  //   description,
-  //   inverseKey: extendedInverseKeyFn,
-  //   key: extendedKeyFn,
-  //   needsSourceValue,
-  //   value: extendedValueFn,
-  // });
-  const temp = {
-    deep,
-    description,
-    inverseKey: extendedInverseKeyFn,
-    key: extendedKeyFn,
-    needsSourceValue,
-    value: extendedValueFn,
-  };
-
-  return (treelike) => {
-    const mapped = map(treelike, temp);
-    mapped.parent = tree;
-    return mapped;
-  };
-}