@shaclmate/compiler 4.0.50 → 4.0.51

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashArray = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashArray`, code `\
+function ${syntheticNamePrefix}hashArray<HasherT extends ${snippets.Hasher}, ItemT>(hashItem: ${snippets.HashFunction}<HasherT, ItemT>): ${snippets.HashFunction}<HasherT, readonly ItemT[]> {
+  return (hasher, value) => {
+    for (const item of value) {
+      hashItem(hasher, item);
+    }
+    return hasher;
+  }
+}`);
+//# sourceMappingURL=snippets_hashArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashBigDecimal = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashBigDecimal`, code `\
+function ${syntheticNamePrefix}hashBigDecimal<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: ${imports.BigDecimal}): HasherT {
+  hasher.update(value.toFixed());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashBigDecimal.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashBoolean = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashBoolean`, code `\
+function ${syntheticNamePrefix}hashBoolean<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: boolean): HasherT {
+  hasher.update(value.toString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashBoolean.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashDate = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashDate`, code `\
+function ${syntheticNamePrefix}hashDate<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: Date): HasherT {
+  hasher.update(${snippets.toIsoDateString}(value));
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashDate.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashDateTime = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashDateTime`, code `\
+function ${syntheticNamePrefix}hashDateTime<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: Date): HasherT {
+  hasher.update(value.toISOString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashDateTime.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashMaybe`, code `\
+function ${syntheticNamePrefix}hashMaybe<HasherT extends ${snippets.Hasher}, ItemT>(hashItem: ${snippets.HashFunction}<HasherT, ItemT>): ${snippets.HashFunction}<HasherT, ${imports.Maybe}<ItemT>> {
+  return (hasher, value) => {
+    value.ifJust(value => {
+      hashItem(hasher, value);
+    });
+    return hasher;
+  }
+}`);
+//# sourceMappingURL=snippets_hashMaybe.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashNumeric = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashNumeric`, code `\
+function ${syntheticNamePrefix}hashNumeric<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: bigint | number): HasherT {
+  hasher.update(value.toString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashNumeric.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashString`, code `\
+function ${syntheticNamePrefix}hashString<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: string): HasherT {
+  hasher.update(value);
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashString.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashTerm = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashTerm`, code `\
+function ${syntheticNamePrefix}hashTerm<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}): HasherT {
+  hasher.update(value.termType);
+  hasher.update(value.value);
+  if (value.termType === "Literal") {
+    hasher.update(value.datatype.value);
+    hasher.update(value.language);
+  }
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashTerm.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identifierFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}identifierFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.BlankNode} | ${imports.NamedNode}>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toIdentifier()));
+}`);
+//# sourceMappingURL=snippets_identifierFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,30 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identifierSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}identifierSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${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_identityConversionFunction.d.ts

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identityConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityConversionFunction`, code `\
+function ${syntheticNamePrefix}identityConversionFunction<T>(value: T): ${imports.Either}<Error, T> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_identityConversionFunction.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_identityValidationFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityValidationFunction`, code `\
+function ${syntheticNamePrefix}identityValidationFunction<T>(_schema: unknown, value: T): ${imports.Either}<Error, T> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_identityValidationFunction.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_intFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}intFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}intFromRdfResourceValues<IntT extends number>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<IntT>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toInt(options.schema.in) : value.toInt() as Either<Error, IntT>));
+}`);
+//# sourceMappingURL=snippets_intFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}iriFromRdfResourceValues<IriT extends string = string>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.NamedNode}<IriT>, ${snippets.IriSchema}<IriT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.NamedNode}<IriT>>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toIri(options.schema.in) : value.toIri() as ${imports.Either}<Error, ${imports.NamedNode}<IriT>>));
+}`);
+//# sourceMappingURL=snippets_iriFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}iriSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.IriFilter}, ${snippets.IriSchema}<string>> =
+  ({ 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}({ ...otherParameters, filterPatterns, valueVariable });
+  };`);
+//# sourceMappingURL=snippets_iriSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_liftSparqlPatterns = ({ snippets, syntheticNamePrefix, }) => 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_listFromRdfResourceValues.d.ts

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

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_listFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}listFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<readonly ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+  return (values, options) =>
+    values\
+      .chainMap(value => value.toList({ graph: options.graph }))\ // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>;
+      .chain(valueLists => valueLists.chainMap(valueList =>
+        itemFromRdfResourceValues(
+          ${imports.Resource}.Values.fromArray({ focusResource: options.focusResource, propertyPath: options.propertyPath, values: valueList.toArray() }),
+          { ...options, schema: options.schema.itemType }
+        )
+      ))\ // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
+      .map(valueLists => valueLists.map(valueList => valueList.toArray())); // Convert inner Resource.Values to arrays
+}`);
+//# sourceMappingURL=snippets_listFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,37 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_listSparqlConstructTriples = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
+  return ({ filter, schema, valueVariable: listVariable, variablePrefix: variablePrefixPrefix }) => {
+    let triples: ${imports.sparqljs}.Triple[] = [];
+    const variable = (suffix: string) => ${imports.dataFactory}.variable!(\`\${variablePrefixPrefix}\${suffix}\`);
+    const variablePrefix = (suffix: string) => \`\${variablePrefixPrefix}\${suffix}\`;
+
+    {
+      // ?list rdf:first ?item0
+      const item0Variable = variable("Item0");
+      triples.push({ subject: listVariable, predicate: ${snippets.RdfVocabularies}.rdf.first, object: item0Variable });
+      triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.itemType, 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, ignoreRdfType: false, schema: schema.itemType, 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,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_listSparqlWherePatterns: SnippetFactory;
+//# sourceMappingURL=snippets_listSparqlWherePatterns.d.ts.map

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

@@ -0,0 +1,116 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_listSparqlWherePatterns = ({ imports, rdfjsTermExpression, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listSparqlWherePatterns`, code `\
+function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
+  return (parameters) => {
+    // Need to handle two cases:
+    // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
+    // (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,
+          ignoreRdfType: parameters.ignoreRdfType,
+          preferredLanguages: parameters.preferredLanguages,
+          propertyPatterns: [],
+          schema: parameters.schema.itemType,
+          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,
+          ignoreRdfType: parameters.ignoreRdfType,
+          preferredLanguages: parameters.preferredLanguages,
+          propertyPatterns: [],
+          schema: parameters.schema.itemType,
+          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,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_literalFactory: SnippetFactory;
+//# sourceMappingURL=snippets_literalFactory.d.ts.map

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}literalFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LiteralSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.Literal}>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLiteral()));
+}`);
+//# sourceMappingURL=snippets_literalFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,39 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalSchemaSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => 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,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_literalSparqlWherePatterns: SnippetFactory;
+//# sourceMappingURL=snippets_literalSparqlWherePatterns.d.ts.map

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

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.LiteralFilter}, ${snippets.LiteralSchema}> =
+  (parameters) => ${syntheticNamePrefix}literalSchemaSparqlPatterns({ filterPatterns: ${snippets.termFilterSparqlPatterns}(parameters), ...parameters });`);
+//# sourceMappingURL=snippets_literalSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,31 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeEquals = ({ imports, snippets, syntheticNamePrefix, }) => 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_maybeFromRdfResourceValues.d.ts

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}maybeFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<${imports.Maybe}<ItemT>, ${snippets.MaybeSchema}<ItemSchemaT>> {
+  return (values, options) =>
+    itemFromRdfResourceValues(values, { ...options, schema: options.schema.itemType })\
+      .map(values => values.length > 0
+        ? values.map(value => ${imports.Maybe}.of(value))
+        : ${imports.Resource}.Values.fromValue<${imports.Maybe}<ItemT>>({ focusResource: options.focusResource, propertyPath: options.propertyPath, value: ${imports.Maybe}.empty() })
+      );
+}`);
+//# sourceMappingURL=snippets_maybeFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeSparqlConstructTriples = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.MaybeFilter}<ItemFilterT>, ${snippets.MaybeSchema}<ItemSchemaT>> {  
+  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.itemType });
+}`);
+//# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map