@shaclmate/compiler 4.0.28 → 4.0.30

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js

@@ -1,15 +1,12 @@
 import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${imports.NamedNode} | ${imports.Variable} } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${imports.sparqljs}.ConstructQuery {
+export function sparqlConstructQuery({ filter, ignoreRdfType, preferredLanguages, prefixes, subject, ...queryParameters }: { filter?: ${this.filterType}; ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable} } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type">): ${this.reusables.imports.sparqljs}.ConstructQuery {
   const variablePrefix = subject.termType === "Variable" ? subject.value : "${camelCase(this.name)}";
 
   return {
@@ -17,7 +14,7 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
     prefixes: prefixes ?? {},
     queryType: "CONSTRUCT",
     template: (queryParameters.template ?? []).concat(
-      ${this.name}.${syntheticNamePrefix}focusSparqlConstructTriples({
+      ${this.name}.focusSparqlConstructTriples({
         filter,
         focusIdentifier: subject,
         ignoreRdfType: !!ignoreRdfType,
@@ -26,8 +23,8 @@ export function ${syntheticNamePrefix}sparqlConstructQuery({ filter, ignoreRdfTy
     ),
     type: "query",
     where: (queryParameters.where ?? []).concat(
-      ${snippets.normalizeSparqlWherePatterns}(
-        ${this.name}.${syntheticNamePrefix}focusSparqlWherePatterns({
+      ${this.reusables.snippets.normalizeSparqlWherePatterns}(
+        ${this.name}.focusSparqlWherePatterns({
           filter,
           focusIdentifier: subject,
           ignoreRdfType: !!ignoreRdfType,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -1,9 +1,11 @@
 import { Maybe } from "purify-ts";
+import type { Reusables } from "../Reusables.js";
 import type { TsFeature } from "../TsFeature.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly name: string;
+    readonly reusables: Reusables;
 }): Maybe<Code>;
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js

@@ -1,14 +1,12 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.${syntheticNamePrefix}sparqlConstructQuery>[0] & ${imports.sparqljs}.GeneratorOptions): string {
-  return new ${imports.sparqljs}.Generator(parameters).stringify(${this.name}.${syntheticNamePrefix}sparqlConstructQuery(parameters));
+export function sparqlConstructQueryString(parameters: Parameters<typeof ${this.name}.sparqlConstructQuery>[0] & ${this.reusables.imports.sparqljs}.GeneratorOptions): string {
+  return new ${this.reusables.imports.sparqljs}.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));
 }`);
 }
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionDeclaration.js

@@ -1,5 +1,4 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toJsonFunctionDeclaration() {
     if (!this.features.has("json")) {
@@ -7,7 +6,7 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
     }
     const jsonObjectMembers = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        jsonObjectMembers.push(code `...${parentObjectType.name}.${syntheticNamePrefix}toJson(${this.thisVariable})`);
+        jsonObjectMembers.push(code `...${parentObjectType.name}.toJson(${this.thisVariable})`);
     }
     if (this.properties.length > 0) {
         jsonObjectMembers.push(...this.properties.flatMap((property) => property
@@ -34,7 +33,7 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
     //     break;
     // }
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+export function toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
   return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
 }`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.js

@@ -1,8 +1,5 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toRdfResourceFunctionDeclaration() {
@@ -10,16 +7,16 @@ export function NamedObjectType_toRdfResourceFunctionDeclaration() {
         return Maybe.empty();
     }
     const statements = [
-        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });`,
+        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${this.reusables.imports.ResourceSet}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: ${this.reusables.imports.datasetFactory}.dataset() });`,
     ];
     if (this.parentObjectTypes.length > 0) {
-        statements.push(code `const ${variables.resource} = ${this.parentObjectTypes[0].name}.${syntheticNamePrefix}toRdfResource(${this.thisVariable}, { ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} });`);
+        statements.push(code `const ${variables.resource} = ${this.parentObjectTypes[0].name}.toRdfResource(${this.thisVariable}, { ${variables.ignoreRdfType}: true, ${variables.graph}: options?.${variables.graph}, ${variables.resourceSet} });`);
     }
     else {
         statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
     }
     if (this.toRdfTypes.length > 0) {
-        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
+        statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
     }
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({
@@ -35,7 +32,7 @@ export function NamedObjectType_toRdfResourceFunctionDeclaration() {
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-export function ${syntheticNamePrefix}toRdfResource(${this.thisVariable}: ${this.name}, options?: Parameters<${snippets.ToRdfResourceFunction}<${this.name}>>[1]): ${this.toRdfjsResourceType} {
+export function toRdfResource(${this.thisVariable}: ${this.name}, options?: Parameters<${this.reusables.snippets.ToRdfResourceFunction}<${this.name}>>[1]): ${this.toRdfjsResourceType} {
   ${joinCode(statements)}
 }`);
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.js

@@ -1,11 +1,10 @@
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toStringFunctionDeclarations() {
     const propertiesToStringRecordProperties = [];
     if (this.parentObjectTypes.length > 0) {
         for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}.${syntheticNamePrefix}propertiesToStrings(${this.thisVariable})`);
+            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}.propertiesToStrings(${this.thisVariable})`);
         }
     }
     for (const property of this.properties) {
@@ -21,19 +20,19 @@ export function NamedObjectType_toStringFunctionDeclarations() {
             propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
         });
     }
-    const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
+    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
     const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
     return [
         // Use overloads to allow the function to be attached to an instance or used freestanding
         code `\
-export function ${syntheticNamePrefix}propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+export function propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
   return ${propertiesToStringsReturnExpression};
 }`,
         code `\
 export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
 export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
 export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
-  return ${toStringReturnExpression(code `${syntheticNamePrefix}propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+  return ${toStringReturnExpression(code `propertiesToStrings((${this.thisVariable} ?? this)!)`)};
 }`,
     ];
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js

@@ -1,13 +1,11 @@
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.name}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
+  ${this.name}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
 //# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js

@@ -1,15 +1,13 @@
 import { Maybe } from "purify-ts";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     if (!this.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
-  (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(
-    ${this.name}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
+  (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
+    ${this.name}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
 //# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -7,9 +7,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { codeEquals } from "../codeEquals.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -135,15 +132,15 @@ export class ShaclProperty extends AbstractProperty {
         // Assume the property has the correct range and ignore the object's RDF type.
         // This also accommodates the case where the object of a property is a dangling identifier that's not the
         // subject of any statements.
-        return Maybe.of(code `${snippets.shaclPropertyFromRdf}(${{
+        return Maybe.of(code `${this.reusables.snippets.shaclPropertyFromRdf}(${{
             graph: variables.graph,
             resource: variables.resource,
-            propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+            propertySchema: code `schema.properties.${this.name}`,
             typeFromRdf: code `((resourceValues) => ${this.type.fromRdfResourceValuesExpression({
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.namedObjectType.name}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.namedObjectType.name}.schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -159,21 +156,21 @@ export class ShaclProperty extends AbstractProperty {
             .altLazy(() => Maybe.of(code `{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
     }
     sparqlConstructTriplesExpression({ variables, }) {
-        return Maybe.of(code `${snippets.shaclPropertySparqlConstructTriples}(${{
+        return Maybe.of(code `${this.reusables.snippets.shaclPropertySparqlConstructTriples}(${{
             filter: this.filterProperty
                 .map(({ name }) => code `${variables.filter}?.${name}`)
                 .extract(),
             focusIdentifier: variables.focusIdentifier,
             ignoreRdfType: true,
             propertyName: this.name,
-            propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+            propertySchema: code `schema.properties.${this.name}`,
             typeSparqlConstructTriples: this.type.valueSparqlConstructTriplesFunction,
             variablePrefix: variables.variablePrefix,
         }})`);
     }
     sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
-            patterns: code `${snippets.shaclPropertySparqlWherePatterns}(${{
+            patterns: code `${this.reusables.snippets.shaclPropertySparqlWherePatterns}(${{
                 filter: this.filterProperty
                     .map(({ name }) => code `${variables.filter}?.${name}`)
                     .extract(),
@@ -181,7 +178,7 @@ export class ShaclProperty extends AbstractProperty {
                 ignoreRdfType: true,
                 preferredLanguages: variables.preferredLanguages,
                 propertyName: this.name,
-                propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+                propertySchema: code `schema.properties.${this.name}`,
                 typeSparqlWherePatterns: this.type.valueSparqlWherePatternsFunction,
                 variablePrefix: variables.variablePrefix,
             }})`,
@@ -226,7 +223,7 @@ export class ShaclProperty extends AbstractProperty {
             case "ZeroOrOnePath":
                 return code `{ path: ${this.propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} as const }`;
             case "NamedNode":
-                return rdfjsTermExpression(propertyPath, { logger: this.logger });
+                return this.rdfjsTermExpression(propertyPath);
         }
     }
 }

package/dist/generators/ts/_NamedObjectType/identifierTypeDeclarations.js

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
     const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
@@ -6,15 +5,15 @@ export function identifierTypeDeclarations() {
         // This object type's identifier type has the same identifier type as an ancestor object type,
         // so just reuse the latter.
         return [
-            code `export type ${syntheticNamePrefix}Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
-            code `export const ${syntheticNamePrefix}Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
+            code `export type Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
+            code `export const Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
         ];
     }
     // Bespoke identifier type and associated functions
     return [
-        code `export type ${syntheticNamePrefix}Identifier = ${this.identifierType.name};`,
+        code `export type Identifier = ${this.identifierType.name};`,
         code `\
-export namespace ${syntheticNamePrefix}Identifier {
+export namespace Identifier {
   export const parse = ${this.identifierType.parseFunction};
   export const stringify = ${this.identifierType.stringifyFunction};
 }`,

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_BlankNodeFilter = conditionalOutput(`${syntheticNamePrefix}BlankNodeFilter`, code `\
+export const snippets_BlankNodeFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BlankNodeFilter`, code `\
 interface ${syntheticNamePrefix}BlankNodeFilter {
 }`);
 //# sourceMappingURL=snippets_BlankNodeFilter.js.map

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_BlankNodeSchema = conditionalOutput(`${syntheticNamePrefix}BlankNodeSchema`, code `\
+export const snippets_BlankNodeSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BlankNodeSchema`, code `\
 interface ${syntheticNamePrefix}BlankNodeSchema {
   readonly kind: "BlankNode";
 }`);

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_BooleanFilter = conditionalOutput(`${syntheticNamePrefix}BooleanFilter`, code `\
+export const snippets_BooleanFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanFilter`, code `\
 interface ${syntheticNamePrefix}BooleanFilter {
   readonly value?: boolean;
 }`);

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_BooleanSchema = conditionalOutput(`${syntheticNamePrefix}BooleanSchema`, code `\
+export const snippets_BooleanSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}BooleanSchema`, code `\
 interface ${syntheticNamePrefix}BooleanSchema {
   readonly kind: "Boolean";
   readonly in?: readonly boolean[];

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_CollectionFilter = conditionalOutput(`${syntheticNamePrefix}CollectionFilter`, code `\
+export const snippets_CollectionFilter = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}CollectionFilter`, code `\
 type ${syntheticNamePrefix}CollectionFilter<ItemFilterT> = ItemFilterT & {
   readonly ${syntheticNamePrefix}maxCount?: number;
   readonly ${syntheticNamePrefix}minCount?: number;

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_CollectionSchema = conditionalOutput(`${syntheticNamePrefix}CollectionSchema`, code `\
+export const snippets_CollectionSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}CollectionSchema`, code `\
 interface ${syntheticNamePrefix}CollectionSchema<ItemSchemaT> {
   readonly item: () => ItemSchemaT;
   readonly kind: "List" | "Set";

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_DateFilter = conditionalOutput(`${syntheticNamePrefix}DateFilter`, code `\
+export const snippets_DateFilter = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}DateFilter`, code `\
 interface ${syntheticNamePrefix}DateFilter {
   readonly in?: readonly Date[];
   readonly maxExclusive?: Date;

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_DateSchema = conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
+export const snippets_DateSchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}DateSchema`, code `\
 interface ${syntheticNamePrefix}DateSchema {
   in?: readonly Date[];
   kind: "Date" | "DateTime",

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_DefaultValueSchema = conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
+export const snippets_DefaultValueSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
 interface ${syntheticNamePrefix}DefaultValueSchema<ItemSchemaT> {
   readonly defaultValue: ${imports.Literal} | ${imports.NamedNode};
   readonly item: () => ItemSchemaT;

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_EqualsResult = conditionalOutput(`${syntheticNamePrefix}EqualsResult`, code `\
+export const snippets_EqualsResult = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}EqualsResult`, code `\
 export type ${syntheticNamePrefix}EqualsResult = ${imports.Either}<${syntheticNamePrefix}EqualsResult.Unequal, true>;
 
 export namespace ${syntheticNamePrefix}EqualsResult {

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FocusSparqlConstructTriplesFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlConstructTriplesFunction`, code `\
+export const snippets_FocusSparqlConstructTriplesFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FocusSparqlConstructTriplesFunction`, code `\
 type ${syntheticNamePrefix}FocusSparqlConstructTriplesFunction<FilterT> = 
   (parameters: {
     filter: FilterT | undefined;

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

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

package/dist/generators/ts/_snippets/snippets_FocusSparqlWherePatternsFunction.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_SparqlPattern } from "./snippets_SparqlPattern.js";
-export const snippets_FocusSparqlWherePatternsFunction = conditionalOutput(`${syntheticNamePrefix}FocusSparqlWherePatternsFunction`, code `\
+export const snippets_FocusSparqlWherePatternsFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FocusSparqlWherePatternsFunction`, code `\
 type ${syntheticNamePrefix}FocusSparqlWherePatternsFunction<FilterT> =
   (parameters: {
     filter: FilterT | undefined;
@@ -10,5 +7,5 @@ type ${syntheticNamePrefix}FocusSparqlWherePatternsFunction<FilterT> =
     ignoreRdfType: boolean;
     preferredLanguages: readonly string[] | undefined;
     variablePrefix: string;
-  }) => readonly ${snippets_SparqlPattern}[];`);
+  }) => readonly ${snippets.SparqlPattern}[];`);
 //# sourceMappingURL=snippets_FocusSparqlWherePatternsFunction.js.map

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromRdfResourceFunction = conditionalOutput(`${syntheticNamePrefix}FromRdfResourceFunction`, code `\
+export const snippets_FromRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceFunction`, code `\
 export type ${syntheticNamePrefix}FromRdfResourceFunction<T> = (
   resource: ${imports.Resource},
   options?: {

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromRdfResourceValuesFunction = conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
+export const snippets_FromRdfResourceValuesFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromRdfResourceValuesFunction`, code `\
 export type ${syntheticNamePrefix}FromRdfResourceValuesFunction<T> = (
   resourceValues: ${imports.Either}<Error, ${imports.Resource}.Values>,
   options: {

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

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

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

@@ -1,4 +1,3 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_Hasher = conditionalOutput(`${syntheticNamePrefix}Hasher`, code `type ${syntheticNamePrefix}Hasher = { update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; };`);
+export const snippets_Hasher = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}Hasher`, code `type ${syntheticNamePrefix}Hasher = { update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; };`);
 //# sourceMappingURL=snippets_Hasher.js.map

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_IdentifierFilter = conditionalOutput(`${syntheticNamePrefix}IdentifierFilter`, code `\
+export const snippets_IdentifierFilter = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierFilter`, code `\
 interface ${syntheticNamePrefix}IdentifierFilter {
   readonly in?: readonly (${imports.BlankNode} | ${imports.NamedNode})[];
   readonly type?: "BlankNode" | "NamedNode";

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

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

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

@@ -1,6 +1,5 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_IdentifierSchema = conditionalOutput(`${syntheticNamePrefix}IdentifierSchema`, code `\
+export const snippets_IdentifierSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierSchema`, code `\
 interface ${syntheticNamePrefix}IdentifierSchema {
   readonly kind: "Identifier";
 }`);

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

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

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

@@ -1,7 +1,5 @@
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_IdentifierSet = conditionalOutput(`${syntheticNamePrefix}IdentifierSet`, code `\
+export const snippets_IdentifierSet = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}IdentifierSet`, code `\
 class ${syntheticNamePrefix}IdentifierSet {
   private readonly blankNodeValues = new Set<string>();
   private readonly namedNodeValues = new Set<string>();