@shaclmate/compiler 3.0.4 → 4.0.0

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

@@ -0,0 +1,36 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+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";
+export const snippets_identifierSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}identifierSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}identifierSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_IdentifierFilter}, ${snippets_IdentifierSchema}> =
+  ({ filter, propertyPatterns, valueVariable }) => {
+    const patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
+
+    if (filter) {
+      if (filter.in !== undefined) {
+        const valueIn = filter.in.filter(identifier => identifier.termType === "NamedNode");
+        if (valueIn.length > 0) {
+          patterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn }));
+        }
+      }
+
+      if (filter.type !== undefined) {
+        patterns.push({
+          expression: {
+            type: "operation",
+            operator: filter.type === "BlankNode" ? "isBlank" : "isIRI",
+            args: [valueVariable],
+          },
+          lift: true,
+          type: "filter",
+        });
+      }
+    }
+
+    return patterns;
+  }`);
+//# sourceMappingURL=snippets_identifierSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,20 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+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";
+export const snippets_iriSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}iriSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_IriFilter}, ${snippets_IriSchema}> =
+  ({ filter, valueVariable, ...otherParameters }) => {
+    const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+
+    if (filter?.in !== undefined && filter.in.length > 0) {
+      filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+    }
+
+    return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+  };`);
+//# sourceMappingURL=snippets_iriSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_isReadonlyBigIntArray = conditionalOutput(`${syntheticNamePrefix}isReadonlyBigIntArray`, code `\
+function ${syntheticNamePrefix}isReadonlyBigIntArray(x: unknown): x is readonly bigint[] {
+  return Array.isArray(x) && x.every(z => typeof z === "bigint");
+}`);
+//# sourceMappingURL=snippets_isReadonlyBigIntArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_isReadonlyBooleanArray = conditionalOutput(`${syntheticNamePrefix}isReadonlyBooleanArray`, code `\
+function ${syntheticNamePrefix}isReadonlyBooleanArray(x: unknown): x is readonly boolean[] {
+  return Array.isArray(x) && x.every(z => typeof z === "boolean");
+}`);
+//# sourceMappingURL=snippets_isReadonlyBooleanArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_isReadonlyNumberArray = conditionalOutput(`${syntheticNamePrefix}isReadonlyNumberArray`, code `\
+function ${syntheticNamePrefix}isReadonlyNumberArray(x: unknown): x is readonly number[] {
+  return Array.isArray(x) && x.every(z => typeof z === "number");
+}`);
+//# sourceMappingURL=snippets_isReadonlyNumberArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_isReadonlyObjectArray = conditionalOutput(`${syntheticNamePrefix}isReadonlyObjectArray`, code `\
+function ${syntheticNamePrefix}isReadonlyObjectArray(x: unknown): x is readonly object[] {
+  return Array.isArray(x) && x.every(z => typeof z === "object");
+}`);
+//# sourceMappingURL=snippets_isReadonlyObjectArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_isReadonlyStringArray = conditionalOutput(`${syntheticNamePrefix}isReadonlyStringArray`, code `\
+function ${syntheticNamePrefix}isReadonlyStringArray(x: unknown): x is readonly string[] {
+  return Array.isArray(x) && x.every(z => typeof z === "string");
+}`);
+//# sourceMappingURL=snippets_isReadonlyStringArray.js.map

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

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

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

@@ -0,0 +1,18 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+export const snippets_liftSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}liftSparqlPatterns`, code `\
+function ${syntheticNamePrefix}liftSparqlPatterns(patterns: Iterable<${snippets_SparqlPattern}>): [readonly ${snippets_SparqlPattern}[], readonly ${snippets_SparqlFilterPattern}[]] {
+  const liftedPatterns: ${snippets_SparqlFilterPattern}[] = [];
+  const unliftedPatterns: ${snippets_SparqlPattern}[] = [];
+  for (const pattern of patterns) {
+    if (pattern.type === "filter" && pattern.lift) {
+      liftedPatterns.push(pattern);
+    } else {
+      unliftedPatterns.push(pattern); 
+    }
+  }
+  return [unliftedPatterns, liftedPatterns];
+}`);
+//# sourceMappingURL=snippets_liftSparqlPatterns.js.map

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

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

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

