@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/Cx2Generator.js

@@ -1,140 +0,0 @@
-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

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

package/dist/generators/Generator.js

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

package/dist/generators/LabeledPropertyGraph.d.ts

@@ -1,42 +0,0 @@
-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

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

package/dist/generators/index.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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