@shaclmate/compiler 4.0.29 → 4.0.30

package/dist/generators/ts/AbstractType.js

@@ -6,13 +6,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export class AbstractType {
     logger;
+    reusables;
+    rdfjsTermExpression;
     /**
      * Comment from rdfs:comment.
      */
@@ -21,10 +23,16 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, logger, }) {
+    constructor({ comment, label, logger, reusables, }) {
         this.comment = comment;
         this.label = label;
         this.logger = logger;
+        this.reusables = reusables;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -46,14 +54,16 @@ export class AbstractType {
          * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
         nullableName;
-        constructor(nullableName, parameters) {
-            this.nullable = !!parameters?.nullable;
+        reusables;
+        constructor(nullableName, reusables, options) {
+            this.nullable = !!options?.nullable;
             this.nullableName = nullableName;
+            this.reusables = reusables;
         }
         get name() {
             return this.nullable
                 ? this.nullableName
-                : code `new ${imports.GraphQLNonNull}(${this.nullableName})`;
+                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableName})`;
         }
     }
     __decorate([

package/dist/generators/ts/AbstractUnionType.js

@@ -8,9 +8,7 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
-import { imports } from "./imports.js";
 import { removeUndefined } from "./removeUndefined.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
@@ -220,7 +218,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
 }`))}
 
-  return ${imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+  return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
 })`;
     }
     get inlineFilterFunction() {
@@ -276,7 +274,7 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
         return code `\
 (((values, _options) =>
     values.chain(values => values.chainMap(value => {
-      const valueAsValues = ${imports.Right}(value.toValues());
+      const valueAsValues = ${this.reusables.imports.Right}(value.toValues());
       return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
             let typeExpression = type.fromRdfResourceValuesExpression({
                 variables: {
@@ -295,24 +293,24 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     this.discriminant.memberValues[memberI].kind === "extrinsic")) {
                 typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.name})))`;
             }
-            typeExpression = code `(${typeExpression} as ${imports.Either}<Error, ${imports.Resource}.Values<${this.name}>>)`;
+            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.name}>>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;
         }, null)}.chain(values => values.head());
     }))
-) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
     }
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "extrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
             case "hybrid":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
                     switch (discriminant.memberValues[memberI].kind) {
                         case "extrinsic":
-                            return code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
+                            return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
                         case "intrinsic":
                             return type.jsonSchema({
                                 includeDiscriminantProperty: true,
@@ -323,12 +321,12 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                     }
                 }), { on: "," })}]).readonly()`;
             case "intrinsic":
-                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw discriminant;
         }
@@ -398,11 +396,11 @@ ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap })
 (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
             switch (toRdfResourceValueType) {
                 case "BlankNode":
-                    return code `${imports.BlankNode}`;
+                    return code `${this.reusables.imports.BlankNode}`;
                 case "Literal":
-                    return code `${imports.Literal}`;
+                    return code `${this.reusables.imports.Literal}`;
                 case "NamedNode":
-                    return code `${imports.NamedNode}`;
+                    return code `${this.reusables.imports.NamedNode}`;
                 default:
                     toRdfResourceValueType;
                     throw new Error();
@@ -419,7 +417,7 @@ ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeChe
         })}; }`))}
 
   throw new Error("unable to serialize to RDF");
-}) satisfies ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
     }
     get inlineToStringFunction() {
         return code `\
