@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/BooleanType.js

@@ -4,74 +4,51 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { PrimitiveType } from "./PrimitiveType.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
-export class BooleanType extends PrimitiveType {
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class BooleanType extends AbstractPrimitiveType {
+    filterFunction = code `${snippets.filterBoolean}`;
+    filterType = code `${snippets.BooleanFilter}`;
+    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLBoolean}`);
     kind = "BooleanType";
-    typeof = "boolean";
-    get conversions() {
-        const conversions = [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
-                sourceTypeName: this.name,
-            },
-        ];
-        this.primitiveDefaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => defaultValue.toString(),
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-        });
-        return conversions;
-    }
-    get graphqlName() {
-        return new Type.GraphqlName("graphql.GraphQLBoolean");
-    }
+    schemaType = code `${snippets.BooleanSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
+    typeofs = NonEmptyList(["boolean"]);
     get name() {
         if (this.primitiveIn.length > 0) {
-            return this.primitiveIn.map((value) => value.toString()).join(" | ");
+            return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
         }
-        return this.typeof;
+        return `boolean`;
     }
-    jsonZodSchema({ variables, }) {
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0 ? this.primitiveIn.concat() : undefined,
+        };
+    }
+    jsonZodSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
-            return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+            return code `${imports.z}.literal(${this.primitiveIn[0]})`;
         }
-        return `${variables.zod}.boolean()`;
+        return code `${imports.z}.boolean()`;
+    }
+    toRdfExpression({ variables, }) {
+        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
-        let fromRdfResourceValueExpression = "value.toBoolean()";
-        if (this.primitiveIn.length === 1) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of${eitherTypeParameters}(value) : purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})))`;
-        }
         return {
             ...super.fromRdfExpressionChain({ variables }),
             languageIn: undefined,
             preferredLanguages: undefined,
-            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
+            valueTo: code `chain(values => values.chainMap(value => value.toBoolean(${this.primitiveIn.length === 1 ? `[${this.primitiveIn[0]}] as const` : ""})))`,
         };
     }
-    toRdfExpression({ variables, }) {
-        return this.primitiveDefaultValue
-            .map((defaultValue) => {
-            if (defaultValue) {
-                // If the default is true, only serialize the value if it's false
-                return `(!${variables.value} ? [false] : [])`;
-            }
-            // If the default is false, only serialize the value if it's true
-            return `(${variables.value} ? [true] : [])`;
-        })
-            .orDefault(variables.value);
-    }
 }
-__decorate([
-    Memoize()
-], BooleanType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);

package/dist/generators/ts/DateTimeType.d.ts

@@ -1,24 +1,10 @@
-import type { NamedNode } from "@rdfjs/types";
-import { PrimitiveType } from "./PrimitiveType.js";
-import type { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-export declare class DateTimeType extends PrimitiveType<Date> {
-    protected readonly xsdDatatype: NamedNode;
-    protected readonly zodDatatype: string;
-    readonly equalsFunction = "$dateEquals";
-    readonly kind: "DateTimeType" | "DateType";
-    readonly mutable = true;
-    readonly typeof = "object";
-    get conversions(): readonly Type.Conversion[];
-    get graphqlName(): Type.GraphqlName;
-    get jsonName(): Type.JsonName;
-    get name(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
-    snippetDeclarations({ features, }: Parameters<PrimitiveType<Date>["snippetDeclarations"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;
+import { AbstractDateType } from "./AbstractDateType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class DateTimeType extends AbstractDateType {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly kind = "DateTimeType";
+    jsonZodSchema(_parameters: Parameters<AbstractDateType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
+    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -1,96 +1,17 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { xsd } from "@tpluscode/rdf-ns-builders";
-import { Memoize } from "typescript-memoize";
-import { PrimitiveType } from "./PrimitiveType.js";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class DateTimeType extends PrimitiveType {
-    xsdDatatype = xsd.dateTime;
-    zodDatatype = "datetime";
-    equalsFunction = `${syntheticNamePrefix}dateEquals`;
+import { AbstractDateType } from "./AbstractDateType.js";
+import { imports } from "./imports.js";
+import { code } from "./ts-poet-wrapper.js";
+export class DateTimeType extends AbstractDateType {
+    graphqlType = new AbstractDateType.GraphqlType(code `${imports.GraphQLDateTime}`);
     kind = "DateTimeType";
-    mutable = true;
-    typeof = "object";
-    get conversions() {
-        const conversions = [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
-                sourceTypeName: this.name,
-            },
-        ];
-        this.primitiveDefaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => `new Date("${defaultValue.toISOString()}")`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-        });
-        return conversions;
-    }
-    get graphqlName() {
-        return new Type.GraphqlName("graphqlScalars.DateTime");
-    }
-    get jsonName() {
-        return new Type.JsonName("string");
-    }
-    get name() {
-        return "Date";
-    }
-    fromJsonExpression({ variables, }) {
-        return `new Date(${variables.value})`;
-    }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.toISOString());`];
-    }
-    jsonZodSchema({ variables, }) {
-        return `${variables.zod}.string().${this.zodDatatype}()`;
-    }
-    fromRdfExpressionChain({ variables, }) {
-        let fromRdfResourceValueExpression = "value.toDate()";
-        if (this.primitiveIn.length > 0) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            fromRdfResourceValueExpression = `${fromRdfResourceValueExpression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of${eitherTypeParameters}(value); }`).join(" ")} return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
-        }
-        return {
-            ...super.fromRdfExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: `chain(values => values.chainMap(value => ${fromRdfResourceValueExpression}))`,
-        };
-    }
-    snippetDeclarations({ features, }) {
-        const snippetDeclarations = [];
-        if (features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.dateEquals);
-        }
-        return snippetDeclarations;
+    jsonZodSchema(_parameters) {
+        return code `${imports.z}.iso.datetime()`;
     }
     toJsonExpression({ variables, }) {
-        return `${variables.value}.toISOString()`;
+        return code `${variables.value}.toISOString()`;
     }
