@shaclmate/compiler 4.0.41 → 4.0.43

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLazy = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazy`, code `\
+function ${syntheticNamePrefix}convertToLazy<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
+  return (value: ${snippets.Lazy}<PartialT, ResolvedT> | ResolvedT): ${imports.Either}<Error, ${snippets.Lazy}<PartialT, ResolvedT>> => {
+    if (value instanceof ${snippets.Lazy}) {
+      return ${imports.Either}.of(value);
+    }
+
+    return ${imports.Either}.of(new ${snippets.Lazy}({
+      partial: resolvedToPartial(value),
+      resolver: async () => ${imports.Right}(value)
+    }));
+  };
+}`);
+//# sourceMappingURL=snippets_convertToLazy.js.map

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

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

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

@@ -0,0 +1,33 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLazyOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyOption`, code `\
+function ${syntheticNamePrefix}convertToLazyOption<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
+  return (value: ${snippets.LazyOption}<PartialT, ResolvedT> | ${imports.Maybe}<ResolvedT> | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazyOption}<PartialT, ResolvedT>> => {
+    switch (typeof value) {
+      case "object": {
+        if (value instanceof ${snippets.LazyOption}) {
+          return ${imports.Either}.of(value);
+        }
+
+        if (${imports.Maybe}.isMaybe(value)) {
+          return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
+            partial: value.map(resolvedToPartial),
+            resolver: async () => ${imports.Right}(value.unsafeCoerce())
+          }));
+        }
+
+        break;
+      }
+      case "undefined":
+        return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
+          partial: ${imports.Maybe}.empty(),
+          resolver: async () => { throw new Error("should never be called"); }
+        }));
+    }
+
+    return ${imports.Either}.of(new ${snippets.LazyOption}<PartialT, ResolvedT>({
+      partial: ${imports.Maybe}.of(resolvedToPartial(value)),
+      resolver: async () => ${imports.Right}(value)
+    }));
+  };
+}`);
+//# sourceMappingURL=snippets_convertToLazyOption.js.map

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

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

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

@@ -0,0 +1,27 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLazySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazySet`, code `\
+function ${syntheticNamePrefix}convertToLazySet<PartialT, ResolvedT>(resolvedToPartial: (resolved: ResolvedT) => PartialT) {
+  return (value: ${snippets.LazySet}<PartialT, ResolvedT> | readonly ResolvedT[] | undefined): ${imports.Either}<Error, ${snippets.LazySet}<PartialT, ResolvedT>> => {
+    switch (typeof value) {
+      case "object": {
+        if (value instanceof ${snippets.LazySet}) {
+          return ${imports.Either}.of(value);
+        }
+
+        break;
+      }
+      case "undefined":
+        return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
+          partials: [],
+          resolver: async () => ${imports.Right}([])
+        }));
+    }
+
+    const captureValue = value;
+    return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
+      partials: value.map(resolvedToPartial),
+      resolver: async () => ${imports.Right}(captureValue)
+    }));
+  };
+}`);
+//# sourceMappingURL=snippets_convertToLazySet.js.map

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_defaultValueFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}defaultValueFromRdfResourceValues<ItemT, ItemSchemaT>(itemFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<ItemT, ItemSchemaT>): ${snippets.FromRdfResourceValuesFunction}<ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
+  return (values, options) =>
+    itemFromRdfResourceValues(
+      values.length > 0 ? values : new ${imports.Resource}.Value({ dataFactory: ${imports.dataFactory}, focusResource: options.focusResource, propertyPath: options.propertyPath, term: options.schema.defaultValue }).toValues(),
+      { ...options, schema: options.schema.itemType }
+    );
+}`);
+//# sourceMappingURL=snippets_defaultValueFromRdfResourceValues.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets.DefaultValueSchema}<unknown, ItemSchemaT>> {  
+function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
     const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.itemType }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_filterNumeric = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}filterNumeric`, code `\
