@shaclmate/compiler 4.0.50 → 4.0.52

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

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

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

@@ -0,0 +1,21 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeSparqlWherePatterns`, code `\
+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
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType }));
+      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({ ...otherParameters, filter: undefined, schema: schema.itemType }));
+      return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
+    }
+
+    // Treat the item as required.
+    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType });
+  }
+}`);
+//# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_monkeyPatchObject = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}monkeyPatchObject`, code `\
+function ${syntheticNamePrefix}monkeyPatchObject<T extends object>(obj: T, methods: { toJson?: (obj: T) => object, ${syntheticNamePrefix}toString?: (obj: T) => string }): T {
+  if (methods.toJson && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON") || typeof (obj as any).toJSON === "function")) {
+    const toJsonMethod = methods.toJson;
+    (obj as any).toJSON = function(this: T, _key: string) { return toJsonMethod(this); }
+  }
+
+  if (methods.${syntheticNamePrefix}toString && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toString") || typeof (obj as any).toJSON === "function")) {
+    const toStringMethod = methods.${syntheticNamePrefix}toString;
+    (obj as any).toString = function(this: T) { return toStringMethod(this); }
+  }
+
+  return obj;
+}`);
+//# sourceMappingURL=snippets_monkeyPatchObject.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_mutableListFromRdfResourceValues = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}mutableListFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}mutableListFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+  const immutableListFromRdfResourceValues = ${snippets.listFromRdfResourceValues}(itemFromRdfResourceValues);
+  return (values, options) => 
+    immutableListFromRdfResourceValues(values, options).map(values => values.map(value => value.concat()));
+}`);
+//# sourceMappingURL=snippets_mutableListFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_mutableSetFromRdfResourceValues = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}mutableSetFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}mutableSetFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+  const immutableSetFromRdfResourceValues = ${snippets.setFromRdfResourceValues}(itemFromRdfResourceValues);
+  return (values, options) => 
+    immutableSetFromRdfResourceValues(values, options).map(values => values.map(value => value.concat()));
+}`);
+//# sourceMappingURL=snippets_mutableSetFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,92 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_normalizeSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}normalizeSparqlWherePatterns`, code `\
+function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly ${snippets.SparqlPattern}[]): readonly ${snippets.SparqlPattern}[] {
+  function normalizePatternsRecursive(patternsRecursive: readonly ${snippets.SparqlPattern}[]): readonly ${snippets.SparqlPattern}[] {
+    if (patternsRecursive.length === 0) {
+      return patternsRecursive;
+    }
+
+    const compactedPatterns: ${snippets.SparqlPattern}[] = [];
+    for (const pattern of ${snippets.deduplicateSparqlPatterns}(patternsRecursive)) {
+      switch (pattern.type) {
+        case "bgp": {
+          if (pattern.triples.length === 0) {
+            continue;
+          }
+          const lastPattern = compactedPatterns.at(-1);
+          if (lastPattern && lastPattern.type === "bgp") {
+            // Coalesce adjacent BGP patterns without mutating lastPattern
+            compactedPatterns[compactedPatterns.length - 1] = { triples: lastPattern.triples.concat(pattern.triples), type: "bgp" };
+          } else {
+            compactedPatterns.push(pattern);
+          }
+          break;
+        }
+        case "bind":
+        case "filter":
+        case "query":
+        case "values":
+          compactedPatterns.push(pattern);
+          break;
+        case "group":
+          // Flatten groups outside unions
+          compactedPatterns.push(...normalizePatternsRecursive(pattern.patterns));
+          break;
+        case "graph":
+        case "minus":
+        case "optional":
+        case "service": {
+          const patterns_ = normalizePatternsRecursive(pattern.patterns);
+          if (patterns_.length > 0) {
+            compactedPatterns.push({ ...pattern, patterns: patterns_.concat() });
+          }
+          break;
+        }
+        case "union": {
+          const unionPatterns = ${snippets.deduplicateSparqlPatterns}(pattern.patterns.flatMap(pattern => {
+            switch (pattern.type) {
+              case "group":
+                // Don't flatten the groups in a union
+              case "graph":
+              case "minus":
+              case "optional":
+              case "service": {
+                const patterns_ = normalizePatternsRecursive(pattern.patterns);
+                if (patterns_.length > 0) {
+                  return [{ ...pattern, patterns: patterns_.concat() }];
+                }
+                return [] as ${snippets.SparqlPattern}[];
+              }
+              default:
+                return [pattern];
+            }
+          }));
+
+          switch (unionPatterns.length) {
+            case 0:
+              break;
+            case 1:
+              compactedPatterns.push(...normalizePatternsRecursive([unionPatterns[0]]));
+              break;
+            default:
+              compactedPatterns.push({ ...pattern, patterns: unionPatterns.concat() });
+              break;
+          }
+          break;
+        }
+        default:
+          pattern satisfies never;
+      }
+    }
+
+    return ${snippets.sortSparqlPatterns}(${snippets.deduplicateSparqlPatterns}(compactedPatterns));
+  }
+
+  const normalizedPatterns = normalizePatternsRecursive(patterns);
+  if (!normalizedPatterns.some(${snippets.SparqlPattern_isSolutionGenerating})) {
+    throw new Error("SPARQL WHERE patterns must have at least one solution-generating pattern");
+  }
+
+  return normalizedPatterns;
+}`);
+//# sourceMappingURL=snippets_normalizeSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,62 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_numericSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
+function $numericSparqlWherePatterns<NumericT extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<NumericT>, ${snippets.NumericSchema}<NumericT>>>[0]): ReturnType<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<NumericT>, ${snippets.NumericSchema}<NumericT>>> {
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
+
+  if (filter) {
+    if (filter.in !== undefined && filter.in.length > 0) {
+      filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+    }
+
+    if (filter.maxExclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: "<",
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxExclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.maxInclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: "<=",
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxInclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.minExclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: ">",
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minExclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.minInclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: ">=",
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minInclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+  }
+
+  return ${snippets.termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+}`);
+//# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_parseBlankNode = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseBlankNode`, code `\
+export function ${syntheticNamePrefix}parseBlankNode(identifier: string): ${imports.Either}<Error, ${imports.BlankNode}> {
+  return \
+    ${snippets.parseIdentifier}(identifier)\
+      .chain((identifier) => (identifier.termType === "BlankNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be BlankNode"))) \
+    as ${imports.Either}<Error, ${imports.BlankNode}>;
+}`);
+//# sourceMappingURL=snippets_parseBlankNode.js.map

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_parseIdentifier = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseIdentifier`, code `\
+const ${syntheticNamePrefix}parseIdentifier = ${imports.NTriplesIdentifier}.parser(${imports.dataFactory});`);
+//# sourceMappingURL=snippets_parseIdentifier.js.map

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_parseIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseIri`, code `\
+export function ${syntheticNamePrefix}parseIri(identifier: string): ${imports.Either}<Error, ${imports.NamedNode}> {
+  return \
+    ${snippets.parseIdentifier}(identifier)\
+      .chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode"))) \
+    as ${imports.Either}<Error, ${imports.NamedNode}>;
+}`);
+//# sourceMappingURL=snippets_parseIri.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_propertyEquals = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}propertyEquals`, code `\
+function ${syntheticNamePrefix}propertyEquals<ObjectT, PropertyValueT>(
+  property: Readonly<{ equalsFunction: ${snippets.EqualsFunction}<PropertyValueT>; name: string; }>,
+  left: readonly [ObjectT, PropertyValueT],
+  right: readonly [ObjectT, PropertyValueT]
+): ${snippets.EqualsResult} {
+  return property.equalsFunction(left[1], right[1])
+    .mapLeft(propertyValuesUnequal => ({ left: left[0], right: right[0], propertyName: property.name, propertyValuesUnequal, type: "property" as const }));
+}`);
+//# sourceMappingURL=snippets_propertyEquals.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_rdfResourceIdentifierValues = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}rdfResourceIdentifierValues`, code `\
+function ${syntheticNamePrefix}rdfResourceIdentifierValues(resource: ${imports.Resource}): ${imports.Resource}.Values {
+  return new ${imports.Resource}.Value({
+    dataFactory: ${imports.dataFactory},
+    focusResource: resource,
+    propertyPath: ${rdfjsTermExpression(rdf.subject)},
+    term: resource.identifier,
+  }).toValues();
+}`);
+//# sourceMappingURL=snippets_rdfResourceIdentifierValues.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_sequenceRecord = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sequenceRecord`, code `\
+function ${syntheticNamePrefix}sequenceRecord<T extends Record<string, unknown>>(
+  record: { [K in keyof T]: ${imports.Either}<Error, T[K]> }
+): ${imports.Either}<Error, T> {
+  const result: { [K in keyof T]?: T[K] } = {};
+
+  for (const key of globalThis.Object.keys(record) as Array<keyof T>) {
+    const either = record[key];
+    if (either.isLeft()) {
+      return either as unknown as ${imports.Either}<Error, T>;
+    }
+    result[key] = either.extract() as T[typeof key];
+  }
+
+  return ${imports.Right}(result as T);
+}`);
+//# sourceMappingURL=snippets_sequenceRecord.js.map

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_setFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}setFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<readonly ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+  return (values, options) =>
+    itemFromRdfResourceValues(values, { ...options, schema: options.schema.itemType })\
+    .map(values => values.toArray())\
+    .map(valuesArray => ${imports.Resource}.Values.fromValue({ focusResource: options.focusResource, propertyPath: options.propertyPath, value: valuesArray }));
+}`);
+//# sourceMappingURL=snippets_setFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_setSparqlConstructTriples = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setSparqlConstructTriples`, code `\
+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.itemType });
+}`);
+//# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_setSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
+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.itemType });
+
+    const minCount = filter?.${syntheticNamePrefix}minCount ?? schema.minCount ?? 0;
+    if (minCount > 0) {
+      // Required
+      return itemSparqlWherePatterns;
+    }
+    
+    const [optionalSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatterns);
+    return [{ patterns: optionalSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
+  }
+}`);
+//# sourceMappingURL=snippets_setSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_shaclPropertyFromRdf = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertyFromRdf`, code `\
+function ${syntheticNamePrefix}shaclPropertyFromRdf<TypeT, TypeSchemaT>(
+  { focusResource, graph, propertySchema, typeFromRdfResourceValues, ...otherParameters }:
+    {
+      propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
+      typeFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<TypeT, TypeSchemaT>;
+    } & Omit<Parameters<${snippets.FromRdfResourceValuesFunction}<TypeT, TypeSchemaT>>[1], "propertyPath" | "schema">
+): ${imports.Either}<Error, TypeT> {
+  return \
+      typeFromRdfResourceValues(
+        focusResource.values(propertySchema.path, { graph, unique: true }),
+        { ...otherParameters, focusResource, graph, propertyPath: propertySchema.path, schema: propertySchema.type }
+      )
+      .chain(values => values.head());
+}`);
+//# sourceMappingURL=snippets_shaclPropertyFromRdf.js.map

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

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

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

