@shaclmate/compiler 4.0.29 → 4.0.31

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

@@ -1,5 +1,3 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_literalFactory = conditionalOutput(`${syntheticNamePrefix}literalFactory`, code `const ${syntheticNamePrefix}literalFactory = new ${imports.LiteralFactory}({ dataFactory: ${imports.dataFactory} });`);
+export const snippets_literalFactory = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalFactory`, code `const ${syntheticNamePrefix}literalFactory = new ${imports.LiteralFactory}({ dataFactory: ${imports.dataFactory} });`);
 //# sourceMappingURL=snippets_literalFactory.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_literalSchemaSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_literalSchemaSparqlPatterns: SnippetFactory;
 //# sourceMappingURL=snippets_literalSchemaSparqlPatterns.d.ts.map

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

@@ -1,11 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_arrayIntersection } from "./snippets_arrayIntersection.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-export const snippets_literalSchemaSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}literalSchemaSparqlPatterns`, code `\
+export const snippets_literalSchemaSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalSchemaSparqlPatterns`, code `\
 function ${syntheticNamePrefix}literalSchemaSparqlPatterns({
   filterPatterns,
   preferredLanguages,
@@ -13,22 +7,22 @@ function ${syntheticNamePrefix}literalSchemaSparqlPatterns({
   schema,
   valueVariable
 }: {
-  filterPatterns: readonly ${snippets_SparqlFilterPattern}[],
+  filterPatterns: readonly ${snippets.SparqlFilterPattern}[],
   preferredLanguages?: readonly string[];
-  propertyPatterns: readonly ${snippets_SparqlPattern}[];
+  propertyPatterns: readonly ${snippets.SparqlPattern}[];
   schema: Readonly<{
     languageIn?: readonly string[];
     in?: readonly (bigint | boolean | Date | string | number | ${imports.Literal} | ${imports.NamedNode})[];
   }>,
   valueVariable: ${imports.Variable};
-}): readonly ${snippets_SparqlPattern}[] {
-  let patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
+}): readonly ${snippets.SparqlPattern}[] {
+  let patterns: ${snippets.SparqlPattern}[] = propertyPatterns.concat();
 
   if (schema.in && schema.in.length > 0) {
-    patterns.push(${snippets_sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
+    patterns.push(${snippets.sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
   }
 
-  const languageIn = ${snippets_arrayIntersection}(schema.languageIn ?? [], preferredLanguages ?? []);
+  const languageIn = ${snippets.arrayIntersection}(schema.languageIn ?? [], preferredLanguages ?? []);
   if (languageIn.length > 0) {
     patterns.push({
       expression: {

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

@@ -1,2 +1,3 @@
-export declare const snippets_literalSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_literalSparqlWherePatterns: SnippetFactory;
 //# sourceMappingURL=snippets_literalSparqlWherePatterns.d.ts.map

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

@@ -1,10 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_LiteralFilter } from "./snippets_LiteralFilter.js";
-import { snippets_LiteralSchema } from "./snippets_LiteralSchema.js";
-import { snippets_termFilterSparqlPatterns } from "./snippets_termFilterSparqlPatterns.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_literalSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}literalSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_LiteralFilter}, ${snippets_LiteralSchema}> =
-  (parameters) => ${syntheticNamePrefix}literalSchemaSparqlPatterns({ filterPatterns: ${snippets_termFilterSparqlPatterns}(parameters), ...parameters });`);
+export const snippets_literalSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}literalSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.LiteralFilter}, ${snippets.LiteralSchema}> =
+  (parameters) => ${syntheticNamePrefix}literalSchemaSparqlPatterns({ filterPatterns: ${snippets.termFilterSparqlPatterns}(parameters), ...parameters });`);
 //# sourceMappingURL=snippets_literalSparqlWherePatterns.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_maybeEquals: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_maybeEquals: SnippetFactory;
 //# sourceMappingURL=snippets_maybeEquals.d.ts.map

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

@@ -1,16 +1,13 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_EqualsResult } from "./snippets_EqualsResult.js";
-export const snippets_maybeEquals = conditionalOutput(`${syntheticNamePrefix}maybeEquals`, code `\
+export const snippets_maybeEquals = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeEquals`, code `\
 function ${syntheticNamePrefix}maybeEquals<T>(
   leftMaybe: ${imports.Maybe}<T>,
   rightMaybe: ${imports.Maybe}<T>,
-  valueEquals: (left: T, right: T) => boolean | ${snippets_EqualsResult},
-): ${snippets_EqualsResult} {
+  valueEquals: (left: T, right: T) => boolean | ${snippets.EqualsResult},
+): ${snippets.EqualsResult} {
   if (leftMaybe.isJust()) {
     if (rightMaybe.isJust()) {
-      return ${snippets_EqualsResult}.fromBooleanEqualsResult(
+      return ${snippets.EqualsResult}.fromBooleanEqualsResult(
         leftMaybe,
         rightMaybe,
         valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
@@ -29,6 +26,6 @@ function ${syntheticNamePrefix}maybeEquals<T>(
     });
   }
 
-  return ${snippets_EqualsResult}.Equal;
+  return ${snippets.EqualsResult}.Equal;
 }`);
 //# sourceMappingURL=snippets_maybeEquals.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_maybeSparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_maybeSparqlConstructTriples: SnippetFactory;
 //# sourceMappingURL=snippets_maybeSparqlConstructTriples.d.ts.map

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

@@ -1,10 +1,6 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_MaybeFilter } from "./snippets_MaybeFilter.js";
-import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
-import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.js";
-export const snippets_maybeSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
-function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlConstructTriplesFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
+export const snippets_maybeSparqlConstructTriples = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
+function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.MaybeFilter}<ItemFilterT>, ${snippets.MaybeSchema}<ItemSchemaT>> {  
   return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_maybeSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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 +1,16 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
-import { snippets_MaybeFilter } from "./snippets_MaybeFilter.js";
-import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_maybeSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}maybeSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
+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.item() }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() }));
       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.item() }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.item() }));
       return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
     }
 

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

@@ -1,2 +1,3 @@
-export declare const snippets_normalizeSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,18 +1,13 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_deduplicateSparqlPatterns } from "./snippets_deduplicateSparqlPatterns.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_SparqlPattern_isSolutionGenerating } from "./snippets_SparqlPattern_isSolutionGenerating.js";
-import { snippets_sortSparqlPatterns } from "./snippets_sortSparqlPatterns.js";
-export const snippets_normalizeSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}normalizeSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly ${snippets_SparqlPattern}[]): readonly ${snippets_SparqlPattern}[] {
-  function normalizePatternsRecursive(patternsRecursive: readonly ${snippets_SparqlPattern}[]): readonly ${snippets_SparqlPattern}[] {
+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)) {
+    const compactedPatterns: ${snippets.SparqlPattern}[] = [];
+    for (const pattern of ${snippets.deduplicateSparqlPatterns}(patternsRecursive)) {
       switch (pattern.type) {
         case "bgp": {
           if (pattern.triples.length === 0) {
@@ -48,7 +43,7 @@ function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly $
           break;
         }
         case "union": {
-          const unionPatterns = ${snippets_deduplicateSparqlPatterns}(pattern.patterns.flatMap(pattern => {
+          const unionPatterns = ${snippets.deduplicateSparqlPatterns}(pattern.patterns.flatMap(pattern => {
             switch (pattern.type) {
               case "group":
                 // Don't flatten the groups in a union
@@ -60,7 +55,7 @@ function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly $
                 if (patterns_.length > 0) {
                   return [{ ...pattern, patterns: patterns_.concat() }];
                 }
-                return [] as ${snippets_SparqlPattern}[];
+                return [] as ${snippets.SparqlPattern}[];
               }
               default:
                 return [pattern];
@@ -84,11 +79,11 @@ function ${syntheticNamePrefix}normalizeSparqlWherePatterns(patterns: readonly $
       }
     }
 
-    return ${snippets_sortSparqlPatterns}(${snippets_deduplicateSparqlPatterns}(compactedPatterns));
+    return ${snippets.sortSparqlPatterns}(${snippets.deduplicateSparqlPatterns}(compactedPatterns));
   }
 
   const normalizedPatterns = normalizePatternsRecursive(patterns);
-  if (!normalizedPatterns.some(${snippets_SparqlPattern_isSolutionGenerating})) {
+  if (!normalizedPatterns.some(${snippets.SparqlPattern_isSolutionGenerating})) {
     throw new Error("SPARQL WHERE patterns must have at least one solution-generating pattern");
   }
 

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

@@ -1,2 +1,3 @@
-export declare const snippets_numericSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,19 +1,11 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_literalFactory } from "./snippets_literalFactory.js";
-import { snippets_NumericFilter } from "./snippets_NumericFilter.js";
-import { snippets_NumericSchema } from "./snippets_NumericSchema.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_numericSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
-function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets_ValueSparqlWherePatternsFunction}<${snippets_NumericFilter}<T>, ${snippets_NumericSchema}<T>>>[0]): ReturnType<${snippets_ValueSparqlWherePatternsFunction}<${snippets_NumericFilter}<T>, ${snippets_NumericSchema}<T>>> {
-  const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+export const snippets_numericSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}numericSparqlWherePatterns`, code `\
+function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueVariable, ...otherParameters }: Parameters<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<T>, ${snippets.NumericSchema}<T>>>[0]): ReturnType<${snippets.ValueSparqlWherePatternsFunction}<${snippets.NumericFilter}<T>, ${snippets.NumericSchema}<T>>> {
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 
   if (filter) {
     if (filter.in !== undefined && filter.in.length > 0) {
-      filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+      filterPatterns.push(${snippets.sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
     }
 
     if (filter.maxExclusive !== undefined) {
@@ -21,7 +13,7 @@ function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueV
         expression: {
           type: "operation",
           operator: "<",
-          args: [valueVariable, ${snippets_literalFactory}.primitive(filter.maxExclusive)],
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxExclusive)],
         },
         lift: true,
         type: "filter",
@@ -33,7 +25,7 @@ function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueV
         expression: {
           type: "operation",
           operator: "<=",
-          args: [valueVariable, ${snippets_literalFactory}.primitive(filter.maxInclusive)],
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.maxInclusive)],
         },
         lift: true,
         type: "filter",
@@ -45,7 +37,7 @@ function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueV
         expression: {
           type: "operation",
           operator: ">",
-          args: [valueVariable, ${snippets_literalFactory}.primitive(filter.minExclusive)],
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minExclusive)],
         },
         lift: true,
         type: "filter",
@@ -57,7 +49,7 @@ function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueV
         expression: {
           type: "operation",
           operator: ">=",
-          args: [valueVariable, ${snippets_literalFactory}.primitive(filter.minInclusive)],
+          args: [valueVariable, ${snippets.literalFactory}.primitive(filter.minInclusive)],
         },
         lift: true,
         type: "filter",
@@ -65,6 +57,6 @@ function $numericSparqlWherePatterns<T extends bigint | number>({ filter, valueV
     }
   }
 
-  return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+  return ${snippets.termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
 }`);
 //# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_parseBlankNode: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,11 +1,8 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_parseIdentifier } from "./snippets_parseIdentifier.js";
-export const snippets_parseBlankNode = conditionalOutput(`${syntheticNamePrefix}parseBlankNode`, code `\
+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)\
+    ${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}>;
 }`);

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

@@ -1,2 +1,3 @@
-export declare const snippets_parseIdentifier: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,6 +1,4 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_parseIdentifier = conditionalOutput(`${syntheticNamePrefix}parseIdentifier`, code `\
+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,2 +1,3 @@
-export declare const snippets_parseIri: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,11 +1,8 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_parseIdentifier } from "./snippets_parseIdentifier.js";
-export const snippets_parseIri = conditionalOutput(`${syntheticNamePrefix}parseIri`, code `\
+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)\
+    ${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}>;
 }`);

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

@@ -1,2 +1,3 @@
-export declare const snippets_setSparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,10 +1,6 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
-import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
-import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.js";
-export const snippets_setSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}setSparqlConstructTriples`, code `\
-function ${syntheticNamePrefix}setSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
+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.item() });
 }`);
 //# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

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

