@shaclmate/compiler 4.0.39 → 4.0.41

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

@@ -10,10 +10,10 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get name(): Code;
-    private get valueTypeName();
+    get expression(): Code;
     get parseFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
+    private get valueTypeExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;

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";
@@ -13,37 +14,33 @@ export class IriType extends AbstractIdentifierType {
     filterType = code `${this.reusables.snippets.IriFilter}`;
     kind = "Iri";
     nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeName}>`;
+    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.valueTypeName}>`,
+            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
             sourceTypes: [
                 {
-                    name: this.valueTypeName,
-                    typeof: "string",
+                    expression: this.valueTypeExpression,
+                    jsType: { typeof: "string" },
                 },
                 {
-                    name: this.name,
-                    typeof: "object",
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
                 },
             ],
         });
     }
-    get name() {
+    get expression() {
         if (this.in_.length > 0) {
-            return code `${this.reusables.imports.NamedNode}<${this.valueTypeName}>`;
+            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
-    get valueTypeName() {
-        return this.in_.length > 0
-            ? `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
-            : "string";
-    }
     get parseFunction() {
         if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
         }
         return code `${this.reusables.snippets.parseIri}`;
     }
@@ -54,8 +51,13 @@ export class IriType extends AbstractIdentifierType {
         }
         return initializers;
     }
+    get valueTypeExpression() {
+        return this.in_.length > 0
+            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
+            : code `string`;
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
@@ -76,7 +78,7 @@ export class IriType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "NamedNode"`
             : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeName}${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
@@ -98,13 +100,13 @@ __decorate([
 ], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "name", null);
+], IriType.prototype, "expression", null);
 __decorate([
     Memoize()
-], IriType.prototype, "valueTypeName", null);
+], IriType.prototype, "parseFunction", null);
 __decorate([
     Memoize()
-], IriType.prototype, "parseFunction", null);
+], IriType.prototype, "valueTypeExpression", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "jsonType", null);

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

@@ -7,6 +7,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     partialType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
     resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
 } & {
+    alias: Maybe<string>;
     comment: Maybe<string>;
     configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;
@@ -15,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,31 +14,34 @@ 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.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            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: [
                 {
-                    name: this.name,
-                    typeof: "object",
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
                 },
                 {
-                    name: this.resolveType.name,
-                    typeof: "object",
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
                 },
                 {
-                    name: this.resolveType.itemType.name,
-                    typeof: "object",
+                    expression: this.resolveType.itemType.expression,
+                    jsType: this.resolveType.itemType.jsTypes[0],
                 },
                 {
-                    name: "undefined",
-                    typeof: "undefined",
+                    expression: code `undefined`,
+                    jsType: { typeof: "undefined" },
                 },
             ],
         });
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObjectOption}`,
         };

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,27 +20,29 @@ 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.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            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: [
                 {
-                    name: this.name,
-                    typeof: "object",
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
                 },
                 {
-                    name: this.resolveType.name,
-                    typeof: "object",
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
                 },
                 {
-                    name: "undefined",
-                    typeof: "undefined",
+                    expression: code `undefined`,
+                    jsType: { typeof: "undefined" },
                 },
             ],
         });
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>`,
+            name: code `${this.reusables.snippets.LazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
             partialPropertyName: "partials",
             rawName: code `${this.reusables.snippets.LazyObjectSet}`,
         };
@@ -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

package/dist/generators/ts/LazyObjectType.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";
@@ -12,23 +13,25 @@ export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObject";
     get conversionFunction() {
+        invariant(this.jsTypes.length === 1);
+        invariant(this.resolveType.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
             sourceTypes: [
                 {
-                    name: this.name,
-                    typeof: "object",
+                    expression: this.expression,
+                    jsType: this.jsTypes[0],
                 },
                 {
-                    name: this.resolveType.name,
-                    typeof: "object",
+                    expression: this.resolveType.expression,
+                    jsType: this.resolveType.jsTypes[0],
                 },
             ],
         });
     }
     get runtimeClass() {
         return {
-            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>`,
+            name: code `${this.reusables.snippets.LazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.expression}, ${this.resolveType.expression}>`,
             partialPropertyName: "partial",
             rawName: code `${this.reusables.snippets.LazyObject}`,
         };

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -12,30 +12,38 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { NamedObjectType } from "./NamedObjectType.js";
-import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
-import type { NamedUnionType } from "./NamedUnionType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
     readonly kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractCollectionType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -5,24 +5,48 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
     kind = "List";
     constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
         this.toRdfTypes = toRdfTypes;
     }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToList}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes: [
+                {
+                    expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+                    jsType: { instanceof: "Array", typeof: "object" },
+                },
+            ],
+        });
+    }
+    get toRdfResourceValueTypes() {
+        return new Set(["BlankNode", "NamedNode"]); // List or rdf:nil
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${variables.value}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
     fromRdfResourceValuesExpression({ variables, }) {
         return joinCode([
             variables.resourceValues,
@@ -39,22 +63,29 @@ export class ListType extends AbstractCollectionType {
             code `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
         ], { on: "." });
     }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
+    }
     jsonType() {
-        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
+        return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         let mintListIdentifierFunction;
         let mintSubListIdentifierFunction;
-        let resourceTypeName;
+        let resourceTypeExpression;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
                 mintListIdentifierFunction =
                     mintSubListIdentifierFunction = code `(() => ${this.reusables.imports.dataFactory}.blankNode())`;
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                resourceTypeName = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
+                resourceTypeExpression = code `${this.reusables.imports.Resource}<${this.reusables.imports.NamedNode}>`;
                 throw new RangeError("list IRI minting is unsupported");
             }
         }
@@ -81,8 +112,8 @@ export class ListType extends AbstractCollectionType {
     currentSubListResource: null,
     listResource: ${variables.resourceSet}.resource(${mintListIdentifierFunction}()),
   } as {
-    currentSubListResource: ${resourceTypeName} | null;
-    listResource: ${resourceTypeName};
+    currentSubListResource: ${resourceTypeExpression} | null;
+    listResource: ${resourceTypeExpression};
   },
 ).listResource.identifier : ${this.rdfjsTermExpression(rdf.nil)}]`;
     }
@@ -90,6 +121,12 @@ export class ListType extends AbstractCollectionType {
         return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
     }
 }
+__decorate([
+    Memoize()
+], ListType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], ListType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], ListType.prototype, "valueSparqlConstructTriplesFunction", null);
@@ -102,7 +139,6 @@ __decorate([
 (function (ListType) {
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnion":
             case "BigDecimal":
             case "BigInt":
             case "BlankNode":
@@ -113,18 +149,18 @@ __decorate([
             case "Identifier":
             case "Iri":
             case "Int":
+            case "List":
             case "Literal":
-            case "NamedObjectUnion":
-            case "NamedUnion":
-            case "NamedObjectType":
+            case "ObjectUnion":
+            case "Object":
             case "String":
             case "Term":
+            case "Union":
                 return true;
             case "DefaultValue":
             case "LazyObjectOption":
             case "LazyObjectSet":
             case "LazyObject":
-            case "List":
             case "Option":
             case "Set":
                 return false;

package/dist/generators/ts/LiteralType.d.ts

@@ -3,10 +3,14 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
-    readonly name: Code;
+    readonly expression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Literal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;

package/dist/generators/ts/LiteralType.js

@@ -3,26 +3,29 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
-    name = code `${this.reusables.imports.Literal}`;
+    expression = code `${this.reusables.imports.Literal}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToLiteral}`,
         sourceTypes: [
             ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
-                name: typeof_,
-                typeof: typeof_,
+                expression: code `${typeof_}`,
+                jsType: { typeof: typeof_ },
             })),
             {
-                name: "Date",
-                typeof: "object",
+                expression: code `Date`,
+                jsType: { instanceof: "Date", typeof: "object" },
             },
             {
-                name: code `${this.reusables.imports.Literal}`,
-                typeof: "object",
+                expression: code `${this.reusables.imports.Literal}`,
+                jsType: { instanceof: "Object", typeof: "object" },
             },
         ],
     });
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Literal";
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
@@ -37,7 +40,7 @@ export class LiteralType extends AbstractLiteralType {
         return initializers;
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined)))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");

