@aeriajs/compiler 0.0.62 → 0.0.64

package/dist/codegen/utils.mjs

@@ -1,161 +0,0 @@
-"use strict";
-export const PACKAGE_NAME = "aeria";
-export const MIDDLEWARES_RUNTIME_PATH = "../../../dist/middlewares/index.mjs";
-export const UnquotedSymbol = Symbol("unquoted");
-export const ArraySymbol = Symbol("array");
-export const getExposedFunctions = (functionNodes) => {
-  return Object.fromEntries(functionNodes.map((node) => [
-    node.name,
-    node.accessCondition
-  ]));
-};
-export const makeASTImports = (ast, initialImports = {}, options = {
-  includeRuntimeOnlyImports: false
-}) => {
-  const modifiedSymbols = {};
-  const toImport = ast.reduce((imports, node) => {
-    if (node.kind === "collection") {
-      if (node.extends) {
-        const modifiedSymbol = `${node.extends.packageName}${resizeFirstChar(node.extends.symbolName, true)}`;
-        modifiedSymbols[node.extends.symbolName] = modifiedSymbol;
-        imports[node.extends.importPath] ??= /* @__PURE__ */ new Set();
-        imports[node.extends.importPath].add(`${node.extends.symbolName} as ${modifiedSymbol}`);
-      }
-      if (node.functions) {
-        for (const functionNode of node.functions) {
-          if (functionNode.exportSymbol) {
-            const { importPath, symbolName } = functionNode.exportSymbol;
-            imports[importPath] ??= /* @__PURE__ */ new Set();
-            imports[importPath].add(symbolName);
-          }
-        }
-      }
-      if (options.includeRuntimeOnlyImports) {
-        if (node.middlewares) {
-          imports[MIDDLEWARES_RUNTIME_PATH] ??= /* @__PURE__ */ new Set();
-          for (const middleware of node.middlewares) {
-            imports[MIDDLEWARES_RUNTIME_PATH].add(middleware);
-          }
-        }
-      }
-    }
-    return imports;
-  }, initialImports);
-  return {
-    code: Object.keys(toImport).map((key) => `import { ${Array.from(toImport[key]).join(", ")} } from '${key}'`),
-    modifiedSymbols
-  };
-};
-export const unwrapNode = (node) => {
-  const { kind, ...unwrappedNode } = Object.fromEntries(Object.entries(node).filter(([key]) => typeof key === "string"));
-  return unwrappedNode;
-};
-export const unwrapPropertyNode = ({ property, nestedProperties, nestedAdditionalProperties }) => {
-  const propertyOrPropertyItems = "items" in property ? property.items : property;
-  let unwrappedProperty = propertyOrPropertyItems;
-  if ("$ref" in propertyOrPropertyItems) {
-    unwrappedProperty = {
-      ...propertyOrPropertyItems,
-      $ref: getCollectionId(propertyOrPropertyItems.$ref)
-    };
-  } else if ("type" in propertyOrPropertyItems && propertyOrPropertyItems.type === "object") {
-    let properties;
-    let additionalProperties;
-    if (nestedProperties) {
-      properties = recursivelyUnwrapPropertyNodes(nestedProperties);
-    }
-    if (nestedAdditionalProperties) {
-      additionalProperties = typeof nestedAdditionalProperties === "boolean" ? nestedAdditionalProperties : unwrapPropertyNode(nestedAdditionalProperties);
-    }
-    if (properties && additionalProperties) {
-      unwrappedProperty = {
-        ...propertyOrPropertyItems,
-        properties,
-        additionalProperties
-      };
-    } else if (properties) {
-      unwrappedProperty = {
-        ...propertyOrPropertyItems,
-        properties
-      };
-    } else if (additionalProperties) {
-      unwrappedProperty = {
-        ...propertyOrPropertyItems,
-        additionalProperties
-      };
-    }
-  }
-  if ("items" in property) {
-    return {
-      ...property,
-      items: unwrappedProperty
-    };
-  }
-  return unwrappedProperty;
-};
-export const recursivelyUnwrapPropertyNodes = (properties) => {
-  return Object.entries(properties).reduce((acc, [key, value]) => {
-    if (Array.isArray(value)) {
-      acc[key] = value.map((propertyNode) => unwrapPropertyNode(propertyNode));
-    } else {
-      acc[key] = unwrapPropertyNode(value);
-    }
-    return acc;
-  }, {});
-};
-const isRecord = (value) => {
-  return !!(value && typeof value === "object");
-};
-export const stringify = (value, parents = []) => {
-  if (Array.isArray(value)) {
-    let arrayString = "[\n";
-    value.map((element) => {
-      const currentParents = [
-        ...parents,
-        ArraySymbol
-      ];
-      arrayString += "	".repeat(currentParents.length) + checkQuotes(currentParents, element) + ",\n";
-    });
-    return arrayString + `${"	".repeat(parents.length)}]`;
-  }
-  if (isRecord(value)) {
-    const objectString = Object.keys(value).map((key) => {
-      const currentParents = [
-        ...parents,
-        key
-      ];
-      const indentation = "	".repeat(currentParents.length);
-      return `${indentation}${key}: ${checkQuotes(currentParents, value[key])}`;
-    }).join(",\n");
-    return `{
-${objectString}
-${"	".repeat(parents.length)}}`;
-  }
-  switch (typeof value) {
-    case "undefined":
-    case "number":
-    case "boolean": {
-      return String(value);
-    }
-    default: {
-      if (value === null) {
-        return String(value);
-      }
-      return `"${String(value)}"`;
-    }
-  }
-};
-const checkQuotes = (parents, value) => {
-  if (value && typeof value === "object" && UnquotedSymbol in value) {
-    return value[UnquotedSymbol];
-  }
-  return stringify(value, parents);
-};
-export const resizeFirstChar = (text, capitalize) => {
-  if (capitalize === true) {
-    return text.charAt(0).toUpperCase() + text.slice(1);
-  }
-  return text.charAt(0).toLowerCase() + text.slice(1);
-};
-export const getCollectionId = (name) => resizeFirstChar(name, false);
-export const getExtendName = (name) => `extend${resizeFirstChar(name, true)}Collection`;