@@ -0,0 +1,90 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_shaclPropertySparqlConstructTriples = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, propertyName, propertySchema, typeSparqlConstructTriples, variablePrefix }: {
+  filter: FilterT | undefined;
+  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
+  ignoreRdfType: boolean;
+  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
+  propertyName: string;
+  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: ${snippets.PropertyPath};
+    start: ${imports.NamedNode} | ${imports.Variable};
+  }): readonly ${imports.sparqljs}.Triple[] => {
+    switch (propertyPath.termType) {
+      case "AlternativePath": {
+        return propertyPath.members.flatMap((member) =>
+          propertyPathSparqlConstructTriples({ end, propertyPath: member, start, variableCounter }),
+        );
+      }
+
+      case "InversePath": {
+        if (end.termType === "Literal") {
+          throw new Error(\`invalid term type for inverse path: \${end.termType}\`);
+        }
+
+        return propertyPathSparqlConstructTriples({
+          end: start,
+          propertyPath: propertyPath.path,
+          start: end,
+          variableCounter,
+        });
+      }
+
+      case "NamedNode": {
+        return [{ subject: start, predicate: propertyPath as NamedNode, object: end }];
+      }
+
+      case "SequencePath": {
+        if (propertyPath.members.length === 0) {
+          return [];
+        }
+
+        if (propertyPath.members.length === 1) {
+          return propertyPathSparqlConstructTriples({ end, propertyPath: propertyPath.members[0], start, variableCounter });
+        }
+
+        let triples: ${imports.sparqljs}.Triple[] = [];
+        let current: ${imports.NamedNode} | ${imports.Variable} = start;
+        for (let memberI = 0; memberI < propertyPath.members.length; memberI++) {
+          const next: ${imports.NamedNode} | ${imports.Literal} | ${imports.Variable} = memberI === propertyPath.members.length - 1
+            ? end
+            : ${imports.dataFactory}.variable(\`\${variablePrefix}\${variableCounter.value++}\`);
+          triples = triples.concat(propertyPathSparqlConstructTriples({ end: next, propertyPath: propertyPath.members[memberI], start: current, variableCounter }));
+          current = next as ${imports.NamedNode} | ${imports.Variable};
+        }
+
+        return triples;
+      }
+
+      case "OneOrMorePath":
+      case "ZeroOrMorePath":
+      case "ZeroOrOnePath": {
+        throw new Error(\`\${propertyName}: \${propertyPath.termType} property path cannot be represented as SPARQL CONSTRUCT triples\`);
+      }
+
+      default: {
+        propertyPath satisfies never;
+        throw new Error(\`\${propertyName}: unhandled property path termType: \${(propertyPath as any).termType}\`);
+      }
+    }
+  }
+
+  const valueString = \`\${variablePrefix}\${propertyName[0].toUpperCase()}\${propertyName.slice(1)}\`;
+  const valueVariable = ${imports.dataFactory}.variable!(valueString);
+
+  const variableCounter = { value: 0 };
+  return propertyPathSparqlConstructTriples({ end: valueVariable, propertyPath: propertySchema.path, start: focusIdentifier, variableCounter })
+    .concat(typeSparqlConstructTriples({
+      filter,
+      ignoreRdfType,
+      schema: propertySchema.type,
+      valueVariable,
+      variablePrefix: valueString
+    }));
+}`);
+//# sourceMappingURL=snippets_shaclPropertySparqlConstructTriples.js.map

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

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

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

@@ -0,0 +1,86 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_shaclPropertySparqlWherePatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
+function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
+  filter: FilterT | undefined;
+  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
+  ignoreRdfType: boolean;
+  preferredLanguages: readonly string[] | undefined;
+  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
+  propertyName: string;
+  typeSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
+  variablePrefix: string;
+}): readonly ${snippets.SparqlPattern}[] {
+  const propertyPathSparqlWherePatterns = ({ end, propertyPath, start, variableCounter }: {
+    end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
+    propertyPath: ${snippets.PropertyPath};
+    start: ${imports.NamedNode} | ${imports.Variable};
+    variableCounter: { value: number };
+  }): ${snippets.SparqlPattern}[] => {
+    switch (propertyPath.termType) {
+      case "AlternativePath": {
+        return [{
+          patterns: propertyPath.members.map((member) => ({
+            patterns: propertyPathSparqlWherePatterns({ end, propertyPath: member, start, variableCounter }),
+            type: "group" as const,
+          })),
+          type: "union",
+        }];
+      }
+
+      case "InversePath":
+      case "NamedNode":
+      case "OneOrMorePath":
+      case "ZeroOrMorePath":
+      case "ZeroOrOnePath": {
+        return [{
+          triples: [{ subject: start, predicate: ${snippets.sparqlPropertyPath}(propertyPath), object: end }],
+          type: "bgp"
+        }];
+      }
+
+      case "SequencePath": {
+        if (propertyPath.members.length === 0) {
+          return [];
+        }
+
+        if (propertyPath.members.length === 1) {
+          return propertyPathSparqlWherePatterns({ end, propertyPath: propertyPath.members[0], start, variableCounter });
+        }
+
+        let patterns: ${snippets.SparqlPattern}[] = [];
+        let current: ${imports.NamedNode} | ${imports.Variable} = start;
+        for (let memberI = 0; memberI < propertyPath.members.length; memberI++) {
+          const next: ${imports.NamedNode} | ${imports.Literal} | ${imports.Variable} = memberI === propertyPath.members.length - 1
+            ? end
+            : ${imports.dataFactory}.variable(\`\${variablePrefix}\${variableCounter.value++}\`);
+          patterns = patterns.concat(propertyPathSparqlWherePatterns({ end: next, propertyPath: propertyPath.members[memberI], start: current, variableCounter }));
+          current = next as ${imports.NamedNode} | ${imports.Variable};
+        }
+
+        return patterns;
+      }
+
+      default: {
+        propertyPath satisfies never;
+        throw new Error(\`\${propertyName}: unhandled property path termType: \${(propertyPath as any).termType}\`);
+      }
+    }
+  }
+
+  const valueString = \`\${variablePrefix}\${propertyName[0].toUpperCase()}\${propertyName.slice(1)}\`;
+  const valueVariable = ${imports.dataFactory}.variable!(valueString);
+
+  const variableCounter = { value: 0 };
+  const propertyPatterns = propertyPathSparqlWherePatterns({ end: valueVariable, propertyPath: propertySchema.path, start: focusIdentifier, variableCounter });
+
+  return typeSparqlWherePatterns({
+    filter,
+    ignoreRdfType,
+    preferredLanguages,
+    propertyPatterns,
+    schema: propertySchema.type,
+    valueVariable,
+    variablePrefix: valueString
+  });
+}`);
+//# sourceMappingURL=snippets_shaclPropertySparqlWherePatterns.js.map

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

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