@weborigami/origami 0.2.11 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.2.11",
+  "version": "0.3.0",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,10 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.2.11",
-    "@weborigami/language": "0.2.11",
-    "@weborigami/types": "0.2.11",
+    "@weborigami/async-tree": "0.3.0",
+    "@weborigami/language": "0.3.0",
+    "@weborigami/json-feed-to-rss": "1.0.0",
+    "@weborigami/types": "0.3.0",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.1",

package/src/handlers/csv.handler.js

@@ -0,0 +1,126 @@
+import { symbols, toString } from "@weborigami/async-tree";
+
+export default {
+  mediaType: "text/csv",
+
+  unpack(packed, options = {}) {
+    const parent = options.parent ?? null;
+    const text = toString(packed);
+    const data = csvParse(text);
+    // Define `parent` as non-enumerable property
+    Object.defineProperty(data, symbols.parent, {
+      configurable: true,
+      enumerable: false,
+      value: parent,
+      writable: true,
+    });
+    return data;
+  },
+};
+
+/**
+ * Parse text as CSV following RFC 4180
+ *
+ * This assumes the presence of a header row, and accepts both CRLF and LF line
+ * endings.
+ *
+ * @param {string} text
+ * @returns {any[]}
+ */
+function csvParse(text) {
+  const rows = [];
+  let currentRow = [];
+  let currentField = "";
+
+  const pushField = () => {
+    // Push the completed field and reset for the next field.
+    currentRow.push(currentField);
+    currentField = "";
+  };
+
+  const pushRow = () => {
+    // Push the row if there is at least one field (accounts for potential trailing newline)
+    rows.push(currentRow);
+    currentRow = [];
+  };
+
+  // Main state machine
+  let i = 0;
+  let inQuotes = false;
+  while (i < text.length) {
+    const char = text[i];
+
+    if (inQuotes) {
+      // In a quoted field
+      if (char === '"') {
+        // Check if next character is also a quote
+        if (i + 1 < text.length && text[i + 1] === '"') {
+          // Append a literal double quote and skip the next character
+          currentField += '"';
+          i += 2;
+          continue;
+        } else {
+          // End of the quoted field
+          inQuotes = false;
+          i++;
+          continue;
+        }
+      } else {
+        // All other characters within quotes are taken literally.
+        currentField += char;
+        i++;
+        continue;
+      }
+    } else if (char === '"') {
+      // Start of a quoted field
+      inQuotes = true;
+      i++;
+      continue;
+    } else if (char === ",") {
+      // End of field
+      pushField();
+      i++;
+      continue;
+    } else if (char === "\n" || (char === "\r" && text[i + 1] === "\n")) {
+      // End of row: push the last field, then row.
+      pushField();
+      pushRow();
+      if (char === "\r" && text[i + 1] === "\n") {
+        i++; // Handle CRLF line endings
+      }
+      i++;
+      continue;
+    } else {
+      // Regular character
+      currentField += char;
+      i++;
+      continue;
+    }
+  }
+
+  // Handle any remaining data after the loop.
+  // This will capture the last field/row if the text did not end with a newline.
+  if (inQuotes) {
+    // Mismatched quotes: you might choose to throw an error or handle it gracefully.
+    throw new Error("CSV parsing error: unmatched quote in the input.");
+  }
+  if (currentField !== "" || text.at(-1) === ",") {
+    pushField();
+  }
+  if (currentRow.length > 0) {
+    pushRow();
+  }
+
+  // The first row is assumed to be the header.
+  if (rows.length === 0) {
+    return [];
+  }
+
+  const header = rows.shift();
+
+  const data = rows.map((row) =>
+    Object.fromEntries(row.map((value, index) => [header[index], value]))
+  );
+
+  return data;
+}

package/src/handlers/handlers.js

@@ -6,6 +6,7 @@ import {
   yamlHandler,
 } from "../internal.js";
 import cssHandler from "./css.handler.js";
+import csvHandler from "./csv.handler.js";
 import htmHandler from "./htm.handler.js";
 import htmlHandler from "./html.handler.js";
 import jpegHandler from "./jpeg.handler.js";
