@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/TypeFactory.js

@@ -3,14 +3,17 @@ 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 { invariant } from "ts-invariant";
+import { Scope } from "ts-morph";
 import { logger } from "../../logger.js";
 import { BooleanType } from "./BooleanType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { DateType } from "./DateType.js";
+import { FloatType } from "./FloatType.js";
 import { IdentifierType } from "./IdentifierType.js";
+import { IntType } from "./IntType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
-import { NumberType } from "./NumberType.js";
 import { ObjectType } from "./ObjectType.js";
 import { ObjectUnionType } from "./ObjectUnionType.js";
 import { OptionType } from "./OptionType.js";
@@ -18,42 +21,163 @@ 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 { tsName } from "./tsName.js";
-function objectTypeNeedsIdentifierPrefixProperty(objectType) {
-    return objectType.identifierMintingStrategy
-        .map((identifierMintingStrategy) => {
-        switch (identifierMintingStrategy) {
-            case "blankNode":
-                return false;
-            case "sha256":
-            case "uuidv4":
-                return true;
-        }
-    })
-        .orDefault(false);
-}
 export class TypeFactory {
     cachedObjectTypePropertiesByIdentifier = new TermMap();
     cachedObjectTypesByIdentifier = new TermMap();
-    dataFactoryVariable;
-    constructor({ dataFactoryVariable }) {
-        this.dataFactoryVariable = dataFactoryVariable;
+    cachedObjectUnionTypesByIdentifier = new TermMap();
+    createObjectTypeFromAstType(astType) {
+        {
+            const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
+            if (cachedObjectType) {
+                return cachedObjectType;
+            }
+        }
+        const identifierType = new IdentifierType({
+            defaultValue: Maybe.empty(),
+            hasValues: [],
+            in_: astType.identifierIn,
+            nodeKinds: astType.identifierNodeKinds,
+        });
+        const staticModuleName = astType.childObjectTypes.length > 0
+            ? `${tsName(astType.name)}Static`
+            : tsName(astType.name);
+        const objectType = new ObjectType({
+            abstract: astType.abstract,
+            comment: astType.comment,
+            declarationType: astType.tsObjectDeclarationType,
+            export_: astType.export,
+            extern: astType.extern,
+            features: astType.tsFeatures,
+            fromRdfType: astType.fromRdfType,
+            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)),
+            lazyProperties: (objectType) => {
+                const properties = astType.properties
+                    .toSorted((left, right) => {
+                    if (left.order < right.order) {
+                        return -1;
+                    }
+                    if (left.order > right.order) {
+                        return 1;
+                    }
+                    return tsName(left.name).localeCompare(tsName(right.name));
+                })
+                    .map((astProperty) => this.createObjectTypePropertyFromAstProperty({
+                    astObjectTypeProperty: astProperty,
+                    objectType,
+                }));
+                // Type discriminator property
+                const typeDiscriminatorOwnValue = !astType.abstract
+                    ? objectType.discriminatorValue
+                    : undefined;
+                const typeDiscriminatorDescendantValues = new Set();
+                for (const descendantObjectType of objectType.descendantObjectTypes) {
+                    if (!descendantObjectType.abstract) {
+                        typeDiscriminatorDescendantValues.add(descendantObjectType.discriminatorValue);
+                    }
+                }
+                if (typeDiscriminatorOwnValue ||
+                    typeDiscriminatorDescendantValues.size > 0) {
+                    properties.splice(0, 0, new ObjectType.TypeDiscriminatorProperty({
+                        abstract: astType.abstract,
+                        name: `${syntheticNamePrefix}type`,
+                        initializer: objectType.discriminatorValue,
+                        objectType,
+                        override: objectType.parentObjectTypes.length > 0,
+                        type: new ObjectType.TypeDiscriminatorProperty.Type({
+                            descendantValues: [...typeDiscriminatorDescendantValues].sort(),
+                            mutable: false,
+                            ownValues: typeDiscriminatorOwnValue
+                                ? [typeDiscriminatorOwnValue]
+                                : [],
+                        }),
+                        visibility: "public",
+                    }));
+                }
+                // 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: new StringType({
+                            defaultValue: Maybe.empty(),
+                            hasValues: [],
+                            in_: [],
+                            languageIn: [],
+                            primitiveDefaultValue: Maybe.empty(),
+                            primitiveIn: [],
+                        }),
+                        visibility: "protected",
+                    }));
+                }
+                // Every ObjectType has an identifier property. Some are abstract.
+                properties.splice(0, 0, new ObjectType.IdentifierProperty({
+                    abstract: astType.abstract,
+                    classGetAccessorScope: (() => {
+                        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();
+                    })(),
+                    classPropertyDeclarationVisibility: (() => {
+                        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");
+                    })(),
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
+                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                    name: `${syntheticNamePrefix}identifier`,
+                    objectType,
+                    override: astType.parentObjectTypes.length > 0,
+                    type: identifierType,
+                    typeAlias: `${staticModuleName}.${syntheticNamePrefix}Identifier`,
+                    visibility: "public",
+                }));
+                return properties;
+            },
+            identifierMintingStrategy: astType.identifierMintingStrategy,
+            name: tsName(astType.name),
+            staticModuleName,
+            synthetic: astType.synthetic,
+            toRdfTypes: astType.toRdfTypes,
+        });
+        this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
+        return objectType;
     }
     createTypeFromAstType(astType) {
         switch (astType.kind) {
             case "IdentifierType":
                 return new IdentifierType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
                     hasValues: astType.hasValues,
-                    in_: astType.in_,
+                    in_: astType.in_.filter((_) => _.termType === "NamedNode"),
                     nodeKinds: astType.nodeKinds,
                 });
             case "IntersectionType":
                 throw new Error("not implemented");
             case "ListType": {
                 return new ListType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     identifierNodeKind: astType.identifierNodeKind,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     mutable: astType.mutable.orDefault(false),
@@ -78,7 +202,6 @@ export class TypeFactory {
                     const datatype = [...datatypes][0];
                     if (datatype.equals(xsd.boolean)) {
                         return new BooleanType({
-                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
                             languageIn: [],
@@ -93,7 +216,6 @@ export class TypeFactory {
                     }
                     if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
                         return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
-                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
                             in_: astType.in_,
@@ -106,45 +228,26 @@ export class TypeFactory {
                                 .filter((value) => typeof value === "object" && value instanceof Date),
                         });
                     }
-                    for (const numberDatatype of [
-                        // Integers
-                        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,
-                        // Floating point
-                        xsd.decimal,
-                        xsd.double,
-                        xsd.float,
-                    ]) {
-                        if (datatype.equals(numberDatatype)) {
-                            return new NumberType({
-                                dataFactoryVariable: this.dataFactoryVariable,
-                                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"),
-                            });
+                    for (const [floatOrInt, numberDatatypes_] of Object.entries(numberDatatypes)) {
+                        for (const numberDatatype of numberDatatypes_) {
+                            if (datatype.equals(numberDatatype)) {
+                                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)) {
                         return new StringType({
-                            dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
                             languageIn: [],
@@ -167,7 +270,6 @@ export class TypeFactory {
                     logger.debug("literal type has no datatypes");
                 }
                 return new LiteralType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     defaultValue: astType.defaultValue,
                     hasValues: astType.hasValues,
                     in_: astType.in_,
@@ -179,205 +281,167 @@ export class TypeFactory {
             case "ObjectType":
                 return this.createObjectTypeFromAstType(astType);
             case "ObjectUnionType":
-                return new ObjectUnionType({
-                    comment: astType.comment,
-                    dataFactoryVariable: this.dataFactoryVariable,
-                    export_: astType.export,
-                    features: astType.tsFeatures,
-                    label: astType.label,
-                    memberTypes: astType.memberTypes
-                        .map((astType) => this.createTypeFromAstType(astType))
-                        .filter((memberType) => memberType instanceof ObjectType),
-                    name: tsName(astType.name),
-                });
+                return this.createObjectUnionTypeFromAstType(astType);
             case "OptionType":
                 return new OptionType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                 });
             case "PlaceholderType":
                 throw new Error(astType.kind);
             case "SetType":
                 return new SetType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     mutable: astType.mutable.orDefault(false),
                     minCount: astType.minCount,
                 });
             case "TermType":
                 return new TermType({
-                    dataFactoryVariable: this.dataFactoryVariable,
-                    defaultValue: astType.defaultValue,
-                    hasValues: astType.hasValues,
-                    in_: astType.in_,
-                    nodeKinds: astType.nodeKinds,
+                    defaultValue: astType["defaultValue"],
+                    hasValues: astType["hasValues"],
+                    in_: astType["in_"],
+                    nodeKinds: astType["nodeKinds"],
                 });
             case "UnionType":
                 return new UnionType({
-                    dataFactoryVariable: this.dataFactoryVariable,
                     memberTypes: astType.memberTypes.map((astType) => this.createTypeFromAstType(astType)),
                 });
         }
     }
-    createObjectTypeFromAstType(astType) {
+    createObjectTypePropertyFromAstProperty({ astObjectTypeProperty, objectType, }) {
         {
-            const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
-            if (cachedObjectType) {
-                return cachedObjectType;
+            const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
+            if (cachedProperty) {
+                return cachedProperty;
             }
         }
-        const identifierType = new IdentifierType({
-            dataFactoryVariable: this.dataFactoryVariable,
-            defaultValue: Maybe.empty(),
-            hasValues: [],
-            in_: astType.identifierIn,
-            nodeKinds: astType.identifierKinds,
-        });
-        const objectType = new ObjectType({
-            abstract: astType.abstract,
+        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,
+                });
+            }
+            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,
+                });
+            }
+            else {
+                invariant(resolvedType instanceof ObjectType ||
+                    resolvedType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
+                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
+                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
+                    resolvedType,
+                    stubType,
+                });
+            }
+            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 {
+            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,
+            });
+        }
+        this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
+        return property;
+    }
+    createObjectUnionTypeFromAstType(astType) {
+        {
+            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 objectUnionType = new ObjectUnionType({
             comment: astType.comment,
-            dataFactoryVariable: this.dataFactoryVariable,
-            declarationType: astType.tsObjectDeclarationType,
             export_: astType.export,
-            extern: astType.extern,
             features: astType.tsFeatures,
-            fromRdfType: astType.fromRdfType,
-            imports: astType.tsImports,
+            identifierType: new IdentifierType({
+                defaultValue: Maybe.empty(),
+                hasValues: [],
+                in_: [...memberIdentifierTypesIn],
+                nodeKinds: memberIdentifierTypeNodeKinds,
+            }),
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
-            lazyProperties: () => {
-                const properties = astType.properties
-                    .toSorted((left, right) => {
-                    if (left.order < right.order) {
-                        return -1;
-                    }
-                    if (left.order > right.order) {
-                        return 1;
-                    }
-                    return tsName(left.name).localeCompare(tsName(right.name));
-                })
-                    .map((astProperty) => this.createObjectTypePropertyFromAstProperty(astType, astProperty));
-                const lazyMutable = () => properties.some((property) => property.mutable || property.type.mutable);
-                // Type discriminator property
-                const typeDiscriminatorValues = new Set();
-                if (!astType.abstract) {
-                    typeDiscriminatorValues.add(objectType.discriminatorValue);
-                }
-                for (const descendantObjectType of objectType.descendantObjectTypes) {
-                    if (!descendantObjectType.abstract) {
-                        typeDiscriminatorValues.add(descendantObjectType.discriminatorValue);
-                    }
-                }
-                if (typeDiscriminatorValues.size > 0) {
-                    properties.splice(0, 0, new ObjectType.TypeDiscriminatorProperty({
-                        abstract: astType.abstract,
-                        dataFactoryVariable: this.dataFactoryVariable,
-                        name: astType.tsTypeDiscriminatorPropertyName,
-                        objectType: {
-                            declarationType: astType.tsObjectDeclarationType,
-                            features: astType.tsFeatures,
-                            mutable: lazyMutable,
-                        },
-                        override: objectType.parentObjectTypes.length > 0,
-                        type: new ObjectType.TypeDiscriminatorProperty.Type({
-                            mutable: false,
-                            values: [...typeDiscriminatorValues].sort(),
-                        }),
-                        visibility: "public",
-                        value: objectType.discriminatorValue,
-                    }));
-                }
-                // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
-                if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new ObjectType.IdentifierPrefixProperty({
-                        dataFactoryVariable: this.dataFactoryVariable,
-                        own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
-                        name: astType.tsIdentifierPrefixPropertyName,
-                        objectType: {
-                            declarationType: astType.tsObjectDeclarationType,
-                            features: astType.tsFeatures,
-                            mutable: lazyMutable,
-                        },
-                        type: new StringType({
-                            dataFactoryVariable: this.dataFactoryVariable,
-                            defaultValue: Maybe.empty(),
-                            hasValues: [],
-                            in_: [],
-                            languageIn: [],
-                            primitiveDefaultValue: Maybe.empty(),
-                            primitiveIn: [],
-                        }),
-                        visibility: "protected",
-                    }));
-                }
-                // Every ObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, new ObjectType.IdentifierProperty({
-                    abstract: astType.abstract,
-                    classDeclarationVisibility: (() => {
-                        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");
-                    })(),
-                    dataFactoryVariable: this.dataFactoryVariable,
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    name: astType.tsIdentifierPropertyName,
-                    objectType: {
-                        declarationType: astType.tsObjectDeclarationType,
-                        features: astType.tsFeatures,
-                        mutable: lazyMutable,
-                    },
-                    override: astType.parentObjectTypes.length > 0,
-                    type: identifierType,
-                    visibility: "public",
-                }));
-                return properties;
-            },
-            identifierMintingStrategy: astType.identifierMintingStrategy,
+            memberTypes,
             name: tsName(astType.name),
