@shaclmate/compiler 4.0.48 → 4.0.50

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

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

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

@@ -1,21 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_maybeSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<${snippets.MaybeFilter}<ItemFilterT>, ${snippets.MaybeSchema}<ItemSchemaT>> {  
-  return ({ filter, schema, ...otherParameters }) => {
-    if (filter === undefined) {
-      // Treat the item's patterns as optional
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType }));
-      return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
-    }
-      
-    if (filter === null) {
-      // Use FILTER NOT EXISTS around the item's patterns
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.itemType }));
-      return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
-    }
-
-    // Treat the item as required.
-    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType });
-  }
-}`);
-//# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

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

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

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

@@ -1,16 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_monkeyPatchObject = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}monkeyPatchObject`, code `\
-function ${syntheticNamePrefix}monkeyPatchObject<T extends object>(obj: T, methods: { toJson?: (obj: T) => object, ${syntheticNamePrefix}toString?: (obj: T) => string }): T {
-  if (methods.toJson && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON") || typeof (obj as any).toJSON === "function")) {
-    const toJsonMethod = methods.toJson;
-    (obj as any).toJSON = function(this: T, _key: string) { return toJsonMethod(this); }
-  }
-
-  if (methods.${syntheticNamePrefix}toString && (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toString") || typeof (obj as any).toJSON === "function")) {
-    const toStringMethod = methods.${syntheticNamePrefix}toString;
-    (obj as any).toString = function(this: T) { return toStringMethod(this); }
-  }
-
-  return obj;
-}`);
-//# sourceMappingURL=snippets_monkeyPatchObject.js.map

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

@@ -1,3 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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_normalizeSparqlWherePatterns.d.ts

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

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

@@ -1,92 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_normalizeSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}normalizeSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly ${snippets.SparqlPattern}[]): readonly ${snippets.SparqlPattern}[] {
-  function normalizePatternsRecursive(patternsRecursive: readonly ${snippets.SparqlPattern}[]): readonly ${snippets.SparqlPattern}[] {
-    if (patternsRecursive.length === 0) {
-      return patternsRecursive;
-    }
-
-    const compactedPatterns: ${snippets.SparqlPattern}[] = [];
-    for (const pattern of ${snippets.deduplicateSparqlPatterns}(patternsRecursive)) {
-      switch (pattern.type) {
-        case "bgp": {
-          if (pattern.triples.length === 0) {
-            continue;
-          }
-          const lastPattern = compactedPatterns.at(-1);
-          if (lastPattern && lastPattern.type === "bgp") {
-            // Coalesce adjacent BGP patterns without mutating lastPattern
-            compactedPatterns[compactedPatterns.length - 1] = { triples: lastPattern.triples.concat(pattern.triples), type: "bgp" };
-          } else {
-            compactedPatterns.push(pattern);
-          }
-          break;
-        }
-        case "bind":
-        case "filter":
-        case "query":
-        case "values":
-          compactedPatterns.push(pattern);
-          break;
-        case "group":
-          // Flatten groups outside unions
-          compactedPatterns.push(...normalizePatternsRecursive(pattern.patterns));
-          break;
-        case "graph":
-        case "minus":
-        case "optional":
-        case "service": {
-          const patterns_ = normalizePatternsRecursive(pattern.patterns);
-          if (patterns_.length > 0) {
-            compactedPatterns.push({ ...pattern, patterns: patterns_.concat() });
-          }
-          break;
-        }
-        case "union": {
-          const unionPatterns = ${snippets.deduplicateSparqlPatterns}(pattern.patterns.flatMap(pattern => {
-            switch (pattern.type) {
-              case "group":
-                // Don't flatten the groups in a union
-              case "graph":
-              case "minus":
-              case "optional":
-              case "service": {
-                const patterns_ = normalizePatternsRecursive(pattern.patterns);
-                if (patterns_.length > 0) {
-                  return [{ ...pattern, patterns: patterns_.concat() }];
-                }
-                return [] as ${snippets.SparqlPattern}[];
-              }
-              default:
-                return [pattern];
-            }
-          }));
-
-          switch (unionPatterns.length) {
-            case 0:
-              break;
-            case 1:
-              compactedPatterns.push(...normalizePatternsRecursive([unionPatterns[0]]));
-              break;
-            default:
-              compactedPatterns.push({ ...pattern, patterns: unionPatterns.concat() });
-              break;
-          }
-          break;
-        }
-        default:
-          pattern satisfies never;
-      }
-    }
-
-    return ${snippets.sortSparqlPatterns}(${snippets.deduplicateSparqlPatterns}(compactedPatterns));
-  }
-
-  const normalizedPatterns = normalizePatternsRecursive(patterns);
-  if (!normalizedPatterns.some(${snippets.SparqlPattern_isSolutionGenerating})) {
-    throw new Error("SPARQL WHERE patterns must have at least one solution-generating pattern");
-  }
-
-  return normalizedPatterns;
-}`);
-//# sourceMappingURL=snippets_normalizeSparqlWherePatterns.js.map

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

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

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

@@ -1,62 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_numericSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
-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) {
-    if (filter.in !== undefined && filter.in.length > 0) {
-      filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
-    }
-
-    if (filter.maxExclusive !== undefined) {
-      filterPatterns.push({
-        expression: {
-          type: "operation",
-          operator: "<",
-          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxExclusive)],
-        },
-        lift: true,
-        type: "filter",
-      });
-    }
-
-    if (filter.maxInclusive !== undefined) {
-      filterPatterns.push({
-        expression: {
-          type: "operation",
-          operator: "<=",
-          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxInclusive)],
-        },
-        lift: true,
-        type: "filter",
-      });
-    }
-
-    if (filter.minExclusive !== undefined) {
-      filterPatterns.push({
-        expression: {
-          type: "operation",
-          operator: ">",
-          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minExclusive)],
-        },
-        lift: true,
-        type: "filter",
-      });
-    }
-
-    if (filter.minInclusive !== undefined) {
-      filterPatterns.push({
-        expression: {
-          type: "operation",
-          operator: ">=",
-          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minInclusive)],
-        },
-        lift: true,
-        type: "filter",
-      });
-    }
-  }
-
-  return ${snippets.termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
-}`);
-//# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

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

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

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

