@weborigami/language 0.5.7 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.7",
-    "@weborigami/types": "0.5.7",
+    "@weborigami/async-tree": "0.5.8",
+    "@weborigami/types": "0.5.8",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/handlers/handlers.js

@@ -27,6 +27,8 @@ export { default as jpg_handler } from "./jpg_handler.js";
 export { default as json_handler } from "./json_handler.js";
 export { default as md_handler } from "./md_handler.js";
 export { default as mjs_handler } from "./mjs_handler.js";
+export { default as sh_handler } from "./sh_handler.js";
+export { default as tsv_handler } from "./tsv_handler.js";
 export { default as wasm_handler } from "./wasm_handler.js";
 export { default as xhtml_handler } from "./xhtml_handler.js";
 export { default as yaml_handler } from "./yaml_handler.js";

package/src/handlers/sh_handler.js

@@ -0,0 +1,65 @@
+import { toString } from "@weborigami/async-tree";
+import { spawn } from "node:child_process";
+
+/**
+ * Shell script file extension handler
+ */
+export default {
+  mediaType: "text/plain",
+
+  /** @type {import("@weborigami/async-tree").UnpackFunction} */
+  async unpack(packed) {
+    const scriptText = toString(packed);
+
+    if (scriptText === null) {
+      throw new Error(".sh handler: input isn't text");
+    }
+
+    return async (input) => {
+      return runShellScript(scriptText, input);
+    };
+  },
+};
+
+/**
+ * Run arbitrary shell script text in /bin/sh and feed it stdin.
+ * Supports multiple commands, pipelines, redirects, etc.
+ *
+ * @param {string} scriptText - Shell code (may contain newlines/side effects)
+ * @param {string} inputText  - Text to pipe to the script's stdin
+ * @returns {Promise<string>}
+ */
+function runShellScript(scriptText, inputText) {
+  return new Promise((resolve, reject) => {
+    // Use sh -c "<scriptText>" so stdin is free for inputText
+    const child = spawn("sh", ["-c", scriptText], {
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (c) => (stdout += c));
+    child.stderr.on("data", (c) => (stderr += c));
+
+    child.on("error", reject);
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        /** @type {any} */
+        const err = new Error(
+          `Shell exited with code ${code}${stderr ? `: ${stderr}` : ""}`
+        );
+        err.code = code;
+        err.stdout = stdout;
+        err.stderr = stderr;
+        return reject(err);
+      }
+      resolve(stdout);
+    });
+
+    // Feed the input to the script's stdin and close it
+    child.stdin.end(inputText);
+  });
+}

package/src/handlers/tsv_handler.js

@@ -0,0 +1,54 @@
+import { symbols, toString } from "@weborigami/async-tree";
+
+export default {
+  mediaType: "text/csv",
+
+  unpack(packed, options = {}) {
+    const parent = options.parent ?? null;
+    const text = toString(packed);
+    if (text === null) {
+      throw new TypeError(".tsv handler can only unpack text");
+    }
+    const data = tsvParse(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 tab-separated values (TSV) format into an array of objects.
+ *
+ * This assumes the presence of a header row, and accepts both CRLF and LF line
+ * endings.
+ *
+ * Blank lines are ignored.
+ *
+ * @param {string} text
+ * @returns {any[]}
+ */
+function tsvParse(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.trim() !== "");
+  if (lines.length === 0) {
+    return [];
+  }
+
+  const headers = lines[0].split("\t");
+  const data = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split("\t");
+    const entry = {};
+    for (let j = 0; j < headers.length; j++) {
+      entry[headers[j]] = values[j] ?? "";
+    }
+    data.push(entry);
+  }
+
+  return data;
+}

package/test/handlers/sh_handler.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import sh_handler from "../../src/handlers/sh_handler.js";
+
+describe(".sh handler", () => {
+  test("invokes shell commands", async () => {
+    const text = `echo Hello
+  cat
+  `;
+    const fn = await sh_handler.unpack(text);
+    const output = await fn("Input text");
+    assert.equal(output, "Hello\nInput text");
+  });
+});

package/test/handlers/tsv_handler.test.js

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import tsv_handler from "../../src/handlers/tsv_handler.js";
+
+describe(".tsv handler", () => {
+  test("parses TSV text into array of objects", () => {
+    const TSVText = `name	age	city
+Alice\t30\tNew York, NY
+Bob\t25\tLos Angeles
+Carol\t22\tChicago`;
+    const result = tsv_handler.unpack(TSVText);
+    assert.deepStrictEqual(result, [
+      { name: "Alice", age: "30", city: "New York, NY" },
+      { name: "Bob", age: "25", city: "Los Angeles" },
+      { name: "Carol", age: "22", city: "Chicago" },
+    ]);
+  });
+
+  test("handles CRLF line endings", () => {
+    const textCRLF = `name\tage\tcity\r\nAlice\t30\tNew York, NY\r\nBob\t25\tLos Angeles\r\n`;
+    const expected = [
+      { name: "Alice", age: "30", city: "New York, NY" },
+      { name: "Bob", age: "25", city: "Los Angeles" },
+    ];
+    const result = tsv_handler.unpack(textCRLF);
+    assert.deepStrictEqual(result, expected);
+  });
+});