@aeriajs/compiler 0.0.25 → 0.0.27

package/dist/ast.d.ts

@@ -1,4 +1,4 @@
-import type { Property, AccessCondition, CollectionActions, SearchOptions, DescriptionPreset, Icon, OwnershipMode, Layout, LayoutOptions } from '@aeriajs/types';
+import type { Property, AccessCondition, CollectionActions, SearchOptions, DescriptionPreset, Icon, OwnershipMode, Layout, LayoutOptions, FormLayout, Description, FormLayoutField } from '@aeriajs/types';
 import type { ArrayProperties } from './utils.js';
 export declare const LOCATION_SYMBOL: unique symbol;
 export declare const PropertyType: {
@@ -26,6 +26,16 @@ export type LayoutNode = NodeBase<'layout'> & Layout & {
         };
     };
 };
+export type FormLayoutNode = NodeBase<'formLayout'> & FormLayout<Description> & {
+    [LOCATION_SYMBOL]: {
+        fields: {
+            [P in string]: {
+                name: symbol;
+                field: FormLayoutField<Description>;
+            };
+        };
+    };
+};
 export type PropertyNode = NodeBase<'property'> & {
     modifier?: keyof typeof PropertyModifiers;
     property: Property & {
@@ -61,6 +71,7 @@ export type CollectionNode = NodeBase<'collection'> & {
     filters?: string[];
     search?: SearchOptions<any>;
     layout?: LayoutNode;
+    formLayout?: FormLayoutNode;
     [LOCATION_SYMBOL]: {
         arrays: {
             [P in ArrayProperties<CollectionNode>]?: symbol[];
@@ -87,4 +98,3 @@ export type ProgramNode = NodeBase<'program'> & {
     functionsets: FunctionSetNode[];
 };
 export type Node = CollectionNode | ContractNode | FunctionSetNode;
-export type NoteKind = Node['kind'];

package/dist/codegen/generateJSCollections.js

@@ -80,6 +80,9 @@ const makeJSCollectionSchema = (collectionNode, collectionId) => {
             case 'layout':
                 collectionSchema.description[key] = collectionNode[key];
                 break;
+            case 'formLayout':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
             case 'required':
                 collectionSchema.description[key] = collectionNode[key];
                 break;

package/dist/codegen/generateJSCollections.mjs

@@ -73,6 +73,9 @@ const makeJSCollectionSchema = (collectionNode, collectionId) => {
       case "layout":
         collectionSchema.description[key] = collectionNode[key];
         break;
+      case "formLayout":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
       case "required":
         collectionSchema.description[key] = collectionNode[key];
         break;

package/dist/codegen/generateTSCollections.js

@@ -87,6 +87,12 @@ const makeTSCollectionSchema = (collectionNode, collectionId) => {
             case 'search':
                 collectionSchema.description[key] = collectionNode[key];
                 break;
+            case 'layout':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
+            case 'formLayout':
+                collectionSchema.description[key] = collectionNode[key];
+                break;
             case 'required':
                 collectionSchema.description[key] = collectionNode[key];
                 break;

package/dist/codegen/generateTSCollections.mjs

@@ -82,6 +82,12 @@ const makeTSCollectionSchema = (collectionNode, collectionId) => {
       case "search":
         collectionSchema.description[key] = collectionNode[key];
         break;
+      case "layout":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
+      case "formLayout":
+        collectionSchema.description[key] = collectionNode[key];
+        break;
       case "required":
         collectionSchema.description[key] = collectionNode[key];
         break;

package/dist/diagnostic.js

@@ -17,6 +17,9 @@ class Diagnostic extends Error {
         this.message = message;
         this.location = location;
         this.fileLocation = fileLocation;
+        if (process.env.NODE_ENV === 'debug') {
+            console.error(message, location);
+        }
     }
 }
 exports.Diagnostic = Diagnostic;

package/dist/diagnostic.mjs

@@ -11,6 +11,9 @@ export class Diagnostic extends Error {
     this.message = message;
     this.location = location;
     this.fileLocation = fileLocation;
+    if (false) {
+      console.error(message, location);
+    }
   }
   static currentFile;
 }

package/dist/lexer.d.ts

@@ -1,15 +1,17 @@
 import { type Token } from './token.js';
 import { Diagnostic } from './diagnostic.js';
-export declare const COLLECTION_KEYWORDS: readonly ["actions", "additionalProperties", "filters", "form", "functions", "icon", "indexes", "individualActions", "layout", "owned", "presets", "properties", "required", "search", "table"];
+export declare const COLLECTION_KEYWORDS: readonly ["actions", "additionalProperties", "filters", "form", "formLayout", "functions", "icon", "indexes", "individualActions", "layout", "owned", "presets", "properties", "required", "search", "table"];
 export declare const COLLECTION_ACTIONS_KEYWORDS: readonly ["ask", "button", "clearItem", "effect", "event", "fetchItem", "function", "icon", "label", "params", "query", "requires", "roles", "route", "selection", "setItem", "translate"];
 export declare const COLLECTION_SEARCH_KEYWORDS: readonly ["indexes", "placeholder", "exactMatches"];
 export declare const COLLECTION_LAYOUT_KEYWORDS: readonly ["name", "options"];
 export declare const COLLECTION_LAYOUT_OPTIONS_KEYWORDS: readonly ["title", "picture", "badge", "information", "active", "translateBadge"];
+export declare const COLLECTION_FORM_LAYOUT_KEYWORDS: readonly ["fields", "if", "span", "verticalSpacing", "separator"];
 export declare const CONTRACT_KEYWORDS: readonly ["roles", "payload", "query", "response"];
 export declare const TOPLEVEL_KEYWORDS: readonly ["collection", "contract", "functionset"];
 export declare const MISC_KEYWORDS: readonly ["extends"];
-export type Keyword = typeof COLLECTION_KEYWORDS[number] | typeof COLLECTION_ACTIONS_KEYWORDS[number] | typeof COLLECTION_SEARCH_KEYWORDS[number] | typeof COLLECTION_LAYOUT_KEYWORDS[number] | typeof COLLECTION_LAYOUT_OPTIONS_KEYWORDS[number] | typeof CONTRACT_KEYWORDS[number] | typeof TOPLEVEL_KEYWORDS[number] | typeof MISC_KEYWORDS[number];
+export type Keyword = typeof COLLECTION_KEYWORDS[number] | typeof COLLECTION_ACTIONS_KEYWORDS[number] | typeof COLLECTION_SEARCH_KEYWORDS[number] | typeof COLLECTION_LAYOUT_KEYWORDS[number] | typeof COLLECTION_LAYOUT_OPTIONS_KEYWORDS[number] | typeof COLLECTION_FORM_LAYOUT_KEYWORDS[number] | typeof CONTRACT_KEYWORDS[number] | typeof TOPLEVEL_KEYWORDS[number] | typeof MISC_KEYWORDS[number];
 export declare const KEYWORDS: Keyword[];
+export declare const OPERATORS: readonly ["&&", "||", "==", "in", ">=", "<=", ">", "<"];
 export declare const tokenize: (rawInput: string) => {
     tokens: Token[];
     errors: Diagnostic[];

package/dist/lexer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokenize = exports.KEYWORDS = exports.MISC_KEYWORDS = exports.TOPLEVEL_KEYWORDS = exports.CONTRACT_KEYWORDS = exports.COLLECTION_LAYOUT_OPTIONS_KEYWORDS = exports.COLLECTION_LAYOUT_KEYWORDS = exports.COLLECTION_SEARCH_KEYWORDS = exports.COLLECTION_ACTIONS_KEYWORDS = exports.COLLECTION_KEYWORDS = void 0;
+exports.tokenize = exports.OPERATORS = exports.KEYWORDS = exports.MISC_KEYWORDS = exports.TOPLEVEL_KEYWORDS = exports.CONTRACT_KEYWORDS = exports.COLLECTION_FORM_LAYOUT_KEYWORDS = exports.COLLECTION_LAYOUT_OPTIONS_KEYWORDS = exports.COLLECTION_LAYOUT_KEYWORDS = exports.COLLECTION_SEARCH_KEYWORDS = exports.COLLECTION_ACTIONS_KEYWORDS = exports.COLLECTION_KEYWORDS = void 0;
 const token_js_1 = require("./token.js");
 const diagnostic_js_1 = require("./diagnostic.js");
 exports.COLLECTION_KEYWORDS = [
@@ -8,6 +8,7 @@ exports.COLLECTION_KEYWORDS = [
     'additionalProperties',
     'filters',
     'form',
+    'formLayout',
     'functions',
     'icon',
     'indexes',
@@ -56,6 +57,13 @@ exports.COLLECTION_LAYOUT_OPTIONS_KEYWORDS = [
     'active',
     'translateBadge',
 ];
+exports.COLLECTION_FORM_LAYOUT_KEYWORDS = [
+    'fields',
+    'if',
+    'span',
+    'verticalSpacing',
+    'separator',
+];
 exports.CONTRACT_KEYWORDS = [
     'roles',
     'payload',
@@ -68,7 +76,17 @@ exports.TOPLEVEL_KEYWORDS = [
     'functionset',
 ];
 exports.MISC_KEYWORDS = ['extends'];
-exports.KEYWORDS = [].concat(exports.COLLECTION_KEYWORDS, exports.COLLECTION_ACTIONS_KEYWORDS, exports.COLLECTION_SEARCH_KEYWORDS, exports.COLLECTION_LAYOUT_KEYWORDS, exports.COLLECTION_LAYOUT_OPTIONS_KEYWORDS, exports.CONTRACT_KEYWORDS, exports.TOPLEVEL_KEYWORDS, exports.MISC_KEYWORDS);
+exports.KEYWORDS = [].concat(exports.COLLECTION_KEYWORDS, exports.COLLECTION_ACTIONS_KEYWORDS, exports.COLLECTION_SEARCH_KEYWORDS, exports.COLLECTION_LAYOUT_KEYWORDS, exports.COLLECTION_LAYOUT_OPTIONS_KEYWORDS, exports.COLLECTION_FORM_LAYOUT_KEYWORDS, exports.CONTRACT_KEYWORDS, exports.TOPLEVEL_KEYWORDS, exports.MISC_KEYWORDS);
+exports.OPERATORS = [
+    '&&',
+    '||',
+    '==',
+    'in',
+    '>=',
+    '<=',
+    '>',
+    '<',
+];
 const keywordsSet = new Set();
 for (const keyword of exports.KEYWORDS) {
     keywordsSet.add(keyword);
@@ -110,6 +128,10 @@ const TOKENS = [
         type: token_js_1.TokenType.RightSquareBracket,
         matcher: ']',
     },
+    {
+        type: token_js_1.TokenType.Operator,
+        matcher: exports.OPERATORS,
+    },
     {
         type: token_js_1.TokenType.Pipe,
         matcher: '|',
@@ -150,7 +172,7 @@ const TOKENS = [
         type: token_js_1.TokenType.Keyword,
         matcher: Array.from(keywordsSet),
         condition: (state, lastToken) => {
-            if (state.inPropertiesStack.at(-1)) {
+            if (state.variableScopeStack.at(-1)) {
                 return false;
             }
             if (lastToken && lastToken.type === token_js_1.TokenType.Keyword) {
@@ -190,7 +212,7 @@ const tokenize = function (rawInput) {
     const tokens = [];
     const errors = [];
     const state = {
-        inPropertiesStack: [],
+        variableScopeStack: [],
     };
     while (index < input.length) {
         let hasMatch = false;
@@ -260,8 +282,10 @@ const tokenize = function (rawInput) {
                         };
                         switch (type) {
                             case token_js_1.TokenType.LeftBracket: {
+                                let variableScope = false;
                                 if (lastToken && lastToken.type === token_js_1.TokenType.Keyword) {
                                     switch (lastToken.value) {
+                                        case 'fields':
                                         case 'information':
                                         case 'form':
                                         case 'table':
@@ -270,19 +294,17 @@ const tokenize = function (rawInput) {
                                         case 'writable':
                                         case 'required':
                                         case 'properties': {
-                                            state.inPropertiesStack.push(true);
+                                            variableScope = true;
                                             break;
                                         }
-                                        default: {
-                                            state.inPropertiesStack.push(false);
-                                        }
                                     }
                                 }
+                                state.variableScopeStack.push(variableScope);
                                 break;
                             }
                             case token_js_1.TokenType.RightBracket: {
-                                if (state.inPropertiesStack.length > 0) {
-                                    state.inPropertiesStack.pop();
+                                if (state.variableScopeStack.length > 0) {
+                                    state.variableScopeStack.pop();
                                 }
                                 break;
                             }

package/dist/lexer.mjs

@@ -6,6 +6,7 @@ export const COLLECTION_KEYWORDS = [
   "additionalProperties",
   "filters",
   "form",
+  "formLayout",
   "functions",
   "icon",
   "indexes",
@@ -54,6 +55,13 @@ export const COLLECTION_LAYOUT_OPTIONS_KEYWORDS = [
   "active",
   "translateBadge"
 ];
+export const COLLECTION_FORM_LAYOUT_KEYWORDS = [
+  "fields",
+  "if",
+  "span",
+  "verticalSpacing",
+  "separator"
+];
 export const CONTRACT_KEYWORDS = [
   "roles",
   "payload",
@@ -72,10 +80,21 @@ export const KEYWORDS = [].concat(
   COLLECTION_SEARCH_KEYWORDS,
   COLLECTION_LAYOUT_KEYWORDS,
   COLLECTION_LAYOUT_OPTIONS_KEYWORDS,
+  COLLECTION_FORM_LAYOUT_KEYWORDS,
   CONTRACT_KEYWORDS,
   TOPLEVEL_KEYWORDS,
   MISC_KEYWORDS
 );
+export const OPERATORS = [
+  "&&",
+  "||",
+  "==",
+  "in",
+  ">=",
+  "<=",
+  ">",
+  "<"
+];
 const keywordsSet = /* @__PURE__ */ new Set();
 for (const keyword of KEYWORDS) {
   keywordsSet.add(keyword);
@@ -117,6 +136,10 @@ const TOKENS = [
     type: TokenType.RightSquareBracket,
     matcher: "]"
   },
+  {
+    type: TokenType.Operator,
+    matcher: OPERATORS
+  },
   {
     type: TokenType.Pipe,
     matcher: "|"
@@ -157,7 +180,7 @@ const TOKENS = [
     type: TokenType.Keyword,
     matcher: Array.from(keywordsSet),
     condition: (state, lastToken) => {
-      if (state.inPropertiesStack.at(-1)) {
+      if (state.variableScopeStack.at(-1)) {
         return false;
       }
       if (lastToken && lastToken.type === TokenType.Keyword) {
@@ -197,7 +220,7 @@ export const tokenize = function(rawInput) {
   const tokens = [];
   const errors = [];
   const state = {
-    inPropertiesStack: []
+    variableScopeStack: []
   };
   while (index < input.length) {
     let hasMatch = false;
@@ -262,8 +285,10 @@ export const tokenize = function(rawInput) {
             };
             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":
@@ -272,19 +297,17 @@ export const tokenize = function(rawInput) {
                     case "writable":
                     case "required":
                     case "properties": {
-                      state.inPropertiesStack.push(true);
+                      variableScope = true;
                       break;
                     }
-                    default: {
-                      state.inPropertiesStack.push(false);
-                    }
                   }
                 }
+                state.variableScopeStack.push(variableScope);
                 break;
               }
               case TokenType.RightBracket: {
-                if (state.inPropertiesStack.length > 0) {
-                  state.inPropertiesStack.pop();
+                if (state.variableScopeStack.length > 0) {
+                  state.variableScopeStack.pop();
                 }
                 break;
               }

package/dist/parser.js

@@ -600,6 +600,7 @@ const parse = (tokens) => {
                     }
                     continue;
                 }
+                throw err;
             }
         }
         consume(token_js_1.TokenType.RightBracket);
@@ -731,6 +732,10 @@ const parse = (tokens) => {
                         node[keyword] = parseLayoutBlock();
                         break;
                     }
+                    case 'formLayout': {
+                        node[keyword] = parseFormLayoutBlock();
+                        break;
+                    }
                 }
             }
             catch (err) {
@@ -739,6 +744,7 @@ const parse = (tokens) => {
                     recover(lexer.COLLECTION_KEYWORDS);
                     continue;
                 }
+                throw err;
             }
         }
         consume(token_js_1.TokenType.RightBracket);
@@ -792,6 +798,7 @@ const parse = (tokens) => {
                 if (match(token_js_1.TokenType.MacroName)) {
                     const { value: macroName } = consume(token_js_1.TokenType.MacroName, ['include']);
                     switch (macroName) {
+                        /* eslint-disable-next-line */
                         case 'include': {
                             const { value: functionSetName, location } = consume(token_js_1.TokenType.Identifier);
                             const functionset = ast.functionsets.find((node) => node.name === functionSetName);
@@ -835,6 +842,7 @@ const parse = (tokens) => {
                     errors.push(err);
                     continue;
                 }
+                throw err;
             }
         }
         consume(token_js_1.TokenType.RightBracket);
@@ -1051,6 +1059,148 @@ const parse = (tokens) => {
             },
         };
     };
+    const parseFormLayoutBlock = () => {
+        const fields = {};
+        const node = {
+            kind: 'formLayout',
+            fields,
+            [AST.LOCATION_SYMBOL]: {
+                fields: {},
+            },
+        };
+        consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: keyword, location: keywordLocation } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+            switch (keyword) {
+                case 'fields': {
+                    consume(token_js_1.TokenType.LeftBracket);
+                    while (!match(token_js_1.TokenType.RightBracket)) {
+                        const { value: identifier, location: identifierLocation } = consume(token_js_1.TokenType.Identifier);
+                        const identifierSymbol = Symbol();
+                        exports.locationMap.set(identifierSymbol, identifierLocation);
+                        fields[identifier] ??= {};
+                        node[AST.LOCATION_SYMBOL].fields[identifier] = {
+                            name: identifierSymbol,
+                            field: {},
+                        };
+                        consume(token_js_1.TokenType.LeftBracket);
+                        while (!match(token_js_1.TokenType.RightBracket)) {
+                            const { value: keyword, location: keywordLocation } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+                            switch (keyword) {
+                                case 'if': {
+                                    fields[identifier].if = parseCondition();
+                                    break;
+                                }
+                                case 'span':
+                                case 'verticalSpacing': {
+                                    fields[identifier].span = consume(token_js_1.TokenType.Number).value;
+                                    break;
+                                }
+                                case 'separator': {
+                                    fields[identifier].separator = match(token_js_1.TokenType.Boolean)
+                                        ? consume(token_js_1.TokenType.Boolean).value
+                                        : consume(token_js_1.TokenType.QuotedString, [
+                                            'top',
+                                            'bottom',
+                                        ]).value;
+                                    break;
+                                }
+                                default: {
+                                    throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
+                                }
+                            }
+                        }
+                        consume(token_js_1.TokenType.RightBracket);
+                    }
+                    consume(token_js_1.TokenType.RightBracket);
+                    break;
+                }
+                default: {
+                    throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return node;
+    };
+    const parseCondition = () => {
+        if (match(token_js_1.TokenType.LeftParens)) {
+            consume(token_js_1.TokenType.LeftParens);
+            let operatorType, newOp = operatorType;
+            const conditions = [];
+            while (!match(token_js_1.TokenType.RightParens)) {
+                conditions.push(parseCondition());
+                if (match(token_js_1.TokenType.RightParens)) {
+                    break;
+                }
+                const { value: operatorSymbol, location } = consume(token_js_1.TokenType.Operator);
+                switch (operatorSymbol) {
+                    case '&&':
+                        newOp = 'and';
+                        break;
+                    case '||':
+                        newOp = 'or';
+                        break;
+                    default: {
+                        throw new diagnostic_js_1.Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
+                    }
+                }
+                if (operatorType && operatorType !== newOp) {
+                    throw new diagnostic_js_1.Diagnostic('having "and" or "or" in the same expression is not supported, please use parenthesis', location);
+                }
+                operatorType = newOp;
+            }
+            consume(token_js_1.TokenType.RightParens);
+            switch (operatorType) {
+                case 'and': {
+                    return {
+                        and: conditions,
+                    };
+                }
+                case 'or': {
+                    return {
+                        or: conditions,
+                    };
+                }
+                default: {
+                    return conditions[0];
+                }
+            }
+        }
+        const { value: term1 } = consume(token_js_1.TokenType.Identifier);
+        const { value: operatorSymbol, location } = consume(token_js_1.TokenType.Operator);
+        const { value: term2 } = current();
+        advance();
+        let operator;
+        switch (operatorSymbol) {
+            case '==':
+                operator = 'equal';
+                break;
+            case 'in':
+                operator = 'in';
+                break;
+            case '>=':
+                operator = 'gte';
+                break;
+            case '<=':
+                operator = 'lte';
+                break;
+            case '>':
+                operator = 'gt';
+                break;
+            case '<':
+                operator = 'lt';
+                break;
+            default: {
+                throw new diagnostic_js_1.Diagnostic(`unsuported operator: "${operatorSymbol}"`, location);
+            }
+        }
+        return {
+            operator,
+            term1,
+            term2,
+        };
+    };
     while (index < tokens.length) {
         const { value: declType, location } = current();
         try {

package/dist/parser.mjs

@@ -551,6 +551,7 @@ export const parse = (tokens) => {
           }
           continue;
         }
+        throw err;
       }
     }
     consume(TokenType.RightBracket);
@@ -676,6 +677,10 @@ export const parse = (tokens) => {
             node[keyword] = parseLayoutBlock();
             break;
           }
+          case "formLayout": {
+            node[keyword] = parseFormLayoutBlock();
+            break;
+          }
         }
       } catch (err) {
         if (err instanceof Diagnostic) {
@@ -683,6 +688,7 @@ export const parse = (tokens) => {
           recover(lexer.COLLECTION_KEYWORDS);
           continue;
         }
+        throw err;
       }
     }
     consume(TokenType.RightBracket);
@@ -777,6 +783,7 @@ export const parse = (tokens) => {
           errors.push(err);
           continue;
         }
+        throw err;
       }
     }
     consume(TokenType.RightBracket);
@@ -991,6 +998,146 @@ export const parse = (tokens) => {
       }
     };
   };
+  const parseFormLayoutBlock = () => {
+    const fields = {};
+    const node = {
+      kind: "formLayout",
+      fields,
+      [AST.LOCATION_SYMBOL]: {
+        fields: {}
+      }
+    };
+    consume(TokenType.LeftBracket);
+    while (!match(TokenType.RightBracket)) {
+      const { value: keyword, location: keywordLocation } = consume(TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+      switch (keyword) {
+        case "fields": {
+          consume(TokenType.LeftBracket);
+          while (!match(TokenType.RightBracket)) {
+            const { value: identifier, location: identifierLocation } = consume(TokenType.Identifier);
+            const identifierSymbol = Symbol();
+            locationMap.set(identifierSymbol, identifierLocation);
+            fields[identifier] ??= {};
+            node[AST.LOCATION_SYMBOL].fields[identifier] = {
+              name: identifierSymbol,
+              field: {}
+            };
+            consume(TokenType.LeftBracket);
+            while (!match(TokenType.RightBracket)) {
+              const { value: keyword2, location: keywordLocation2 } = consume(TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+              switch (keyword2) {
+                case "if": {
+                  fields[identifier].if = parseCondition();
+                  break;
+                }
+                case "span":
+                case "verticalSpacing": {
+                  fields[identifier].span = consume(TokenType.Number).value;
+                  break;
+                }
+                case "separator": {
+                  fields[identifier].separator = match(TokenType.Boolean) ? consume(TokenType.Boolean).value : consume(TokenType.QuotedString, [
+                    "top",
+                    "bottom"
+                  ]).value;
+                  break;
+                }
+                default: {
+                  throw new Diagnostic(`invalid keyword "${keyword2}"`, keywordLocation2);
+                }
+              }
+            }
+            consume(TokenType.RightBracket);
+          }
+          consume(TokenType.RightBracket);
+          break;
+        }
+        default: {
+          throw new Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
+        }
+      }
+    }
+    consume(TokenType.RightBracket);
+    return node;
+  };
+  const parseCondition = () => {
+    if (match(TokenType.LeftParens)) {
+      consume(TokenType.LeftParens);
+      let operatorType, newOp = operatorType;
+      const conditions = [];
+      while (!match(TokenType.RightParens)) {
+        conditions.push(parseCondition());
+        if (match(TokenType.RightParens)) {
+          break;
+        }
+        const { value: operatorSymbol2, location: location2 } = consume(TokenType.Operator);
+        switch (operatorSymbol2) {
+          case "&&":
+            newOp = "and";
+            break;
+          case "||":
+            newOp = "or";
+            break;
+          default: {
+            throw new Diagnostic(`unsupported operator: "${operatorSymbol2}"`, location2);
+          }
+        }
+        if (operatorType && operatorType !== newOp) {
+          throw new Diagnostic('having "and" or "or" in the same expression is not supported, please use parenthesis', location2);
+        }
+        operatorType = newOp;
+      }
+      consume(TokenType.RightParens);
+      switch (operatorType) {
+        case "and": {
+          return {
+            and: conditions
+          };
+        }
+        case "or": {
+          return {
+            or: conditions
+          };
+        }
+        default: {
+          return conditions[0];
+        }
+      }
+    }
+    const { value: term1 } = consume(TokenType.Identifier);
+    const { value: operatorSymbol, location } = consume(TokenType.Operator);
+    const { value: term2 } = current();
+    advance();
+    let operator;
+    switch (operatorSymbol) {
+      case "==":
+        operator = "equal";
+        break;
+      case "in":
+        operator = "in";
+        break;
+      case ">=":
+        operator = "gte";
+        break;
+      case "<=":
+        operator = "lte";
+        break;
+      case ">":
+        operator = "gt";
+        break;
+      case "<":
+        operator = "lt";
+        break;
+      default: {
+        throw new Diagnostic(`unsuported operator: "${operatorSymbol}"`, location);
+      }
+    }
+    return {
+      operator,
+      term1,
+      term2
+    };
+  };
   while (index < tokens.length) {
     const { value: declType, location } = current();
     try {

package/dist/semantic.js

@@ -160,6 +160,16 @@ const analyze = async (ast, options, errors = []) => {
                 }
             }
         }
+        if (node.formLayout) {
+            if (node.formLayout.fields) {
+                for (const [name, value] of Object.entries(node.formLayout[AST.LOCATION_SYMBOL].fields)) {
+                    if (!(name in node.properties)) {
+                        const location = parser_js_1.locationMap.get(value.name);
+                        errors.push(new diagnostic_js_1.Diagnostic(`invalid property "${name}"`, location));
+                    }
+                }
+            }
+        }
     }
     for (const node of ast.contracts) {
         if (node.payload) {

package/dist/semantic.mjs

@@ -122,6 +122,16 @@ export const analyze = async (ast, options, errors = []) => {
         }
       }
     }
+    if (node.formLayout) {
+      if (node.formLayout.fields) {
+        for (const [name, value] of Object.entries(node.formLayout[AST.LOCATION_SYMBOL].fields)) {
+          if (!(name in node.properties)) {
+            const location = locationMap.get(value.name);
+            errors.push(new Diagnostic(`invalid property "${name}"`, location));
+          }
+        }
+      }
+    }
   }
   for (const node of ast.contracts) {
     if (node.payload) {

package/dist/token.d.ts

@@ -19,6 +19,7 @@ export declare const TokenType: {
     readonly AttributeName: "ATTRIBUTE_NAME";
     readonly MacroName: "MACRO_NAME";
     readonly Range: "RANGE";
+    readonly Operator: "OPERATOR";
 };
 export type TokenType = typeof TokenType[keyof typeof TokenType];
 export type TypeMap = {

package/dist/token.js

@@ -22,4 +22,5 @@ exports.TokenType = {
     AttributeName: 'ATTRIBUTE_NAME',
     MacroName: 'MACRO_NAME',
     Range: 'RANGE',
+    Operator: 'OPERATOR',
 };

package/dist/token.mjs

@@ -19,5 +19,6 @@ export const TokenType = {
   QuotedString: "QUOTED_STRING",
   AttributeName: "ATTRIBUTE_NAME",
   MacroName: "MACRO_NAME",
-  Range: "RANGE"
+  Range: "RANGE",
+  Operator: "OPERATOR"
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/compiler",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,8 +21,8 @@
     "dist"
   ],
   "peerDependencies": {
-    "@aeriajs/common": "^0.0.141",
-    "@aeriajs/types": "^0.0.123"
+    "@aeriajs/common": "^0.0.142",
+    "@aeriajs/types": "^0.0.124"
   },
   "devDependencies": {
     "@aeriajs/common": "link:../common",