@shaclmate/compiler 4.0.50 → 4.0.52

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets__ToRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}_ToRdfResourceFunction`, code `\
+export type ${syntheticNamePrefix}_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }> = (
+  parameters: {
+    graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined;
+    ignoreRdfType: boolean;
+    object: ObjectT
+    resource: ${imports.Resource}<IdentifierT>;
+    resourceSet: ${imports.ResourceSet};
+  }
+) => void;`);
+//# sourceMappingURL=snippets__ToRdfResourceFunction.js.map

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

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

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

@@ -0,0 +1,68 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_arrayEquals = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayEquals`, code `\
+/**
+ * Compare two arrays element-wise with the provided elementEquals function.
+ */  
+function ${syntheticNamePrefix}arrayEquals<T>(
+  leftArray: readonly T[],
+  rightArray: readonly T[],
+  elementEquals: (left: T, right: T) => boolean | ${snippets.EqualsResult},
+): ${snippets.EqualsResult} {
+  if (leftArray.length !== rightArray.length) {
+    return ${imports.Left}({
+      left: leftArray,
+      right: rightArray,
+      type: "array-length",
+    });
+  }
+
+  for (
+    let leftElementIndex = 0;
+    leftElementIndex < leftArray.length;
+    leftElementIndex++
+  ) {
+    const leftElement = leftArray[leftElementIndex];
+
+    const rightUnequals: ${snippets.EqualsResult}.Unequal[] = [];
+    for (
+      let rightElementIndex = 0;
+      rightElementIndex < rightArray.length;
+      rightElementIndex++
+    ) {
+      const rightElement = rightArray[rightElementIndex];
+
+      const leftElementEqualsRightElement =
+        ${snippets.EqualsResult}.fromBooleanEqualsResult(
+          leftElement,
+          rightElement,
+          elementEquals(leftElement, rightElement),
+        );
+      if (leftElementEqualsRightElement.isRight()) {
+        break; // left element === right element, break out of the right iteration
+      }
+      rightUnequals.push(
+        leftElementEqualsRightElement.extract() as ${snippets.EqualsResult}.Unequal,
+      );
+    }
+
+    if (rightUnequals.length === rightArray.length) {
+      // All right elements were unequal to the left element
+      return ${imports.Left}({
+        left: {
+          array: leftArray,
+          element: leftElement,
+          elementIndex: leftElementIndex,
+        },
+        right: {
+          array: rightArray,
+          unequals: rightUnequals,
+        },
+        type: "array-element",
+      });
+    }
+    // Else there was a right element equal to the left element, continue to the next left element
+  }
+
+  return ${snippets.EqualsResult}.Equal;
+}`);
+//# sourceMappingURL=snippets_arrayEquals.js.map

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

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

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

@@ -0,0 +1,29 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_arrayIntersection = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayIntersection`, code `\
+function ${syntheticNamePrefix}arrayIntersection<T>(left: readonly T[], right: readonly T[]): readonly T[] {
+  if (left.length === 0) {
+    return right;
+  }
+  if (right.length === 0) {
+    return left;
+  }
+
+  const intersection = new Set<T>();
+  if (left.length <= right.length) {
+    const rightSet = new Set(right);
+    for (const leftElement of left) {
+      if (rightSet.has(leftElement)) {
+        intersection.add(leftElement);
+      }
+    }
+  } else {
+    const leftSet = new Set(left);
+    for (const rightElement of right) {
+      if (leftSet.has(rightElement)) {
+        intersection.add(rightElement);
+      }  
+    }
+  }
+  return [...intersection];
+}`);
+//# sourceMappingURL=snippets_arrayIntersection.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_bigDecimalLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalLiteral`, code `\
+/**
+ * Create a Literal from a BigDecimal.
+ */  
+function ${syntheticNamePrefix}bigDecimalLiteral(value: ${imports.BigDecimal}): ${imports.Literal} {
+  return ${imports.dataFactory}.literal(value.toFixed(), ${snippets.RdfVocabularies}.xsd.decimal);
+}`);
+//# sourceMappingURL=snippets_bigDecimalLiteral.js.map

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

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

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

