@lionweb/validation 0.7.2-beta.6 → 0.8.0-beta.0

package/src/validators/definitions/ResponseDefinitions.ts

@@ -0,0 +1,274 @@
+import { MessageGroup } from "../generic/schema/SyntaxDefinition.js";
+
+export const ResponseDefinitions: MessageGroup = {
+    name: "Response",
+    taggedUnionProperty: "messageKind",
+    sharedProperties: [
+        {
+            name: "messageKind",
+            type: "String",
+            isList: false,
+            isOptional: false,
+            mayBeNull: false,
+        },
+        {
+            name: "protocolMessages",
+            type: "ProtocolMessage",
+            isList: true,
+            isOptional: false,
+            mayBeNull: false,
+        },
+        {
+            name: "queryId",
+            type: "QueryId",
+            isList: false,
+            isOptional: false,
+            mayBeNull: false,
+        },
+    ],
+    messages: [
+        {
+            name: "SubscribeToChangingPartitionsResponse",
+            properties: [
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "SubscribeToPartitionContentsResponse",
+            properties: [
+                {
+                    name: "contents",
+                    type: "LionWebDeltaJsonChunk",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "UnsubscribeFromPartitionContentsResponse",
+            properties: [
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "SignOnResponse",
+            properties: [
+                {
+                    name: "participationId",
+                    type: "ParticipationId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "SignOffResponse",
+            properties: [
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "ReconnectResponse",
+            properties: [
+                {
+                    name: "lastSentSequenceNumber",
+                    type: "SequenceNumber",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "GetAvailableIdsResponse",
+            properties: [
+                {
+                    name: "ids",
+                    type: "LionWebId",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "ListPartitionsResponse",
+            properties: [
+                {
+                    name: "partitions",
+                    type: "LionWebDeltaJsonChunk",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "messageKind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "protocolMessages",
+                    type: "ProtocolMessage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "queryId",
+                    type: "QueryId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+    ],
+};

package/src/validators/definitions/index.ts

@@ -0,0 +1,7 @@
+export * from "./ChunksDefinitions.js"
+export * from "./CommandDefinitions.js"
+export * from "./DeltaTypesDefinitions.js"
+export * from "./EventDefinitions.js"
+export * from "./QueryDefinitions.js"
+export * from "./RequestDefinitions.js"
+export * from "./ResponseDefinitions.js"

package/src/validators/generic/SyntaxValidator.ts

@@ -6,12 +6,9 @@ import {
     Syntax_PropertyTypeIssue,
     Syntax_PropertyUnknownIssue
 } from "../../issues/index.js"
+import { SyntaxDefinition, StructuredType, PrimitiveType } from "./schema/SyntaxDefinition.js"
 import { ValidationResult } from "./ValidationResult.js"
-import {
-    isObjectDefinition,
-    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
-    UnknownObjectType
-} from "./schema/index.js"
+import { UnknownObjectType } from "./schema/index.js"
 
 /**
  * Syntax Validator checks whether objects are structurally conforming to the
@@ -19,9 +16,9 @@ import {
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    schema: DefinitionSchema
+    schema: SyntaxDefinition
 
-    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
+    constructor(validationResult: ValidationResult, schema: SyntaxDefinition) {
         this.validationResult = validationResult
         this.schema = schema
     }
@@ -34,14 +31,19 @@ export class SyntaxValidator {
      */
     validate(obj: unknown, expectedType: string) {
         const object = obj as UnknownObjectType
-        const typeDef = this.schema.getDefinition(expectedType)
+        const primitiveTypeDef: PrimitiveType | undefined = this.schema.getPrimitiveType(expectedType)
 
-        if (typeDef === undefined) {
-            throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
-        } else if (isObjectDefinition(typeDef)) {
-            this.validateObjectProperties(expectedType, typeDef, object, new JsonContext(null, ["$"]))
-        } else if (isPrimitiveDefinition(typeDef)) {
-            this.validatePrimitiveValue("$", typeDef, object, new JsonContext(null, ["$"]))
+        if (primitiveTypeDef === undefined) {
+            const objectTypeDef: StructuredType | undefined = this.schema.getStructuredType(expectedType)
+            if( objectTypeDef === undefined) {
+                throw new Error(`SyntaxValidator.validate: cannot find definition for '${expectedType}'`)
+            } else {
+                // ObjectType found
+                this.validateObjectProperties(expectedType, objectTypeDef, object, new JsonContext(null, ["$"]))
+            }
+        } else {
+            // PrimitiveType found
+            this.validatePrimitiveValue("$", primitiveTypeDef, object, new JsonContext(null, ["$"]))
         }
     }
 
@@ -53,7 +55,7 @@ export class SyntaxValidator {
      * @param jsonContext       The location in the JSON
      * @private
      */
-    validateObjectProperties(originalProperty: string, typeDef: ObjectDefinition, object: UnknownObjectType, jsonContext: JsonContext) {
+    validateObjectProperties(originalProperty: string, typeDef: StructuredType, object: UnknownObjectType, jsonContext: JsonContext) {
         if (typeDef === null || typeDef === undefined) {
             return
         }
@@ -62,8 +64,13 @@ export class SyntaxValidator {
             return
         }
         for (const propertyDef of typeDef.properties) {
-            const expectedTypeDef = this.schema.getDefinition(propertyDef.type)
-            const validator = propertyDef.validate!
+            const expectedTypeDefPrimitive = this.schema.getPrimitiveType(propertyDef.type)
+            const expectedTypeDefStructured = this.schema.getStructuredType(propertyDef.type)
+            const expectedMessageGroup = this.schema.getMessageGroup(propertyDef.type)
+            const expectedTypeDef = expectedTypeDefPrimitive ?? expectedTypeDefStructured
+
+            const validator = this.schema.getValidator(propertyDef.name)
+
             const propertyValue = object[propertyDef.name]
             if (propertyValue === undefined) {
                 if (!propertyDef.isOptional) {
@@ -93,15 +100,25 @@ export class SyntaxValidator {
                         this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, propertyDef.name, index))
                     } else {
                         if (expectedTypeDef !== undefined) {
-                            if (isPrimitiveDefinition(expectedTypeDef)) {
+                            if (expectedTypeDef === expectedTypeDefPrimitive) {
                                 if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, item, jsonContext)) {
-                                    validator.apply(null, [item, this.validationResult, newContext, propertyDef])
+                                    if (validator !== undefined) {
+                                        validator(item, this.validationResult, newContext)
+                                    }
                                 }
-                            } else {
+                            } else if (expectedTypeDef === expectedTypeDefStructured) {
                                 // propertyValue should be an object, validate its properties
                                 this.validateObjectProperties(propertyDef.name, expectedTypeDef, item as UnknownObjectType, newContext)
-                                validator.apply(null, [item, this.validationResult, newContext, propertyDef])
+                                if (validator !== undefined) {
+                                    validator(item, this.validationResult, newContext)
+                                }
                             }
+                        } else if (expectedMessageGroup !== undefined) {
+                                console.log(`+++++++++++++++++++ ${expectedMessageGroup.name}`)
+                                const messageKind = item[expectedMessageGroup.taggedUnionProperty] as string
+                                    const groupTypeDef = this.schema.getStructuredType(messageKind)!
+                                    this.validateObjectProperties(originalProperty, groupTypeDef, item as UnknownObjectType, newContext)
+                                
                         } else {
                             throw new Error(`Expected type '${propertyDef.type} has neither property defs, nor a validator.`)
                         }
@@ -115,21 +132,32 @@ export class SyntaxValidator {
                 }
                 // Single valued property, validate it
                 if (expectedTypeDef !== undefined) {
-                    if (isPrimitiveDefinition(expectedTypeDef)) {
+                    // const primitiveType = this.schema.getPrimitiveType(expectedTypeDef.name)
+                    if (expectedTypeDef === expectedTypeDefPrimitive) {
                         // propertyValue should be a primitive as it has no property definitions
                         if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, propertyValue, jsonContext)) {
-                            validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
+                            if (validator !== undefined) {
+                                validator(propertyValue, this.validationResult, newContext)
+                            }
                         }
-                    } else if (isObjectDefinition(expectedTypeDef)) {
+                    } else if (expectedTypeDef === expectedTypeDefStructured) {
                         // propertyValue should be an object, validate its properties
                         this.validateObjectProperties(propertyDef.name, expectedTypeDef, propertyValue as UnknownObjectType, newContext)
-                        validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
+                        if (validator !== undefined) {
+                            validator(propertyValue, this.validationResult, newContext)
+                        }
+                    } else if (expectedMessageGroup !== undefined) {
+                        console.log(`+++++++++++++++++++ LIST ${expectedMessageGroup.name}`)
+                        const messageKind = object[expectedMessageGroup.taggedUnionProperty] as string
+                        const groupTypeDef = this.schema.getStructuredType(messageKind)!
+                        this.validateObjectProperties(originalProperty, groupTypeDef, propertyValue as UnknownObjectType, newContext)
                     } else {
                         throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
                     }
                 } else {
                     throw new Error(
-                        `Expected single type '${propertyDef.type}' for '${propertyDef.name}'  at ${newContext.toString()} has neither property defs, nor a validator.`
+                        `Op ${originalProperty}: Expected single type '${propertyDef.type}' for '${propertyDef.name}'  at ${newContext.toString()} has neither property defs, nor a validator.
+                        Typedef is ${JSON.stringify(typeDef)}`
                     )
                 }
             }
@@ -137,12 +165,15 @@ export class SyntaxValidator {
         this.checkStrayProperties(object, typeDef, jsonContext)
     }
 
-    validatePrimitiveValue(propertyName: string, propDef: PrimitiveDefinition, object: unknown, jsonContext: JsonContext): boolean {
+    validatePrimitiveValue(propertyName: string, propDef: PrimitiveType, object: unknown, jsonContext: JsonContext): boolean {
         if (typeof object !== propDef.primitiveType) {
             this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType, typeof object))
             return false
         }
-        propDef.validate!(object, this.validationResult, jsonContext)
+        const validator = this.schema.getValidator(propDef.name)
+        if (validator !== undefined) {
+            validator(object, this.validationResult, jsonContext)
+        }
         return true
     }
 
@@ -152,7 +183,7 @@ export class SyntaxValidator {
      * @param properties    The names of the expected properties
      * @param context       Location in JSON
      */
-    checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
+    checkStrayProperties(obj: UnknownObjectType, def: StructuredType, context: JsonContext) {
         const own = Object.getOwnPropertyNames(obj)
         const defined = def.properties.map(pdef => pdef.name)
         own.forEach(ownProp => {

package/src/validators/generic/index.ts

@@ -1,3 +1,4 @@
 export * from "./schema/index.js"
 export * from "./ValidationResult.js"
 export * from "./SyntaxValidator.js"
+

package/src/validators/generic/schema/SyntaxDefinition.ts

@@ -0,0 +1,83 @@
+import { JsonContext } from "@lionweb/json-utils"
+import { ValidationResult } from "../ValidationResult.js"
+
+export type UnknownObjectType = { [key: string]: unknown }
+
+export type PrimitiveValidatorFunction = <T>(obj: T, result: ValidationResult, ctx: JsonContext) => void
+
+export type MessageGroup = {
+    name: string;
+    taggedUnionProperty: string; // messageKind 
+    sharedProperties: PropertyDefinition[];
+    messages: StructuredType[];
+}
+
+export type PropertyDefinition = {
+    name: string;
+    type: string;
+    isList: boolean,
+    isOptional: boolean,
+    mayBeNull: boolean
+}
+
+export type StructuredType = {
+    name: string;
+    properties: PropertyDefinition[];
+}
+
+export type TypeGroup = {
+    name: string;
+    primitiveTypes: PrimitiveType[];
+    structuredTypes:  StructuredType[];
+
+}
+export type PrimitiveType = {
+    name: string
+    primitiveType: string;
+}
+
+export class SyntaxDefinition {
+    // Maps to make searching easier and faster
+    allPrimitiveTypes: Map<string, PrimitiveType> = new Map<string, PrimitiveType>()
+    allStructuredTypes: Map<string, StructuredType> = new Map<string, StructuredType>()
+    allMessageGroups: Map<string, MessageGroup> = new Map<string, MessageGroup>()
+
+    validateFunctions: Map<string, PrimitiveValidatorFunction> = new Map<string, PrimitiveValidatorFunction>()
+    
+    constructor(messageGroups: MessageGroup[], typeGroups: TypeGroup[]) {
+        typeGroups.forEach(typeGroup => {
+            typeGroup.primitiveTypes.forEach(primitiveType => {
+                this.allPrimitiveTypes.set(primitiveType.name, primitiveType)
+            })
+            typeGroup.structuredTypes.forEach(objectType => {
+                this.allStructuredTypes.set(objectType.name, objectType)
+            })
+        })
+        messageGroups.forEach(messageGroup => {
+            this.allMessageGroups.set(messageGroup.name, messageGroup)
+            messageGroup.messages.forEach(msg => {
+                this.allStructuredTypes.set(msg.name, msg) 
+            })
+        })
+    }
+
+    addValidator(primitiveTypeName: string, validate: PrimitiveValidatorFunction): void {
+        this.validateFunctions.set(primitiveTypeName, validate)
+    }
+
+    getValidator(primitiveTypeName: string): PrimitiveValidatorFunction | undefined {
+        return this.validateFunctions.get(primitiveTypeName)
+    }
+
+    getPrimitiveType(name: string): PrimitiveType | undefined {
+        return this.allPrimitiveTypes.get(name)
+    }
+
+    getStructuredType(name: string): StructuredType | undefined {
+        return this.allStructuredTypes.get(name)
+    }
+
+    getMessageGroup(name: string): MessageGroup | undefined {
+        return this.allMessageGroups.get(name)
+    }
+}

package/src/validators/generic/schema/index.ts

@@ -1,2 +1 @@
-export * from "./ValidationTypes.js"
-export * from "./DefinitionSchema.js"
+export * from "./SyntaxDefinition.js"

package/src/validators/index.ts

@@ -4,5 +4,5 @@ export * from "./LionWebReferenceValidator.js"
 export * from "./LionWebLanguageValidator.js"
 export * from "./LionWebLanguageReferenceValidator.js"
 export * from "./LionWebValidator.js"
+export * from "./definitions/index.js"
 export * from "./ValidationFunctions.js"
-export * from "./LionWebChunkDefinitions.js"

package/dist/validators/LionWebChunkDefinitions.d.ts

@@ -1,9 +0,0 @@
-import { DefinitionSchema } from "./generic/index.js";
-/**
- * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
- * It can
- *   - be used by the SyntaxValidator to validate an object sat runtime.
- *   - used to generate all the TypeScript types for a LionWebChunk.
- */
-export declare const LionWebSchema: DefinitionSchema;
-//# sourceMappingURL=LionWebChunkDefinitions.d.ts.map

package/dist/validators/LionWebChunkDefinitions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LionWebChunkDefinitions.d.ts","sourceRoot":"","sources":["../../src/validators/LionWebChunkDefinitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAA2C,MAAM,oBAAoB,CAAA;AAG9F;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,gBA0F1B,CAAA"}

package/dist/validators/LionWebChunkDefinitions.js

@@ -1,100 +0,0 @@
-import { DefinitionSchema, MAY_BE_NULL, PropertyDef, PrimitiveDef } from "./generic/index.js";
-import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js";
-/**
- * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
- * It can
- *   - be used by the SyntaxValidator to validate an object sat runtime.
- *   - used to generate all the TypeScript types for a LionWebChunk.
- */
-export const LionWebSchema = new DefinitionSchema([
-    {
-        name: "LionWebJsonMetaPointer",
-        properties: [
-            PropertyDef({ name: "key", type: "LionWebKey" }),
-            PropertyDef({ name: "version", type: "LionWebVersion" }),
-            PropertyDef({ name: "language", type: "LionWebKey" })
-        ]
-    },
-    {
-        name: "LionWebJsonMetaPointer",
-        properties: [
-            PropertyDef({ name: "key", type: "LionWebKey" }),
-            PropertyDef({ name: "version", type: "LionWebVersion" }),
-            PropertyDef({ name: "language", type: "LionWebKey" }),
-        ]
-    },
-    {
-        name: "ResponseMessage",
-        properties: [
-            PropertyDef({ name: "kind", type: "JSstring" }),
-            PropertyDef({ name: "message", type: "JSstring" }),
-            PropertyDef({ name: "data", type: "JSobject", mayBeNull: true, isOptional: true })
-        ]
-    },
-    {
-        name: "LionWebJsonChunk",
-        properties: [
-            PropertyDef({ name: "serializationFormatVersion", type: "LionWebSerializationFormatVersion" }),
-            PropertyDef({ name: "languages", type: "LionWebJsonUsedLanguage", isList: true }),
-            PropertyDef({ name: "nodes", type: "LionWebJsonNode", isList: true })
-        ]
-    },
-    {
-        name: "LionWebJsonUsedLanguage",
-        properties: [
-            PropertyDef({ name: "key", type: "LionWebKey" }),
-            PropertyDef({ name: "version", type: "LionWebVersion" })
-        ]
-    },
-    {
-        name: "LionWebJsonNode",
-        properties: [
-            PropertyDef({ name: "id", type: "LionWebId" }),
-            PropertyDef({ name: "classifier", type: "LionWebJsonMetaPointer" }),
-            PropertyDef({ name: "properties", type: "LionWebJsonProperty", isList: true }),
-            PropertyDef({ name: "containments", type: "LionWebJsonContainment", isList: true }),
-            PropertyDef({ name: "references", type: "LionWebJsonReference", isList: true }),
-            PropertyDef({ name: "annotations", type: "LionWebId", isList: true }),
-            PropertyDef({ name: "parent", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
-        ]
-    },
-    {
-        name: "LionWebJsonProperty",
-        properties: [
-            PropertyDef({ name: "property", type: "LionWebJsonMetaPointer" }),
-            PropertyDef({ name: "value", type: "JSstring", mayBeNull: MAY_BE_NULL }),
-        ]
-    },
-    {
-        name: "LionWebJsonContainment",
-        properties: [
-            PropertyDef({ name: "containment", type: "LionWebJsonMetaPointer" }),
-            PropertyDef({ name: "children", type: "LionWebId", isList: true }),
-        ]
-    },
-    {
-        name: "LionWebJsonReference",
-        properties: [
-            PropertyDef({ name: "reference", type: "LionWebJsonMetaPointer" }),
-            PropertyDef({ name: "targets", type: "LionWebJsonReferenceTarget", isList: true }),
-        ]
-    },
-    {
-        name: "LionWebJsonReferenceTarget",
-        properties: [
-            PropertyDef({ name: "resolveInfo", type: "JSstring", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ name: "reference", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
-        ]
-    },
-    /**
-     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
-     * and the (optional) validate function.
-     */
-    PrimitiveDef({ name: "LionWebId", primitiveType: "string", validate: validateId }),
-    PrimitiveDef({ name: "LionWebKey", primitiveType: "string", validate: validateKey }),
-    PrimitiveDef({ name: "LionWebVersion", primitiveType: "string", validate: validateVersion }),
-    PrimitiveDef({ name: "LionWebSerializationFormatVersion", primitiveType: "string", validate: validateSerializationFormatVersion }),
-    PrimitiveDef({ name: "JSstring", primitiveType: "string" }),
-    PrimitiveDef({ name: "JSobject", primitiveType: "object" }),
-]);
-//# sourceMappingURL=LionWebChunkDefinitions.js.map