@@ -0,0 +1,43 @@
+import { imports } from "../imports.js";
+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_RdfVocabularies } from "./snippets_RdfVocabularies.js";
+import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
+export const snippets_listSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
+  return ({ filter, schema, valueVariable: listVariable, ...otherParameters }) => {
+    let triples: ${imports.sparqljs}.Triple[] = [];
+    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${otherParameters.variablePrefix}\${suffix}\`);
+    const variablePrefix = (suffix: string) => \`\${otherParameters.variablePrefix}\${suffix}\`;
+
+    {
+      // ?list rdf:first ?item0
+      const item0Variable = variable("Item0");
+      triples.push({ subject: listVariable, predicate: ${snippets_RdfVocabularies}.rdf.first, object: item0Variable });
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, schema: schema.item(), valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
+    }
+
+    {
+      // ?list rdf:rest ?rest0
+      triples.push({ subject: listVariable, predicate: ${snippets_RdfVocabularies}.rdf.rest, object: variable("Rest0") });
+    }
+
+    // Don't do ?list rdf:rest+ ?restN in CONSTRUCT
+    const restNVariable = variable("RestN");
+
+    {
+      // ?rest rdf:first ?itemN
+      const itemNVariable = variable("ItemN");
+      triples.push({ subject: restNVariable, predicate: ${snippets_RdfVocabularies}.rdf.first, object: itemNVariable });
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, schema: schema.item(), valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
+    }
+
+    // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
+    triples.push({ subject: restNVariable, predicate: ${snippets_RdfVocabularies}.rdf.rest, object: variable("RestNBasic") });
+
+    return triples;
+  }
+}`);
+//# sourceMappingURL=snippets_listSparqlConstructTriples.js.map

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

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

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

