@weborigami/language 0.0.35

package/index.ts

@@ -0,0 +1,30 @@
+import { AsyncTree } from "@weborigami/types";
+import { StringLike } from "../async-tree/index.js";
+
+export * from "./main.js";
+
+/**
+ * A class constructor is an object with a `new` method that returns an
+ * instance of the indicated type.
+ */
+export type Constructor<T> = new (...args: any[]) => T;
+
+/**
+ * A function that can convert a string-like input value into some live object.
+ */
+export type FileUnpackFunction = (
+  input: StringLike,
+  options?: { key?: any, parent?: AsyncTree | null }
+) => any;
+
+/**
+ * A mixin is a function that takes an existing class and returns a new class.
+ *
+ * The use of a generic type `T` here is a way of indicating that the members of
+ * the supplied base class automatically pass through to the result. That
+ * ensures the use of the mixin doesn't accidentally hide members of the class
+ * passed to the mixin.
+ */
+export type Mixin<MixinMembers> = <T>(
+  Base: Constructor<T>
+) => Constructor<T & MixinMembers>;

package/main.js

@@ -0,0 +1,21 @@
+export * from "./src/runtime/internal.js";
+
+export * as compile from "./src/compiler/compile.js";
+export { default as EventTargetMixin } from "./src/runtime/EventTargetMixin.js";
+export { default as ExpressionTree } from "./src/runtime/ExpressionTree.js";
+export { default as FileLoadersTransform } from "./src/runtime/FileLoadersTransform.js";
+export { default as ImportModulesMixin } from "./src/runtime/ImportModulesMixin.js";
+export { default as InheritScopeMixin } from "./src/runtime/InheritScopeMixin.js";
+export { default as InvokeFunctionsTransform } from "./src/runtime/InvokeFunctionsTransform.js";
+export { default as OrigamiFiles } from "./src/runtime/OrigamiFiles.js";
+export { default as OrigamiTransform } from "./src/runtime/OrigamiTransform.js";
+export { default as OrigamiTree } from "./src/runtime/OrigamiTree.js";
+export { default as Scope } from "./src/runtime/Scope.js";
+export { default as TreeEvent } from "./src/runtime/TreeEvent.js";
+export { default as WatchFilesMixin } from "./src/runtime/WatchFilesMixin.js";
+export { default as concatTreeValues } from "./src/runtime/concatTreeValues.js";
+export { default as evaluate } from "./src/runtime/evaluate.js";
+export * as expressionFunction from "./src/runtime/expressionFunction.js";
+export { default as extname } from "./src/runtime/extname.js";
+export { default as format } from "./src/runtime/format.js";
+export { default as functionResultsMap } from "./src/runtime/functionResultsMap.js";

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@weborigami/language",
+  "version": "0.0.35",
+  "description": "Graph Origami expression language compiler and runtime",
+  "type": "module",
+  "main": "./main.js",
+  "types": "./index.ts",
+  "devDependencies": {
+    "@types/node": "20.8.10",
+    "typescript": "5.2.2"
+  },
+  "dependencies": {
+    "@weborigami/types": "0.0.35",
+    "@weborigami/async-tree": "https://gitpkg.now.sh/GraphOrigami/origami/async-tree?main",
+    "peggy": "3.0.2",
+    "watcher": "2.3.0"
+  },
+  "scripts": {
+    "build": "peggy --allowed-start-rules=\"*\" --format es src/compiler/origami.pegjs --output src/compiler/parse.js",
+    "prepublishOnly": "npm run build",
+    "test": "node --test",
+    "typecheck": "tsc"
+  }
+}

package/src/compiler/code.d.ts

@@ -0,0 +1,3 @@
+import type { Treelike } from "@weborigami/async-tree";
+
+type Code = [Treelike, ...any[]] | any;

package/src/compiler/compile.js

