@shaclmate/compiler 4.0.50 → 4.0.51

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/generators/ts/_snippets/snippets_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_stringSparqlWherePatterns.d.ts

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

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

@@ -0,0 +1,39 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_stringSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}<string>> =
+  ({ filter, valueVariable, ...otherParameters }) => {
+    const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
+
+    if (filter) {
+      if (filter.in !== undefined && filter.in.length > 0) {
+        filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+      }
+
+      if (filter.maxLength !== undefined) {
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: "<=",
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.maxLength)],
+          },
+          lift: true,
+          type: "filter",
+        });
+      }
+
+      if (filter.minLength !== undefined) {
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: ">=",
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.minLength)],
+          },
+          lift: true,
+          type: "filter",
+        });
+      }
+    }
+
+    return ${snippets.literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+  }`);
+//# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,93 @@
+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}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
+  if (!filter) {
+    return [];
+  }
+
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
+
+  if (
+    filter.datatypeIn !== undefined &&
+    filter.datatypeIn.length > 0
+  ) {
+    filterPatterns.push({
+      expression: {
+        type: "operation",
+        operator: "in",
+        args: [
+          { args: [valueVariable], operator: "datatype", type: "operation" },
+          filter.datatypeIn.concat(),
+        ],
+      },
+      lift: true,
+      type: "filter",
+    });
+  }
+
+  if (filter.in !== undefined && filter.in.length > 0) {
+    filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+  }
+
+  if (
+    filter.languageIn !== undefined &&
+    filter.languageIn.length > 0
+  ) {
+    filterPatterns.push({
+      expression: {
+        type: "operation",
+        operator: "in",
+        args: [{ args: [valueVariable], operator: "lang", type: "operation" }, filter.languageIn.map(value => ${imports.dataFactory}.literal(value))]
+      },
+      lift: true,
+      type: "filter",
+    });
+  }
+
+  if (filter.typeIn !== undefined) {
+    const typeInExpressions = filter.typeIn
+      .map((inType) => {
+        switch (inType) {
+          case "BlankNode":
+            return "isBlank";
+          case "Literal":
+            return "isLiteral";
+          case "NamedNode":
+            return "isIRI";
+          default:
+            inType satisfies never;
+            throw new RangeError(inType);
+        }
+      })
+      .map((operator) => ({
+        type: "operation" as const,
+        operator,
+        args: [valueVariable],
+      }));
+
+    switch (typeInExpressions.length) {
+      case 0:
+        break;
+      case 1:
+        filterPatterns.push({
+          expression: typeInExpressions[0],
+          lift: true,
+          type: "filter",
+        });
+        break;
+      default:
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: "||",
+            args: typeInExpressions,
+          },
+          lift: true,
+          type: "filter",
+        });
+    }
+  }
+
+  return filterPatterns;
+}`);
+//# sourceMappingURL=snippets_termFilterSparqlPatterns.js.map

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_termSchemaSparqlPatterns.d.ts

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

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

@@ -0,0 +1,24 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_termSchemaSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termSchemaSparqlPatterns`, code `\
+function ${syntheticNamePrefix}termSchemaSparqlPatterns({
+  filterPatterns,
+  propertyPatterns,
+  schema,
+  valueVariable
+}: {
+  filterPatterns: readonly ${snippets.SparqlFilterPattern}[],
+  propertyPatterns: readonly ${snippets.SparqlPattern}[];
+  schema: Readonly<{
+    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 }));
+  }
+
+  return patterns.concat(filterPatterns);
+}`);
+//# sourceMappingURL=snippets_termSchemaSparqlPatterns.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+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

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_toIsoDateString = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}toIsoDateString`, code `\
+export function ${syntheticNamePrefix}toIsoDateString(date: Date): string {
+  return date.toISOString().replace(/T.*$/, '')
+}`);
+//# sourceMappingURL=snippets_toIsoDateString.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateArray`, code `\
+function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT, Readonly extends boolean>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>, _readonly: Readonly) {
+  type EitherR = Readonly extends true ? ReadonlyArray<ItemValueT> : Array<ItemValueT>;
+  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, valueArray: readonly ItemValueT[]): ${imports.Either}<Error, EitherR> => {
+    if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
+      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, EitherR>;
+    }
+
+    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, EitherR>;
+  }
+}`);
+//# sourceMappingURL=snippets_validateArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMaybe`, code `\
+function ${syntheticNamePrefix}validateMaybe<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>) {
+  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, valueMaybe: ${imports.Maybe}<ItemValueT>): ${imports.Either}<Error, ${imports.Maybe}<ItemValueT>> =>
+    valueMaybe.map(value => validateItem(schema.itemType, value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
+}`);
+//# sourceMappingURL=snippets_validateMaybe.js.map

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_FromRdfResourceFunction = ({ configuration, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_FromRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_FromRdfResourceFunction<T>(_fromRdfResourceFunction: ${snippets._FromRdfResourceFunction}<T>): ${snippets.FromRdfResourceFunction}<T> {
+  return (resource, options) => {
+    const { context, graph, ignoreRdfType = false, ${configuration.features.has("ObjectSet") ? "objectSet, " : ""}preferredLanguages } = (options ?? {});
+    return _fromRdfResourceFunction(resource, { context, graph, ignoreRdfType, ${configuration.features.has("ObjectSet") ? code `objectSet: objectSet ?? new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset), ` : ""}preferredLanguages });
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_FromRdfResourceFunction.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_ToRdfResourceFunction`, code `\
+function ${syntheticNamePrefix}wrap_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<ObjectT, IdentifierT> {
+  return (object, options) => {
+    let { graph, ignoreRdfType = false, resourceSet } = (options ?? {});
+    if (!resourceSet) {
+      resourceSet = new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });
+    }
+    const resource = resourceSet.resource(object.${syntheticNamePrefix}identifier());
+    _toRdfResourceFunction({ graph, ignoreRdfType, object, resource, resourceSet });
+    return resource;
+  };
+}`);
+//# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.js.map

package/dist/generators/ts/codeEquals.d.ts

@@ -0,0 +1,3 @@
+import type { Code } from "./ts-poet-wrapper.js";
+export declare function codeEquals(left: Code | string, right: Code | string): boolean;
+//# sourceMappingURL=codeEquals.d.ts.map

package/dist/generators/ts/codeEquals.js

@@ -0,0 +1,7 @@
+function codeToString(code) {
+    return typeof code === "string" ? code : code.toString({});
+}
+export function codeEquals(left, right) {
+    return codeToString(left) === codeToString(right);
+}
+//# sourceMappingURL=codeEquals.js.map

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -0,0 +1,11 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+import type { Logger } from "ts-log";
+import type { Imports } from "./Imports.js";
+import type { Snippets } from "./Snippets.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare function rdfjsTermExpression(this: {
+    imports: Imports;
+    logger: Logger;
+    snippets: Snippets;
+}, rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): Code;
+//# sourceMappingURL=rdfjsTermExpression.d.ts.map