@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/ast/ObjectType.js

@@ -5,38 +5,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { PropertyPath } from "@rdfx/resource";
-import { NTriplesIdentifier } from "@rdfx/string";
-import genericToposort from "toposort";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { arrayEquals } from "./equals.js";
 import { Type } from "./Type.js";
 export class ObjectType extends AbstractType {
-    /**
-     * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #ancestorObjectTypes = [];
-    /**
-     * Immediate child ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #childObjectTypes = [];
-    /**
-     * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #descendantObjectTypes = [];
-    /**
-     * Immediate parent ObjectTypes of this Object types.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #parentObjectTypes = [];
     /**
      * Properties of this ObjectType.
      *
@@ -94,36 +68,12 @@ export class ObjectType extends AbstractType {
         this.toRdfTypes = toRdfTypes;
         this.tsImports = tsImports;
     }
-    get ancestorObjectTypes() {
-        return this.#ancestorObjectTypes;
-    }
-    get childObjectTypes() {
-        return this.#childObjectTypes;
-    }
-    get descendantObjectTypes() {
-        return this.#descendantObjectTypes;
-    }
-    get parentObjectTypes() {
-        return this.#parentObjectTypes;
-    }
     get properties() {
         return this.#properties;
     }
     get recursive() {
         return this.properties.some((property) => property.recursive);
     }
-    addAncestorObjectTypes(...ancestorObjectTypes) {
-        this.#ancestorObjectTypes.push(...ancestorObjectTypes);
-    }
-    addChildObjectTypes(...childObjectTypes) {
-        this.#childObjectTypes.push(...childObjectTypes);
-    }
-    addDescendantObjectTypes(...descendantObjectTypes) {
-        this.#descendantObjectTypes.push(...descendantObjectTypes);
-    }
-    addParentObjectTypes(...parentObjectTypes) {
-        this.#parentObjectTypes.push(...parentObjectTypes);
-    }
     addProperties(...properties) {
         this.#properties.push(...properties);
         for (const property of properties) {
@@ -150,10 +100,6 @@ export class ObjectType extends AbstractType {
             ...super.toJSON(),
             fromRdfType: this.fromRdfType.extract(),
             identifierType: this.identifierType.toJSON(),
-            parentObjectTypes: this.parentObjectTypes.length > 0
-                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
-                    parentObjectType.shapeIdentifier)
-                : undefined,
             synthetic: this.synthetic ? true : undefined,
             toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
         };
@@ -362,28 +308,4 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
     ], Property.prototype, "recursive", null);
     ObjectType.Property = Property;
 })(ObjectType || (ObjectType = {}));
-(function (ObjectType) {
-    function toposort(objectTypes) {
-        const objectTypesByShapeIdentifier = {};
-        const objectTypeGraphNodes = [];
-        const objectTypeGraphEdges = [];
-        for (const objectType of objectTypes) {
-            const objectTypeShapeIdentifier = NTriplesIdentifier.stringify(objectType.shapeIdentifier);
-            invariant(!objectTypesByShapeIdentifier[objectTypeShapeIdentifier]);
-            objectTypesByShapeIdentifier[objectTypeShapeIdentifier] = objectType;
-            objectTypeGraphNodes.push(objectTypeShapeIdentifier);
-            for (const parentAstObjectType of objectType.parentObjectTypes) {
-                objectTypeGraphEdges.push([
-                    objectTypeShapeIdentifier,
-                    NTriplesIdentifier.stringify(parentAstObjectType.shapeIdentifier),
-                ]);
-            }
-        }
-        return genericToposort
-            .array(objectTypeGraphNodes, objectTypeGraphEdges)
-            .map((objectTypeIdentifier) => objectTypesByShapeIdentifier[objectTypeIdentifier])
-            .reverse();
-    }
-    ObjectType.toposort = toposort;
-})(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map

package/dist/generators/AstJsonGenerator.js

@@ -1,9 +1,13 @@
 export class AstJsonGenerator {
     generate(ast) {
         return JSON.stringify({
-            objectTypes: ast.namedObjectTypes.map((objectType) => ({
-                ...objectType.toJSON(),
-                properties: objectType.properties.map((property) => property.toJSON()),
+            namedTypes: ast.namedTypes.map((namedType) => ({
+                ...namedType.toJSON(),
+                ...(namedType.kind === "Object"
+                    ? {
+                        properties: namedType.properties.map((property) => property.toJSON()),
+                    }
+                    : {}),
             })),
         }, undefined, 2);
     }

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -2,64 +2,67 @@ import { Maybe } from "purify-ts";
 export function transformAstToLabeledPropertyGraph(ast) {
     const nodes = [];
     const relationships = [];
-    for (const namedObjectType of ast.namedObjectTypes) {
-        const id = typeId(namedObjectType);
-        const properties = {
-            name: { type: "string", value: typeName(namedObjectType) },
-        };
-        for (const namedObjectTypeProperty of namedObjectType.properties) {
-            let itemType;
-            switch (namedObjectTypeProperty.type.kind) {
-                case "DefaultValue":
-                case "List":
-                case "Option":
-                case "Set":
-                    itemType = namedObjectTypeProperty.type.itemType;
-                    break;
-                case "LazyObject":
-                    itemType = namedObjectTypeProperty.type.resolveType;
-                    break;
-                case "LazyObjectOption":
-                case "LazyObjectSet":
-                    itemType = namedObjectTypeProperty.type.resolveType.itemType;
-                    break;
-                default:
-                    itemType = namedObjectTypeProperty.type;
-                    break;
-            }
-            switch (itemType.kind) {
-                case "Intersection":
-                case "Object":
-                case "Union":
-                    if (itemType.name.isJust()) {
-                        relationships.push({
-                            id: namedObjectTypeProperty.shapeIdentifier.toString(),
-                            label: Maybe.of(namedObjectTypeProperty.name),
-                            properties: {},
-                            sourceNodeId: id,
-                            targetNodeId: typeId(itemType),
-                        });
-                    }
-                    break;
-                default:
-                    properties[namedObjectTypeProperty.name] = {
-                        type: "string",
-                        value: namedObjectTypeProperty.toString(),
-                    };
+    for (const namedType of ast.namedTypes) {
+        if (namedType.kind === "Object") {
+            const namedObjectType = namedType;
+            const id = typeId(namedType);
+            const properties = {
+                name: { type: "string", value: typeName(namedType) },
+            };
+            for (const namedObjectTypeProperty of namedObjectType.properties) {
+                let itemType;
+                switch (namedObjectTypeProperty.type.kind) {
+                    case "DefaultValue":
+                    case "List":
+                    case "Option":
+                    case "Set":
+                        itemType = namedObjectTypeProperty.type.itemType;
+                        break;
+                    case "LazyObject":
+                        itemType = namedObjectTypeProperty.type.resolveType;
+                        break;
+                    case "LazyObjectOption":
+                    case "LazyObjectSet":
+                        itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                        break;
+                    default:
+                        itemType = namedObjectTypeProperty.type;
+                        break;
+                }
+                switch (itemType.kind) {
+                    case "Intersection":
+                    case "Object":
+                    case "Union":
+                        if (itemType.name.isJust()) {
+                            relationships.push({
+                                id: namedObjectTypeProperty.shapeIdentifier.toString(),
+                                label: Maybe.of(namedObjectTypeProperty.name),
+                                properties: {},
+                                sourceNodeId: id,
+                                targetNodeId: typeId(itemType),
+                            });
+                        }
+                        break;
+                    default:
+                        properties[namedObjectTypeProperty.name] = {
+                            type: "string",
+                            value: namedObjectTypeProperty.toString(),
+                        };
+                }
             }
+            nodes.push({
+                id,
+                label: typeName(namedObjectType),
+                properties: properties,
+            });
+        }
+        else if (namedType.kind === "Union") {
+            nodes.push({
+                id: typeId(namedType),
+                label: typeName(namedType),
+                properties: {},
+            });
         }
-        nodes.push({
-            id,
-            label: typeName(namedObjectType),
-            properties: properties,
-        });
-    }
-    for (const namedUnionType of ast.namedUnionTypes) {
-        nodes.push({
-            id: typeId(namedUnionType),
-            label: typeName(namedUnionType),
-            properties: {},
-        });
     }
     return {
         nodes,

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -1,21 +1,16 @@
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import type { AbstractType } from "./AbstractType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     protected readonly _mutable: boolean;
-    protected readonly minCount: bigint;
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly typeofs: "object"[];
-    constructor({ minCount, mutable, ...superParameters }: {
-        minCount: bigint;
+    constructor({ mutable, ...superParameters }: {
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
@@ -25,20 +20,18 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get mutable(): boolean;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
-    protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractCollectionType {
+    type ConversionFunction = AbstractContainerType.ConversionFunction;
     type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractContainerType.GraphqlType;
     const isItemType: typeof AbstractContainerType.isItemType;
     type ItemType = AbstractContainerType.ItemType;
-    const JsonType: typeof AbstractType.JsonType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractContainerType.JsonType;
 }
 //# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -5,46 +5,19 @@ 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 { AbstractContainerType } from "./AbstractContainerType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
 export class AbstractCollectionType extends AbstractContainerType {
     _mutable;
-    minCount;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    typeofs = ["object"];
-    constructor({ minCount, mutable, ...superParameters }) {
+    constructor({ mutable, ...superParameters }) {
         super(superParameters);
-        this.minCount = minCount;
-        invariant(this.minCount >= 0n);
         this._mutable = mutable;
-        if (mutable) {
-            invariant(this.minCount === 0n);
-        }
-    }
-    get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
-        const sourceTypes = [
-            {
-                expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
-                typeof: "object",
-            },
-        ];
-        if (this.minCount === 0n) {
-            sourceTypes.push({
-                expression: code `undefined`,
-                typeof: "undefined",
-            });
-        }
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToArray}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
-            sourceTypes,
-        });
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -59,7 +32,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${this.reusables.snippets.CollectionFilter}<${this.itemType.filterType}>`;
     }
     get graphqlType() {
-        return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.name})`, this.reusables);
+        return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.expression})`, this.reusables);
     }
     get hashFunction() {
         return code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction})`;
@@ -73,38 +46,9 @@ export class AbstractCollectionType extends AbstractContainerType {
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
     }
-    get schemaInitializers() {
-        let schemaInitializers = super.schemaInitializers;
-        if (this.minCount > 0n) {
-            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
-        }
-        return schemaInitializers;
-    }
-    fromJsonExpression({ variables, }) {
-        let expression = variables.value;
-        if (this.minCount === 0n) {
-            expression = code `(${expression} ?? [])`;
-        }
-        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        })})))`;
-    }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    jsonSchema(parameters) {
-        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
-        if (this.minCount > 0n) {
-            schema = code `${schema}.nonempty().min(${this.minCount})`;
-        }
-        else {
-            schema = code `${schema}.optional()`;
-        }
-        if (!this._mutable) {
-            schema = code `${schema}.readonly()`;
-        }
-        return schema;
-    }
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
@@ -112,9 +56,6 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
     }
 }
-__decorate([
-    Memoize()
-], AbstractCollectionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "equalsFunction", null);

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -36,7 +36,6 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
     get referencesObjectType(): boolean;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
     protected get itemValidationFunctionDefault(): Code;
     protected get schemaInitializers(): readonly Code[];

package/dist/generators/ts/AbstractContainerType.js

@@ -29,16 +29,13 @@ export class AbstractContainerType extends AbstractType {
     get referencesObjectType() {
         return this.itemType.referencesObjectType;
     }
-    get toRdfResourceValueTypes() {
-        return this.itemType.toRdfResourceValueTypes;
-    }
     get itemConversionFunctionDefault() {
         return {
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: [
                 {
                     expression: this.itemType.expression,
-                    typeof: this.itemType.typeofs[0],
+                    jsType: this.itemType.jsTypes[0],
                 },
             ],
         };

package/dist/generators/ts/AbstractDateType.d.ts

@@ -5,10 +5,13 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }];
     abstract readonly kind: "DateTime" | "Date";
     readonly mutable = false;
     readonly schemaType: Code;
-    readonly typeofs: "object"[];
     readonly valueSparqlWherePatternsFunction: Code;
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;

package/dist/generators/ts/AbstractDateType.js

@@ -12,9 +12,14 @@ export class AbstractDateType extends AbstractPrimitiveType {
     expression = code `Date`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
+    jsTypes = [
+        {
+            instanceof: "Date",
+            typeof: "object",
+        },
+    ];
     mutable = false;
     schemaType = code `${this.reusables.snippets.DateSchema}`;
-    typeofs = ["object"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;

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

@@ -3,6 +3,10 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     abstract readonly kind: "BlankNode" | "Identifier" | "Iri";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;

package/dist/generators/ts/AbstractIdentifierType.js

@@ -8,6 +8,9 @@ import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
     get graphqlType() {
         return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);

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

@@ -17,7 +17,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly referencesObjectType = true;
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
@@ -29,6 +28,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Code;
+    get jsTypes(): readonly AbstractType.JsType[];
     get recursive(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -16,7 +16,6 @@ export class AbstractLazyObjectType extends AbstractType {
     discriminantProperty = Maybe.empty();
     mutable = false;
     referencesObjectType = true;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
@@ -41,6 +40,15 @@ export class AbstractLazyObjectType extends AbstractType {
     get hashFunction() {
         return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
     }
+    get jsTypes() {
+        return [
+            {
+                className: this.runtimeClass.rawName,
+                instanceof: "class",
+                typeof: "object",
+            },
+        ];
+    }
     get recursive() {
         return this.partialType.recursive;
     }
@@ -125,6 +133,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "schemaType", null);

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -22,6 +22,7 @@ export declare namespace AbstractLiteralType {
     type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;
+    type JsType = AbstractTermType.JsType;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractTermType.JsonType;
 }

package/dist/generators/ts/AbstractNumericType.js

@@ -13,27 +13,27 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractNumericType extends AbstractPrimitiveType {
     hashFunction = code `${this.reusables.snippets.hashNumeric}`;
     get filterFunction() {
-        return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.filterNumeric}<${this.jsTypes[0].typeof}>`;
     }
     get filterType() {
-        return code `${this.reusables.snippets.NumericFilter}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.NumericFilter}<${this.jsTypes[0].typeof}>`;
     }
     get expression() {
         if (this.primitiveIn.length > 0) {
             return code `${joinCode(this.primitiveIn.map((value) => this.literalExpression(value)), { on: " | " })}`;
         }
-        return code `${this.typeofs[0]}`;
+        return code `${this.jsTypes[0].typeof}`;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.NumericSchema}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.NumericSchema}<${this.jsTypes[0].typeof}>`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
+        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.jsTypes[0].typeof}>`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${this.reusables.imports.z}.${this.typeofs[0]}()`;
+                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
             case 1:
                 return code `${this.reusables.imports.z}.literal(${this.literalExpression(this.primitiveIn[0])})`;
             default:
@@ -41,7 +41,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.reusables.snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
+        return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
     fromRdfResourceValuesExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -23,6 +23,7 @@ export declare abstract class AbstractPrimitiveType<ValueT extends bigint | bool
 export declare namespace AbstractPrimitiveType {
     type ConversionFunction = AbstractLiteralType.ConversionFunction;
     type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
+    type JsType = AbstractLiteralType.JsType;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;

package/dist/generators/ts/AbstractTermType.d.ts

@@ -3,7 +3,6 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { Type } from "./Type.js";
-import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
@@ -24,7 +23,6 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
     readonly referencesObjectType = false;
-    readonly typeofs: readonly Typeof[];
     readonly validationFunction: Maybe<Code>;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
@@ -60,6 +58,7 @@ export declare namespace AbstractTermType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
+    type JsType = AbstractType.JsType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;
 }

package/dist/generators/ts/AbstractTermType.js

@@ -27,7 +27,6 @@ export class AbstractTermType extends AbstractType {
     mutable = false;
     recursive = false;
     referencesObjectType = false;
-    typeofs = ["object"];
     validationFunction = Maybe.empty();
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
@@ -39,10 +38,9 @@ export class AbstractTermType extends AbstractType {
     }
     get discriminantProperty() {
         return Maybe.of({
-            descendantValues: [],
             jsonName: "termType",
             name: "termType",
-            ownValues: [...this.nodeKinds].map(NodeKind.toTermType),
+            values: [...this.nodeKinds].map(NodeKind.toTermType),
             type: "string",
         });
     }