@shaclmate/compiler 4.0.39 → 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,44 +1,37 @@
 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;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
-    get name(): Code;
     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,58 +5,34 @@ 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 = [
-            {
-                name: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.name}`), { on: " | " })})[]`,
-                typeof: "object",
-            },
-        ];
-        if (this.minCount === 0n) {
-            sourceTypes.push({
-                name: "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}))`;
     }
+    get expression() {
+        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;
+    }
     get filterFunction() {
-        return code `${this.reusables.snippets.filterArray}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+        return code `${this.reusables.snippets.filterArray}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
     get filterType() {
         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})`;
@@ -64,47 +40,15 @@ export class AbstractCollectionType extends AbstractContainerType {
     get mutable() {
         return this._mutable || this.itemType.mutable;
     }
-    get name() {
-        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.name})[]`;
-    }
     get schemaType() {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
     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.name}>(${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);
     }
@@ -114,10 +58,10 @@ export class AbstractCollectionType extends AbstractContainerType {
 }
 __decorate([
     Memoize()
-], AbstractCollectionType.prototype, "conversionFunction", null);
+], AbstractCollectionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], AbstractCollectionType.prototype, "equalsFunction", null);
+], AbstractCollectionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "filterFunction", null);
@@ -130,9 +74,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], AbstractCollectionType.prototype, "name", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "schemaType", null);

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

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.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";
@@ -13,13 +12,13 @@ import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
 import type { ListType } from "./ListType.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";
 /**
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
@@ -37,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[];
@@ -47,7 +45,7 @@ export declare namespace AbstractContainerType {
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | 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;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;

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: [
                 {
-                    name: this.itemType.name,
-                    typeof: this.itemType.typeofs[0],
+                    expression: this.itemType.expression,
+                    jsType: this.itemType.jsTypes[0],
                 },
             ],
         };
@@ -67,7 +64,6 @@ __decorate([
     AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
     function isItemType(type) {
         switch (type.kind) {
-            case "AnonymousUnion":
             case "BigDecimal":
             case "BigInt":
             case "BlankNode":
@@ -80,11 +76,11 @@ __decorate([
             case "Iri":
             case "List":
             case "Literal":
-            case "NamedObjectUnion":
-            case "NamedUnion":
-            case "NamedObjectType":
+            case "Object":
+            case "ObjectUnion":
             case "String":
             case "Term":
+            case "Union":
                 return true;
             case "DefaultValue":
             case "LazyObjectOption":

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

@@ -2,23 +2,26 @@ import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
     readonly equalsFunction: Code;
+    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 name = "Date";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    readonly typeofs: "object"[];
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
     protected abstract fromRdfResourceValueExpression(variables: {
         variables: {
             value: Code;
         };
     }): Code;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
 }
 export declare namespace AbstractDateType {
     type ConversionFunction = AbstractPrimitiveType.ConversionFunction;

package/dist/generators/ts/AbstractDateType.js

@@ -9,13 +9,18 @@ import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
+    expression = code `Date`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
+    jsTypes = [
+        {
+            instanceof: "Date",
+            typeof: "object",
+        },
+    ];
     mutable = false;
-    name = "Date";
     schemaType = code `${this.reusables.snippets.DateSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
-    typeofs = ["object"];
     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);