@weborigami/language 0.3.3 → 0.3.4-jse.4

package/main.js

@@ -7,13 +7,15 @@ export { default as evaluate } from "./src/runtime/evaluate.js";
 export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
 export * as expressionFunction from "./src/runtime/expressionFunction.js";
 export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";
+export { default as getHandlers } from "./src/runtime/getHandlers.js";
 export { default as HandleExtensionsTransform } from "./src/runtime/HandleExtensionsTransform.js";
 export * from "./src/runtime/handlers.js";
 export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
 export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
+export { default as jsGlobals } from "./src/runtime/jsGlobals.js";
 export * as moduleCache from "./src/runtime/moduleCache.js";
 export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
 export * as symbols from "./src/runtime/symbols.js";
-export { default as taggedTemplateIndent } from "./src/runtime/taggedTemplateIndent.js";
+export { default as taggedTemplateIndent } from "./src/runtime/templateIndent.js";
 export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
 export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.3.3",
+  "version": "0.3.4-jse.4",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.3.3",
-    "@weborigami/types": "0.3.3",
+    "@weborigami/async-tree": "0.3.4-jse.4",
+    "@weborigami/types": "0.3.4-jse.4",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/compile.js

@@ -1,18 +1,28 @@
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
+import jsGlobals from "../runtime/jsGlobals.js";
 import optimize from "./optimize.js";
 import { parse } from "./parse.js";
 
 function compile(source, options) {
-  const { macros, startRule } = options;
+  const { front, startRule } = options;
+  const mode = options.mode ?? "shell";
+  const globals = options.globals ?? jsGlobals;
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
-  const code = parse(source.text, {
+  let code = parse(source.text, {
+    front,
     grammarSource: source,
+    mode,
     startRule,
   });
-  const optimized = optimize(code, enableCaching, macros);
+  const cache = enableCaching ? {} : null;
+  const optimized = optimize(code, {
+    cache,
+    globals,
+    mode,
+  });
   const fn = createExpressionFunction(optimized);
   return fn;
 }

package/src/compiler/isOrigamiFrontMatter.js

@@ -3,14 +3,15 @@
  *
  * Our heurstic is to see skip any initial alphanumeric or underscore
  * characters, then see if the next character is a parenthesis, dot, slash,
- * curly brace, or equals sign. If so, we assume this is an Origami expression.
+ * curly brace, left angle bracket, or equals sign. If so, we assume this is an
+ * Origami expression.
  *
  * The goal is to identify Origami front matter like:
  *
  * ```
  *   fn(x)              function call
  *   index.ori()        file extension
- *   src/data.json      file path
+ *   <src/data.json>    file path
  *   // Hello           comment
  *   { a: 1 }           object literal
  * ```
@@ -22,5 +23,5 @@
  * @param {string} text
  */
 export default function isOrigamiFrontMatter(text) {
-  return /^[ \t\r\n]*[A-Za-z0-9_]*[\(\.\/\{=]/.test(text);
+  return /^[ \t\r\n]*[A-Za-z0-9_]*[\(\.\/\{<=]/.test(text);
 }

package/src/compiler/optimize.js

@@ -1,142 +1,309 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
+import { entryKey } from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
-import { annotate, undetermined } from "./parserHelpers.js";
+import jsGlobals from "../runtime/jsGlobals.js";
+import { annotate, markers } from "./parserHelpers.js";
+
+const REFERENCE_LOCAL = 1;
+const REFERENCE_GLOBAL = 2;
+const REFERENCE_EXTERNAL = 3;
 
 /**
  * Optimize an Origami code instruction:
  *
- * - Transform any remaining undetermined references to scope references.
- * - Transform those or explicit ops.scope calls to ops.external calls unless
- *   they refer to local variables (variables defined by object literals or
- *   lambda parameters).
- * - Apply any macros to the code.
+ * - Resolve local references to the appropriate context
+ * - Resolve global references to the globals object
+ * - Resolve other references to external values
+ * - Determine whether x.y is a file name or property access
+ * - Determine whether x/y is a file path or division operation
  *
  * @typedef {import("./parserHelpers.js").AnnotatedCode} AnnotatedCode
  * @typedef {import("./parserHelpers.js").Code} Code
  *
  * @param {AnnotatedCode} code
- * @param {boolean} enableCaching
- * @param {Record<string, AnnotatedCode>} macros
- * @param {Record<string, AnnotatedCode>} cache
- * @param {Record<string, boolean>} locals
+ * @param {any} options
  * @returns {AnnotatedCode}
  */
-export default function optimize(
-  code,
-  enableCaching = true,
-  macros = {},
-  cache = {},
-  locals = {}
-) {
+export default function optimize(code, options = {}) {
+  const globals = options.globals ?? jsGlobals;
+  const cache = options.cache ?? {};
+
+  // The locals is an array, one item for each function or object context that
+  // has been entered. The array grows to the right. The array items are
+  // subarrays containing the names of local variables defined in that context.
+  const locals = options.locals ? options.locals.slice() : [];
+
   // See if we can optimize this level of the code
-  const [fn, ...args] = code;
-  let additionalLocalNames;
-  switch (fn) {
+  const [op, ...args] = code;
+  switch (op) {
+    case markers.global:
+      // Replace global op with the globals
+      return annotate([globals, args[0]], code.location);
+
+    case markers.traverse:
+      return resolvePath(code, globals, locals, cache);
+
     case ops.lambda:
       const parameters = args[0];
-      additionalLocalNames = parameters.map((param) => param[1]);
+      if (parameters.length > 0) {
+        const names = parameters.map((param) => param[1]);
+        locals.push(names);
+      }
       break;
 
     case ops.literal:
-      const value = args[0];
-      if (!(value instanceof Array)) {
-        return value;
-      }
-      break;
+      return inlineLiteral(code);
 
     case ops.object:
       const entries = args;
-      additionalLocalNames = entries.map(([key]) => trailingSlash.remove(key));
+      const keys = entries.map(entryKey);
+      locals.push(keys);
       break;
+  }
 
-    // Both of these are handled the same way
-    case undetermined:
-    case ops.scope:
-      const key = args[0];
-      const normalizedKey = trailingSlash.remove(key);
-      if (macros?.[normalizedKey]) {
-        // Apply macro
-        const macro = macros?.[normalizedKey];
-        return applyMacro(macro, code, enableCaching, macros, cache, locals);
-      } else if (enableCaching && !locals[normalizedKey]) {
-        // Upgrade to cached external scope reference
-        return annotate(
-          [ops.external, key, annotate([ops.scope, key], code.location), cache],
-          code.location
-        );
-      } else if (fn === undetermined) {
-        // Transform undetermined reference to regular scope call
-        return annotate([ops.scope, key], code.location);
+  // Optimize children
+  const optimized = annotate(
+    code.map((child, index) => {
+      // Don't optimize lambda parameter names
+      if (op === ops.lambda && index === 1) {
+        return child;
+      } else if (op === ops.object && index > 0) {
+        const [key, value] = child;
+        const adjustedLocals = avoidLocalRecursion(locals, key);
+        return [
+          key,
+          optimize(/** @type {AnnotatedCode} */ (value), {
+            ...options,
+            locals: adjustedLocals,
+          }),
+        ];
+      } else if (Array.isArray(child) && "location" in child) {
+        // Review: Aside from ops.object (above), what non-instruction arrays
+        // does this descend into?
+        return optimize(/** @type {AnnotatedCode} */ (child), {
+          ...options,
+          locals,
+        });
       } else {
-        // Internal ops.scope call; leave as is
-        return code;
+        return child;
       }
+    }),
+    code.location
+  );
 
-    case ops.traverse:
-      // Is the first argument a nonscope/undetermined reference?
-      const isScopeRef =
-        args[0]?.[0] === ops.scope || args[0]?.[0] === undetermined;
-      if (enableCaching && isScopeRef) {
-        // Is the first argument a nonlocal reference?
-        const normalizedKey = trailingSlash.remove(args[0][1]);
-        if (!locals[normalizedKey]) {
-          // Are the remaining arguments all literals?
-          const allLiterals = args
-            .slice(1)
-            .every((arg) => arg[0] === ops.literal);
-          if (allLiterals) {
-            // Convert to ops.external
-            const keys = args.map((arg) => arg[1]);
-            const path = pathFromKeys(keys);
-            /** @type {Code} */
-            const optimized = [ops.external, path, code, cache];
-            return annotate(optimized, code.location);
-          }
-        }
-      }
-      break;
+  return annotate(optimized, code.location);
+}
+
+// When defining a property named `key` (or `key/` or `(key)`), we need to
+// remove any local variable with that name from the stack of locals to avoid a
+// recursive reference.
+function avoidLocalRecursion(locals, key) {
+  if (key[0] === "(" && key[key.length - 1] === ")") {
+    // Non-enumerable property, remove parentheses
+    key = key.slice(1, -1);
   }
 
-  // Add any locals introduced by this code to the list that will be consulted
-  // when we descend into child nodes.
-  let updatedLocals;
-  if (additionalLocalNames) {
-    updatedLocals = { ...locals };
-    for (const key of additionalLocalNames) {
-      updatedLocals[key] = true;
-    }
+  const currentFrame = locals.length - 1;
+  const matchingKeyIndex = locals[currentFrame].findIndex(
+    (localKey) =>
+      // Ignore trailing slashes when comparing keys
+      trailingSlash.remove(localKey) === trailingSlash.remove(key)
+  );
+
+  if (matchingKeyIndex >= 0) {
+    // Remove the key from the current context's locals
+    const adjustedLocals = locals.slice();
+    adjustedLocals[currentFrame] = adjustedLocals[currentFrame].slice();
+    adjustedLocals[currentFrame].splice(matchingKeyIndex, 1);
+    return adjustedLocals;
   } else {
-    updatedLocals = locals;
+    return locals;
   }
+}
 
-  // Optimize children
-  const optimized = code.map((child, index) => {
-    // Don't optimize lambda parameter names
-    if (fn === ops.lambda && index === 1) {
-      return child;
-    } else if (Array.isArray(child) && "location" in child) {
-      // Review: This currently descends into arrays that are not instructions,
-      // such as the entries of an ops.object. This should be harmless, but it'd
-      // be preferable to only descend into instructions. This would require
-      // surrounding ops.object entries with ops.array.
-      return optimize(
-        /** @type {AnnotatedCode} */ (child),
-        enableCaching,
-        macros,
-        cache,
-        updatedLocals
-      );
-    } else {
-      return child;
-    }
-  });
+function cachePath(code, cache) {
+  const keys = code.map(keyFromCode).filter((key) => key !== null);
+  const path = pathFromKeys(keys);
+  return annotate([ops.cache, cache, path, code], code.location);
+}
 
-  return annotate(optimized, code.location);
+// A reference with periods like x.y.z
+function compoundReference(key, globals, locals, location) {
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    // Not a compound reference
+    return { type: REFERENCE_EXTERNAL, result: null };
+  }
+
+  // Check first part to see if it's a global or local reference
+  const [head, ...tail] = parts;
+  const type = referenceType(head, globals, locals);
+  let result;
+  if (type === REFERENCE_GLOBAL) {
+    result = globalReference(head, globals, location);
+  } else if (type === REFERENCE_LOCAL) {
+    result = localReference(head, locals, location);
+  } else {
+    // Not a compound reference
+    return { type: REFERENCE_EXTERNAL, result: null };
+  }
+
+  // Process the remaining parts as property accesses
+  while (tail.length > 0) {
+    const part = tail.shift();
+    result = annotate([result, part], location);
+  }
+
+  return { type, result };
+}
+
+function externalReference(key, locals, location) {
+  const scope = scopeCall(locals, location);
+  const literal = annotate([ops.literal, key], location);
+  return annotate([scope, literal], location);
+}
+
+// Determine how many contexts up we need to go for a local
+function getLocalReferenceDepth(locals, key) {
+  const contextIndex = locals.findLastIndex((names) =>
+    names.some(
+      (name) => trailingSlash.remove(name) === trailingSlash.remove(key)
+    )
+  );
+  if (contextIndex < 0) {
+    return -1; // Not a local reference
+  }
+  const depth = locals.length - contextIndex - 1;
+  return depth;
+}
+
+function globalReference(key, globals, location) {
+  const normalized = trailingSlash.remove(key);
+  return annotate([globals, normalized], location);
+}
+
+function inlineLiteral(code) {
+  // If the literal value is an array, it's likely the strings array
+  // of a template literal, so return it as is.
+  return code[0] === ops.literal && !Array.isArray(code[1]) ? code[1] : code;
+}
+
+function localReference(key, locals, location) {
+  const normalized = trailingSlash.remove(key);
+  const depth = getLocalReferenceDepth(locals, normalized);
+  const context = [ops.context];
+  if (depth > 0) {
+    context.push(depth);
+  }
+  const contextCall = annotate(context, location);
+  const literal = annotate([ops.literal, key], location);
+  return annotate([contextCall, literal], location);
+}
+
+function keyFromCode(code) {
+  const op = code instanceof Array ? code[0] : code;
+  switch (op) {
+    case ops.homeDirectory:
+      return "~";
+
+    case markers.external:
+    case markers.global:
+    case markers.reference:
+    case ops.literal:
+      return code[1];
+
+    case ops.rootDirectory:
+      return "/";
+
+    default:
+      return null;
+  }
 }
 
-function applyMacro(macro, code, enableCaching, macros, cache, locals) {
-  const optimized = optimize(macro, enableCaching, macros, cache, locals);
-  return optimized instanceof Array
-    ? annotate(optimized, code.location)
-    : optimized;
+function reference(code, globals, locals) {
+  const key = keyFromCode(code);
+  const normalized = trailingSlash.remove(key);
+  const location = code.location;
+
+  if (normalized === "~") {
+    // Special case for home directory
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: annotate([ops.homeDirectory], location),
+    };
+  } else if (normalized === "") {
+    // Special case for root directory
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: annotate([ops.rootDirectory], location),
+    };
+  }
+
+  if (code[0] === markers.external) {
+    // Explicit external reference
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: externalReference(key, locals, location),
+    };
+  }
+
+  // See if the whole key is a global or local variable
+  let type = referenceType(key, globals, locals);
+  let result;
+  if (type === REFERENCE_GLOBAL) {
+    result = globalReference(key, globals, location);
+  } else if (type === REFERENCE_LOCAL) {
+    result = localReference(key, locals, location);
+  } else {
+    // Try key as a compound reference x.y.z
+    const compound = compoundReference(key, globals, locals, location);
+    result = compound?.result;
+    type = compound?.type;
+  }
+
+  if (!result) {
+    // If none of the above worked, it must be an external reference
+    result = externalReference(key, locals, location);
+  }
+
+  return { type, result };
+}
+
+function referenceType(key, globals, locals) {
+  // Check if the key is a global variable
+  const normalized = trailingSlash.remove(key);
+  if (getLocalReferenceDepth(locals, normalized) >= 0) {
+    return REFERENCE_LOCAL;
+  } else if (normalized in globals) {
+    return REFERENCE_GLOBAL;
+  } else {
+    return REFERENCE_EXTERNAL;
+  }
+}
+
+function resolvePath(code, globals, locals, cache) {
+  const args = code.slice(1);
+  const [head, ...tail] = args;
+
+  let { type, result } = reference(head, globals, locals);
+
+  result.push(...tail);
+
+  if (type === REFERENCE_EXTERNAL && cache !== null) {
+    // Cache external path
+    return cachePath(result, cache);
+  }
+
+  return result;
+}
+
+function scopeCall(locals, location) {
+  const depth = locals.length;
+  const code = [ops.scope];
+  if (depth > 0) {
+    // Add context for appropriate depth to scope call
+    const contextCode = annotate([ops.context, depth], location);
+    code.push(contextCode);
+  }
+  return annotate(code, location);
 }