-            toRdfTypes: astType.toRdfTypes,
         });
-        this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
-        return objectType;
+        this.cachedObjectUnionTypesByIdentifier.set(astType.name.identifier, objectUnionType);
+        return objectUnionType;
     }
-    createObjectTypePropertyFromAstProperty(astObjectType, astObjectTypeProperty) {
-        {
-            const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
-            if (cachedProperty) {
-                return cachedProperty;
-            }
+}
+function objectTypeNeedsIdentifierPrefixProperty(objectType) {
+    return objectType.identifierMintingStrategy
+        .map((identifierMintingStrategy) => {
+        switch (identifierMintingStrategy) {
+            case "blankNode":
+                return false;
+            case "sha256":
+            case "uuidv4":
+                return true;
         }
-        const property = new ObjectType.ShaclProperty({
-            comment: astObjectTypeProperty.comment,
-            dataFactoryVariable: this.dataFactoryVariable,
-            description: astObjectTypeProperty.description,
-            label: astObjectTypeProperty.label,
-            mutable: astObjectTypeProperty.mutable.orDefault(false),
-            objectType: {
-                declarationType: astObjectType.tsObjectDeclarationType,
-                features: astObjectType.tsFeatures,
-                mutable: () => {
-                    throw new Error("not implemented");
-                },
-            },
-            name: tsName(astObjectTypeProperty.name),
-            path: astObjectTypeProperty.path.iri,
-            type: this.createTypeFromAstType(astObjectTypeProperty.type),
-            visibility: astObjectTypeProperty.visibility,
-        });
-        this.cachedObjectTypePropertiesByIdentifier.set(astObjectTypeProperty.name.identifier, property);
-        return property;
-    }
+    })
+        .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

package/dist/generators/ts/UnionType.d.ts

@@ -1,32 +1,36 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class UnionType extends Type {
+    private readonly _discriminator;
+    private readonly memberTypes;
+    private _name?;
     readonly kind = "UnionType";
-    readonly memberTypes: readonly Type[];
-    constructor({ memberTypes, name, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    readonly typeof = "object";
+    constructor({ memberTypes, name, }: {
         memberTypes: readonly Type[];
         name?: string;
     });
-    private _name?;
-    get name(): string;
     get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
-    private get _discriminatorProperty();
-    private get memberTypeTraits();
+    get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement(): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
     sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
+    private discriminatorVariable;
     private ternaryExpression;
 }
 //# sourceMappingURL=UnionType.d.ts.map