@shaclmate/compiler 4.0.39 → 4.0.40

package/dist/generators/ts/BlankNodeType.js

@@ -13,21 +13,21 @@ export class BlankNodeType extends AbstractIdentifierType {
         code: code `${this.reusables.snippets.convertToBlankNode}`,
         sourceTypes: [
             {
-                name: code `${this.reusables.imports.BlankNode}`,
+                expression: code `${this.reusables.imports.BlankNode}`,
                 typeof: "object",
             },
             {
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             },
         ],
     });
+    expression = code `${this.reusables.imports.BlankNode}`;
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
-    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
     kind = "BlankNode";
-    name = code `${this.reusables.imports.BlankNode}`;
     nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
     schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
@@ -38,13 +38,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "BlankNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -52,6 +46,12 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType`

package/dist/generators/ts/BooleanType.d.ts

@@ -7,10 +7,10 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "Boolean";
-    readonly schemaType: Code;
     readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    get name(): string;
+    get expression(): Code;
+    get schemaType(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
     literalExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/BooleanType.js

@@ -14,14 +14,16 @@ export class BooleanType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashBoolean}`;
     kind = "Boolean";
-    schemaType = code `${this.reusables.snippets.BooleanSchema}<${this.name}>`;
     typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    get name() {
+    get expression() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
+            return code `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
         }
-        return `boolean`;
+        return code `boolean`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
     }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
@@ -46,5 +48,8 @@ export class BooleanType extends AbstractPrimitiveType {
 }
 __decorate([
     Memoize()
-], BooleanType.prototype, "name", null);
+], BooleanType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "schemaType", null);
 //# sourceMappingURL=BooleanType.js.map

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

@@ -17,12 +17,12 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
-    get name(): Code | string;
     get schemaType(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;

package/dist/generators/ts/DefaultValueType.js

@@ -27,7 +27,7 @@ export class DefaultValueType extends AbstractContainerType {
             sourceTypes: itemConversionFunction.sourceTypes
                 .filter((sourceType) => sourceType.typeof !== "undefined")
                 .concat({
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             }),
         });
@@ -35,6 +35,9 @@ export class DefaultValueType extends AbstractContainerType {
     get equalsFunction() {
         return this.itemType.equalsFunction;
     }
+    get expression() {
+        return this.itemType.expression;
+    }
     get filterFunction() {
         return this.itemType.filterFunction;
     }
@@ -50,11 +53,8 @@ export class DefaultValueType extends AbstractContainerType {
     get mutable() {
         return this.itemType.mutable;
     }
-    get name() {
-        return this.itemType.name;
-    }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.name}, ${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.expression}, ${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
@@ -72,11 +72,10 @@ export class DefaultValueType extends AbstractContainerType {
             case "Literal":
             case "Term":
                 return this.rdfjsTermExpression(this.defaultValue);
-            case "AnonymousUnion":
             case "List":
-            case "NamedObjectType":
-            case "NamedObjectUnion":
-            case "NamedUnion":
+            case "Object":
+            case "ObjectUnion":
+            case "Union":
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");

package/dist/generators/ts/GraphqlSchema.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "ts-log";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -12,8 +12,8 @@ export declare class GraphqlSchema {
     constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
-        namedObjectTypes: readonly NamedObjectType[];
-        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        namedObjectTypes: readonly ObjectType[];
+        namedObjectUnionTypes: readonly ObjectUnionType[];
         reusables: Reusables;
     });
     get declaration(): Code;

package/dist/generators/ts/GraphqlSchema.js

@@ -28,8 +28,8 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
                     },
                 },
                 resolve: code `\
-  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
-    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.expression}> => 
+    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
       liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
     )).unsafeCoerce()`,
                 type: namedObjectType.graphqlType.name,
@@ -61,8 +61,8 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
                     },
                 },
                 resolve: code `\
-  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
-  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.expression}[]> =>
+  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.expression}[]>(async ({ liftEither }) => {
     let filter: ${namedObjectType.filterType} | undefined;
     if (args.identifiers) {
       const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];

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

@@ -5,18 +5,18 @@ import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
+    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly parseFunction: Code;
     readonly kind = "Identifier";
-    readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
+    readonly parseFunction: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfResourceValuesExpressionChain"]>;
 }

package/dist/generators/ts/IdentifierType.js

@@ -14,29 +14,29 @@ export class IdentifierType extends AbstractIdentifierType {
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
             {
-                name: code `${this.reusables.imports.BlankNode}`,
+                expression: code `${this.reusables.imports.BlankNode}`,
                 typeof: "object",
             },
             {
-                name: code `${this.reusables.imports.NamedNode}`,
+                expression: code `${this.reusables.imports.NamedNode}`,
                 typeof: "object",
             },
             {
-                name: "string",
+                expression: code `string`,
                 typeof: "string",
             },
             {
-                name: "undefined",
+                expression: code `undefined`,
                 typeof: "undefined",
             },
         ],
     });
+    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
-    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
     kind = "Identifier";
-    name = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     nodeKinds = nodeKinds;
+    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
     schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
     constructor(parameters) {
@@ -47,13 +47,7 @@ export class IdentifierType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "BlankNode" | "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -61,6 +55,12 @@ export class IdentifierType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode" | "NamedNode"`
+            : "";
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType as ${[...this.nodeKinds].map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`).join(" | ")}`

package/dist/generators/ts/IriType.d.ts

@@ -10,10 +10,10 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get name(): Code;
-    private get valueTypeName();
+    get expression(): Code;
     get parseFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
+    private get valueTypeExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;

package/dist/generators/ts/IriType.js

@@ -13,37 +13,32 @@ export class IriType extends AbstractIdentifierType {
     filterType = code `${this.reusables.snippets.IriFilter}`;
     kind = "Iri";
     nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeName}>`;
+    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeName}>`,
+            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
             sourceTypes: [
                 {
-                    name: this.valueTypeName,
+                    expression: this.valueTypeExpression,
                     typeof: "string",
                 },
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
             ],
         });
     }
