@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/Cx2Generator.js

@@ -0,0 +1,140 @@
+import { transformAstToLabeledPropertyGraph } from "./transformAstToLabeledPropertyGraph.js";
+export class Cx2Generator {
+    visualProperties;
+    constructor(options) {
+        this.visualProperties = options?.visualProperties;
+    }
+    generate(ast) {
+        const labeledPropertyGraph = transformAstToLabeledPropertyGraph(ast);
+        const edgeAttributeDeclarations = {
+            interaction: { d: "string" },
+        };
+        const edgeIdMap = {};
+        const edges = [];
+        const nodeAttributeDeclarations = {
+            name: { d: "string" },
+        };
+        const nodeIdMap = {};
+        const nodes = [];
+        function attributeDeclaration(lpgPropertyValue) {
+            switch (lpgPropertyValue.type) {
+                case "boolean":
+                case "double":
+                case "integer":
+                case "long":
+                case "string":
+                    return { d: lpgPropertyValue.type };
+                case "boolean[]":
+                case "double[]":
+                case "integer[]":
+                case "long[]":
+                case "string[]":
+                    return {
+                        d: `list_of_${lpgPropertyValue.type.substring(0, lpgPropertyValue.type.length - 2)}`,
+                    };
+            }
+        }
+        for (const lpgNode of labeledPropertyGraph.nodes) {
+            let id = nodeIdMap[lpgNode.id];
+            if (id === undefined) {
+                id = Object.keys(nodeIdMap).length + 1;
+                nodeIdMap[lpgNode.id] = id;
+            }
+            const v = {
+                name: lpgNode.label,
+            };
+            for (const [lpgNodePropertyName, lpgNodePropertyValue] of Object.entries(lpgNode.properties)) {
+                if (lpgNodePropertyName === "name") {
+                    continue;
+                }
+                if (!nodeAttributeDeclarations[lpgNodePropertyName]) {
+                    nodeAttributeDeclarations[lpgNodePropertyName] =
+                        attributeDeclaration(lpgNodePropertyValue);
+                }
+                v[lpgNodePropertyName] = lpgNodePropertyValue.value;
+            }
+            nodes.push({
+                id,
+                v,
+            });
+        }
+        for (const lpgRelationship of labeledPropertyGraph.relationships) {
+            let id = edgeIdMap[lpgRelationship.id];
+            if (id === undefined) {
+                id = Object.keys(edgeIdMap).length + 1;
+                edgeIdMap[lpgRelationship.id] = id;
+            }
+            edges.push({
+                id,
+                s: nodeIdMap[lpgRelationship.sourceNodeId],
+                t: nodeIdMap[lpgRelationship.targetNodeId],
+                v: lpgRelationship.label
+                    .map((label) => ({ interaction: label }))
+                    .orDefault({}),
+            });
+        }
+        let visualProperties = this.visualProperties ?? {};
+        visualProperties = {
+            ...visualProperties,
+            default: {
+                edge: {
+                    ...visualProperties?.default?.edge,
+                    EDGE_LABEL: "interaction",
+                },
+            },
+            edgeMapping: {
+                ...visualProperties?.edgeMapping,
+                EDGE_LABEL: {
+                    type: "PASSTHROUGH",
+                    definition: {
+                        attribute: "interaction",
+                        type: "string",
+                    },
+                },
+            },
+        };
+        return JSON.stringify([
+            {
+                CXVersion: "2.0",
+                hasFragments: false,
+            },
+            {
+                metaData: [
+                    {
+                        elementCount: edges.length,
+                        name: "edges",
+                    },
+                    {
+                        elementCount: nodes.length,
+                        name: "nodes",
+                    },
+                ],
+            },
+            {
+                attributeDeclarations: [
+                    {
+                        edges: edgeAttributeDeclarations,
+                        nodes: nodeAttributeDeclarations,
+                    },
+                ],
+            },
+            {
+                nodes,
+            },
+            {
+                edges,
+            },
+            {
+                visualProperties: [visualProperties],
+            },
+            {
+                status: [
+                    {
+                        success: true,
+                    },
+                ],
+            },
+        ], undefined, 2);
+    }
+}
+//# sourceMappingURL=Cx2Generator.js.map

package/dist/generators/Generator.d.ts

@@ -0,0 +1,5 @@
+import type { Ast } from "../ast/Ast.js";
+export interface Generator {
+    generate(ast: Ast): string;
+}
+//# sourceMappingURL=Generator.d.ts.map

package/dist/generators/Generator.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Generator.js.map

package/dist/generators/LabeledPropertyGraph.d.ts