@@ -1,2 +1,3 @@
-export declare const snippets_setSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,11 +1,6 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_CollectionFilter } from "./snippets_CollectionFilter.js";
-import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
-import { snippets_liftSparqlPatterns } from "./snippets_liftSparqlPatterns.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_setSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_ValueSparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
+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.item() });
 
@@ -15,7 +10,7 @@ function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(
       return itemSparqlWherePatterns;
     }
     
-    const [optionalSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatterns);
+    const [optionalSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatterns);
     return [{ patterns: optionalSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
   }
 }`);

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

@@ -1,2 +1,3 @@
-export declare const snippets_shaclPropertyFromRdf: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,11 +1,8 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
-export const snippets_shaclPropertyFromRdf = conditionalOutput(`${syntheticNamePrefix}shaclPropertyFromRdf`, code `\
+export const snippets_shaclPropertyFromRdf = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}shaclPropertyFromRdf`, code `\
 function ${syntheticNamePrefix}shaclPropertyFromRdf<T>({ graph, propertySchema, resource, typeFromRdf }: {
   graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  propertySchema: ${snippets_ShaclPropertySchema};
+  propertySchema: ${snippets.ShaclPropertySchema};
   resource: ${imports.Resource};
   typeFromRdf: (resourceValues: ${imports.Either}<Error, ${imports.Resource}.Values>) => ${imports.Either}<Error, ${imports.Resource}.Values<T>>;
 }): ${imports.Either}<Error, T> {

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

@@ -1,2 +1,3 @@
-export declare const snippets_shaclPropertySparqlConstructTriples: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,23 +1,18 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
-import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
-import { snippets_ValueSparqlConstructTriplesFunction } from "./snippets_ValueSparqlConstructTriplesFunction.js";
-export const snippets_shaclPropertySparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
+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>;
+  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
-  typeSparqlConstructTriples: ${snippets_ValueSparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;
+  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};
+    propertyPath: ${snippets.PropertyPath};
     start: ${imports.NamedNode} | ${imports.Variable};
   }): readonly ${imports.sparqljs}.Triple[] => {
     switch (propertyPath.termType) {

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

@@ -1,2 +1,3 @@
-export declare const snippets_shaclPropertySparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,28 +1,21 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_PropertyPath } from "./snippets_PropertyPath.js";
-import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-import { snippets_sparqlPropertyPath } from "./snippets_sparqlPropertyPath.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_shaclPropertySparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
+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>;
+  propertySchema: ${snippets.ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
-  typeSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
+  typeSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<FilterT, TypeSchemaT>;
   variablePrefix: string;
-}): readonly ${snippets_SparqlPattern}[] {
+}): readonly ${snippets.SparqlPattern}[] {
   const propertyPathSparqlWherePatterns = ({ end, propertyPath, start, variableCounter }: {
     end: ${imports.Literal} | ${imports.NamedNode} | ${imports.Variable};
-    propertyPath: ${snippets_PropertyPath};
+    propertyPath: ${snippets.PropertyPath};
     start: ${imports.NamedNode} | ${imports.Variable};
     variableCounter: { value: number };
-  }): ${snippets_SparqlPattern}[] => {
+  }): ${snippets.SparqlPattern}[] => {
     switch (propertyPath.termType) {
       case "AlternativePath": {
         return [{
@@ -40,7 +33,7 @@ function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSch
       case "ZeroOrMorePath":
       case "ZeroOrOnePath": {
         return [{
-          triples: [{ subject: start, predicate: ${snippets_sparqlPropertyPath}(propertyPath), object: end }],
+          triples: [{ subject: start, predicate: ${snippets.sparqlPropertyPath}(propertyPath), object: end }],
           type: "bgp"
         }];
       }
@@ -54,7 +47,7 @@ function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSch
           return propertyPathSparqlWherePatterns({ end, propertyPath: propertyPath.members[0], start, variableCounter });
         }
 
-        let patterns: ${snippets_SparqlPattern}[] = [];
+        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

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

@@ -1,2 +1,3 @@
-export declare const snippets_sortSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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,11 +1,9 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
-export const snippets_sortSparqlPatterns = 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}[] = [];
+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) {

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

@@ -1,2 +1,3 @@
-export declare const snippets_sparqlInstancesOfPattern: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+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

@@ -1,8 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_RdfVocabularies } from "./snippets_RdfVocabularies.js";
-export const snippets_sparqlInstancesOfPattern = conditionalOutput(`${syntheticNamePrefix}sparqlInstancesOfPattern`, code `\
+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 .
  */
@@ -13,9 +10,9 @@ function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: {
         subject,
         predicate: {
           items: [
-            ${snippets_RdfVocabularies}.rdf.type,
+            ${snippets.RdfVocabularies}.rdf.type,
             {
-              items: [${snippets_RdfVocabularies}.rdfs.subClassOf],
+              items: [${snippets.RdfVocabularies}.rdfs.subClassOf],
               pathType: "*",
               type: "path",
             },