-function ${syntheticNamePrefix}filterNumeric<T extends bigint | number>(filter: ${snippets.NumericFilter}<T>, value: T) {
+function ${syntheticNamePrefix}filterNumeric<NumericT extends bigint | number>(filter: ${snippets.NumericFilter}<NumericT>, value: NumericT) {
   if (filter.in !== undefined && !filter.in.some(inValue => inValue === value)) {
     return false;
   }

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_filterTerm = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}filterTerm`, code `\
-  function ${syntheticNamePrefix}filterTerm(filter: ${snippets.TermFilter}, value: ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}): boolean {
+  function ${syntheticNamePrefix}filterTerm<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(filter: ${snippets.TermFilter}<TermT>, value: ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}): boolean {
     if (filter.datatypeIn !== undefined && (value.termType !== "Literal" || !filter.datatypeIn.some(inDatatype => inDatatype.equals(value.datatype)))) {
       return false;
     }
@@ -8,7 +8,6 @@ export const snippets_filterTerm = ({ imports, snippets, syntheticNamePrefix, })
     if (filter.in !== undefined && !filter.in.some(inTerm => inTerm.equals(value))) {
       return false;
     }
-
   
     if (filter.languageIn !== undefined && (value.termType !== "Literal" || !filter.languageIn.some(inLanguage => inLanguage === value.language))) {
       return false;

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_floatFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}floatFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}floatFromRdfResourceValues<FloatT extends number>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<FloatT>> {
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => options.schema.in ? value.toFloat(options.schema.in) : value.toFloat() as ${imports.Either}<Error, FloatT>));
+}`);
+//# sourceMappingURL=snippets_floatFromRdfResourceValues.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_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_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_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_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_mutableListFromRdfResourceValues.d.ts

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_numericSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
-function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<T>, ${snippets.NumericSchema}<T>>>[0]): ReturnType<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<T>, ${snippets.NumericSchema}<T>>> {
+function $numericSparqlWherePatterns<NumericT extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<NumericT>, ${snippets.NumericSchema}<NumericT>>>[0]): ReturnType<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<NumericT>, ${snippets.NumericSchema}<NumericT>>> {
   const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 
   if (filter) {

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_termFilterSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
-function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets.TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
+function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets.TermFilter}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
   if (!filter) {
     return [];
   }

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_termFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}termFromRdfResourceValues<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<TermT, ${snippets.TermSchema}<TermT>>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<TermT>> {
+  const { focusResource, propertyPath, schema } = options;
+  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toTerm().chain(term => {
+    if (schema.in && schema.in.length > 0 && !schema.in.some(in_ => in_.equals(term))) {
+      return ${imports.Left}(new ${imports.Resource}.MistypedTermValueError({ actualValue: term, expectedValueType: "Term in", focusResource, propertyPath }));
+    }
+
+    if (!schema.types.some(type => term.termType === type)) {
+      return ${imports.Left}(new ${imports.Resource}.MistypedTermValueError({ actualValue: term, expectedValueType: "Term types", focusResource, propertyPath }));
+    }
+
+    return ${imports.Right}(term as TermT);
+  })));
+}`);
+//# sourceMappingURL=snippets_termFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,60 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_termLikeFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termLikeFromRdfResourceValues`, code `\
+const ${syntheticNamePrefix}termLikeFromRdfResourceValues:
+  ${snippets.FromRdfResourceValuesFunction}<${imports.Resource}.Value, {
+    readonly hasValues?: readonly (${imports.Literal} | ${imports.NamedNode})[];
+    readonly languageIn?: readonly string[];
+  }> = (values, { preferredLanguages, schema: { hasValues, languageIn } }) => {
+    let chain = ${imports.Either}.of<Error, ${imports.Resource}.Values>(values);
+
+    if (hasValues && hasValues.length > 0) {
+      chain = chain.chain(values => ${imports.Either}.sequence(hasValues.map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values));
+    }
+
+    if (languageIn && languageIn.length > 0) {
+      chain = chain.chain(values => values.chainMap(value => value.toLiteral().chain(literal =>
+        languageIn.includes(literal.language) ?
+          ${imports.Right}(value) :
+          ${imports.Left}(new ${imports.Resource}.MistypedTermValueError(${{
+    actualValue: code `literal`,
+    expectedValueType: "Literal",
+    focusResource: code `value.focusResource`,
+    propertyPath: code `value.propertyPath`,
+}}))
+      )));
+    }
+
+    if (preferredLanguages && preferredLanguages.length > 0) {
+      chain = chain.chain(values => {
+        const literals: ${imports.Literal}[] = [];
+        const literalValues: ${imports.Resource}.Value[] = [];
+        const nonLiteralValues: ${imports.Resource}.Value[] = [];
+
+        for (const value of values) {
+          const term = value.toTerm().unsafeCoerce();
+          if (term.termType === "Literal") {
+            literals.push(term);
+            literalValues.push(value);
+          } else {
+            nonLiteralValues.push(value);
+          }
+        }
+
+        // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+        // Within a preferredLanguage the literals may be in any order.
+        const preferredLanguageLiteralValues: ${imports.Resource}.Value[] = [];
+        for (const preferredLanguage of preferredLanguages) {
+          for (let literalI = 0; literalI < literals.length; literalI++) {
+            if (literals[literalI].language === preferredLanguage) {
+              preferredLanguageLiteralValues.push(literalValues[literalI]);
+            }
+          }
+        }
+
+        return ${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: values.focusResource, propertyPath: values.propertyPath, values: nonLiteralValues.concat(preferredLanguageLiteralValues) }));
+      });
+    }
+
+    return chain;
+  };`);
+//# sourceMappingURL=snippets_termLikeFromRdfResourceValues.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_termSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.TermFilter}, ${snippets.TermSchema}> =
+export const snippets_termSparqlWherePatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.TermFilter}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>, ${snippets.TermSchema}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>> =
   (parameters) => ${snippets.termSchemaSparqlPatterns}({ filterPatterns: ${snippets.termFilterSparqlPatterns}(parameters), ...parameters })`);
 //# sourceMappingURL=snippets_termSparqlWherePatterns.js.map