@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/ast/StructType.js

@@ -1,314 +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 { PropertyPath } from "@rdfx/resource";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { arrayEquals } from "./equals.js";
-import { Type } from "./Type.js";
-export class StructType extends AbstractType {
-    /**
-     * Fields of this StructType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #fields = [];
-    fieldNames = new Set();
-    /**
-     * If true, the code for this StructType is defined externally and should not be generated.
-     *
-     * Defaults to false.
-     */
-    extern;
-    /**
-     * 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).
-     */
-    fromRdfType;
-    /**
-     * Identifier type.
-     */
-    identifierType;
-    /**
-     * Type discriminant.
-     */
-    kind = "Struct";
-    nodeKinds = nodeKinds;
-    /**
-     * Was this type synthesized or did it come from SHACL?
-     */
-    synthetic;
-    /**
-     * 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;
-    /**
-     * 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"
-     */
-    tsImports;
-    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsImports, ...superParameters }) {
-        super(superParameters);
-        this.extern = extern;
-        this.fromRdfType = fromRdfType;
-        this.identifierType = identifierType;
-        this.synthetic = synthetic;
-        this.toRdfTypes = toRdfTypes;
-        this.tsImports = tsImports;
-    }
-    get fields() {
-        return this.#fields;
-    }
-    get recursive() {
-        return this.fields.some((field) => field.recursive);
-    }
-    addFields(...fields) {
-        for (const field of fields) {
-            invariant(Object.is(field.structType, this), "field has unexpected .structType");
-            invariant(!this.fieldNames.has(field.name), `${field.structType.shapeIdentifier}: duplicate field name: ${field.name}`);
-            this.#fields.push(field);
-            this.fieldNames.add(field.name);
-        }
-    }
-    equals(other) {
-        // Don't recurse
-        return this.shapeIdentifier.equals(other.shapeIdentifier);
-    }
-    sortFields() {
-        this.#fields.sort((left, right) => {
-            if (left.order < right.order) {
-                return -1;
-            }
-            if (left.order > right.order) {
-                return 1;
-            }
-            return 0;
-        });
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            fromRdfType: this.fromRdfType.extract(),
-            identifierType: this.identifierType.toJSON(),
-            synthetic: this.synthetic ? true : undefined,
-            toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
-        };
-    }
-}
-const nodeKinds = new Set(["BlankNode", "IRI"]);
-(function (StructType) {
-    class Field {
-        /**
-         * Documentation comment from rdfs:comment.
-         */
-        comment;
-        /**
-         * Description from sh:description.
-         */
-        description;
-        /**
-         * Should the field and its value be displayed in a toString()-type representation?
-         */
-        display;
-        /**
-         * Human-readable label from rdfs:label.
-         */
-        label;
-        /**
-         * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
-         * not be mutable.
-         */
-        mutable;
-        /**
-         * Name of this field, derived from sh:name or shaclmate:name.
-         */
-        name;
-        /**
-         * Relative order of this field, derived from sh:order.
-         */
-        order;
-        /**
-         * SHACL property path (https://www.w3.org/TR/shacl/#field-paths)
-         */
-        path;
-        /**
-         * Identifier of the field shape.
-         */
-        shapeIdentifier;
-        /**
-         * StructType this field belongs to.
-         */
-        structType;
-        /**
-         * Type of this field.
-         */
-        type;
-        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }) {
-            this.comment = comment;
-            this.description = description;
-            this.display = display;
-            this.label = label;
-            this.mutable = mutable;
-            this.name = name;
-            this.structType = structType;
-            this.order = order;
-            this.path = path;
-            this.shapeIdentifier = shapeIdentifier;
-            this.type = type;
-        }
-        equals(other) {
-            return this.shapeIdentifier.equals(other.shapeIdentifier);
-        }
-        /**
-         * Does the field directly or indirectly reference the StructType itself?
-         */
-        get recursive() {
-            const DEBUG = false;
-            const rootField = this;
-            const rootStructType = this.structType;
-            function helper(stack) {
-                const currentStackFrame = stack.at(-1);
-                const { field, fieldType, structType } = currentStackFrame;
-                if (DEBUG) {
-                    process.stderr.write(`${[
-                        stack.length.toString(),
-                        rootField,
-                        rootStructType,
-                        field,
-                        fieldType
-                            ? `[${fieldType.map(Type.toString).join(", ")}]`
-                            : "undefined",
-                        structType,
-                    ].join(",")}\n`);
-                }
-                for (const lowerStackFrame of stack.slice(0, -1)) {
-                    if (!Type.equals(currentStackFrame.structType, lowerStackFrame.structType)) {
-                        continue;
-                    }
-                    if (!currentStackFrame.field.equals(lowerStackFrame.field)) {
-                        continue;
-                    }
-                    if (!arrayEquals(Type.equals)(currentStackFrame.fieldType ?? [], lowerStackFrame.fieldType ?? [])) {
-                        continue;
-                    }
-                    // We've seen this combination before and don't want to recurse further, to avoid infinite recursion
-                    if (DEBUG) {
-                        process.stderr.write("recursion detected, halting");
-                    }
-                    return true;
-                }
-                if (!fieldType) {
-                    return helper(stack.concat({
-                        field,
-                        fieldType: [field.type],
-                        structType,
-                    }));
-                }
-                invariant(fieldType.length > 0);
-                const currentFieldType = fieldType.at(-1);
-                switch (currentFieldType.kind) {
-                    case "BlankNode":
-                    case "Identifier":
-                    case "Iri":
-                    case "Literal":
-                    case "Term":
-                        return false;
-                    case "LazyOption":
-                    case "LazySet":
-                    case "Lazy": {
-                        if (helper(stack.concat({
-                            field,
-                            fieldType: fieldType.concat(currentFieldType.partialType),
-                            structType,
-                        }))) {
-                            return true;
-                        }
-                        if (helper(stack.concat({
-                            field,
-                            fieldType: fieldType.concat(currentFieldType.resolveType),
-                            structType,
-                        }))) {
-                            return true;
-                        }
-                        return false;
-                    }
-                    case "Struct": {
-                        if (DEBUG) {
-                            process.stderr.write(`recurse into ${currentFieldType}`);
-                        }
-                        for (const field of currentFieldType.fields) {
-                            if (helper(stack.concat({
-                                structType: currentFieldType,
-                                field,
-                            }))) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    }
-                    case "Intersection":
-                    case "Union": {
-                        if (DEBUG) {
-                            process.stderr.write(`recurse into ${currentFieldType}`);
-                        }
-                        for (const member of currentFieldType.members) {
-                            if (helper(stack.concat({
-                                field,
-                                fieldType: fieldType.concat(member.type),
-                                structType,
-                            }))) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    }
-                    case "DefaultValue":
-                    case "List":
-                    case "Option":
-                    case "Set":
-                        return helper(stack.concat({
-                            field,
-                            fieldType: fieldType.concat(currentFieldType.itemType),
-                            structType,
-                        }));
-                }
-            }
-            return helper([{ structType: rootStructType, field: rootField }]);
-        }
-        toJSON() {
-            return {
-                comment: this.comment.extract(),
-                description: this.description.extract(),
-                label: this.label.extract(),
-                mutable: this.mutable ? true : undefined,
-                name: this.name,
-                order: this.order,
-                path: PropertyPath.toString(this.path),
-                recursive: this.recursive ? true : undefined,
-                shapeIdentifier: this.shapeIdentifier,
-                type: this.type.toJSON(),
-            };
-        }
-        toString() {
-            return JSON.stringify(this.toJSON());
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Field.prototype, "recursive", null);
-    StructType.Field = Field;
-})(StructType || (StructType = {}));
-//# sourceMappingURL=StructType.js.map

package/dist/ast/StructUnionType.d.ts

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

package/dist/ast/StructUnionType.js

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

package/dist/ast/TermType.d.ts

@@ -1,14 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { NodeKind } from "@shaclmate/shacl-ast";
-import { AbstractTermType } from "./AbstractTermType.js";
-/**
- * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
- */
-export declare class TermType extends AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode> {
-    readonly kind = "Term";
-    readonly nodeKinds: ReadonlySet<NodeKind>;
-    constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode>>[0] & {
-        nodeKinds: ReadonlySet<NodeKind>;
-    });
-}
-//# sourceMappingURL=TermType.d.ts.map

