@shaclmate/compiler 4.0.40 → 4.0.42

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