@shaclmate/compiler 4.0.29 → 4.0.31

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

package/dist/generators/ts/rdfjsTermExpression.js

@@ -1,19 +1,17 @@
 import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
-import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
-import { imports } from "./imports.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
-export function rdfjsTermExpression(rdfjsTerm, { logger }) {
+export function rdfjsTermExpression(rdfjsTerm) {
     switch (rdfjsTerm.termType) {
         case "BlankNode":
-            return code `${imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
         case "Literal":
             if (rdfjsTerm.datatype.equals(xsd.string)) {
                 if (rdfjsTerm.language.length === 0) {
-                    return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
+                    return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
                 }
-                return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
+                return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
             }
-            return code `${imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression(rdfjsTerm.datatype, { logger })})`;
+            return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression.call(this, rdfjsTerm.datatype)})`;
         case "NamedNode": {
             if (rdfjsTerm.value.startsWith(rdf[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
@@ -23,18 +21,18 @@ export function rdfjsTermExpression(rdfjsTerm, { logger }) {
                     case "rest":
                     case "subject":
                     case "type":
-                        return code `${snippets_RdfVocabularies}.rdf.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.rdf.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
                 }
             }
             else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
                 const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
                 switch (unqualifiedName) {
                     case "subClassOf":
-                        return code `${snippets_RdfVocabularies}.rdfs.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.rdfs.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
                 }
             }
             else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
@@ -60,15 +58,15 @@ export function rdfjsTermExpression(rdfjsTerm, { logger }) {
                     case "unsignedInt":
                     case "unsignedLong":
                     case "unsignedShort":
-                        return code `${snippets_RdfVocabularies}.xsd.${unqualifiedName}`;
+                        return code `${this.snippets.RdfVocabularies}.xsd.${unqualifiedName}`;
                     default:
-                        logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
+                        this.logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
                 }
             }
-            return code `${imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
         }
         case "Variable":
-            return code `${imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
+            return code `${this.imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
     }
 }
 //# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/sparqlObjectSetClassDeclaration.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 sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+export declare function sparqlObjectSetClassDeclaration(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -1,45 +1,43 @@
-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 sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     const parameters = {
         constructObjectType: code `namedObjectType: {\
-  ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
-  ${syntheticNamePrefix}fromRdfResource:  ${snippets.FromRdfResourceFunction}<ObjectT>;
-  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
+  focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
+  fromRdfResource:  ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
+  sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${this.reusables.imports.sparqljs}.GeneratorOptions) => string;
 }`,
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
-        selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
-    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }`;
+    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
     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}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
-  readonly #countVariable = ${imports.dataFactory}.variable!("count");;
-  readonly #graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  readonly #objectVariable = ${imports.dataFactory}.variable!("object");
+  readonly #countVariable = ${this.reusables.imports.dataFactory}.variable!("count");;
+  readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+  readonly #objectVariable = ${this.reusables.imports.dataFactory}.variable!("object");
   readonly #sparqlClient: ${sparqlClientType};
-  readonly #sparqlGenerator = new ${imports.sparqljs}.Generator();
+  readonly #sparqlGenerator = new ${this.reusables.imports.sparqljs}.Generator();
 
-  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}> }) {
     this.#graph = options?.graph;
     this.#sparqlClient = sparqlClient;
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
         if (!namedObjectType.features.has("sparql")) {
-            return Object.values(unsupportedObjectSetMethodDeclarations({
+            return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
                 namedObjectType,
             }));
         }
-        const methodSignatures = objectSetMethodSignatures({
+        const methodSignatures = objectSetMethodSignatures.call(this, {
             namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
         });
@@ -64,29 +62,29 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         ];
     }), { on: "\n\n" })}
 
-  #mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
+  #mapBindingsToCount(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): ${this.reusables.imports.Either}<Error, number> {
     if (bindings.length === 0) {
-      return ${imports.Left}(new Error("empty result rows"));
+      return ${this.reusables.imports.Left}(new Error("empty result rows"));
     }
     if (bindings.length > 1) {
-      return ${imports.Left}(new Error("more than one result row"));
+      return ${this.reusables.imports.Left}(new Error("more than one result row"));
     }
     const count = bindings[0][variable];
     if (count === undefined) {
-      return ${imports.Left}(new Error("no 'count' variable in result row"));
+      return ${this.reusables.imports.Left}(new Error("no 'count' variable in result row"));
     }
     if (count.termType !== "Literal") {
-      return ${imports.Left}(new Error("'count' variable is not a Literal"));
+      return ${this.reusables.imports.Left}(new Error("'count' variable is not a Literal"));
     }
     const parsedCount = Number.parseInt(count.value, 10);
     if (Number.isNaN(parsedCount)) {
-      return ${imports.Left}(new Error("'count' variable is NaN"));
+      return ${this.reusables.imports.Left}(new Error("'count' variable is NaN"));
     }