package/dist/ast/TermType.js

@@ -1,16 +0,0 @@
-import { invariant } from "ts-invariant";
-import { AbstractTermType } from "./AbstractTermType.js";
-/**
- * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
- */
-export class TermType extends AbstractTermType {
-    kind = "Term";
-    nodeKinds;
-    constructor({ nodeKinds, ...superParameters }) {
-        super(superParameters);
-        this.nodeKinds = nodeKinds;
-        invariant(this.nodeKinds.has("Literal") &&
-            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
-    }
-}
-//# sourceMappingURL=TermType.js.map

package/dist/ast/Type.d.ts

@@ -1,20 +0,0 @@
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { DefaultValueType } from "./DefaultValueType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IntersectionType } from "./IntersectionType.js";
-import type { IriType } from "./IriType.js";
-import type { LazyOptionType } from "./LazyOptionType.js";
-import type { LazySetType } from "./LazySetType.js";
-import type { LazyType } from "./LazyType.js";
-import type { ListType } from "./ListType.js";
-import type { LiteralType } from "./LiteralType.js";
-import type { OptionType } from "./OptionType.js";
-import type { SetType } from "./SetType.js";
-import type { StructType } from "./StructType.js";
-import type { TermType } from "./TermType.js";
-import type { UnionType } from "./UnionType.js";
-export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType | UnionType;
-export declare namespace Type {
-    function equals(left: Type, right: Type): boolean;
-}
-//# sourceMappingURL=Type.d.ts.map

package/dist/ast/Type.js

@@ -1,42 +0,0 @@
-export var Type;
-(function (Type) {
-    function equals(left, right) {
-        if (left.kind !== right.kind) {
-            return false;
-        }
-        switch (left.kind) {
-            case "BlankNode":
-                return left.equals(right);
-            case "DefaultValue":
-                return left.equals(right);
-            case "Identifier":
-                return left.equals(right);
-            case "Intersection":
-                return left.equals(right);
-            case "Iri":
-                return left.equals(right);
-            case "Literal":
-                return left.equals(right);
-            case "LazyOption":
-                return left.equals(right);
-            case "LazySet":
-                return left.equals(right);
-            case "Lazy":
-                return left.equals(right);
-            case "List":
-                return left.equals(right);
-            case "Struct":
-                return left.equals(right);
-            case "Option":
-                return left.equals(right);
-            case "Term":
-                return left.equals(right);
-            case "Union":
-                return left.equals(right);
-            case "Set":
-                return left.equals(right);
-        }
-    }
-    Type.equals = equals;
-})(Type || (Type = {}));
-//# sourceMappingURL=Type.js.map

package/dist/ast/UnionType.d.ts

@@ -1,30 +0,0 @@
-import type { Maybe } from "purify-ts";
-import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { StructUnionType } from "./StructUnionType.js";
-/**
- * A disjunction/union of types, corresponding to an sh:xone.
- */
-export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
-    readonly kind = "Union";
-    isStructUnionType(): this is StructUnionType;
-    toJSON(): {
-        members: {
-            discriminantValue: string | number | undefined;
-            type: any;
-        }[] | undefined;
-        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 UnionType {
-    interface Member<TypeT extends UnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {
-        readonly discriminantValue: Maybe<number | string>;
-    }
-    type MemberType = AbstractCompoundType.MemberType;
-    const isMemberType: typeof AbstractCompoundType.isMemberType;
-}
-//# sourceMappingURL=UnionType.d.ts.map

package/dist/ast/UnionType.js

@@ -1,27 +0,0 @@
-import { AbstractCompoundType } from "./AbstractCompoundType.js";
-/**
- * A disjunction/union of types, corresponding to an sh:xone.
- */
-export class UnionType extends AbstractCompoundType {
-    kind = "Union";
-    isStructUnionType() {
-        return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "Struct" ||
-                (member.type.kind === "Union" && member.type.isStructUnionType())));
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            members: !this.recursive
-                ? this.members.map((member) => ({
-                    discriminantValue: member.discriminantValue.extract(),
-                    type: member.type.toJSON(),
-                }))
-                : undefined,
-        };
-    }
-}
-(function (UnionType) {
-    UnionType.isMemberType = AbstractCompoundType.isMemberType;
-})(UnionType || (UnionType = {}));
-//# sourceMappingURL=UnionType.js.map