@@ -1,9 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_parseBlankNode = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseBlankNode`, code `\
-export function ${syntheticNamePrefix}parseBlankNode(identifier: string): ${imports.Either}<Error, ${imports.BlankNode}> {
-  return \
-    ${snippets.parseIdentifier}(identifier)\
-      .chain((identifier) => (identifier.termType === "BlankNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be BlankNode"))) \
-    as ${imports.Either}<Error, ${imports.BlankNode}>;
-}`);
-//# sourceMappingURL=snippets_parseBlankNode.js.map

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

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

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

@@ -1,4 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_parseIdentifier = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseIdentifier`, code `\
-const ${syntheticNamePrefix}parseIdentifier = ${imports.NTriplesIdentifier}.parser(${imports.dataFactory});`);
-//# sourceMappingURL=snippets_parseIdentifier.js.map

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

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

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

@@ -1,9 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_parseIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}parseIri`, code `\
-export function ${syntheticNamePrefix}parseIri(identifier: string): ${imports.Either}<Error, ${imports.NamedNode}> {
-  return \
-    ${snippets.parseIdentifier}(identifier)\
-      .chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode"))) \
-    as ${imports.Either}<Error, ${imports.NamedNode}>;
-}`);
-//# sourceMappingURL=snippets_parseIri.js.map

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

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

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

@@ -1,18 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_sequenceRecord = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sequenceRecord`, code `\
-function ${syntheticNamePrefix}sequenceRecord<T extends Record<string, unknown>>(
-  record: { [K in keyof T]: ${imports.Either}<Error, T[K]> }
-): ${imports.Either}<Error, T> {
-  const result: { [K in keyof T]?: T[K] } = {};
-
-  for (const key of globalThis.Object.keys(record) as Array<keyof T>) {
-    const either = record[key];
-    if (either.isLeft()) {
-      return either as unknown as ${imports.Either}<Error, T>;
-    }
-    result[key] = either.extract() as T[typeof key];
-  }
-
-  return ${imports.Right}(result as T);
-}`);
-//# sourceMappingURL=snippets_sequenceRecord.js.map

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

