@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/TypeFactory.js

@@ -1,17 +1,23 @@
 import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { fromRdf } from "rdf-literal";
+import { LiteralDecoder, literalDatatypeDefinitions } from "rdfjs-resource";
 import { invariant } from "ts-invariant";
-import { Scope } from "ts-morph";
 import { logger } from "../../logger.js";
+import { BigDecimalType } from "./BigDecimalType.js";
+import { BigIntType } from "./BigIntType.js";
+import { BlankNodeType } from "./BlankNodeType.js";
 import { BooleanType } from "./BooleanType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { DateType } from "./DateType.js";
+import { DefaultValueType } from "./DefaultValueType.js";
 import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IntType } from "./IntType.js";
+import { IriType } from "./IriType.js";
+import { LazyObjectOptionType } from "./LazyObjectOptionType.js";
+import { LazyObjectSetType } from "./LazyObjectSetType.js";
+import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
 import { ObjectType } from "./ObjectType.js";
@@ -19,90 +25,26 @@ import { ObjectUnionType } from "./ObjectUnionType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
-import { TermType } from "./TermType.js";
-import { UnionType } from "./UnionType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { TermType } from "./TermType.js";
+import { code } from "./ts-poet-wrapper.js";
 import { tsName } from "./tsName.js";
