@shaclmate/compiler 4.0.29 → 4.0.30

package/dist/generators/ts/_snippets/snippets_termSchemaSparqlPatterns.js

@@ -1,27 +1,22 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-export const snippets_termSchemaSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}termSchemaSparqlPatterns`, code `\
+export const snippets_termSchemaSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSchemaSparqlPatterns`, code `\
 function ${syntheticNamePrefix}termSchemaSparqlPatterns({
   filterPatterns,
   propertyPatterns,
   schema,
   valueVariable
 }: {
-  filterPatterns: readonly ${snippets_SparqlFilterPattern}[],
-  propertyPatterns: readonly ${snippets_SparqlPattern}[];
+  filterPatterns: readonly ${snippets.SparqlFilterPattern}[],
+  propertyPatterns: readonly ${snippets.SparqlPattern}[];
   schema: Readonly<{
     in?: readonly (bigint | boolean | Date | string | number | ${imports.Literal} | ${imports.NamedNode})[];
   }>,
   valueVariable: ${imports.Variable};
-}): readonly ${snippets_SparqlPattern}[] {
-  let patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
+}): readonly ${snippets.SparqlPattern}[] {
+  let patterns: ${snippets.SparqlPattern}[] = propertyPatterns.concat();
 
   if (schema.in && schema.in.length > 0) {
-    patterns.push(${snippets_sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
+    patterns.push(${snippets.sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
   }
 
   return patterns.concat(filterPatterns);

package/dist/generators/ts/_snippets/snippets_termSparqlWherePatterns.d.ts

@@ -1,2 +1,3 @@
-export declare const snippets_termSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_termSparqlWherePatterns: SnippetFactory;
 //# sourceMappingURL=snippets_termSparqlWherePatterns.d.ts.map

package/dist/generators/ts/_snippets/snippets_termSparqlWherePatterns.js

@@ -1,11 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_TermFilter } from "./snippets_TermFilter.js";
-import { snippets_TermSchema } from "./snippets_TermSchema.js";
-import { snippets_termFilterSparqlPatterns } from "./snippets_termFilterSparqlPatterns.js";
-import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_termSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_TermFilter}, ${snippets_TermSchema}> =
-  (parameters) => ${snippets_termSchemaSparqlPatterns}({ filterPatterns: ${snippets_termFilterSparqlPatterns}(parameters), ...parameters })`);
+export const snippets_termSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.TermFilter}, ${snippets.TermSchema}> =
+  (parameters) => ${snippets.termSchemaSparqlPatterns}({ filterPatterns: ${snippets.termFilterSparqlPatterns}(parameters), ...parameters })`);
 //# sourceMappingURL=snippets_termSparqlWherePatterns.js.map

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -1,8 +1,9 @@
 import { Maybe } from "purify-ts";
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function graphqlSchemaVariableStatement(parameters: {
+export declare function graphqlSchemaVariableStatement(this: TsGenerator, parameters: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: NamedObjectUnionType[];
 }): Maybe<Code>;

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -1,21 +1,20 @@
 import { Maybe } from "purify-ts";
-import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 function graphqlQueryObjectType({ namedObjectTypes, namedObjectUnionTypes, }) {
-    return code `new ${imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
+    return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
         ...namedObjectTypes,
         ...namedObjectUnionTypes,
     ].reduce((fields, namedObjectType) => {
         fields[namedObjectType.objectSetMethodNames.object] = {
             args: {
                 identifier: {
-                    type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLID})`,
+                    type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID})`,
                 },
             },
             resolve: code `\
 async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
-  (await ${imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+  (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,
@@ -23,32 +22,32 @@ async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObj
         fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
             args: {
                 limit: {
-                    type: code `${imports.GraphQLInt}`,
+                    type: code `${this.reusables.imports.GraphQLInt}`,
                 },
                 offset: {
-                    type: code `${imports.GraphQLInt}`,
+                    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 ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${imports.GraphQLString}))`,
+            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 ${imports.GraphQLList}(new ${imports.GraphQLNonNull}(${imports.GraphQLID}))`,
+                    type: code `new ${this.reusables.imports.GraphQLList}(new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID}))`,
                 },
                 limit: {
-                    type: code `${imports.GraphQLInt}`,
+                    type: code `${this.reusables.imports.GraphQLInt}`,
                 },
                 offset: {
-                    type: code `${imports.GraphQLInt}`,
+                    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 ${imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+(await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
   let filter: ${namedObjectType.filterType} | undefined;
   if (args.identifiers) {
     const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
@@ -59,12 +58,12 @@ async (_source, args: { identifiers: readonly string[] | null; limit: number | n
   }
   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 ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
+            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 ${imports.GraphQLNonNull}(${imports.GraphQLInt})`,
+            type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLInt})`,
         };
         return fields;
     }, {})} })`;
@@ -76,7 +75,7 @@ export function graphqlSchemaVariableStatement(parameters) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ namedObjectTypes: namedObjectTypes, namedObjectUnionTypes })} });
+export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${graphqlQueryObjectType.call(this, { namedObjectTypes: namedObjectTypes, namedObjectUnionTypes })} });
 `);
 }
 //# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/objectSetDeclarations.d.ts

@@ -1,7 +1,8 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Code } from "./ts-poet-wrapper.js";
-export declare function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }: {
+export declare function objectSetDeclarations(this: TsGenerator, { namedObjectUnionTypes, ...parameters }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): readonly Code[];

package/dist/generators/ts/objectSetDeclarations.js

@@ -38,19 +38,19 @@ export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters })
         return [];
     }
     const declarations = [
-        objectSetInterfaceDeclaration({
+        objectSetInterfaceDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }),
     ];
     if (namedObjectTypesWithRdfFeatureCount > 0) {
-        declarations.push(rdfjsDatasetObjectSetClassDeclaration({
+        declarations.push(rdfjsDatasetObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));
     }
     if (namedObjectTypesWithSparqlFeatureCount > 0) {
-        declarations.push(sparqlObjectSetClassDeclaration({
+        declarations.push(sparqlObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));

package/dist/generators/ts/objectSetInterfaceDeclaration.d.ts

@@ -1,7 +1,8 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+export declare function objectSetInterfaceDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -1,4 +1,3 @@
-import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
@@ -6,17 +5,17 @@ export function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUni
     return code `\
 export interface ${syntheticNamePrefix}ObjectSet {
   ${joinCode(namedObjectTypes
-        .flatMap((namedObjectType) => Object.values(objectSetMethodSignatures({ namedObjectType })))
-        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures({
+        .flatMap((namedObjectType) => Object.values(objectSetMethodSignatures.call(this, { namedObjectType })))
+        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures.call(this, {
         namedObjectType: namedObjectUnionType,
     }))))
         .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
 }
 
 export namespace ${syntheticNamePrefix}ObjectSet {
-  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}> {
+  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}> {
     readonly filter?: ObjectFilterT;
-    readonly graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    readonly graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
     readonly identifiers?: readonly ObjectIdentifierT[];
     readonly limit?: number;
     readonly offset?: number;

package/dist/generators/ts/objectSetMethodSignatures.d.ts

@@ -1,6 +1,7 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetMethodSignatures(parameters: {
+export declare function objectSetMethodSignatures(this: TsGenerator, parameters: {
     namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -1,4 +1,3 @@
-import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export function objectSetMethodSignatures(parameters) {
@@ -10,22 +9,22 @@ export function objectSetMethodSignatures(parameters) {
         object: {
             name: methodNames.object,
             parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-            returnType: code `Promise<${imports.Either}<Error, ${namedObjectType.name}>>`,
+            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<${imports.Either}<Error, number>>`,
+            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<${imports.Either}<Error, readonly ${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<${imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
+            returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
         },
     };
 }

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

@@ -1,7 +1,8 @@
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+export declare function rdfjsDatasetObjectSetClassDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,15 +1,13 @@
-import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-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({ namedObjectTypes, namedObjectUnionTypes, }) {
     const namedObjectTypeType = code `\
 {
-  ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-  ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<ObjectT>;
-  ${syntheticNamePrefix}fromRdfTypes: readonly ${imports.NamedNode}[]
+  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>`,
@@ -17,16 +15,16 @@ export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedO
     const typeParameters = {
         ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
-        ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
+        ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
     };
     return code `\
 export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticNamePrefix}ObjectSet {
-  protected readonly ${syntheticNamePrefix}graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  readonly #dataset: ${imports.DatasetCore} | (() => ${imports.DatasetCore});
+  readonly #dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore});
+  readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
 
-  constructor(dataset: ${imports.DatasetCore} | (() => ${imports.DatasetCore}), options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+  constructor(dataset: ${this.reusables.imports.DatasetCore} | (() => ${this.reusables.imports.DatasetCore}), options?: { graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}> }) {
     this.#dataset = dataset;
-    this.${syntheticNamePrefix}graph = options?.graph;
+    this.#graph = options?.graph;
   }
 
   protected ${syntheticNamePrefix}dataset(): DatasetCore {
@@ -36,18 +34,18 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
     return this.#dataset();
   }
 
-  protected ${syntheticNamePrefix}resourceSet(): ${imports.ResourceSet} {
-    return new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: this.${syntheticNamePrefix}dataset() });
+  protected ${syntheticNamePrefix}resourceSet(): ${this.reusables.imports.ResourceSet} {
+    return new ${this.reusables.imports.ResourceSet}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: this.${syntheticNamePrefix}dataset() });
   }
 
   ${joinCode([
         ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
             if (!namedObjectType.features.has("rdf")) {
-                return Object.values(unsupportedObjectSetMethodDeclarations({
+                return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
                     namedObjectType,
                 }));
             }
-            const methodSignatures = objectSetMethodSignatures({
+            const methodSignatures = objectSetMethodSignatures.call(this, {
                 namedObjectType,
             });
             const delegatingMethods = [
@@ -58,7 +56,7 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
                 // objectSync
                 code `\
-${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${namedObjectType.name}> {
+${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
@@ -68,7 +66,7 @@ async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parame
 }`,
                 // objectCountSync
                 code `\
-${methodSignatures.objectCount.name}Sync(${methodSignatures.objectCount.parameters}): ${imports.Either}<Error, number> {
+${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
@@ -78,7 +76,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
 }`,
                 // objectIdentifiersSync
                 code `\
-${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
+${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
@@ -92,18 +90,18 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                 const fromRdfTypes = namedObjectType.fromRdfTypeVariable
                     .toList()
                     .concat(namedObjectType.descendantFromRdfTypeVariables);
-                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdfResource: ${namedObjectType.name}.${syntheticNamePrefix}fromRdfResource, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                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}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+${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 `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
+${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);
@@ -116,28 +114,28 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
         ...(namedObjectTypes.length > 0
             ? [
                 code `\
-#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
-  const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
+#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${this.reusables.imports.Either}<Error, readonly ObjectT[]> {
+  const graph = query?.graph ?? this.#graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
-  if (limit <= 0) { return ${imports.Right}([]); }
+  if (limit <= 0) { return ${this.reusables.imports.Right}([]); }
 
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
-  const fromRdfResourceOptions: Parameters<${snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+  const fromRdfResourceOptions: Parameters<${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
 
-  let resources: { object?: ObjectT, resource: ${imports.Resource} }[];
+  let resources: { object?: ObjectT, resource: ${this.reusables.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 (namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
-    const identifierSet = new ${snippets.IdentifierSet}();
+  } else if (namedObjectType.fromRdfTypes.length > 0) {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
-    for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
+    for (const fromRdfType of namedObjectType.fromRdfTypes) {
       for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
         if (!identifierSet.has(resource.identifier)) {
           identifierSet.add(resource.identifier);
@@ -146,7 +144,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
       }
     }
   } else {
-    const identifierSet = new ${snippets.IdentifierSet}();
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
     for (const quad of resourceSet.dataset) {
@@ -168,7 +166,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
       identifierSet.add(quad.subject);
       const resource = resourceSet.resource(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object type
-      namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+      namedObjectType.fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
         resources.push({ object, resource });
       });
     }
@@ -183,54 +181,54 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   const objects: ObjectT[] = [];
   for (let { object, resource } of resources) {
     if (!object) {
-      const objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
+      const objectEither = namedObjectType.fromRdfResource(resource, fromRdfResourceOptions);
       if (objectEither.isLeft()) {
         return objectEither;
       }
       object = objectEither.unsafeCoerce();
     }
 
-    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.filter(query.filter, object)) {
       continue;
     }
 
     if (objectI++ >= offset) {
       objects.push(object);
       if (objects.length === limit) {
-        return ${imports.Right}(objects);
+        return ${this.reusables.imports.Right}(objects);
       }
     }
   }
-  return ${imports.Right}(objects);
+  return ${this.reusables.imports.Right}(objects);
   }`,
             ]
             : []),
         ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
-  const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
+#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;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
-  if (limit <= 0) { return ${imports.Right}([]); }
+  if (limit <= 0) { return ${this.reusables.imports.Right}([]); }
 
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
-  const fromRdfResourceOptions: Parameters<${snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+  const fromRdfResourceOptions: Parameters<${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>>[1] = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
 
-  let resources: { object?: ObjectT, namedObjectType?: ${namedObjectTypeType}, resource: ${imports.Resource} }[];
+  let resources: { object?: ObjectT, namedObjectType?: ${namedObjectTypeType}, resource: ${this.reusables.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 (namedObjectTypes.every(namedObjectType => namedObjectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
-    const identifierSet = new ${snippets.IdentifierSet}();
+  } else if (namedObjectTypes.every(namedObjectType => namedObjectType.fromRdfTypes.length > 0)) {
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
     for (const namedObjectType of namedObjectTypes) {
-      for (const fromRdfType of namedObjectType.${syntheticNamePrefix}fromRdfTypes) {
+      for (const fromRdfType of namedObjectType.fromRdfTypes) {
         for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
           if (!identifierSet.has(resource.identifier)) {
             identifierSet.add(resource.identifier);
@@ -240,7 +238,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
       }
     }
   } else {
-    const identifierSet = new ${snippets.IdentifierSet}();
+    const identifierSet = new ${this.reusables.snippets.IdentifierSet}();
     resources = [];
     sortResources = true;
     for (const quad of resourceSet.dataset) {
@@ -263,7 +261,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
       // Eagerly eliminate the majority of resources that won't match the object types
       const resource = resourceSet.resource(quad.subject);
       for (const namedObjectType of namedObjectTypes) {
-        if (namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
+        if (namedObjectType.fromRdfResource(resource, fromRdfResourceOptions).ifRight(object => {
           resources.push({ object, namedObjectType, resource });
         }).isRight()) {
           break;
@@ -281,13 +279,13 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
   const objects: ObjectT[] = [];
   for (let { object, namedObjectType, resource } of resources) {
     if (!object) {
-      let objectEither: ${imports.Either}<Error, ObjectT>;
+      let objectEither: ${this.reusables.imports.Either}<Error, ObjectT>;
       if (namedObjectType) {
-        objectEither = namedObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
+        objectEither = namedObjectType.fromRdfResource(resource, fromRdfResourceOptions);
       } else {
-        objectEither = ${imports.Left}(new Error("no object types"));
+        objectEither = ${this.reusables.imports.Left}(new Error("no object types"));
         for (const tryObjectType of namedObjectTypes) {
-          objectEither = tryObjectType.${syntheticNamePrefix}fromRdfResource(resource, fromRdfResourceOptions);
+          objectEither = tryObjectType.fromRdfResource(resource, fromRdfResourceOptions);
           if (objectEither.isRight()) {
             namedObjectType = tryObjectType;
             break;
@@ -303,18 +301,18 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
       throw new Error("namedObjectType should be set here");
     }
 
-    if (query?.filter && !namedObjectType.${syntheticNamePrefix}filter(query.filter, object)) {
+    if (query?.filter && !namedObjectType.filter(query.filter, object)) {
       continue;
     }
 
     if (objectI++ >= offset) {
       objects.push(object);
       if (objects.length === limit) {
-        return ${imports.Right}(objects);
+        return ${this.reusables.imports.Right}(objects);
       }
     }
   }
-  return ${imports.Right}(objects);
+  return ${this.reusables.imports.Right}(objects);
 }`,
             ]
             : []),

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -1,7 +1,11 @@
 import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Logger } from "ts-log";
+import type { Imports } from "./Imports.js";
+import type { Snippets } from "./Snippets.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">, { logger }: {
+export declare function rdfjsTermExpression(this: {
+    imports: Imports;
     logger: Logger;
-}): Code;
+    snippets: Snippets;
+}, rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): Code;
 //# sourceMappingURL=rdfjsTermExpression.d.ts.map