@weborigami/origami 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.2.7",
+  "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.7",
-    "@weborigami/language": "0.2.7",
-    "@weborigami/types": "0.2.7",
+    "@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/builtins.js

@@ -1,5 +1,4 @@
 import * as calc from "./calc/calc.js";
-import deprecated from "./deprecated.js";
 import * as dev from "./dev/dev.js";
 import * as handlers from "./handlers/handlers.js";
 import help from "./help/help.js";
@@ -46,9 +45,6 @@ export default {
 
   // Some builtins need to be exposed at top level
   ...handlers.default,
-
-  // Deprecated builtins
-  ...deprecated,
 };
 
 // Handle cases where a builtin name conflicts with a JS reserved word

package/src/handlers/oridocument.handler.js

@@ -40,6 +40,7 @@ export default {
     let text;
     let frontData = null;
     let frontSource = null;
+    let offset = 0;
     let extendedParent = parent;
     const parsed = parseFrontMatter(unpacked);
     if (!parsed) {
@@ -58,11 +59,21 @@ export default {
         extendedParent = new ObjectTree(frontData);
         extendedParent.parent = parent;
       }
+
+      // Determine how many lines the source code is offset by (if any) to
+      // account for front matter, plus 2 lines for `---` separators
+      offset = (frontText.match(/\r?\n/g) ?? []).length + 2;
+
       text = body;
     }
 
     // Construct an object to represent the source code
-    const bodySource = { name: key, text, url };
+    const bodySource = {
+      name: key,
+      offset,
+      text,
+      url,
+    };
 
     // Compile the source as an Origami template document
     const scopeCaching = frontSource ? false : true;

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/map.js

@@ -7,6 +7,7 @@ import {
 } from "@weborigami/async-tree";
 import getTreeArgument from "../common/getTreeArgument.js";
 import { toFunction } from "../common/utilities.js";
+import parseExtensions from "./parseExtensions.js";
 
 /**
  * Map a hierarchical tree of keys and values to a new tree of keys and values.
@@ -142,37 +143,3 @@ function extendKeyFn(keyFn) {
     return resultKey;
   };
 }
-
-/**
- * Given a string specifying an extension or a mapping of one extension to another,
- * return the source and result extensions.
- *
- * Syntax:
- *   foo
- *   foo→bar      Unicode Rightwards Arrow
- *   foo->bar     hyphen and greater-than sign
- *
- * @param {string} specifier
- */
-function parseExtensions(specifier) {
-  const lowercase = specifier?.toLowerCase() ?? "";
-  const extensionRegex =
-    /^((?<sourceExtension>\.?\S*)\s*(→|->)\s*(?<resultExtension>\.?\S*))|(?<extension>\.?\S*)$/;
-  const match = lowercase.match(extensionRegex);
-  if (!match) {
-    // Shouldn't happen because the regex is exhaustive.
-    throw new Error(`map: Invalid extension specifier "${specifier}".`);
-  }
-  // @ts-ignore
-  const { extension, resultExtension, sourceExtension } = match.groups;
-  if (extension) {
-    // foo
-    return {
-      resultExtension: extension,
-      sourceExtension: extension,
-    };
-  } else {
-    // foo→bar
-    return { resultExtension, sourceExtension };
-  }
-}

package/src/tree/parseExtensions.js

@@ -0,0 +1,44 @@
+/**
+ * Given a string specifying an extension or a mapping of one extension to another,
+ * return the source and result extensions.
+ *
+ * Syntax:
+ *   .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
+ */
+export default function parseExtensions(specifier) {
+  const lowercase = specifier?.toLowerCase() ?? "";
+  const extensionRegex =
+    /^((?<sourceExtension>\/|\.\S*)?\s*(→|->)\s*(?<resultExtension>\/|\.\S*)?)|(?<extension>\/|\.\S*)$/;
+  const match = lowercase.match(extensionRegex);
+  if (!match) {
+    throw new Error(`Invalid file extension specifier "${specifier}".`);
+  }
+
+  // @ts-ignore
+  let { extension, resultExtension, sourceExtension } = match.groups;
+  if (extension) {
+    // foo
+    return {
+      resultExtension: extension,
+      sourceExtension: extension,
+    };
+  } else {
+    // foo→bar
+
+    if (resultExtension === undefined && sourceExtension === undefined) {
+      throw new Error(
+        `A file extension mapping must indicate a source or result extension: "${specifier}".`
+      );
+    }
+
+    resultExtension ??= "";
+    sourceExtension ??= "";
+    return { resultExtension, sourceExtension };
+  }
+}

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/deprecated.js

@@ -1,140 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-import * as calc from "./calc/calc.js";
-import * as dev from "./dev/dev.js";
-import * as image from "./image/image.js";
-import js from "./js.js";
-import node from "./node.js";
-import * as origami from "./origami/origami.js";
-import files from "./protocols/files.js";
-import * as site from "./site/site.js";
-import * as text from "./text/text.js";
-import * as tree from "./tree/tree.js";
-
-const warningsDisplayedForKeys = new Set();
-
-export function command(namespace, newKey, oldKey, fn) {
-  const wrappedFn = function (...args) {
-    const keys = newKey
-      ? `"${namespace}${newKey}" or just "${newKey}"`
-      : `"${namespace}"`;
-    if (!warningsDisplayedForKeys.has(oldKey)) {
-      console.warn(
-        `ori: Warning: "${oldKey}" is deprecated. Use ${keys} instead.`
-      );
-      warningsDisplayedForKeys.add(oldKey);
-    }
-    return fn instanceof Function
-      ? // @ts-ignore
-        fn.call(this, ...args)
-      : Tree.traverseOrThrow(fn, ...args);
-  };
-  if (fn.key) {
-    wrappedFn.key = fn.key;
-  }
-  if (fn.inverseKey) {
-    wrappedFn.inverseKey = fn.inverseKey;
-  }
-  return wrappedFn;
-}
-
-export function commands(namespace, object) {
-  const deprecatedEntries = Object.entries(object).map(([key, fn]) => [
-    `@${fn.key ?? key}`,
-    command(namespace, fn.key ?? key, `@${fn.key ?? key}`, fn),
-  ]);
-  return Object.fromEntries(deprecatedEntries);
-}
-
-export default {
-  ...commands("calc:", calc),
-  ...commands("dev:", dev),
-  "@false": command("js:", "false", "@false", js.false),
-  "@fetch": command("js:", "fetch", "@fetch", js.fetch),
-  "@files": command("files:", null, "@files/", files),
-  "@image": command("image:", null, "@image/", image),
-  "@js": command("js:", null, "@js/", js),
-  "@math": command("calc:", null, "@math/", calc),
-  "@mdHtml": command("text:", "mdHtml", "@mdHtml", text.mdHtml),
-  "@node": command("node:", null, "@node/", node),
-  ...commands("origami:", origami),
-  ...commands("site:", site),
-  ...commands("text:", text),
-  ...commands("tree:", tree),
-  "@tree": command("tree:", null, "@tree/", Tree),
-  "@true": command("js:", "true", "@true", js.true),
-
-  // Renamed commands
-  "@clean": command("tree:", "clear", "@clean", tree.clear),
-
-  // Deprecated commands
-  "@deepTakeFn": command(
-    "tree:",
-    "deepTake",
-    "@deepTakeFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.deepTake.call(this, treelike, options);
-      }
-  ),
-  "@deepMapFn": command(
-    "tree:",
-    "deepMap",
-    "@deepMapFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.deepMap.call(this, treelike, options);
-      }
-  ),
-  "@groupFn": command(
-    "tree:",
-    "group",
-    "@groupFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.group.call(this, treelike, options);
-      }
-  ),
-  "@mapFn": command(
-    "tree:",
-    "map",
-    "@mapFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.map.call(this, treelike, options);
-      }
-  ),
-  "@paginateFn": command(
-    "tree:",
-    "paginate",
-    "@paginateFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.paginate.call(this, treelike, options);
-      }
-  ),
-  "@sortFn": command(
-    "tree:",
-    "sort",
-    "@sortFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.sort.call(this, treelike, options);
-      }
-  ),
-  "@takeFn": command(
-    "tree:",
-    "take",
-    "@takeFn",
-    (options) =>
-      /** @this {any} */
-      function (treelike) {
-        return tree.take.call(this, treelike, options);
-      }
-  ),
-};

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,159 +0,0 @@
-import {
-  cachedKeyFunctions,
-  isPlainObject,
-  keyFunctionsForExtensions,
-  map,
-} from "@weborigami/async-tree";
-import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
-import { toFunction } from "../common/utilities.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;
-  };
-}
-
-/**
- * Given a string specifying an extension or a mapping of one extension to another,
- * return the source and result extensions.
- *
- * Syntax:
- *   foo
- *   foo→bar      Unicode Rightwards Arrow
- *   foo->bar     hyphen and greater-than sign
- *
- * @param {string} specifier
- */
-function parseExtensions(specifier) {
-  const lowercase = specifier?.toLowerCase() ?? "";
-  const extensionRegex =
-    /^(\.?(?<sourceExtension>\S*)\s*(→|->)\s*\.?(?<resultExtension>\S*))|(\.?(?<extension>\S*))$/;
-  const match = lowercase.match(extensionRegex);
-  if (!match) {
-    // Shouldn't happen because the regex is exhaustive.
-    throw new Error(`@mapFn: Invalid extension specifier "${specifier}".`);
-  }
-  // @ts-ignore
-  const { extension, resultExtension, sourceExtension } = match.groups;
-  if (sourceExtension || resultExtension) {
-    // foo→bar
-    return { resultExtension, sourceExtension };
-  } else {
-    // foo
-    return {
-      resultExtension: specifier,
-      sourceExtension: specifier,
-    };
-  }
-}