@shaclmate/compiler 4.0.9 → 4.0.11

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -2,30 +2,30 @@ import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export function objectSetMethodSignatures(parameters) {
-    const { objectType } = parameters;
+    const { namedObjectType } = parameters;
     const parameterNamePrefix = parameters?.parameterNamePrefix ?? "";
     const queryT = parameters.queryT ?? `${syntheticNamePrefix}ObjectSet.Query`;
-    const methodNames = objectType.objectSetMethodNames;
+    const methodNames = namedObjectType.objectSetMethodNames;
     return {
         object: {
             name: methodNames.object,
-            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-            returnType: code `Promise<${imports.Either}<Error, ${objectType.name}>>`,
+            parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+            returnType: code `Promise<${imports.Either}<Error, ${namedObjectType.name}>>`,
         },
         objectCount: {
             name: methodNames.objectCount,
-            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>, "filter">`,
+            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
             returnType: code `Promise<${imports.Either}<Error, number>>`,
         },
         objectIdentifiers: {
             name: methodNames.objectIdentifiers,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
         },
         objects: {
             name: methodNames.objects,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${imports.Either}<Error, readonly ${objectType.name}[]>>`,
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
         },
     };
 }

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.d.ts

@@ -1,8 +1,8 @@
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, namedObjectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
+export declare function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -4,8 +4,8 @@ import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, namedObjectUnionTypes, }) {
-    const objectTypeType = code `\
+export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const namedObjectTypeType = code `\
 {
   ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
   ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<ObjectT>;
@@ -41,13 +41,15 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-        ...[...objectTypes, ...namedObjectUnionTypes].flatMap((objectType) => {
-            if (!objectType.features.has("rdf")) {
+        ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
+            if (!namedObjectType.features.has("rdf")) {
                 return Object.values(unsupportedObjectSetMethodDeclarations({
-                    objectType,
+                    namedObjectType,
                 }));
             }
-            const methodSignatures = objectSetMethodSignatures({ objectType });
+            const methodSignatures = objectSetMethodSignatures({
+                namedObjectType,
+            });
             const delegatingMethods = [
                 // object
                 code `\
@@ -56,7 +58,7 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
                 // objectSync
                 code `\
-${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${objectType.name}> {
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${namedObjectType.name}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                 // objectCount
@@ -76,7 +78,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
 }`,
                 // objectIdentifiersSync
                 code `\
-${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]> {
+${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));
 }`,
                 // objects
@@ -86,37 +88,37 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 }`,
                 // objectsSync has per-object type logic, not just forwarding
             ];
-            const runtimeObjectType = (filterFunction, objectType) => {
-                const fromRdfTypes = objectType.fromRdfTypeVariable
+            const runtimeObjectType = (filterFunction, namedObjectType) => {
+                const fromRdfTypes = namedObjectType.fromRdfTypeVariable
                     .toList()
-                    .concat(objectType.descendantFromRdfTypeVariables);
-                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    .concat(namedObjectType.descendantFromRdfTypeVariables);
+                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${namedObjectType.staticModuleName}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
             };
-            switch (objectType.kind) {
-                case "ObjectType": {
+            switch (namedObjectType.kind) {
+                case "NamedObjectType": {
                     return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
-  return this.${syntheticNamePrefix}objectsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType(objectType.filterFunction, objectType)}, query);
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+  return this.${syntheticNamePrefix}objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                 }
                 case "NamedObjectUnionType":
                     return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
-  return this.${syntheticNamePrefix}objectUnionsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>([
-    ${joinCode(objectType.members
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+  return this.${syntheticNamePrefix}objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+    ${joinCode(namedObjectType.members
                         .filter((member) => !member.type.abstract)
-                        .map((member) => runtimeObjectType(objectType.filterFunction, member.type)), { on: ", " })}
+                        .map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
                 default:
-                    objectType;
+                    namedObjectType;
                     return [];
             }
         }),
-        ...(objectTypes.length > 0
+        ...(namedObjectTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectType: ${objectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -133,11 +135,11 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   if (query?.identifiers) {
     resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
     sortResources = false;
-  } else if (objectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
+  } else if (namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
     const identifierSet = new ${snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
-    for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
       for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
         if (!identifierSet.has(resource.identifier)) {
           identifierSet.add(resource.identifier);
@@ -168,7 +170,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
       identifierSet.add(quad.subject);
       const resource = resourceSet.resource(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object type
-      objectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+      namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
         resources.push({ object, resource });
       });
     }
@@ -183,14 +185,14 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   const objects: ObjectT[] = [];
   for (let { object, resource } of resources) {
     if (!object) {
-      const objectEither = objectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
+      const objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
       if (objectEither.isLeft()) {
         return objectEither;
       }
       object = objectEither.unsafeCoerce();
     }
 
-    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
       continue;
     }
 
@@ -208,7 +210,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
         ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectTypes: readonly ${objectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -219,22 +221,22 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
 
   const fromRdfResourceOptions: Parameters<${snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
 
-  let resources: { object?: ObjectT, objectType?: ${objectTypeType}, resource: ${imports.Resource} }[];
+  let resources: { object?: ObjectT, namedObjectType?: ${namedObjectTypeType}, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
   if (query?.identifiers) {
     resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
     sortResources = false;
-  } else if (objectTypes.every(objectType => objectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
+  } else if (namedObjectTypes.every(namedObjectType => namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
     const identifierSet = new ${snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
-    for (const objectType of objectTypes) {
-      for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const namedObjectType of namedObjectTypes) {
+      for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
         for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
           if (!identifierSet.has(resource.identifier)) {
             identifierSet.add(resource.identifier);
-            resources.push({ objectType, resource });
+            resources.push({ namedObjectType, resource });
           }
         }
       }
@@ -262,9 +264,9 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       identifierSet.add(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object types
       const resource = resourceSet.resource(quad.subject);
-      for (const objectType of objectTypes) {
-        if (objectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
-          resources.push({ object, objectType, resource });
+      for (const namedObjectType of namedObjectTypes) {
+        if (namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+          resources.push({ object, namedObjectType, resource });
         }).isRight()) {
           break;
         }
@@ -279,17 +281,17 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
 
   let objectI = 0;
   const objects: ObjectT[] = [];
-  for (let { object, objectType, resource } of resources) {
+  for (let { object, namedObjectType, resource } of resources) {
     if (!object) {
       let objectEither: ${imports.Either}<Error, ObjectT>;
-      if (objectType) {
-        objectEither = objectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
+      if (namedObjectType) {
+        objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
       } else {
         objectEither = ${imports.Left}(new Error("no object types"));
-        for (const tryObjectType of objectTypes) {
+        for (const tryObjectType of namedObjectTypes) {
           objectEither = tryObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
           if (objectEither.isRight()) {
-            objectType = tryObjectType;
+            namedObjectType = tryObjectType;
             break;
           }
         }
@@ -299,11 +301,11 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       }
       object = objectEither.unsafeCoerce();
     }
-    if (!objectType) {
-      throw new Error("objectType should be set here");
+    if (!namedObjectType) {
+      throw new Error("namedObjectType should be set here");
     }
 
-    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
       continue;
     }
 

package/dist/generators/ts/singleEntryRecord.d.ts

@@ -0,0 +1,2 @@
+export declare function singleEntryRecord<T>(key: string, value: T): Record<string, T>;
+//# sourceMappingURL=singleEntryRecord.d.ts.map

package/dist/generators/ts/singleEntryRecord.js

@@ -0,0 +1,6 @@
+export function singleEntryRecord(key, value) {
+    const record = {};
+    record[key] = value;
+    return record;
+}
+//# sourceMappingURL=singleEntryRecord.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.d.ts

@@ -1,8 +1,8 @@
+import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function sparqlObjectSetClassDeclaration({ objectTypes, namedObjectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
+export declare function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=sparqlObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -4,15 +4,15 @@ import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
-export function sparqlObjectSetClassDeclaration({ objectTypes, namedObjectUnionTypes, }) {
+export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     const parameters = {
-        constructObjectType: code `objectType: {\
+        constructObjectType: code `namedObjectType: {\
   ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
   ${syntheticNamePrefix}fromRdfResource:  ${snippets.FromRdfResourceFunction}<ObjectT>;
   ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
 }`,
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-        selectObjectTypeType: code `objectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
     const typeParameters = {
         ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
@@ -30,17 +30,17 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
     this.graph = options?.graph;
   }
 
-${joinCode([...objectTypes, ...namedObjectUnionTypes].flatMap((objectType) => {
-        if (!objectType.features.has("sparql")) {
+${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
+        if (!namedObjectType.features.has("sparql")) {
             return Object.values(unsupportedObjectSetMethodDeclarations({
-                objectType,
+                namedObjectType,
             }));
         }
         const methodSignatures = objectSetMethodSignatures({
-            objectType,
+            namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
         });
-        const runtimeObjectType = objectType.staticModuleName;
+        const runtimeObjectType = namedObjectType.staticModuleName;
         return [
             code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
@@ -48,15 +48,15 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
-  return this.${syntheticNamePrefix}objectCount<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
-  return this.${syntheticNamePrefix}objectIdentifiers<${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.${syntheticNamePrefix}objects<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.${syntheticNamePrefix}objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
         ];
     }), { on: "\n\n" })}
@@ -111,7 +111,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       offset = 0;
     }
 
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
@@ -139,12 +139,12 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
   protected async ${syntheticNamePrefix}objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
     return ${imports.EitherAsync}(async ({ liftEither }) => {
-      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(objectType, query));
+      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
-      const constructQueryString = objectType.${syntheticNamePrefix}sparqlConstructQueryString({
+      const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
         subject: this.${syntheticNamePrefix}objectVariable,
         where: [{
           type: "values" as const,
@@ -161,14 +161,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
   }
 
   protected async ${syntheticNamePrefix}objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(objectType, query);
+    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
@@ -210,7 +210,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
     }
 
-    patterns = patterns.concat(objectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 

package/dist/generators/ts/synthesizeUberObjectUnionType.d.ts

@@ -1,9 +1,9 @@
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { ObjectType } from "./ObjectType.js";
 /**
  * Synthesize the $Object union.
  */
 export declare function synthesizeUberObjectUnionType(parameters: {
-    objectTypes: readonly ObjectType[];
+    namedObjectTypes: readonly NamedObjectType[];
 }): NamedObjectUnionType;
 //# sourceMappingURL=synthesizeUberObjectUnionType.d.ts.map

package/dist/generators/ts/synthesizeUberObjectUnionType.js

@@ -9,10 +9,10 @@ import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
  * Synthesize the $Object union.
  */
 export function synthesizeUberObjectUnionType(parameters) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.extern);
-    invariant(objectTypes.length > 0);
-    const nodeKinds = objectTypes.reduce((nodeKinds, objectType) => {
-        for (const nodeKind of objectType.identifierType.nodeKinds) {
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
+    invariant(namedObjectTypes.length > 0);
+    const nodeKinds = namedObjectTypes.reduce((nodeKinds, namedObjectType) => {
+        for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
             nodeKinds.add(nodeKind);
         }
         return nodeKinds;
@@ -44,8 +44,8 @@ export function synthesizeUberObjectUnionType(parameters) {
     }
     return new NamedObjectUnionType({
         comment: Maybe.empty(),
-        features: objectTypes.reduce((features, objectType) => {
-            for (const feature of objectType.features) {
+        features: namedObjectTypes.reduce((features, namedObjectType) => {
+            for (const feature of namedObjectType.features) {
                 features.add(feature);
             }
             features.delete("graphql");
@@ -53,9 +53,9 @@ export function synthesizeUberObjectUnionType(parameters) {
         }, new Set()),
         identifierType,
         label: Maybe.empty(),
-        members: objectTypes.map((objectType) => ({
+        members: namedObjectTypes.map((namedObjectType) => ({
             discriminantValue: Maybe.empty(),
-            type: objectType,
+            type: namedObjectType,
         })),
         name: `${syntheticNamePrefix}Object`,
         recursive: false,

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -1,11 +1,11 @@
-import type { ObjectType } from "./ObjectType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function unsupportedObjectSetMethodDeclarations({ objectType, }: {
-    objectType: {
+export declare function unsupportedObjectSetMethodDeclarations({ namedObjectType, }: {
+    namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
         readonly name: string;
     };
-}): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, Code>>;
+}): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, Code>>;
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.d.ts.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -7,9 +7,9 @@ async ${name}(${parameters}): ${returnType} {
   return ${imports.Left}(new Error("${name}: not supported")) satisfies Awaited<${returnType}>;
 }`;
 }
-export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
+export function unsupportedObjectSetMethodDeclarations({ namedObjectType, }) {
     const methodSignatures = objectSetMethodSignatures({
-        objectType,
+        namedObjectType,
         parameterNamePrefix: "_",
     });
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.9",
+    "@shaclmate/shacl-ast": "4.0.11",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -51,8 +51,8 @@
     "dist/generators/json/*.js",
     "dist/generators/ts/*.d.ts",
     "dist/generators/ts/*.js",
-    "dist/generators/ts/_ObjectType/*.d.ts",
-    "dist/generators/ts/_ObjectType/*.js",
+    "dist/generators/ts/_NamedObjectType/*.d.ts",
+    "dist/generators/ts/_NamedObjectType/*.js",
     "dist/generators/ts/_snippets/*.d.ts",
     "dist/generators/ts/_snippets/*.js",
     "dist/input/*.d.ts",
@@ -78,5 +78,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.9"
+  "version": "4.0.11"
 }

package/dist/generators/ts/_ObjectType/ObjectType_classDeclaration.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_classDeclaration(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_classDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_createFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_createFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_createFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_equalsFunctionOrMethodDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_equalsFunctionOrMethodDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_equalsFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_filterFunctionDeclaration.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_filterFunctionDeclaration(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_filterFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_filterTypeDeclaration.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_filterTypeDeclaration(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_filterTypeDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_focusSparqlWherePatternsFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_fromJsonFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_fromRdfResourceFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_fromRdfResourceValuesFunctionDeclaration(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromRdfResourceValuesFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfTypeVariableStatement.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_fromRdfTypeVariableStatement(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_fromRdfTypeVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_graphqlTypeVariableStatement.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_graphqlTypeVariableStatement(this: ObjectType): Maybe<Code>;
-//# sourceMappingURL=ObjectType_graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_hashFunctionOrMethodDeclarations(this: ObjectType): readonly Code[];
-//# sourceMappingURL=ObjectType_hashFunctionOrMethodDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_interfaceDeclaration.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_interfaceDeclaration(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_interfaceDeclaration.d.ts.map