@shaclmate/compiler 4.0.18 → 4.0.19

package/dist/ast/AbstractCollectionType.d.ts

@@ -12,6 +12,16 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     equals(other: AbstractCollectionType<ItemTypeT>): boolean;
+    toJSON(): {
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace AbstractCollectionType {
     type ItemType = AbstractContainerType.ItemType;

package/dist/ast/AbstractCollectionType.js

@@ -20,6 +20,12 @@ export class AbstractCollectionType extends AbstractContainerType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            mutable: this.mutable ? true : undefined,
+        };
+    }
 }
 (function (AbstractCollectionType) {
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;

package/dist/ast/AbstractCompoundType.d.ts

@@ -31,7 +31,6 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
     get tsFeatures(): ReadonlySet<TsFeature>;
     addMember(member: MemberT): void;
     equals(other: AbstractCompoundType<MemberT, MemberTypeT>): boolean;
-    toString(): string;
 }
 export declare namespace AbstractCompoundType {
     interface Member<TypeT extends MemberType> {

package/dist/ast/AbstractCompoundType.js

@@ -80,9 +80,6 @@ export class AbstractCompoundType extends AbstractType {
         // Don't recurse
         return this.shapeIdentifier.equals(other.shapeIdentifier);
     }
-    toString() {
-        return `${this.kind}(memberTypes=[${this.members.map((memberType) => memberType.toString()).join(", ")}])`;
-    }
 }
 __decorate([
     Memoize()

package/dist/ast/AbstractContainerType.d.ts

@@ -27,7 +27,15 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
-    toString(): string;
+    toJSON(): {
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace AbstractContainerType {
     type ItemType = BlankNodeType | IdentifierType | IntersectionType | IriType | ListType | LiteralType | ObjectType | TermType | UnionType;

package/dist/ast/AbstractContainerType.js

@@ -29,8 +29,11 @@ export class AbstractContainerType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(itemType=${this.itemType})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            itemType: this.itemType.toJSON(),
+        };
     }
 }
 (function (AbstractContainerType) {

package/dist/ast/AbstractLazyObjectType.d.ts

@@ -18,7 +18,160 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
     equals(other: AbstractLazyObjectType<PartialTypeT, ResolveTypeT>): boolean;
-    toString(): string;
+    toJSON(): {
+        partialType: {
+            fromRdfType: string | undefined;
+            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+            identifierType: {
+                hasValues: ({
+                    termType: "BlankNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                } | {
+                    datatype: string;
+                    language: string;
+                    termType: "Literal";
+                    value: string;
+                } | {
+                    termType: "NamedNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                })[] | undefined;
+                in: ({
+                    termType: "BlankNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                } | {
+                    datatype: string;
+                    language: string;
+                    termType: "Literal";
+                    value: string;
+                } | {
+                    termType: "NamedNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                })[] | undefined;
+                nodeKinds: NodeKind[];
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: string;
+            };
+            parentObjectTypes: string[] | undefined;
+            synthetic: boolean | undefined;
+            toRdfTypes: string[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        } | {
+            members: {
+                discriminantValue: string | number | undefined;
+                type: any;
+            }[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        } | {
+            itemType: any;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        };
+        resolveType: {
+            fromRdfType: string | undefined;
+            identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+            identifierType: {
+                hasValues: ({
+                    termType: "BlankNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                } | {
+                    datatype: string;
+                    language: string;
+                    termType: "Literal";
+                    value: string;
+                } | {
+                    termType: "NamedNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                })[] | undefined;
+                in: ({
+                    termType: "BlankNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                } | {
+                    datatype: string;
+                    language: string;
+                    termType: "Literal";
+                    value: string;
+                } | {
+                    termType: "NamedNode";
+                    value: string;
+                    datatype?: undefined;
+                    language?: undefined;
+                })[] | undefined;
+                nodeKinds: NodeKind[];
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: string;
+            };
+            parentObjectTypes: string[] | undefined;
+            synthetic: boolean | undefined;
+            toRdfTypes: string[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        } | {
+            members: {
+                discriminantValue: string | number | undefined;
+                type: any;
+            }[] | undefined;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        } | {
+            itemType: any;
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        };
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace AbstractLazyObjectType {
     type ObjectTypeConstraint = ObjectType | ObjectUnionType;

package/dist/ast/AbstractLazyObjectType.js

@@ -29,8 +29,12 @@ export class AbstractLazyObjectType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(partialType=${this.partialType}, resolveType=${this.resolveType})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            partialType: this.partialType.toJSON(),
+            resolveType: this.resolveType.toJSON(),
+        };
     }
 }
 //# sourceMappingURL=AbstractLazyObjectType.js.map

package/dist/ast/AbstractTermType.d.ts

@@ -18,6 +18,46 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     equals(other: AbstractTermType<ConstantTermT, _RuntimeTermT>): boolean;
-    toString(): string;
+    toJSON(): {
+        hasValues: ({
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        })[] | undefined;
+        in: ({
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        })[] | undefined;
+        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractTermType.js

@@ -1,5 +1,6 @@
 import { AbstractType } from "./AbstractType.js";
 import { arrayEquals, setEquals, strictEquals, termEquals } from "./equals.js";
+import { termToJson } from "./termToJson.js";
 /**
  * Abstract base class of term types (BlankNodeType, IdentifierType, LiteralType, IriType, TermType).
  *
@@ -35,8 +36,13 @@ export class AbstractTermType extends AbstractType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}(nodeKinds=${[...this.nodeKinds].join(" | ")})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            hasValues: this.hasValues.length > 0 ? this.hasValues.map(termToJson) : undefined,
+            in: this.in_.length > 0 ? this.in_.map(termToJson) : undefined,
+            nodeKinds: [...this.nodeKinds],
+        };
     }
 }
 //# sourceMappingURL=AbstractTermType.js.map

package/dist/ast/AbstractType.d.ts

@@ -9,6 +9,10 @@ export declare abstract class AbstractType {
      * Documentation comment from rdfs:comment.
      */
     readonly comment: Maybe<string>;
+    /**
+     * Type discriminant
+     */
+    abstract readonly kind: string;
     /**
      * Human-readable label from rdfs:label.
      */
@@ -38,6 +42,14 @@ export declare abstract class AbstractType {
         shapeIdentifier: BlankNode | NamedNode;
     });
     equals(other: AbstractType): boolean;
-    abstract toString(): string;
+    toJSON(): {
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
+    toString(): string;
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/ast/AbstractType.js

@@ -1,3 +1,4 @@
+import { Resource } from "@rdfx/resource";
 import { Maybe } from "purify-ts";
 import { maybeEquals, strictEquals } from "./equals.js";
 /**
@@ -35,5 +36,18 @@ export class AbstractType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            comment: this.comment.extract(),
+            kind: this.kind,
+            label: this.label.extract(),
+            name: this.name.extract(),
+            recursive: this.recursive ? true : undefined,
+            shapeIdentifier: Resource.Identifier.toString(this.shapeIdentifier),
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
 }
 //# sourceMappingURL=AbstractType.js.map

package/dist/ast/DefaultValueType.d.ts

@@ -17,6 +17,31 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         defaultValue: Literal | NamedNode;
     });
     equals(other: DefaultValueType<ItemTypeT>): boolean;
+    toJSON(): {
+        defaultValue: {
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        };
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;

package/dist/ast/DefaultValueType.js

@@ -1,5 +1,6 @@
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { termEquals } from "./equals.js";
+import { termToJson } from "./termToJson.js";
 /**
  * A type with an sh:defaultValue.
  *
@@ -30,6 +31,12 @@ export class DefaultValueType extends AbstractContainerType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            defaultValue: termToJson(this.defaultValue),
+        };
+    }
 }
 (function (DefaultValueType) {
     function isItemType(type) {

package/dist/ast/LiteralType.d.ts

@@ -19,6 +19,112 @@ export declare class LiteralType extends AbstractTermType<Literal, Literal> {
         minInclusive: Maybe<Literal>;
     } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
     equals(other: AbstractTermType<Literal, Literal>): boolean;
-    toString(): string;
+    toJSON(): {
+        datatype: string | undefined;
+        languageIn: readonly string[] | undefined;
+        maxExclusive: {
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | undefined;
+        maxInclusive: {
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | undefined;
+        minExclusive: {
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | undefined;
+        minInclusive: {
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | undefined;
+        hasValues: ({
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        })[] | undefined;
+        in: ({
+            termType: "BlankNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        } | {
+            datatype: string;
+            language: string;
+            termType: "Literal";
+            value: string;
+        } | {
+            termType: "NamedNode";
+            value: string;
+            datatype?: undefined;
+            language?: undefined;
+        })[] | undefined;
+        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -1,5 +1,7 @@
+import { Resource } from "@rdfx/resource";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { arrayEquals, maybeEquals, strictEquals, termEquals, } from "./equals.js";
+import { termToJson } from "./termToJson.js";
 export class LiteralType extends AbstractTermType {
     datatype;
     kind = "LiteralType";
@@ -43,8 +45,16 @@ export class LiteralType extends AbstractTermType {
         }
         return true;
     }
-    toString() {
-        return `${this.kind}()`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            datatype: this.datatype.map(Resource.Identifier.toString).extract(),
+            languageIn: this.languageIn.length > 0 ? this.languageIn : undefined,
+            maxExclusive: this.maxExclusive.map(termToJson).extract(),
+            maxInclusive: this.maxInclusive.map(termToJson).extract(),
+            minExclusive: this.minExclusive.map(termToJson).extract(),
+            minInclusive: this.minInclusive.map(termToJson).extract(),
+        };
     }
 }
 const nodeKinds = new Set(["Literal"]);

package/dist/ast/ObjectType.d.ts

@@ -98,7 +98,60 @@ export declare class ObjectType extends AbstractType {
     addProperties(...properties: readonly ObjectType.Property[]): void;
     equals(other: ObjectType): boolean;
     sortProperties(): void;
-    toString(): string;
+    toJSON(): {
+        fromRdfType: string | undefined;
+        identifierMintingStrategy: "blankNode" | "sha256" | "uuidv4" | undefined;
+        identifierType: {
+            hasValues: ({
+                termType: "BlankNode";
+                value: string;
+                datatype?: undefined;
+                language?: undefined;
+            } | {
+                datatype: string;
+                language: string;
+                termType: "Literal";
+                value: string;
+            } | {
+                termType: "NamedNode";
+                value: string;
+                datatype?: undefined;
+                language?: undefined;
+            })[] | undefined;
+            in: ({
+                termType: "BlankNode";
+                value: string;
+                datatype?: undefined;
+                language?: undefined;
+            } | {
+                datatype: string;
+                language: string;
+                termType: "Literal";
+                value: string;
+            } | {
+                termType: "NamedNode";
+                value: string;
+                datatype?: undefined;
+                language?: undefined;
+            })[] | undefined;
+            nodeKinds: NodeKind[];
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+        };
+        parentObjectTypes: string[] | undefined;
+        synthetic: boolean | undefined;
+        toRdfTypes: string[] | undefined;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace ObjectType {
     class Property {
@@ -165,6 +218,26 @@ export declare namespace ObjectType {
          * Does the property directly or indirectly reference the ObjectType itself?
          */
         get recursive(): boolean;
+        toJSON(): {
+            comment: string | undefined;
+            description: string | undefined;
+            label: string | undefined;
+            mutable: boolean | undefined;
+            name: string;
+            order: number;
+            path: string;
+            recursive: boolean | undefined;
+            shapeIdentifier: string;
+            type: {
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: string;
+            };
+            visibility: Visibility;
+        };
         toString(): string;
     }
 }