@@ -0,0 +1,55 @@
+import { createExpressionFunction } from "../runtime/expressionFunction.js";
+import { parse } from "./parse.js";
+
+function compile(text, startRule) {
+  // Trim whitespace from template blocks before we begin lexing, as our
+  // heuristics are non-local and hard to implement in our parser.
+  const preprocessed = trimTemplateWhitespace(text);
+  const code = parse(preprocessed, { startRule });
+  const fn = createExpressionFunction(code);
+  return fn;
+}
+
+export function expression(text) {
+  return compile(text, "expression");
+}
+
+export function templateDocument(text) {
+  return compile(text, "templateDocument");
+}
+
+// Trim the whitespace around and in substitution blocks in a template. There's
+// no explicit syntax for blocks, but we infer them as any place where a
+// substitution itself contains a multi-line template literal.
+//
+// Example:
+//
+//     {{ if `
+//       true text
+//     `, `
+//       false text
+//     ` }}
+//
+// Case 1: a substitution that starts the text or starts a line (there's only
+// whitespace before the `{{`), and has the line end with the start of a
+// template literal (there's only whitespace after the backtick) marks the start
+// of a block.
+//
+// Case 2: a line in the middle that ends one template literal and starts
+// another is an internal break in the block. Edge case: three backticks in a
+// row, like ```, are common in markdown and are not treated as a break.
+//
+// Case 3: a line that ends a template literal and ends with `}}` or ends the
+// text marks the end of the block.
+//
+// In all three cases, we trim spaces and tabs from the start and end of the
+// line. In case 1, we also remove the preceding newline.
+function trimTemplateWhitespace(text) {
+  const regex1 = /(^|\n)[ \t]*({{.*?`)[ \t]*\n/g;
+  const regex2 = /\n[ \t]*(`(?!`).*?`)[ \t]*\n/g;
+  const regex3 = /\n[ \t]*(`(?!`).*?}})[ \t]*(?:\n|$)/g;
+  const trimBlockStarts = text.replace(regex1, "$1$2");
+  const trimBlockBreaks = trimBlockStarts.replace(regex2, "\n$1");
+  const trimBlockEnds = trimBlockBreaks.replace(regex3, "\n$1");
+  return trimBlockEnds;
+}

package/src/compiler/origami.pegjs

