@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/generators/ts/AbstractType.d.ts

@@ -3,7 +3,6 @@ import type { Logger } from "ts-log";
 import type { Reusables } from "./Reusables.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import type { TsGenerator } from "./TsGenerator.js";
-import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
@@ -70,6 +69,10 @@ export declare abstract class AbstractType {
      * A function (reference or declaration) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
      */
     abstract readonly hashFunction: Code;
+    /**
+     * JavaScript type(s) the type.
+     */
+    abstract readonly jsTypes: readonly AbstractType.JsType[];
     /**
      * Type discriminant.
      */
@@ -98,10 +101,6 @@ export declare abstract class AbstractType {
      * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
      */
     abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
-    /**
-     * JavaScript typeof(s) the type.
-     */
-    abstract readonly typeofs: readonly Typeof[];
     /**
      * Function that takes
      * - a schema of this.schemaType
@@ -277,14 +276,13 @@ export declare namespace AbstractType {
         readonly code: Code;
         readonly sourceTypes: {
             readonly expression: Code;
-            readonly typeof: Typeof;
+            readonly jsType: JsType;
         }[];
     }
     interface DiscriminantProperty {
-        readonly descendantValues: readonly DiscriminantProperty.Value[];
         readonly jsonName: string;
         readonly name: string;
-        readonly ownValues: readonly DiscriminantProperty.Value[];
+        readonly values: readonly DiscriminantProperty.Value[];
     }
     namespace DiscriminantProperty {
         type Value = number | string;
@@ -295,14 +293,46 @@ export declare namespace AbstractType {
          */
         readonly nullable: boolean;
         /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
-        readonly nullableName: Code;
+        readonly nullableExpression: Code;
         private readonly reusables;
-        constructor(nullableName: Code, reusables: Reusables, options?: {
+        constructor(nullableExpression: Code, reusables: Reusables, options?: {
             nullable: boolean;
         });
-        get name(): Code;
+        get expression(): Code;
+    }
+    type JsType = {
+        typeof: "bigint";
+    } | {
+        typeof: "boolean";
+    } | {
+        typeof: "function";
+    } | {
+        typeof: "number";
+    } | {
+        instanceof: "Array";
+        typeof: "object";
+    } | {
+        className: Code;
+        instanceof: "class";
+        typeof: "object";
+    } | {
+        instanceof: "Date";
+        typeof: "object";
+    } | {
+        instanceof: "Maybe";
+        typeof: "object";
+    } | {
+        instanceof: "Object";
+        typeof: "object";
+    } | {
+        typeof: "string";
+    } | {
+        typeof: "undefined";
+    };
+    namespace JsType {
+        function equals(left: JsType, right: JsType): boolean;
     }
     class JsonType {
         /**
@@ -310,13 +340,13 @@ export declare namespace AbstractType {
          */
         readonly optional: boolean;
         /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
          */
-        readonly requiredName: Code | string;
-        constructor(requiredName: Code | string, parameters?: {
+        readonly requiredExpression: Code;
+        constructor(requiredExpression: Code, parameters?: {
             optional: boolean;
         });
-        get name(): Code | string;
+        get expression(): Code;
     }
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/generators/ts/AbstractType.js

@@ -63,47 +63,62 @@ __decorate([
          */
         nullable;
         /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
-        nullableName;
+        nullableExpression;
         reusables;
-        constructor(nullableName, reusables, options) {
+        constructor(nullableExpression, reusables, options) {
             this.nullable = !!options?.nullable;
-            this.nullableName = nullableName;
+            this.nullableExpression = nullableExpression;
             this.reusables = reusables;
         }
-        get name() {
+        get expression() {
             return this.nullable
-                ? this.nullableName
-                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableName})`;
+                ? this.nullableExpression
+                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableExpression})`;
         }
     }
     __decorate([
         Memoize()
-    ], GraphqlType.prototype, "name", null);
+    ], GraphqlType.prototype, "expression", null);
     AbstractType.GraphqlType = GraphqlType;
+    let JsType;
+    (function (JsType) {
+        function equals(left, right) {
+            if (left.typeof !== right.typeof) {
+                return false;
+            }
+            if (left.typeof === "object" &&
+                right.typeof === "object" &&
+                left.instanceof !== right.instanceof) {
+                return false;
+            }
+            return true;
+        }
+        JsType.equals = equals;
+    })(JsType = AbstractType.JsType || (AbstractType.JsType = {}));
     class JsonType {
         /**
          * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
          */
         optional;
         /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
          */
-        requiredName;
-        constructor(requiredName, parameters) {
+        requiredExpression;
+        constructor(requiredExpression, parameters) {
             this.optional = !!parameters?.optional;
-            this.requiredName = requiredName;
+            this.requiredExpression = requiredExpression;
         }
-        get name() {
+        get expression() {
             return this.optional
-                ? code `(${this.requiredName}) | undefined`
-                : this.requiredName;
+                ? code `(${this.requiredExpression}) | undefined`
+                : this.requiredExpression;
         }
     }
     __decorate([
         Memoize()
-    ], JsonType.prototype, "name", null);
+    ], JsonType.prototype, "expression", null);
     AbstractType.JsonType = JsonType;
 })(AbstractType || (AbstractType = {}));
 //# sourceMappingURL=AbstractType.js.map

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

@@ -8,6 +8,10 @@ export declare class BigDecimalType extends AbstractLiteralType {
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/BigDecimalType.js

@@ -14,6 +14,9 @@ export class BigDecimalType extends AbstractLiteralType {
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
@@ -30,7 +33,7 @@ export class BigDecimalType extends AbstractLiteralType {
         return code `${this.reusables.imports.z}.string()`;
     }
     jsonType() {
-        return new AbstractLiteralType.JsonType("string");
+        return new AbstractLiteralType.JsonType(code `string`);
     }
     literalExpression(literal) {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;

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

@@ -2,8 +2,10 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
+    readonly jsTypes: {
+        readonly typeof: "bigint";
+    }[];
     readonly kind = "BigInt";
-    readonly typeofs: "bigint"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/BigIntType.js

@@ -9,8 +9,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "bigint" }];
     kind = "BigInt";
-    typeofs = ["bigint"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
     }

package/dist/generators/ts/BlankNodeType.d.ts

@@ -3,8 +3,8 @@ import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
-    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly expression: Code;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly kind = "BlankNode";

package/dist/generators/ts/BlankNodeType.js

@@ -9,20 +9,20 @@ import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
+    expression = code `${this.reusables.imports.BlankNode}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToBlankNode}`,
         sourceTypes: [
             {
                 expression: code `${this.reusables.imports.BlankNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             },
         ],
     });
-    expression = code `${this.reusables.imports.BlankNode}`;
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
     kind = "BlankNode";

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

@@ -6,8 +6,10 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "boolean";
+    }];
     readonly kind = "Boolean";
-    readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
     get expression(): Code;
     get schemaType(): Code;

package/dist/generators/ts/BooleanType.js

@@ -13,8 +13,8 @@ export class BooleanType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashBoolean}`;
+    jsTypes = [{ typeof: "boolean" }];
     kind = "Boolean";
-    typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
     get expression() {
         if (this.primitiveIn.length > 0) {

package/dist/generators/ts/DefaultValueType.d.ts

@@ -10,7 +10,44 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "DefaultValue";
-    readonly typeofs: "object"[];
+    readonly jsTypes: readonly AbstractType.JsType[] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | {
+        readonly typeof: "bigint";
+    }[] | readonly [{
+        readonly typeof: "boolean";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "string";
+    }] | readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
@@ -24,6 +61,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get hashFunction(): Code;
     get mutable(): boolean;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): Code[];

package/dist/generators/ts/DefaultValueType.js

@@ -14,7 +14,7 @@ export class DefaultValueType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "DefaultValue";
-    typeofs = ["object"];
+    jsTypes = this.itemType.jsTypes;
     validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
@@ -25,10 +25,10 @@ export class DefaultValueType extends AbstractContainerType {
         return Maybe.of({
             code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code}, ${this.defaultValueExpression})`,
             sourceTypes: itemConversionFunction.sourceTypes
-                .filter((sourceType) => sourceType.typeof !== "undefined")
+                .filter((sourceType) => sourceType.jsType.typeof !== "undefined")
                 .concat({
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             }),
         });
     }
@@ -56,6 +56,9 @@ export class DefaultValueType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.expression}, ${this.itemType.schemaType}>`;
     }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
     }

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

@@ -2,8 +2,10 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
+    readonly jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
     readonly kind = "Float";
-    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/FloatType.js

@@ -9,8 +9,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
     kind = "Float";
-    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     }

package/dist/generators/ts/GraphqlSchema.js

@@ -32,7 +32,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
     (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
       liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
     )).unsafeCoerce()`,
-                type: namedObjectType.graphqlType.name,
+                type: namedObjectType.graphqlType.expression,
             };
             fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
                 args: {
@@ -73,7 +73,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
     }
     return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
   })).unsafeCoerce()`,
-                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.name}))`,
+                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.expression}))`,
             };
             fields[namedObjectType.objectSetMethodNames.objectCount] = {
                 resolve: code `\

package/dist/generators/ts/IdentifierType.d.ts

@@ -4,8 +4,8 @@ import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
-    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly expression: Code;
+    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly kind = "Identifier";

package/dist/generators/ts/IdentifierType.js

@@ -10,28 +10,30 @@ import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
+    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToIdentifier}`,
         sourceTypes: [
             {
                 expression: code `${this.reusables.imports.BlankNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
                 expression: code `${this.reusables.imports.NamedNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
+                // To NamedNode
                 expression: code `string`,
-                typeof: "string",
+                jsType: { typeof: "string" },
             },
             {
+                // To BlankNode
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             },
         ],
     });
