@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/OptionType.js

@@ -9,21 +9,21 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "OptionType";
+    kind = "Option";
     typeofs = ["object"];
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
             sourceTypes: itemConversionFunction.sourceTypes.concat({
-                name: this.name,
+                expression: this.expression,
                 typeof: "object",
             }, {
-                name: code `undefined`,
+                expression: code `undefined`,
                 typeof: "undefined",
             }),
         });
@@ -31,8 +31,11 @@ export class OptionType extends AbstractContainerType {
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
+    get expression() {
+        return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
+    }
     get filterFunction() {
-        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
@@ -49,9 +52,6 @@ export class OptionType extends AbstractContainerType {
     get mutable() {
         return this.itemType.mutable;
     }
-    get name() {
-        return code `${this.reusables.imports.Maybe}<${this.itemType.name}>`;
-    }
     get schemaType() {
         return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
@@ -64,12 +64,6 @@ export class OptionType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            kind: code `${literalOf("Maybe")} as const`,
-        };
-    }
     fromJsonExpression({ variables, }) {
         const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
@@ -79,7 +73,7 @@ export class OptionType extends AbstractContainerType {
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
+        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.expression}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
@@ -120,6 +114,9 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterFunction", null);
@@ -132,9 +129,6 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "name", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "schemaType", null);

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -56,7 +56,7 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
                     // objectSync
                     code `\
-${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.name}> {
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.expression}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                     // objectCount
@@ -90,19 +90,19 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                     const fromRdfTypes = namedObjectType.fromRdfTypeVariable
                         .toList()
                         .concat(namedObjectType.descendantFromRdfTypeVariables);
-                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
                 };
                 switch (namedObjectType.kind) {
-                    case "NamedObjectType": {
+                    case "Object": {
                         return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                     }
-                    case "NamedObjectUnionType":
+                    case "ObjectUnion":
                         return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);

package/dist/generators/ts/SetType.d.ts

@@ -2,7 +2,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
-    readonly kind = "SetType";
+    readonly kind = "Set";
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -10,7 +10,7 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
-    kind = "SetType";
+    kind = "Set";
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }

package/dist/generators/ts/Snippets.d.ts

@@ -87,6 +87,7 @@ export declare class Snippets {
     get decodeBigDecimalLiteral(): Snippet;
     get deduplicateSparqlPatterns(): Snippet;
     get defaultValueSparqlWherePatterns(): Snippet;
+    get ensureRdfResourceType(): Snippet;
     get filterArray(): Snippet;
     get filterBigDecimal(): Snippet;
     get filterBlankNode(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -45,6 +45,7 @@ import { snippets_decodeBigDecimalLiteral } from "./_snippets/snippets_decodeBig
 import { snippets_deduplicateSparqlPatterns } from "./_snippets/snippets_deduplicateSparqlPatterns.js";
 import { snippets_defaultValueSparqlWherePatterns } from "./_snippets/snippets_defaultValueSparqlWherePatterns.js";
 import { snippets_EqualsResult } from "./_snippets/snippets_EqualsResult.js";
+import { snippets_ensureRdfResourceType } from "./_snippets/snippets_ensureRdfResourceType.js";
 import { snippets_FocusSparqlConstructTriplesFunction } from "./_snippets/snippets_FocusSparqlConstructTriplesFunction.js";
 import { snippets_FocusSparqlWherePatternsFunction } from "./_snippets/snippets_FocusSparqlWherePatternsFunction.js";
 import { snippets_FromRdfResourceFunction } from "./_snippets/snippets_FromRdfResourceFunction.js";
@@ -379,6 +380,9 @@ export class Snippets {
     get defaultValueSparqlWherePatterns() {
         return this.snippet(snippets_defaultValueSparqlWherePatterns);
     }
+    get ensureRdfResourceType() {
+        return this.snippet(snippets_ensureRdfResourceType);
+    }
     get filterArray() {
         return this.snippet(snippets_filterArray);
     }
@@ -827,6 +831,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "defaultValueSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "ensureRdfResourceType", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "filterArray", null);

package/dist/generators/ts/SparqlObjectSetType.js

@@ -42,7 +42,7 @@ ${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((na
             const methodSignatures = this.methodSignatures(namedObjectType, {
                 queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
             });
-            const runtimeObjectType = namedObjectType.name;
+            const runtimeObjectType = namedObjectType.expression;
             return [
                 code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
@@ -58,7 +58,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
 }`,
                 code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objects<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             ];
         }), { on: "\n\n" })}

package/dist/generators/ts/StringType.d.ts

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

package/dist/generators/ts/StringType.js

@@ -13,15 +13,17 @@ export class StringType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashString}`;
-    kind = "StringType";
-    schemaType = code `${this.reusables.snippets.StringSchema}`;
+    kind = "String";
     typeofs = ["string"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
-    get name() {
+    get expression() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
+            return code `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
         }
-        return `string`;
+        return code `string`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
@@ -48,5 +50,8 @@ export class StringType extends AbstractPrimitiveType {
 }
 __decorate([
     Memoize()
-], StringType.prototype, "name", null);
+], StringType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "schemaType", null);
 //# sourceMappingURL=StringType.js.map

package/dist/generators/ts/TermType.d.ts

@@ -7,19 +7,19 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly kind = "TermType";
+    readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
+    get expression(): Code;
     get graphqlType(): AbstractTermType.GraphqlType;
