@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/ast/StructType.js

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

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

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

package/dist/ast/TermType.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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