package/dist/codegen.mjs

@@ -1,54 +0,0 @@
-"use strict";
-import { generateContracts, generateExports, generateJSCollections, generateTSCollections } from "./codegen/index.mjs";
-import * as fsPromises from "node:fs/promises";
-import * as path from "node:path";
-const generateFileMap = async (fileTree, outDir = ".") => {
-  const mappedPaths = {};
-  const mapPathTree = async (tree, previousPath) => {
-    for (const treePath in tree) {
-      const currentPath = path.join(previousPath, treePath);
-      if (typeof tree[treePath] === "object") {
-        await mapPathTree(tree[treePath], currentPath);
-        continue;
-      }
-      await fsPromises.mkdir(previousPath, {
-        recursive: true
-      });
-      mappedPaths[currentPath] = tree[treePath];
-    }
-    return;
-  };
-  await mapPathTree(fileTree, outDir);
-  return mappedPaths;
-};
-export const generateCode = async (ast, options) => {
-  const contracts = generateContracts(ast);
-  const exports = generateExports(ast, {
-    hasContracts: !!contracts
-  });
-  const fileTree = {
-    ["collections"]: {
-      ["collections.d.ts"]: generateTSCollections(ast),
-      ["collections.mjs"]: generateJSCollections(ast),
-      ["index.d.ts"]: exports.collections.dts,
-      ["index.mjs"]: exports.collections.js
-    },
-    ["index.d.ts"]: exports.index.dts,
-    ["index.mjs"]: exports.index.js
-  };
-  if (contracts) {
-    fileTree.contracts = {
-      ["contracts.mjs"]: contracts.js,
-      ["contracts.d.ts"]: contracts.dts,
-      ["index.d.ts"]: exports.contracts.dts,
-      ["index.mjs"]: exports.contracts.js
-    };
-  }
-  const fileStructure = await generateFileMap(fileTree, options.outDir);
-  if (!options.dryRun) {
-    for (const path2 in fileStructure) {
-      await fsPromises.writeFile(path2, fileStructure[path2]);
-    }
-  }
-  return fileStructure;
-};

package/dist/compile.mjs