@@ -1,3 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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_setSparqlConstructTriples.d.ts

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

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

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

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

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

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

@@ -1,17 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_setSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
-  return ({ filter, schema, ...otherParameters }) => {
-    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.itemType });
-
-    const minCount = filter?.${syntheticNamePrefix}minCount ?? schema.minCount ?? 0;
-    if (minCount > 0) {
-      // Required
-      return itemSparqlWherePatterns;
-    }
-    
-    const [optionalSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatterns);
-    return [{ patterns: optionalSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
-  }
-}`);
-//# sourceMappingURL=snippets_setSparqlWherePatterns.js.map

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

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

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

@@ -1,17 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_shaclPropertyFromRdf = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertyFromRdf`, code `\
-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_shaclPropertySparqlConstructTriples.d.ts

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

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

@@ -1,90 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_shaclPropertySparqlConstructTriples = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
-function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, propertyName, propertySchema, typeSparqlConstructTriples, variablePrefix }: {
-  filter: FilterT | undefined;
-  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType: boolean;
-  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
-  propertyName: string;
-  typeSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;
-  variablePrefix: string;
-}): readonly ${imports.sparqljs}.Triple[] {
-  const propertyPathSparqlConstructTriples = ({ end, propertyPath, start, variableCounter }: {
-    variableCounter: { value: number };
-    end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
-    propertyPath: ${snippets.PropertyPath};
-    start: ${imports.NamedNode} | ${imports.Variable};
-  }): readonly ${imports.sparqljs}.Triple[] => {
-    switch (propertyPath.termType) {
-      case "AlternativePath": {
-        return propertyPath.members.flatMap((member) =>
-          propertyPathSparqlConstructTriples({ end, propertyPath: member, start, variableCounter }),
-        );
-      }
-
-      case "InversePath": {
-        if (end.termType === "Literal") {
-          throw new Error(\`invalid term type for inverse path: \${end.termType}\`);
-        }
-
-        return propertyPathSparqlConstructTriples({
-          end: start,
-          propertyPath: propertyPath.path,
-          start: end,
-          variableCounter,
-        });
-      }
-
-      case "NamedNode": {
-        return [{ subject: start, predicate: propertyPath as NamedNode, object: end }];
-      }
-
-      case "SequencePath": {
-        if (propertyPath.members.length === 0) {
-          return [];
-        }
-
-        if (propertyPath.members.length === 1) {
-          return propertyPathSparqlConstructTriples({ end, propertyPath: propertyPath.members[0], start, variableCounter });
-        }
-
-        let triples: ${imports.sparqljs}.Triple[] = [];
-        let current: ${imports.NamedNode} | ${imports.Variable} = start;
-        for (let memberI = 0; memberI < propertyPath.members.length; memberI++) {
-          const next: ${imports.NamedNode} | ${imports.Literal} | ${imports.Variable} = memberI === propertyPath.members.length - 1
-            ? end
-            : ${imports.dataFactory}.variable(\`\${variablePrefix}\${variableCounter.value++}\`);
-          triples = triples.concat(propertyPathSparqlConstructTriples({ end: next, propertyPath: propertyPath.members[memberI], start: current, variableCounter }));
-          current = next as ${imports.NamedNode} | ${imports.Variable};
-        }
-
-        return triples;
-      }
-
-      case "OneOrMorePath":
-      case "ZeroOrMorePath":
-      case "ZeroOrOnePath": {
-        throw new Error(\`\${propertyName}: \${propertyPath.termType} property path cannot be represented as SPARQL CONSTRUCT triples\`);
-      }
-
-      default: {
-        propertyPath satisfies never;
-        throw new Error(\`\${propertyName}: unhandled property path termType: \${(propertyPath as any).termType}\`);
-      }
-    }
-  }
-
-  const valueString = \`\${variablePrefix}\${propertyName[0].toUpperCase()}\${propertyName.slice(1)}\`;
-  const valueVariable = ${imports.dataFactory}.variable!(valueString);
-
-  const variableCounter = { value: 0 };
-  return propertyPathSparqlConstructTriples({ end: valueVariable, propertyPath: propertySchema.path, start: focusIdentifier, variableCounter })
-    .concat(typeSparqlConstructTriples({
-      filter,
-      ignoreRdfType,
-      schema: propertySchema.type,
-      valueVariable,
-      variablePrefix: valueString
-    }));
-}`);
-//# sourceMappingURL=snippets_shaclPropertySparqlConstructTriples.js.map

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

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

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

