@shaclmate/compiler 4.0.97 → 4.0.99

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.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/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

package/dist/generators/ts/_snippets/snippets_FromJsonObjectFunction.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_FromJsonObjectFunction: SnippetFactory;
-//# sourceMappingURL=snippets_FromJsonObjectFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_FromJsonObjectFunction.js

@@ -1,21 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromJsonObjectFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromJsonObjectFunction`, code `\
-export type ${syntheticNamePrefix}FromJsonObjectFunction<JsonObjectT extends object, ValueT, ValueSchemaT> = 
-  [ValueSchemaT] extends [undefined]
-  ? (
-      jsonObject: JsonObjectT,
-      options?: {
-        context?: unknown;
-        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
-        schema?: unknown;
-      },
-    ) => ${imports.Either}<Error, ValueT>
-  : (
-      jsonObject: JsonObjectT,
-      options: {
-        context?: unknown;
-        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
-        schema: ValueSchemaT;
-      },
-    ) => ${imports.Either}<Error, ValueT>;`);
-//# sourceMappingURL=snippets_FromJsonObjectFunction.js.map

package/dist/generators/ts/_snippets/snippets_FromJsonValueFunction.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_FromJsonValueFunction: SnippetFactory;
-//# sourceMappingURL=snippets_FromJsonValueFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_FromJsonValueFunction.js

@@ -1,21 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_FromJsonValueFunction = ({ configuration, imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}FromJsonValueFunction`, code `\
-export type ${syntheticNamePrefix}FromJsonValueFunction<JsonValueT, ValueT, ValueSchemaT> = 
-  [ValueSchemaT] extends [undefined]
-  ? (
-      jsonValue: JsonValueT,
-      options?: {
-        context?: unknown;
-        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
-        schema?: unknown;
-      },
-    ) => ${imports.Either}<Error, ValueT>
-  : (
-      jsonValue: JsonValueT,
-      options: {
-        context?: unknown;
-        ${configuration.features.has("ObjectSet") ? code `objectSet?: ${syntheticNamePrefix}ObjectSet;` : ""}
-        schema: ValueSchemaT;
-      },
-    ) => ${imports.Either}<Error, ValueT>;`);
-//# sourceMappingURL=snippets_FromJsonValueFunction.js.map

package/dist/generators/ts/_snippets/snippets_ToJsonObjectFunction.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_ToJsonObjectFunction: SnippetFactory;
-//# sourceMappingURL=snippets_ToJsonObjectFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_ToJsonObjectFunction.js

@@ -1,3 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_ToJsonObjectFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ToJsonObjectFunction`, code `export type ${syntheticNamePrefix}ToJsonObjectFunction<T, JsonObjectT extends object> = (value: T) => JsonObjectT;`);
-//# sourceMappingURL=snippets_ToJsonObjectFunction.js.map

package/dist/generators/ts/_snippets/snippets_ToJsonValueFunction.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_ToJsonValueFunction: SnippetFactory;
-//# sourceMappingURL=snippets_ToJsonValueFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_ToJsonValueFunction.js

@@ -1,3 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_ToJsonValueFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ToJsonValueFunction`, code `export type ${syntheticNamePrefix}ToJsonValueFunction<T, JsonValueT> = (value: T) => JsonValueT;`);
-//# sourceMappingURL=snippets_ToJsonValueFunction.js.map

package/dist/generators/ts/_snippets/snippets_convertToInIri.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToInIri: SnippetFactory;
-//# sourceMappingURL=snippets_convertToInIri.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToInIri.js

@@ -1,11 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToInIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToInIri`, code `\
-function ${syntheticNamePrefix}convertToInIri<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
-  switch (typeof value) {
-    case "object":
-      return ${imports.Either}.of(value);
-    case "string":
-      return ${imports.Either}.of(${imports.dataFactory}.namedNode<IriT>(value));
-  }
-}`);
-//# sourceMappingURL=snippets_convertToInIri.js.map

package/dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_convertToInIriIdentifierProperty: SnippetFactory;
-//# sourceMappingURL=snippets_convertToInIriIdentifierProperty.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.js

@@ -1,17 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToInIriIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToInIriIdentifierProperty`, code `\
-function ${syntheticNamePrefix}convertToInIriIdentifierProperty<InIriT extends string>(identifier: (() => ${imports.NamedNode}<InIriT>) | ${imports.NamedNode}<InIriT> | InIriT, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, (() => ${imports.NamedNode}<InIriT>)> {
-  switch (typeof identifier) {
-    case "function":
-      return ${imports.Either}.of(identifier);
-    case "object": {
-      const captureIdentifier = identifier;
-      return ${imports.Either}.of(() => captureIdentifier);
-    }
-    case "string": {
-      const captureIdentifier = ${imports.dataFactory}.namedNode<InIriT>(identifier);
-      return ${imports.Either}.of(() => captureIdentifier);
-    }
-  }
-}`);
-//# sourceMappingURL=snippets_convertToInIriIdentifierProperty.js.map