@weborigami/origami 0.0.58 → 0.0.59

package/exports/buildExports.js

@@ -1,5 +1,9 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { keyFunctionsForExtensions, map } from "@weborigami/async-tree";
+import {
+  keyFunctionsForExtensions,
+  map,
+  toString,
+} from "@weborigami/async-tree";
 import fileTypeOrigami from "../src/builtins/ori_handler.js";
 import { transformObject } from "../src/common/utilities.js";
 import PathTransform from "./PathTransform.js";
@@ -32,7 +36,7 @@ export default async function exportFile(src) {
  * @this {AsyncTree}
  */
 async function exportStatementForCode(codeBuffer, key) {
-  const code = String(codeBuffer);
+  const code = toString(codeBuffer);
 
   const exportsAnything = code.match(/^export /m);
   if (!exportsAnything) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.58",
+  "version": "0.0.59",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,22 +13,22 @@
   "main": "./exports/exports.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.12.7",
-    "typescript": "5.4.5"
+    "@types/node": "20.14.9",
+    "typescript": "5.5.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.58",
-    "@weborigami/language": "0.0.58",
-    "@weborigami/types": "0.0.58",
+    "@weborigami/async-tree": "0.0.59",
+    "@weborigami/language": "0.0.59",
+    "@weborigami/types": "0.0.59",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.9.0",
-    "marked": "12.0.2",
-    "marked-gfm-heading-id": "3.1.3",
-    "marked-highlight": "2.1.1",
-    "marked-smartypants": "1.1.6",
-    "sharp": "0.33.3",
-    "yaml": "2.4.2"
+    "marked": "13.0.1",
+    "marked-gfm-heading-id": "4.0.0",
+    "marked-highlight": "2.1.3",
+    "marked-smartypants": "1.1.7",
+    "sharp": "0.33.4",
+    "yaml": "2.4.5"
   },
   "scripts": {
     "build": "ori exports/buildExports.js src > exports/exports.js",

package/src/builtins/@image/format.js

@@ -7,12 +7,12 @@ import imageFormatFn from "./formatFn.js";
  * @this {import("@weborigami/types").AsyncTree|null}
  *
  * @this {import("@weborigami/types").AsyncTree|null}
- * @param {Buffer} buffer
+ * @param {import("@weborigami/async-tree").Packed} input
  * @param {keyof import("sharp").FormatEnum|import("sharp").AvailableFormatInfo}
  * format
  * @param {any} options
  */
-export default async function imageFormat(buffer, format, options) {
+export default async function imageFormat(input, format, options) {
   assertScopeIsDefined(this, "image/format");
-  return imageFormatFn.call(this, format, options)(buffer);
+  return imageFormatFn.call(this, format, options)(input);
 }

package/src/builtins/@image/resize.js

@@ -5,10 +5,10 @@ import imageResizeFn from "./resizeFn.js";
  * Resize an image.
  *
  * @this {import("@weborigami/types").AsyncTree|null}
- * @param {Buffer} buffer
+ * @param {import("@weborigami/async-tree").Packed} input
  * @param {import("sharp").ResizeOptions} options
  */
-export default async function resize(buffer, options) {
+export default async function resize(input, options) {
   assertScopeIsDefined(this, "image/resize");
-  return imageResizeFn.call(this, options)(buffer);
+  return imageResizeFn.call(this, options)(input);
 }

package/src/builtins/@json.js

@@ -1,6 +1,5 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { isUnpackable } from "@weborigami/async-tree";
-import * as serialize from "../common/serialize.js";
+import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 
 /**
@@ -24,7 +23,7 @@ export default async function json(obj) {
   if (isUnpackable(obj)) {
     obj = await obj.unpack();
   }
-  const value = await serialize.toJsonValue(obj);
+  const value = await toPlainValue(obj);
   return JSON.stringify(value, null, 2);
 }
 

package/src/builtins/@ori.js

@@ -20,7 +20,8 @@ export default async function ori(
   options = { formatResult: true }
 ) {
   assertScopeIsDefined(this, "ori");
-  // In case expression is a Buffer, cast it to a string.
+
+  // In case expression has come from a file, cast it to a string.
   expression = String(expression);
 
   // Obtain the scope from `this` or builtins.

package/src/builtins/@perf.js

@@ -14,5 +14,6 @@ export default async function perf(fn, count = 1) {
     await fn.call(this);
   }
   const end = performance.now();
-  return end - start;
+  const milliseconds = Math.round(end - start);
+  return `${milliseconds} ms`;
 }

package/src/builtins/@stdin.js

@@ -16,7 +16,13 @@ function readAll(readable) {
     });
 
     readable.on("end", () => {
-      const buffer = Buffer.concat(chunks);
+      const size = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const buffer = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.length;
+      }
       resolve(buffer);
     });
   });

package/src/builtins/@unpack.js

@@ -1,7 +1,7 @@
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 
 /**
- * Unpack a packed format like a Buffer or ArrayBuffer to a usable form like
+ * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
  * text or a plain JavaScript object.
  *
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree

package/src/builtins/@yaml.js

@@ -1,7 +1,6 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { isUnpackable } from "@weborigami/async-tree";
+import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
-import * as serialize from "../common/serialize.js";
 import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 
 /**
@@ -25,7 +24,7 @@ export default async function toYaml(obj) {
   if (isUnpackable(obj)) {
     obj = await obj.unpack();
   }
-  const value = await serialize.toJsonValue(obj);
+  const value = await toPlainValue(obj);
   return YAML.stringify(value);
 }
 

package/src/builtins/jpeg_handler.js

@@ -17,6 +17,10 @@ export default {
 
   /** @type {import("@weborigami/language").UnpackFunction} */
   async unpack(packed, options) {
+    if (packed instanceof Uint8Array) {
+      // Downgrade to old Node Buffer for exif-parser.
+      packed = Buffer.from(packed);
+    }
     const parser = exifParser.create(packed);
     parser.enableTagNames(true);
     parser.enableSimpleValues(true);

package/src/common/serialize.d.ts

@@ -4,6 +4,4 @@ import type { JsonValue } from "../../index.ts";
 export function evaluateYaml(text: string, parent?: AsyncTree|null): Promise<JsonValue>;
 export function parseYaml(text: string): JsonValue|AsyncTree;
 export function toJson(obj: JsonValue | AsyncTree): Promise<string>;
-export function toJsonValue(obj: any): Promise<JsonValue>;
-export function toValue(obj: any, jsonValuesOnly?: boolean): Promise<JsonValue>;
 export function toYaml(obj: JsonValue | AsyncTree): Promise<string>;

package/src/common/serialize.js

@@ -5,12 +5,9 @@
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
-import { Tree, isStringLike } from "@weborigami/async-tree";
+import { Tree, toPlainValue } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
 
-const textDecoder = new TextDecoder();
-const TypedArray = Object.getPrototypeOf(Uint8Array);
-
 // The "yaml" package doesn't seem to provide a default export that the browser can
 // recognize, so we have to handle two ways to accommodate Node and the browser.
 // @ts-ignore
@@ -31,21 +28,6 @@ export async function evaluateYaml(text, parent) {
   }
 }
 
-/**
- * @param {any} obj
- * @returns {obj is JsonValue}
- */
-function isJsonValue(obj) {
-  const t = typeof obj;
-  return (
-    t === "boolean" ||
-    t === "number" ||
-    t === "string" ||
-    obj instanceof Date ||
-    obj === null
-  );
-}
-
 /**
  * @param {string} text
  * @returns {JsonValue|AsyncTree}
@@ -60,79 +42,10 @@ export function parseYaml(text) {
  * @param {any} obj
  */
 export async function toJson(obj) {
-  const serializable = await toJsonValue(obj);
+  const serializable = await toPlainValue(obj);
   return JSON.stringify(serializable, null, 2);
 }
 
-/**
- * Convert the given object to a corresponding JSON value that can be
- * represented as JSON or YAML.
- *
- * @param {any} object
- * @returns {Promise<JsonValue>}
- */
-export async function toJsonValue(object) {
-  return toValue(object, true);
-}
-
-/**
- * Convert the given input to the plainest possible JavaScript value. This
- * helper is intended for functions that want to accept an argument from the ori
- * CLI, which could a string, a file buffer, an ArrayBuffer from a URL, or some
- * other kind of JavaScript object.
- *
- * If the input implements the `unpack()` method, the input will be unpacked and
- * before processing.
- *
- * If the input is treelike, it will be converted to a plain JavaScript object,
- * recursively traversing the tree and converting all values to plain types.
- *
- * If the input is stringlike, its text will be returned.
- *
- * If the input is a Buffer or ArrayBuffer, it will be interpreted as UTF-8
- * text.
- *
- * If the input has a custom class instance, its public properties will be
- * returned as a plain object.
- *
- * The `jsonValuesOnly` parameter can be set to `true` to ensure that the
- * returned value can be represented as JSON. If the input can't be represented
- * as JSON, an error is thrown.
- *
- * @param {any} input
- * @param {boolean} [jsonValuesOnly]
- * @returns {Promise<any>}
- */
-export async function toValue(input, jsonValuesOnly = false) {
-  if (input instanceof Promise) {
-    // Resolve promise before processing.
-    return toValue(await input, jsonValuesOnly);
-  } else if (isJsonValue(input)) {
-    return input;
-  } else if (typeof input !== "object") {
-    if (jsonValuesOnly) {
-      throw new TypeError(`Couldn't serialize value to JSON: ${input}`);
-    } else {
-      return input;
-    }
-  } else if (isStringLike(input) && !(input instanceof Array)) {
-    return String(input);
-  } else if (Tree.isTreelike(input)) {
-    const mapped = await Tree.map(input, (value) => toValue(value));
-    return Tree.plain(mapped);
-  } else if (input instanceof ArrayBuffer || input instanceof TypedArray) {
-    // Interpret input as UTF-8 text.
-    return textDecoder.decode(input);
-  } else {
-    // Some other kind of class instance; return its public properties.
-    const plain = {};
-    for (const [key, value] of Object.entries(input)) {
-      plain[key] = await toValue(value);
-    }
-    return plain;
-  }
-}
-
 /**
  * Serializes an object as a JSON string.
  *
@@ -140,6 +53,6 @@ export async function toValue(input, jsonValuesOnly = false) {
  * @returns {Promise<string>}
  */
 export async function toYaml(obj) {
-  const serializable = await toJsonValue(obj);
+  const serializable = await toPlainValue(obj);
   return YAML.stringify(serializable);
 }

package/src/server/constructResponse.js

@@ -62,7 +62,7 @@ export default async function constructResponse(request, resource) {
     !isStringLike(resource)
   ) {
     // The request is for a JSON or YAML result, and the resource we got isn't
-    // yet a string or Buffer: convert the resource to JSON or YAML now.
+    // yet a string: convert the resource to JSON or YAML now.
     const tree = Tree.from(resource);
     resource =
       mediaType === "text/yaml"
@@ -103,7 +103,7 @@ export default async function constructResponse(request, resource) {
   if (!validResponse) {
     const typeName = body?.constructor?.name ?? typeof body;
     console.error(
-      `A served tree must return a string or a TypedArray (such as a Buffer) but returned an instance of ${typeName}.`
+      `A served tree must return a string or a TypedArray but returned an instance of ${typeName}.`
     );
     return null;
   }
@@ -123,8 +123,8 @@ export default async function constructResponse(request, resource) {
  */
 function textOrObject(object) {
   if (object instanceof ArrayBuffer) {
-    // Convert to Buffer.
-    return Buffer.from(object);
+    // Convert to Uint8Array so we can write it to the Response.
+    return new Uint8Array(object);
   } else if (object instanceof TypedArray) {
     // Return typed arrays as is.
     return object;