@weborigami/language 0.0.72 → 0.1.0

package/main.js

@@ -1,13 +1,13 @@
 export * from "./src/runtime/internal.js";
 
 export * as compile from "./src/compiler/compile.js";
+export * 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 * from "./src/runtime/extensions.js";
-export { default as formatError } from "./src/runtime/formatError.js";
 export { default as functionResultsMap } from "./src/runtime/functionResultsMap.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 OrigamiFiles } from "./src/runtime/OrigamiFiles.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.0.72",
+  "version": "0.1.0",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.72",
-    "@weborigami/types": "0.0.72",
+    "@weborigami/async-tree": "0.1.0",
+    "@weborigami/types": "0.1.0",
     "watcher": "2.3.1"
   },
   "scripts": {

package/src/compiler/compile.js

@@ -2,8 +2,11 @@ import { trailingSlash } from "@weborigami/async-tree";
 import { createExpressionFunction } from "../runtime/expressionFunction.js";
 import { ops } from "../runtime/internal.js";
 import { parse } from "./parse.js";
+import { annotate } from "./parserHelpers.js";
 
-function compile(source, startRule) {
+function compile(source, options) {
+  const { startRule } = options;
+  const scopeCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
@@ -12,20 +15,24 @@ function compile(source, startRule) {
     startRule,
   });
   const cache = {};
-  const modified = cacheNonLocalScopeReferences(code, cache);
-  // const modified = code;
+  const modified = scopeCaching
+    ? cacheExternalScopeReferences(code, cache)
+    : code;
   const fn = createExpressionFunction(modified);
   return fn;
 }
 
-export function expression(source) {
-  return compile(source, "expression");
+export function expression(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "expression",
+  });
 }
 
 // Given code containing ops.scope calls, upgrade them to ops.cache calls unless
 // they refer to local variables: variables defined by object literals or lambda
 // parameters.
-export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
+export function cacheExternalScopeReferences(code, cache, locals = {}) {
   const [fn, ...args] = code;
 
   let additionalLocalNames;
@@ -38,7 +45,7 @@ export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
       } else {
         // Upgrade to cached scope lookup
         const modified = [ops.cache, key, cache];
-        /** @type {any} */ (modified).location = code.location;
+        annotate(modified, code.location);
         return modified;
       }
 
@@ -67,18 +74,28 @@ export function cacheNonLocalScopeReferences(code, cache, locals = {}) {
       // be preferable to only descend into instructions. This would require
       // surrounding ops.lambda parameters with ops.literal, and ops.object
       // entries with ops.array.
-      return cacheNonLocalScopeReferences(child, cache, updatedLocals);
+      return cacheExternalScopeReferences(child, cache, updatedLocals);
     } else {
       return child;
     }
   });
 
   if (code.location) {
-    modified.location = code.location;
+    annotate(modified, code.location);
   }
   return modified;
 }
 
-export function templateDocument(source) {
-  return compile(source, "templateDocument");
+export function program(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "program",
+  });
+}
+
+export function templateDocument(source, options = {}) {
+  return compile(source, {
+    ...options,
+    startRule: "templateDocument",
+  });
 }

package/src/compiler/origami.pegjs

@@ -52,20 +52,19 @@ arrayEntries
 
 arrayEntry
   = spread
-  / expr
+  / pipeline
 
-// Something that can be called. This is more restrictive than the `expr`
+// Something that can be called. This is more restrictive than the `value`
 // parser; it doesn't accept regular function calls.
 callTarget "function call"
   = absoluteFilePath
+  / scopeTraverse
   / array
   / object
-  / lambda
-  / parameterizedLambda
-  / protocolCall
   / group
-  / scopeTraverse
-  / scopeReference
+  / namespacePath
+  / namespace
+  / functionReference
 
 // Required closing curly brace. We use this for the `object` term: if the
 // parser sees a left curly brace, here we must see a right curly brace.
@@ -109,6 +108,12 @@ doubleQuoteString "double quote string"
 doubleQuoteStringChar
   = !('"' / newLine) @textChar
 
+// Path that follows a builtin reference in a URL: `//example.com/index.html`
+doubleSlashPath
+  = "//" host:host path:path? {
+      return annotate([host, ...(path ?? [])], location());
+    }
+
 ellipsis = "..." / "…" // Unicode ellipsis
 
 escapedChar "backslash-escaped character"
@@ -121,14 +126,9 @@ escapedChar "backslash-escaped character"
   / "\\v" { return "\v"; }
   / "\\" @.
 
-// An Origami expression, no leading/trailing whitespace
-expr
-  = pipeline
-
-// Top-level Origami expression, possible shebang directive and leading/trailing
-// whitepsace.
-expression "Origami expression"
-  = shebang? __ @expr __
+// A top-level expression, possibly with leading/trailing whitespace
+expression
+  = __ @pipeline __
 
 float "floating-point number"
   = sign? digits? "." digits {
@@ -153,11 +153,23 @@ functionComposition "function composition"
       return annotate(makeFunctionCall(target, chain, location()), location());
     }
 