@@ -0,0 +1,42 @@
+import type { Maybe } from "purify-ts";
+export interface LabeledPropertyGraph {
+    readonly nodes: readonly LabeledPropertyGraph.Node[];
+    readonly relationships: readonly LabeledPropertyGraph.Relationship[];
+}
+export declare namespace LabeledPropertyGraph {
+    export type Id = string;
+    export interface Node {
+        readonly id: Id;
+        readonly label: string;
+        readonly properties: Record<PropertyName, PropertyValue>;
+    }
+    export type PropertyName = string;
+    type PropertyTypeValueMap = {
+        boolean: boolean;
+        "boolean[]": readonly boolean[];
+        double: number;
+        "double[]": readonly number[];
+        integer: bigint;
+        "integer[]": readonly bigint[];
+        long: bigint;
+        "long[]": readonly bigint[];
+        string: string;
+        "string[]": readonly string[];
+    };
+    export type PropertyType = keyof PropertyTypeValueMap;
+    export type PropertyValue = {
+        [K in PropertyType]: {
+            type: K;
+            value: PropertyTypeValueMap[K];
+        };
+    }[PropertyType];
+    export interface Relationship {
+        readonly id: Id;
+        readonly label: Maybe<string>;
+        readonly properties: Record<PropertyName, PropertyValue>;
+        readonly sourceNodeId: Id;
+        readonly targetNodeId: Id;
+    }
+    export {};
+}
+//# sourceMappingURL=LabeledPropertyGraph.d.ts.map

package/dist/generators/LabeledPropertyGraph.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LabeledPropertyGraph.js.map

package/dist/generators/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
+export * from "./Generator.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/index.js

@@ -0,0 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
+export * from "./Generator.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
+//# sourceMappingURL=index.js.map

package/dist/generators/transformAstToLabeledPropertyGraph.d.ts

@@ -0,0 +1,4 @@
+import type * as ast from "../ast/index.js";
+import type { LabeledPropertyGraph } from "./LabeledPropertyGraph.js";
+export declare function transformAstToLabeledPropertyGraph(ast: ast.Ast): LabeledPropertyGraph;
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.d.ts.map

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -0,0 +1,78 @@
+import { Maybe } from "purify-ts";
+export function transformAstToLabeledPropertyGraph(ast) {
+    const nodes = [];
+    const relationships = [];
+    for (const namedType of ast.namedTypes) {
+        if (namedType.kind === "Struct") {
+            const namedStructType = namedType;
+            const id = typeId(namedType);
+            const properties = {
+                name: { type: "string", value: typeName(namedType) },
+            };
+            for (const namedObjectTypeProperty of namedStructType.fields) {
+                let itemType;
+                switch (namedObjectTypeProperty.type.kind) {
+                    case "DefaultValue":
+                    case "List":
+                    case "Option":
+                    case "Set":
+                        itemType = namedObjectTypeProperty.type.itemType;
+                        break;
+                    case "Lazy":
+                        itemType = namedObjectTypeProperty.type.resolveType;
+                        break;
+                    case "LazyOption":
+                    case "LazySet":
+                        itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                        break;
+                    default:
+                        itemType = namedObjectTypeProperty.type;
+                        break;
+                }
+                switch (itemType.kind) {
+                    case "Intersection":
+                    case "Struct":
+                    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(namedStructType),
+                properties: properties,
+            });
+        }
+        else if (namedType.kind === "Union") {
+            nodes.push({
+                id: typeId(namedType),
+                label: typeName(namedType),
+                properties: {},
+            });
+        }
+    }
+    return {
+        nodes,
+        relationships,
+    };
+}
+function typeId(type) {
+    return type.name.orDefault(type.shapeIdentifier.toString());
+}
+function typeName(type) {
+    return type.name.orDefault(type.shapeIdentifier.toString());
+}
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.js.map

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

