@shaclmate/compiler 4.0.29 → 4.0.31

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

@@ -1,5 +1,3 @@
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 const hasherVariable = code `_hasher`;
 export function NamedObjectType_hashFunctionDeclarations() {
@@ -20,9 +18,9 @@ export function NamedObjectType_hashFunctionDeclarations() {
     const hashShaclPropertiesStatements = [];
     const hashStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
     }
-    hashStatements.push(code `${this.name}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    hashStatements.push(code `${this.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
     hashStatements.push(...this.properties
@@ -37,11 +35,11 @@ export function NamedObjectType_hashFunctionDeclarations() {
     hashStatements.push(code `return ${hasherVariable};`);
     return [
         code `\
-export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
   ${joinCode(hashStatements)}
 }`,
         code `\
-export function ${syntheticNamePrefix}hashShaclProperties<HasherT extends ${snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
   ${joinCode(hashShaclPropertiesStatements)}
 }`,
     ];

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

@@ -1,16 +1,14 @@
 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_jsonParseFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
   const jsonSafeParseResult = schema().safeParse(json);
-  if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
-  return ${imports.Right}(jsonSafeParseResult.data);
+  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonParseFunctionDeclaration.js.map

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

@@ -1,6 +1,4 @@
 import { Maybe } from "purify-ts";
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
@@ -27,7 +25,7 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
     return Maybe.of(code `\
 export function schema() {
-  return ${imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+  return ${this.reusables.imports.z}.object({${joinCode(properties, { on: "," })}}).meta(${meta}) satisfies ${this.reusables.imports.z}.ZodType<Json>;
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.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_jsonTypeAliasDeclaration() {
     if (!this.features.has("json")) {
@@ -12,6 +11,6 @@ export function NamedObjectType_jsonTypeAliasDeclaration() {
     for (const parentObjectType of this.parentObjectTypes) {
         members.push(code `${parentObjectType.jsonType().name}`);
     }
-    return Maybe.of(code `export type ${syntheticNamePrefix}Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
+    return Maybe.of(code `export type Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
 }
 //# sourceMappingURL=NamedObjectType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.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_jsonUiSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
@@ -7,7 +6,7 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     }
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.name}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
+        .map((parentObjectType) => code `${parentObjectType.name}.Json.uiSchema({ scopePrefix })`)
         .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {

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

@@ -1,9 +1,8 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_schemaVariableStatement() {
     return code `\
-export const ${syntheticNamePrefix}schema = { properties: { ${joinCode(this.parentObjectTypes
-        .map((parentObjectType) => code `...${parentObjectType.name}.${syntheticNamePrefix}schema.properties`)
+export const schema = { properties: { ${joinCode(this.parentObjectTypes
+        .map((parentObjectType) => code `...${parentObjectType.name}.schema.properties`)
         .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
 }
 //# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.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_sparqlConstructQueryFunctionDeclaration(this: {
     readonly features: ReadonlySet<TsFeature>;
     readonly filterType: Code;
     readonly name: string;
+    readonly reusables: Reusables;
 }): Maybe<Code>;
 //# sourceMappingURL=NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts.map

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,48 +1,39 @@
 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() {
     if (!this.features.has("rdf")) {
         return Maybe.empty();
     }
-    const statements = [
-        code `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${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} });`);
-    }
-    else {
-        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
-    }
+    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
     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 (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({
             variables: {
-                graph: code `options?.${variables.graph}`,
+                graph: variables.graph,
                 resource: variables.resource,
                 resourceSet: variables.resourceSet,
                 value: property.accessExpression({
-                    variables: { object: this.thisVariable },
+                    variables: { object: variables.object },
                 }),
             },
         }));
     }
     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} {
-  ${joinCode(statements)}
-}`);
+export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.name}> = (parameters) => {
+${joinCode(statements)}
+}
+
+export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
 }
 const variables = {
-    ignoreRdfType: code `ignoreRdfType`,
-    graph: code `graph`,
-    resource: code `resource`,
-    resourceSet: code `resourceSet`,
+    ignoreRdfType: code `parameters.ignoreRdfType`,
+    graph: code `parameters.graph`,
+    object: code `parameters.object`,
+    resource: code `parameters.resource`,
+    resourceSet: code `parameters.resourceSet`,
 };
 //# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.js.map

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

@@ -36,7 +36,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         type: Code;
     };
     constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonStatements({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonStatements"]>[0]): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements(parameters: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

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";
@@ -126,24 +123,24 @@ export class ShaclProperty extends AbstractProperty {
             .concat(code `{ ${this.name} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
         return statements;
     }
-    fromJsonStatements({ variables, }) {
-        return [
-            code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: code `${variables.jsonObject}["${this.name}"]` } })};`,
-        ];
+    fromJsonExpression({ variables, }) {
+        return Maybe.of(this.type.fromJsonExpression({
+            variables: { value: code `${variables.jsonObject}["${this.name}"]` },
+        }));
     }
     fromRdfResourceValuesExpression({ variables, }) {
         // 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