@aeriajs/compiler 0.0.4 → 0.0.7

package/dist/lexer.mjs

@@ -0,0 +1,270 @@
+"use strict";
+import { TokenType } from "./token.mjs";
+import { Diagnostic } from "./diagnostic.mjs";
+export const COLLECTION_KEYWORDS = [
+  "actions",
+  "filters",
+  "form",
+  "functions",
+  "icon",
+  "indexes",
+  "individualActions",
+  "owned",
+  "presets",
+  "properties",
+  "required",
+  "search",
+  "table"
+];
+export const COLLECTION_ACTIONS_KEYWORDS = [
+  "ask",
+  "button",
+  "clearItem",
+  "effect",
+  "event",
+  "fetchItem",
+  "function",
+  "icon",
+  "label",
+  "params",
+  "query",
+  "requires",
+  "roles",
+  "route",
+  "selection",
+  "setItem",
+  "translate"
+];
+export const COLLECTION_SEARCH_KEYWORDS = [
+  "indexes",
+  "placeholder",
+  "exactMatches"
+];
+export const CONTRACT_KEYWORDS = [
+  "payload",
+  "query",
+  "response"
+];
+export const TOPLEVEL_KEYWORDS = [
+  "collection",
+  "contract",
+  "functionset"
+];
+export const MISC_KEYWORDS = ["extends"];
+export const KEYWORDS = [].concat(
+  COLLECTION_KEYWORDS,
+  COLLECTION_ACTIONS_KEYWORDS,
+  COLLECTION_SEARCH_KEYWORDS,
+  CONTRACT_KEYWORDS,
+  TOPLEVEL_KEYWORDS,
+  MISC_KEYWORDS
+);
+const keywordsSet = /* @__PURE__ */ new Set();
+for (const keyword of KEYWORDS) {
+  keywordsSet.add(keyword);
+}
+const TOKENS = [
+  {
+    type: null,
+    matcher: /\r?[ \t]+/
+  },
+  {
+    type: TokenType.LineBreak,
+    matcher: "\n"
+  },
+  {
+    type: TokenType.Comment,
+    matcher: "//"
+  },
+  {
+    type: TokenType.LeftBracket,
+    matcher: "{"
+  },
+  {
+    type: TokenType.RightBracket,
+    matcher: "}"
+  },
+  {
+    type: TokenType.LeftParens,
+    matcher: "("
+  },
+  {
+    type: TokenType.RightParens,
+    matcher: ")"
+  },
+  {
+    type: TokenType.LeftSquareBracket,
+    matcher: "["
+  },
+  {
+    type: TokenType.RightSquareBracket,
+    matcher: "]"
+  },
+  {
+    type: TokenType.Pipe,
+    matcher: "|"
+  },
+  {
+    type: TokenType.Comma,
+    matcher: ","
+  },
+  {
+    type: TokenType.Range,
+    matcher: /(\d+\.\.\d*|\d*\.\.\d+)/g,
+    valueExtractor: (value) => {
+      const [, left, right] = value.match(/(\d*)\.\.(\d*)/);
+      return [
+        parseInt(left),
+        parseInt(right)
+      ];
+    }
+  },
+  {
+    type: TokenType.Dot,
+    matcher: "."
+  },
+  {
+    type: TokenType.Number,
+    matcher: /[0-9]+(\.[0-9]+)?/,
+    construct: Number
+  },
+  {
+    type: TokenType.Boolean,
+    matcher: [
+      "true",
+      "false"
+    ],
+    construct: Boolean
+  },
+  {
+    type: TokenType.Keyword,
+    matcher: Array.from(keywordsSet),
+    condition: (state) => !state.inPropertiesStack.at(-1)
+  },
+  {
+    type: TokenType.MacroName,
+    matcher: /[a-zA-Z]([a-zA-Z0-9]|_)+\(/,
+    valueExtractor: (value) => value.slice(0, -1)
+  },
+  {
+    type: TokenType.Identifier,
+    matcher: /([a-zA-Z0-9]|_)+/
+  },
+  {
+    type: TokenType.QuotedString,
+    matcher: /"([^"]+)"/,
+    valueExtractor: (value) => value.slice(1, -1)
+  },
+  {
+    type: TokenType.AttributeName,
+    matcher: /@[a-zA-Z0-9]+/,
+    valueExtractor: (value) => value.slice(1)
+  }
+];
+export const tokenize = function(input) {
+  let index = 0, line = 1, start = 0, end = 0;
+  const tokens = [];
+  const errors = [];
+  const state = {
+    inPropertiesStack: []
+  };
+  while (index < input.length) {
+    let hasMatch = false;
+    for (const { type, matcher, valueExtractor, construct, condition } of TOKENS) {
+      let value;
+      let token;
+      if (condition) {
+        if (!condition(state)) {
+          continue;
+        }
+      }
+      if (typeof matcher === "string") {
+        if (input.slice(index).startsWith(matcher)) {
+          value = matcher;
+        }
+      } else if (matcher instanceof RegExp) {
+        const currentMatcher = new RegExp(matcher.source, "y");
+        currentMatcher.lastIndex = index;
+        const matched = currentMatcher.exec(input);
+        if (matched) {
+          [value] = matched;
+        }
+      } else {
+        const segment = input.slice(index, index + input.slice(index).search(/[ \t\n\{\}\(\)\[\]]/));
+        if (segment && matcher.includes(segment)) {
+          value = segment;
+        }
+      }
+      if (value) {
+        let tokenValue;
+        const location = {
+          index: index += value.length,
+          line,
+          end: end += value.length,
+          start: start = end - value.length
+        };
+        switch (type) {
+          case null:
+            break;
+          case TokenType.LineBreak:
+            line++;
+            end = 0;
+            start = 0;
+            break;
+          case TokenType.Comment: {
+            while (input[index++] !== "\n") {
+            }
+            line++;
+            break;
+          }
+          default: {
+            if (valueExtractor) {
+              tokenValue = construct ? construct(valueExtractor(value)) : valueExtractor(value);
+            } else {
+              tokenValue = construct ? construct(value) : value;
+            }
+            token = {
+              type,
+              location,
+              value: tokenValue
+            };
+            switch (type) {
+              case TokenType.LeftBracket: {
+                const lastToken = tokens.at(-1);
+                if (lastToken) {
+                  if (lastToken.value === "properties") {
+                    state.inPropertiesStack.push(true);
+                  } else {
+                    state.inPropertiesStack.push(false);
+                  }
+                }
+                break;
+              }
+              case TokenType.RightBracket: {
+                if (state.inPropertiesStack.length > 0) {
+                  state.inPropertiesStack.pop();
+                }
+                break;
+              }
+            }
+            tokens.push(token);
+          }
+        }
+        hasMatch = true;
+      }
+    }
+    if (!hasMatch) {
+      index += input.slice(index).search(/[ \t\n\{\}\(\)\[\]]/);
+      errors.push(new Diagnostic("unexpected token", {
+        index,
+        line,
+        start,
+        end
+      }));
+    }
+  }
+  return {
+    tokens,
+    errors
+  };
+};

package/dist/parser.d.ts

@@ -0,0 +1,8 @@
+import { type Token, type Location } from './token.js';
+import { Diagnostic } from './diagnostic.js';
+import * as AST from './ast.js';
+export declare const locationMap: WeakMap<symbol, Location>;
+export declare const parse: (tokens: (Token | undefined)[]) => {
+    ast: AST.ProgramNode;
+    errors: Diagnostic[];
+};