@@ -1,86 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_shaclPropertySparqlWherePatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
-  filter: FilterT | undefined;
-  focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType: boolean;
-  preferredLanguages: readonly string[] | undefined;
-  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
-  propertyName: string;
-  typeSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
-  variablePrefix: string;
-}): readonly ${snippets.SparqlPattern}[] {
-  const propertyPathSparqlWherePatterns = ({ end, propertyPath, start, variableCounter }: {
-    end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
-    propertyPath: ${snippets.PropertyPath};
-    start: ${imports.NamedNode} | ${imports.Variable};
-    variableCounter: { value: number };
-  }): ${snippets.SparqlPattern}[] => {
-    switch (propertyPath.termType) {
-      case "AlternativePath": {
-        return [{
-          patterns: propertyPath.members.map((member) => ({
-            patterns: propertyPathSparqlWherePatterns({ end, propertyPath: member, start, variableCounter }),
-            type: "group" as const,
-          })),
-          type: "union",
-        }];
-      }
-
-      case "InversePath":
-      case "NamedNode":
-      case "OneOrMorePath":
-      case "ZeroOrMorePath":
-      case "ZeroOrOnePath": {
-        return [{
-          triples: [{ subject: start, predicate: ${snippets.sparqlPropertyPath}(propertyPath), object: end }],
-          type: "bgp"
-        }];
-      }
-
-      case "SequencePath": {
-        if (propertyPath.members.length === 0) {
-          return [];
-        }
-
-        if (propertyPath.members.length === 1) {
-          return propertyPathSparqlWherePatterns({ end, propertyPath: propertyPath.members[0], start, variableCounter });
-        }
-
-        let patterns: ${snippets.SparqlPattern}[] = [];
-        let current: ${imports.NamedNode} | ${imports.Variable} = start;
-        for (let memberI = 0; memberI < propertyPath.members.length; memberI++) {
-          const next: ${imports.NamedNode} | ${imports.Literal} | ${imports.Variable} = memberI === propertyPath.members.length - 1
-            ? end
-            : ${imports.dataFactory}.variable(\`\${variablePrefix}\${variableCounter.value++}\`);
-          patterns = patterns.concat(propertyPathSparqlWherePatterns({ end: next, propertyPath: propertyPath.members[memberI], start: current, variableCounter }));
-          current = next as ${imports.NamedNode} | ${imports.Variable};
-        }
-
-        return patterns;
-      }
-
-      default: {
-        propertyPath satisfies never;
-        throw new Error(\`\${propertyName}: unhandled property path termType: \${(propertyPath as any).termType}\`);
-      }
-    }
-  }
-
-  const valueString = \`\${variablePrefix}\${propertyName[0].toUpperCase()}\${propertyName.slice(1)}\`;
-  const valueVariable = ${imports.dataFactory}.variable!(valueString);
-
-  const variableCounter = { value: 0 };
-  const propertyPatterns = propertyPathSparqlWherePatterns({ end: valueVariable, propertyPath: propertySchema.path, start: focusIdentifier, variableCounter });
-
-  return typeSparqlWherePatterns({
-    filter,
-    ignoreRdfType,
-    preferredLanguages,
-    propertyPatterns,
-    schema: propertySchema.type,
-    valueVariable,
-    variablePrefix: valueString
-  });
-}`);
-//# sourceMappingURL=snippets_shaclPropertySparqlWherePatterns.js.map

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

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

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

@@ -1,24 +0,0 @@
-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

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