+// A reference to a function in scope: `fn` or `fn.js`.
+functionReference
+  = ref:scopeReference {
+    // If the reference looks like a builtin name, we treat it as a builtin
+    // reference, otherwise it's a regular scope reference. We can't make this
+    // distinction in the grammar.
+    const name = ref[1];
+      const builtinRegex = /^[A-Za-z][A-Za-z0-9]*$/;
+      const op = builtinRegex.test(name) ? ops.builtin : ops.scope;
+      return annotate([op, name], location());
+    }
+
 // An expression in parentheses: `(foo)`
 group "parenthetical group"
-  = "(" __ expr:expr __ closingParen {
-      return annotate(expr, location());
-    }
+  = "(" __ pipeline:pipeline __ closingParen {
+    return annotate(pipeline, location());
+  }
 
 guillemetString "guillemet string"
   = '«' chars:guillemetStringChar* '»' {
@@ -167,13 +179,19 @@ guillemetString "guillemet string"
 guillemetStringChar
   = !('»' / newLine) @textChar
 
+homeTree
+  = "~" {
+      return annotate([ops.homeTree], location());
+    }
+
 // 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"
-  = identifier:identifier port:(":" @number)? {
+  = identifier:identifier port:(":" @number)? slash:"/"? {
     const portText = port ? `:${port[1]}` : "";
-    const hostText = identifier + portText;
+    const slashText = slash ? "/" : "";
+    const hostText = identifier + portText + slashText;
     return annotate([ops.literal, hostText], location());
   }
 
@@ -191,12 +209,7 @@ identifierList
     }
 
 implicitParensArgs "arguments with implicit parentheses"
-  // Implicit parens args are a separate list of `step`, not `expr`, because
-  // they can't contain a pipeline.
-  = inlineSpace+ args:step|1.., separator| separator? {
-      /* Stuff */
-      return annotate(args, location());
-    }
+  = inlineSpace+ @list
 
 inlineSpace
   = [ \t]
@@ -208,8 +221,8 @@ integer "integer"
 
 // A lambda expression: `=foo()`
 lambda "lambda function"
-  = "=" __ expr:expr {
-      return annotate([ops.lambda, ["_"], expr], location());
+  = "=" __ pipeline:pipeline {
+      return annotate([ops.lambda, ["_"], pipeline], location());
     }
 
 // A path that begins with a slash: `/foo/bar`
@@ -218,15 +231,31 @@ leadingSlashPath "path with a leading slash"
       return annotate(path ?? [], location());
     }
 
-// A separated list of expressions
+// A separated list of values
 list "list"
-  = list:expr|1.., separator| separator? {
-      return annotate(list, location());
+  = values:value|1.., separator| separator? {
+      return annotate(values, location());
     }
 
 multiLineComment
   = "/*" (!"*/" .)* "*/" { return null; }
 
+// A namespace reference is a string of letters only, followed by a colon.
+// For the time being, we also allow a leading `@`, which is deprecated.
+namespace
+  = at:"@"? chars:[A-Za-z]+ ":" {
+    return annotate([ops.builtin, (at ?? "") + chars.join("") + ":"], location());
+  }
+
+// A namespace followed by a path: `fn:a/b/c`
+namespacePath
+  = fn:namespace path:doubleSlashPath {
+      return annotate(makeFunctionCall(fn, [path], location()), location());
+    }
+  / fn:namespace path:path {
+      return annotate(makeFunctionCall(fn, [path], location()), location());
+    }
+
 newLine
   = "\n"
   / "\r\n"
@@ -257,8 +286,11 @@ objectEntry
 
 // A getter definition inside an object literal: `foo = 1`
 objectGetter "object getter"
-  = key:objectKey __ "=" __ value:expr {
-      return annotate(makeProperty(key, [ops.getter, value]), location());
+  = key:objectKey __ "=" __ pipeline:pipeline {
+      return annotate(
+        makeProperty(key, annotate([ops.getter, pipeline], location())),
+        location()
+      );
     }
 
 objectHiddenKey
@@ -270,8 +302,8 @@ objectKey "object key"
 
 // A property definition in an object literal: `x: 1`
 objectProperty "object property"
-  = key:objectKey __ ":" __ value:expr {
-      return annotate(makeProperty(key, value), location());
+  = key:objectKey __ ":" __ pipeline:pipeline {
+      return annotate(makeProperty(key, pipeline), location());
     }
 
 // A shorthand reference inside an object literal: `foo`
@@ -290,8 +322,8 @@ objectPublicKey
   }
 
 parameterizedLambda
-  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ expr:expr {
-      return annotate([ops.lambda, parameters ?? [], expr], location());
+  = "(" __ parameters:identifierList? __ ")" __ doubleArrow __ pipeline:pipeline {
+      return annotate([ops.lambda, parameters ?? [], pipeline], location());
     }
 
 // Function arguments in parentheses
@@ -300,19 +332,22 @@ parensArgs "function arguments in parentheses"
       return annotate(list ?? [undefined], location());
     }
 
-pipeline
-  = steps:(@step|1.., __ singleArrow __ |) {
-      return annotate(makePipeline(steps), location());
-    }
-
 // A slash-separated path of keys
 path "slash-separated path"
-  = head:pathElement|0..| tail:pathTail? {
+  // Path with at least a tail
+  = 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());
     }
+  // Path with slashes, maybe no tail
+  / head:pathElement|1..| tail:pathTail? {
+      let path = tail ? [...head, tail] : head;
+      // Remove parts for consecutive slashes
+      path = path.filter((part) => part[1] !== "/");
+      return annotate(path, location());
+  }
 
 // A path key followed by a slash
 pathElement
@@ -333,26 +368,24 @@ pathTail
     return annotate([ops.literal, 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"
-  = protocol:protocol ":" "/"|0..2| host:host path:leadingSlashPath? {
-      return annotate([protocol, host, ...(path ?? [])], location());
+// A pipeline that starts with a value and optionally applies a series of
+// functions to it.
+pipeline
+  = head:value tail:(__ singleArrow __ @pipelineStep)* {
+      return tail.length === 0
+        ? head
+        : annotate(makePipeline([head, ...tail]), location());
     }
 
-protocol "protocol"
-  = reservedProtocol
-  / scopeReference
+// A step in a pipeline
+pipelineStep
+  = lambda
+  / parameterizedLambda
+  / callTarget
 
-reservedProtocol "reserved protocol"
-  = "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; } // Must come before `treehttp`
-  / "treehttp" { return ops.treeHttp; } // Must come before `tree`
-  / "tree" { return ops.treeHttps; }
+// Top-level Origami progam with possible shebang directive (which is ignored)
+program "Origami program"
+  = shebang? @expression
 
 scopeReference "scope reference"
   = key:identifier {
@@ -360,10 +393,10 @@ scopeReference "scope reference"
     }
 
 scopeTraverse
-  = ref:scopeReference "/" path:path {
+  = ref:scopeReference "/" path:path? {
       const head = [ops.scope, `${ ref[1] }/`];
       head.location = ref.location;
-      return annotate([ops.traverse, head, ...path], location());
+      return annotate([ops.traverse, head, ...(path ?? [])], location());
     }
 
 separator
@@ -376,7 +409,9 @@ shebang
 sign
   = [+\-]
 
-singleArrow = "→" / "->"
+singleArrow
+  = "→"
+  / "->"
 
 singleLineComment
   = "//" [^\n\r]* { return null; }
@@ -390,34 +425,10 @@ singleQuoteStringChar
   = !("'" / newLine) @textChar
 
 spread
-  = ellipsis expr:expr {
-      return annotate([ops.spread, expr], location());
+  = ellipsis value:value {
+      return annotate([ops.spread, value], location());
     }
 
-// A single step in a pipeline, or a top-level expression
-step
-  // Literals that can't start a function call
-  = number
-  // Try functions next; they can start with expression types that follow
-  // (array, object, etc.), and we want to parse the larger thing first.
-  / functionComposition
-  // Then try parsers that look for a distinctive token at the start: an opening
-  // slash, bracket, curly brace, etc.
-  / absoluteFilePath
-  / array
-  / object
-  / lambda
-  / parameterizedLambda
-  / templateLiteral
-  / string
-  / group
-  // Things that have a distinctive character, but not at the start
-  / protocolCall
-  / taggedTemplate
-  / scopeTraverse
-  // Least distinctive option is a simple scope reference, so it comes last.
-  / scopeReference
-
 start
   = number
 
@@ -474,11 +485,37 @@ templateLiteralText
 
 // A substitution in a template literal: `${x}`
 templateSubstitution "template substitution"
-  = "${" __ @expr __ "}"
+  = "${" @expression "}"
 
 textChar
   = escapedChar
   / .
 
+// An Origami expression that produces a value, no leading/trailing whitespace
+value
+  // Literals that can't start a function call
+  = number
+  // Try functions next; they can start with expression types that follow
+  // (array, object, etc.), and we want to parse the larger thing first.
+  / parameterizedLambda
+  / functionComposition
+  / taggedTemplate
+  / namespacePath
+  // Then try parsers that look for a distinctive token at the start: an opening
+  // slash, bracket, curly brace, etc.
+  / absoluteFilePath
+  / array
+  / object
+  / lambda
+  / templateLiteral
+  / string
+  / group
+  / homeTree
+  // Things that have a distinctive character, but not at the start
+  / scopeTraverse
+  / namespace
+  // Least distinctive option is a simple scope reference, so it comes last.
+  / scopeReference
+
 whitespaceWithNewLine
   = inlineSpace* comment? newLine __