@shaclmate/compiler 3.0.4 → 4.0.0

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

@@ -0,0 +1,71 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+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";
+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}[] {
+  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}({ filterPatterns, valueVariable, ...otherParameters });
+}`);
+//# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

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

@@ -0,0 +1,2 @@
+export declare const snippets_setSparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_setSparqlConstructTriples.d.ts.map

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

@@ -0,0 +1,10 @@
+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";
+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 });
+}`);
+//# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

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

@@ -0,0 +1,2 @@
+export declare const snippets_setSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_setSparqlWherePatterns.d.ts.map

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

@@ -0,0 +1,22 @@
+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_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
+import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.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>> {
+  return ({ filter, schema, ...otherParameters }) => {
+    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+
+    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,2 @@
+export declare const snippets_shaclPropertyFromRdf: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_shaclPropertyFromRdf.d.ts.map

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

@@ -0,0 +1,14 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
+export const snippets_shaclPropertyFromRdf = conditionalOutput(`${syntheticNamePrefix}shaclPropertyFromRdf`, code `\
+function ${syntheticNamePrefix}shaclPropertyFromRdf<T>({ graph, propertySchema, resource, typeFromRdf }: {
+  graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+  propertySchema: ${snippets_ShaclPropertySchema};
+  resource: ${imports.Resource};
+  typeFromRdf: (resourceValues: ${imports.Either}<Error, ${imports.Resource}.Values>) => ${imports.Either}<Error, ${imports.Resource}.Values<T>>;
+}): ${imports.Either}<Error, T> {
+  return typeFromRdf(${imports.Right}(resource.values(propertySchema.path, { graph, unique: true }))).chain(values => values.head());
+}`);
+//# sourceMappingURL=snippets_shaclPropertyFromRdf.js.map

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

@@ -0,0 +1,2 @@
+export declare const snippets_shaclPropertySparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_shaclPropertySparqlConstructTriples.d.ts.map

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

@@ -0,0 +1,94 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+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;
+  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
+  ignoreRdfType?: boolean;
+  propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
+  propertyName: string;
+  typeSparqlConstructTriples: ${snippets_SparqlConstructTriplesFunction}<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};
+    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,2 @@
+export declare const snippets_shaclPropertySparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_shaclPropertySparqlWherePatterns.d.ts.map

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

@@ -0,0 +1,92 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.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";
+export const snippets_shaclPropertySparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
+function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
+  filter?: FilterT;
+  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
+  ignoreRdfType?: boolean;
+  preferredLanguages?: readonly string[];
+  propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
+  propertyName: string;
+  typeSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
+  variablePrefix: string;
+}): readonly ${snippets_SparqlPattern}[] {
+  const propertyPathSparqlWherePatterns = ({ end, propertyPath, start, variableCounter }: {
+    end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
+    propertyPath: ${imports.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,2 @@
+export declare const snippets_sortSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_sortSparqlPatterns.d.ts.map

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

@@ -0,0 +1,26 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+export const snippets_sortSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}sortSparqlPatterns`, code `\
+function ${syntheticNamePrefix}sortSparqlPatterns(patterns: readonly ${snippets_SparqlPattern}[]): readonly ${snippets_SparqlPattern}[] {
+  const filterPatterns: ${snippets_SparqlPattern}[] = [];
+  const otherPatterns: ${snippets_SparqlPattern}[] = [];
+  const valuesPatterns: ${snippets_SparqlPattern}[] = [];
+
+  for (const pattern of patterns) {
+    switch (pattern.type) {
+      case "filter":
+        filterPatterns.push(pattern);
+        break;
+      case "values":
+        valuesPatterns.push(pattern);
+        break;
+      default:
+        otherPatterns.push(pattern);
+        break;
+    }
+  }
+
+  return valuesPatterns.concat(otherPatterns).concat(filterPatterns);
+}`);
+//# sourceMappingURL=snippets_sortSparqlPatterns.js.map

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

@@ -0,0 +1,2 @@
+export declare const snippets_sparqlInstancesOfPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_sparqlInstancesOfPattern.d.ts.map

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

@@ -0,0 +1,32 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
+export const snippets_sparqlInstancesOfPattern = conditionalOutput(`${syntheticNamePrefix}sparqlInstancesOfPattern`, code `\
+/**
+ * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .
+ */
+function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: { rdfType: ${imports.NamedNode} | ${imports.Variable}, subject: ${imports.sparqljs}.Triple["subject"] }): ${imports.sparqljs}.BgpPattern {
+  return {
+    triples: [
+      {
+        subject,
+        predicate: {
+          items: [
+            ${snippets_RdfVocabularies}.rdf.type,
+            {
+              items: [${snippets_RdfVocabularies}.rdfs.subClassOf],
+              pathType: "*",
+              type: "path",
+            },
+          ],
+          pathType: "/",
+          type: "path",
+        },
+        object: rdfType,
+      },
+    ],
+    type: "bgp",
+  };
+}`);
+//# sourceMappingURL=snippets_sparqlInstancesOfPattern.js.map

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

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

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

@@ -0,0 +1,61 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_sparqlPropertyPath = conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
+/**
+ * Convert a ${imports.PropertyPath} to a ${imports.sparqljs}.PropertyPath.
+ */  
+function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${imports.PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
+  switch (propertyPath.termType) {
+    case "AlternativePath":
+      return {
+        type: "path",
+        pathType: "|",
+        items: propertyPath.members.map(${syntheticNamePrefix}sparqlPropertyPath),
+      };
+
+    case "InversePath":
+      return {
+        type: "path",
+        pathType: "^",
+        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
+      };
+
+    case "NamedNode":
+      return propertyPath;
+
+    case "OneOrMorePath":
+      return {
+        type: "path",
+        pathType: "+",
+        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
+      };
+
+    case "SequencePath":
+      return {
+        type: "path",
+        pathType: "/",
+        items: propertyPath.members.map(${syntheticNamePrefix}sparqlPropertyPath),
+      };
+
+    case "ZeroOrMorePath":
+      return {
+        type: "path",
+        pathType: "*",
+        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
+      };
+
+    case "ZeroOrOnePath":
+      return {
+        type: "path",
+        pathType: "?",
+        items: [${syntheticNamePrefix}sparqlPropertyPath(propertyPath.path)],
+      };
+
+    default: {
+      propertyPath satisfies never;
+      throw new Error(\`unhandled property path termType: \${(propertyPath as any).termType}\`);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_sparqlPropertyPath.js.map

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_literalFactory } from "./snippets_literalFactory.js";
+import { snippets_literalSchemaSparqlPatterns } from "./snippets_literalSchemaSparqlPatterns.js";
+import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
+import { snippets_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";
+export const snippets_stringSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_StringFilter}, ${snippets_StringSchema}> =
+  ({ filter, valueVariable, ...otherParameters }) => {
+    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.maxLength !== undefined) {
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: "<=",
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.maxLength)],
+          },
+          lift: true,
+          type: "filter",
+        });
+      }
+
+      if (filter.minLength !== undefined) {
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: ">=",
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.minLength)],
+          },
+          lift: true,
+          type: "filter",
+        });
+      }
+    }
+
+    return ${snippets_literalSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+  }`);
+//# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

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

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