@@ -19,6 +20,7 @@ import ymlHandler from "./yml.handler.js";
 
 export default {
   "css.handler": cssHandler,
+  "csv.handler": csvHandler,
   "htm.handler": htmHandler,
   "html.handler": htmlHandler,
   "jpeg.handler": jpegHandler,

package/src/help/help.yaml

@@ -302,8 +302,8 @@ tree:
       args: (tree)
       description: The tree's [key, value] pairs
     filter:
-      args: (source, filter)
-      description: Filter the source tree using the filter tree
+      args: (source, options)
+      description: Filter the source tree
     first:
       args: (tree)
       description: The first value in the tree
@@ -352,6 +352,9 @@ tree:
     mapReduce:
       args: (tree, valueFn, reduceFn)
       description: Map values and reduce them
+    mask:
+      args: (source, mask)
+      description: Return the source tree with only the keys in the mask
     match:
       args: (pattern, fn, [keys])
       description: Matches simple patterns or regular expressions

package/src/origami/csv.js

@@ -0,0 +1,58 @@
+import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+
+/**
+ * Render the object as text in CSV format.
+ *
+ * The object should a treelike object such as an array. The output will include
+ * a header row with field names taken from the first item in the tree/array.
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {any} [object]
+ */
+export default async function csv(object) {
+  assertTreeIsDefined(this, "origami:csv");
+  if (isUnpackable(object)) {
+    object = await object.unpack();
+  }
+  const value = await toPlainValue(object);
+  const text = formatCsv(value);
+  return text;
+}
+
+function formatCsv(array) {
+  if (!array || array.length === 0) {
+    return "";
+  }
+
+  // Helper to quote field if necessary
+  const formatField = (value) => {
+    // Convert value to string.
+    let field = String(value);
+
+    // RFC 4180: Quote field if it contains a comma, a CR/LF, or a double quote
+    if (field.search(/("|,|\n|\r)/) !== -1) {
+      // Escape existing double quotes by replacing " with ""
+      field = field.replace(/"/g, '""');
+      // Surround the field with quotes
+      field = `"${field}"`;
+    }
+    return field;
+  };
+
+  // Extract header fields from the first object.
+  const headerFields = Object.keys(array[0]);
+
+  // Generate the header row by formatting each header field.
+  const headerRow = headerFields.map(formatField).join(",");
+
+  // Map through each object and generate a CSV row.
+  const dataRows = array.map((row) => {
+    return headerFields
+      .map((field) => formatField(row[field] !== undefined ? row[field] : ""))
+      .join(",");
+  });
+
+  // Concatenate header and data rows, joining and ending with CRLF.
+  return [headerRow, ...dataRows].join("\r\n") + "\r\n";
+}

package/src/origami/origami.js

@@ -9,6 +9,7 @@ export { toFunction } from "../common/utilities.js";
 export { default as help } from "../help/help.js"; // Alias
 export { default as basename } from "./basename.js";
 export { default as config } from "./config.js";
+export { default as csv } from "./csv.js";
 export { default as json } from "./json.js";
 export { default as jsonParse } from "./jsonParse.js";
 export { default as naturalOrder } from "./naturalOrder.js";

package/src/site/rss.js

@@ -1,22 +1,7 @@
 import { Tree } from "@weborigami/async-tree";
+import jsonFeedToRss from "@weborigami/json-feed-to-rss";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
-const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-const months = [
-  "Jan",
-  "Feb",
-  "Mar",
-  "Apr",
-  "May",
-  "Jun",
-  "Jul",
-  "Aug",
-  "Sep",
-  "Oct",
-  "Nov",
-  "Dec",
-];
-
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
@@ -27,89 +12,5 @@ const months = [
 export default async function rss(jsonFeedTree, options = {}) {
   assertTreeIsDefined(this, "site:rss");
   const jsonFeed = await Tree.plain(jsonFeedTree);
-  const { description, home_page_url, items, title } = jsonFeed;
-
-  let { feed_url, language } = options;
-  if (!feed_url && jsonFeed.feed_url) {
-    // Presume that the RSS feed lives in same location as feed_url
-    // but with a .xml extension.
-    feed_url = jsonFeed.feed_url;
-    if (feed_url.endsWith(".json")) {
-      feed_url = feed_url.replace(".json", ".xml");
-    }
-  }
-
-  const itemsRss = items?.map((story) => itemRss(story)).join("") ?? [];
-
-  const titleElement = title ? `    <title>${escapeXml(title)}</title>\n` : "";
-  const descriptionElement = description
-    ? `    <description>${escapeXml(description)}</description>\n`
-    : "";
-  const linkElement = home_page_url
-    ? `    <link>${home_page_url}</link>\n`
-    : "";
-  const languageElement = language
-    ? `    <language>${language}</language>\n`
-    : "";
-  const feedLinkElement = `    <atom:link href="${feed_url}" rel="self" type="application/rss+xml"/>\n`;
-
-  return `<?xml version="1.0" ?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
-  <channel>
-${titleElement}${descriptionElement}${linkElement}${languageElement}${feedLinkElement}${itemsRss}  </channel>
-</rss>`;
-}
-
-function itemRss(jsonFeedItem) {
-  const { content_html, id, summary, title, url } = jsonFeedItem;
-  let { date_published } = jsonFeedItem;
-  if (typeof date_published === "string") {
-    // Parse as ISO 8601 date.
-    date_published = new Date(date_published);
-  }
-  const date =
-    date_published instanceof Date
-      ? toRFC822Date(date_published)
-      : date_published;
-
-  const dateElement = date ? `      <pubDate>${date}</pubDate>\n` : "";
-  const isPermaLink =
-    id !== undefined && !URL.canParse(id) ? ` isPermaLink="false"` : "";
-  const guidElement = id ? `      <guid${isPermaLink}>${id}</guid>\n` : "";
-  const descriptionElement = summary
-    ? `      <description>${escapeXml(summary)}</description>\n`
-    : "";
-  const contentElement = content_html
-    ? `      <content:encoded><![CDATA[${content_html}]]></content:encoded>\n`
-    : "";
-  const titleElement = title
-    ? `      <title>${escapeXml(title)}</title>\n`
-    : "";
-  const linkElement = url ? `      <link>${url}</link>\n` : "";
-
-  return `    <item>
-${dateElement}${titleElement}${linkElement}${guidElement}${descriptionElement}${contentElement}    </item>
-`;
-}
-
-// Escape XML entities for in the text.
-function escapeXml(text) {
-  return text
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&apos;");
-}
-
-// RSS wants dates in RFC-822.
-function toRFC822Date(date) {
-  const day = days[date.getUTCDay()];
-  const dayOfMonth = date.getUTCDate().toString().padStart(2, "0");
-  const month = months[date.getUTCMonth()];
-  const year = date.getUTCFullYear();
-  const hours = date.getUTCHours().toString().padStart(2, "0");
-  const minutes = date.getUTCMinutes().toString().padStart(2, "0");
-  const seconds = date.getUTCSeconds().toString().padStart(2, "0");
-  return `${day}, ${dayOfMonth} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
+  return jsonFeedToRss(jsonFeed, options);
 }

package/src/tree/addNextPrevious.js

@@ -1,4 +1,4 @@
-import { Tree } from "@weborigami/async-tree";
+import { addNextPrevious, symbols } from "@weborigami/async-tree";
 import getTreeArgument from "../common/getTreeArgument.js";
 
 /**
@@ -9,55 +9,14 @@ import getTreeArgument from "../common/getTreeArgument.js";
  * @this {AsyncTree|null}
  * @param {import("@weborigami/async-tree").Treelike} treelike
  */
-export default async function addNextPrevious(treelike) {
+export default async function addNextPreviousBuiltin(treelike) {
   const tree = await getTreeArgument(
     this,
     arguments,
     treelike,
     "tree:addNextPrevious"
   );
-  let keys;
-  return Object.create(tree, {
-    get: {
-      value: async (key) => {
-        let value = await tree.get(key);
-
-        if (value === undefined) {
-          return undefined;
-        } else if (Tree.isTreelike(value)) {
-          value = await Tree.plain(value);
-        } else if (typeof value === "object") {
-          // Clone value to avoid modifying the original object.
-          value = { ...value };
-        } else if (typeof value === "string") {
-          // Upgrade text nodes to objects.
-          value = { "@text": value };
-        } else {
-          // Upgrade other scalar types to objects.
-          value = { "@data": value };
-        }
-
-        if (keys === undefined) {
-          keys = Array.from(await tree.keys());
-        }
-        const index = keys.indexOf(key);
-        if (index === -1) {
-          // Key is supported but not published in `keys`
-          return value;
-        }
-
-        // Extend value with nextKey/previousKey properties.
-        const nextKey = keys[index + 1];
-        if (nextKey) {
-          value.nextKey = nextKey;
-        }
-        const previousKey = keys[index - 1];
-        if (previousKey) {
-          value.previousKey = previousKey;
-        }
-        return value;
-      },
-      writable: true,
-    },
-  });
+  const result = await addNextPrevious(tree);
+  result[symbols.parent] = this;
+  return result;
 }

package/src/tree/filter.js

@@ -2,7 +2,7 @@ import { filter } from "@weborigami/async-tree";
 import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
 
 /**
- * Apply a filter to a tree.
+ * Apply a filter to a tree
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike

package/src/tree/map.js

@@ -1,8 +1,8 @@
 import {
   cachedKeyFunctions,
+  extensionKeyFunctions,
   isPlainObject,
   isUnpackable,
-  keyFunctionsForExtensions,
   map as mapTransform,
 } from "@weborigami/async-tree";
 import getTreeArgument from "../common/getTreeArgument.js";
@@ -102,10 +102,7 @@ function extendedOptions(context, operation) {
   if (extension) {
     // Generate key/inverseKey functions from the extension
     let { resultExtension, sourceExtension } = parseExtensions(extension);
-    const keyFns = keyFunctionsForExtensions({
-      resultExtension,
-      sourceExtension,
-    });
+    const keyFns = extensionKeyFunctions(sourceExtension, resultExtension);
     keyFn = keyFns.key;
     inverseKeyFn = keyFns.inverseKey;
   } else if (keyFn) {

package/src/tree/mask.js

@@ -0,0 +1,19 @@
+import { mask } from "@weborigami/async-tree";
+import assertTreeIsDefined from "../common/assertTreeIsDefined.js";
+
+/**
+ * Apply a mask to a tree
+ *
+ * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {AsyncTree|null}
+ * @param {Treelike} sourceTreelike
+ * @param {Treelike} maskTreelike
+ */
+export default async function maskBuiltin(sourceTreelike, maskTreelike) {
+  assertTreeIsDefined(this, "tree:mask");
+  const result = mask(sourceTreelike, maskTreelike);
+  result.parent = this;
+  return result;
+}

package/src/tree/paginate.js

@@ -1,3 +1,4 @@
+import { paginate } from "@weborigami/async-tree";
 import getTreeArgument from "../common/getTreeArgument.js";
 
 /**
@@ -11,51 +12,14 @@ import getTreeArgument from "../common/getTreeArgument.js";
  * @param {Treelike} [treelike]
  * @param {number} [size=10]
  */
-export default async function paginate(treelike, size = 10) {
+export default async function paginateBuiltin(treelike, size = 10) {
   const tree = await getTreeArgument(
     this,
     arguments,
     treelike,
     "tree:paginate"
   );
-
-  const keys = Array.from(await tree.keys());
-  const pageCount = Math.ceil(keys.length / size);
-
-  const paginated = {
-    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 paginated = await paginate(tree, size);
   paginated.parent = this;
   return paginated;
 }

package/src/tree/tree.js

@@ -21,6 +21,7 @@ export { default as inners } from "./inners.js";
 export { default as keys } from "./keys.js";
 export { default as length } from "./length.js";
 export { default as map } from "./map.js";
+export { default as mask } from "./mask.js";
 export { default as match } from "./match.js";
 export { default as merge } from "./merge.js";
 export { default as paginate } from "./paginate.js";