@weborigami/language 0.7.0-beta.1 → 0.7.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.7.0-beta.1",
+  "version": "0.7.0-beta.2",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,8 @@
     "typescript": "6.0.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.7.0-beta.1",
+    "@weborigami/async-tree": "0.7.0-beta.2",
+    "adm-zip": "0.5.17",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.9.0"

package/src/handlers/addExtensionKeyFn.js

@@ -0,0 +1,18 @@
+import { extension, trailingSlash } from "@weborigami/async-tree";
+
+// Return a function that adds the given extension
+export default function addExtensionKeyFn(resultExtension) {
+  const keyFn = (sourceValue, sourceKey) => {
+    if (sourceKey === undefined) {
+      return undefined;
+    }
+    const normalizedKey = trailingSlash.remove(sourceKey);
+    const sourceExtension = extension.extname(normalizedKey);
+    const resultKey = sourceExtension
+      ? extension.replace(normalizedKey, sourceExtension, resultExtension)
+      : normalizedKey + resultExtension;
+    return resultKey;
+  };
+  keyFn.needsSourceValue = false;
+  return keyFn;
+}

package/src/handlers/epub_handler.js

@@ -0,0 +1,54 @@
+import { AsyncMap, isUnpackable, Tree } from "@weborigami/async-tree";
+import addExtensionKeyFn from "./addExtensionKeyFn.js";
+import zip_handler from "./zip_handler.js";
+
+/**
+ * Handler for EPUB files
+ */
+const epub_handler = {
+  mediaType: "application/epub+zip",
+
+  /**
+   * Package a tree of files as an EPUB file in Buffer form.
+   *
+   * This calls the pack() method for ZIP files, but ensures the `mimetype` file
+   * is the first file in the package -- a requirement for EPUB files.
+   *
+   * @param {import("@weborigami/async-tree").Maplike} maplike
+   */
+  async pack(maplike) {
+    if (isUnpackable(maplike)) {
+      maplike = await maplike.unpack();
+    }
+    const tree = Tree.from(maplike, { deep: true });
+    return zip_handler.pack(mimetypeFirst(tree));
+  },
+
+  async unpack(buffer, options) {
+    return zip_handler.unpack(buffer, options);
+  },
+};
+
+/** @type {any} */ (epub_handler.pack).key = addExtensionKeyFn(".epub");
+
+export default epub_handler;
+
+// A tree with its `mimetype` file first
+function mimetypeFirst(tree) {
+  return Object.assign(new AsyncMap(), {
+    async get(key) {
+      return tree.get(key);
+    },
+
+    async *keys() {
+      const keys = await Tree.keys(tree);
+      // Move `mimetype` (if present) to the front of the list.
+      const index = keys.indexOf("mimetype");
+      if (index >= 0) {
+        keys.splice(index, 1);
+        keys.unshift("mimetype");
+      }
+      yield* keys;
+    },
+  });
+}

package/src/handlers/handlers.js

@@ -20,6 +20,7 @@ export { default as txt_handler } from "./txt_handler.js";
 
 export { default as css_handler } from "./css_handler.js";
 export { default as csv_handler } from "./csv_handler.js";
+export { default as epub_handler } from "./epub_handler.js";
 export { default as htm_handler } from "./htm_handler.js";
 export { default as html_handler } from "./html_handler.js";
 export { default as jpeg_handler } from "./jpeg_handler.js";
@@ -33,3 +34,4 @@ 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";
 export { default as yml_handler } from "./yml_handler.js";
+export { default as zip_handler } from "./zip_handler.js";

package/src/handlers/oridocument_handler.js

@@ -1,7 +1,8 @@
-import { extension, getParent, trailingSlash } from "@weborigami/async-tree";
+import { extension, getParent } from "@weborigami/async-tree";
 import * as compile from "../compiler/compile.js";
 import coreGlobals from "../project/coreGlobals.js";
 import getGlobalsForTree from "../project/getGlobalsForTree.js";
+import addExtensionKeyFn from "./addExtensionKeyFn.js";
 import getSource from "./getSource.js";
 import processOriExport from "./processOriExport.js";
 
@@ -37,27 +38,10 @@ export default {
       const resultExtension = key ? extension.extname(key) : null;
       if (resultExtension && Object.isExtensible(result)) {
         // Add sidecar function so this template can be used in a map.
-        result.key = addExtension(resultExtension);
+        result.key = addExtensionKeyFn(resultExtension);
       }
     }
 
     return result;
   },
 };
-
-// Return a function that adds the given extension
-function addExtension(resultExtension) {
-  const keyFn = (sourceValue, sourceKey) => {
-    if (sourceKey === undefined) {
-      return undefined;
-    }
-    const normalizedKey = trailingSlash.remove(sourceKey);
-    const sourceExtension = extension.extname(normalizedKey);
-    const resultKey = sourceExtension
-      ? extension.replace(normalizedKey, sourceExtension, resultExtension)
-      : normalizedKey + resultExtension;
-    return resultKey;
-  };
-  keyFn.needsSourceValue = false;
-  return keyFn;
-}

package/src/handlers/zip_handler.js