-    return ${imports.Right}(parsedCount);
+    return ${this.reusables.imports.Right}(parsedCount);
   }
 
-  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
-    const identifiers: ${imports.NamedNode}[] = [];
+  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): readonly ${this.reusables.imports.NamedNode}[] {
+    const identifiers: ${this.reusables.imports.NamedNode}[] = [];
     for (const bindings_ of bindings) {
       const identifier = bindings_[variable];
       if (
@@ -99,14 +97,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return identifiers;
   }
 
-  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectIdentifierT[]>> {
     if (query?.identifiers) {
-      return ${imports.Right}(query.identifiers);
+      return ${this.reusables.imports.Right}(query.identifiers);
     }
 
     const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
     if (limit <= 0) {
-      return ${imports.Right}([]);
+      return ${this.reusables.imports.Right}([]);
     }
 
     let offset = query?.offset ?? 0;
@@ -116,7 +114,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
     const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
-      return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
 
     const selectQueryString = \
@@ -132,7 +130,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         where: wherePatterns.concat()
       });
       
-    return ${imports.EitherAsync}(async () =>
+    return ${this.reusables.imports.EitherAsync}(async () =>
       this.#mapBindingsToIdentifiers(
         await this.#sparqlClient.queryBindings(selectQueryString),
         this.#objectVariable.value,
@@ -140,20 +138,20 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     );  
   }
 
-  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
-    return ${imports.EitherAsync}(async ({ liftEither }) => {
+  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectT[]>> {
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) => {
       const identifiers = await liftEither(await this.#objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
-      const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
+      const constructQueryString = namedObjectType.sparqlConstructQueryString({
         subject: this.#objectVariable,
         where: [{
           type: "values" as const,
           values: identifiers.map((identifier) => {
-            const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
-            valuePatternRow["?object"] = identifier as ${imports.NamedNode};
+            const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
+            valuePatternRow["?object"] = identifier as ${this.reusables.imports.NamedNode};
             return valuePatternRow;
           }),
         }]
@@ -161,19 +159,19 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
       const quads = await this.#sparqlClient.queryQuads(constructQueryString);
 
-      const dataset = ${imports.datasetFactory}.dataset(quads.concat());
+      const dataset = ${this.reusables.imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(namedObjectType.${syntheticNamePrefix}fromRdfResource(new ${imports.Resource}({ dataFactory: ${imports.dataFactory}, dataset: dataset, identifier: identifier as ${imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+        objects.push(await liftEither(namedObjectType.fromRdfResource(new ${this.reusables.imports.Resource}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: dataset, identifier: identifier as ${this.reusables.imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
   }
 
-  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
+  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, number>> {
     const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
-      return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
 
     const selectQueryString = \
@@ -195,7 +193,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         where: wherePatterns.concat()
       });
 
-    return ${imports.EitherAsync}(async ({ liftEither }) =>
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) =>
       liftEither(
         this.#mapBindingsToCount(
           await this.#sparqlClient.queryBindings(selectQueryString),
@@ -205,17 +203,17 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     );
   }
 
-  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
+  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${this.reusables.imports.sparqljs}.Pattern[] {
     // Patterns should be most to least specific.
-    let patterns: ${imports.sparqljs}.Pattern[] = [];
+    let patterns: ${this.reusables.imports.sparqljs}.Pattern[] = [];
 
     if (query?.where) {
       patterns = patterns.concat(query.where(this.#objectVariable));
     }
 
-    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
 
-    patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
+    patterns = ${this.reusables.snippets.normalizeSparqlWherePatterns}(patterns).concat();
 
     const graph = query?.graph ?? this.#graph;
     if (graph) {
@@ -227,12 +225,12 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       }
     }
     // Union of all graphs: { ... patterns covering default graph ... } UNION { GRAPH ?g { ... patterns covering named graphs ... } }
-    return [{ patterns: [{ patterns, type: "group" }, { name: ${imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
+    return [{ patterns: [{ patterns, type: "group" }, { name: ${this.reusables.imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
   }
 }
   
 export namespace ${syntheticNamePrefix}SparqlObjectSet {
-  export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${imports.Variable}) => readonly ${imports.sparqljs}.Pattern[] };
+  export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Pattern[] };
 }`;
 }
 //# sourceMappingURL=sparqlObjectSetClassDeclaration.js.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.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 unsupportedObjectSetMethodDeclarations({ namedObjectType, }: {
+export declare function unsupportedObjectSetMethodDeclarations(this: TsGenerator, { namedObjectType, }: {
     namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;