@shaclmate/compiler 4.0.36 → 4.0.38

package/dist/ShapesGraphToAstTransformer.js

@@ -143,6 +143,16 @@ export class ShapesGraphToAstTransformer {
             }
         }
         return Either.of({
+            lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
+                switch (astType.kind) {
+                    case "LazyObjectType":
+                    case "LazyObjectOptionType":
+                    case "LazyObjectSetType":
+                        return acc + 1;
+                    default:
+                        return acc;
+                }
+            }, 0),
             namedIntersectionTypes: astNamedIntersectionTypes,
             namedObjectTypes: astObjectTypes.concat(Object.values(syntheticAstObjectTypesByName)),
             namedUnionTypes: astNamedUnionTypes,

package/dist/ast/Ast.d.ts

@@ -2,6 +2,7 @@ import type { IntersectionType } from "./IntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { UnionType } from "./UnionType.js";
 export interface Ast {
+    readonly lazyTypesCount: number;
     readonly namedIntersectionTypes: readonly IntersectionType[];
     readonly namedObjectTypes: readonly ObjectType[];
     readonly namedUnionTypes: readonly UnionType[];

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -132,8 +132,12 @@ export namespace Json {
         return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
     }
     jsonSchema({ context, }) {
         const expression = code `${this.name}.Json.schema()`;

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -0,0 +1,35 @@
+import type { Logger } from "ts-log";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractObjectSetType {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
+    protected readonly namedObjectTypes: readonly NamedObjectType[];
+    protected readonly namedObjectUnionTypes: readonly NamedObjectUnionType[];
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly NamedObjectType[];
+        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        reusables: Reusables;
+    });
+    abstract readonly declaration: Code;
+    protected methodSignatures(namedObjectType: {
+        readonly filterType: Code;
+        readonly identifierTypeAlias: Code;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    }, options?: {
+        parameterNamePrefix?: string;
+        queryT?: string;
+    }): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
+        readonly name: string;
+        readonly parameters: Code;
+        readonly returnType: Code;
+    }>>;
+}
+//# sourceMappingURL=AbstractObjectSetType.d.ts.map

package/dist/generators/ts/AbstractObjectSetType.js

@@ -0,0 +1,44 @@
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractObjectSetType {
+    configuration;
+    logger;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    methodSignatures(namedObjectType, options) {
+        const parameterNamePrefix = options?.parameterNamePrefix ?? "";
+        const queryT = options?.queryT ??
+            `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
+        const methodNames = namedObjectType.objectSetMethodNames;
+        return {
+            object: {
+                name: methodNames.object,
+                parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name}>>`,
+            },
+            objectCount: {
+                name: methodNames.objectCount,
+                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
+            },
+            objectIdentifiers: {
+                name: methodNames.objectIdentifiers,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
+            },
+            objects: {
+                name: methodNames.objects,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
+            },
+        };
+    }
+}
+//# sourceMappingURL=AbstractObjectSetType.js.map

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

@@ -0,0 +1,22 @@
+import type { Logger } from "ts-log";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class GraphqlSchema {
+    private readonly configuration;
+    private readonly reusables;
+    private readonly namedObjectTypes;
+    private readonly namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly NamedObjectType[];
+        namedObjectUnionTypes: readonly NamedObjectUnionType[];
+        reusables: Reusables;
+    });
+    get declaration(): Code;
+    private get graphqlQueryObjectType();
+}
+//# sourceMappingURL=GraphqlSchema.d.ts.map

package/dist/generators/ts/GraphqlSchema.js