@@ -0,0 +1,112 @@
+import { isUnpackable, SyncMap, Tree } from "@weborigami/async-tree";
+import {
+  getGlobalsForTree,
+  HandleExtensionsTransform,
+} from "@weborigami/language";
+import Zip from "adm-zip";
+import addExtensionKeyFn from "./addExtensionKeyFn.js";
+
+/**
+ * Handler for ZIP files
+ */
+const zip_handler = {
+  mediaType: "application/zip",
+
+  /**
+   * Pack a tree of files as a ZIP file in Buffer form.
+   *
+   * @param {import("@weborigami/async-tree").Maplike} maplike
+   */
+  async pack(maplike) {
+    // The ZIP file should leave the files in tree order.
+    const zip = new Zip({ noSort: true });
+
+    if (isUnpackable(maplike)) {
+      maplike = await maplike.unpack();
+    }
+    const tree = Tree.from(maplike, { deep: true });
+    const deflated = await Tree.deflatePaths(tree);
+    for (let [path, value] of deflated) {
+      if (typeof value === "function") {
+        value = value();
+      }
+      if (value instanceof Promise) {
+        value = await value;
+      } else if (value instanceof String) {
+        value = value.toString(); // adm-zip wants simple strings
+      }
+      zip.addFile(path, value);
+
+      // Special case for EPUB files, where `mimetype` must be uncompressed.
+      if (path === "mimetype") {
+        const entry = zip.getEntry(path);
+        entry.header.method = 0; // STORE (not DEFLATE)
+      }
+    }
+    const buffer = zip.toBuffer();
+    return buffer;
+  },
+
+  /**
+   * Unpack a ZIP file
+   */
+  async unpack(buffer, options) {
+    // Origami generally prefers keeping things as an Uint8Array or ArrayBuffer,
+    // but adm-zip only accepts a Buffer.
+    if (buffer instanceof Uint8Array || buffer instanceof ArrayBuffer) {
+      // @ts-ignore
+      buffer = Buffer.from(buffer);
+    }
+
+    const zip = new Zip(buffer);
+
+    const entries = zip.getEntries();
+    const filtered = entries.filter(
+      (entry) =>
+        !entry.entryName.startsWith("__MACOSX/") &&
+        !entry.entryName.endsWith("/"),
+    );
+    const deflated = Object.fromEntries(
+      filtered.map((entry) => [entry.entryName, () => entry.getData()]),
+    );
+
+    // The final tree will include extension handlers and have functions invoked
+    // to retrieve data from the ZIP file. While the base map is a SyncMap, the
+    // final tree will be async.
+    const classFn = HandleExtensionsTransform(
+      InvokeFunctionsTransform(SyncMap),
+    );
+    const result = await Tree.inflatePaths(deflated, { classFn });
+
+    const parent = options?.parent;
+    const globals = parent ? getGlobalsForTree(parent) : null;
+    if (globals) {
+      result.globals = globals;
+    }
+
+    return result;
+  },
+};
+
+/** @type {any} */ (zip_handler.pack).key = addExtensionKeyFn(".zip");
+
+export default zip_handler;
+
+function InvokeFunctionsTransform(Base) {
+  return class InvokeFunctions extends Base {
+    delete(key) {
+      return super.delete(key);
+    }
+
+    get(key) {
+      const value = super.get(key);
+      return typeof value === "function" ? value() : value;
+    }
+
+    set(key, value) {
+      return super.set(key, value);
+    }
+
+    trailingSlashKeys = true;
+  };
+}

package/test/handlers/epub_handler.test.js

@@ -0,0 +1,27 @@
+import Zip from "adm-zip";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import epub_handler from "../../src/handlers/epub_handler.js";
+
+describe("EPUB handler", () => {
+  test("ensures mimetype file comes first", async () => {
+    const tree = {
+      EPUB: {
+        "index.xhtml": "This is where the book content goes",
+      },
+      "META-INF": {
+        "container.xml": "This is where the metadata goes",
+      },
+      mimetype: "application/epub+zip",
+    };
+    const buffer = await epub_handler.pack(tree);
+    const unzipped = new Zip(buffer);
+    const entries = unzipped.getEntries();
+    const entryNames = entries.map((entry) => entry.entryName);
+    assert.deepEqual(entryNames, [
+      "mimetype",
+      "EPUB/index.xhtml",
+      "META-INF/container.xml",
+    ]);
+  });
+});

package/test/handlers/zip_handler.test.js

@@ -0,0 +1,45 @@
+import { Tree } from "@weborigami/async-tree";
+import Zip from "adm-zip";
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import { describe, test } from "node:test";
+import zip_handler from "../../src/handlers/zip_handler.js";
+
+describe("ZIP handler", () => {
+  test("creates a ZIP file as Buffer", async () => {
+    const tree = {
+      "ReadMe.md": "This is a ReadMe file.",
+      sub: {
+        "file.txt": "This is a text file in a subfolder.",
+      },
+    };
+    const buffer = await zip_handler.pack(tree);
+    const unzipped = new Zip(buffer);
+    const entries = unzipped.getEntries();
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].entryName, "ReadMe.md");
+    assert.equal(
+      entries[0].getData().toString("utf8"),
+      "This is a ReadMe file.",
+    );
+    assert.equal(entries[1].entryName, "sub/file.txt");
+    assert.equal(
+      entries[1].getData().toString("utf8"),
+      "This is a text file in a subfolder.",
+    );
+  });
+
+  test("reads a ZIP file", async () => {
+    const fixturePath = new URL("fixtures/test.zip", import.meta.url);
+    const buffer = await fs.readFile(fixturePath);
+    const tree = await zip_handler.unpack(buffer);
+    const plain = await Tree.plain(tree);
+    assert.deepEqual(Object.keys(plain), ["ReadMe.md", "sub"]);
+    assert.deepEqual(Object.keys(plain.sub), ["file.txt"]);
+    assert.equal(String(plain["ReadMe.md"]), "This is a ReadMe file.\n");
+    assert.equal(
+      String(plain.sub["file.txt"]),
+      "This is a text file in a subfolder.\n",
+    );
+  });
+});