@shaclmate/compiler 4.0.29 → 4.0.31

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

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

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

@@ -1,12 +1,9 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
-export const snippets_sparqlPropertyPath = conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
+export const snippets_sparqlPropertyPath = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
 /**
- * Convert a ${snippets_PropertyPath} to a ${imports.sparqljs}.PropertyPath.
+ * Convert a ${snippets.PropertyPath} to a ${imports.sparqljs}.PropertyPath.
  */  
-function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${snippets_PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
+function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${snippets.PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
   switch (propertyPath.termType) {
     case "AlternativePath":
       return {

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

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

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

@@ -1,10 +1,6 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_literalFactory } from "./snippets_literalFactory.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-export const snippets_sparqlValueInPattern = conditionalOutput(`${syntheticNamePrefix}sparqlValueInPattern`, code `\
-function ${syntheticNamePrefix}sparqlValueInPattern({ lift, valueIn, valueVariable }: { lift?: boolean, valueIn: readonly (bigint | boolean | Date | number | string | ${imports.Literal} | ${imports.NamedNode})[], valueVariable: ${imports.Variable}}): ${snippets_SparqlFilterPattern} {
+export const snippets_sparqlValueInPattern = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlValueInPattern`, code `\
+function ${syntheticNamePrefix}sparqlValueInPattern({ lift, valueIn, valueVariable }: { lift?: boolean, valueIn: readonly (bigint | boolean | Date | number | string | ${imports.Literal} | ${imports.NamedNode})[], valueVariable: ${imports.Variable}}): ${snippets.SparqlFilterPattern} {
   if (valueIn.length === 0) {
     throw new RangeError("expected valueIn not to be empty");
   }
@@ -13,7 +9,7 @@ function ${syntheticNamePrefix}sparqlValueInPattern({ lift, valueIn, valueVariab
     expression: {
       args: [valueVariable, valueIn.map(inValue => {
         if (typeof inValue !== "object" || inValue instanceof Date) {
-          return ${snippets_literalFactory}.primitive(inValue);
+          return ${snippets.literalFactory}.primitive(inValue);
         }
         return inValue;
       })],

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

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

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

@@ -1,14 +1,12 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_EqualsResult } from "./snippets_EqualsResult.js";
-export const snippets_strictEquals = conditionalOutput(`${syntheticNamePrefix}strictEquals`, code `\
+export const snippets_strictEquals = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}strictEquals`, code `\
 /**
- * Compare two values for strict equality (===), returning an ${snippets_EqualsResult} rather than a boolean.
+ * Compare two values for strict equality (===), returning an ${snippets.EqualsResult} rather than a boolean.
  */
 function ${syntheticNamePrefix}strictEquals<T extends bigint | boolean | number | string>(
   left: T,
   right: T,
-): ${snippets_EqualsResult} {
-  return ${snippets_EqualsResult}.fromBooleanEqualsResult(left, right, left === right);
+): ${snippets.EqualsResult} {
+  return ${snippets.EqualsResult}.fromBooleanEqualsResult(left, right, left === right);
 }`);
 //# sourceMappingURL=snippets_strictEquals.js.map

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

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

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

@@ -1,20 +1,12 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_literalFactory } from "./snippets_literalFactory.js";
-import { snippets_literalSchemaSparqlPatterns } from "./snippets_literalSchemaSparqlPatterns.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_StringFilter } from "./snippets_StringFilter.js";
-import { snippets_StringSchema } from "./snippets_StringSchema.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_stringSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_StringFilter}, ${snippets_StringSchema}> =
+export const snippets_stringSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}> =
   ({ filter, valueVariable, ...otherParameters }) => {
-    const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+    const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 
     if (filter) {
       if (filter.in !== undefined && filter.in.length > 0) {
-        filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+        filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
       }
 
       if (filter.maxLength !== undefined) {
@@ -22,7 +14,7 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
           expression: {
             type: "operation",
             operator: "<=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.maxLength)],
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.maxLength)],
           },
           lift: true,
           type: "filter",
@@ -34,7 +26,7 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
           expression: {
             type: "operation",
             operator: ">=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.minLength)],
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.minLength)],
           },
           lift: true,
           type: "filter",
@@ -42,6 +34,6 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
       }
     }
 
-    return ${snippets_literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+    return ${snippets.literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

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

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

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

@@ -1,16 +1,11 @@
-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_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-import { snippets_TermFilter } from "./snippets_TermFilter.js";
-export const snippets_termFilterSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
-function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets_TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets_SparqlFilterPattern}[] {
+export const snippets_termFilterSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
+function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets.TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
   if (!filter) {
     return [];
   }
 
-  const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 
   if (
     filter.datatypeIn !== undefined &&
@@ -31,7 +26,7 @@ function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable
   }
 
   if (filter.in !== undefined && filter.in.length > 0) {
-    filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+    filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
   }
 
   if (

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

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

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/_snippets/snippets_wrap_FromRdfResourceFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_wrap_FromRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,10 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_FromRdfResourceFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_FromRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_FromRdfResourceFunction<T>(_fromRdfResourceFunction: ${snippets._FromRdfResourceFunction}<T>): ${snippets.FromRdfResourceFunction}<T> {
+  return (resource, options) => {
+    let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});
+    if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); };
+    return _fromRdfResourceFunction(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages });
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.js.map

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

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_wrap_ToRdfResourceFunction: SnippetFactory;
+//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.d.ts.map

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_ToRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<ObjectT, IdentifierT> {
+  return (object, options) => {
+    let { graph, ignoreRdfType = false, resourceSet } = (options ?? {});
+    if (!resourceSet) {
+      resourceSet = new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });
+    }
+    const resource = resourceSet.resource(object.${syntheticNamePrefix}identifier());
+    _toRdfResourceFunction({ graph, ignoreRdfType, object, resource, resourceSet });
+    return resource;
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.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;