@@ -0,0 +1,87 @@
+import { code } from "./ts-poet-wrapper.js";
+export class GraphqlSchema {
+    configuration;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    get declaration() {
+        return code `\
+export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${this.graphqlQueryObjectType} });
+`;
+    }
+    get graphqlQueryObjectType() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
+            ...this.namedObjectTypes,
+            ...this.namedObjectUnionTypes,
+        ].reduce((fields, namedObjectType) => {
+            fields[namedObjectType.objectSetMethodNames.object] = {
+                args: {
+                    identifier: {
+                        type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID})`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
+    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+      liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
+    )).unsafeCoerce()`,
+                type: namedObjectType.graphqlType.name,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
+                args: {
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+   async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
+    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.stringify)`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${this.reusables.imports.GraphQLString}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objects] = {
+                args: {
+                    identifiers: {
+                        type: code `new ${this.reusables.imports.GraphQLList}(new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID}))`,
+                    },
+                    limit: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                    offset: {
+                        type: code `${this.reusables.imports.GraphQLInt}`,
+                    },
+                },
+                resolve: code `\
+  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
+  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+    let filter: ${namedObjectType.filterType} | undefined;
+    if (args.identifiers) {
+      const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
+      for (const identifierArg of args.identifiers) {
+        identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.parse(identifierArg)));
+      }
+      filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
+    }
+    return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
+  })).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
+            };
+            fields[namedObjectType.objectSetMethodNames.objectCount] = {
+                resolve: code `\
+  async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLInt})`,
+            };
+            return fields;
+        }, {})} })`;
+    }
+}
+//# sourceMappingURL=GraphqlSchema.js.map

package/dist/generators/ts/NamedObjectType.js

@@ -212,8 +212,12 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues, ...options } = variables;
-        return code `${this.name}.fromRdfResourceValues(${resourceValues}, ${options})`;
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;

package/dist/generators/ts/ObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class ObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=ObjectSetType.d.ts.map

package/dist/generators/ts/ObjectSetType.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class ObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `\
+export interface ${syntheticNamePrefix}ObjectSet {
+  ${joinCode(this.namedObjectTypes
+            .flatMap((namedObjectType) => Object.values(this.methodSignatures(namedObjectType)))
+            .concat(this.namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(this.methodSignatures(namedObjectUnionType))))
+            .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
+}
+
+export namespace ${syntheticNamePrefix}ObjectSet {
+  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}> {
+    readonly filter?: ObjectFilterT;
+    readonly graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+    readonly identifiers?: readonly ObjectIdentifierT[];
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly preferredLanguages?: readonly string[];
+  }
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], ObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=ObjectSetType.js.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=RdfjsDatasetObjectSetType.d.ts.map

package/dist/generators/ts/{rdfjsDatasetObjectSetClassDeclaration.js → RdfjsDatasetObjectSetType.js}