package/dist/ast/equals.d.ts

@@ -1,12 +0,0 @@
-import type { Term } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-type EqualsFunction<T> = (left: T, right: T) => boolean;
-export declare function arrayEquals<T>(elementEquals: EqualsFunction<T>): EqualsFunction<readonly T[]>;
-export declare function dateEquals(left: Date, right: Date): boolean;
-export declare function maybeEquals<T>(valueEquals: EqualsFunction<T>): EqualsFunction<Maybe<T>>;
-export declare function recordEquals<KeyT extends keyof any, ValueT>(valueEquals: EqualsFunction<ValueT>): EqualsFunction<Record<KeyT, ValueT>>;
-export declare function setEquals<T>(elementEquals: EqualsFunction<T>): EqualsFunction<ReadonlySet<T>>;
-export declare function strictEquals<T>(left: T, right: T): boolean;
-export declare function termEquals(left: Term, right: Term): boolean;
-export {};
-//# sourceMappingURL=equals.d.ts.map

package/dist/ast/equals.js

@@ -1,65 +0,0 @@
-export function arrayEquals(elementEquals) {
-    return (left, right) => {
-        if (left.length !== right.length) {
-            return false;
-        }
-        for (let i = 0; i < left.length; i++) {
-            if (!elementEquals(left[i], right[i])) {
-                return false;
-            }
-        }
-        return true;
-    };
-}
-export function dateEquals(left, right) {
-    return left.getTime() === right.getTime();
-}
-export function maybeEquals(valueEquals) {
-    return (left, right) => {
-        if (left.isJust()) {
-            if (right.isJust()) {
-                return valueEquals(left.unsafeCoerce(), right.unsafeCoerce());
-            }
-            return false;
-        }
-        if (right.isJust()) {
-            return false;
-        }
-        return true;
-    };
-}
-export function recordEquals(valueEquals) {
-    return (left, right) => {
-        const leftKeys = Object.keys(left);
-        const rightKeys = Object.keys(right);
-        if (leftKeys.length !== rightKeys.length) {
-            return false;
-        }
-        for (const leftKey of leftKeys) {
-            const leftValue = left[leftKey];
-            const rightValue = right[leftKey];
-            if (rightValue === undefined) {
-                return false;
-            }
-            if (!valueEquals(leftValue, rightValue)) {
-                return false;
-            }
-        }
-        return true;
-    };
-}
-export function setEquals(elementEquals) {
-    return (left, right) => {
-        if (left.size !== right.size) {
-            return false;
-        }
-        return arrayEquals(elementEquals)([...left], [...right]);
-    };
-}
-export function strictEquals(left, right) {
-    return left === right;
-}
-export function termEquals(left, right) {
-    return left.equals(right);
-}
-//# sourceMappingURL=equals.js.map

