@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/ast/ListType.js

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

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

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

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

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

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

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

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

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

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

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

package/dist/ast/StructType.d.ts

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