@shaclmate/compiler 4.0.39 → 4.0.40

package/dist/generators/ts/{NamedObjectUnionType.js → ObjectUnionType.js}

@@ -6,44 +6,38 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { PropertyPath } from "@rdfx/resource";
 import { pascalCase } from "change-case";
-import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import { AbstractType } from "./AbstractType.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class NamedObjectUnionType extends AbstractNamedUnionType {
-    #identifierType;
-    graphqlArgs = Maybe.empty();
-    kind = "NamedObjectUnion";
-    synthetic;
-    constructor({ identifierType, synthetic, ...superParameters }) {
-        super({ ...superParameters, identifierType: Maybe.of(identifierType) });
-        this.#identifierType = identifierType;
-        this.synthetic = synthetic;
-    }
-    get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this._name}.GraphQL`, this.reusables);
-    }
+import { UnionType } from "./UnionType.js";
+export class ObjectUnionType extends UnionType {
+    kind = "ObjectUnion";
     get identifierTypeAlias() {
-        return code `${this.name}.Identifier`;
+        return this.alias.map((alias) => code `${alias}.Identifier`).unsafeCoerce();
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call({
+        return this.alias
+            .map((alias) => ObjectType_objectSetMethodNames.call({
+            alias,
             configuration: this.configuration,
-            name: this.name,
-        });
+        }))
+            .unsafeCoerce();
     }
     get schema() {
-        return code `${this.name}.schema`;
+        return this.alias
+            .map((alias) => code `${alias}.schema`)
+            .orDefault(super.schema);
     }
     get schemaType() {
-        return code `typeof ${this.schema}`;
+        return this.alias
+            .map(() => code `typeof ${this.schema}`)
+            .orDefault(super.schemaType);
     }
     get staticModuleDeclarations() {
+        const alias = this.alias.unsafeCoerce();
         return {
             ...super.staticModuleDeclarations,
             ...this.identifierTypeDeclarations,
@@ -53,18 +47,18 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                alias,
                 configuration: this.configuration,
                 filterType: this.filterType,
-                name: this.name,
                 reusables: this.reusables,
             })
                 .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
                 .orDefault({}),
-            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                alias,
                 configuration: this.configuration,
                 filterType: this.filterType,
-                name: this.name,
                 reusables: this.reusables,
             })
                 .map((code_) => singleEntryRecord(`sparqlConstructQueryString`, code_))
@@ -78,7 +72,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
 export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -91,18 +85,18 @@ ${joinCode([
             code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
             code `\
 if (focusIdentifier.termType === "Variable") {
-  patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
+  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
       filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
       ignoreRdfType: false,
       preferredLanguages,
       propertyPatterns: [],
-      schema: ${this.#identifierType.schema},
+      schema: ${this.identifierType.unsafeCoerce().schema},
       valueVariable: focusIdentifier,
       variablePrefix,
   }));
 }`,
             code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                patterns: code `${member.type.name}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+                patterns: code `${member.type.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -113,10 +107,11 @@ if (focusIdentifier.termType === "Variable") {
         if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${alias}> = (resource, options) => 
   ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.name}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${this.name}>)`;
+            const memberTypeExpression = code `(${member.type.alias.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${alias}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -129,11 +124,12 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         if (this.synthetic) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
-            name: this.name,
-            resolveType: code `(value: ${this.name}) => value.${this.configuration.syntheticNamePrefix}type`,
+            name: alias,
+            resolveType: code `(value: ${alias}) => value.${this.configuration.syntheticNamePrefix}type`,
             types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
@@ -142,22 +138,23 @@ export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             return {};
         }
         return singleEntryRecord(`Identifier`, code `\
-export type Identifier = ${this.#identifierType.name};
+export type Identifier = ${this.identifierType.unsafeCoerce().expression};
 export namespace Identifier {
-  export const parse = ${this.#identifierType.parseFunction};
-  export const stringify = ${this.#identifierType.stringifyFunction};
+  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
+  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
 }`);
     }
     get isTypeFunctionDeclaration() {
         if (!this.configuration.features.has("Object.type")) {
             return {};
         }
-        if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
+        const alias = this.alias.unsafeCoerce();
+        if (alias === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
-        return singleEntryRecord(`is${this._name}`, code `\
-    export function is${this._name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
-      return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
+        return singleEntryRecord(`is${alias}`, code `\
+    export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
+      return ${joinCode(this.members.map((member) => code `${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
@@ -191,7 +188,7 @@ export namespace Identifier {
             if (!memberTypesWithProperty.every((value) => value)) {
                 continue;
             }
-            property.schema.ifJust(propertySchema => {
+            property.schema.ifJust((propertySchema) => {
                 propertiesObject.push(code `${property.name}: ${propertySchema}`);
             });
         }
@@ -202,30 +199,25 @@ export const schema = { ${joinCode(super.schemaInitializers.concat(code `propert
         if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (object, options) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${alias}> = (object, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.name}.is${member.type.name}(object)) { return ${member.type.name}.toRdfResource(object, options); }`)
+            .map((member) => code `if (${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)) { return ${member.type.alias.unsafeCoerce()}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
 }
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectUnionType.prototype, "identifierTypeAlias", null);
+], ObjectUnionType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "objectSetMethodNames", null);
+], ObjectUnionType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "schema", null);
+], ObjectUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "schemaType", null);
-//# sourceMappingURL=NamedObjectUnionType.js.map
+], ObjectUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=ObjectUnionType.js.map

package/dist/generators/ts/OptionType.d.ts

@@ -8,12 +8,12 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     readonly typeofs: "object"[];
     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;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;

package/dist/generators/ts/OptionType.js

@@ -20,10 +20,10 @@ export class OptionType extends AbstractContainerType {
         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}>`;
     }
@@ -73,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()`;
@@ -114,6 +114,9 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterFunction", null);
@@ -126,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 "NamedObjectUnion":
+                    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/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

@@ -7,10 +7,10 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "String";
-    readonly schemaType: Code;
     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

@@ -14,14 +14,16 @@ export class StringType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashString}`;
     kind = "String";
-    schemaType = code `${this.reusables.snippets.StringSchema}<${this.name}>`;
     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

@@ -14,12 +14,12 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     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

@@ -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;