@weborigami/origami 0.0.35

package/src/common/utilities.js

@@ -0,0 +1,132 @@
+import { Tree, isPlainObject, isStringLike } from "@weborigami/async-tree";
+
+const textDecoder = new TextDecoder();
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+
+export function isTransformApplied(Transform, obj) {
+  let transformName = Transform.name;
+  if (!transformName) {
+    throw `isTransformApplied was called on an unnamed transform function, but a name is required.`;
+  }
+  if (transformName.endsWith("Transform")) {
+    transformName = transformName.slice(0, -9);
+  }
+  // Walk up prototype chain looking for a constructor with the same name as the
+  // transform. This is not a great test.
+  for (let proto = obj; proto; proto = Object.getPrototypeOf(proto)) {
+    if (proto.constructor.name === transformName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export const keySymbol = Symbol("key");
+
+export const parentSymbol = Symbol("parent");
+
+/**
+ * Convert the given object to a function.
+ *
+ * @typedef {import("../../index.ts").Invocable} Invocable
+ * @param {any} obj
+ * @returns {Function}
+ */
+export function toFunction(obj) {
+  if (typeof obj === "function") {
+    // Return a function as is.
+    return obj;
+  } else if (
+    typeof obj === "object" &&
+    typeof (/** @type {any} */ (obj)?.unpack) === "function"
+  ) {
+    // Extract the contents of the object and convert that to a function.
+    let fn;
+    /** @this {any} */
+    return async function (...args) {
+      if (!fn) {
+        const content = await /** @type {any} */ (obj).unpack();
+        fn = toFunction(content);
+      }
+      return fn.call(this, ...args);
+    };
+  } else if (Tree.isTreelike(obj)) {
+    // Return a function that invokes the tree's getter.
+    return Tree.toFunction(obj);
+  } else {
+    // Return a constant function.
+    return () => obj;
+  }
+}
+
+/**
+ * Return a string form of the object, handling two cases not generally handled
+ * by a .toString() method:
+ *
+ * 1. If the object is a plain JavaScript object with a `@text` property, return
+ *    the value of that property.
+ * 2. If the object is an ArrayBuffer or TypedArray, decode the array as UTF-8.
+ *
+ * Finally, if the object is otherwise a plain JavaScript object with the
+ * useless default toString() method, return null instead of "[object Object]".
+ * In practice, it's generally more useful to have this method fail than to
+ * return a useless string.
+ *
+ * @param {any} object
+ * @returns {string|null}
+ */
+export function toString(object) {
+  if (isPlainObject(object) && "@text" in object) {
+    return object["@text"];
+  } else if (object instanceof ArrayBuffer || object instanceof TypedArray) {
+    // Serialize data as UTF-8.
+    return textDecoder.decode(object);
+  } else if (isStringLike(object)) {
+    return String(object);
+  } else {
+    return null;
+  }
+}
+
+/**
+ * Apply a functional class mixin to an individual object instance.
+ *
+ * This works by create an intermediate class, creating an instance of that, and
+ * then setting the intermediate class's prototype to the given individual
+ * object. The resulting, extended object is then returned.
+ *
+ * This manipulation of the prototype chain is generally sound in JavaScript,
+ * with some caveats. In particular, the original object class cannot make
+ * direct use of private members; JavaScript will complain if the extended
+ * object does anything that requires access to those private members.
+ *
+ * @param {Function} Transform
+ * @param {any} obj
+ */
+export function transformObject(Transform, obj) {
+  // Apply the mixin to Object and instantiate that. The Object base class here
+  // is going to be cut out of the prototype chain in a moment; we just use
+  // Object as a convenience because its constructor takes no arguments.
+  const mixed = new (Transform(Object))();
+
+  // Find the highest prototype in the chain that was added by the class mixin.
+  // The mixin may have added multiple prototypes to the chain. Walk up the
+  // prototype chain until we hit Object.
+  let mixinProto = Object.getPrototypeOf(mixed);
+  while (Object.getPrototypeOf(mixinProto) !== Object.prototype) {
+    mixinProto = Object.getPrototypeOf(mixinProto);
+  }
+
+  // Redirect the prototype chain above the mixin to point to the original
+  // object. The mixed object now extends the original object with the mixin.
+  Object.setPrototypeOf(mixinProto, obj);
+
+  // Create a new constructor for this mixed object that reflects its prototype
+  // chain. Because we've already got the instance we want, we won't use this
+  // constructor now, but this can be used later to instantiate other objects
+  // that look like the mixed one.
+  mixed.constructor = Transform(obj.constructor);
+
+  // Return the mixed object.
+  return mixed;
+}

package/src/misc/OriCommandTransform.d.ts

@@ -0,0 +1,5 @@
+import { Mixin } from "@weborigami/language";
+
+declare const OriCommandTransform: Mixin<{}>;
+
+export default OriCommandTransform;

package/src/misc/OriCommandTransform.js

@@ -0,0 +1,54 @@
+/** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
+import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { Scope } from "@weborigami/language";
+import ori from "../builtins/@ori.js";
+import {
+  isTransformApplied,
+  keySymbol,
+  transformObject,
+} from "../common/utilities.js";
+
+/**
+ * Add support for commands prefixed with `!`.
+ *
+ * E.g., asking this tree for `!yaml` will invoke the yaml() builtin function
+ * in the context of this tree.
+ *
+ * @typedef {import("../../index.js").Constructor<AsyncTree>} AsyncTreeConstructor
+ * @param {AsyncTreeConstructor} Base
+ */
+export default function OriCommandTransform(Base) {
+  return class OriCommand extends Base {
+    async get(key) {
+      let value = await super.get(key);
+
+      if (value === undefined) {
+        if (
+          key === undefined ||
+          typeof key !== "string" ||
+          !key.startsWith?.("!")
+        ) {
+          return undefined;
+        }
+        // Key is an Origami command; invoke it.
+        const ambientsTree = new ObjectTree({
+          "@current": this,
+        });
+        ambientsTree[keySymbol] = "ori command";
+        const extendedScope = new Scope(ambientsTree, Scope.getScope(this));
+        const source = key.slice(1).trim();
+        value = await ori.call(extendedScope, source);
+
+        // Ensure this transform is applied to any subtree.
+        if (
+          Tree.isAsyncTree(value) &&
+          !isTransformApplied(OriCommandTransform, value)
+        ) {
+          value = transformObject(OriCommandTransform, value);
+        }
+      }
+
+      return value;
+    }
+  };
+}

package/src/misc/assertScopeIsDefined.js

@@ -0,0 +1,7 @@
+export default function assertScopeIsDefined(scope) {
+  if (scope === undefined) {
+    throw new Error(
+      "Tree methods must be called a scope. If you don't want to pass a scope, invoke with: <methodName>.call(null)"
+    );
+  }
+}

package/src/misc/explore.orit

@@ -0,0 +1,241 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>Graph Origami Explorer</title>
+    <style>
+      * {
+        box-sizing: border-box;
+      }
+
+      html {
+        height: 100%;
+      }
+
+      body {
+        background: #333;
+        color: #eee;
+        display: grid;
+        font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+        font-size: 13px;
+        grid-template-columns: 200px 1fr;
+        grid-template-rows: minMax(0, 1fr);
+        height: 100%;
+        margin: 0;
+        overflow: hidden;
+      }
+
+      nav {
+        display: grid;
+        gap: 1em;
+        grid-auto-rows: min-content;
+        grid-template-columns: minmax(0, 1fr);
+        overflow: auto;
+        padding: 1em 0.5em;
+      }
+
+      #label {
+        font-weight: bold;
+      }
+
+      #scopeToolbar {
+        display: grid;
+        grid-template-columns: repeat(4, auto);        
+      }
+
+      button {
+        background: transparent;
+        border: solid 1px #555;
+        color: inherit;
+        font-size: smaller;
+        font-family: inherit;
+        font-weight: inherit;
+        padding: 0.25em;
+      }
+      button:hover {
+        border-color: #999;
+      }
+      button:active {
+        border-color: #eee;
+      }
+      button[aria-pressed="true"] {
+        background: #555;
+      }
+
+      ul {
+        list-style: none;
+        margin: 0;
+        padding: 0;
+      }
+
+      h2 {
+        color: #999;
+        font-size: inherit;
+        margin: 0.25em 0;
+        padding-left: 0.25em;
+      }
+
+      li {
+        padding: 0.25em;
+        padding-left: 1em;
+        text-indent: -0.75em;
+      }
+
+      a {
+        color: inherit;
+        text-decoration: none;
+      }
+
+      iframe {
+        background: white;
+        border: none;
+        height: 100%;
+        width: 100%;
+      }
+    </style>
+    <script>
+      let defaultPath;
+      let path;
+      let frame;
+
+      const modes = {
+        Content: "",
+        Index: "!@index",
+        YAML: "!@yaml",
+        SVG: "!@svg",
+      };
+
+      // Extract the path from the URL hash.
+      function getPathFromHash() {
+        return window.location.hash.slice(1); // Remove `#`
+      }
+
+      function getModeFromLocation() {
+        const href = document.location.href;
+        const match = /[\/](?<command>\!(?:@index|@yaml|@svg))$/.exec(href);
+        const command = match?.groups.command ?? "";
+        const mode = Object.keys(modes).find(key => modes[key] === command) ?? "Content";
+        return mode;
+      }
+
+      function removeDocumentPath(path) {
+        const documentPath = document.location.pathname;
+        if (path.startsWith(documentPath)) {
+          // Remove the document path prefix.
+          path = path.slice(documentPath.length);
+        }
+        if (path.startsWith("/")) {
+          // Remove the leading slash.
+          path = path.slice(1);
+        }
+        return path;
+      }
+
+      function selectMode(newMode) {
+        const currentMode = getModeFromLocation();
+        if (newMode !== currentMode) {
+          let newPath = removeDocumentPath(frame.contentDocument.location.pathname);
+          const currentExtension = modes[currentMode];
+          if (currentExtension && newPath.endsWith(currentExtension)) {
+            // Remove the current extension.
+            newPath = newPath.slice(0, -currentExtension.length);
+          }
+          const newExtension = modes[newMode];
+          const separator = newPath.endsWith("/") ? "" : "/";
+          const newFullPath = `${newPath}${separator}${newExtension}`;
+          setPath(newFullPath);
+        }
+      }
+
+      function setPath(path) {
+        currentPath = path;
+
+        // Show the indicated page in the frame.
+        const abbreviatedPath = `/${path}`;
+        const fullPath = `${document.location.pathname}/${path}`;
+        const framePathname = frame.contentDocument.location.pathname;
+        if (framePathname !== abbreviatedPath && framePathname !== fullPath) {
+          // Use `replace` to avoid affecting browser history.
+          frame.contentWindow.location.replace(fullPath);
+        }
+
+        // If the path ends with a file name corresponding to a mode, select
+        // the corresponding mode button.
+        const mode = getModeFromLocation();
+        const selectedButtonId = `button${mode}`;
+        scopeToolbar.querySelectorAll("button").forEach(button => {
+          const pressed = button.id === selectedButtonId ? "true" : "false";
+          button.setAttribute("aria-pressed", pressed);
+        });
+      }
+
+      // When hash changes, load the indicated page.
+      window.addEventListener("hashchange", () => {
+        const hashPath = getPathFromHash();
+        const newPath = hashPath !== undefined ? hashPath : defaultPath;
+        if (newPath) {
+          setPath(newPath);
+        }
+      });
+
+      // Initialize
+      window.addEventListener("load", () => {
+        // Refresh title on page load.
+        frame = document.getElementById("frame");
+        frame.addEventListener("load", () => {
+          if (frame.contentDocument.location.href !== "about:blank") {
+            document.title = frame.contentDocument.title;
+            const newPath = removeDocumentPath(frame.contentDocument.location.pathname);
+            const hash = `#${newPath}`;
+            if (window.location.hash !== hash) {
+              // Use `replace` to avoid affecting browser history.
+              window.location.replace(hash);
+            }
+          }
+        });
+
+        buttonContent.addEventListener("click", () => {
+          selectMode("Content");
+        });
+        buttonIndex.addEventListener("click", () => {
+          selectMode("Index");
+        });
+        buttonYAML.addEventListener("click", () => {
+          selectMode("YAML");
+        });
+        buttonSVG.addEventListener("click", () => {
+          selectMode("SVG");
+        });
+
+        // Navigate to any path already in the hash.
+        defaultPath = getPathFromHash();
+        if (defaultPath) {
+          setPath(defaultPath);
+        }
+      })
+    </script>
+  </head>
+  <body>
+    <nav>
+    <div id="label">Graph Origami Explorer</div>
+    <div id="scopeToolbar">
+      <button id="buttonContent">Content</button>
+      <button id="buttonIndex">Index</button>
+      <button id="buttonSVG">SVG</button>
+      <button id="buttonYAML">YAML</button>
+    </div>
+    {{ @map(=`
+      <ul>
+        <h2>{{ _/name }}</h2>
+        {{ @map(=`
+        <li>
+          <a href="./!@explore/{{ _ }}" target="frame">{{ _ }}</a>
+        </li>
+        `)(_/keys) }}
+      </ul>
+    `)(_) }}
+    </nav>
+    <iframe id="frame" name="frame"></iframe>
+  </body>
+</html>

package/src/misc/yamlOrigamiTag.js

@@ -0,0 +1,17 @@
+import { expressionFunction } from "@weborigami/language";
+import * as compile from "../../../language/src/compiler/compile.js";
+/**
+ * A YAML tag for an Origami expression.
+ */
+export default {
+  identify: expressionFunction.isExpressionFunction,
+
+  resolve(str) {
+    const code = compile.expression(str);
+    return code instanceof Array
+      ? expressionFunction.createExpressionFunction(code)
+      : code;
+  },
+
+  tag: "!ori",
+};

package/src/server/mediaTypes.js

@@ -0,0 +1,97 @@
+// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+export const mediaTypeForExtension = {
+  ".3g2": "video/3gpp2",
+  ".3gp": "video/3gpp",
+  ".7z": "application/x-7z-compressed",
+  ".aac": "audio/aac",
+  ".abw": "application/x-abiword",
+  ".arc": "application/x-freearc",
+  ".avi": "video/x-msvideo",
+  ".avif": "image/avif",
+  ".azw": "application/vnd.amazon.ebook",
+  ".bin": "application/octet-stream",
+  ".bmp": "image/bmp",
+  ".bz": "application/x-bzip",
+  ".bz2": "application/x-bzip2",
+  ".csh": "application/x-csh",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".doc": "application/msword",
+  ".docx":
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".eot": "application/vnd.ms-fontobject",
+  ".epub": "application/epub+zip",
+  ".gif": "image/gif",
+  ".gz": "application/gzip",
+  ".htm": "text/html",
+  ".html": "text/html",
+  ".ico": "image/vnd.microsoft.icon",
+  ".ics": "text/calendar",
+  ".jar": "application/java-archive",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript",
+  ".json": "application/json",
+  ".jsonld": "application/ld+json",
+  ".mid": "audio/midi audio/x-midi",
+  ".midi": "audio/midi audio/x-midi",
+  ".mjs": "text/javascript",
+  ".mp3": "audio/mpeg",
+  ".mpeg": "video/mpeg",
+  ".mpkg": "application/vnd.apple.installer+xml",
+  ".odp": "application/vnd.oasis.opendocument.presentation",
+  ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+  ".odt": "application/vnd.oasis.opendocument.text",
+  ".oga": "audio/ogg",
+  ".ogv": "video/ogg",
+  ".ogx": "application/ogg",
+  ".opus": "audio/opus",
+  ".otf": "font/otf",
+  ".pdf": "application/pdf",
+  ".php": "application/x-httpd-php",
+  ".png": "image/png",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx":
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".rar": "application/vnd.rar",
+  ".rtf": "application/rtf",
+  ".sh": "application/x-sh",
+  ".svg": "image/svg+xml",
+  ".swf": "application/x-shockwave-flash",
+  ".tar": "application/x-tar",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".ts": "video/mp2t",
+  ".ttf": "font/ttf",
+  ".txt": "text/plain",
+  ".vsd": "application/vnd.visio",
+  ".wav": "audio/wav",
+  ".weba": "audio/webm",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".xhtml": "application/xhtml+xml",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".xml": "application/xml",
+  ".xul": "application/vnd.mozilla.xul+xml",
+  ".yaml": "text/yaml", // Not official
+  ".zip": "application/zip",
+};
+
+export const mediaTypeIsText = {
+  "application/json": true,
+  "application/ld+json": true,
+  "application/vnd.oasis.opendocument.text": true,
+  "application/x-httpd-php": true,
+  "application/x-sh": true,
+  "application/xhtml+xml": true,
+  "text/css": true,
+  "text/csv": true,
+  "text/html": true,
+  "text/javascript": true,
+  "text/plain": true,
+  "text/yaml": true,
+  "text/yml": true,
+};