@weborigami/language 0.5.4 → 0.5.6

package/index.ts

@@ -1,4 +1,5 @@
 import { UnpackFunction } from "@weborigami/async-tree";
+import { AsyncTree } from "@weborigami/types";
 
 export * from "./main.js";
 
@@ -38,12 +39,6 @@ export type ExtensionHandler = {
   unpack?: UnpackFunction;
 }
 
-export type Position = {
-  column: number;
-  line: number;
-  offset: number;
-}
-
 /**
  * A mixin is a function that takes an existing class and returns a new class.
  *
@@ -56,6 +51,21 @@ export type Mixin<MixinMembers> = <T>(
   Base: Constructor<T>
 ) => Constructor<T & MixinMembers>;
 
+export type Position = {
+  column: number;
+  line: number;
+  offset: number;
+}
+
+export type RuntimeState = {
+  /** The container (e.g., file system) that holds the code */
+  container?: AsyncTree | null;
+  /** The object to which this code is attached */
+  object?: AsyncTree | null;
+  /** The current stack of function parameter assignments */
+  stack?: Array<Record<string, any>>;
+}
+
 /**
  * Source code representation used by the parser.
  */

package/main.js

@@ -2,17 +2,22 @@ export * from "./src/runtime/internal.js";
 
 export * as compile from "./src/compiler/compile.js";
 export { default as isOrigamiFrontMatter } from "./src/compiler/isOrigamiFrontMatter.js";
-export * from "./src/runtime/errors.js";
+export * as Handlers from "./src/handlers/handlers.js";
+export { default as builtins } from "./src/project/builtins.js";
+export { default as jsGlobals } from "./src/project/jsGlobals.js";
+export { default as projectGlobals } from "./src/project/projectGlobals.js";
+export { default as projectRoot } from "./src/project/projectRoot.js";
+export * as Protocols from "./src/protocols/protocols.js";
+export { formatError } from "./src/runtime/errors.js";
 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 * from "./src/runtime/handleExtension.js";
+export { default as handleExtension } from "./src/runtime/handleExtension.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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,9 @@
     "typescript": "5.9.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.5.4",
-    "@weborigami/types": "0.5.4",
+    "@weborigami/async-tree": "0.5.6",
+    "@weborigami/types": "0.5.6",
+    "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"
   },

package/src/compiler/compile.js

@@ -1,27 +1,33 @@
 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 { front, startRule } = options;
+  const { front, parent, startRule } = options;
   const mode = options.mode ?? "program";
-  const globals = options.globals ?? jsGlobals;
+  const globals = options.globals ?? {};
   if (typeof source === "string") {
     source = { text: source };
   }
+
+  // Parse the code
   let code = parse(source.text, {
     front,
     grammarSource: source,
     mode,
     startRule,
   });
+
+  // Optimize the code
   const cache = mode === "program" ? {} : null;
   const optimized = optimize(code, {
     cache,
     globals,
+    parent,
   });
-  const fn = createExpressionFunction(optimized);
+
+  // Create a function that executes the optimized code.
+  const fn = createExpressionFunction(optimized, parent);
   return fn;
 }
 

package/src/compiler/optimize.js

@@ -1,12 +1,13 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
+import jsGlobals from "../project/jsGlobals.js";
 import { entryKey } from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.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;