@@ -1,69 +0,0 @@
-"use strict";
-import { Diagnostic } from "./diagnostic.mjs";
-import { tokenize } from "./lexer.mjs";
-import { parse, locationMap } from "./parser.mjs";
-import { analyze } from "./semantic.mjs";
-import { generateCode } from "./codegen.mjs";
-import * as fs from "node:fs";
-export const GLOB_PATTERN = "**/*.aeria";
-export const postflight = (ast) => {
-  const errors = [];
-  for (const node of ast.collections) {
-    if (node.functionSets?.length) {
-      for (const [functionSetName, locationSymbol] of node.functionSets) {
-        const functionSet = ast.functionsets.find(({ name }) => name === functionSetName);
-        if (!functionSet) {
-          const location = locationMap.get(locationSymbol);
-          errors.push(new Diagnostic(`invalid function set "${functionSetName}"`, location));
-          continue;
-        }
-        node.functions.push(...functionSet.functions);
-      }
-    }
-  }
-  return {
-    errors
-  };
-};
-export const parseAndCheck = async (sources, options = {}) => {
-  const errors = [];
-  const allTokens = [];
-  for (const fileName in sources) {
-    const { errors: lexerErrors, tokens } = tokenize(sources[fileName], fileName);
-    if (lexerErrors.length > 0) {
-      errors.push(...lexerErrors);
-    }
-    allTokens.push(...tokens);
-  }
-  const { errors: parserErrors, ast } = parse(allTokens);
-  const { errors: semanticErrors } = await analyze(ast, options);
-  const { errors: postflightErrors } = postflight(ast);
-  errors.push(...parserErrors.concat(semanticErrors, postflightErrors));
-  return {
-    success: errors.length === 0,
-    errors,
-    errorCount: errors.length,
-    ast
-  };
-};
-export const compileFromFiles = async (options) => {
-  const fileList = await Array.fromAsync(fs.promises.glob(GLOB_PATTERN));
-  const sources = {};
-  for (const fileName of fileList) {
-    sources[fileName] = await fs.promises.readFile(fileName, {
-      encoding: "utf-8"
-    });
-  }
-  const result = await parseAndCheck(sources, options);
-  if (!result.ast || result.errorCount > 0) {
-    return result;
-  }
-  if (options.outDir) {
-    const emittedFiles = await generateCode(result.ast, options);
-    return {
-      ...result,
-      emittedFiles
-    };
-  }
-  return result;
-};

package/dist/diagnostic.mjs

@@ -1,18 +0,0 @@
-"use strict";
-const emptyLocation = {
-  file: "",
-  index: 0,
-  line: 0,
-  start: 0,
-  end: 0
-};
-export class Diagnostic extends Error {
-  constructor(message, location = emptyLocation) {
-    super();
-    this.message = message;
-    this.location = location;
-    if (false) {
-      console.error(message, location);
-    }
-  }
-}

package/dist/guards.mjs

@@ -1,8 +0,0 @@
-"use strict";
-import * as AST from "./ast.mjs";
-export const isNativePropertyType = (value) => {
-  return value in AST.PropertyType;
-};
-export const isValidPropertyModifier = (value) => {
-  return value in AST.PropertyModifiers;
-};

package/dist/index.mjs

@@ -1,8 +0,0 @@
-"use strict";
-export * from "./ast.mjs";
-export * from "./compile.mjs";
-export * from "./parser.mjs";
-export * from "./lexer.mjs";
-export * from "./semantic.mjs";
-export * from "./token.mjs";
-export * from "./diagnostic.mjs";

package/dist/lexer.mjs