@@ -434,24 +432,24 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
     get inlineValueSparqlConstructTriplesFunction() {
         return code `\
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
-  let triples: ${imports.sparqljs}.Triple[] = [];
+  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
   
   return triples;
-}) satisfies ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get inlineValueSparqlWherePatternsFunction() {
         return code `\
 ((({ filter, schema, ...otherParameters }) => {
-  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+  const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
 
   ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
 unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
     get schemaObject() {
         return {

package/dist/generators/ts/BigDecimalType.d.ts

@@ -3,19 +3,19 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BigDecimalType";
     readonly name: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversions(): readonly AbstractLiteralType.Conversion[];
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractLiteralType.JsonType;
     jsonSchema(): Code;
+    jsonType(): AbstractLiteralType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -6,22 +6,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
-    filterFunction = code `${snippets.filterBigDecimal}`;
-    filterType = code `${snippets.NumericFilter}<${imports.BigDecimal}>`;
-    graphqlType = new AbstractLiteralType.GraphqlType(code `${imports.GraphQLString}`);
+    filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
+    filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     kind = "BigDecimalType";
-    name = code `${imports.BigDecimal}`;
-    schemaType = code `${snippets.NumericSchema}<${imports.BigDecimal}>`;
-    valueSparqlWherePatternsFunction = code `${snippets.bigDecimalSparqlWherePatterns}`;
+    name = code `${this.reusables.imports.BigDecimal}`;
+    schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
     get conversions() {
         return [
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value}.toString())`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value}.toString())`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "bigint"`,
             //   sourceTypeName: code`bigint`,
@@ -30,12 +27,12 @@ export class BigDecimalType extends AbstractLiteralType {
             {
                 conversionExpression: (value) => value,
                 sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `${imports.BigDecimal}`,
+                sourceTypeName: code `${this.reusables.imports.BigDecimal}`,
                 sourceTypeof: "object",
             },
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value})`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "number"`,
             //   sourceTypeName: code`number`,
@@ -43,7 +40,7 @@ export class BigDecimalType extends AbstractLiteralType {
             // },
             // {
             //   conversionExpression: (value) =>
-            //     code`new ${imports.BigDecimal}(${value})`,
+            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
             //   sourceTypeCheckExpression: (value) =>
             //     code`typeof ${value} === "string"`,
             //   sourceTypeName: code`string`,
@@ -51,8 +48,11 @@ export class BigDecimalType extends AbstractLiteralType {
             // },
         ];
     }
+    get graphqlType() {
+        return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    }
     fromJsonExpression({ variables, }) {
-        return code `new ${imports.BigDecimal}(${variables.value})`;
+        return code `new ${this.reusables.imports.BigDecimal}(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
@@ -60,32 +60,35 @@ export class BigDecimalType extends AbstractLiteralType {
     hashStatements({ variables, }) {
         return [code `${variables.hasher}.update(${variables.value}.toFixed());`];
     }
+    jsonSchema() {
+        return code `${this.reusables.imports.z}.string()`;
+    }
     jsonType() {
         return new AbstractLiteralType.JsonType("string");
     }
-    jsonSchema() {
-        return code `${imports.z}.string()`;
-    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
+    }
     fromRdfExpressionChain({ variables, }) {
         return {
             ...super.fromRdfExpressionChain({ variables }),
-            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})))`,
+            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${this.reusables.snippets.decodeBigDecimalLiteral})))`,
         };
     }
-    toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.bigDecimalLiteral}(${variables.value})]`;
-    }
 }
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], BigDecimalType.prototype, "jsonType", null);
+], BigDecimalType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "jsonType", null);
 //# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.d.ts

@@ -2,9 +2,9 @@ import { NonEmptyList } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BigIntType";
     readonly typeofs: NonEmptyList<"bigint">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     get conversions(): readonly AbstractNumericType.Conversion[];
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -7,12 +7,13 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { imports } from "./imports.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
-    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLBigInt}`);
     kind = "BigIntType";
     typeofs = NonEmptyList(["bigint"]);
+    get graphqlType() {
+        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
+    }
     get conversions() {
         if (this.in_.length > 0) {
             return super.conversions;
@@ -34,11 +35,11 @@ export class BigIntType extends AbstractNumericType {
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${imports.z}.string()`;
+                return code `${this.reusables.imports.z}.string()`;
             case 1:
-                return code `${imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
+                return code `${this.reusables.imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
             default:
-                return code `${imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
         }
     }
     jsonType() {
@@ -54,6 +55,9 @@ export class BigIntType extends AbstractNumericType {
         return `${value.toString()}n`;
     }
 }
+__decorate([
+    Memoize()
+], BigIntType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "jsonType", null);

package/dist/generators/ts/BlankNodeType.js

@@ -7,18 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
-    filterFunction = code `${snippets.filterBlankNode}`;
-    filterType = code `${snippets.BlankNodeFilter}`;
-    parseFunction = code `${snippets.parseBlankNode};`;
+    filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
+    filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
+    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
     kind = "BlankNodeType";
-    name = code `${imports.BlankNode}`;
+    name = code `${this.reusables.imports.BlankNode}`;
     nodeKinds = nodeKinds;
-    schemaType = code `${snippets.BlankNodeSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
     constructor(superParameters) {
         super({
             ...superParameters,
@@ -27,7 +25,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+        return code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -37,9 +35,9 @@ export class BlankNodeType extends AbstractIdentifierType {
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${imports.z}.literal("BlankNode")`
+            ? code `, termType: ${this.reusables.imports.z}.literal("BlankNode")`
             : "";
-        return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1)${discriminantProperty} })`;
+        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty

package/dist/generators/ts/BooleanType.d.ts

@@ -4,11 +4,11 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BooleanType";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"boolean">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     get name(): string;
     protected get schemaObject(): {
         in: boolean[] | undefined;

package/dist/generators/ts/BooleanType.js

@@ -7,18 +7,17 @@ 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 { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
-    filterFunction = code `${snippets.filterBoolean}`;
-    filterType = code `${snippets.BooleanFilter}`;
-    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLBoolean}`);
+    filterFunction = code `${this.reusables.snippets.filterBoolean}`;
+    filterType = code `${this.reusables.snippets.BooleanFilter}`;
     kind = "BooleanType";