@@ -0,0 +1,121 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+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_SparqlPattern } from "./snippets_SparqlPattern.js";
+import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.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>> {
+  return (parameters) => {
+    // Need to handle two cases:
+    // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
+    // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
+    // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
+
+    const listVariable = parameters.valueVariable;
+    const patterns: ${snippets_SparqlPattern}[] = [];
+    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${parameters.variablePrefix}\${suffix}\`);
+    const variablePrefix = (suffix: string) => \`\${parameters.variablePrefix}\${suffix}\`;
+
+    {
+      // ?list rdf:first ?item0
+      const item0Variable = variable("Item0");
+      patterns.push(
+        {
+          triples: [
+            {
+              subject: listVariable,
+              predicate: ${rdfjsTermExpression(rdf.first)},
+              object: item0Variable,
+            },
+          ],
+          type: "bgp",
+        },
+        ...itemSparqlWherePatternsFunction({
+          filter: parameters.filter,
+          preferredLanguages: parameters.preferredLanguages,
+          propertyPatterns: [],
+          schema: parameters.schema.item(),
+          valueVariable: item0Variable,
+          variablePrefix: variablePrefix("Item0"),
+        }),
+      );
+    }
+
+    {
+      // ?list rdf:rest ?rest0
+      const rest0Variable = variable("Rest0");
+      patterns.push({
+        triples: [
+          {
+            subject: listVariable,
+            predicate: ${rdfjsTermExpression(rdf.rest)},
+            object: rest0Variable,
+          },
+        ],
+        type: "bgp",
+      });
+    }
+
+    const optionalPatterns: ${snippets_SparqlPattern}[] = [];
+    
+    const restNVariable = variable("RestN");
+    // ?list rdf:rest+ ?restN
+    optionalPatterns.push({
+      type: "bgp",
+      triples: [
+        {
+          subject: listVariable,
+          predicate: { type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest)}] },
+          object: restNVariable,
+        },
+      ],
+    });
+
+    {
+      // ?rest rdf:first ?itemN
+      const itemNVariable = variable("ItemN");
+      optionalPatterns.push(
+        {
+          triples: [
+            {
+              subject: restNVariable,
+              predicate: ${rdfjsTermExpression(rdf.first)},
+              object: itemNVariable,
+            },
+          ],
+          type: "bgp"
+        },
+        ...itemSparqlWherePatternsFunction({
+          filter: parameters.filter,
+          preferredLanguages: parameters.preferredLanguages,
+          propertyPatterns: [],
+          schema: parameters.schema.item(),
+          valueVariable: itemNVariable,
+          variablePrefix: variablePrefix("ItemN"),
+        }),
+      );
+    }
+
+    // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
+    optionalPatterns.push({
+      triples: [
+        {
+          subject: restNVariable,
+          predicate: ${rdfjsTermExpression(rdf.rest)},
+          object: variable("RestNBasic"),
+        },
+      ],
+      type: "bgp"
+    });
+
+    patterns.push({ type: "optional", patterns: optionalPatterns });
+
+    // Having an optional around everything handles the rdf:nil case
+    return [...parameters.propertyPatterns, { patterns, type: "optional" }];
+  }
+}`);
+//# sourceMappingURL=snippets_listSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalFactory = conditionalOutput(`${syntheticNamePrefix}literalFactory`, code `const ${syntheticNamePrefix}literalFactory = new ${imports.LiteralFactory}({ dataFactory: ${imports.dataFactory} });`);
+//# sourceMappingURL=snippets_literalFactory.js.map

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

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

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

@@ -0,0 +1,45 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_arrayIntersection } from "./snippets_arrayIntersection.js";
+import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
+export const snippets_literalSchemaSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}literalSchemaSparqlPatterns`, code `\
+function ${syntheticNamePrefix}literalSchemaSparqlPatterns({
+  filterPatterns,
+  preferredLanguages,
+  propertyPatterns,
+  schema,
+  valueVariable
+}: {
+  filterPatterns: readonly ${snippets_SparqlFilterPattern}[],
+  preferredLanguages?: readonly string[];
+  propertyPatterns: readonly ${snippets_SparqlPattern}[];
+  schema: Readonly<{
+    languageIn?: readonly string[];
+    in?: readonly (bigint | boolean | Date | string | number | ${imports.Literal} | ${imports.NamedNode})[];
+  }>,
+  valueVariable: ${imports.Variable};
+}): readonly ${snippets_SparqlPattern}[] {
+  let patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
+
+  if (schema.in && schema.in.length > 0) {
+    patterns.push(${snippets_sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
+  }
+
+  const languageIn = ${snippets_arrayIntersection}(schema.languageIn ?? [], preferredLanguages ?? []);
+  if (languageIn.length > 0) {
+    patterns.push({
+      expression: {
+        args: [{ args: [valueVariable], operator: "lang", type: "operation" }, languageIn.map(_ => ${imports.dataFactory}.literal(_))],
+        operator: "in",
+        type: "operation"
+      },
+      type: "filter",
+    });
+  }
+
+  return patterns.concat(filterPatterns);
+}`);
+//# sourceMappingURL=snippets_literalSchemaSparqlPatterns.js.map

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

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

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

@@ -0,0 +1,10 @@
+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";
+export const snippets_literalSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}literalSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_LiteralFilter}, ${snippets_LiteralSchema}> =
+  (parameters) => ${syntheticNamePrefix}literalSchemaSparqlPatterns({ filterPatterns: ${snippets_termFilterSparqlPatterns}(parameters), ...parameters });`);
+//# sourceMappingURL=snippets_literalSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,34 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_EqualsResult } from "./snippets_EqualsResult.js";
+export const snippets_maybeEquals = conditionalOutput(`${syntheticNamePrefix}maybeEquals`, code `\
+function ${syntheticNamePrefix}maybeEquals<T>(
+  leftMaybe: ${imports.Maybe}<T>,
+  rightMaybe: ${imports.Maybe}<T>,
+  valueEquals: (left: T, right: T) => boolean | ${snippets_EqualsResult},
+): ${snippets_EqualsResult} {
+  if (leftMaybe.isJust()) {
+    if (rightMaybe.isJust()) {
+      return ${snippets_EqualsResult}.fromBooleanEqualsResult(
+        leftMaybe,
+        rightMaybe,
+        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
+      );
+    }
+    return ${imports.Left}({
+      left: leftMaybe.unsafeCoerce(),
+      type: "right-null",
+    });
+  }
+
+  if (rightMaybe.isJust()) {
+    return ${imports.Left}({
+      right: rightMaybe.unsafeCoerce(),
+      type: "left-null",
+    });
+  }
+
+  return ${snippets_EqualsResult}.Equal;
+}`);
+//# sourceMappingURL=snippets_maybeEquals.js.map

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

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

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

@@ -0,0 +1,10 @@
+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";
+export const snippets_maybeSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
+  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ filter: filter ?? undefined, schema: schema.item(), ...otherParameters });
+}`);
+//# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map

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

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

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

@@ -0,0 +1,26 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+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";
+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>> {  
+  return ({ filter, schema, ...otherParameters }) => {
+    if (filter === undefined) {
+      // Treat the item's patterns as optional
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters }));
+      return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
+    }
+      
+    if (filter === null) {
+      // Use FILTER NOT EXISTS around the item's patterns
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ schema: schema.item(), ...otherParameters }));
+      return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
+    }
+
+    // Treat the item as required.
+    return itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+  }
+}`);
+//# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,97 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_deduplicateSparqlPatterns } from "./snippets_deduplicateSparqlPatterns.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+import { snippets_SparqlPattern_isSolutionGenerating } from "./snippets_SparqlPattern_isSolutionGenerating.js";
+import { snippets_sortSparqlPatterns } from "./snippets_sortSparqlPatterns.js";
+export const snippets_normalizeSparqlWherePatterns = 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,2 @@
+export declare const snippets_numericSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_numericSparqlWherePatterns.d.ts.map