-    get name() {
+    get expression() {
         if (this.in_.length > 0) {
-            return code `${this.reusables.imports.NamedNode}<${this.valueTypeName}>`;
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
-    get valueTypeName() {
-        return this.in_.length > 0
-            ? `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
-            : "string";
-    }
     get parseFunction() {
         if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
         return code `${this.reusables.snippets.parseIri}`;
     }
@@ -54,8 +49,13 @@ export class IriType extends AbstractIdentifierType {
         }
         return initializers;
     }
+    get valueTypeExpression() {
+        return this.in_.length > 0
+            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
+            : code `string`;
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
@@ -76,7 +76,7 @@ export class IriType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "NamedNode"`
             : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeName}${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -98,13 +98,13 @@ __decorate([
 ], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "name", null);
+], IriType.prototype, "expression", null);
 __decorate([
     Memoize()
-], IriType.prototype, "valueTypeName", null);
+], IriType.prototype, "parseFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "parseFunction", null);
+], IriType.prototype, "valueTypeExpression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "jsonType", null);

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -7,6 +7,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     partialType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
     resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
 } & {
+    alias: Maybe<string>;
     comment: Maybe<string>;
     configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -14,22 +14,22 @@ export class LazyObjectOptionType extends Super {
     kind = "LazyObjectOption";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.itemType.name,
+                    expression: this.resolveType.itemType.expression,
                     typeof: "object",
                 },
                 {
-                    name: "undefined",
+                    expression: code `undefined`,
                     typeof: "undefined",
                 },
             ],
@@ -37,7 +37,7 @@ export class LazyObjectOptionType extends Super {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObjectOption}`,
         };

package/dist/generators/ts/LazyObjectSetType.js

@@ -20,18 +20,18 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     kind = "LazyObjectSet";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
                 {
-                    name: "undefined",
+                    expression: code `undefined`,
                     typeof: "undefined",
                 },
             ],
@@ -39,7 +39,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partials",
             rawName: code `${this.reusables.snippets.LazyObjectSet}`,
         };

package/dist/generators/ts/LazyObjectType.js

@@ -13,14 +13,14 @@ export class LazyObjectType extends AbstractLazyObjectType {
     kind = "LazyObject";
     get conversionFunction() {
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
+                    expression: this.expression,
                     typeof: "object",
                 },
                 {
-                    name: this.resolveType.name,
+                    expression: this.resolveType.expression,
                     typeof: "object",
                 },
             ],
@@ -28,7 +28,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>`,
+            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObject}`,
         };

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -12,13 +11,13 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { NamedUnionType } from "./NamedUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
@@ -35,7 +34,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -102,7 +102,6 @@ __decorate([
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnion":
             case "BigDecimal":
             case "BigInt":
             case "BlankNode":
@@ -114,11 +113,11 @@ __decorate([
             case "Iri":
             case "Int":
             case "Literal":
-            case "NamedObjectUnion":
-            case "NamedUnion":
-            case "NamedObjectType":
+            case "ObjectUnion":
+            case "Object":
             case "String":
             case "Term":
+            case "Union":
                 return true;
             case "DefaultValue":
             case "LazyObjectOption":

package/dist/generators/ts/LiteralType.d.ts

@@ -3,7 +3,7 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
-    readonly name: Code;
+    readonly expression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;

package/dist/generators/ts/LiteralType.js

@@ -3,20 +3,20 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    name = code `${this.reusables.imports.Literal}`;
+    expression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
-                name: typeof_,
+                expression: code `${typeof_}`,
                 typeof: typeof_,
             })),
             {
-                name: "Date",
+                expression: code `Date`,
                 typeof: "object",
             },
             {
-                name: code `${this.reusables.imports.Literal}`,
+                expression: code `${this.reusables.imports.Literal}`,
                 typeof: "object",
             },
         ],
@@ -37,7 +37,7 @@ export class LiteralType extends AbstractLiteralType {
         return initializers;
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");