@weborigami/language 0.4.1 → 0.5.0

package/src/compiler/parserHelpers.js

@@ -177,8 +177,8 @@ export function makeCall(target, args, location) {
   } else if (op === markers.property) {
     // Property access
     const property = args[1];
-    fnCall = [target, property];
-  } else if (op === ops.templateTree) {
+    fnCall = [ops.property, target, property];
+  } else if (op === ops.templateText) {
     // Tagged template
     const strings = args[1];
     const values = args.slice(2);
@@ -218,8 +218,6 @@ export function makeDocument(front, body, location) {
   );
 
   // Add an entry for the body
-  // TODO: Deprecate @text
-  entries.push(annotate(["(@text)", body], location));
   entries.push(annotate(["_body", body], location));
 
   // Return the code for the document object
@@ -233,7 +231,7 @@ export function makeDocument(front, body, location) {
  *
  *      {
  *        x = { a: 1 }
- *        …x
+ *        ...x
  *        y = x
  *      }
  *
@@ -244,7 +242,7 @@ export function makeDocument(front, body, location) {
  *        y = x
  *        _result: {
  *          x
- *          …x
+ *          ...x
  *          y
  *        }
  *      }.result
@@ -348,8 +346,12 @@ export function makeObject(entries, location) {
     // Merge multiple spreads
     code = makeMerge(spreads, location);
   } else if (spreads.length === 1) {
-    // A single spread can just be the object
-    code = spreads[0];
+    // Spreading a single reference equates to an unpack
+    if (spreads[0][0] === markers.traverse) {
+      code = annotate([ops.unpack, spreads[0]], location);
+    } else {
+      code = spreads[0];
+    }
   } else {
     // Empty object
     code = [ops.object];

package/src/runtime/errors.js

@@ -23,6 +23,10 @@ const origamiSourceSignals = [
 const displayedWarnings = new Set();
 
 export function attachWarning(value, message) {
+  if (value == null) {
+    return value;
+  }
+
   if (typeof value === "object" && value?.[symbols.warningSymbol]) {
     // Already has a warning, don't overwrite it
     return value;

package/src/runtime/expressionObject.js

@@ -156,14 +156,29 @@ export function entryKey(entry, object = null, eagerProperties = []) {
     return trailingSlash.add(key);
   }
 
+  if (!(value instanceof Array)) {
+    // Can't be a subtree
+    return trailingSlash.remove(key);
+  }
+
+  // If we're dealing with a getter, work with what that gets
+  if (value[0] === ops.getter) {
+    value = value[1];
+  }
+
   // If entry will definitely create a subtree, add a trailing slash
-  const entryCreatesSubtree =
-    value instanceof Array &&
-    (value[0] === ops.object ||
-      (value[0] === ops.getter &&
-        value[1] instanceof Array &&
-        (value[1][0] === ops.object || value[1][0] === ops.merge)));
-  return trailingSlash.toggle(key, entryCreatesSubtree);
+  if (value[0] === ops.object) {
+    // Subtree
+    return trailingSlash.add(key);
+  }
+
+  // See if it looks a merged object
+  if (value[1] === "_result" && value[0][0] === ops.object) {
+    // Merge
+    return trailingSlash.add(key);
+  }
+
+  return key;
 }
 
 function keys(object, eagerProperties, propertyIsEnumerable, entries) {

package/src/runtime/handlers.js

@@ -31,6 +31,7 @@ export async function handleExtension(parent, value, key, handlers) {
 
     // Special cases: `.ori.<ext>` extensions are Origami documents,
     // `.jse.<ext>` are JSE documents.
+    // TODO: Remove .jse.<ext>
     const extname = key.match(/\.ori\.\S+$/)
       ? ".oridocument"
       : key.match(/\.jse\.\S+$/)

package/src/runtime/jsGlobals.js

@@ -163,6 +163,9 @@ Object.defineProperty(globals, "globalThis", {
 export default globals;
 
 async function fetchWrapper(resource, options) {
+  console.warn(
+    "Warning: A plain `fetch` reference will eventually call the standard JavaScript fetch() function. For Origami's fetch behavior, update your code to call Origami.fetch()."
+  );
   const response = await fetch(resource, options);
   return response.ok ? await response.arrayBuffer() : undefined;
 }

package/src/runtime/ops.js

@@ -6,12 +6,13 @@
  */
 
 import {
-  ObjectTree,
-  Tree,
   deepText,
+  indent,
   isUnpackable,
+  ObjectTree,
   scope as scopeFn,
-  text as templateFunctionTree,
+  text,
+  Tree,
 } from "@weborigami/async-tree";
 import os from "node:os";
 import expressionObject from "./expressionObject.js";
@@ -20,7 +21,6 @@ import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import { codeSymbol } from "./symbols.js";
-import templateFunctionIndent from "./templateIndent.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -273,7 +273,7 @@ export function lambda(parameters, code) {
   invoke.code = code;
   return invoke;
 }
-addOpLabel(lambda, "«ops.lambda");
+addOpLabel(lambda, "«ops.lambda»");
 lambda.unevaluatedArgs = true;
 
 export function lessThan(a, b) {
@@ -293,7 +293,12 @@ addOpLabel(lessThanOrEqual, "«ops.lessThanOrEqual»");
  * literals.
  */
 export async function literal(value) {
-  return value;
+  if (value instanceof Array) {
+    // Strip code properties like `source`
+    return [...value];
+  } else {
+    return value;
+  }
 }
 addOpLabel(literal, "«ops.literal»");
 literal.unevaluatedArgs = true;
@@ -416,6 +421,45 @@ export function optionalTraverse(treelike, key) {
 }
 addOpLabel(optionalTraverse, "«ops.optionalTraverse");
 
+/**
+ * Return the indicated property
+ *
+ * @param {any} obj
+ * @param {string} key
+ */
+export async function property(obj, key) {
+  if (obj == null) {
+    throw new ReferenceError();
+  }
+
+  if (isUnpackable(obj)) {
+    obj = await obj.unpack();
+  } else if (typeof obj === "string") {
+    obj = new String(obj);
+  } else if (typeof obj === "number") {
+    obj = new Number(obj);
+  }
+
+  if (key in obj) {
+    // Object defines the property, get it
+    let value = obj[key];
+    // Is value an instance method? Copied from ObjectTree.
+    const isInstanceMethod =
+      !(obj instanceof Function) &&
+      value instanceof Function &&
+      !Object.hasOwn(obj, key);
+    if (isInstanceMethod) {
+      // Bind it to the object
+      value = value.bind(obj);
+    }
+    return value;
+  }
+
+  // Handle as tree traversal
+  return Tree.traverseOrThrow(obj, key);
+}
+addOpLabel(property, "«ops.property»");
+
 export function remainder(a, b) {
   return a % b;
 }
@@ -491,17 +535,17 @@ addOpLabel(subtraction, "«ops.subtraction»");
  * Apply the tree indent tagged template function.
  */
 export async function templateIndent(strings, ...values) {
-  return templateFunctionIndent(strings, ...values);
+  return indent(strings, ...values);
 }
 addOpLabel(templateIndent, "«ops.templateIndent»");
 
 /**
  * Apply the tree tagged template function.
  */
-export async function templateTree(strings, ...values) {
-  return templateFunctionTree(strings, ...values);
+export async function templateText(strings, ...values) {
+  return text(strings, ...values);
 }
-addOpLabel(templateTree, "«ops.templateTree»");
+addOpLabel(templateText, "«ops.templateText»");
 
 export function unaryMinus(a) {
   return -a;

package/test/compiler/compile.test.js

@@ -19,8 +19,7 @@ describe("compile", () => {
   test("functionComposition", async () => {
     await assertCompile("greet()", "Hello, undefined!");
     await assertCompile("greet(name)", "Hello, Alice!");
-    await assertCompile("greet(name)", "Hello, Alice!", { mode: "jse" });
-    await assertCompile("greet 'world'", "Hello, world!");
+    await assertCompile("greet 'world'", "Hello, world!", { mode: "shell" });
   });
 
   test("angle bracket path", async () => {
@@ -40,7 +39,7 @@ describe("compile", () => {
       {
         message: "Hello, Alice!",
       },
-      { mode: "jse" }
+      { mode: "shell" }
     );
   });
 
@@ -109,7 +108,7 @@ describe("compile", () => {
       tag: (strings, ...values) => {
         assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
-          assert.equal(strings, saved);
+          assert.deepEqual(strings, saved);
         } else {
           saved = strings;
         }
@@ -126,7 +125,7 @@ describe("compile", () => {
 });
 
 async function assertCompile(text, expected, options = {}) {
-  const mode = options.mode ?? "shell";
+  const mode = options.mode ?? "program";
   const fn = compile.expression(text, { globals: sharedGlobals, mode });
   const target = options.target ?? null;
   let result = await fn.call(target);

package/test/compiler/optimize.test.js

@@ -89,7 +89,7 @@ describe("optimize", () => {
       ],
     ];
     assertCompile(expression, expected);
-    assertCompile(expression, expected, "jse");
+    assertCompile(expression, expected, "shell");
   });
 
   describe("resolve reference", () => {
@@ -171,7 +171,7 @@ describe("optimize", () => {
         [markers.reference, "Math.PI"],
       ]);
       const globals = { Math: { PI: null } }; // value doesn't matter
-      const expected = [globals.Math, "PI"];
+      const expected = [ops.property, globals.Math, "PI"];
       assertCodeEqual(optimize(code, { globals }), expected);
     });
 
@@ -195,7 +195,8 @@ describe("optimize", () => {
       const locals = [["post"]];
       const actual = optimize(code, { globals, locals });
       const expected = [
-        [[[ops.context], [ops.literal, "post"]], "author"],
+        ops.property,
+        [ops.property, [[ops.context], [ops.literal, "post"]], "author"],
         "name",
       ];
       assertCodeEqual(actual, expected);