@@ -0,0 +1,37 @@
+import { Maybe } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.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;
+    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
+    readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
+    constructor({ mutable, ...superParameters }: {
+        mutable: boolean;
+    } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
+    get equalsFunction(): Code;
+    get expression(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
+    get mutable(): boolean;
+    get schemaType(): Code;
+    get validationFunction(): Maybe<Code>;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[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 import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractContainerType.GraphqlType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+    type ItemType = AbstractContainerType.ItemType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractContainerType.JsonType;
+}
+//# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -0,0 +1,88 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for ListType and SetType.
+ */
+export class AbstractCollectionType extends AbstractContainerType {
+    _mutable;
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    constructor({ mutable, ...superParameters }) {
+        super(superParameters);
+        this._mutable = mutable;
+    }
+    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.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.expression})`, this.reusables);
+    }
+    get hashFunction() {
+        return code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction})`;
+    }
+    get mutable() {
+        return this._mutable || this.itemType.mutable;
+    }
+    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)})`);
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "validationFunction", null);
+(function (AbstractCollectionType) {
+    AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
+    AbstractCollectionType.isItemType = AbstractContainerType.isItemType;
+    AbstractCollectionType.JsonType = AbstractContainerType.JsonType;
+})(AbstractCollectionType || (AbstractCollectionType = {}));
+//# sourceMappingURL=AbstractCollectionType.js.map

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

@@ -0,0 +1,53 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { BigDecimalType } from "./BigDecimalType.js";
+import type { BigIntType } from "./BigIntType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { BooleanType } from "./BooleanType.js";
+import type { DateTimeType } from "./DateTimeType.js";
+import type { DateType } from "./DateType.js";
+import type { FloatType } from "./FloatType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+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 { 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.
+ */
+export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
+    readonly declaration: Maybe<Code>;
+    abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType: ItemTypeT;
+    constructor({ itemType, ...superParameters }: {
+        itemType: ItemTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get recursive(): boolean;
+    get referencesNamedType(): boolean;
+    protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
+    protected get itemValidationFunctionDefault(): Code;
+    protected get schemaInitializers(): readonly Code[];
+}
+export declare namespace AbstractContainerType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    const GraphqlType: typeof AbstractType.GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    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;
+}
+//# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/generators/ts/AbstractContainerType.js

@@ -0,0 +1,97 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
+ */
+export class AbstractContainerType extends AbstractType {
+    declaration = Maybe.empty();
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType;
+    constructor({ itemType, ...superParameters }) {
+        super(superParameters);
+        this.itemType = itemType;
+    }
+    get recursive() {
+        return this.itemType.recursive;
+    }
+    get referencesNamedType() {
+        return this.name.isJust() || this.itemType.referencesNamedType;
+    }
+    get itemConversionFunctionDefault() {
+        return {
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: [
+                {
+                    expression: this.itemType.expression,
+                    jsType: this.itemType.jsTypes[0],
+                },
+            ],
+        };
+    }
+    get itemValidationFunctionDefault() {
+        return code `${this.reusables.snippets.identityValidationFunction}`;
+    }
+    get schemaInitializers() {
+        const initializers = super.schemaInitializers.concat();
+        if (this.recursive || this.referencesNamedType) {
+            initializers.push(code `get itemType() { return ${this.itemType.schema}; }`);
+        }
+        else {
+            initializers.push(code `itemType: ${this.itemType.schema}`);
+        }
+        return initializers;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "itemConversionFunctionDefault", null);
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "itemValidationFunctionDefault", null);
+(function (AbstractContainerType) {
+    AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BigDecimal":
+            case "BigInt":
+            case "BlankNode":
+            case "Boolean":
+            case "DateTime":
+            case "Date":
+            case "Float":
+            case "Identifier":
+            case "Int":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "Object":
+            case "ObjectUnion":
+            case "String":
+            case "Term":
+            case "Union":
+                return true;
+            case "DefaultValue":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
+            case "Option":
+            case "Set":
+                return false;
+        }
+    }
+    AbstractContainerType.isItemType = isItemType;
+    AbstractContainerType.JsonType = AbstractType.JsonType;
+})(AbstractContainerType || (AbstractContainerType = {}));
+//# sourceMappingURL=AbstractContainerType.js.map

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

@@ -0,0 +1,23 @@
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
+    protected readonly inlineExpression: Code;
+    readonly equalsFunction: 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 valueSparqlWherePatternsFunction: Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
+    jsonType(): AbstractPrimitiveType.JsonType;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
+}
+export declare namespace AbstractDateType {
+    type ConversionFunction = AbstractPrimitiveType.ConversionFunction;
+}
+//# sourceMappingURL=AbstractDateType.d.ts.map

package/dist/generators/ts/AbstractDateType.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractDateType extends AbstractPrimitiveType {
+    inlineExpression = code `Date`;
+    equalsFunction = code `${this.reusables.snippets.dateEquals}`;
+    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}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;
+    }
+    jsonType() {
+        return new AbstractPrimitiveType.JsonType(code `string`);
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractDateType.prototype, "jsonType", null);
+//# sourceMappingURL=AbstractDateType.js.map

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

@@ -0,0 +1,21 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+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;
+    readonly stringifyFunction: Code;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
+}
+export declare namespace AbstractIdentifierType {
+    type ConversionFunction = AbstractTermType.ConversionFunction;
+    type JsonType = AbstractTermType.JsonType;
+}
+//# sourceMappingURL=AbstractIdentifierType.d.ts.map