-    schemaType = code `${snippets.BooleanSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.booleanSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.BooleanSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
     typeofs = NonEmptyList(["boolean"]);
+    get graphqlType() {
+        return new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
+    }
     get name() {
         if (this.primitiveIn.length > 0) {
             return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
@@ -33,12 +32,12 @@ export class BooleanType extends AbstractPrimitiveType {
     }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
-            return code `${imports.z}.literal(${this.primitiveIn[0]})`;
+            return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
         }
-        return code `${imports.z}.boolean()`;
+        return code `${this.reusables.imports.z}.boolean()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
+        return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {
@@ -49,6 +48,9 @@ export class BooleanType extends AbstractPrimitiveType {
         };
     }
 }
+__decorate([
+    Memoize()
+], BooleanType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);

package/dist/generators/ts/DateTimeType.d.ts

@@ -1,8 +1,8 @@
 import { AbstractDateType } from "./AbstractDateType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateTimeType";
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/DateTimeType.js

@@ -1,11 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
-import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
-    graphqlType = new AbstractDateType.GraphqlType(code `${imports.GraphQLDateTime}`);
     kind = "DateTimeType";
+    get graphqlType() {
+        return new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
+    }
     jsonSchema(_parameters) {
-        return code `${imports.z}.iso.datetime()`;
+        return code `${this.reusables.imports.z}.iso.datetime()`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toISOString()`;
@@ -14,4 +22,7 @@ export class DateTimeType extends AbstractDateType {
         return code `${variables.value}.toDateTime(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
+__decorate([
+    Memoize()
+], DateTimeType.prototype, "graphqlType", null);
 //# sourceMappingURL=DateTimeType.js.map

package/dist/generators/ts/DateType.d.ts

@@ -2,8 +2,8 @@ import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "DateType";
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/DateType.js

@@ -1,12 +1,20 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
-import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
-    graphqlType = new DateTimeType.GraphqlType(code `${imports.GraphQLDate}`);
     kind = "DateType";
+    get graphqlType() {
+        return new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
+    }
     jsonSchema(_parameters) {
-        return code `${imports.z}.iso.date()`;
+        return code `${this.reusables.imports.z}.iso.date()`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toISOString().replace(/T.*$/, '')`;
@@ -15,4 +23,7 @@ export class DateType extends AbstractDateType {
         return code `${variables.value}.toDate(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
+__decorate([
+    Memoize()
+], DateType.prototype, "graphqlType", null);
 //# sourceMappingURL=DateType.js.map

package/dist/generators/ts/DefaultValueType.js

@@ -9,9 +9,6 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
@@ -54,13 +51,13 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.name;
     }
     get schemaType() {
-        return code `${snippets.DefaultValueSchema}`;
+        return code `${this.reusables.snippets.DefaultValueSchema}`;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+        return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -72,7 +69,7 @@ export class DefaultValueType extends AbstractContainerType {
         switch (this.itemType.kind) {
             case "BigDecimalType":
                 invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new ${imports.BigDecimal}(${literalOf(this.defaultValue.value)})`);
+                return Maybe.of(code `new ${this.reusables.imports.BigDecimal}(${literalOf(this.defaultValue.value)})`);
             case "BigIntType":
                 invariant(this.defaultValue.termType === "Literal");
                 return Maybe.of(code `${LiteralDecoder.decodeBigIntLiteral(this.defaultValue).unsafeCoerce()}n`);
@@ -114,7 +111,7 @@ export class DefaultValueType extends AbstractContainerType {
         }
     }
     get defaultValueTermExpression() {
-        return rdfjsTermExpression(this.defaultValue, { logger: this.logger });
+        return this.rdfjsTermExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
@@ -123,7 +120,7 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${imports.Resource}.Value(${{ dataFactory: imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
+                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
             },
         });
     }

package/dist/generators/ts/FloatType.d.ts

@@ -3,8 +3,8 @@ import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
     readonly kind = "FloatType";
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly typeofs: NonEmptyList<"number">;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
     protected literalOf(value: number): string;
 }