@weborigami/language 0.6.4 → 0.6.6

package/main.js

@@ -4,14 +4,18 @@ export * as compile from "./src/compiler/compile.js";
 export { default as isOrigamiFrontMatter } from "./src/compiler/isOrigamiFrontMatter.js";
 export * as Handlers from "./src/handlers/handlers.js";
 export { default as builtins } from "./src/project/builtins.js";
+export { default as coreGlobals } from "./src/project/coreGlobals.js";
 export { default as jsGlobals } from "./src/project/jsGlobals.js";
+export { default as projectConfig } from "./src/project/projectConfig.js";
 export { default as projectGlobals } from "./src/project/projectGlobals.js";
 export { default as projectRoot } from "./src/project/projectRoot.js";
+export { default as projectRootFromPath } from "./src/project/projectRootFromPath.js";
 export * as Protocols from "./src/protocols/protocols.js";
 export { formatError, highlightError } 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 expressionObject } from "./src/runtime/expressionObject.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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.4",
+    "@weborigami/async-tree": "0.6.6",
     "exif-parser": "0.1.12",
     "watcher": "2.3.1",
     "yaml": "2.8.1"

package/src/compiler/optimize.js

@@ -1,6 +1,10 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
 import jsGlobals from "../project/jsGlobals.js";
-import { entryKey } from "../runtime/expressionObject.js";
+import {
+  KEY_TYPE,
+  normalizeKey,
+  propertyInfo,
+} from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
 import { annotate, markers, spanLocations } from "./parserHelpers.js";
 
