@shaclmate/compiler 4.0.98 → 4.0.99

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

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

@@ -1,273 +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 { 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.FromJsonFunction}<${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.ToJsonFunction}<${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/ReferenceCallable.d.ts

@@ -1,14 +0,0 @@
-import { AbstractCallable } from "./AbstractCallable.js";
-import type { Snippet } from "./Snippet.js";
-import { type Code } from "./ts-poet-wrapper.js";
-/**
- * A callable that's a reference to a snippet, an import, or a global function.
- *
- * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
- */
-export declare class ReferenceCallable extends AbstractCallable {
-    readonly annotatedUsage: Code;
-    readonly unannotatedUsage: Code;
-    constructor(reference: Code | Snippet);
-}
-//# sourceMappingURL=ReferenceCallable.d.ts.map

package/dist/generators/ts/ReferenceCallable.js

@@ -1,16 +0,0 @@
-import { AbstractCallable } from "./AbstractCallable.js";
-import { code } from "./ts-poet-wrapper.js";
-/**
- * A callable that's a reference to a snippet, an import, or a global function.
- *
- * Callers assume the referent carries its own type annotations, so there's no distinction between annotated and unannotated usage.
- */
-export class ReferenceCallable extends AbstractCallable {
-    annotatedUsage;
-    unannotatedUsage;
-    constructor(reference) {
-        super();
-        this.annotatedUsage = this.unannotatedUsage = code `${reference}`;
-    }
-}
-//# sourceMappingURL=ReferenceCallable.js.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts

@@ -1,5 +0,0 @@
-import type { AbstractDiscriminatedUnionType } from "../AbstractDiscriminatedUnionType.js";
-import type { Type } from "../Type.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function AbstractDiscriminatedUnionType_schemaTypeExpression<MemberTypeT extends Type>(this: AbstractDiscriminatedUnionType<MemberTypeT>): Code;
-//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/_AbstractDiscriminatedUnionType/AbstractDiscriminatedUnionType_schemaTypeExpression.js

@@ -1,11 +0,0 @@
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
-export function AbstractDiscriminatedUnionType_schemaTypeExpression() {
-    return code `${{
-        kind: this.kind,
-        members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
-            discriminantValues: code `readonly (number | string)[]`,
-            type: type.schemaType,
-        }}`), { on: ";" })} }`,
-    }}`;
-}
-//# sourceMappingURL=AbstractDiscriminatedUnionType_schemaTypeExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaExpression.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_schemaExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_schemaExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaExpression.js

@@ -1,15 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaExpression() {
-    const schema = {};
-    const properties = {};
-    for (const property of this.properties) {
-        property.schema.ifJust((propertySchema) => {
-            properties[property.name] = propertySchema;
-        });
-    }
-    invariant(Object.keys(properties).length > 0);
-    schema["properties"] = properties;
-    return code `${schema} as const`;
-}
-//# sourceMappingURL=ObjectType_schemaExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_schemaTypeExpression(this: ObjectType): Code;
-//# sourceMappingURL=ObjectType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_schemaTypeExpression.js

@@ -1,15 +0,0 @@
-import { invariant } from "ts-invariant";
-import { code } from "../ts-poet-wrapper.js";
-export function ObjectType_schemaTypeExpression() {
-    const schemaType = {};
-    const properties = {};
-    for (const property of this.properties) {
-        property.schemaType.ifJust((propertySchemaType) => {
-            properties[property.name] = propertySchemaType;
-        });
-    }
-    invariant(Object.keys(properties).length > 0);
-    schemaType["properties"] = properties;
-    return code `${schemaType}`;
-}
-//# sourceMappingURL=ObjectType_schemaTypeExpression.js.map