@shaclmate/compiler 4.0.4 → 4.0.6

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -59,10 +59,10 @@ export class AbstractLazyObjectType extends AbstractType {
         }}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ schema: schema.partial(), ...otherParameters }))`;
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ schema: schema.partial(), ...otherParameters }))`;
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partial() }))`;
     }
     get schemaObject() {
         return {

package/dist/generators/ts/AbstractType.d.ts

@@ -69,23 +69,23 @@ export declare abstract class AbstractType {
      * A SparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property of this type.
      *
      * The function takes a parameters object (type: SparqlConstructTriplesFunctionParameters) with the following parameters:
-     * - filter?: an instance of filterType
-     * - ignoreRdfType?: boolean
+     * - filter: an instance of filterType | undefined
+     * - ignoreRdfType: boolean
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
-     * - variablePrefix: prefix to use for new variables
+     * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly sparqlConstructTriplesFunction: Code;
     /**
      * A SparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property of this type.
      *
      * The function takes a parameters object (type: SparqlWherePatternsFunctionParameters) with the following parameters:
-     * - filter?: an instance of filterType
-     * - preferredLanguages: array of preferred language code (strings); may be empty
+     * - filter: an instance of filterType | undefined
+     * - preferredLanguages: array of preferred language code (strings) | undefined
      * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
      * - schema: instance of this.schemaType
      * - valueVariable: rdfjs.Variable of the value of this type
-     * - variablePrefix: prefix to use for new variables
+     * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly sparqlWherePatternsFunction: Code;
     /**

package/dist/generators/ts/LazyObjectOptionType.js

@@ -75,7 +75,7 @@ export class LazyObjectOptionType extends Super {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

package/dist/generators/ts/LazyObjectSetType.js

@@ -66,7 +66,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers }) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifiers, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers, ...options }) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `(${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).then(either => either.unsafeCoerce())`;

package/dist/generators/ts/LazyObjectType.js

@@ -50,7 +50,7 @@ export class LazyObjectType extends AbstractLazyObjectType {
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier) })))`;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier, options) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier, options) })))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;

package/dist/generators/ts/ObjectType.js

@@ -201,10 +201,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `typeof ${this.schema}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ ignoreRdfType: ignoreRdfType ?? true, ...otherParameters }))`;
+        return code `(({ filter, ignoreRdfType, valueVariable, variablePrefix }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, ...otherParameters })))`;
+        return code `(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })))`;
     }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {

package/dist/generators/ts/ObjectUnionType.js

@@ -120,10 +120,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `typeof ${this.schema}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(otherParameters))`;
+        return code `(({ ignoreRdfType, schema, valueVariable, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ ...otherParameters, focusIdentifier: valueVariable, ignoreRdfType: false }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ...otherParameters })))`;
+        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({  ...otherParameters, focusIdentifier: valueVariable, ignoreRdfType: false })))`;
     }
     get staticModuleName() {
         return this.name;

package/dist/generators/ts/UnionType.js

@@ -294,7 +294,7 @@ ${memberType.discriminantValues.map((discriminantValue) => `case "${discriminant
   let triples: ${imports.sparqljs}.Triple[] = [];
 
   ${joinCode(this.memberTypes.map((memberType) => code `\
-triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }));`))}
+triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }));`))}
   
   return triples;
 })`;
@@ -305,7 +305,7 @@ triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ filter:
   const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
 
   ${joinCode(this.memberTypes.map((memberType) => code `\
-unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }).concat(), type: "group" });`))}
+unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
 })`;

package/dist/generators/ts/_ObjectType/IdentifierProperty.js

@@ -300,6 +300,7 @@ export class IdentifierProperty extends AbstractProperty {
             condition: code `${variables.focusIdentifier}.termType === "Variable"`,
             patterns: code `${this.type.sparqlWherePatternsFunction}(${{
                 filter: code `${variables.filter}?.${this.name}`,
+                ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
                 schema: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.objectType.identifierProperty.name}.type()`,

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

@@ -1,6 +1,7 @@
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function ObjectType_sparqlConstructQueryFunctionDeclaration(this: {
     readonly filterType: Code;
+    readonly name: string;
     readonly staticModuleName: string;
 }): Code;
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js

@@ -1,12 +1,38 @@
+import { camelCase } from "change-case";
 import { imports } from "../imports.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryFunctionDeclaration() {
     return code `\
-export function ${syntheticNamePrefix}sparqlConstructQuery(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
-  const { filter, ignoreRdfType, preferredLanguages, subject, ...queryParameters } = parameters ?? {};
-  return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: subject, ignoreRdfType })), type: "query", where: (queryParameters.where ?? []).concat(${snippets.normalizeSparqlWherePatterns}(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: subject, ignoreRdfType, preferredLanguages }))) };
+export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
+  const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
+
+  return {
+    ...queryParameters,
+    prefixes: prefixes ?? {},
+    queryType: "CONSTRUCT",
+    template: (queryParameters.template ?? []).concat(
+      ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({
+        filter,
+        focusIdentifier: subject,
+        ignoreRdfType: !!ignoreRdfType,
+        variablePrefix
+      })
+    ),
+    type: "query",
+    where: (queryParameters.where ?? []).concat(
+      ${snippets.normalizeSparqlWherePatterns}(
+        ${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({
+          filter,
+          focusIdentifier: subject,
+          ignoreRdfType: !!ignoreRdfType,
+          preferredLanguages,
+          variablePrefix
+        })
+      )
+    )
+  };
 }`;
 }
 //# sourceMappingURL=ObjectType_sparqlConstructQueryFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js

@@ -3,7 +3,7 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_sparqlConstructQueryStringFunctionDeclaration() {
     return code `\
