@zenstackhq/language 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/ast.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/ast.ts
@@ -36,11 +46,11 @@ __export(ast_exports, {
   ConfigField: () => ConfigField,
   ConfigInvocationArg: () => ConfigInvocationArg,
   ConfigInvocationExpr: () => ConfigInvocationExpr,
+  DataField: () => DataField,
+  DataFieldAttribute: () => DataFieldAttribute,
+  DataFieldType: () => DataFieldType,
   DataModel: () => DataModel,
   DataModelAttribute: () => DataModelAttribute,
-  DataModelField: () => DataModelField,
-  DataModelFieldAttribute: () => DataModelFieldAttribute,
-  DataModelFieldType: () => DataModelFieldType,
   DataSource: () => DataSource,
   Enum: () => Enum,
   EnumField: () => EnumField,
@@ -71,9 +81,6 @@ __export(ast_exports, {
   ThisExpr: () => ThisExpr,
   TypeDeclaration: () => TypeDeclaration,
   TypeDef: () => TypeDef,
-  TypeDefField: () => TypeDefField,
-  TypeDefFieldType: () => TypeDefFieldType,
-  TypeDefFieldTypes: () => TypeDefFieldTypes,
   UnaryExpr: () => UnaryExpr,
   UnsupportedFieldType: () => UnsupportedFieldType,
   ZModelAstReflection: () => ZModelAstReflection,
@@ -94,11 +101,11 @@ __export(ast_exports, {
   isConfigField: () => isConfigField,
   isConfigInvocationArg: () => isConfigInvocationArg,
   isConfigInvocationExpr: () => isConfigInvocationExpr,
+  isDataField: () => isDataField,
+  isDataFieldAttribute: () => isDataFieldAttribute,
+  isDataFieldType: () => isDataFieldType,
   isDataModel: () => isDataModel,
   isDataModelAttribute: () => isDataModelAttribute,
-  isDataModelField: () => isDataModelField,
-  isDataModelFieldAttribute: () => isDataModelFieldAttribute,
-  isDataModelFieldType: () => isDataModelFieldType,
   isDataSource: () => isDataSource,
   isEnum: () => isEnum,
   isEnumField: () => isEnumField,
@@ -132,9 +139,6 @@ __export(ast_exports, {
   isThisExpr: () => isThisExpr,
   isTypeDeclaration: () => isTypeDeclaration,
   isTypeDef: () => isTypeDef,
-  isTypeDefField: () => isTypeDefField,
-  isTypeDefFieldType: () => isTypeDefFieldType,
-  isTypeDefFieldTypes: () => isTypeDefFieldTypes,
   isUnaryExpr: () => isUnaryExpr,
   isUnsupportedFieldType: () => isUnsupportedFieldType,
   reflection: () => reflection
@@ -142,7 +146,7 @@ __export(ast_exports, {
 module.exports = __toCommonJS(ast_exports);
 
 // src/generated/ast.ts
-var import_langium = require("langium");
+var langium = __toESM(require("langium"), 1);
 var ZModelTerminals = {
   WS: /\s+/,
   INTERNAL_ATTRIBUTE_NAME: /@@@([_a-zA-Z][\w_]*\.)*[_a-zA-Z][\w_]*/,
@@ -210,11 +214,6 @@ function isTypeDeclaration(item) {
   return reflection.isInstance(item, TypeDeclaration);
 }
 __name(isTypeDeclaration, "isTypeDeclaration");
-var TypeDefFieldTypes = "TypeDefFieldTypes";
-function isTypeDefFieldTypes(item) {
-  return reflection.isInstance(item, TypeDefFieldTypes);
-}
-__name(isTypeDefFieldTypes, "isTypeDefFieldTypes");
 var Argument = "Argument";
 function isArgument(item) {
   return reflection.isInstance(item, Argument);
@@ -275,6 +274,21 @@ function isConfigInvocationExpr(item) {
   return reflection.isInstance(item, ConfigInvocationExpr);
 }
 __name(isConfigInvocationExpr, "isConfigInvocationExpr");
+var DataField = "DataField";
+function isDataField(item) {
+  return reflection.isInstance(item, DataField);
+}
+__name(isDataField, "isDataField");
+var DataFieldAttribute = "DataFieldAttribute";
+function isDataFieldAttribute(item) {
+  return reflection.isInstance(item, DataFieldAttribute);
+}
+__name(isDataFieldAttribute, "isDataFieldAttribute");
+var DataFieldType = "DataFieldType";
+function isDataFieldType(item) {
+  return reflection.isInstance(item, DataFieldType);
+}
+__name(isDataFieldType, "isDataFieldType");
 var DataModel = "DataModel";
 function isDataModel(item) {
   return reflection.isInstance(item, DataModel);
@@ -285,21 +299,6 @@ function isDataModelAttribute(item) {
   return reflection.isInstance(item, DataModelAttribute);
 }
 __name(isDataModelAttribute, "isDataModelAttribute");
-var DataModelField = "DataModelField";
-function isDataModelField(item) {
-  return reflection.isInstance(item, DataModelField);
-}
-__name(isDataModelField, "isDataModelField");
-var DataModelFieldAttribute = "DataModelFieldAttribute";
-function isDataModelFieldAttribute(item) {
-  return reflection.isInstance(item, DataModelFieldAttribute);
-}
-__name(isDataModelFieldAttribute, "isDataModelFieldAttribute");
-var DataModelFieldType = "DataModelFieldType";
-function isDataModelFieldType(item) {
-  return reflection.isInstance(item, DataModelFieldType);
-}
-__name(isDataModelFieldType, "isDataModelFieldType");
 var DataSource = "DataSource";
 function isDataSource(item) {
   return reflection.isInstance(item, DataSource);
@@ -425,16 +424,6 @@ function isTypeDef(item) {
   return reflection.isInstance(item, TypeDef);
 }
 __name(isTypeDef, "isTypeDef");
-var TypeDefField = "TypeDefField";
-function isTypeDefField(item) {
-  return reflection.isInstance(item, TypeDefField);
-}
-__name(isTypeDefField, "isTypeDefField");
-var TypeDefFieldType = "TypeDefFieldType";
-function isTypeDefFieldType(item) {
-  return reflection.isInstance(item, TypeDefFieldType);
-}
-__name(isTypeDefFieldType, "isTypeDefFieldType");
 var UnaryExpr = "UnaryExpr";
 function isUnaryExpr(item) {
   return reflection.isInstance(item, UnaryExpr);
@@ -445,7 +434,7 @@ function isUnsupportedFieldType(item) {
   return reflection.isInstance(item, UnsupportedFieldType);
 }
 __name(isUnsupportedFieldType, "isUnsupportedFieldType");
-var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
+var ZModelAstReflection = class extends langium.AbstractAstReflection {
   static {
     __name(this, "ZModelAstReflection");
   }
@@ -465,11 +454,11 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
       ConfigField,
       ConfigInvocationArg,
       ConfigInvocationExpr,
+      DataField,
+      DataFieldAttribute,
+      DataFieldType,
       DataModel,
       DataModelAttribute,
-      DataModelField,
-      DataModelFieldAttribute,
-      DataModelFieldType,
       DataSource,
       Enum,
       EnumField,
@@ -500,9 +489,6 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
       ThisExpr,
       TypeDeclaration,
       TypeDef,
-      TypeDefField,
-      TypeDefFieldType,
-      TypeDefFieldTypes,
       UnaryExpr,
       UnsupportedFieldType
     ];
@@ -535,16 +521,13 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
       case ConfigArrayExpr: {
         return this.isSubtype(ConfigExpr, supertype);
       }
-      case DataModel: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
-      }
-      case DataModelField:
-      case TypeDefField: {
+      case DataField: {
         return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
       }
+      case DataModel:
       case Enum:
       case TypeDef: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype) || this.isSubtype(TypeDefFieldTypes, supertype);
+        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
       }
       case EnumField:
       case FunctionParam: {
@@ -563,18 +546,22 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
     const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
     switch (referenceId) {
       case "AttributeParamType:reference":
-      case "DataModelFieldType:reference":
+      case "DataFieldType:reference":
       case "FunctionParamType:reference": {
         return TypeDeclaration;
       }
-      case "DataModel:superTypes": {
-        return DataModel;
-      }
+      case "DataFieldAttribute:decl":
       case "DataModelAttribute:decl":
-      case "DataModelFieldAttribute:decl":
       case "InternalAttribute:decl": {
         return Attribute;
       }
+      case "DataModel:baseModel": {
+        return DataModel;
+      }
+      case "DataModel:mixins":
+      case "TypeDef:mixins": {
+        return TypeDef;
+      }
       case "InvocationExpr:function": {
         return FunctionDecl;
       }
@@ -584,9 +571,6 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
       case "ReferenceExpr:target": {
         return ReferenceTarget;
       }
-      case "TypeDefFieldType:reference": {
-        return TypeDefFieldTypes;
-      }
       default: {
         throw new Error(`${referenceId} is not a valid reference id.`);
       }
@@ -773,9 +757,9 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
           ]
         };
       }
-      case DataModel: {
+      case DataField: {
         return {
-          name: DataModel,
+          name: DataField,
           properties: [
             {
               name: "attributes",
@@ -785,31 +769,18 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
               name: "comments",
               defaultValue: []
             },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "isAbstract",
-              defaultValue: false
-            },
-            {
-              name: "isView",
-              defaultValue: false
-            },
             {
               name: "name"
             },
             {
-              name: "superTypes",
-              defaultValue: []
+              name: "type"
             }
           ]
         };
       }
-      case DataModelAttribute: {
+      case DataFieldAttribute: {
         return {
-          name: DataModelAttribute,
+          name: DataFieldAttribute,
           properties: [
             {
               name: "args",
@@ -821,61 +792,73 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
           ]
         };
       }
-      case DataModelField: {
+      case DataFieldType: {
         return {
-          name: DataModelField,
+          name: DataFieldType,
           properties: [
             {
-              name: "attributes",
-              defaultValue: []
+              name: "array",
+              defaultValue: false
             },
             {
-              name: "comments",
-              defaultValue: []
+              name: "optional",
+              defaultValue: false
             },
             {
-              name: "name"
+              name: "reference"
             },
             {
               name: "type"
+            },
+            {
+              name: "unsupported"
             }
           ]
         };
       }
-      case DataModelFieldAttribute: {
+      case DataModel: {
         return {
-          name: DataModelFieldAttribute,
+          name: DataModel,
           properties: [
             {
-              name: "args",
+              name: "attributes",
               defaultValue: []
             },
             {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case DataModelFieldType: {
-        return {
-          name: DataModelFieldType,
-          properties: [
+              name: "baseModel"
+            },
             {
-              name: "array",
-              defaultValue: false
+              name: "comments",
+              defaultValue: []
             },
             {
-              name: "optional",
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "isView",
               defaultValue: false
             },
             {
-              name: "reference"
+              name: "mixins",
+              defaultValue: []
             },
             {
-              name: "type"
+              name: "name"
+            }
+          ]
+        };
+      }
+      case DataModelAttribute: {
+        return {
+          name: DataModelAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
             },
             {
-              name: "unsupported"
+              name: "decl"
             }
           ]
         };
@@ -1249,49 +1232,11 @@ var ZModelAstReflection = class extends import_langium.AbstractAstReflection {
               defaultValue: []
             },
             {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case TypeDefField: {
-        return {
-          name: TypeDefField,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
+              name: "mixins",
               defaultValue: []
             },
             {
               name: "name"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case TypeDefFieldType: {
-        return {
-          name: TypeDefFieldType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
             }
           ]
         };
@@ -1366,11 +1311,11 @@ var BinaryExprOperatorPriority = {
   ConfigField,
   ConfigInvocationArg,
   ConfigInvocationExpr,
+  DataField,
+  DataFieldAttribute,
+  DataFieldType,
   DataModel,
   DataModelAttribute,
-  DataModelField,
-  DataModelFieldAttribute,
-  DataModelFieldType,
   DataSource,
   Enum,
   EnumField,
@@ -1401,9 +1346,6 @@ var BinaryExprOperatorPriority = {
   ThisExpr,
   TypeDeclaration,
   TypeDef,
-  TypeDefField,
-  TypeDefFieldType,
-  TypeDefFieldTypes,
   UnaryExpr,
   UnsupportedFieldType,
   ZModelAstReflection,
@@ -1424,11 +1366,11 @@ var BinaryExprOperatorPriority = {
   isConfigField,
   isConfigInvocationArg,
   isConfigInvocationExpr,
+  isDataField,
+  isDataFieldAttribute,
+  isDataFieldType,
   isDataModel,
   isDataModelAttribute,
-  isDataModelField,
-  isDataModelFieldAttribute,
-  isDataModelFieldType,
   isDataSource,
   isEnum,
   isEnumField,
@@ -1462,9 +1404,6 @@ var BinaryExprOperatorPriority = {
   isThisExpr,
   isTypeDeclaration,
   isTypeDef,
-  isTypeDefField,
-  isTypeDefFieldType,
-  isTypeDefFieldTypes,
   isUnaryExpr,
   isUnsupportedFieldType,
   reflection