+import { UnionType } from "./UnionType.js";
 export class TypeFactory {
-    cachedBooleanType = new BooleanType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    cachedDateType = new DateType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    cachedDateTimeType = new DateTimeType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    cachedFloatType = new FloatType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    cachedIdentifierType = new IdentifierType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        nodeKinds: new Set(["BlankNode", "NamedNode"]),
-    });
-    cachedIntType = new IntType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    cachedNamedIdentifierType = new IdentifierType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        nodeKinds: new Set(["NamedNode"]),
-    });
-    cachedObjectTypePropertiesByIdentifier = new TermMap();
-    cachedObjectTypesByIdentifier = new TermMap();
-    cachedObjectUnionTypesByIdentifier = new TermMap();
-    cachedStringType = new StringType({
-        defaultValue: Maybe.empty(),
-        hasValues: [],
-        in_: [],
-        languageIn: [],
-        primitiveDefaultValue: Maybe.empty(),
-        primitiveIn: [],
-    });
-    createObjectTypeFromAstType(astType) {
+    cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
+    cachedObjectTypesByShapeIdentifier = new TermMap();
+    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
+    createObjectType(astType) {
         {
-            const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
+            const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
             if (cachedObjectType) {
                 return cachedObjectType;
             }
         }
-        const identifierType = new IdentifierType({
-            defaultValue: Maybe.empty(),
-            hasValues: [],
-            in_: astType.identifierIn,
-            nodeKinds: astType.identifierNodeKinds,
-        });
+        const identifierType = this.createIdentifierType(astType.identifierType);
         const staticModuleName = astType.childObjectTypes.length > 0
-            ? `${tsName(astType.name)}Static`
-            : tsName(astType.name);
+            ? `${tsName(astType)}Static`
+            : tsName(astType);
         const objectType = new ObjectType({
             abstract: astType.abstract,
             comment: astType.comment,
@@ -111,12 +53,13 @@ export class TypeFactory {
             extern: astType.extern,
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
+            identifierType,
             imports: astType.tsImports,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
+            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyProperties: (objectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
@@ -126,35 +69,32 @@ export class TypeFactory {
                     if (left.order > right.order) {
                         return 1;
                     }
-                    return tsName(left.name).localeCompare(tsName(right.name));
+                    return tsName(left).localeCompare(tsName(right));
                 })
-                    .map((astProperty) => this.createObjectTypePropertyFromAstProperty({
+                    .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
                     objectType,
                 }));
-                // Type discriminator property
-                const typeDiscriminatorOwnValue = !astType.abstract
-                    ? objectType.discriminatorValue
+                // Type discriminant property
+                const typeDiscriminantOwnValue = !astType.abstract
+                    ? objectType.discriminantValue
                     : undefined;
-                const typeDiscriminatorDescendantValues = new Set();
+                const typeDiscriminantDescendantValues = new Set();
                 for (const descendantObjectType of objectType.descendantObjectTypes) {
                     if (!descendantObjectType.abstract) {
-                        typeDiscriminatorDescendantValues.add(descendantObjectType.discriminatorValue);
+                        typeDiscriminantDescendantValues.add(descendantObjectType.discriminantValue);
                     }
                 }
-                if (typeDiscriminatorOwnValue ||
-                    typeDiscriminatorDescendantValues.size > 0) {
-                    properties.splice(0, 0, new ObjectType.TypeDiscriminatorProperty({
-                        abstract: astType.abstract,
+                if (typeDiscriminantOwnValue ||
+                    typeDiscriminantDescendantValues.size > 0) {
+                    properties.splice(0, 0, new ObjectType.TypeDiscriminantProperty({
                         name: `${syntheticNamePrefix}type`,
-                        initializer: objectType.discriminatorValue,
                         objectType,
-                        override: objectType.parentObjectTypes.length > 0,
-                        type: new ObjectType.TypeDiscriminatorProperty.Type({
-                            descendantValues: [...typeDiscriminatorDescendantValues].sort(),
+                        type: new ObjectType.TypeDiscriminantProperty.Type({
+                            descendantValues: [...typeDiscriminantDescendantValues].sort(),
                             mutable: false,
-                            ownValues: typeDiscriminatorOwnValue
-                                ? [typeDiscriminatorOwnValue]
+                            ownValues: typeDiscriminantOwnValue
+                                ? [typeDiscriminantOwnValue]
                                 : [],
                         }),
                         visibility: "public",
@@ -163,345 +103,350 @@ export class TypeFactory {
                 // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
                 if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
                     properties.splice(0, 0, new ObjectType.IdentifierPrefixProperty({
-                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
                         name: `${syntheticNamePrefix}identifierPrefix`,
                         objectType,
-                        type: this.cachedStringType,
+                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
+                        type: new StringType({
+                            comment: astType.comment,
+                            datatype: xsd.string,
+                            hasValues: [],
+                            in_: [],
+                            label: astType.label,
+                            languageIn: [],
+                            primitiveIn: [],
+                        }),
                         visibility: "protected",
                     }));
                 }
                 // Every ObjectType has an identifier property. Some are abstract.
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
-                    abstract: astType.abstract,
-                    getAccessorScope: (() => {
-                        if (astType.abstract) {
-                            return Maybe.empty();
-                        }
-                        if (astType.identifierMintingStrategy.isJust() ||
-                            astType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierMintingStrategy.isJust())) {
-                            return Maybe.of(Scope.Public);
-                        }
-                        return Maybe.empty();
-                    })(),
                     identifierMintingStrategy: astType.identifierMintingStrategy,
                     identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
                     name: `${syntheticNamePrefix}identifier`,
                     objectType,
-                    override: astType.parentObjectTypes.length > 0,
-                    propertyDeclarationVisibility: (() => {
-                        if (astType.abstract) {
-                            // If the type is abstract, don't declare an identifier property.
-                            return Maybe.empty();
-                        }
-                        if (astType.ancestorObjectTypes.some((ancestorObjectType) => !ancestorObjectType.abstract)) {
-                            // If the type has a non-abstract ancestor, that ancestor will declare the identifier property.
-                            return Maybe.empty();
-                        }
-                        if (astType.descendantObjectTypes.some((descendantObjectType) => !descendantObjectType.abstract)) {
-                            // If the type has a non-abstract descendant, declare the identifier property for it.
-                            return Maybe.of("protected");
-                        }
-                        return Maybe.of("private");
-                    })(),
                     type: identifierType,
-                    typeAlias: `${staticModuleName}.${syntheticNamePrefix}Identifier`,
+                    typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
                     visibility: "public",
                 }));
                 return properties;
             },
             identifierMintingStrategy: astType.identifierMintingStrategy,
-            name: tsName(astType.name),
+            name: tsName(astType),
             staticModuleName,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
+        this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
         return objectType;
     }
-    createTypeFromAstType(astType) {
+    createObjectUnionType(astType) {
+        {
+            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedObjectUnionType) {
+                return cachedObjectUnionType;
+            }
+        }
+        const objectUnionType = new ObjectUnionType({
+            comment: astType.comment,
+            export_: astType.export,
+            features: astType.tsFeatures,
+            identifierType: this.createIdentifierType(astType.identifierType),
+            label: astType.label,
+            memberTypes: astType.memberObjectTypes.map((objectType) => this.createObjectType(objectType)),
+            name: tsName(astType),
+        });
+        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
+        return objectUnionType;
+    }
+    createType(astType, parameters) {
         switch (astType.kind) {
+            case "BlankNodeType":
+                return this.createBlankNodeType(astType);
+            case "DefaultValueType":
+                return this.createDefaultValueType(astType);
             case "IdentifierType":
-                if (astType.defaultValue.isNothing() &&
-                    astType.hasValues.length === 0 &&
-                    astType.in_.length === 0) {
-                    if (astType.nodeKinds.size === 2) {
-                        return this.cachedIdentifierType;
-                    }
-                    if (astType.nodeKinds.size === 1 &&
-                        astType.nodeKinds.has("NamedNode")) {
-                        return this.cachedNamedIdentifierType;
-                    }
-                }
-                return new IdentifierType({
-                    defaultValue: astType.defaultValue,
-                    hasValues: astType.hasValues,
-                    in_: astType.in_.filter((_) => _.termType === "NamedNode"),
-                    nodeKinds: astType.nodeKinds,
-                });
+                return this.createIdentifierType(astType);
             case "IntersectionType":
                 throw new Error("not implemented");
-            case "ListType": {
-                return new ListType({
-                    identifierNodeKind: astType.identifierNodeKind,
-                    itemType: this.createTypeFromAstType(astType.itemType),
-                    mutable: astType.mutable.orDefault(false),
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    toRdfTypes: astType.toRdfTypes,
-                });
-            }
-            case "LiteralType": {
-                // Look at sh:datatype as well as sh:defaultValue/sh:hasValue/sh:in term datatypes
-                // If there's one common datatype than we can refine the type
-                // Otherwise default to rdfjs.Literal
-                const datatypes = new TermSet();
-                astType.datatype.ifJust((datatype) => datatypes.add(datatype));
-                astType.defaultValue.ifJust((defaultValue) => datatypes.add(defaultValue.datatype));
-                for (const hasValue of astType.hasValues) {
-                    datatypes.add(hasValue.datatype);
-                }
-                for (const value of astType.in_) {
-                    datatypes.add(value.datatype);
-                }
-                if (datatypes.size === 1) {
-                    const datatype = [...datatypes][0];
-                    if (datatype.equals(xsd.boolean)) {
-                        if (astType.defaultValue.isNothing() &&
-                            astType.hasValues.length === 0 &&
-                            astType.in_.length === 0) {
-                            return this.cachedBooleanType;
-                        }
-                        return new BooleanType({
-                            defaultValue: astType.defaultValue,
-                            hasValues: astType.hasValues,
-                            languageIn: [],
-                            in_: astType.in_,
-                            primitiveDefaultValue: astType.defaultValue
-                                .map((value) => fromRdf(value, true))
-                                .filter((value) => typeof value === "boolean"),
-                            primitiveIn: astType.in_
-                                .map((value) => fromRdf(value, true))
-                                .filter((value) => typeof value === "boolean"),
-                        });
-                    }
-                    if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
-                        if (astType.defaultValue.isNothing() &&
-                            astType.hasValues.length === 0 &&
-                            astType.in_.length === 0) {
-                            return datatype.equals(xsd.date)
-                                ? this.cachedDateType
-                                : this.cachedDateTimeType;
-                        }
-                        return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
-                            defaultValue: astType.defaultValue,
-                            hasValues: astType.hasValues,
-                            in_: astType.in_,
-                            languageIn: [],
-                            primitiveDefaultValue: astType.defaultValue
-                                .map((value) => fromRdf(value, true))
-                                .filter((value) => typeof value === "object" && value instanceof Date),
-                            primitiveIn: astType.in_
-                                .map((value) => fromRdf(value, true))
-                                .filter((value) => typeof value === "object" && value instanceof Date),
-                        });
-                    }
-                    for (const [floatOrInt, numberDatatypes_] of Object.entries(numberDatatypes)) {
-                        for (const numberDatatype of numberDatatypes_) {
-                            if (datatype.equals(numberDatatype)) {
-                                if (astType.defaultValue.isNothing() &&
-                                    astType.hasValues.length === 0 &&
-                                    astType.in_.length === 0) {
-                                    return floatOrInt === "float"
-                                        ? this.cachedFloatType
-                                        : this.cachedIntType;
-                                }
-                                return new (floatOrInt === "float" ? FloatType : IntType)({
-                                    defaultValue: astType.defaultValue,
-                                    hasValues: astType.hasValues,
-                                    in_: astType.in_,
-                                    languageIn: [],
-                                    primitiveDefaultValue: astType.defaultValue
-                                        .map((value) => fromRdf(value, true))
-                                        .filter((value) => typeof value === "number"),
-                                    primitiveIn: astType.in_
-                                        .map((value) => fromRdf(value, true))
-                                        .filter((value) => typeof value === "number"),
-                                });
-                            }
-                        }
-                    }
-                    if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
-                        if (astType.defaultValue.isNothing() &&
-                            astType.hasValues.length === 0 &&
-                            astType.in_.length === 0 &&
-                            astType.languageIn.length === 0) {
-                            return this.cachedStringType;
-                        }
-                        return new StringType({
-                            defaultValue: astType.defaultValue,
-                            hasValues: astType.hasValues,
-                            languageIn: astType.languageIn,
-                            in_: astType.in_,
-                            primitiveDefaultValue: astType.defaultValue.map((value) => value.value),
-                            primitiveIn: astType.in_.map((value) => value.value),
-                        });
-                    }
-                    if (datatype.equals(rdf.langString)) {
-                        // Drop down
-                    }
-                    else {
-                        logger.warn("unrecognized literal datatype: %s", datatype.value);
-                    }
-                }
-                else if (datatypes.size > 0) {
-                    logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
-                }
-                else {
-                    logger.debug("literal type has no datatypes");
-                }
-                return new LiteralType({
-                    defaultValue: astType.defaultValue,
-                    hasValues: astType.hasValues,
-                    in_: astType.in_,
-                    languageIn: astType.languageIn,
-                });
-            }
+            case "IriType":
+                return this.createIriType(astType);
+            case "LazyObjectOptionType":
+                return this.createLazyObjectOptionType(astType);
+            case "LazyObjectSetType":
+                return this.createLazyObjectSetType(astType);
+            case "LazyObjectType":
+                return this.createLazyObjectType(astType);
+            case "ListType":
+                return this.createListType(astType);
+            case "LiteralType":
+                return this.createLiteralType(astType, parameters);
             case "ObjectIntersectionType":
                 throw new Error("not implemented");
             case "ObjectType":
-                return this.createObjectTypeFromAstType(astType);
+                return this.createObjectType(astType);
             case "ObjectUnionType":
-                return this.createObjectUnionTypeFromAstType(astType);
+                return this.createObjectUnionType(astType);
             case "OptionType":
-                return new OptionType({
-                    itemType: this.createTypeFromAstType(astType.itemType),
-                });
+                return this.createOptionType(astType);
             case "PlaceholderType":
                 throw new Error(astType.kind);
             case "SetType":
-                return new SetType({
-                    itemType: this.createTypeFromAstType(astType.itemType),
-                    mutable: astType.mutable.orDefault(false),
-                    minCount: astType.minCount,
-                });
+                return this.createSetType(astType);
             case "TermType":
-                return new TermType({
-                    defaultValue: astType["defaultValue"],
-                    hasValues: astType["hasValues"],
-                    in_: astType["in_"],
-                    nodeKinds: astType["nodeKinds"],
-                });
+                return this.createTermType(astType);
             case "UnionType":
-                return new UnionType({
-                    memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
+                return this.createUnionType(astType);
+        }
+    }
+    createBlankNodeType(astType) {
+        return new BlankNodeType({
+            comment: astType.comment,
+            label: astType.label,
+        });
+    }
+    createDefaultValueType(astType) {
+        const itemType = this.createType(astType.itemType, {
+            defaultValue: astType.defaultValue,
+        });
+        invariant(DefaultValueType.isItemType(itemType));
+        return new DefaultValueType({
+            comment: astType.comment,
+            defaultValue: astType.defaultValue,
+            itemType,
+            label: astType.label,
+        });
+    }
+    createIdentifierType(astType) {
+        switch (astType.kind) {
+            case "BlankNodeType":
+                return this.createBlankNodeType(astType);
+            case "IdentifierType":
+                return new IdentifierType({
+                    comment: astType.comment,
+                    label: astType.label,
                 });
+            case "IriType":
+                return this.createIriType(astType);
         }
     }
-    createObjectTypePropertyFromAstProperty({ astObjectTypeProperty, objectType, }) {
-        {
-            const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
-            if (cachedProperty) {
-                return cachedProperty;
+    createIriType(astType) {
+        return new IriType({
+            comment: astType.comment,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+        });
+    }
+    createLazyObjectOptionType(astType) {
+        return new LazyObjectOptionType({
+            comment: astType.comment,
+            label: astType.label,
+            partialType: this.createOptionType(astType.partialType),
+            resolveType: this.createOptionType(astType.resolveType),
+        });
+    }
+    createLazyObjectSetType(astType) {
+        return new LazyObjectSetType({
+            comment: astType.comment,
+            label: astType.label,
+            partialType: this.createSetType(astType.partialType),
+            resolveType: this.createSetType(astType.resolveType),
+        });
+    }
+    createLazyObjectType(astType) {
+        return new LazyObjectType({
+            comment: astType.comment,
+            label: astType.label,
+            partialType: this.createType(astType.partialType),
+            resolveType: this.createType(astType.resolveType),
+        });
+    }
+    createListType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(ListType.isItemType(itemType));
+        return new ListType({
+            comment: astType.comment,
+            identifierNodeKind: astType.identifierNodeKind,
+            itemType,
+            label: astType.label,
+            minCount: 0,
+            mutable: astType.mutable,
+            identifierMintingStrategy: astType.identifierMintingStrategy,
+            toRdfTypes: astType.toRdfTypes,
+        });
+    }
+    createLiteralType(astType, parameters) {
+        // Look at sh:datatype as well as sh:defaultValue, sh:hasValue, and sh:in datatypes
+        // If there's one common datatype than we can refine the type
+        // Otherwise default to rdfjs.Literal
+        const datatypes = new TermSet();
+        astType.datatype.ifJust((datatype) => datatypes.add(datatype));
+        if (datatypes.size === 0) {
+            if (parameters?.defaultValue &&
+                parameters.defaultValue.termType === "Literal") {
+                datatypes.add(parameters.defaultValue.datatype);
             }
-        }
-        let property;
-        const name = tsName(astObjectTypeProperty.name);
-        if (astObjectTypeProperty.stubType.isJust()) {
-            const resolvedType = this.createTypeFromAstType(astObjectTypeProperty.type);
-            let lazyType;
-            const stubType = this.createTypeFromAstType(astObjectTypeProperty.stubType.unsafeCoerce());
-            if (resolvedType instanceof OptionType) {
-                invariant(resolvedType.itemType instanceof ObjectType ||
-                    resolvedType.itemType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind} ${resolvedType.itemType.kind} items`);
-                invariant(stubType instanceof OptionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
-                lazyType = new ObjectType.LazyShaclProperty.OptionalObjectType({
-                    resolvedType,
-                    stubType,
-                });
+            for (const hasValue of astType.hasValues) {
+                datatypes.add(hasValue.datatype);
             }
-            else if (resolvedType instanceof ObjectType ||
-                resolvedType instanceof ObjectUnionType) {
-                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
-                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
-                    resolvedType: resolvedType,
-                    stubType: stubType,
-                });
+            for (const value of astType.in_) {
+                datatypes.add(value.datatype);
             }
-            else if (resolvedType instanceof SetType) {
-                invariant(resolvedType.itemType instanceof ObjectType ||
-                    resolvedType.itemType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind} ${resolvedType.itemType.kind} items`);
-                invariant(stubType instanceof SetType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
-                lazyType = new ObjectType.LazyShaclProperty.ObjectSetType({
-                    resolvedType,
-                    stubType,
-                });
+        }
+        if (datatypes.size === 1) {
+            const datatype = [...datatypes][0];
+            const datatypeDefinition = literalDatatypeDefinitions[datatype.value];
+            if (datatypeDefinition) {
+                switch (datatypeDefinition.kind) {
+                    case "bigdecimal":
+                        return new BigDecimalType({
+                            comment: astType.comment,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                        });
+                    case "bigint":
+                        return new BigIntType({
+                            comment: astType.comment,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
+                        });
+                    case "boolean":
+                        return new BooleanType({
+                            comment: astType.comment,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            label: astType.label,
+                            languageIn: [],
+                            in_: astType.in_,
+                            primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
+                        });
+                    case "date":
+                    case "datetime":
+                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
+                            comment: astType.comment,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
+                                ? LiteralDecoder.decodeDateLiteral
+                                : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
+                        });
+                    case "float":
+                    case "int":
+                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
+                            comment: astType.comment,
+                            datatype,
+                            hasValues: astType.hasValues,
+                            in_: astType.in_,
+                            label: astType.label,
+                            languageIn: [],
+                            primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
+                                ? LiteralDecoder.decodeFloatLiteral
+                                : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
+                        });
+                    case "string":
+                        if (!datatype.equals(rdf.langString)) {
+                            return new StringType({
+                                comment: astType.comment,
+                                datatype,
+                                hasValues: astType.hasValues,
+                                label: astType.label,
+                                languageIn: astType.languageIn,
+                                in_: astType.in_,
+                                primitiveIn: astType.in_.map((value) => value.value),
+                            });
+                        }
+                        break;
+                }
+            }
+            if (datatype.equals(rdf.langString)) {
+                // Drop down
             }
             else {
-                throw new Error(`lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
+                logger.warn("unrecognized literal datatype: %s", datatype.value);
             }
-            property = new ObjectType.LazyShaclProperty({
-                comment: astObjectTypeProperty.comment,
-                description: astObjectTypeProperty.description,
-                label: astObjectTypeProperty.label,
-                objectType,
-                name,
-                path: astObjectTypeProperty.path.iri,
-                type: lazyType,
-                visibility: astObjectTypeProperty.visibility,
-            });
+        }
+        else if (datatypes.size > 0) {
+            logger.warn("literal type has multiple datatypes: %s", JSON.stringify([...datatypes].map((datatype) => datatype.value)));
         }
         else {
-            property = new ObjectType.EagerShaclProperty({
-                comment: astObjectTypeProperty.comment,
-                description: astObjectTypeProperty.description,
-                label: astObjectTypeProperty.label,
-                mutable: astObjectTypeProperty.mutable.orDefault(false),
-                objectType,
-                name,
-                path: astObjectTypeProperty.path.iri,
-                recursive: !!astObjectTypeProperty.recursive,
-                type: this.createTypeFromAstType(astObjectTypeProperty.type),
-                visibility: astObjectTypeProperty.visibility,
-            });
+            logger.debug("literal type has no datatypes");
         }
-        this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
-        return property;
+        return new LiteralType({
+            comment: astType.comment,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+            languageIn: astType.languageIn,
+        });
     }
-    createObjectUnionTypeFromAstType(astType) {
+    createObjectTypeProperty({ astObjectTypeProperty, objectType, }) {
         {
-            const cachedObjectUnionType = this.cachedObjectUnionTypesByIdentifier.get(astType.name.identifier);
-            if (cachedObjectUnionType) {
-                return cachedObjectUnionType;
-            }
-        }
-        const memberTypes = astType.memberTypes
-            .map((astType) => this.createTypeFromAstType(astType))
-            .filter((memberType) => memberType instanceof ObjectType);
-        const memberIdentifierTypeNodeKinds = new Set();
-        const memberIdentifierTypesIn = new TermSet();
-        for (const memberType of memberTypes) {
-            for (const nodeKind of memberType.identifierType.nodeKinds) {
-                memberIdentifierTypeNodeKinds.add(nodeKind);
-            }
-            for (const in_ of memberType.identifierType.in_) {
-                memberIdentifierTypesIn.add(in_);
+            const cachedProperty = this.cachedObjectTypePropertiesByShapeIdentifier.get(astObjectTypeProperty.shapeIdentifier);
+            if (cachedProperty) {
+                return cachedProperty;
             }
         }
-        const objectUnionType = new ObjectUnionType({
+        const name = tsName(astObjectTypeProperty);
+        const property = new ObjectType.ShaclProperty({
+            comment: astObjectTypeProperty.comment,
+            description: astObjectTypeProperty.description,
+            label: astObjectTypeProperty.label,
+            mutable: astObjectTypeProperty.mutable,
+            objectType,
+            name,
+            path: astObjectTypeProperty.path,
+            recursive: !!astObjectTypeProperty.recursive,
+            type: this.createType(astObjectTypeProperty.type),
+            visibility: astObjectTypeProperty.visibility,
+        });
+        this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
+        return property;
+    }
+    createOptionType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(OptionType.isItemType(itemType));
+        return new OptionType({
             comment: astType.comment,
-            export_: astType.export,
-            features: astType.tsFeatures,
-            identifierType: new IdentifierType({
-                defaultValue: Maybe.empty(),
-                hasValues: [],
-                in_: [...memberIdentifierTypesIn],
-                nodeKinds: memberIdentifierTypeNodeKinds,
-            }),
+            itemType,
             label: astType.label,
-            memberTypes,
-            name: tsName(astType.name),
         });
-        this.cachedObjectUnionTypesByIdentifier.set(astType.name.identifier, objectUnionType);
-        return objectUnionType;
+    }
+    createSetType(astType) {
+        const itemType = this.createType(astType.itemType);
+        invariant(SetType.isItemType(itemType));
+        return new SetType({
+            comment: astType.comment,
+            itemType,
+            label: astType.label,
+            mutable: astType.mutable,
+            minCount: astType.minCount,
+        });
+    }
+    createTermType(astType) {
+        return new TermType({
+            comment: astType.comment,
+            hasValues: astType.hasValues,
+            in_: astType.in_,
+            label: astType.label,
+            nodeKinds: astType.nodeKinds,
+        });
+    }
+    createUnionType(astType) {
+        return new UnionType({
+            comment: astType.comment,
+            label: astType.label,
+            memberDiscriminantValues: astType.memberDiscriminantValues,
+            memberTypes: astType.memberTypes.map((astType) => this.createType(astType)),
+        });
     }
 }
 function objectTypeNeedsIdentifierPrefixProperty(objectType) {
@@ -513,26 +458,11 @@ function objectTypeNeedsIdentifierPrefixProperty(objectType) {
             case "sha256":
             case "uuidv4":
                 return true;
+            default:
+                identifierMintingStrategy;
+                throw new RangeError(identifierMintingStrategy);
         }
     })
         .orDefault(false);
 }
-const numberDatatypes = {
-    float: [xsd.decimal, xsd.double, xsd.float],
-    int: [
-        xsd.byte,
-        xsd.int,
-        xsd.integer,
-        xsd.long,
-        xsd.negativeInteger,
-        xsd.nonNegativeInteger,
-        xsd.nonPositiveInteger,
-        xsd.positiveInteger,
-        xsd.short,
-        xsd.unsignedByte,
-        xsd.unsignedInt,
-        xsd.unsignedLong,
-        xsd.unsignedShort,
-    ],
-};
 //# sourceMappingURL=TypeFactory.js.map