-export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters?: { filter?: ${this.filterType}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: ${imports.NamedNode} | ${imports.Variable}; variablePrefix?: string; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions): string {
+export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
   return new ${imports.sparqljs}.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
 }`;
 }

package/dist/generators/ts/_ObjectType/ObjectType_sparqlFunctionDeclarations.js

@@ -1,10 +1,9 @@
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { camelCase } from "change-case";
 import { imports } from "../imports.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 export function ObjectType_sparqlFunctionDeclarations() {
@@ -12,10 +11,10 @@ export function ObjectType_sparqlFunctionDeclarations() {
         return [];
     }
     const variables = {
-        filter: code `parameters?.filter`,
-        preferredLanguages: code `parameters?.preferredLanguages`,
-        focusIdentifier: code `focusIdentifier`,
-        variablePrefix: code `(parameters?.variablePrefix ?? (focusIdentifier.termType === "Variable" ? focusIdentifier.value : ${literalOf(camelCase(this.name))}))`,
+        filter: code `parameters.filter`,
+        preferredLanguages: code `parameters.preferredLanguages`,
+        focusIdentifier: code `parameters.focusIdentifier`,
+        variablePrefix: code `parameters.variablePrefix`,
     };
     const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
     const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
@@ -24,10 +23,10 @@ export function ObjectType_sparqlFunctionDeclarations() {
     const sparqlConstructTriplesStatements = [];
     const sparqlWherePatternsStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        sparqlConstructTriplesStatements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+        sparqlConstructTriplesStatements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
         triplesVariableDeclarationKeyword = "let";
         sparqlWherePatternsStatements.push(code `\
-patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
         patternsVariableDeclarationKeyword = "let";
     }
     if (this.fromRdfType.isJust()) {
@@ -37,7 +36,7 @@ patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNameP
         sparqlConstructTriplesStatements.push(code `\
 if (!parameters?.ignoreRdfType) {
   triples.push(
-    { subject: focusIdentifier, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
+    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
     { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
   );
 }`);
@@ -54,12 +53,12 @@ if (!parameters?.ignoreRdfType) {
         return valuePatternRow;
       }),
     },
-    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: focusIdentifier }),`
-            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: focusIdentifier }),`}
+    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
-          subject: focusIdentifier,
+          subject: ${variables.focusIdentifier},
           predicate: ${rdfjsTermExpression(rdf.type)},
           object: rdfTypeVariable
         }
