@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/AbstractStructuredType.d.ts

@@ -0,0 +1,71 @@
+import { AbstractType } from "./AbstractType.js";
+import type { Callable } from "./Callable.js";
+import type { CodeThunk } from "./CodeThunk.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for AbstractCompoundType and StructType.
+ */
+export declare abstract class AbstractStructuredType extends AbstractType {
+    get equalsFunction(): Callable;
+    get filterFunction(): Callable;
+    get filterType(): Code;
+    get fromJsonValueFunction(): Callable;
+    get fromJsonObjectFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
+    get hashFunction(): Callable;
+    get schemaType(): Code;
+    get toJsonValueFunction(): Callable;
+    get toJsonObjectFunction(): Callable;
+    get toLoggableFunction(): Callable;
+    get toRdfResourceValuesFunction(): Callable;
+    get toStringFunction(): Callable;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
+    protected get toRdfResourceValueTypesExpression(): Code;
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected _function({ type, unannotatedExpression, unqualifiedName, }: {
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+        unqualifiedName: string;
+    }): Callable;
+    protected abstract equalsFunctionExpression(): Code;
+    protected equalsFunctionType(): Code;
+    protected abstract filterFunctionExpression(): Code;
+    protected filterFunctionType(): Code;
+    protected abstract filterTypeExpression(): Code;
+    protected abstract fromJsonObjectFunctionExpression(): Code;
+    protected fromJsonObjectFunctionType(): Code;
+    protected abstract fromRdfResourceValuesFunctionExpression(): Code;
+    protected fromRdfResourceValuesFunctionType(): Code;
+    protected abstract hashFunctionExpression(): Code;
+    protected hashFunctionType(): Code;
+    protected abstract schemaTypeExpression(): Code;
+    protected staticModuleDeclarations(name: string): Record<string, Code>;
+    protected abstract toJsonObjectFunctionExpression(): Code;
+    protected toJsonObjectFunctionType(): Code;
+    protected abstract toLoggableFunctionExpression(): Code;
+    protected toLoggableFunctionType(): Code;
+    protected abstract toRdfResourceValuesFunctionExpression(): Code;
+    protected toRdfResourceValuesFunctionType(): Code;
+    protected abstract toStringFunctionExpression(): Code;
+    protected toStringFunctionType(): Code;
+    protected abstract valueSparqlConstructTriplesFunctionExpression(): Code;
+    protected valueSparqlConstructTriplesType(): Code;
+    protected abstract valueSparqlWherePatternsFunctionExpression(): Code;
+    protected valueSparqlWherePatternsFunctionType(): Code;
+}
+export declare namespace AbstractStructuredType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsonType = AbstractType.JsonType;
+    type JsType = AbstractType.JsType;
+}
+//# sourceMappingURL=AbstractStructuredType.d.ts.map

package/dist/generators/ts/AbstractStructuredType.js