@@ -47,9 +51,9 @@ export default function optimize(code, options = {}) {
       return resolvePath(code, globals, parent, locals, cache);
 
     case ops.lambda:
-      const parameters = args[0];
+      const parameters = args[1];
       if (parameters.length > 0) {
-        const paramNames = parameters.map((param) => param[1]);
+        const paramNames = parameters.map((param) => param[0]);
         locals.push({
           type: REFERENCE_PARAM,
           names: paramNames,
@@ -62,10 +66,7 @@ export default function optimize(code, options = {}) {
 
     case ops.object:
       const entries = args;
-      // Filter out computed property keys when determining local variables
-      const propertyNames = entries
-        .map((entry) => entryKey(entry))
-        .filter((key) => key !== null);
+      const propertyNames = getPropertyNames(entries);
       locals.push({
         type: REFERENCE_INHERITED,
         names: propertyNames,
@@ -76,10 +77,7 @@ export default function optimize(code, options = {}) {
   // 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) {
+      if (op === ops.object && index > 0) {
         const [key, value] = child;
         const adjustedLocals = avoidLocalRecursion(locals, key);
         const optimizedKey =
@@ -210,6 +208,14 @@ function findLocalDetails(key, locals) {
   return null;
 }
 
+function getPropertyNames(entries) {
+  const infos = entries.map(([key, value]) => propertyInfo(key, value));
+  // Filter out computed property keys when determining local variables
+  return infos
+    .filter((info) => info.keyType !== KEY_TYPE.COMPUTED)
+    .map((info) => normalizeKey(info));
+}
+
 function globalReference(key, globals) {
   const normalized = trailingSlash.remove(key);
   return globals[normalized];

package/src/compiler/origami.pegjs

@@ -21,6 +21,7 @@ import {
   makeCallChain,
   makeDeferredArguments,
   makeDocument,
+  makeLambda,
   makeObject,
   makePath,
   makePipeline,
@@ -101,18 +102,18 @@ arrayEntries
 arrayEntry
   = spreadElement
   / pipelineExpression
-  // JavaScript treats a missing value as `undefined`
-  / __ !"]" {
+  / &separator {
+      // Missing value is allowed
       return annotate([ops.literal, undefined], location());
     }
 
 arrowFunction
-  = ("async" __)? "(" __ parameters:parameterList? __ ")" __ doubleArrow __ pipeline:expectPipelineExpression {
-      const lambdaParameters = parameters ?? annotate([], location());
-      return annotate([ops.lambda, lambdaParameters, pipeline], location());
+  = ("async" __)? "(" __ parameters:paramList? __ ")" __ doubleArrow __ body:expectPipelineExpression {
+      parameters ??= annotate([], location());
+      return makeLambda(parameters, body, location());
     }
-  / parameter:parameterSingleton __ doubleArrow __ pipeline:expectPipelineExpression {
-      return annotate([ops.lambda, parameter, pipeline], location());
+  / parameters:paramSingleton __ doubleArrow __ body:expectPipelineExpression {
+      return makeLambda(parameters, body, location());
     }
   / conditionalExpression
 
@@ -162,16 +163,18 @@ comment "comment"
   / singleLineComment
 
 computedPropertyAccess
-  = computedPropertySpace "[" expression:expectExpression expectClosingBracket {
+  = computedPropertySpace? "[" expression:expectExpression expectClosingBracket {
       return annotate([markers.property, expression], location());
     }
 
-// A space before a computed property access. This is allowed when not in shell
-// mode. In shell mode `foo [bar]` should parse as a function call with a single
-// argument of an array, not as a property access.
+// An inline space before a computed property access. This is allowed when not
+// in shell mode. In shell mode `foo [bar]` should parse as a function call with
+// a single argument of an array, not as a property access. In program made, we
+// allow an inline space per JavaScript. JavaScript also allows newlines, but we
+// disallow those to avoid confusion with array/list/object entry separators.
 computedPropertySpace
   = shellMode
-  / !shellMode __
+  / !shellMode inlineSpace
 
 conditionalExpression
   = condition:logicalOrExpression tail:(__
@@ -189,9 +192,6 @@ conditionalExpression
         deferred[1]
       ], location());
     }
-  
-digits
-  = @[0-9]+
 
 doubleArrow = "⇒" / "=>"
 
@@ -269,7 +269,13 @@ expectFrontDelimiter
       error("Expected \"---\"");
     }
 
-expectGuillemet
+expectLeftGuillemet
+  = '«'
+  / .? {
+      error("Expected closing guillemet");
+    }
+
+expectRightGuillemet
   = '»'
   / .? {
       error("Expected closing guillemet");
@@ -303,11 +309,6 @@ exponentiationExpression
 expression
   = __ @commaExpression __
 
-floatLiteral "floating-point number"
-  = digits? "." digits {
-      return annotate([ops.literal, parseFloat(text())], location());
-    }
-
 // Marker for the beginning or end of front matter
 frontDelimiter
   = "---\n"
@@ -336,19 +337,22 @@ group "parenthetical group"
   }
 
 guillemetString "guillemet string"
-  = '«' chars:guillemetStringChar* expectGuillemet {
-    return annotate([ops.literal, chars.join("")], location());
-  }
+  = "«" chars:guillemetStringChar* expectRightGuillemet {
+      return annotate([ops.literal, chars.join("")], location());
+    }
+  / "»" chars:guillemetStringChar* expectLeftGuillemet {
+      return annotate([ops.literal, chars.join("")], location());
+    }
 
 guillemetStringChar
-  = !('»' / newLine) @textChar
+  = !("«" / "»" / newLine) @textChar
 
 // A host identifier that may include a colon and port number: `example.com:80`.
 // This is used as a special case at the head of a path, where we want to
 // interpret a colon as part of a text identifier.
 host "HTTP/HTTPS host"
-  = name:hostname port:(":" @integerLiteral)? slashFollows:slashFollows? {
-      const portText = port ? `:${port[1]}` : "";
+  = name:hostname port:port? slashFollows:slashFollows? {
+      const portText = port ?? "";
       const slashText = slashFollows ? "/" : "";
       const host = name + portText + slashText;
       return annotate([ops.literal, host], location());
@@ -407,11 +411,6 @@ implicitParenthesesCallExpression "function call with implicit parentheses"
 inlineSpace
   = [ \t]
 
-integerLiteral "integer"
-  = digits {
-      return annotate([ops.literal, parseInt(text())], location());
-    }
-
 // A key in a path or an expression that looks like one
 key
   = keyCharStart keyChar* {
@@ -435,7 +434,7 @@ keyChar
 keyCharStart
   // All JS identifier characters
   = char:. &{ return char.match(/[$_\p{ID_Continue}]/u) }
-  / "."
+  / "." !".." // a dot, but not a spread/rest operator
   / "@"
   / "~"
 
@@ -494,10 +493,52 @@ newLine
   / "\r\n"
   / "\r"
 
+number
+  = numberBigInt
+  / numberStandard {
+      const stripped = text().replace("_", ""); // remove underscores
+      return Number(stripped);
+    }
+
+numberBigInt
+  = digits:numberDecimalDigits "n"  {
+      const stripped = digits.replace("_", ""); // remove underscores
+      return BigInt(stripped);
+    }
+
+numberBinary
+  = "0" [bB] digits:[01_]+
+
+numberDecimal
+  = numberDecimalDigits? "." numberDecimalDigits numberExponent?
+  / numberDecimalDigits numberExponent?
+
+numberDecimalDigits
+  = [0-9]([_]*[0-9])* {
+    return text();
+  }
+
+numberExponent
+  = [eE] [+\-]? digits:numberDecimalDigits
+
+numberHex
+  = "0" [xX] digits:[0-9a-fA-F_]+
+
 // A number
-numericLiteral "number"
-  = floatLiteral
-  / integerLiteral
+numberLiteral "number"
+  = number:number {
+      return annotate([ops.literal, number], location());
+    }
+
+numberOctal
+  = "0" [oO] digits:[0-7]+
+
+// Any number that can be parsed with Number(); i.e., not a bigint
+numberStandard
+  = numberBinary
+  / numberOctal
+  / numberHex
+  / numberDecimal
 
 nullishCoalescingExpression
   = head:logicalAndExpression tail:(__ "??" __ @logicalAndExpression)* {
@@ -586,20 +627,112 @@ optional
       return annotate([ops.optional, propertyAccess], location());
     }
 
-// Name of a function parameter
-parameter
+paramArray
+  = "[" __ entries:paramArrayEntries __ "]" {
+      return annotate([markers.paramArray, ...entries], location());
+    }
+
+// A list of parameters inside array destructuring: `a, b` in `([a, b]) => a + b`
+// Different than top-level parameters because elements can be elided: `a, , b`
+paramArrayEntries
+  = entries:paramArrayEntry|1.., separator| rest:(separator @paramRest?)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
+    }
+
+// Single parameter in a function's parameter list
+param
+  = paramNameWithInitilializer
+  / pattern:paramBindingPattern initializer:paramInitializer? {
+      return initializer
+        ? annotate([markers.paramInitializer, pattern, initializer], location())
+        : pattern;
+    }
+
+paramArrayEntry
+  = param
+  / &separator {
+      // Missing value is allowed
+      return undefined;
+    }
+
+paramBindingPattern
+  = paramArray
+  / paramObject
+
+paramInitializer
+  = __ "=" __ @pipelineExpression
+
+// A list of lambda parameters inside the parentheses: `a, b` in `(a, b) => a + b`
+paramList
+  = entries:param|1.., separator| rest:(separator @paramRest?)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
+    }
+
+// A single name in a parameter list: `a` in `a, b`
+paramName
   = key:key {
-      return annotate([ops.literal, key], location());
+      return annotate([markers.paramName, key], location());
+    }
+
+paramNameWithInitilializer
+  = name:paramName initializer:paramInitializer? {
+      return initializer
+        ? annotate([markers.paramInitializer, name, initializer], location())
+        : name;
     }
 
-parameterList
-  = list:parameter|1.., separator| separator? {
-      return annotate(list, location());
+// Object binding pattern in function parameter: `{ a, b: c }`
+paramObject
+  = "{" __ entries:paramObjectEntries? __ "}" {
+      return annotate([markers.paramObject, ...(entries ?? [])], location());
     }
 
-// A list with a single identifier
-parameterSingleton
-  = param:parameter {
+// A separated list of parameter object entries inside the curly braces
+paramObjectEntries
+  = entries:paramObjectEntry|1.., separator| rest:(separator @paramRest)? {
+      if (rest) {
+        entries.push(rest);
+      }
+      return annotate(entries, location());
+    }
+  / rest:paramRest {
+      return annotate([rest], location());
+    }
+
+// An entry in a parameter object: `a: b` in `{ a: b }`
+paramObjectEntry
+  = key:objectPublicKey __ ":" __ param:param {
+      return annotate([key, param], location());
+    }
+  / name:paramName initializer:paramInitializer? {
+      const binding = initializer
+        ? annotate([markers.paramInitializer, name, initializer], location())
+        : name;
+      return annotate([name[1], binding], location());
+    }
+
+// Optional rest parameter for param array or object
+paramRest
+  = "..." __ param:param {
+    return annotate([markers.paramRest, param], location());
+    }
+
+// A lambda parameter list with a single identifier with no parentheses:
+// `x` in `x => x + 1`
+paramSingleton
+  = param:paramName {
       return annotate([param], location());
     }
 
@@ -619,7 +752,7 @@ parenthesesArgumentList "list"
 // Function arguments in parentheses
 parenthesesArguments "function arguments in parentheses"
   = inlineSpace* "(" __ list:parenthesesArgumentList? __ expectClosingParenthesis {
-      return annotate(list ?? [undefined], location());
+      return annotate(list ?? [], location());
     }
 
 // A slash-separated path of keys that follows a call target, such as the path
@@ -660,6 +793,11 @@ pipelineExpression
       );
     }
 
+port
+  = ":" [0-9]+ {
+    return text();
+  }
+
 primary
   // The following start with distinct characters
   = stringLiteral
@@ -671,7 +809,7 @@ primary
   / templateLiteral
 
   // These are more ambiguous
-  / @numericLiteral !keyChar // numbers + chars would be a key
+  / @numberLiteral !keyChar // numbers + chars would be a key
   / pathLiteral
 
 // Top-level Origami progam with possible shebang directive (which is ignored)
@@ -741,15 +879,13 @@ shiftOperator
 // A shorthand lambda expression: `=foo(_)`
 shorthandFunction "lambda function"
   // Avoid a following equal sign (for an equality)
-  = (shellMode / programMode) "=" !"=" __ definition:implicitParenthesesCallExpression {
+  = (shellMode / programMode) "=" !"=" __ body:implicitParenthesesCallExpression {
       if (options.mode === "program") {
         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())],
-        location()
-      );
-      return annotate([ops.lambda, lambdaParameters, definition], location());
+      const underscore = annotate([markers.paramName, "_"], location());
+      const parameters = annotate([underscore], location());
+      return makeLambda(parameters, body, location());
     }
   / implicitParenthesesCallExpression
 
@@ -824,11 +960,9 @@ templateDocument "template document"
       if (options.front) {
         return makeDocument(options.front, body, location());
       }
-      const lambdaParameters = annotate(
-        [annotate([ops.literal, "_"], location())],
-        location()
-      );
-      return annotate([ops.lambda, lambdaParameters, body], location());
+      const underscore = annotate([markers.paramName, "_"], location());
+      const parameters = annotate([underscore], location());
+      return makeLambda(parameters, body, location());
     }
 
 // A backtick-quoted template literal