@weborigami/origami 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "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.10",
-    "@weborigami/language": "0.2.10",
-    "@weborigami/types": "0.2.10",
+    "@weborigami/async-tree": "0.2.12",
+    "@weborigami/language": "0.2.12",
+    "@weborigami/json-feed-to-rss": "1.0.0",
+    "@weborigami/types": "0.2.12",
     "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/handlers/oridocument.handler.js

@@ -1,15 +1,8 @@
-import {
-  extension,
-  ObjectTree,
-  symbols,
-  trailingSlash,
-} from "@weborigami/async-tree";
+import { extension, trailingSlash } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
-import { parseYaml } from "../common/serialize.js";
 import { toString } from "../common/utilities.js";
 import { processUnpackedContent } from "../internal.js";
 import getParent from "./getParent.js";
-import parseFrontMatter from "./parseFrontMatter.js";
 
 /**
  * An Origami template document: a plain text file that contains Origami
@@ -23,7 +16,7 @@ export default {
     const parent = getParent(packed, options);
 
     // Unpack as a text document
-    const unpacked = toString(packed);
+    const text = toString(packed);
 
     // See if we can construct a URL to use in error messages
     const key = options.key;
@@ -36,79 +29,16 @@ export default {
       url = new URL(key, parentHref);
     }
 
-    // Determine the data (if present) and text content
-    let text;
-    let frontData = null;
-    let frontSource = null;
-    let offset = 0;
-    let extendedParent = parent;
-    const parsed = parseFrontMatter(unpacked);
-    if (!parsed) {
-      text = unpacked;
-    } else {
-      const { body, frontText, isOrigami } = parsed;
-      if (isOrigami) {
-        // Origami front matter
-        frontSource = { name: key, text: frontText, url };
-      } else {
-        // YAML front matter
-        frontData = parseYaml(frontText);
-        if (typeof frontData !== "object") {
-          throw new TypeError(`YAML or JSON front matter must be an object`);
-        }
-        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 = {
+    // Compile the text as an Origami template document
+    const source = {
       name: key,
-      offset,
       text,
       url,
     };
+    const defineFn = compile.templateDocument(source);
 
-    // Compile the source as an Origami template document
-    const scopeCaching = frontSource ? false : true;
-    const defineTemplateFn = compile.templateDocument(bodySource, {
-      scopeCaching,
-    });
-
-    // Determine the result of the template
-    let result;
-    if (frontSource) {
-      // Result is the evaluated front source
-      const frontFn = compile.expression(frontSource, {
-        macros: {
-          "@template": defineTemplateFn.code,
-        },
-      });
-      result = await frontFn.call(parent);
-    } else {
-      const templateFn = await defineTemplateFn.call(extendedParent);
-      if (frontData) {
-        // Result is a function that adds the front data to the template result
-        result = async (input) => {
-          const text = await templateFn.call(extendedParent, input);
-          const object = {
-            ...frontData,
-            "@text": text,
-          };
-          object[symbols.parent] = extendedParent;
-          return object;
-        };
-      } else {
-        // Result is a function that calls the body template
-        result = templateFn;
-      }
-    }
+    // Invoke the definition to get back the template function
+    const result = await defineFn.call(parent);
 
     const resultExtension = key ? extension.extname(key) : null;
     if (resultExtension && Object.isExtensible(result)) {

package/src/handlers/parseFrontMatter.js

@@ -1,3 +1,5 @@
+import { isOrigamiFrontMatter } from "@weborigami/language";
+
 export default function parseFrontMatter(text) {
   const regex =
     /^(---\r?\n(?<frontText>[\s\S]*?\r?\n?)---\r?\n)(?<body>[\s\S]*$)/;
@@ -5,17 +7,10 @@ export default function parseFrontMatter(text) {
   if (!match?.groups) {
     return null;
   }
-  const isOrigami = detectOrigami(match.groups.frontText);
+  const isOrigami = isOrigamiFrontMatter(match.groups.frontText);
   return {
     body: match.groups.body,
     frontText: match.groups.frontText,
     isOrigami,
   };
 }
-
-function detectOrigami(text) {
-  // Find first character that's not whitespace, alphanumeric, or underscore
-  const first = text.match(/[^A-Za-z0-9_ \t\n\r]/)?.[0];
-  const origamiMarkers = ["(", ".", "/", "{"];
-  return origamiMarkers.includes(first);
-}

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/text/inline.js

@@ -43,14 +43,18 @@ export default async function inline(input) {
   }
 
   // @ts-ignore
-  const templateFn = await oridocumentHandler.unpack(input, {
+  let result = await oridocumentHandler.unpack(input, {
     parent: extendedParent,
   });
 
-  const inputData = inputIsDocument ? input : null;
-  const templateResult = await templateFn(inputData);
+  if (result instanceof Function) {
+    const text = await result();
+    if (inputIsDocument) {
+      return documentObject(text, input);
+    } else {
+      return text;
+    }
+  }
 
-  return inputIsDocument
-    ? documentObject(templateResult, inputData)
-    : templateResult;
+  return result;
 }

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/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/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;
 }