@shaclmate/compiler 4.0.29 → 4.0.30

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",
             },

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

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

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

@@ -1,12 +1,9 @@
-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";
-export const snippets_sparqlPropertyPath = conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
+export const snippets_sparqlPropertyPath = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlPropertyPath`, code `\
 /**
- * Convert a ${snippets_PropertyPath} to a ${imports.sparqljs}.PropertyPath.
+ * Convert a ${snippets.PropertyPath} to a ${imports.sparqljs}.PropertyPath.
  */  
-function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${snippets_PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
+function ${syntheticNamePrefix}sparqlPropertyPath(propertyPath: ${snippets.PropertyPath}): ${imports.NamedNode} | ${imports.sparqljs}.PropertyPath {
   switch (propertyPath.termType) {
     case "AlternativePath":
       return {

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +1,12 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_literalFactory } from "./snippets_literalFactory.js";
-import { snippets_literalSchemaSparqlPatterns } from "./snippets_literalSchemaSparqlPatterns.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_StringFilter } from "./snippets_StringFilter.js";
-import { snippets_StringSchema } from "./snippets_StringSchema.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-import { snippets_ValueSparqlWherePatternsFunction } from "./snippets_ValueSparqlWherePatternsFunction.js";
-export const snippets_stringSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
-const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWherePatternsFunction}<${snippets_StringFilter}, ${snippets_StringSchema}> =
+export const snippets_stringSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${snippets.StringFilter}, ${snippets.StringSchema}> =
   ({ filter, valueVariable, ...otherParameters }) => {
-    const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+    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.maxLength !== undefined) {
@@ -22,7 +14,7 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
           expression: {
             type: "operation",
             operator: "<=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.maxLength)],
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.maxLength)],
           },
           lift: true,
           type: "filter",
@@ -34,7 +26,7 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
           expression: {
             type: "operation",
             operator: ">=",
-            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets_literalFactory}.number(filter.minLength)],
+            args: [{ args: [valueVariable], operator: "strlen", type: "operation" }, ${snippets.literalFactory}.number(filter.minLength)],
           },
           lift: true,
           type: "filter",
@@ -42,6 +34,6 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_ValueSparqlWhe
       }
     }
 
-    return ${snippets_literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
+    return ${snippets.literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

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

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

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

@@ -1,16 +1,11 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
-import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
-import { snippets_TermFilter } from "./snippets_TermFilter.js";
-export const snippets_termFilterSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
-function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets_TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets_SparqlFilterPattern}[] {
+export const snippets_termFilterSparqlPatterns = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
+function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets.TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets.SparqlFilterPattern}[] {
   if (!filter) {
     return [];
   }
 
-  const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+  const filterPatterns: ${snippets.SparqlFilterPattern}[] = [];
 
   if (
     filter.datatypeIn !== undefined &&
@@ -31,7 +26,7 @@ function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable
   }
 
   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 (

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

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