-    toRdfExpression({ variables, }) {
-        const valueToRdf = `rdfLiteral.toRdf(${variables.value}, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`;
-        return this.primitiveDefaultValue
-            .map((defaultValue) => `(${variables.value}.getTime() !== ${defaultValue.getTime()} ? [${valueToRdf}] : [])`)
-            .orDefault(`[${valueToRdf}]`);
+    fromRdfResourceValueExpression({ variables, }) {
+        return code `${variables.value}.toDateTime(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
-__decorate([
-    Memoize()
-], DateTimeType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], DateTimeType.prototype, "graphqlName", null);
-__decorate([
-    Memoize()
-], DateTimeType.prototype, "jsonName", null);
 //# sourceMappingURL=DateTimeType.js.map

package/dist/generators/ts/DateType.d.ts

@@ -1,12 +1,11 @@
-import type { NamedNode } from "@rdfjs/types";
+import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
-import type { PrimitiveType } from "./PrimitiveType.js";
-import { Type } from "./Type.js";
-export declare class DateType extends DateTimeType {
-    protected readonly xsdDatatype: NamedNode;
-    protected readonly zodDatatype = "date";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class DateType extends AbstractDateType {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateType";
-    get graphqlName(): Type.GraphqlName;
-    toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
+    jsonZodSchema(_parameters: Parameters<DateTimeType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
+    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -1,25 +1,18 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { xsd } from "@tpluscode/rdf-ns-builders";
-import { Memoize } from "typescript-memoize";
+import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
-import { Type } from "./Type.js";
-export class DateType extends DateTimeType {
-    xsdDatatype = xsd.date;
-    zodDatatype = "date";
+import { imports } from "./imports.js";
+import { code } from "./ts-poet-wrapper.js";
+export class DateType extends AbstractDateType {
+    graphqlType = new DateTimeType.GraphqlType(code `${imports.GraphQLDate}`);
     kind = "DateType";
-    get graphqlName() {
-        return new Type.GraphqlName("graphqlScalars.Date");
+    jsonZodSchema(_parameters) {
+        return code `${imports.z}.iso.date()`;
     }
     toJsonExpression({ variables, }) {
-        return `${variables.value}.toISOString().replace(/T.*$/, '')`;
+        return code `${variables.value}.toISOString().replace(/T.*$/, '')`;
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        return code `${variables.value}.toDate(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
-__decorate([
-    Memoize()
-], DateType.prototype, "graphqlName", null);
 //# sourceMappingURL=DateType.js.map

package/dist/generators/ts/DefaultValueType.d.ts

@@ -0,0 +1,48 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import { Maybe, NonEmptyList } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    readonly defaultValue: Literal | NamedNode;
+    readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly kind = "DefaultValueType";
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ defaultValue, ...superParameters }: {
+        defaultValue: Literal | NamedNode;
+    } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
+    get conversions(): readonly AbstractContainerType.Conversion[];
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
+    get mutable(): boolean;
+    get name(): Code | string;
+    get schemaType(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    protected get schemaObject(): {
+        defaultValue: Code;
+        item: Code;
+        kind: Code;
+    };
+    private get defaultValuePrimitiveExpression();
+    private get defaultValueTermExpression();
+    fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
+    hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfExpression(parameters: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+}
+export declare namespace DefaultValueType {
+    type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;
+    function isItemType(type: Type): type is ItemType;
+}
+//# sourceMappingURL=DefaultValueType.d.ts.map

package/dist/generators/ts/DefaultValueType.js

@@ -0,0 +1,178 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe, NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "rdfjs-resource";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export class DefaultValueType extends AbstractContainerType {
+    defaultValue;
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    kind = "DefaultValueType";
+    typeofs = NonEmptyList(["object"]);
+    constructor({ defaultValue, ...superParameters }) {
+        super(superParameters);
+        this.defaultValue = defaultValue;
+    }
+    get conversions() {
+        let conversions = this.itemType.conversions;
+        this.defaultValuePrimitiveExpression.ifJust((defaultValue) => {
+            conversions = conversions.concat({
+                conversionExpression: () => code `${defaultValue}`,
+                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+                sourceTypeName: code `undefined`,
+                sourceTypeof: "undefined",
+            });
+        });
+        return conversions;
+    }
+    get equalsFunction() {
+        return this.itemType.equalsFunction;
+    }
+    get filterFunction() {
+        return this.itemType.filterFunction;
+    }
+    get filterType() {
+        return this.itemType.filterType;
+    }
+    get graphqlType() {
+        return this.itemType.graphqlType;
+    }
+    get mutable() {
+        return this.itemType.mutable;
+    }
+    get name() {
+        return this.itemType.name;
+    }
+    get schemaType() {
+        return code `${snippets.DefaultValueSchema}`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return this.itemType.sparqlConstructTriplesFunction;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            defaultValue: this.defaultValueTermExpression,
+        };
+    }
+    get defaultValuePrimitiveExpression() {
+        switch (this.itemType.kind) {
+            case "BigDecimalType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `new ${imports.BigDecimal}(${literalOf(this.defaultValue.value)})`);
+            case "BigIntType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `${LiteralDecoder.decodeBigIntLiteral(this.defaultValue).unsafeCoerce()}n`);
+            case "BooleanType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `${LiteralDecoder.decodeBooleanLiteral(this.defaultValue).unsafeCoerce()}`);
+            case "DateType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
+            case "DateTimeType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateTimeLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
+            case "FloatType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `${LiteralDecoder.decodeFloatLiteral(this.defaultValue).unsafeCoerce()}`);
+            case "IntType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `${LiteralDecoder.decodeIntLiteral(this.defaultValue).unsafeCoerce()}`);
+            case "StringType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(code `${literalOf(this.defaultValue.value)}`);
+            case "IdentifierType":
+            case "IriType":
+                invariant(this.defaultValue.termType === "NamedNode");
+                return Maybe.of(this.defaultValueTermExpression);
+            case "LiteralType":
+            case "TermType":
+                invariant(this.defaultValue.termType === "Literal");
+                return Maybe.of(this.defaultValueTermExpression);
+            case "ListType":
+            case "ObjectType":
+            case "ObjectUnionType":
+            case "UnionType":
+                return Maybe.empty();
+            default:
+                this.itemType;
+                throw new Error("should never reach this point");
+        }
+    }
+    get defaultValueTermExpression() {
+        return rdfjsTermExpression(this.defaultValue);
+    }
+    fromJsonExpression(parameters) {
+        return this.itemType.fromJsonExpression(parameters);
+    }
+    fromRdfExpression({ variables, }) {
+        return this.itemType.fromRdfExpression({
+            variables: {
+                ...variables,
+                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
+            },
+        });
+    }
+    graphqlResolveExpression(parameters) {
+        return this.itemType.graphqlResolveExpression(parameters);
+    }
+    hashStatements(parameters) {
+        return this.itemType.hashStatements(parameters);
+    }
+    jsonType(parameters) {
+        return this.itemType.jsonType(parameters);
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        return this.itemType.jsonZodSchema(parameters);
+    }
+    toJsonExpression(parameters) {
+        return this.itemType.toJsonExpression(parameters);
+    }
+    toRdfExpression(parameters) {
+        const { variables } = parameters;
+        return this.defaultValuePrimitiveExpression
+            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfExpression(parameters)} : []`)
+            .orDefault(code `${this.itemType.toRdfExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
+    }
+}
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "sparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "defaultValuePrimitiveExpression", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "defaultValueTermExpression", null);
+(function (DefaultValueType) {
+    function isItemType(type) {
+        if (type.kind === "BlankNodeType") {
+            return false;
+        }
+        return AbstractContainerType.isItemType(type);
+    }
+    DefaultValueType.isItemType = isItemType;
+})(DefaultValueType || (DefaultValueType = {}));
+//# sourceMappingURL=DefaultValueType.js.map

package/dist/generators/ts/FloatType.d.ts

@@ -1,6 +1,11 @@
-import { NumberType } from "./NumberType.js";
-import { Type } from "./Type.js";
-export declare class FloatType extends NumberType {
-    get graphqlName(): Type.GraphqlName;
+import { NonEmptyList } from "purify-ts";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class FloatType extends AbstractNumericType<number> {
+    readonly kind = "FloatType";
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly typeofs: NonEmptyList<"number">;
+    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
+    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -1,18 +1,16 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Memoize } from "typescript-memoize";
-import { NumberType } from "./NumberType.js";
-import { Type } from "./Type.js";
-export class FloatType extends NumberType {
-    get graphqlName() {
-        return new Type.GraphqlName("graphql.GraphQLFloat");
+import { NonEmptyList } from "purify-ts";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { imports } from "./imports.js";
+import { code } from "./ts-poet-wrapper.js";
+export class FloatType extends AbstractNumericType {
+    kind = "FloatType";
+    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLFloat}`);
+    typeofs = NonEmptyList(["number"]);
+    fromRdfResourceValueExpression({ variables, }) {
+        return code `${variables.value}.toFloat(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
+    }
+    literalOf(value) {
+        return value.toString();
     }
 }
-__decorate([
-    Memoize()
-], FloatType.prototype, "graphqlName", null);
 //# sourceMappingURL=FloatType.js.map

package/dist/generators/ts/IdentifierType.d.ts

@@ -1,20 +1,22 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import { type FunctionDeclarationStructure, type VariableStatementStructure } from "ts-morph";
-import { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-export declare class IdentifierType extends TermType<NamedNode, BlankNode | NamedNode> {
+import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly fromStringFunction: Code;
     readonly kind = "IdentifierType";
-    get conversions(): readonly Type.Conversion[];
-    get fromStringFunctionDeclaration(): FunctionDeclarationStructure;
-    get graphqlName(): Type.GraphqlName;
-    get isNamedNodeKind(): boolean;
-    get jsonName(): Type.JsonName;
-    get name(): string;
-    get toStringFunctionDeclaration(): VariableStatementStructure;
-    fromJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
-    graphqlResolveExpression({ variables: { value }, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    jsonZodSchema({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>;
-    toJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): string;
+    readonly name: Code;
+    readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
+    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
+    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map