@shaclmate/compiler 4.0.29 → 4.0.31

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -12,10 +12,6 @@ export function shapeAstTypeName(shape) {
     if (shape.shaclmateName.isJust()) {
         return shape.shaclmateName;
     }
-    // Explicit rdfs:label
-    if (shape.label.isJust()) {
-        return shape.label;
-    }
     // CURIE shape identifier
     if (shapeIdentifier instanceof Curie) {
         if (shapeIdentifier.hasUniqueReference) {

package/dist/generators/ts/AbstractCollectionType.js

@@ -9,8 +9,6 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
@@ -83,15 +81,15 @@ export class AbstractCollectionType extends AbstractContainerType {
                         sourceTypeCheckExpression: (value) => {
                             switch (itemTypeof) {
                                 case "bigint":
-                                    return code `${snippets.isReadonlyBigIntArray}(${value})`;
+                                    return code `${this.reusables.snippets.isReadonlyBigIntArray}(${value})`;
                                 case "boolean":
-                                    return code `${snippets.isReadonlyBooleanArray}(${value})`;
+                                    return code `${this.reusables.snippets.isReadonlyBooleanArray}(${value})`;
                                 case "number":
-                                    return code `${snippets.isReadonlyNumberArray}(${value})`;
+                                    return code `${this.reusables.snippets.isReadonlyNumberArray}(${value})`;
                                 case "object":
-                                    return code `${snippets.isReadonlyObjectArray}(${value})`;
+                                    return code `${this.reusables.snippets.isReadonlyObjectArray}(${value})`;
                                 case "string":
-                                    return code `${snippets.isReadonlyStringArray}(${value})`;
+                                    return code `${this.reusables.snippets.isReadonlyStringArray}(${value})`;
                                 case "function":
                                 case "symbol":
                                 case "undefined":
@@ -109,7 +107,7 @@ export class AbstractCollectionType extends AbstractContainerType {
             // Don't try to do any item type conversions here (yet).
             conversions.push({
                 conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `${imports.NonEmptyList}.isNonEmpty(${value})`,
+                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.NonEmptyList}.isNonEmpty(${value})`,
                 sourceTypeName: this.name,
                 sourceTypeof: "object",
             });
@@ -117,16 +115,16 @@ export class AbstractCollectionType extends AbstractContainerType {
         return conversions;
     }
     get equalsFunction() {
-        return code `((left, right) => ${snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
+        return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
     get filterFunction() {
-        return code `${snippets.filterArray}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterArray}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
-        return code `${snippets.CollectionFilter}<${this.itemType.filterType}>`;
+        return code `${this.reusables.snippets.CollectionFilter}<${this.itemType.filterType}>`;
     }
     get graphqlType() {
-        return new AbstractContainerType.GraphqlType(code `new ${imports.GraphQLList}(${this.itemType.graphqlType.name})`);
+        return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.name})`, this.reusables);
     }
     get mutable() {
         return this._mutable || this.itemType.mutable;
@@ -138,10 +136,10 @@ export class AbstractCollectionType extends AbstractContainerType {
         if (this.minCount === 0n) {
             return code `readonly (${this.itemType.name})[]`;
         }
-        return code `${imports.NonEmptyList}<${this.itemType.name}>`;
+        return code `${this.reusables.imports.NonEmptyList}<${this.itemType.name}>`;
     }
     get schemaType() {
-        return code `${snippets.CollectionSchema}<${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
     get schemaObject() {
         return {
@@ -152,7 +150,7 @@ export class AbstractCollectionType extends AbstractContainerType {
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
         if (!this._mutable && this.minCount > 0n) {
-            expression = code `${imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
+            expression = code `${this.reusables.imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
         }
         if (this.minCount === 0n) {
             expression = code `(${expression} ?? [])`;

package/dist/generators/ts/AbstractDateType.js

@@ -7,17 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
-    equalsFunction = code `${snippets.dateEquals}`;
-    filterFunction = code `${snippets.filterDate}`;
-    filterType = code `${snippets.DateFilter}`;
+    equalsFunction = code `${this.reusables.snippets.dateEquals}`;
+    filterFunction = code `${this.reusables.snippets.filterDate}`;
+    filterType = code `${this.reusables.snippets.DateFilter}`;
     mutable = false;
     name = "Date";
-    schemaType = code `${snippets.DateSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.DateSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     typeofs = NonEmptyList(["object"]);
     get conversions() {
         return [
@@ -49,7 +47,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
+        return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,12 +3,12 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;
     readonly stringifyFunction: Code;
     get conversions(): readonly AbstractTermType.Conversion[];
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }
 //# sourceMappingURL=AbstractIdentifierType.d.ts.map

package/dist/generators/ts/AbstractIdentifierType.js

@@ -6,16 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
-    graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
-    stringifyFunction = code `${imports.NTriplesTerm}.stringify`;
+    stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.nodeKinds.has("IRI")) {
             conversions.push({
-                conversionExpression: (value) => code `${imports.dataFactory}.namedNode(${value})`,
+                conversionExpression: (value) => code `${this.reusables.imports.dataFactory}.namedNode(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
                 sourceTypeName: this.in_.length > 0
                     ? code `${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}`
@@ -25,11 +23,17 @@ export class AbstractIdentifierType extends AbstractTermType {
         }
         return conversions;
     }
+    get graphqlType() {
+        return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    }
     graphqlResolveExpression({ variables: { value }, }) {
-        return code `${imports.NTriplesTerm}.stringify(${value})`;
+        return code `${this.reusables.imports.NTriplesTerm}.stringify(${value})`;
     }
 }
 __decorate([
     Memoize()
 ], AbstractIdentifierType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractIdentifierType.prototype, "graphqlType", null);
 //# sourceMappingURL=AbstractIdentifierType.js.map

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -8,7 +8,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
     protected readonly partialType: PartialTypeT;
     protected readonly resolveType: ResolveTypeT;
-    protected readonly runtimeClass: {
+    protected abstract readonly runtimeClass: {
         readonly name: Code;
         readonly partialPropertyName: string;
         readonly rawName: Code;
@@ -17,10 +17,9 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly typeofs: NonEmptyList<"object">;
-    constructor({ partialType, resolveType, runtimeClass, ...superParameters }: {
+    constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
-        runtimeClass: AbstractLazyObjectType<ResolveTypeT, PartialTypeT>["runtimeClass"];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get conversions(): readonly AbstractType.Conversion[];
     get equalsFunction(): Code;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -9,21 +9,18 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyObjectType extends AbstractType {
     partialType;
     resolveType;
-    runtimeClass;
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
     typeofs = NonEmptyList(["object"]);
-    constructor({ partialType, resolveType, runtimeClass, ...superParameters }) {
+    constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
         this.partialType = partialType;
         this.resolveType = resolveType;
-        this.runtimeClass = runtimeClass;
     }
     get conversions() {
         return [
@@ -124,7 +121,7 @@ export class AbstractLazyObjectType extends AbstractType {
         invariant(resolvedNamedObjectUnionType.members.length ===
             partialNamedObjectUnionType.members.length);
         const caseBlocks = resolvedNamedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.${syntheticNamePrefix}create(${variables.resolvedObjectUnion});`;
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialNamedObjectUnionType.members[memberI].type.name}.create(${variables.resolvedObjectUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,5 +1,4 @@
 import { AbstractTermType } from "./AbstractTermType.js";
-import { snippets } from "./snippets.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractLiteralType extends AbstractTermType {
     nodeKinds = nodeKinds;
@@ -21,9 +20,9 @@ export class AbstractLiteralType extends AbstractTermType {
         return {
             ...super.fromRdfExpressionChain({ variables }),
             languageIn: this.languageIn.length > 0
-                ? code `chain(values => ${snippets.fromRdfLanguageIn}(values, ${JSON.stringify(this.languageIn)}))`
+                ? code `chain(values => ${this.reusables.snippets.fromRdfLanguageIn}(values, ${JSON.stringify(this.languageIn)}))`
                 : undefined,
-            preferredLanguages: code `chain(values => ${snippets.fromRdfPreferredLanguages}(values, ${variables.preferredLanguages}))`,
+            preferredLanguages: code `chain(values => ${this.reusables.snippets.fromRdfPreferredLanguages}(values, ${variables.preferredLanguages}))`,
             valueTo: code `chain(values => values.chainMap(value => value.toLiteral()))`,
         };
     }

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -8,8 +8,6 @@ import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { AbstractUnionType } from "./AbstractUnionType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractNamedUnionType extends AbstractUnionType {
@@ -37,15 +35,15 @@ ${joinCode(staticModuleDeclarations
     }
     get equalsFunction() {
         if (this.features.has("equals")) {
-            return code `${this.name}.${syntheticNamePrefix}equals`;
+            return code `${this.name}.equals`;
         }
         return this.inlineEqualsFunction;
     }
     get filterFunction() {
-        return code `${this.name}.${syntheticNamePrefix}filter`;
+        return code `${this.name}.filter`;
     }
     get filterType() {
-        return code `${this.name}.${syntheticNamePrefix}Filter`;
+        return code `${this.name}.Filter`;
     }
     get jsonSchemaFunctionDeclaration() {
         const meta = {
@@ -60,66 +58,66 @@ ${joinCode(staticModuleDeclarations
         return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
     }
     get jsonTypeAliasDeclaration() {
-        return code `export type ${syntheticNamePrefix}Json = ${this.inlineJsonType.name}`;
+        return code `export type Json = ${this.inlineJsonType.name}`;
     }
     get name() {
         return this._name;
     }
     get valueSparqlConstructTriplesFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.name}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+            return code `${this.name}.valueSparqlConstructTriples`;
         }
         return this.inlineValueSparqlConstructTriplesFunction;
     }
     get valueSparqlWherePatternsFunction() {
         if (this.features.has("sparql")) {
-            return code `${this.name}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+            return code `${this.name}.valueSparqlWherePatterns`;
         }
         return this.inlineValueSparqlWherePatternsFunction;
     }
     get staticModuleDeclarations() {
         const staticModuleDeclarations = {};
         if (this.features.has("equals")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}equals`] =
-                code `export const ${syntheticNamePrefix}equals = ${this.inlineEqualsFunction};`;
+            staticModuleDeclarations[`equals`] =
+                code `export const equals = ${this.inlineEqualsFunction};`;
         }
-        staticModuleDeclarations[`${syntheticNamePrefix}Filter`] =
-            code `export type ${syntheticNamePrefix}Filter = ${this.inlineFilterType};`;
-        staticModuleDeclarations[`${syntheticNamePrefix}filter`] =
-            code `export const ${syntheticNamePrefix}filter = ${this.inlineFilterFunction};`;
+        staticModuleDeclarations[`Filter`] =
+            code `export type Filter = ${this.inlineFilterType};`;
+        staticModuleDeclarations[`filter`] =
+            code `export const filter = ${this.inlineFilterFunction};`;
         if (this.features.has("hash")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}hash`] =
-                code `export function ${syntheticNamePrefix}hash<HasherT extends ${snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
+            staticModuleDeclarations[`hash`] =
+                code `export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
         }
         if (this.features.has("json")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}Json`] = code `\
+            staticModuleDeclarations[`Json`] = code `\
 ${this.jsonTypeAliasDeclaration}
 
-export namespace ${syntheticNamePrefix}Json {
+export namespace Json {
   ${this.jsonSchemaFunctionDeclaration}
 
-  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);
   }
 }`;
-            staticModuleDeclarations[`${syntheticNamePrefix}fromJson`] =
-                code `export const ${syntheticNamePrefix}fromJson = ${this.inlineFromJsonFunction};`;
-            staticModuleDeclarations[`${syntheticNamePrefix}toJson`] =
-                code `export const ${syntheticNamePrefix}toJson = ${this.inlineToJsonFunction};`;
+            staticModuleDeclarations[`fromJson`] =
+                code `export const fromJson = ${this.inlineFromJsonFunction};`;
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.inlineToJsonFunction};`;
         }
         if (this.features.has("rdf")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}fromRdfResourceValues`] =
-                code `export const ${syntheticNamePrefix}fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
-            staticModuleDeclarations[`${syntheticNamePrefix}toRdfResourceValues`] =
-                code `export const ${syntheticNamePrefix}toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
+            staticModuleDeclarations[`fromRdfResourceValues`] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
+            staticModuleDeclarations[`toRdfResourceValues`] =
+                code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
         if (this.features.has("sparql")) {
-            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlConstructTriples`] =
-                code `export const ${syntheticNamePrefix}valueSparqlConstructTriples: ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
-            staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlWherePatterns`] =
-                code `export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
+            staticModuleDeclarations[`valueSparqlConstructTriples`] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
+            staticModuleDeclarations[`valueSparqlWherePatterns`] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
         staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
             code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
@@ -127,30 +125,30 @@ export namespace ${syntheticNamePrefix}Json {
     }
     fromJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.name}.${syntheticNamePrefix}fromJson(${variables.value})`;
+            return code `${this.name}.fromJson(${variables.value})`;
         }
         return code `${this.inlineFromJsonFunction}(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.name}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
+            return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
         }
         return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
     }
     hashStatements({ depth, variables, }) {
         if (this.features.has("hash")) {
             return [
-                code `${this.name}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                code `${this.name}.hash(${variables.value}, ${variables.hasher});`,
             ];
         }
         return this.inlineHashStatements({ depth, variables });
     }
     jsonSchema({ context, }) {
         if (this.features.has("json")) {
-            const expression = code `${this.name}.${syntheticNamePrefix}Json.schema()`;
+            const expression = code `${this.name}.Json.schema()`;
             if (context === "property" && this.recursive) {
-                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.name}.${syntheticNamePrefix}Json> => ${expression})`;
+                return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
             }
             return expression;
         }
@@ -158,20 +156,20 @@ export namespace ${syntheticNamePrefix}Json {
     }
     jsonType() {
         if (this.features.has("json")) {
-            return new AbstractType.JsonType(`${this.name}.${syntheticNamePrefix}Json`);
+            return new AbstractType.JsonType(`${this.name}.Json`);
         }
         return this.inlineJsonType;
     }
     toJsonExpression({ variables, }) {
         if (this.features.has("json")) {
-            return code `${this.name}.${syntheticNamePrefix}toJson(${variables.value})`;
+            return code `${this.name}.toJson(${variables.value})`;
         }
         return code `${this.inlineToJsonFunction}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
         if (this.features.has("rdf")) {
-            return code `${this.name}.${syntheticNamePrefix}toRdfResourceValues(${valueVariable}, ${otherVariables})`;
+            return code `${this.name}.toRdfResourceValues(${valueVariable}, ${otherVariables})`;
         }
         return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
     }

package/dist/generators/ts/AbstractNumericType.js

@@ -6,19 +6,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export class AbstractNumericType extends AbstractPrimitiveType {
     get filterFunction() {
-        return code `${snippets.filterNumeric}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
     }
     get filterType() {
-        return code `${snippets.NumericFilter}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.NumericFilter}<${this.typeofs[0]}>`;
     }
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -27,10 +24,10 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         return this.typeofs[0];
     }
     get schemaType() {
-        return code `${snippets.NumericSchema}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.NumericSchema}<${this.typeofs[0]}>`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
     }
     get schemaObject() {
         return {
@@ -43,15 +40,15 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${imports.z}.${this.typeofs[0]}()`;
+                return code `${this.reusables.imports.z}.${this.typeofs[0]}()`;
             case 1:
-                return code `${imports.z}.literal(${this.literalOf(this.primitiveIn[0])})`;
+                return code `${this.reusables.imports.z}.literal(${this.literalOf(this.primitiveIn[0])})`;
             default:
-                return code `${imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
+        return code `[${this.reusables.snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,11 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractPrimitiveType extends AbstractLiteralType {
     datatype;
-    equalsFunction = code `${snippets.strictEquals}`;
+    equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     primitiveIn;
     constructor({ datatype, primitiveIn, ...superParameters }) {
         super(superParameters);

package/dist/generators/ts/AbstractTermType.js

@@ -8,10 +8,7 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { removeUndefined } from "./removeUndefined.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
@@ -23,7 +20,7 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  */
 export class AbstractTermType extends AbstractType {
     declaration = Maybe.empty();
-    equalsFunction = code `${snippets.booleanEquals}`;
+    equalsFunction = code `${this.reusables.snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
     in_;
@@ -44,27 +41,27 @@ export class AbstractTermType extends AbstractType {
         const conversions = [];
         if (this.nodeKinds.has("Literal")) {
             conversions.push({
-                conversionExpression: (value) => code `${snippets.literalFactory}.bigint(${value})`,
+                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.bigint(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "bigint"`,
                 sourceTypeName: code `bigint`,
                 sourceTypeof: "bigint",
             }, {
-                conversionExpression: (value) => code `${snippets.literalFactory}.boolean(${value})`,
+                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.boolean(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "boolean"`,
                 sourceTypeName: code `boolean`,
                 sourceTypeof: "boolean",
             }, {
-                conversionExpression: (value) => code `${snippets.literalFactory}.date(${value})`,
+                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.date(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
                 sourceTypeName: code `Date`,
                 sourceTypeof: "object",
             }, {
-                conversionExpression: (value) => code `${snippets.literalFactory}.number(${value})`,
+                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.number(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
                 sourceTypeName: code `number`,
                 sourceTypeof: "number",
             }, {
-                conversionExpression: (value) => code `${snippets.literalFactory}.string(${value})`,
+                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.string(${value})`,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
                 sourceTypeName: code `string`,
                 sourceTypeof: "string",
@@ -80,9 +77,10 @@ export class AbstractTermType extends AbstractType {
     }
     get discriminantProperty() {
         return Maybe.of({
+            descendantValues: [],
+            jsonName: "termType",
             name: "termType",
             ownValues: [...this.nodeKinds].map(NodeKind.toTermType),
-            descendantValues: [],
             type: "string",
         });
     }
@@ -141,14 +139,14 @@ export class AbstractTermType extends AbstractType {
     fromRdfExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
-            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger })), { on: ", " })}])`;
+            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}])`;
         }
         else if (this.nodeKinds.size < 3) {
             const eitherTypeParameters = code `<Error, ${this.name}>`;
             valueToExpression = code `value.toTerm().chain(term => {
   switch (term.termType) {
-  ${[...this.nodeKinds].map((nodeKind) => `case "${NodeKind.toTermType(nodeKind)}":`).join("\n")} return ${imports.Either}.of${eitherTypeParameters}(term);
-  default: return ${imports.Left}${eitherTypeParameters}(new ${imports.Resource}.MistypedTermValueError(${{ actualValue: code `term`, expectedValueType: code `${this.name}`.toCodeString([]), focusResource: variables.resource, propertyPath: variables.propertyPath }}));
+  ${[...this.nodeKinds].map((nodeKind) => `case "${NodeKind.toTermType(nodeKind)}":`).join("\n")} return ${this.reusables.imports.Either}.of${eitherTypeParameters}(term);
+  default: return ${this.reusables.imports.Left}${eitherTypeParameters}(new ${this.reusables.imports.Resource}.MistypedTermValueError(${{ actualValue: code `term`, expectedValueType: code `${this.name}`.toCodeString([]), focusResource: variables.resource, propertyPath: variables.propertyPath }}));
   }})`;
         }
         else {
@@ -157,7 +155,7 @@ export class AbstractTermType extends AbstractType {
         return {
             hasValues: this.hasValues.length > 0
                 ? code `\
-chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => rdfjsTermExpression(hasValue, { logger: this.logger })), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
+chain(values => ${this.reusables.imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
                 : undefined,
             valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
         };