-    expression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
     kind = "Identifier";

package/dist/generators/ts/IntType.d.ts

@@ -2,8 +2,10 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
+    readonly jsTypes: readonly [{
+        readonly typeof: "number";
+    }];
     readonly kind = "Int";
-    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;

package/dist/generators/ts/IntType.js

@@ -9,8 +9,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "number" }];
     kind = "Int";
-    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
     }

package/dist/generators/ts/IriType.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
@@ -16,16 +17,17 @@ export class IriType extends AbstractIdentifierType {
     schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
     get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
             sourceTypes: [
                 {
                     expression: this.valueTypeExpression,
-                    typeof: "string",
+                    jsType: { typeof: "string" },
                 },
                 {
                     expression: this.expression,
-                    typeof: "object",
+                    jsType: this.jsTypes[0],
                 },
             ],
         });

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -16,6 +16,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 }) => AbstractLazyObjectType<OptionType<AbstractLazyObjectType.ObjectTypeConstraint>, OptionType<AbstractLazyObjectType.ObjectTypeConstraint>>) & {
     readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    JsType: typeof import("./AbstractType.js").AbstractType.JsType;
 };
 export declare class LazyObjectOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];

package/dist/generators/ts/LazyObjectOptionType.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -13,24 +14,27 @@ export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectOption";
     get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