+export const REFERENCE_PARAM = 1;
+export const REFERENCE_INHERITED = 2;
+export const REFERENCE_GLOBAL = 3;
+export const REFERENCE_EXTERNAL = 4;
 
 /**
  * Optimize an Origami code instruction:
@@ -27,10 +28,12 @@ const REFERENCE_EXTERNAL = 3;
 export default function optimize(code, options = {}) {
   const globals = options.globals ?? jsGlobals;
   const cache = options.cache === undefined ? {} : options.cache;
+  const parent = options.parent ?? null;
 
   // 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.
+  // has been entered. The array grows to the right. Array items are objects
+  // { type, names }, where type is REFERENCE_PARAM or REFERENCE_INHERITED
+  // and names is an array of the variable names in that context.
   const locals = options.locals ? options.locals.slice() : [];
 
   // See if we can optimize this level of the code
@@ -41,13 +44,16 @@ export default function optimize(code, options = {}) {
       return globals[args[0]];
 
     case markers.traverse:
-      return resolvePath(code, globals, locals, cache);
+      return resolvePath(code, globals, parent, locals, cache);
 
     case ops.lambda:
       const parameters = args[0];
       if (parameters.length > 0) {
-        const names = parameters.map((param) => param[1]);
-        locals.push(names);
+        const paramNames = parameters.map((param) => param[1]);
+        locals.push({
+          type: REFERENCE_PARAM,
+          names: paramNames,
+        });
       }
       break;
 
@@ -56,8 +62,11 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      const keys = entries.map((entry) => entryKey(entry));
-      locals.push(keys);
+      const propertyNames = entries.map((entry) => entryKey(entry));
+      locals.push({
+        type: REFERENCE_INHERITED,
+        names: propertyNames,
+      });
       break;
   }
 
@@ -106,18 +115,29 @@ function avoidLocalRecursion(locals, key) {
     key = key.slice(1, -1);
   }
 
-  const currentFrame = locals.length - 1;
-  const matchingKeyIndex = locals[currentFrame].findIndex(
-    (localKey) =>
+  const currentFrameIndex = locals.length - 1;
+  if (locals[currentFrameIndex]?.type !== REFERENCE_INHERITED) {
+    // Not an inherited context, nothing to do
+    return locals;
+  }
+
+  // See if the key matches any of the local variable names in the current
+  // context (ignoring trailing slashes)
+  const matchingKeyIndex = locals[currentFrameIndex].names.findIndex(
+    (name) =>
       // Ignore trailing slashes when comparing keys
-      trailingSlash.remove(localKey) === trailingSlash.remove(key)
+      trailingSlash.remove(name) === 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);
+    const adjustedNames = adjustedLocals[currentFrameIndex].names.slice();
+    adjustedNames.splice(matchingKeyIndex, 1);
+    adjustedLocals[currentFrameIndex] = {
+      type: REFERENCE_INHERITED,
+      names: adjustedNames,
+    };
     return adjustedLocals;
   } else {
     return locals;
@@ -135,49 +155,54 @@ function compoundReference(key, globals, locals, location) {
   const parts = key.split(".");
   if (parts.length === 1) {
     // Not a compound reference
-    return { type: REFERENCE_EXTERNAL, result: null };
+    return 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);
-  } else if (type === REFERENCE_LOCAL) {
-    result = localReference(head, locals, location);
-  } else {
-    // Not a compound reference
-    return { type: REFERENCE_EXTERNAL, result: null };
+  const headReference = localOrGlobalReference(head, globals, locals, location);
+  if (headReference === null) {
+    // First part isn't global/local reference, so not a compound reference
+    return null;
   }
 
+  let result = headReference.result;
+
   // Process the remaining parts as property accesses
   while (tail.length > 0) {
     const part = tail.shift();
     result = annotate([ops.property, result, part], location);
   }
 
-  return { type, result };
+  return { type: headReference.type, result };
 }
 
-function externalReference(key, locals, location) {
-  const scope = scopeCall(locals, location);
+function externalReference(key, parent, location) {
+  const scope = annotate([ops.scope, parent], 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
+function findLocalDetails(key, locals) {
+  const normalized = trailingSlash.remove(key);
+  let paramDepth = 0;
+  let inheritedDepth = 0;
+  for (let i = locals.length - 1; i >= 0; i--) {
+    const { type, names } = locals[i];
+    const local = names.find(
+      (name) => trailingSlash.remove(name) === normalized
+    );
+    if (local) {
+      const depth = type === REFERENCE_PARAM ? paramDepth : inheritedDepth;
+      return { type, depth };
+    }
+    if (type === REFERENCE_PARAM) {
+      paramDepth++;
+    } else {
+      inheritedDepth++;
+    }
   }
-  const depth = locals.length - contextIndex - 1;
-  return depth;
+  return null;
 }
 
 function globalReference(key, globals) {
@@ -185,25 +210,18 @@ function globalReference(key, globals) {
   return globals[normalized];
 }
 
+function inheritedReference(key, depth, location) {
+  const literal = annotate([ops.literal, key], location);
+  const inherited = annotate([ops.inherited, depth], location);
+  return annotate([inherited, literal], 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);
-  /** @type {any[]} */
-  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) {
@@ -224,7 +242,37 @@ function keyFromCode(code) {
   }
 }
 
