@weborigami/language 0.0.66-beta.1 → 0.0.66

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.66-beta.1",
+  "version": "0.0.66",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.5.4",
+    "@types/node": "22.7.4",
     "peggy": "4.0.3",
-    "typescript": "5.5.4"
+    "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.66-beta.1",
-    "@weborigami/types": "0.0.66-beta.1",
+    "@weborigami/async-tree": "0.0.66",
+    "@weborigami/types": "0.0.66",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/origami.pegjs

@@ -63,6 +63,7 @@ callTarget "function call"
   / parameterizedLambda
   / protocolCall
   / group
+  / scopeTraverse
   / scopeReference
 
 // Required closing curly brace. We use this for the `object` term: if the
@@ -161,8 +162,10 @@ guillemetStringChar
 // 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"
-  = identifier (":" number)? {
-    return annotate([ops.primitive, text()], location());
+  = identifier:identifier port:(":" @number)? {
+    const portText = port ? `:${port[1]}` : "";
+    const hostText = identifier + portText;
+    return annotate([ops.primitive, hostText], location());
   }
 
 identifier "identifier"
@@ -202,11 +205,8 @@ lambda "lambda function"
 
 // A path that begins with a slash: `/foo/bar`
 leadingSlashPath "path with a leading slash"
-  = "/" path:path {
-      return annotate(path, location());
-    }
-  / "/" {
-      return annotate([""], location());
+  = "/" path:path? {
+      return annotate(path ?? [], location());
     }
 
 // A separated list of expressions
@@ -259,13 +259,6 @@ objectKey "object key"
   = objectHiddenKey
   / objectPublicKey
 
-objectPublicKey
-  = identifier
-  / string:string {
-    // Remove `ops.primitive` from the string code
-    return string[1];
-  }
-
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
   = key:objectKey __ ":" __ value:expr {
@@ -278,6 +271,15 @@ objectShorthandProperty "object identifier"
       return annotate([key, [ops.inherited, key]], location());
     }
 
+objectPublicKey
+  = identifier:identifier slash:"/"? {
+    return identifier + (slash ?? "");
+  }
+  / string:string {
+    // Remove `ops.primitive` from the string code
+    return string[1];
+  }
+
 parameterizedLambda
   = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ expr:expr {
       return annotate([ops.lambda, parameters ?? [], expr], location());
@@ -296,14 +298,17 @@ pipeline
 
 // A slash-separated path of keys
 path "slash-separated path"
-  = path:pathKey|1.., "/"| {
+  = head:pathElement|0..| tail:pathTail? {
+      let path = tail ? [...head, tail] : head;
+      // Remove parts for consecutive slashes
+      path = path.filter((part) => part[1] !== "/");
       return annotate(path, location());
     }
 
-// A single key in a slash-separated path
-pathKey "path element"
-  = chars:pathKeyChar* {
-    return annotate([ops.primitive, chars.join("")], location());
+// A path key followed by a slash
+pathElement
+  = chars:pathKeyChar* "/" {
+    return annotate([ops.primitive, chars.join("") + "/"], location());
   }
 
 // A single character in a slash-separated path.
@@ -313,6 +318,12 @@ pathKeyChar
   = [^(){}\[\],:/\\ \t\n\r]
   / escapedChar
 
+// A path key without a slash
+pathTail
+  = chars:pathKeyChar+ {
+    return annotate([ops.primitive, chars.join("")], location());
+  }
+
 // Parse a protocol call like `fn://foo/bar`.
 // There can be zero, one, or two slashes after the colon.
 protocolCall "function call using protocol: syntax"
@@ -325,19 +336,26 @@ protocol "protocol"
   / scopeReference
 
 reservedProtocol "reserved protocol"
-  = "https" { return ops.https; }
+  = "explore" { return ops.explorableSite; }
+  / "https" { return ops.https; } // Must come before "http"
   / "http" { return ops.http; }
   / "new" { return ops.constructor; }
   / "package" { return [ops.scope, "@package"] } // Alias
-  / "treehttps" { return ops.treeHttps; }
-  / "treehttp" { return ops.treeHttp; }
-  / "tree" { return ops.treeHttps; } // Alias
+  / "treehttps" { return ops.treeHttps; } // Must come before `treehttp`
+  / "treehttp" { return ops.treeHttp; } // Must come before `tree`
+  / "tree" { return ops.treeHttps; }
 
 scopeReference "scope reference"
   = key:identifier {
       return annotate([ops.scope, key], location());
     }
 
+scopeTraverse
+  = ref:scopeReference "/" path:path {
+      const head = [ops.scope, `${ ref[1] }/`];
+      return annotate([ops.traverse, head, ...path], location());
+    }
+
 separator
   = __ "," __
   / whitespaceWithNewLine