package/dist/ast/index.d.ts

@@ -1,21 +0,0 @@
-export * from "./Ast.js";
-export * from "./BlankNodeType.js";
-export * from "./DefaultValueType.js";
-export * from "./IdentifierType.js";
-export * from "./IntersectionType.js";
-export * from "./IriType.js";
-export * from "./LazyOptionType.js";
-export * from "./LazySetType.js";
-export * from "./LazyType.js";
-export * from "./ListType.js";
-export * from "./LiteralType.js";
-export * from "./OptionType.js";
-export * from "./SetType.js";
-export * from "./StructCompoundType.js";
-export * from "./StructIntersectionType.js";
-export * from "./StructType.js";
-export * from "./StructUnionType.js";
-export * from "./TermType.js";
-export * from "./Type.js";
-export * from "./UnionType.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/ast/index.js

@@ -1,21 +0,0 @@
-export * from "./Ast.js";
-export * from "./BlankNodeType.js";
-export * from "./DefaultValueType.js";
-export * from "./IdentifierType.js";
-export * from "./IntersectionType.js";
-export * from "./IriType.js";
-export * from "./LazyOptionType.js";
-export * from "./LazySetType.js";
-export * from "./LazyType.js";
-export * from "./ListType.js";
-export * from "./LiteralType.js";
-export * from "./OptionType.js";
-export * from "./SetType.js";
-export * from "./StructCompoundType.js";
-export * from "./StructIntersectionType.js";
-export * from "./StructType.js";
-export * from "./StructUnionType.js";
-export * from "./TermType.js";
-export * from "./Type.js";
-export * from "./UnionType.js";
-//# sourceMappingURL=index.js.map

package/dist/generators/AstJsonGenerator.d.ts

@@ -1,6 +0,0 @@
-import type * as ast from "../ast/index.js";
-import type { Generator } from "./Generator.js";
-export declare class AstJsonGenerator implements Generator {
-    generate(ast: ast.Ast): string;
-}
-//# sourceMappingURL=AstJsonGenerator.d.ts.map

package/dist/generators/AstJsonGenerator.js

@@ -1,15 +0,0 @@
-export class AstJsonGenerator {
-    generate(ast) {
-        return JSON.stringify({
-            namedTypes: ast.namedTypes.map((namedType) => ({
-                ...namedType.toJSON(),
-                ...(namedType.kind === "Struct"
-                    ? {
-                        properties: namedType.fields.map((property) => property.toJSON()),
-                    }
-                    : {}),
-            })),
-        }, undefined, 2);
-    }
-}
-//# sourceMappingURL=AstJsonGenerator.js.map

package/dist/generators/Cx2Generator.d.ts

@@ -1,10 +0,0 @@
-import type { Ast } from "../ast/Ast.js";
-import type { Generator } from "./Generator.js";
-export declare class Cx2Generator implements Generator {
-    private readonly visualProperties;
-    constructor(options?: {
-        visualProperties?: Record<string, unknown>;
-    });
-    generate(ast: Ast): string;
-}
-//# sourceMappingURL=Cx2Generator.d.ts.map