-    get name(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
-    jsonType(): AbstractTermType.JsonType;
     jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractTermType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -15,7 +15,7 @@ export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterTerm}`;
     filterType = code `${this.reusables.snippets.TermFilter}`;
-    kind = "TermType";
+    kind = "Term";
     nodeKinds;
     schemaType = code `${this.reusables.snippets.TermSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
@@ -25,10 +25,7 @@ export class TermType extends AbstractTermType {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get graphqlType() {
-        throw new Error("not implemented");
-    }
-    get name() {
+    get expression() {
         return code `(${joinCode([...this.nodeKinds]
             .map((nodeKind) => {
             switch (nodeKind) {
@@ -45,8 +42,11 @@ export class TermType extends AbstractTermType {
         })
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${[
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
             ...this.nodeKinds,
         ].reduce((expression, nodeKind) => {
             let valueToNodeKind;
@@ -71,12 +71,6 @@ export class TermType extends AbstractTermType {
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    jsonType() {
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
-            .filter((nodeKind) => nodeKind !== "Literal")
-            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
-            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
-    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
             switch (nodeKind) {
@@ -90,6 +84,12 @@ export class TermType extends AbstractTermType {
             }
         }), { on: "," })}])`;
     }
+    jsonType() {
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
+            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
+    }
     toJsonExpression({ variables, }) {
         return [...this.nodeKinds].reduce((expression, nodeKind) => {
             let valueToNodeKind;
@@ -114,7 +114,7 @@ export class TermType extends AbstractTermType {
 }
 __decorate([
     Memoize()
-], TermType.prototype, "name", null);
+], TermType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "jsonType", null);

package/dist/generators/ts/TsGenerator.js

@@ -5,8 +5,8 @@ import { BlankNodeType } from "./BlankNodeType.js";
 import { GraphqlSchema } from "./GraphqlSchema.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { ObjectSetType } from "./ObjectSetType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
@@ -42,23 +42,23 @@ export class TsGenerator {
             }
             declarations = declarations.concat(typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createNamedObjectType(astObjectType));
+        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createObjectType(astObjectType));
         const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
             .filter((_) => _.isObjectUnionType())
-            .map((astObjectUnionType) => typeFactory.createNamedObjectUnionType(astObjectUnionType));
+            .map((astObjectUnionType) => typeFactory.createObjectUnionType(astObjectUnionType));
         for (const namedObjectType of namedObjectTypesToposorted) {
             declarations = declarations.concat(namedObjectType.declaration.toList());
         }
         for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
             declarations = declarations.concat(namedObjectUnionType.declaration.toList());
         }
-        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce()));
+        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce()));
         switch (namedObjectTypesNameSorted.length) {
             case 0:
                 break;
             case 1:
-                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].expression};`);
                 break;
             default: {
                 const uberObjectUnionType = this.synthesizeUberObjectUnionType({
@@ -127,6 +127,7 @@ export class TsGenerator {
         let identifierType;
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
+                alias: Maybe.empty(),
                 comment: Maybe.empty(),
                 configuration,
                 label: Maybe.empty(),
@@ -138,6 +139,7 @@ export class TsGenerator {
             switch ([...nodeKinds][0]) {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
+                        alias: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         label: Maybe.empty(),
@@ -147,6 +149,7 @@ export class TsGenerator {
                     break;
                 case "IRI":
                     identifierType = new IriType({
+                        alias: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         hasValues: [],
@@ -158,17 +161,17 @@ export class TsGenerator {
                     break;
             }
         }
-        return new NamedObjectUnionType({
+        return new ObjectUnionType({
+            alias: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
             comment: Maybe.empty(),
             configuration,
-            identifierType,
+            identifierType: Maybe.of(identifierType),
             label: Maybe.empty(),
             logger: this.logger,
             members: filteredNamedObjectTypes.map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
                 type: namedObjectType,
             })),
-            name: `${configuration.syntheticNamePrefix}Object`,
             recursive: false,
             reusables,
             synthetic: true,

package/dist/generators/ts/Type.d.ts

@@ -1,4 +1,3 @@
-import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -15,12 +14,12 @@ import type { LazyObjectSetType } from "./LazyObjectSetType.js";
 import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.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 { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
-export type Type = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
+import type { UnionType } from "./UnionType.js";
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,18 +1,17 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
-import { AnonymousUnionType } from "./AnonymousUnionType.js";
-import { NamedObjectType } from "./NamedObjectType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import { NamedUnionType } from "./NamedUnionType.js";
+import { ObjectType } from "./ObjectType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import type { Type } from "./Type.js";
+import { UnionType } from "./UnionType.js";
 export declare class TypeFactory {
     private readonly configuration;
     private readonly logger;
     private readonly reusables;
-    private cachedNamedObjectUnionTypesByShapeIdentifier;
+    private cachedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
     constructor({ configuration, logger, reusables, }: {
@@ -20,12 +19,12 @@ export declare class TypeFactory {
         logger: Logger;
         reusables: Reusables;
     });
-    createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
-    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
+    createObjectType(astType: ast.ObjectType): ObjectType;
+    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
-    createUnionType(astType: ast.UnionType): AnonymousUnionType | NamedUnionType | NamedObjectUnionType;
+    createUnionType(astType: ast.UnionType): ObjectUnionType | UnionType<Type>;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;