@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/ast/ListType.js

@@ -0,0 +1,56 @@
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+/**
+ * An ordered sequence of items with zero or one values of an item type.
+ *
+ * ListType is transformed from a SHACL node shape that models an RDF list (https://www.w3.org/TR/rdf11-schema/#ch_collectionvocab).
+ *
+ * Contrast SetType, which is transformed from any SHACL property shape with no maxCount or maxCount greater than 1.
+ */
+export class ListType extends AbstractCollectionType {
+    /**
+     * Type of identifier (blank or named node) to use for lists and sub-lists.
+     */
+    identifierNodeKind;
+    kind = "List";
+    /**
+     * rdf:type's that will be added to this object when it's serialized toRdf.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    toRdfTypes;
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
+        super(superParameters);
+        this.identifierNodeKind = identifierNodeKind;
+        this.toRdfTypes = toRdfTypes;
+    }
+    equals(other) {
+        // Don't recurse
+        return this.shapeIdentifier.equals(other.shapeIdentifier);
+    }
+}
+(function (ListType) {
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BlankNode":
+            case "Identifier":
+            case "Intersection":
+            case "Iri":
+            case "List":
+            case "Literal":
+            case "Struct":
+            case "Term":
+            case "Union":
+                return true;
+            case "DefaultValue":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
+            case "Option":
+            case "Set":
+                return false;
+        }
+    }
+    ListType.isItemType = isItemType;
+})(ListType || (ListType = {}));
+//# sourceMappingURL=ListType.js.map

package/dist/ast/LiteralType.d.ts

@@ -0,0 +1,40 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+import { AbstractTermType } from "./AbstractTermType.js";
+export declare class LiteralType extends AbstractTermType<Literal, Literal> {
+    readonly datatype: Maybe<NamedNode>;
+    readonly kind = "Literal";
+    readonly nodeKinds: ReadonlySet<"Literal">;
+    readonly languageIn: readonly string[];
+    readonly maxExclusive: Maybe<Literal>;
+    readonly maxInclusive: Maybe<Literal>;
+    readonly minExclusive: Maybe<Literal>;
+    readonly minInclusive: Maybe<Literal>;
+    constructor({ datatype, languageIn, maxExclusive, maxInclusive, minExclusive, minInclusive, ...superParameters }: {
+        datatype: Maybe<NamedNode>;
+        languageIn: readonly string[];
+        maxExclusive: Maybe<Literal>;
+        maxInclusive: Maybe<Literal>;
+        minExclusive: Maybe<Literal>;
+        minInclusive: Maybe<Literal>;
+    } & Omit<ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0], "nodeKinds">);
+    equals(other: AbstractTermType<Literal, Literal>): boolean;
+    toJSON(): {
+        datatype: NamedNode<string> | undefined;
+        languageIn: readonly string[] | undefined;
+        maxExclusive: Literal | undefined;
+        maxInclusive: Literal | undefined;
+        minExclusive: Literal | undefined;
+        minInclusive: Literal | undefined;
+        hasValues: readonly Literal[] | undefined;
+        in: readonly Literal[] | undefined;
+        nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
+    };
+}
+//# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/LiteralType.js

@@ -0,0 +1,59 @@
+import { AbstractTermType } from "./AbstractTermType.js";
+import { arrayEquals, maybeEquals, strictEquals, termEquals, } from "./equals.js";
+export class LiteralType extends AbstractTermType {
+    datatype;
+    kind = "Literal";
+    nodeKinds = nodeKinds;
+    languageIn;
+    maxExclusive;
+    maxInclusive;
+    minExclusive;
+    minInclusive;
+    constructor({ datatype, languageIn, maxExclusive, maxInclusive, minExclusive, minInclusive, ...superParameters }) {
+        super(superParameters);
+        this.datatype = datatype;
+        this.languageIn = languageIn;
+        this.maxExclusive = maxExclusive;
+        this.maxInclusive = maxInclusive;
+        this.minExclusive = minExclusive;
+        this.minInclusive = minInclusive;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        const otherLiteralType = other;
+        if (!maybeEquals(termEquals)(this.datatype, otherLiteralType.datatype)) {
+            return false;
+        }
+        if (!arrayEquals(strictEquals)(this.languageIn, otherLiteralType.languageIn)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.maxExclusive, otherLiteralType.maxExclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.maxInclusive, otherLiteralType.maxInclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.minExclusive, otherLiteralType.minExclusive)) {
+            return false;
+        }
+        if (!maybeEquals(termEquals)(this.minInclusive, otherLiteralType.minInclusive)) {
+            return false;
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            datatype: this.datatype.extract(),
+            languageIn: this.languageIn.length > 0 ? this.languageIn : undefined,
+            maxExclusive: this.maxExclusive.extract(),
+            maxInclusive: this.maxInclusive.extract(),
+            minExclusive: this.minExclusive.extract(),
+            minInclusive: this.minInclusive.extract(),
+        };
+    }
+}
+const nodeKinds = new Set(["Literal"]);
+//# sourceMappingURL=LiteralType.js.map

package/dist/ast/OptionType.d.ts

@@ -0,0 +1,13 @@
+import { AbstractContainerType } from "./AbstractContainerType.js";
+/**
+ * A type with zero or one values of an item type.
+ */
+export declare class OptionType<ItemTypeT extends OptionType.ItemType = OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    readonly kind = "Option";
+    constructor({ itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType">);
+}
+export declare namespace OptionType {
+    type ItemType = AbstractContainerType.ItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+}
+//# sourceMappingURL=OptionType.d.ts.map

package/dist/ast/OptionType.js

@@ -0,0 +1,21 @@
+import { Maybe } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+/**
+ * A type with zero or one values of an item type.
+ */
+export class OptionType extends AbstractContainerType {
+    kind = "Option";
+    constructor({ itemType, }) {
+        super({
+            comment: itemType.comment,
+            itemType,
+            label: itemType.label,
+            name: Maybe.empty(),
+            shapeIdentifier: itemType.shapeIdentifier,
+        });
+    }
+}
+(function (OptionType) {
+    OptionType.isItemType = AbstractContainerType.isItemType;
+})(OptionType || (OptionType = {}));
+//# sourceMappingURL=OptionType.js.map

package/dist/ast/SetType.d.ts

@@ -0,0 +1,31 @@
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+/**
+ * An unordered set of items of a specific type.
+ */
+export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
+    readonly kind = "Set";
+    /**
+     * Minimum number of items in the set.
+     */
+    readonly minCount: bigint;
+    constructor({ itemType, minCount, ...superParameters }: {
+        minCount: bigint;
+    } & Pick<ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0], "itemType" | "mutable">);
+    equals(other: SetType<ItemTypeT>): boolean;
+    toJSON(): {
+        minCount: number;
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
+}
+export declare namespace SetType {
+    type ItemType = AbstractCollectionType.ItemType;
+    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/dist/ast/SetType.js

@@ -0,0 +1,42 @@
+import { Maybe } from "purify-ts";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+/**
+ * An unordered set of items of a specific type.
+ */
+export class SetType extends AbstractCollectionType {
+    kind = "Set";
+    /**
+     * Minimum number of items in the set.
+     */
+    minCount;
+    constructor({ itemType, minCount, ...superParameters }) {
+        super({
+            ...superParameters,
+            comment: itemType.comment,
+            itemType,
+            label: itemType.label,
+            name: Maybe.empty(),
+            shapeIdentifier: itemType.shapeIdentifier,
+        });
+        this.minCount = minCount;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (this.minCount !== other.minCount) {
+            return false;
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            minCount: Number(this.minCount),
+        };
+    }
+}
+(function (SetType) {
+    SetType.isItemType = AbstractCollectionType.isItemType;
+})(SetType || (SetType = {}));
+//# sourceMappingURL=SetType.js.map

package/dist/ast/StructCompoundType.d.ts

@@ -0,0 +1,12 @@
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import type { StructIntersectionType } from "./StructIntersectionType.js";
+import type { StructType } from "./StructType.js";
+import type { StructUnionType } from "./StructUnionType.js";
+export type StructCompoundType = StructIntersectionType | StructUnionType;
+export declare namespace StructCompoundType {
+    function identifierType(objectCompoundType: StructCompoundType): BlankNodeType | IdentifierType | IriType;
+    function memberStructTypes(objectCompoundType: StructCompoundType): readonly StructType[];
+}
+//# sourceMappingURL=StructCompoundType.d.ts.map

package/dist/ast/StructCompoundType.js

@@ -0,0 +1,87 @@
+import TermSet from "@rdfjs/term-set";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { BlankNodeType } from "./BlankNodeType.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+export var StructCompoundType;
+(function (StructCompoundType) {
+    function identifierType(objectCompoundType) {
+        const memberIdentifierTypeNodeKinds = new Set();
+        const memberIdentifierTypesIn = new TermSet();
+        for (const memberType of memberStructTypes(objectCompoundType)) {
+            for (const nodeKind of memberType.identifierType.nodeKinds) {
+                memberIdentifierTypeNodeKinds.add(nodeKind);
+            }
+            for (const in_ of memberType.identifierType.in_) {
+                memberIdentifierTypesIn.add(in_);
+            }
+        }
+        invariant(memberIdentifierTypeNodeKinds.size > 0);
+        if (memberIdentifierTypeNodeKinds.size === 2) {
+            return new IdentifierType({
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                name: Maybe.empty(),
+                shapeIdentifier: objectCompoundType.shapeIdentifier,
+            });
+        }
+        const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
+        switch (memberIdentifierTypeNodeKind) {
+            case "BlankNode":
+                return new BlankNodeType({
+                    comment: Maybe.empty(),
+                    label: Maybe.empty(),
+                    name: Maybe.empty(),
+                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                });
+            case "IRI":
+                return new IriType({
+                    comment: Maybe.empty(),
+                    hasValues: [],
+                    in_: [...memberIdentifierTypesIn],
+                    label: Maybe.empty(),
+                    name: Maybe.empty(),
+                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                });
+            default:
+                memberIdentifierTypeNodeKind;
+                throw new Error("should never reach here");
+        }
+    }
+    StructCompoundType.identifierType = identifierType;
+    function memberStructTypes(objectCompoundType) {
+        const memberStructTypes_ = [];
+        for (const member of objectCompoundType.members) {
+            switch (member.type.kind) {
+                case "Struct":
+                    memberStructTypes_.push(member.type);
+                    break;
+                case "Intersection":
+                case "Union": {
+                    invariant(member.type.kind === objectCompoundType.kind);
+                    memberStructTypes_.push(...memberStructTypes(member.type));
+                    break;
+                }
+            }
+        }
+        invariant(memberStructTypes_.length >= objectCompoundType.members.length, "object compound type has no member StructType's");
+        // Member object types must have distinct RDF types or no RDF types at all.
+        const fromRdfTypes = new TermSet();
+        let expectUniqueFromRdfTypesCount = 0;
+        for (const memberStructType of memberStructTypes_) {
+            if (memberStructType.extern) {
+                continue;
+            }
+            expectUniqueFromRdfTypesCount++;
+            memberStructType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
+        }
+        if (fromRdfTypes.size > 0 &&
+            fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
+            throw new Error(`one or more ${objectCompoundType} members ([${memberStructTypes_.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].join(", ")}})`);
+        }
+        return memberStructTypes_;
+    }
+    StructCompoundType.memberStructTypes = memberStructTypes;
+})(StructCompoundType || (StructCompoundType = {}));
+//# sourceMappingURL=StructCompoundType.js.map

package/dist/ast/StructIntersectionType.d.ts

@@ -0,0 +1,4 @@
+import type { IntersectionType } from "./IntersectionType.js";
+import type { StructType } from "./StructType.js";
+export type StructIntersectionType = IntersectionType<IntersectionType<StructType> | StructType>;
+//# sourceMappingURL=StructIntersectionType.d.ts.map

package/dist/ast/StructIntersectionType.js

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

package/dist/ast/StructType.d.ts

@@ -0,0 +1,178 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { PropertyPath } from "@rdfx/resource";
+import type { NodeKind } from "@shaclmate/shacl-ast";
+import type { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import { Type } from "./Type.js";
+export declare class StructType extends AbstractType {
+    #private;
+    private fieldNames;
+    /**
+     * If true, the code for this StructType is defined externally and should not be generated.
+     *
+     * Defaults to false.
+     */
+    readonly extern: boolean;
+    /**
+     * The expected rdf:type of instances of this StructType.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    readonly fromRdfType: Maybe<NamedNode>;
+    /**
+     * Identifier type.
+     */
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
+    /**
+     * Type discriminant.
+     */
+    readonly kind = "Struct";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
+    /**
+     * Was this type synthesized or did it come from SHACL?
+     */
+    readonly synthetic: boolean;
+    /**
+     * rdf:type's that will be added to this object when it's serialized toRdf.
+     *
+     * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
+     * class targets).
+     */
+    readonly toRdfTypes: readonly NamedNode[];
+    /**
+     * TypeScript imports to add to generated code.
+     *
+     * This is often used in conjunction with extern=true to import the extern'd StructType code in order for generated
+     * code to reference it.
+     *
+     * import { MyType } from "./MyType.js"
+     */
+    readonly tsImports: readonly string[];
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsImports, ...superParameters }: {
+        extern: boolean;
+        fromRdfType: Maybe<NamedNode>;
+        identifierType: BlankNodeType | IdentifierType | IriType;
+        synthetic: boolean;
+        toRdfTypes: readonly NamedNode[];
+        tsImports: readonly string[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get fields(): readonly StructType.Field[];
+    get recursive(): boolean;
+    addFields(...fields: readonly StructType.Field[]): void;
+    equals(other: StructType): boolean;
+    sortFields(): void;
+    toJSON(): {
+        fromRdfType: NamedNode<string> | undefined;
+        identifierType: {
+            hasValues: readonly NamedNode<string>[] | undefined;
+            in: readonly NamedNode<string>[] | undefined;
+            nodeKinds: NodeKind[];
+            comment: string | undefined;
+            kind: string;
+            label: string | undefined;
+            name: string | undefined;
+            recursive: boolean | undefined;
+            shapeIdentifier: BlankNode | NamedNode<string>;
+        };
+        synthetic: boolean | undefined;
+        toRdfTypes: readonly NamedNode<string>[] | undefined;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: BlankNode | NamedNode<string>;
+    };
+}
+export declare namespace StructType {
+    class Field {
+        /**
+         * Documentation comment from rdfs:comment.
+         */
+        readonly comment: Maybe<string>;
+        /**
+         * Description from sh:description.
+         */
+        readonly description: Maybe<string>;
+        /**
+         * Should the field and its value be displayed in a toString()-type representation?
+         */
+        readonly display: boolean;
+        /**
+         * Human-readable label from rdfs:label.
+         */
+        readonly label: Maybe<string>;
+        /**
+         * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
+         * not be mutable.
+         */
+        readonly mutable: boolean;
+        /**
+         * Name of this field, derived from sh:name or shaclmate:name.
+         */
+        readonly name: string;
+        /**
+         * Relative order of this field, derived from sh:order.
+         */
+        readonly order: number;
+        /**
+         * SHACL property path (https://www.w3.org/TR/shacl/#field-paths)
+         */
+        readonly path: PropertyPath;
+        /**
+         * Identifier of the field shape.
+         */
+        readonly shapeIdentifier: BlankNode | NamedNode;
+        /**
+         * StructType this field belongs to.
+         */
+        readonly structType: StructType;
+        /**
+         * Type of this field.
+         */
+        readonly type: Type;
+        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }: {
+            comment: Maybe<string>;
+            description: Maybe<string>;
+            display: boolean;
+            label: Maybe<string>;
+            mutable: boolean;
+            name: string;
+            order: number;
+            path: PropertyPath;
+            shapeIdentifier: BlankNode | NamedNode;
+            structType: StructType;
+            type: Type;
+        });
+        equals(other: Field): boolean;
+        /**
+         * Does the field directly or indirectly reference the StructType 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: BlankNode | NamedNode<string>;
+            type: {
+                comment: string | undefined;
+                kind: string;
+                label: string | undefined;
+                name: string | undefined;
+                recursive: boolean | undefined;
+                shapeIdentifier: BlankNode | NamedNode<string>;
+            };
+        };
+        toString(): string;
+    }
+}
+//# sourceMappingURL=StructType.d.ts.map