@@ -0,0 +1,277 @@
+{{
+//
+// Origami language parser
+//
+// Generate the parser via `npm build`.
+// @ts-nocheck
+//
+
+import * as ops from "../runtime/ops.js";
+import { makeFunctionCall, makeTemplate } from "./parserHelpers.js";
+}}
+
+// A block of optional whitespace
+__
+  = (inlineSpace / newLine / comment)*  { return ""; }
+
+// A filesystem path that begins with a slash: `/foo/bar`
+absoluteFilePath
+  = path:leadingSlashPath { return [[ops.filesRoot], ...path]; }
+
+// A chain of arguments: `(arg1)(arg2)(arg3)`
+argsChain
+  = parts:(parensArgs / leadingSlashPath)+ { return parts; }
+
+// An assignment statement: `foo = 1`
+assignment
+  = @identifier __ "=" __ @expr
+
+assignmentOrShorthand
+  = assignment
+  / key:identifier { return [key, [ops.inherited, key]]; }
+
+array
+  = "[" __ list:list? "]" { return [ops.array, ...(list ?? [])]; }
+
+// Something that can be called. This is more restrictive than the `expr`
+// parser; it doesn't accept regular function calls.
+callTarget
+  = absoluteFilePath
+  / array
+  / object
+  / tree
+  / lambda
+  / protocolCall
+  / group
+  / scopeReference
+
+// A single line comment
+comment
+  = "#" [^\n\r]*
+
+digits
+  = @[0-9]+
+
+doubleQuoteString
+  = '"' chars:doubleQuoteStringChar* '"' { return chars.join(""); }
+
+doubleQuoteStringChar
+  = !('"' / newLine) @textChar
+
+escapedChar
+  = "\\" @.
+
+// An Origami expression, no leading/trailing whitespace
+expr
+  // Try function calls first, as they can start with expression types that
+  // follow (array, object, etc.); we want to parse the largest thing first.
+  = implicitParensCall
+  / functionComposition
+  // Then try parsers that look for a distinctive token at the start: an opening
+  // slash, bracket, curly brace, etc.
+  / absoluteFilePath
+  / array
+  / object
+  / tree
+  / lambda
+  / templateLiteral
+  / group
+  / string
+  / number
+  // Protocol calls are distinguished by a colon, but it's not at the start.
+  / protocolCall
+  // Least distinctive option is a simple scope reference, so it comes last.
+  / scopeReference
+
+// Top-level Origami expression, possible leading/trailing whitepsace.
+expression "Origami expression"
+  = __ @expr __
+
+float
+  = sign? digits? "." digits {
+      return parseFloat(text());
+    }
+
+// Parse a function and its arguments, e.g. `fn(arg)`, possibly part of a chain
+// of function calls, like `fn(arg1)(arg2)(arg3)`.
+functionComposition
+  = target:callTarget chain:argsChain { return makeFunctionCall(target, chain); }
+
+// An expression in parentheses: `(foo)`
+group
+  = "(" __ @expr __ ")"
+
+identifier
+  = chars:identifierChar+ { return chars.join(""); }
+
+identifierChar
+  = [^(){}\[\],/:=\`"'\\# \t\n\r] // No unescaped whitespace or special chars
+  / escapedChar
+
+// A function call with implicit parentheses: `fn 1, 2, 3`
+implicitParensCall
+  = target:(functionComposition / callTarget) inlineSpace+ args:list {
+      return [target, ...args];
+    }
+
+// 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
+  = identifier (":" number)? { return text(); }
+
+inlineSpace
+  = [ \t]
+
+integer
+  = sign? digits {
+      return parseInt(text());
+    }
+
+// A lambda expression: `=foo()`
+lambda
+  = "=" __ expr:expr { return [ops.lambda, expr]; }
+
+// A path that begins with a slash: `/foo/bar`
+leadingSlashPath
+  = "/" @path
+  / "/" { return [""]; }
+
+// A separated list of expressions
+list = head:expr tail:(separator @expr)* separator? { return [head].concat(tail); }
+
+newLine
+  = "\n"
+  / "\r\n"
+  / "\r"
+
+// A number
+number
+  = float
+  / integer
+
+// An object literal: `{foo: 1, bar: 2}`
+//
+// TODO: Use Object.fromEntries with array of key/value pairs
+//
+object
+  = "{" __ properties:objectProperties? "}" { return [ops.object, ...(properties ?? [])]; }
+
+// A separated list of object properties or shorthands
+objectProperties
+  = head:objectPropertyOrShorthand tail:(separator @objectPropertyOrShorthand)* separator? __ {
+      return [head].concat(tail);
+    }
+
+// A single object property with key and value: `x: 1`
+objectProperty
+  = @identifier __ ":" __ @expr
+
+objectPropertyOrShorthand
+  = objectProperty
+  / key:identifier { return [key, [ops.inherited, key]]; }
+
+// Function arguments in parentheses
+parensArgs
+  = "(" __ list:list? ")" { return list ?? [undefined]; }
+
+separator
+  = __ "," __
+  / whitespaceWithNewLine
+
+sign
+  = [+\-]
+
+// A slash-separated path of keys
+path
+  = head:pathKey "/" tail:path { return [head].concat(tail); }
+  / key:pathKey { return [key]; }
+
+// A single key in a slash-separated path
+pathKey
+  = key:identifierChar* { return key.join(""); }
+
+// Parse a protocol call like `fn://foo/bar`.
+// There can be zero, one, or two slashes after the colon.
+protocolCall
+  = protocol:protocol ":" "/"|0..2| host:host path:leadingSlashPath? {
+      return [protocol, host, ...(path ?? [])];
+    }
+
+protocol
+  = reservedProtocol
+  / scopeReference
+
+reservedProtocol
+  = "https" { return ops.https; }
+  / "http" { return ops.http; }
+  / "treehttps" { return ops.treeHttps; }
+  / "treehttp" { return ops.treeHttp; }
+  / "tree" { return ops.treeHttps; } // Shorthand alias
+
+scopeReference
+  = key:identifier { return [ops.scope, key]; }
+
+singleQuoteString
+  = "'" chars:singleQuoteStringChar* "'" { return chars.join(""); }
+
+singleQuoteStringChar
+  = !("'" / newLine) @textChar
+
+start
+  = number
+
+string
+  = doubleQuoteString
+  / singleQuoteString
+
+// A top-level document defining a template. This is the same as a template
+// literal, but can contain backticks at the top level.
+templateDocument "Origami template"
+  = contents:templateDocumentContents { return [ops.lambda, contents]; }
+
+// Template documents can contain backticks at the top level.
+templateDocumentChar
+  = !"{{" @textChar
+
+// The contents of a template document containing plain text and substitutions
+templateDocumentContents
+  = parts:(templateDocumentText / templateSubstitution)* { return makeTemplate(parts); }
+
+templateDocumentText
+  = chars:templateDocumentChar+ { return chars.join(""); }
+
+// A backtick-quoted template literal
+templateLiteral
+  = "`" @templateLiteralContents "`"
+
+templateLiteralChar
+  = !("`" / "{{") @textChar
+
+// The contents of a template literal containing plain text and substitutions
+templateLiteralContents
+  = parts:(templateLiteralText / templateSubstitution)* { return makeTemplate(parts); }
+
+// Plain text in a template literal
+templateLiteralText
+  = chars:templateLiteralChar+ { return chars.join(""); }
+
+// A substitution in a template literal: `{{ fn() }}`
+templateSubstitution
+  = "{{" @expression "}}"
+
+textChar
+  = escapedChar / .
+
+// A tree literal: `{ index.html = "Hello" }`
+tree
+  = "{" __ assignments:treeAssignments? "}" { return [ops.tree, ...(assignments ?? [])]; }
+
+// A separated list of assignments or shorthands
+treeAssignments
+  = head:assignmentOrShorthand tail:(separator @assignmentOrShorthand)* separator? __ {
+      return [head].concat(tail);
+    }
+
+whitespaceWithNewLine
+  = inlineSpace* comment? newLine __