@@ -1,375 +0,0 @@
-"use strict";
-import { TokenType } from "./token.mjs";
-import { Diagnostic } from "./diagnostic.mjs";
-export const COLLECTION_KEYWORDS = [
-  "actions",
-  "additionalProperties",
-  "filters",
-  "form",
-  "formLayout",
-  "functions",
-  "icon",
-  "indexes",
-  "individualActions",
-  "layout",
-  "middlewares",
-  "owned",
-  "presets",
-  "properties",
-  "required",
-  "search",
-  "table",
-  "tableMeta",
-  "unique",
-  "writable"
-];
-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 COLLECTION_LAYOUT_KEYWORDS = [
-  "name",
-  "options"
-];
-export const COLLECTION_LAYOUT_OPTIONS_KEYWORDS = [
-  "title",
-  "picture",
-  "badge",
-  "information",
-  "active",
-  "translateBadge"
-];
-export const COLLECTION_FORM_LAYOUT_KEYWORDS = [
-  "fields",
-  "if",
-  "span",
-  "verticalSpacing",
-  "separator"
-];
-export const CONTRACT_KEYWORDS = [
-  "roles",
-  "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,
-  COLLECTION_LAYOUT_KEYWORDS,
-  COLLECTION_LAYOUT_OPTIONS_KEYWORDS,
-  COLLECTION_FORM_LAYOUT_KEYWORDS,
-  CONTRACT_KEYWORDS,
-  TOPLEVEL_KEYWORDS,
-  MISC_KEYWORDS
-);
-export const FINAL_OPERATORS = [
-  "==",
-  "in",
-  ">=",
-  "<=",
-  ">",
-  "<",
-  "!"
-];
-export const LOGICAL_OPERATORS = [
-  "&&",
-  "||"
-];
-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.Operator,
-    matcher: [].concat(FINAL_OPERATORS, LOGICAL_OPERATORS)
-  },
-  {
-    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, lastToken) => {
-      if (state.variableScopeStack.at(-1) || state.variableExpressionStack.at(-1)) {
-        return false;
-      }
-      if (lastToken && lastToken.type === TokenType.Keyword) {
-        switch (lastToken.value) {
-          case "if":
-          case "badge":
-          case "title": {
-            return false;
-          }
-        }
-      }
-      return true;
-    }
-  },
-  {
-    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(rawInput, fileLocation) {
-  const input = rawInput.replace(/\r\n/g, "\n");
-  let index = 0, line = 1, start = 0, end = 0;
-  const tokens = [];
-  const errors = [];
-  const state = {
-    variableScopeStack: [],
-    variableExpressionStack: []
-  };
-  while (index < input.length) {
-    let hasMatch = false;
-    for (const { type, matcher, valueExtractor, construct, condition } of TOKENS) {
-      let value;
-      let token;
-      const lastToken = tokens.at(-1);
-      if (condition) {
-        if (!condition(state, lastToken)) {
-          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 = {
-          file: fileLocation,
-          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: {
-                let variableScope = false;
-                if (lastToken && lastToken.type === TokenType.Keyword) {
-                  switch (lastToken.value) {
-                    case "fields":
-                    case "information":
-                    case "form":
-                    case "table":
-                    case "tableMeta":
-                    case "indexes":
-                    case "filters":
-                    case "writable":
-                    case "required":
-                    case "properties": {
-                      variableScope = true;
-                      break;
-                    }
-                  }
-                }
-                state.variableScopeStack.push(variableScope);
-                break;
-              }
-              case TokenType.LeftParens: {
-                let variableExpression = false;
-                if (lastToken) {
-                  switch (lastToken.type) {
-                    case TokenType.Keyword: {
-                      switch (lastToken.value) {
-                        case "if": {
-                          variableExpression = true;
-                          break;
-                        }
-                      }
-                      break;
-                    }
-                    case TokenType.Operator: {
-                      variableExpression = true;
-                      break;
-                    }
-                  }
-                }
-                state.variableExpressionStack.push(variableExpression);
-                break;
-              }
-              case TokenType.RightBracket: {
-                if (state.variableScopeStack.length > 0) {
-                  state.variableScopeStack.pop();
-                }
-                break;
-              }
-              case TokenType.RightParens: {
-                if (state.variableExpressionStack.length > 0) {
-                  state.variableExpressionStack.pop();
-                }
-                break;
-              }
-            }
-            tokens.push(token);
-          }
-        }
-        hasMatch = true;
-      }
-    }
-    if (!hasMatch) {
-      index += input.slice(index).search(/[ \t\n\{\}\(\)\[\]]/);
-      errors.push(new Diagnostic("unexpected token", {
-        file: fileLocation,
-        index,
-        line,
-        start,
-        end
-      }));
-    }
-  }
-  return {
-    tokens,
-    errors
-  };
-};