@@ -1,22 +1,30 @@
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const namedObjectTypeType = code `\
+export class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const namedObjectTypeType = code `\
 {
   filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
   fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
   fromRdfTypes: readonly ${this.reusables.imports.NamedNode}[]
 }`;
-    const parameters = {
-        query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-    };
-    const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
-        ObjectFilterT: code `ObjectFilterT`,
-        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
-    };
-    return code `\
+        const parameters = {
+            query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+        };
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
 export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticNamePrefix}ObjectSet {
   readonly #dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore});
   readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
@@ -38,76 +46,74 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
   }
 
   ${joinCode([
-        ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-            const methodSignatures = objectSetMethodSignatures.call(this, {
-                namedObjectType,
-            });
-            const delegatingMethods = [
-                // object
-                code `\
+            ...[...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+                const methodSignatures = this.methodSignatures(namedObjectType);
+                const delegatingMethods = [
+                    // object
+                    code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
   return this.${methodSignatures.object.name}Sync(identifier, options);
 }`,
-                // objectSync
-                code `\
+                    // objectSync
+                    code `\
 ${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.name}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
-                // objectCount
-                code `\
+                    // objectCount
+                    code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
   return this.${methodSignatures.objectCount.name}Sync(query);
 }`,
-                // objectCountSync
-                code `\
+                    // objectCountSync
+                    code `\
 ${methodSignatures.objectCount.name}Sync(${methodSignatures.objectCount.parameters}): ${this.reusables.imports.Either}<Error, number> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.length);
 }`,
-                // objectIdentifiers
-                code `\
+                    // objectIdentifiers
+                    code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
   return this.${methodSignatures.objectIdentifiers.name}Sync(query);
 }`,
-                // objectIdentifiersSync
-                code `\
+                    // objectIdentifiersSync
+                    code `\
 ${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
   return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier()));
 }`,
-                // objects
-                code `\
+                    // objects
+                    code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
   return this.${methodSignatures.objects.name}Sync(query);
 }`,
-                // objectsSync has per-object type logic, not just forwarding
-            ];
-            const runtimeObjectType = (filterFunction, namedObjectType) => {
-                const fromRdfTypes = namedObjectType.fromRdfTypeVariable
-                    .toList()
-                    .concat(namedObjectType.descendantFromRdfTypeVariables);
-                return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
-            };
-            switch (namedObjectType.kind) {
-                case "NamedObjectType": {
-                    return delegatingMethods.concat(code `\
+                    // objectsSync has per-object type logic, not just forwarding
+                ];
+                const runtimeObjectType = (filterFunction, namedObjectType) => {
+                    const fromRdfTypes = namedObjectType.fromRdfTypeVariable
+                        .toList()
+                        .concat(namedObjectType.descendantFromRdfTypeVariables);
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                };
+                switch (namedObjectType.kind) {
+                    case "NamedObjectType": {
+                        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);
 }`);
-                }
-                case "NamedObjectUnionType":
-                    return delegatingMethods.concat(code `\
+                    }
+                    case "NamedObjectUnionType":
+                        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}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
-                default:
-                    namedObjectType;
-                    return [];
-            }
-        }),
-        ...(namedObjectTypes.length > 0
-            ? [
-                code `\
+                    default:
+                        namedObjectType;
+                        return [];
+                }
+            }),
+            ...(this.namedObjectTypes.length > 0
+                ? [
+                    code `\
 #objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.#graph;
 
@@ -195,11 +201,11 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }
   return ${this.reusables.imports.Right}(objects);
   }`,
-            ]
-            : []),
-        ...(namedObjectUnionTypes.length > 0
-            ? [
-                code `\
+                ]
+                : []),
+            ...(this.namedObjectUnionTypes.length > 0
+                ? [
+                    code `\
 #objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.#graph;
 
@@ -308,9 +314,13 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   }
   return ${this.reusables.imports.Right}(objects);
 }`,
-            ]
-            : []),
-    ], { on: "\n\n" })}
+                ]
+                : []),
+        ], { on: "\n\n" })}
 }`;
+    }
 }
-//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.js.map
+__decorate([
+    Memoize()
+], RdfjsDatasetObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=RdfjsDatasetObjectSetType.js.map

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

@@ -124,6 +124,7 @@ export declare class Snippets {
     get maybeEquals(): Snippet;
     get maybeSparqlConstructTriples(): Snippet;
     get maybeSparqlWherePatterns(): Snippet;
+    get monkeyPatchObject(): Snippet;
     get normalizeSparqlWherePatterns(): Snippet;
     get numericSparqlWherePatterns(): Snippet;
     get parseBlankNode(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -99,6 +99,7 @@ import { snippets_MaybeSchema } from "./_snippets/snippets_MaybeSchema.js";
 import { snippets_maybeEquals } from "./_snippets/snippets_maybeEquals.js";
 import { snippets_maybeSparqlConstructTriples } from "./_snippets/snippets_maybeSparqlConstructTriples.js";
 import { snippets_maybeSparqlWherePatterns } from "./_snippets/snippets_maybeSparqlWherePatterns.js";
+import { snippets_monkeyPatchObject } from "./_snippets/snippets_monkeyPatchObject.js";
 import { snippets_NumericFilter } from "./_snippets/snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./_snippets/snippets_NumericSchema.js";
 import { snippets_normalizeSparqlWherePatterns } from "./_snippets/snippets_normalizeSparqlWherePatterns.js";
@@ -505,6 +506,9 @@ export class Snippets {
     get maybeSparqlWherePatterns() {
         return this.snippet(snippets_maybeSparqlWherePatterns);
     }
+    get monkeyPatchObject() {
+        return this.snippet(snippets_monkeyPatchObject);
+    }
     get normalizeSparqlWherePatterns() {
         return this.snippet(snippets_normalizeSparqlWherePatterns);
     }
@@ -931,6 +935,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "maybeSparqlWherePatterns", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "monkeyPatchObject", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "normalizeSparqlWherePatterns", null);

package/dist/generators/ts/SparqlObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=SparqlObjectSetType.d.ts.map