@shaclmate/compiler 4.0.8 → 4.0.10

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

@@ -3,10 +3,10 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_IdentifierFilter } from "./snippets_IdentifierFilter.js";
 import { snippets_IdentifierSchema } from "./snippets_IdentifierSchema.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_identifierSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}identifierSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}identifierSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_IdentifierFilter}, ${snippets_IdentifierSchema}> =
+const ${syntheticNamePrefix}identifierSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_IdentifierFilter}, ${snippets_IdentifierSchema}> =
   ({ filter, propertyPatterns, valueVariable }) => {
     const patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
 

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

@@ -3,11 +3,11 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_IriFilter } from "./snippets_IriFilter.js";
 import { snippets_IriSchema } from "./snippets_IriSchema.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
 import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_iriSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}iriSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_IriFilter}, ${snippets_IriSchema}> =
+const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_IriFilter}, ${snippets_IriSchema}> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 

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

@@ -4,9 +4,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
-import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
+import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.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>> {
+function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, valueVariable: listVariable, variablePrefix: variablePrefixPrefix }) => {
     let triples: ${imports.sparqljs}.Triple[] = [];
     const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${variablePrefixPrefix}\${suffix}\`);

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

@@ -6,9 +6,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_listSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}listSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return (parameters) => {
     // Need to handle two cases:
     // (1) (?s, ?p, ?list) where ?list binds to rdf:nil

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

@@ -2,9 +2,9 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_LiteralFilter } from "./snippets_LiteralFilter.js";
 import { snippets_LiteralSchema } from "./snippets_LiteralSchema.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_termFilterSparqlPatterns } from "./snippets_termFilterSparqlPatterns.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_literalSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}literalSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_LiteralFilter}, ${snippets_LiteralSchema}> =
+const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_LiteralFilter}, ${snippets_LiteralSchema}> =
   (parameters) => ${syntheticNamePrefix}literalSchemaSparqlPatterns({ filterPatterns: ${snippets_termFilterSparqlPatterns}(parameters), ...parameters });`);
 //# sourceMappingURL=snippets_literalSparqlWherePatterns.js.map

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

@@ -2,9 +2,9 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_MaybeFilter } from "./snippets_MaybeFilter.js";
 import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
-import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
+import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.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>> {  
+function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlConstructTriplesFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
   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

@@ -3,9 +3,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
 import { snippets_MaybeFilter } from "./snippets_MaybeFilter.js";
 import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_maybeSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}maybeSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
