@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/ast/AbstractConstruct.d.ts

@@ -0,0 +1,25 @@
+import { Maybe } from "purify-ts";
+/**
+ * Abstract base class for operations, services, and types.
+ */
+export declare abstract class AbstractConstruct {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Human-readable label from rdfs:label.
+     */
+    readonly label: Maybe<string>;
+    constructor({ comment, label, }: {
+        comment: Maybe<string>;
+        label: Maybe<string>;
+    });
+    equals(other: AbstractConstruct): boolean;
+    toJSON(): {
+        comment: string | undefined;
+        label: string | undefined;
+    };
+    toString(): string;
+}
+//# sourceMappingURL=AbstractConstruct.d.ts.map

package/dist/ast/AbstractConstruct.js

@@ -0,0 +1,38 @@
+import { Maybe } from "purify-ts";
+import { maybeEquals, strictEquals } from "./equals.js";
+/**
+ * Abstract base class for operations, services, and types.
+ */
+export class AbstractConstruct {
+    /**
+     * Documentation comment from rdfs:comment.
+     */
+    comment = Maybe.empty();
+    /**
+     * Human-readable label from rdfs:label.
+     */
+    label = Maybe.empty();
+    constructor({ comment, label, }) {
+        this.comment = comment;
+        this.label = label;
+    }
+    equals(other) {
+        if (!maybeEquals(strictEquals)(this.comment, other.comment)) {
+            return false;
+        }
+        if (!maybeEquals(strictEquals)(this.label, other.label)) {
+            return false;
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            comment: this.comment.extract(),
+            label: this.label.extract(),
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+//# sourceMappingURL=AbstractConstruct.js.map

package/dist/ast/AbstractContainerType.d.ts

@@ -29,12 +29,12 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     equals(other: AbstractContainerType<ItemTypeT>): boolean;
     toJSON(): {
         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>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace AbstractContainerType {

package/dist/ast/AbstractLazyType.d.ts

@@ -21,92 +21,70 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
     toJSON(): {
         partialType: {
             fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierType: {
-                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                nodeKinds: NodeKind[];
-                comment: string | undefined;
-                kind: string;
-                label: string | undefined;
-                name: string | undefined;
-                recursive: boolean | undefined;
-                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-            };
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | 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>;
+            comment: string | undefined;
+            label: string | undefined;
         } | {
             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>;
+            comment: string | undefined;
+            label: string | 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>;
+            comment: string | undefined;
+            label: string | undefined;
         };
         resolveType: {
             fromRdfType: import("@rdfjs/types").NamedNode<string> | undefined;
-            identifierType: {
-                hasValues: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                in: readonly import("@rdfjs/types").NamedNode<string>[] | undefined;
-                nodeKinds: NodeKind[];
-                comment: string | undefined;
-                kind: string;
-                label: string | undefined;
-                name: string | undefined;
-                recursive: boolean | undefined;
-                shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
-            };
             synthetic: boolean | undefined;
             toRdfTypes: readonly import("@rdfjs/types").NamedNode<string>[] | 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>;
+            comment: string | undefined;
+            label: string | undefined;
         } | {
             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>;
+            comment: string | undefined;
+            label: string | 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>;
+            comment: string | undefined;
+            label: string | 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>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace AbstractLazyType {

package/dist/ast/AbstractTermType.d.ts

@@ -22,12 +22,12 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
         hasValues: readonly ConstantTermT[] | undefined;
         in: readonly ConstantTermT[] | undefined;
         nodeKinds: import("@shaclmate/shacl-ast").NodeKind[];
-        comment: string | undefined;
         kind: string;
-        label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
         shapeIdentifier: BlankNode | NamedNode<string>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/ast/AbstractType.d.ts

@@ -1,22 +1,15 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
+import type { Maybe } from "purify-ts";
+import { AbstractConstruct } from "./AbstractConstruct.js";
 /**
  * Abstract base class for Types.
  */
-export declare abstract class AbstractType {
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    readonly comment: Maybe<string>;
+export declare abstract class AbstractType extends AbstractConstruct {
     /**
      * Type discriminant
      */
     abstract readonly kind: string;
-    /**
-     * Human-readable label from rdfs:label.
-     */
-    readonly label: Maybe<string>;
     /**
      * Name of this type, from shaclmate:name or sh:name.
      */
@@ -35,21 +28,18 @@ export declare abstract class AbstractType {
      * Identifier of the shape this type was derived from.
      */
     readonly shapeIdentifier: BlankNode | NamedNode;
-    constructor({ comment, label, name, shapeIdentifier, }: {
-        comment: Maybe<string>;
-        label: Maybe<string>;
+    constructor({ name, shapeIdentifier, ...superParameters }: {
         name: Maybe<string>;
         shapeIdentifier: BlankNode | NamedNode;
-    });
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
     equals(other: AbstractType): boolean;
     toJSON(): {
-        comment: string | undefined;
         kind: string;
-        label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
         shapeIdentifier: BlankNode | NamedNode<string>;
+        comment: string | undefined;
+        label: string | undefined;
     };
-    toString(): string;
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/ast/AbstractType.js

@@ -1,17 +1,9 @@
-import { Maybe } from "purify-ts";
+import { AbstractConstruct } from "./AbstractConstruct.js";
 import { maybeEquals, strictEquals } from "./equals.js";
 /**
  * Abstract base class for Types.
  */
-export class AbstractType {
-    /**
-     * Documentation comment from rdfs:comment.
-     */
-    comment = Maybe.empty();
-    /**
-     * Human-readable label from rdfs:label.
-     */
-    label = Maybe.empty();
+export class AbstractType extends AbstractConstruct {
     /**
      * Name of this type, from shaclmate:name or sh:name.
      */
@@ -20,17 +12,13 @@ export class AbstractType {
      * Identifier of the shape this type was derived from.
      */
     shapeIdentifier;
-    constructor({ comment, label, name, shapeIdentifier, }) {
-        this.comment = comment;
-        this.label = label;
+    constructor({ name, shapeIdentifier, ...superParameters }) {
+        super(superParameters);
         this.name = name;
         this.shapeIdentifier = shapeIdentifier;
     }
     equals(other) {
-        if (!maybeEquals(strictEquals)(this.comment, other.comment)) {
-            return false;
-        }
-        if (!maybeEquals(strictEquals)(this.label, other.label)) {
+        if (!super.equals(other)) {
             return false;
         }
         if (!maybeEquals(strictEquals)(this.name, other.name)) {
@@ -40,16 +28,12 @@ export class AbstractType {
     }
     toJSON() {
         return {
-            comment: this.comment.extract(),
+            ...super.toJSON(),
             kind: this.kind,
-            label: this.label.extract(),
             name: this.name.extract(),
             recursive: this.recursive ? true : undefined,
             shapeIdentifier: this.shapeIdentifier,
         };
     }
-    toString() {
-        return JSON.stringify(this.toJSON());
-    }
 }
 //# sourceMappingURL=AbstractType.js.map

package/dist/ast/Ast.d.ts

@@ -1,6 +1,8 @@
+import type { Service } from "./Service.js";
 import type { Type } from "./Type.js";
 export interface Ast {
     readonly lazyTypesCount: number;
     readonly namedTypes: readonly Type[];
+    readonly services: readonly Service[];
 }
 //# sourceMappingURL=Ast.d.ts.map

package/dist/ast/DefaultValueType.d.ts

@@ -20,12 +20,12 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     toJSON(): {
         defaultValue: Literal | NamedNode<string>;
         itemType: any;
-        comment: string | undefined;
         kind: string;
-        label: string | undefined;
         name: string | undefined;
         recursive: boolean | undefined;
         shapeIdentifier: import("@rdfjs/types").BlankNode | NamedNode<string>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace DefaultValueType {

package/dist/ast/DiscriminatedUnionType.d.ts

@@ -12,12 +12,12 @@ export declare class DiscriminatedUnionType<MemberTypeT extends DiscriminatedUni
             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>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace DiscriminatedUnionType {

package/dist/ast/DiscriminatedUnionType.js

@@ -8,7 +8,9 @@ export class DiscriminatedUnionType extends AbstractCompoundType {
         return (this.members.length > 0 &&
             this.members.every((member) => member.type.kind === "Struct" ||
                 (member.type.kind === "DiscriminatedUnion" &&
-                    member.type.isStructDiscriminatedUnionType())));
+                    member.type.isStructDiscriminatedUnionType()) ||
+                (member.type.kind === "Intersection" &&
+                    member.type.isStructIntersectionType())));
     }
     toJSON() {
         return {

package/dist/ast/LiteralType.d.ts

@@ -29,12 +29,12 @@ export declare class LiteralType extends AbstractTermType<Literal, Literal> {
         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>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/ast/Operation.d.ts

@@ -0,0 +1,67 @@
+import type { Maybe } from "purify-ts";
+import type * as uriTemplate from "uri-template";
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import type { OptionType } from "./OptionType.js";
+import type { StructDiscriminatedUnionType } from "./StructDiscriminatedUnionType.js";
+import type { StructType } from "./StructType.js";
+export declare class Operation extends AbstractConstruct {
+    /**
+     * Bindings of this operation.
+     */
+    readonly bindings: readonly Operation.Binding[];
+    /**
+     * Error(s) returned by this operation.
+     */
+    readonly error: Maybe<Operation.Error>;
+    /**
+     * Name of this operation.
+     */
+    readonly name: string;
+    /**
+     * Parameter type.
+     */
+    readonly parameter: Maybe<Operation.Parameter>;
+    /**
+     * Result type.
+     */
+    readonly result: Maybe<Operation.Result>;
+    constructor({ bindings, error, name, parameter, result, ...superParameters }: {
+        bindings: readonly Operation.Binding[];
+        error: Maybe<Operation.Error>;
+        name: string;
+        parameter: Maybe<Operation.Parameter>;
+        result: Maybe<Operation.Result>;
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
+}
+export declare namespace Operation {
+    type Error = StructType | StructDiscriminatedUnionType;
+    interface HttpBinding {
+        readonly request: HttpBinding.Request;
+        readonly errorResponses: readonly HttpBinding.ErrorResponse[];
+        readonly resultResponse: HttpBinding.ResultResponse;
+    }
+    namespace HttpBinding {
+        interface Request {
+            readonly contentType: Maybe<string>;
+            readonly method: string;
+            readonly parameterSources: ReadonlyMap<string, Request.ParameterSource>;
+            readonly uriTemplate: ReturnType<typeof uriTemplate.parse>["ast"];
+        }
+        namespace Request {
+            type ParameterSource = "body" | "path" | "query";
+        }
+        interface ErrorResponse {
+            readonly contentType: "application/problem+json";
+            readonly error: StructType;
+            readonly statusCode: 500;
+        }
+        interface ResultResponse {
+            readonly contentType: Maybe<string>;
+            readonly statusCode: 200;
+        }
+    }
+    type Binding = HttpBinding;
+    type Parameter = StructType;
+    type Result = OptionType<StructType> | StructType;
+}
+//# sourceMappingURL=Operation.d.ts.map

package/dist/ast/Operation.js

@@ -0,0 +1,32 @@
+import { AbstractConstruct } from "./AbstractConstruct.js";
+export class Operation extends AbstractConstruct {
+    /**
+     * Bindings of this operation.
+     */
+    bindings;
+    /**
+     * Error(s) returned by this operation.
+     */
+    error;
+    /**
+     * Name of this operation.
+     */
+    name;
+    /**
+     * Parameter type.
+     */
+    parameter;
+    /**
+     * Result type.
+     */
+    result;
+    constructor({ bindings, error, name, parameter, result, ...superParameters }) {
+        super(superParameters);
+        this.bindings = bindings;
+        this.error = error;
+        this.name = name;
+        this.parameter = parameter;
+        this.result = result;
+    }
+}
+//# sourceMappingURL=Operation.js.map

package/dist/ast/Service.d.ts

@@ -0,0 +1,17 @@
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import type { Operation } from "./Operation.js";
+export declare class Service extends AbstractConstruct {
+    /**
+     * Name of this service.
+     */
+    readonly name: string;
+    /**
+     * Operations associated with this service.
+     */
+    readonly operations: readonly Operation[];
+    constructor({ name, operations, ...superParameters }: {
+        name: string;
+        operations: readonly Operation[];
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
+}
+//# sourceMappingURL=Service.d.ts.map

package/dist/ast/Service.js

@@ -0,0 +1,17 @@
+import { AbstractConstruct } from "./AbstractConstruct.js";
+export class Service extends AbstractConstruct {
+    /**
+     * Name of this service.
+     */
+    name;
+    /**
+     * Operations associated with this service.
+     */
+    operations;
+    constructor({ name, operations, ...superParameters }) {
+        super(superParameters);
+        this.name = name;
+        this.operations = operations;
+    }
+}
+//# sourceMappingURL=Service.js.map

package/dist/ast/SetType.d.ts

@@ -16,12 +16,12 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
         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>;
+        comment: string | undefined;
+        label: string | undefined;
     };
 }
 export declare namespace SetType {

package/dist/ast/StructCompoundType.d.ts

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

package/dist/ast/StructCompoundType.js

@@ -6,10 +6,10 @@ import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
 export var StructCompoundType;
 (function (StructCompoundType) {
-    function identifierType(objectCompoundType) {
+    function identifierType(structCompoundType) {
         const memberIdentifierTypeNodeKinds = new Set();
         const memberIdentifierTypesIn = new TermSet();
-        for (const memberType of memberStructTypes(objectCompoundType)) {
+        for (const memberType of memberStructTypes(structCompoundType)) {
             for (const nodeKind of memberType.identifierType.nodeKinds) {
                 memberIdentifierTypeNodeKinds.add(nodeKind);
             }
@@ -23,7 +23,7 @@ export var StructCompoundType;
                 comment: Maybe.empty(),
                 label: Maybe.empty(),
                 name: Maybe.empty(),
-                shapeIdentifier: objectCompoundType.shapeIdentifier,
+                shapeIdentifier: structCompoundType.shapeIdentifier,
             });
         }
         const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
@@ -33,7 +33,7 @@ export var StructCompoundType;
                     comment: Maybe.empty(),
                     label: Maybe.empty(),
                     name: Maybe.empty(),
-                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                    shapeIdentifier: structCompoundType.shapeIdentifier,
                 });
             case "IRI":
                 return new IriType({
@@ -42,7 +42,7 @@ export var StructCompoundType;
                     in_: [...memberIdentifierTypesIn],
                     label: Maybe.empty(),
                     name: Maybe.empty(),
-                    shapeIdentifier: objectCompoundType.shapeIdentifier,
+                    shapeIdentifier: structCompoundType.shapeIdentifier,
                 });
             default:
                 memberIdentifierTypeNodeKind;