@@ -117,10 +116,9 @@ if (!parameters?.ignoreRdfType) {
         ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)(),
         ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
         code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(${sparqlConstructTriplesStatements.length === 0 ? "_" : ""}parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean;  variablePrefix?: string }): readonly ${imports.sparqljs}.Triple[] {
+export function ${syntheticNamePrefix}sparqlConstructTriples(${sparqlConstructTriplesStatements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
 ${sparqlConstructTriplesStatements.length > 0
             ? joinCode([
-                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
                 code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
                 ...sparqlConstructTriplesStatements,
                 code `return triples;`,
@@ -128,11 +126,10 @@ ${sparqlConstructTriplesStatements.length > 0
             : "return [];"}
 }`,
         code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(${sparqlWherePatternsStatements.length === 0 ? "_" : ""}parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; variablePrefix?: string }): readonly ${snippets.SparqlPattern}[] {
+export function ${syntheticNamePrefix}sparqlWherePatterns(${sparqlWherePatternsStatements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
 ${sparqlWherePatternsStatements.length > 0
             ? joinCode([
                 code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
-                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
                 ...sparqlWherePatternsStatements,
                 code `return patterns;`,
             ])

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlFunctionDeclarations.js

@@ -1,4 +1,4 @@
-import { camelCase, pascalCase } from "change-case";
+import { pascalCase } from "change-case";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "../_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "../_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { imports } from "../imports.js";
@@ -13,28 +13,27 @@ export function ObjectUnionType_sparqlFunctionDeclarations() {
         ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)(),
         ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
         code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; variablePrefix?: string }): readonly ${imports.sparqljs}.Triple[] {
-  return [${joinCode(this.concreteMemberTypes.map((memberType) => code `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter: parameters?.filter?.on?.${memberType.name}, focusIdentifier: parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`), { on: ", " })}];
+export function ${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMemberTypes.map((memberType) => code `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`), { on: ", " })}];
 }`,
         code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; variablePrefix?: string }): readonly ${snippets.SparqlPattern}[] {
+export function ${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
 ${joinCode([
             code `let patterns: ${snippets.SparqlPattern}[] = [];`,
             code `\
-    const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}");
-    if (focusIdentifier.termType === "Variable") {
-      patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
-          filter: parameters?.filter?.${syntheticNamePrefix}identifier,
-          ignoreRdfType: false,
-          preferredLanguages: parameters?.preferredLanguages,
-          propertyPatterns: [],
-          schema: ${this.identifierType.schema},
-          valueVariable: focusIdentifier,
-          variablePrefix: focusIdentifier.termType === "Variable" ? focusIdentifier.value : ${literalOf(camelCase(this.name))},
-      }));
-    }`,
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
             code `patterns.push({ patterns: [${joinCode(this.concreteMemberTypes.map((memberType) => code `${{
-                patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: parameters?.filter?.on?.${memberType.name}, focusIdentifier: parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
+                patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,

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

@@ -7,18 +7,18 @@ export const snippets_LazyObject = conditionalOutput(`${syntheticNamePrefix}Lazy
  */
 export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partial: PartialObjectT;
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
+  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
   constructor({ partial, resolver }: {
     partial: PartialObjectT
-    resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
+    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
   }) {
     this.partial = partial;
     this.resolver = resolver;
   }
 
-  resolve(): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier);
+  resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
+    return this.resolver(this.partial.${syntheticNamePrefix}identifier, options);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObject.js.map

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

@@ -7,21 +7,21 @@ export const snippets_LazyObjectOption = conditionalOutput(`${syntheticNamePrefi
  */
 export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partial: ${imports.Maybe}<PartialObjectT>;
-  private readonly resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
+  private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
   constructor({ partial, resolver }: {
     partial: ${imports.Maybe}<PartialObjectT>
-    resolver: (identifier: ObjectIdentifierT) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
+    resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>,
   }) {
     this.partial = partial;
     this.resolver = resolver;
   }
 
-  async resolve(): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedObjectT>>> {
+  async resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ${imports.Maybe}<ResolvedObjectT>>> {
     if (this.partial.isNothing()) {
       return ${imports.Right}(${imports.Maybe}.empty());
     }
-    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier)).map(${imports.Maybe}.of);
+    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier, options)).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectOption.js.map

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

@@ -7,11 +7,11 @@ export const snippets_LazyObjectSet = conditionalOutput(`${syntheticNamePrefix}L
  */
 export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
   readonly partials: readonly PartialObjectT[];
-  private readonly resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
+  private readonly resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
 
   constructor({ partials, resolver }: {
     partials: readonly PartialObjectT[]
-    resolver: (identifiers: readonly ObjectIdentifierT[]) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>,
+    resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>,
   }) {
     this.partials = partials;
     this.resolver = resolver;
@@ -21,7 +21,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
     return this.partials.length;
   }
 
-  async resolve(options?: { limit?: number; offset?: number }): Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>> {
+  async resolve(options?: { limit?: number; offset?: number; preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>> {
     if (this.partials.length === 0) {
       return ${imports.Right}([]);
     }
@@ -36,7 +36,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
       offset = 0;
     }
 
-    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier));
+    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier), { preferredLanguages: options?.preferredLanguages });
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectSet.js.map

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

@@ -3,8 +3,8 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_SparqlConstructTriplesFunctionParameters = conditionalOutput(`${syntheticNamePrefix}SparqlConstructTriplesFunctionParameters`, code `\
 type ${syntheticNamePrefix}SparqlConstructTriplesFunctionParameters<FilterT, SchemaT> = Readonly<{
-  filter?: FilterT;
-  ignoreRdfType?: boolean;
+  filter: FilterT | undefined;
+  ignoreRdfType: boolean;
   schema: SchemaT;
   valueVariable: ${imports.Variable};
   variablePrefix: string;

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

@@ -4,9 +4,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
 export const snippets_SparqlWherePatternsFunctionParameters = conditionalOutput(`${syntheticNamePrefix}SparqlWherePatternsFunctionParameters`, code `\
 type ${syntheticNamePrefix}SparqlWherePatternsFunctionParameters<FilterT, SchemaT> = Readonly<{
-  filter?: FilterT;
-  ignoreRdfType?: boolean;
-  preferredLanguages?: readonly string[];
+  filter: FilterT | undefined;
+  ignoreRdfType: boolean;
+  preferredLanguages: readonly string[] | undefined;
   propertyPatterns: readonly ${snippets_SparqlPattern}[];
   schema: SchemaT;
   valueVariable: ${imports.Variable};

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

@@ -17,6 +17,6 @@ const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets_SparqlWherePa
       }
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_booleanSparqlWherePatterns.js.map

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

@@ -74,6 +74,6 @@ const ${syntheticNamePrefix}dateSparqlWherePatterns: ${snippets_SparqlWherePatte
       }
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, schema, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, schema, valueVariable });
   }`);
 //# sourceMappingURL=snippets_dateSparqlWherePatterns.js.map

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

@@ -6,7 +6,7 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 export const snippets_defaultValueSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ${snippets_DefaultValueSchema}<ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
-    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ schema: schema.item(), ...otherParameters }));
+    const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.item() }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
   }
 }`);

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

@@ -15,6 +15,6 @@ const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets_SparqlWherePatter
       filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
     }
 
-    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   };`);
 //# sourceMappingURL=snippets_iriSparqlWherePatterns.js.map

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

@@ -7,16 +7,16 @@ import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_listSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
-  return ({ filter, schema, valueVariable: listVariable, ...otherParameters }) => {
+  return ({ filter, schema, valueVariable: listVariable, variablePrefix: variablePrefixPrefix }) => {
     let triples: ${imports.sparqljs}.Triple[] = [];
-    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${otherParameters.variablePrefix}\${suffix}\`);
-    const variablePrefix = (suffix: string) => \`\${otherParameters.variablePrefix}\${suffix}\`;
+    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${variablePrefixPrefix}\${suffix}\`);
+    const variablePrefix = (suffix: string) => \`\${variablePrefixPrefix}\${suffix}\`;
 
     {
       // ?list rdf:first ?item0
       const item0Variable = variable("Item0");
       triples.push({ subject: listVariable, predicate: ${snippets_RdfVocabularies}.rdf.first, object: item0Variable });
-      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
     }
 
     {
@@ -31,7 +31,7 @@ function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchem
       // ?rest rdf:first ?itemN
       const itemNVariable = variable("ItemN");
       triples.push({ subject: restNVariable, predicate: ${snippets_RdfVocabularies}.rdf.first, object: itemNVariable });
-      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
     }
 
     // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT

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

@@ -36,6 +36,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
         },
         ...itemSparqlWherePatternsFunction({
           filter: parameters.filter,
+          ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
           schema: parameters.schema.item(),
@@ -91,6 +92,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
         },
         ...itemSparqlWherePatternsFunction({
           filter: parameters.filter,
+          ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
           schema: parameters.schema.item(),

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

@@ -5,6 +5,6 @@ import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_maybeSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
-  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ filter: filter ?? undefined, schema: schema.item(), ...otherParameters });
+  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map

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

@@ -9,18 +9,18 @@ function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT
   return ({ filter, schema, ...otherParameters }) => {
     if (filter === undefined) {
       // Treat the item's patterns as optional
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() }));
       return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
     }
       
     if (filter === null) {
       // Use FILTER NOT EXISTS around the item's patterns
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ schema: schema.item(), ...otherParameters }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.item() }));
       return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
     }
 
     // Treat the item as required.
-    return itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
   }
 }`);
 //# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

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

@@ -66,6 +66,6 @@ function ${syntheticNamePrefix}numericSparqlWherePatterns<T extends bigint | num
     }
   }
 
-  return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+  return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
 }`);
 //# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

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

@@ -5,6 +5,6 @@ import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_setSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}setSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}setSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
-  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ filter: filter ?? undefined, schema: schema.item(), ...otherParameters });
+  return ({ schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

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

@@ -7,7 +7,7 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 export const snippets_setSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, ...otherParameters }) => {
-    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
 
     const minCount = filter?.${syntheticNamePrefix}minCount ?? schema.minCount ?? 0;
     if (minCount > 0) {

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

@@ -5,9 +5,9 @@ import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js"
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_shaclPropertySparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, propertyName, propertySchema, typeSparqlConstructTriples, variablePrefix }: {
-  filter?: FilterT;
+  filter: FilterT | undefined;
   focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType?: boolean;
+  ignoreRdfType: boolean;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
   typeSparqlConstructTriples: ${snippets_SparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;

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

@@ -7,10 +7,10 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 import { snippets_sparqlPropertyPath } from "./snippets_sparqlPropertyPath.js";
 export const snippets_shaclPropertySparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
-  filter?: FilterT;
+  filter: FilterT | undefined;
   focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType?: boolean;
-  preferredLanguages?: readonly string[];
+  ignoreRdfType: boolean;
+  preferredLanguages: readonly string[] | undefined;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
   typeSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<FilterT, TypeSchemaT>;

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

@@ -42,6 +42,6 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_SparqlWherePat
       }
     }
 
-    return ${snippets_literalSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -18,6 +18,7 @@ export namespace ${syntheticNamePrefix}ObjectSet {
     readonly identifiers?: readonly ObjectIdentifierT[];
     readonly limit?: number;
     readonly offset?: number;
+    readonly preferredLanguages?: readonly string[];
   }
 }`;
 }

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -9,7 +9,7 @@ export function objectSetMethodSignatures(parameters) {
     return {
         object: {
             name: methodNames.object,
-            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}`,
+            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
             returnType: code `Promise<${imports.Either}<Error, ${objectType.name}>>`,
         },
         objectCount: {

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,3 +1,4 @@
+import { snippets_FromRdfOptions } from "./_snippets/snippets_FromRdfOptions.js";
 import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { snippets } from "./snippets.js";
@@ -8,7 +9,7 @@ export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnion
     const objectTypeType = code `\
 {
   ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options?: ${snippets_FromRdfOptions}) => ${imports.Either}<Error, ObjectT>;
   ${syntheticNamePrefix}fromRdfTypes: readonly ${imports.NamedNode}[]
 }`;
     const parameters = {
@@ -52,12 +53,12 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
                 // object
                 code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
-  return this.${methodSignatures.object.name}Sync(identifier);
+  return this.${methodSignatures.object.name}Sync(identifier, options);
 }`,
                 // objectSync
                 code `\
 ${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${objectType.name}> {
-  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier] }).map(objects => objects[0]);
+  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                 // objectCount
                 code `\
@@ -125,6 +126,8 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
+  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
   let resources: { object?: ObjectT, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
@@ -166,7 +169,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
       identifierSet.add(quad.subject);
       const resource = resourceSet.resource(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object type
-      objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+      objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
         resources.push({ object, resource });
       });
     }
@@ -181,7 +184,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   const objects: ObjectT[] = [];
   for (let { object, resource } of resources) {
     if (!object) {
-      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
       if (objectEither.isLeft()) {
         return objectEither;
       }
@@ -215,6 +218,8 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
+  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
   let resources: { object?: ObjectT, objectType?: ${objectTypeType}, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
@@ -259,7 +264,7 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       // Eagerly eliminate the majority of resources that won't match the object types
       const resource = resourceSet.resource(quad.subject);
       for (const objectType of objectTypes) {
-        if (objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+        if (objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
           resources.push({ object, objectType, resource });
         }).isRight()) {
           break;
@@ -279,11 +284,11 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
     if (!object) {
       let objectEither: ${imports.Either}<Error, ObjectT>;
       if (objectType) {
-        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
       } else {
         objectEither = ${imports.Left}(new Error("no object types"));
         for (const tryObjectType of objectTypes) {
-          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
           if (objectEither.isRight()) {
             objectType = tryObjectType;
             break;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -5,11 +5,11 @@ import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const sparqlWherePatternsFunctionType = code `(parameters?: { filter?: ObjectFilterT; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; }) => readonly ${imports.sparqljs}.Pattern[]`;
+    const sparqlWherePatternsFunctionType = code `(parameters: { filter: ObjectFilterT | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string; }) => readonly ${imports.sparqljs}.Pattern[]`;
     const parameters = {
         constructObjectType: code `objectType: {\
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
-  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { filter?: ObjectFilterT; subject?: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
   ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
 }`,
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
@@ -45,7 +45,7 @@ ${joinCode([...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
         return [
             code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
-  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier] })).map(objects => objects[0]);
+  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages })).map(objects => objects[0]);
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
@@ -162,7 +162,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this })));
+        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
@@ -211,7 +211,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
     }
 
-    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable }));
+    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.4",
+    "@shaclmate/shacl-ast": "4.0.6",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -80,5 +80,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.4"
+  "version": "4.0.6"
 }