+function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
   return ({ filter, schema, ...otherParameters }) => {
     if (filter === undefined) {
       // Treat the item's patterns as optional

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

@@ -4,12 +4,11 @@ import { snippets_literalFactory } from "./snippets_literalFactory.js";
 import { snippets_NumericFilter } from "./snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./snippets_NumericSchema.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlWherePatternsFunctionParameters } from "./snippets_SparqlWherePatternsFunctionParameters.js";
 import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
 import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_numericSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}numericSparqlWherePatterns<T extends bigint | number>({ filter, valueVariable, ...otherParameters }: ${snippets_SparqlWherePatternsFunctionParameters}<${snippets_NumericFilter}<T>, ${snippets_NumericSchema}<T>>): readonly ${snippets_SparqlPattern}[] {
+function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets_ValueSparqlWherePatternsFunction}<${snippets_NumericFilter}<T>, ${snippets_NumericSchema}<T>>>[0]): ReturnType<${snippets_ValueSparqlWherePatternsFunction}<${snippets_NumericFilter}<T>, ${snippets_NumericSchema}<T>>> {
   const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 
   if (filter) {

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

@@ -2,9 +2,9 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
-import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
+import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.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>> {
+function ${syntheticNamePrefix}setSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return ({ schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

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

@@ -3,9 +3,9 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 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>> {
+function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, ...otherParameters }) => {
     const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
 

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

@@ -1,8 +1,9 @@
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
 import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
-import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
+import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.js";
 export const snippets_shaclPropertySparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, propertyName, propertySchema, typeSparqlConstructTriples, variablePrefix }: {
   filter: FilterT | undefined;
@@ -10,13 +11,13 @@ function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, Type
   ignoreRdfType: boolean;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
-  typeSparqlConstructTriples: ${snippets_SparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;
+  typeSparqlConstructTriples: ${snippets_ValueSparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;
   variablePrefix: string;
 }): readonly ${imports.sparqljs}.Triple[] {
   const propertyPathSparqlConstructTriples = ({ end, propertyPath, start, variableCounter }: {
     variableCounter: { value: number };
     end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
-    propertyPath: ${imports.PropertyPath};
+    propertyPath: ${snippets_PropertyPath};
     start: ${imports.NamedNode} | ${imports.Variable};
   }): readonly ${imports.sparqljs}.Triple[] => {
     switch (propertyPath.termType) {

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

@@ -1,10 +1,11 @@
 import { imports } from "../imports.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
 import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
 import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_sparqlPropertyPath } from "./snippets_sparqlPropertyPath.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_shaclPropertySparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
   filter: FilterT | undefined;
@@ -13,12 +14,12 @@ function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSch
   preferredLanguages: readonly string[] | undefined;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
-  typeSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
+  typeSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
   variablePrefix: string;
 }): readonly ${snippets_SparqlPattern}[] {
   const propertyPathSparqlWherePatterns = ({ end, propertyPath, start, variableCounter }: {
     end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
-    propertyPath: ${imports.PropertyPath};
+    propertyPath: ${snippets_PropertyPath};
     start: ${imports.NamedNode} | ${imports.Variable};
     variableCounter: { value: number };
   }): ${snippets_SparqlPattern}[] => {

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

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

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

@@ -3,12 +3,12 @@ import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 import { snippets_literalFactory } from "./snippets_literalFactory.js";
 import { snippets_literalSchemaSparqlPatterns } from "./snippets_literalSchemaSparqlPatterns.js";
 import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
 import { snippets_StringFilter } from "./snippets_StringFilter.js";
 import { snippets_StringSchema } from "./snippets_StringSchema.js";
 import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
+import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
 export const snippets_stringSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_StringFilter}, ${snippets_StringSchema}> =
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_StringFilter}, ${snippets_StringSchema}> =
   ({ filter, valueVariable, ...otherParameters }) => {
     const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
 

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

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

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

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare function graphqlSchemaVariableStatement(parameters: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: ObjectUnionType[];
+    namedObjectTypes: readonly NamedObjectType[];
+    namedObjectUnionTypes: NamedObjectUnionType[];
 }): Maybe<Code>;
 //# sourceMappingURL=graphqlSchemaVariableStatement.d.ts.map

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -2,25 +2,25 @@ import { Maybe } from "purify-ts";
 import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
-function graphqlQueryObjectType({ objectTypes, objectUnionTypes, }) {
+function graphqlQueryObjectType({ namedObjectTypes, namedObjectUnionTypes, }) {
     return code `new ${imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
-        ...objectTypes,
-        ...objectUnionTypes,
-    ].reduce((fields, objectType) => {
-        fields[objectType.objectSetMethodNames.object] = {
+        ...namedObjectTypes,
+        ...namedObjectUnionTypes,
+    ].reduce((fields, namedObjectType) => {
+        fields[namedObjectType.objectSetMethodNames.object] = {
             args: {
                 identifier: {
                     type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLID})`,
                 },
             },
             resolve: code `\
-async (_source, args: { identifier: string }, { objectSet }): Promise<${objectType.name}> => 
-  (await ${imports.EitherAsync}<Error, ${objectType.name}>(async ({ liftEither }) => 
-    liftEither(await objectSet.${objectType.objectSetMethodNames.object}(await liftEither(${objectType.identifierTypeAlias}.fromString(args.identifier))))
+async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.name}> => 
+  (await ${imports.EitherAsync}<Error, ${namedObjectType.name}>(async ({ liftEither }) => 
+    liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.fromString(args.identifier))))
   )).unsafeCoerce()`,
-            type: objectType.graphqlType.name,
+            type: namedObjectType.graphqlType.name,
         };
-        fields[objectType.objectSetMethodNames.objectIdentifiers] = {
+        fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
             args: {
                 limit: {
                     type: code `${imports.GraphQLInt}`,
@@ -31,10 +31,10 @@ async (_source, args: { identifier: string }, { objectSet }): Promise<${objectTy
             },
             resolve: code `\
  async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
-  (await objectSet.${objectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${objectType.identifierTypeAlias}.toString)`,
+  (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.toString)`,
             type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${imports.GraphQLString}))`,
         };
-        fields[objectType.objectSetMethodNames.objects] = {
+        fields[namedObjectType.objectSetMethodNames.objects] = {
             args: {
                 identifiers: {
                     type: code `new ${imports.GraphQLList}(new ${imports.GraphQLNonNull}(${imports.GraphQLID}))`,
@@ -47,36 +47,36 @@ async (_source, args: { identifier: string }, { objectSet }): Promise<${objectTy
                 },
             },
             resolve: code `\
-async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${objectType.name}[]> =>
-(await ${imports.EitherAsync}<Error, readonly ${objectType.name}[]>(async ({ liftEither }) => {
-  let filter: ${objectType.filterType} | undefined;
+async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.name}[]> =>
+(await ${imports.EitherAsync}<Error, readonly ${namedObjectType.name}[]>(async ({ liftEither }) => {
+  let filter: ${namedObjectType.filterType} | undefined;
   if (args.identifiers) {
-    const identifiers: ${objectType.identifierTypeAlias}[] = [];
+    const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
     for (const identifierArg of args.identifiers) {
-      identifiers.push(await liftEither(${objectType.identifierTypeAlias}.fromString(identifierArg)));
+      identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.fromString(identifierArg)));
     }
     filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
   }
-  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
+  return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
 })).unsafeCoerce()`,
-            type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${objectType.graphqlType.name}))`,
+            type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
         };
-        fields[objectType.objectSetMethodNames.objectCount] = {
+        fields[namedObjectType.objectSetMethodNames.objectCount] = {
             resolve: code `\
-async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${objectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
             type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLInt})`,
         };
         return fields;
     }, {})} })`;
 }
 export function graphqlSchemaVariableStatement(parameters) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => objectType.features.has("graphql") && !objectType.synthetic);
-    const objectUnionTypes = parameters.objectUnionTypes.filter((objectUnionType) => objectUnionType.features.has("graphql"));
-    if (objectTypes.length === 0) {
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => namedObjectType.features.has("graphql") && !namedObjectType.synthetic);
+    const namedObjectUnionTypes = parameters.namedObjectUnionTypes.filter((namedObjectUnionType) => namedObjectUnionType.features.has("graphql"));
+    if (namedObjectTypes.length === 0) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ objectTypes, objectUnionTypes })} });
+export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ namedObjectTypes: namedObjectTypes, namedObjectUnionTypes })} });
 `);
 }
 //# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/imports.d.ts

@@ -25,9 +25,9 @@ export declare const imports: {
     readonly Maybe: import("ts-poet/build/Import.js").Import;
     readonly NamedNode: import("ts-poet/build/Import.js").Import;
     readonly NonEmptyList: import("ts-poet/build/Import.js").Import;
-    readonly PropertyPath: import("ts-poet/build/Import.js").Import;
     readonly Quad: import("ts-poet/build/Import.js").Import;
     readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
+    readonly RdfjsResourcePropertyPath: import("ts-poet/build/Import.js").Import;
     readonly Resource: import("ts-poet/build/Import.js").Import;
     readonly ResourceSet: import("ts-poet/build/Import.js").Import;
     readonly Right: import("ts-poet/build/Import.js").Import;

package/dist/generators/ts/imports.js

@@ -26,9 +26,9 @@ export const imports = {
     Maybe: imp("Maybe@purify-ts"),
     NamedNode: imp("NamedNode@@rdfjs/types"),
     NonEmptyList: imp("NonEmptyList@purify-ts"),
-    PropertyPath: imp("PropertyPath@rdfjs-resource"),
     Quad: imp("Quad@@rdfjs/types"),
     Quad_Graph: imp("Quad_Graph@@rdfjs/types"),
+    RdfjsResourcePropertyPath: imp("PropertyPath:RdfjsResourcePropertyPath@rdfjs-resource"),
     Resource: imp("Resource@rdfjs-resource"),
     ResourceSet: imp("ResourceSet@rdfjs-resource"),
     Right: imp("Right@purify-ts"),

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

@@ -1,8 +1,8 @@
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import type { Code } from "./ts-poet-wrapper.js";
-export declare function objectSetDeclarations({ objectUnionTypes, ...parameters }: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: readonly ObjectUnionType[];
+export declare function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }: {
+    namedObjectTypes: readonly NamedObjectType[];
+    namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): readonly Code[];
 //# sourceMappingURL=objectSetDeclarations.d.ts.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -1,57 +1,60 @@
 import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
-export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.abstract && !objectType.extern && !objectType.synthetic);
-    let objectTypesWithRdfFeatureCount = 0;
-    let objectTypesWithSparqlFeatureCount = 0;
-    for (const objectType of objectTypes) {
-        if (!objectType.features.has("rdf") && !objectType.features.has("sparql")) {
+export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.abstract &&
+        !namedObjectType.extern &&
+        !namedObjectType.synthetic);
+    let namedObjectTypesWithRdfFeatureCount = 0;
+    let namedObjectTypesWithSparqlFeatureCount = 0;
+    for (const namedObjectType of namedObjectTypes) {
+        if (!namedObjectType.features.has("rdf") &&
+            !namedObjectType.features.has("sparql")) {
             continue;
         }
-        if (objectType.features.has("rdf")) {
-            objectTypesWithRdfFeatureCount++;
+        if (namedObjectType.features.has("rdf")) {
+            namedObjectTypesWithRdfFeatureCount++;
         }
-        if (objectType.features.has("sparql")) {
-            objectTypesWithSparqlFeatureCount++;
+        if (namedObjectType.features.has("sparql")) {
+            namedObjectTypesWithSparqlFeatureCount++;
         }
     }
-    let objectUnionTypesWithRdfFeatureCount = 0;
-    let objectUnionTypesWithSparqlFeatureCount = 0;
-    for (const objectUnionType of objectUnionTypes) {
-        if (!objectUnionType.features.has("rdf") &&
-            !objectUnionType.features.has("sparql")) {
+    let namedObjectUnionTypesWithRdfFeatureCount = 0;
+    let namedObjectUnionTypesWithSparqlFeatureCount = 0;
+    for (const namedObjectUnionType of namedObjectUnionTypes) {
+        if (!namedObjectUnionType.features.has("rdf") &&
+            !namedObjectUnionType.features.has("sparql")) {
             continue;
         }
-        if (objectUnionType.features.has("rdf")) {
-            objectUnionTypesWithRdfFeatureCount++;
+        if (namedObjectUnionType.features.has("rdf")) {
+            namedObjectUnionTypesWithRdfFeatureCount++;
         }
-        if (objectUnionType.features.has("sparql")) {
-            objectUnionTypesWithSparqlFeatureCount++;
+        if (namedObjectUnionType.features.has("sparql")) {
+            namedObjectUnionTypesWithSparqlFeatureCount++;
         }
     }
-    if (objectTypesWithRdfFeatureCount === 0 &&
-        objectTypesWithSparqlFeatureCount === 0 &&
-        objectUnionTypesWithRdfFeatureCount === 0 &&
-        objectUnionTypesWithSparqlFeatureCount === 0) {
+    if (namedObjectTypesWithRdfFeatureCount === 0 &&
+        namedObjectTypesWithSparqlFeatureCount === 0 &&
+        namedObjectUnionTypesWithRdfFeatureCount === 0 &&
+        namedObjectUnionTypesWithSparqlFeatureCount === 0) {
         return [];
     }
     const declarations = [
         objectSetInterfaceDeclaration({
-            objectTypes,
-            objectUnionTypes,
+            namedObjectTypes: namedObjectTypes,
+            namedObjectUnionTypes,
         }),
     ];
-    if (objectTypesWithRdfFeatureCount > 0) {
+    if (namedObjectTypesWithRdfFeatureCount > 0) {
         declarations.push(rdfjsDatasetObjectSetClassDeclaration({
-            objectTypes,
-            objectUnionTypes,
+            namedObjectTypes: namedObjectTypes,
+            namedObjectUnionTypes,
         }));
     }
-    if (objectTypesWithSparqlFeatureCount > 0) {
+    if (namedObjectTypesWithSparqlFeatureCount > 0) {
         declarations.push(sparqlObjectSetClassDeclaration({
-            objectTypes,
-            objectUnionTypes,
+            namedObjectTypes: namedObjectTypes,
+            namedObjectUnionTypes,
         }));
     }
     return declarations;

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

@@ -1,8 +1,8 @@
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: readonly ObjectUnionType[];
+export declare function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }: {
+    namedObjectTypes: readonly NamedObjectType[];
+    namedObjectUnionTypes: readonly NamedObjectUnionType[];
 }): Code;
 //# sourceMappingURL=objectSetInterfaceDeclaration.d.ts.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -2,12 +2,14 @@ import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
-export function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }) {
+export function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
     return code `\
 export interface ${syntheticNamePrefix}ObjectSet {
-  ${joinCode(objectTypes
-        .flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })))
-        .concat(objectUnionTypes.flatMap((objectUnionType) => Object.values(objectSetMethodSignatures({ objectType: objectUnionType }))))
+  ${joinCode(namedObjectTypes
+        .flatMap((namedObjectType) => Object.values(objectSetMethodSignatures({ namedObjectType })))
+        .concat(namedObjectUnionTypes.flatMap((namedObjectUnionType) => Object.values(objectSetMethodSignatures({
+        namedObjectType: namedObjectUnionType,
+    }))))
         .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
 }
 

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

@@ -1,15 +1,15 @@
-import type { ObjectType } from "./ObjectType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare function objectSetMethodSignatures(parameters: {
-    objectType: {
+    namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
         readonly name: string;
     };
     parameterNamePrefix?: string;
     queryT?: string;
-}): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, {
+}): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, {
     readonly name: string;
     readonly parameters: Code;
     readonly returnType: Code;

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -2,30 +2,30 @@ import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export function objectSetMethodSignatures(parameters) {
-    const { objectType } = parameters;
+    const { namedObjectType } = parameters;
     const parameterNamePrefix = parameters?.parameterNamePrefix ?? "";
     const queryT = parameters.queryT ?? `${syntheticNamePrefix}ObjectSet.Query`;
-    const methodNames = objectType.objectSetMethodNames;
+    const methodNames = namedObjectType.objectSetMethodNames;
     return {
         object: {
             name: methodNames.object,
-            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-            returnType: code `Promise<${imports.Either}<Error, ${objectType.name}>>`,
+            parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+            returnType: code `Promise<${imports.Either}<Error, ${namedObjectType.name}>>`,
         },
         objectCount: {
             name: methodNames.objectCount,
-            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>, "filter">`,
+            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
             returnType: code `Promise<${imports.Either}<Error, number>>`,
         },
         objectIdentifiers: {
             name: methodNames.objectIdentifiers,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
         },
         objects: {
             name: methodNames.objects,
-            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
-            returnType: code `Promise<${imports.Either}<Error, readonly ${objectType.name}[]>>`,
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.Either}<Error, readonly ${namedObjectType.name}[]>>`,
         },
     };
 }