+        invariant(this.resolveType.itemType.jsTypes.length === 1);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
                     expression: this.expression,
-                    typeof: "object",
+                    jsType: this.jsTypes[0],
                 },
                 {
                     expression: this.resolveType.expression,
-                    typeof: "object",
+                    jsType: this.resolveType.jsTypes[0],
                 },
                 {
                     expression: this.resolveType.itemType.expression,
-                    typeof: "object",
+                    jsType: this.resolveType.itemType.jsTypes[0],
                 },
                 {
                     expression: code `undefined`,
-                    typeof: "undefined",
+                    jsType: { typeof: "undefined" },
                 },
             ],
         });

package/dist/generators/ts/LazyObjectSetType.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -19,20 +20,22 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
     });
     kind = "LazyObjectSet";
     get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
             sourceTypes: [
                 {
                     expression: this.expression,
-                    typeof: "object",
+                    jsType: this.jsTypes[0],
                 },
                 {
                     expression: this.resolveType.expression,
-                    typeof: "object",
+                    jsType: this.resolveType.jsTypes[0],
                 },
                 {
                     expression: code `undefined`,
-                    typeof: "undefined",
+                    jsType: { typeof: "undefined" },
                 },
             ],
         });
@@ -58,4 +61,7 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
 __decorate([
     Memoize()
 ], LazyObjectSetType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], LazyObjectSetType.prototype, "runtimeClass", null);
 //# sourceMappingURL=LazyObjectSetType.js.map