-function reference(code, globals, locals) {
+function localOrGlobalReference(key, globals, locals, location) {
+  // Is key a local?
+  const normalized = trailingSlash.remove(key);
+  const localDetails = findLocalDetails(normalized, locals);
+  if (localDetails) {
+    const { type, depth } = localDetails;
+    const result =
+      type === REFERENCE_PARAM
+        ? paramReference(key, depth, location)
+        : inheritedReference(key, depth, location);
+    return { type, result };
+  }
+
+  // Is key a global?
+  if (normalized in globals) {
+    return {
+      type: REFERENCE_GLOBAL,
+      result: globalReference(key, globals),
+    };
+  }
+
+  return null;
+}
+
+function paramReference(key, depth, location) {
+  const literal = annotate([ops.literal, key], location);
+  const params = annotate([ops.params, depth], location);
+  return annotate([params, literal], location);
+}
+
+function reference(code, globals, parent, locals) {
   const key = keyFromCode(code);
   const normalized = trailingSlash.remove(key);
   const location = code.location;
@@ -247,61 +295,43 @@ function reference(code, globals, locals) {
     // Explicit external reference
     return {
       type: REFERENCE_EXTERNAL,
-      result: externalReference(key, locals, location),
+      result: externalReference(key, parent, location),
     };
   }
 
   // See if the whole key is a global or local variable
-  let type = referenceType(key, globals, locals);
-  if (type === REFERENCE_GLOBAL) {
-    return {
-      type,
-      result: globalReference(key, globals),
-    };
-  } else if (type === REFERENCE_LOCAL) {
-    return {
-      type,
-      result: localReference(key, locals, location),
-    };
+  const whole = localOrGlobalReference(key, globals, locals, location);
+  if (whole) {
+    return whole;
   }
 
   // Try key as a compound reference x.y.z
   const compound = compoundReference(key, globals, locals, location);
-  if (compound.type !== REFERENCE_EXTERNAL) {
+  if (compound) {
     return compound;
   }
 
-  // Not a compound reference, must be external
+  // Must be external
   return {
     type: REFERENCE_EXTERNAL,
-    result: externalReference(key, locals, location),
+    result: externalReference(key, parent, location),
   };
 }
 
-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) {
+function resolvePath(code, globals, parent, locals, cache) {
   const args = code.slice(1);
   const [head, ...tail] = args;
 
-  let { type, result } = reference(head, globals, locals);
+  let { type, result } = reference(head, globals, parent, locals);
 
   if (tail.length > 0) {
     // If the result is a traversal, we can safely extend it
     const extendResult =
       result instanceof Array &&
       result[0] instanceof Array &&
-      (result[0][0] === ops.scope || result[0][0] === ops.context);
+      (result[0][0] === ops.scope ||
+        result[0][0] === ops.params ||
+        result[0][0] === ops.inherited);
     if (extendResult) {
       result.push(...tail);
     } else {
@@ -316,15 +346,3 @@ function resolvePath(code, globals, locals, cache) {
 
   return result;
 }
-
-function scopeCall(locals, location) {
-  const depth = locals.length;
-  /** @type {any[]} */
-  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);
-}

package/src/compiler/origami.pegjs

@@ -207,9 +207,6 @@ doubleQuoteStringChar
 
 ellipsis
   = "..."
-  / "…" {
-    console.warn("The use of the Unicode ellipsis character for an object spread is deprecated; use `...` (three periods) instead.");
-  }
 
 equalityExpression
   = head:relationalExpression tail:(__ @equalityOperator __ @relationalExpression)* {
@@ -719,7 +716,7 @@ shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
   = (shellMode / programMode) "=" !"=" __ definition:implicitParenthesesCallExpression {
       if (options.mode === "program") {
-        console.warn("Warning: the shorthand function syntax is deprecated in Origami programs. Use arrow syntax instead.");
+        throw new Error("Parse error: shorthand function syntax isn't allowed in Origami programs. Use arrow syntax instead.");
       }
       const lambdaParameters = annotate(
         [annotate([ops.literal, "_"], location())],