package/dist/generators/ts/{NamedObjectType.d.ts → ObjectType.d.ts}

@@ -1,56 +1,47 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_NamedObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import type { Property as _Property } from "./_ObjectType/Property.js";
+import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class NamedObjectType extends AbstractType {
+export declare class ObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
+    readonly discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
-    readonly kind = "NamedObjectType";
-    readonly name: string;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
+    readonly kind = "Object";
     readonly recursive: boolean;
     readonly referencesObjectType = true;
     readonly synthetic: boolean;
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
-    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ discriminantProperty, extern, fromRdfType, identifierType, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }: {
+        discriminantProperty: Maybe<ObjectType.DiscriminantProperty>;
         comment: Maybe<string>;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly NamedObjectType[];
-        lazyChildObjectTypes: () => readonly NamedObjectType[];
-        lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
-        lazyDescendantObjectTypes: () => readonly NamedObjectType[];
-        lazyParentObjectTypes: () => readonly NamedObjectType[];
-        lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
-        name: string;
+        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
         recursive: boolean;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
-    get ancestorObjectTypes(): readonly NamedObjectType[];
-    get childObjectTypes(): readonly NamedObjectType[];
     get declaration(): Maybe<Code>;
-    get descendantFromRdfTypeVariables(): readonly Code[];
-    get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly NamedObjectType[];
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get discriminantValue(): string;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
@@ -58,9 +49,8 @@ export declare class NamedObjectType extends AbstractType {
     get hashFunction(): Code;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
-    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get parentObjectTypes(): readonly NamedObjectType[];
-    get properties(): readonly NamedObjectType.Property[];
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get properties(): readonly ObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
@@ -81,14 +71,9 @@ export declare class NamedObjectType extends AbstractType {
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyChildObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyDiscriminantProperty;
-    private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
-export declare namespace NamedObjectType {
+export declare namespace ObjectType {
     const IdentifierProperty: typeof _IdentifierProperty;
     type IdentifierProperty = _IdentifierProperty;
     type ObjectSetMethodNames = {
@@ -103,4 +88,4 @@ export declare namespace NamedObjectType {
     const DiscriminantProperty: typeof _DiscriminantProperty;
     type DiscriminantProperty = _DiscriminantProperty;
 }
-//# sourceMappingURL=NamedObjectType.d.ts.map
+//# sourceMappingURL=ObjectType.d.ts.map