@@ -0,0 +1,273 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { DeclaredCallable } from "./DeclaredCallable.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for AbstractCompoundType and StructType.
+ */
+export class AbstractStructuredType extends AbstractType {
+    get equalsFunction() {
+        return this._function({
+            type: () => this.equalsFunctionType(),
+            unannotatedExpression: () => this.equalsFunctionExpression(),
+            unqualifiedName: "equals",
+        });
+    }
+    get filterFunction() {
+        return this._function({
+            type: () => this.filterFunctionType(),
+            unannotatedExpression: () => this.filterFunctionExpression(),
+            unqualifiedName: "filter",
+        });
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefaultLazy(() => this.filterTypeExpression());
+    }
+    get fromJsonValueFunction() {
+        return this.fromJsonObjectFunction;
+    }
+    get fromJsonObjectFunction() {
+        return this._function({
+            type: () => this.fromJsonObjectFunctionType(),
+            unannotatedExpression: () => this.fromJsonObjectFunctionExpression(),
+            unqualifiedName: "fromJson",
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.fromRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.fromRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "fromRdfResourceValues",
+        });
+    }
+    get hashFunction() {
+        return this._function({
+            type: () => this.hashFunctionType(),
+            unannotatedExpression: () => this.hashFunctionExpression(),
+            unqualifiedName: "hash",
+        });
+    }
+    get schemaType() {
+        return this.name
+            .map((name) => code `${name}.Schema`)
+            .orDefaultLazy(() => this.schemaTypeExpression());
+    }
+    get toJsonValueFunction() {
+        return this.toJsonObjectFunction;
+    }
+    get toJsonObjectFunction() {
+        return this._function({
+            type: () => this.toJsonObjectFunctionType(),
+            unannotatedExpression: () => this.toJsonObjectFunctionExpression(),
+            unqualifiedName: "toJson",
+        });
+    }
+    get toLoggableFunction() {
+        return this._function({
+            type: () => this.toLoggableFunctionType(),
+            unannotatedExpression: () => this.toLoggableFunctionExpression(),
+            unqualifiedName: "toLoggable",
+        });
+    }
+    get toRdfResourceValuesFunction() {
+        return this._function({
+            type: () => this.toRdfResourceValuesFunctionType(),
+            unannotatedExpression: () => this.toRdfResourceValuesFunctionExpression(),
+            unqualifiedName: "toRdfResourceValues",
+        });
+    }
+    get toStringFunction() {
+        return this._function({
+            type: () => this.toStringFunctionType(),
+            unannotatedExpression: () => this.toStringFunctionExpression(),
+            unqualifiedName: `${this.configuration.syntheticNamePrefix}toString`,
+        });
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this._function({
+            type: () => this.valueSparqlConstructTriplesType(),
+            unannotatedExpression: () => this.valueSparqlConstructTriplesFunctionExpression(),
+            unqualifiedName: "valueSparqlConstructTriples",
+        });
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this._function({
+            type: () => this.valueSparqlWherePatternsFunctionType(),
+            unannotatedExpression: () => this.valueSparqlWherePatternsFunctionExpression(),
+            unqualifiedName: "valueSparqlWherePatterns",
+        });
+    }
+    get toRdfResourceValueTypesExpression() {
+        return joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${this.reusables.imports.BlankNode}`;
+                case "Literal":
+                    return code `${this.reusables.imports.Literal}`;
+                case "NamedNode":
+                    return code `${this.reusables.imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " });
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    toLoggableExpression({ variables, }) {
+        return code `${this.toLoggableFunction.unannotatedUsage}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.toRdfResourceValuesFunction.unannotatedUsage}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.toStringFunction.unannotatedUsage}(${variables.value})`;
+    }
+    _function({ type, unannotatedExpression, unqualifiedName, }) {
+        return this.name
+            .map((name) => new DeclaredCallable({
+            qualifiedName: [name, unqualifiedName],
+            type,
+            unannotatedExpression,
+        }))
+            .orDefault(new InlineCallable(unannotatedExpression, { type }));
+    }
+    equalsFunctionType() {
+        return code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`;
+    }
+    filterFunctionType() {
+        return code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`;
+    }
+    fromJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.expression}, undefined>`;
+    }
+    fromRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`;
+    }
+    hashFunctionType() {
+        return code `${this.reusables.snippets.HashFunction}<${this.expression}>`;
+    }
+    staticModuleDeclarations(name) {
+        const staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
+        function addFunctionDeclaration(function_) {
+            invariant(function_ instanceof DeclaredCallable);
+            staticModuleDeclarations[function_.unqualifiedName] =
+                code `export ${function_.declaration}`;
+        }
+        if (this.configuration.features.has("Object.equals")) {
+            addFunctionDeclaration(this.equalsFunction);
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations["Filter"] =
+                code `export type Filter = ${this.filterTypeExpression()};`;
+            addFunctionDeclaration(this.filterFunction);
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            // Hash functions take a generic parameter and const declaration like this can't have type parameters.
+            addFunctionDeclaration(this.hashFunction);
+        }
+        if (this.configuration.features.has("Object.JSON.type")) {
+            this.jsonObjectType.declaration.ifJust((jsonTypeDeclaration) => {
+                staticModuleDeclarations["JSON"] = jsonTypeDeclaration;
+            });
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
+            addFunctionDeclaration(this.fromJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            addFunctionDeclaration(this.fromRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            addFunctionDeclaration(this.valueSparqlConstructTriplesFunction);
+            addFunctionDeclaration(this.valueSparqlWherePatternsFunction);
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            addFunctionDeclaration(this.toJsonObjectFunction);
+        }
+        if (this.configuration.features.has("Object.toLoggable")) {
+            addFunctionDeclaration(this.toLoggableFunction);
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            addFunctionDeclaration(this.toRdfResourceValuesFunction);
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            addFunctionDeclaration(this.toStringFunction);
+        }
+        return staticModuleDeclarations;
+    }
+    toJsonObjectFunctionType() {
+        return code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonObjectType.expression}>`;
+    }
+    toLoggableFunctionType() {
+        return code `${this.reusables.snippets.ToLoggableFunction}<${this.expression}>`;
+    }
+    toRdfResourceValuesFunctionType() {
+        return code `${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}, ${this.toRdfResourceValueTypesExpression}>`;
+    }
+    toStringFunctionType() {
+        return code `${this.reusables.snippets.ToStringFunction}<${this.expression}>`;
+    }
+    valueSparqlConstructTriplesType() {
+        return code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>`;
+    }
+    valueSparqlWherePatternsFunctionType() {
+        return code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "toJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "toLoggableFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "toRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "toStringFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractStructuredType.prototype, "toRdfResourceValueTypesExpression", null);
+//# sourceMappingURL=AbstractStructuredType.js.map

package/dist/generators/ts/AbstractTermType.d.ts

@@ -1,7 +1,8 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
@@ -12,26 +13,24 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    readonly equalsFunction: Code;
+    readonly equalsFunction: ReferenceCallable;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
-    readonly hashFunction: Code;
+    readonly hashFunction: ReferenceCallable;
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
-    readonly validationFunction: Maybe<Code>;
+    readonly validationFunction: AbstractType["validationFunction"];
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get referencesNamedType(): boolean;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
-    get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
-    get valueSparqlConstructTriplesFunction(): Code;
+    get toRdfResourceValueTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
+    get valueSparqlConstructTriplesFunction(): Callable;
     protected get schemaInitializers(): readonly Code[];
-    jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     /**
@@ -43,11 +42,10 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
 }
 export declare namespace AbstractTermType {
     type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
     type JsType = AbstractType.JsType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/generators/ts/AbstractTermType.js

@@ -8,6 +8,8 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
@@ -18,10 +20,10 @@ import { arrayOf, code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export class AbstractTermType extends AbstractType {
-    equalsFunction = code `${this.reusables.snippets.booleanEquals}`;
+    equalsFunction = new ReferenceCallable(this.reusables.snippets.booleanEquals);
     graphqlArgs = Maybe.empty();
     hasValues;
-    hashFunction = code `${this.reusables.snippets.hashTerm}`;
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashTerm);
     in_;
     mutable = false;
     recursive = false;
@@ -31,13 +33,6 @@ export class AbstractTermType extends AbstractType {
         this.hasValues = hasValues;
         this.in_ = in_;
     }
-    get discriminantProperty() {
-        return Maybe.of({
-            jsonName: "termType",
-            name: "termType",
-            values: [...this.nodeKinds].map(NodeKind.toTermType),
-        });
-    }
     get referencesNamedType() {
         return this.name.isJust();
     }
@@ -45,10 +40,10 @@ export class AbstractTermType extends AbstractType {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
     get toRdfResourceValueTypes() {
-        return new Set([...this.nodeKinds].map(NodeKind.toTermType));
+        return this.termTypes;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `((_: object) => [])`;
+        return new InlineCallable(code `((_: object) => [])`);
     }
     get schemaInitializers() {
         let initializers = super.schemaInitializers;
@@ -60,9 +55,6 @@ export class AbstractTermType extends AbstractType {
         }
         return initializers;
     }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${variables.value}]`;
     }
@@ -78,9 +70,6 @@ export class AbstractTermType extends AbstractType {
         return this.rdfjsTermExpression(term);
     }
 }
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);
@@ -92,6 +81,5 @@ __decorate([
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);
 (function (AbstractTermType) {
     AbstractTermType.GraphqlType = AbstractType.GraphqlType;
-    AbstractTermType.JsonType = AbstractType.JsonType;
 })(AbstractTermType || (AbstractTermType = {}));
 //# sourceMappingURL=AbstractTermType.js.map