@@ -0,0 +1,83 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_bigDecimalSparqlWherePatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}bigDecimalSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<${imports.BigDecimal}>, ${snippets.NumericSchema}<${imports.BigDecimal}>> = ({ filter, propertyPatterns, schema, valueVariable }) => {
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
+
+  if (filter) {
+    if (filter.in !== undefined && filter.in.length > 0) {
+      filterPatterns.push({
+        expression: {
+          args: [valueVariable, filter.in.map(${snippets.bigDecimalLiteral})],
+          operator: "in",
+          type: "operation",
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.maxExclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: "<",
+          args: [valueVariable, ${snippets.bigDecimalLiteral}(filter.maxExclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.maxInclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: "<=",
+          args: [valueVariable, ${snippets.bigDecimalLiteral}(filter.maxInclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.minExclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: ">",
+          args: [valueVariable, ${snippets.bigDecimalLiteral}(filter.minExclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+
+    if (filter.minInclusive !== undefined) {
+      filterPatterns.push({
+        expression: {
+          type: "operation",
+          operator: ">=",
+          args: [valueVariable, ${snippets.bigDecimalLiteral}(filter.minInclusive)],
+        },
+        lift: true,
+        type: "filter",
+      });
+    }
+  }
+
+  const schemaPatterns: ${snippets.SparqlPattern}[] = [];
+  if (schema.in && schema.in.length > 0) {
+    schemaPatterns.push({
+      expression: {
+        args: [valueVariable, schema.in.map(${snippets.bigDecimalLiteral})],
+        operator: "in",
+        type: "operation",
+      },
+      lift: true,
+      type: "filter",
+    });
+  }
+
+  return (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(schemaPatterns).concat(filterPatterns);
+}`);
+//# sourceMappingURL=snippets_bigDecimalSparqlWherePatterns.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_blankNodeFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromRdfResourceValues`, code `\
+function ${syntheticNamePrefix}blankNodeFromRdfResourceValues(values: ${imports.Resource}.Values, _options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.BlankNode}, ${snippets.BlankNodeSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.BlankNode}>> {
+  return values.chainMap(value => value.toBlankNode());
+}`);
+//# sourceMappingURL=snippets_blankNodeFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_blankNodeSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}blankNodeSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.BlankNodeFilter}, ${snippets.BlankNodeSchema}> =
+  ({ propertyPatterns }) => propertyPatterns;`);
+//# sourceMappingURL=snippets_blankNodeSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_booleanEquals = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanEquals`, code `\
+/**
+ * Compare two objects with equals(other: T): boolean methods and return an ${snippets.EqualsResult}.
+ */
+function ${syntheticNamePrefix}booleanEquals<T extends { equals: (other: T) => boolean }>(
+  left: T,
+  right: T,
+): ${snippets.EqualsResult} {
+  return ${snippets.EqualsResult}.fromBooleanEqualsResult(
+    left,
+    right,
+    left.equals(right),
+  );
+}`);
+//# sourceMappingURL=snippets_booleanEquals.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_booleanSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}booleanSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.BooleanFilter}, ${snippets.BooleanSchema}<boolean>> =
+  ({ filter, valueVariable, ...otherParameters }) => {
+    const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
+
+    if (filter) {
+      if (filter.value !== undefined) {
+        filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: [filter.value] }));
+      }
+    }
+
+    return ${snippets.termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+  }`);
+//# sourceMappingURL=snippets_booleanSparqlWherePatterns.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_compactRecord = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}compactRecord`, code `\
+/**
+ * Remove undefined values from a record.
+ */  
+function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
+  return \
+    globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+      if (propertyValue !== undefined) {
+        definedProperties[propertyName as KeyT] = propertyValue as ValueT;
+      }
+      return definedProperties;
+    }, {} as Record<KeyT, ValueT>);
+}`);
+//# sourceMappingURL=snippets_compactRecord.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToArraySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArraySet`, code `\
+function ${syntheticNamePrefix}convertToArraySet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => 
+    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToArraySet.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToBlankNode = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNode`, code `\
+function ${syntheticNamePrefix}convertToBlankNode(value: ${imports.BlankNode} | undefined): ${imports.Either}<Error, ${imports.BlankNode}> {
+  switch (typeof value) {
+    case "object":
+      return ${imports.Either}.of(value);
+    case "undefined":
+      return ${imports.Either}.of(${imports.dataFactory}.blankNode());
+  }
+}`);
+//# sourceMappingURL=snippets_convertToBlankNode.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToBlankNodeIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNodeIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToBlankNodeIdentifierProperty(identifier: (() => ${imports.BlankNode}) | ${imports.BlankNode} | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode})> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "undefined": {
+      const captureIdentifier = ${imports.dataFactory}.blankNode();
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToBlankNodeIdentifierProperty.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIdentifier = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifier`, code `\
+function ${syntheticNamePrefix}convertToIdentifier(value: ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> {
+  switch (typeof value) {
+    case "object":
+      return ${imports.Either}.of(value);
+    case "string":
+      return ${imports.Either}.of(${imports.dataFactory}.namedNode(value));
+    case "undefined":
+      return ${imports.Either}.of(${imports.dataFactory}.blankNode());
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIdentifier.js.map

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

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

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

@@ -0,0 +1,21 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIdentifierProperty(identifier: (() => ${imports.BlankNode} | ${imports.NamedNode}) | ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode} | ${imports.NamedNode})> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "string": {
+      const captureIdentifier = ${imports.dataFactory}.namedNode(identifier);
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "undefined": {
+      const captureIdentifier = ${imports.dataFactory}.blankNode();
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIdentifierProperty.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIri = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
+function ${syntheticNamePrefix}convertToIri<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+  switch (typeof value) {
+    case "object":
+      return ${imports.Either}.of(value);
+    case "string":
+      return ${imports.Either}.of(${imports.dataFactory}.namedNode<IriT>(value));
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIri.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIriIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIriIdentifierProperty<IriT extends string = string>(identifier: (() => ${imports.NamedNode}<IriT>) | ${imports.NamedNode}<IriT> | IriT): ${imports.Either}<Error, (() => ${imports.NamedNode}<IriT>)> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "string": {
+      const captureIdentifier = ${imports.dataFactory}.namedNode<IriT>(identifier);
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIriIdentifierProperty.js.map

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToList = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToList`, code `\
+function ${syntheticNamePrefix}convertToList<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[]): ${imports.Either}<Error, ItemTargetArrayT> => ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToList.js.map

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

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