@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -0,0 +1,140 @@
+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 { Maybe, NonEmptyList } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { removeUndefined } from "./removeUndefined.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class AbstractLazyObjectType extends AbstractType {
+    partialType;
+    resolveType;
+    runtimeClass;
+    discriminantProperty = Maybe.empty();
+    mutable = false;
+    typeofs = NonEmptyList(["object"]);
+    constructor({ partialType, resolveType, runtimeClass, ...superParameters }) {
+        super(superParameters);
+        this.partialType = partialType;
+        this.resolveType = resolveType;
+        this.runtimeClass = runtimeClass;
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof ${this.runtimeClass.rawName}`,
+                sourceTypeName: this.name,
+                sourceTypeof: "object",
+            },
+        ];
+    }
+    get equalsFunction() {
+        return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
+    }
+    get filterFunction() {
+        return code `((filter: ${this.filterType}, value: ${this.name}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
+    }
+    get filterType() {
+        return this.partialType.filterType;
+    }
+    get graphqlType() {
+        return this.resolveType.graphqlType;
+    }
+    get name() {
+        return this.runtimeClass.name;
+    }
+    get schema() {
+        return code `${removeUndefined(this.schemaObject)}`;
+    }
+    get schemaType() {
+        return code `${{
+            kind: this.kind,
+            partialType: this.partialType.schemaType,
+            resolveType: this.resolveType.schemaType,
+        }}`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlConstructTriplesFunction}({ schema: schema.partial(), ...otherParameters }))`;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.sparqlWherePatternsFunction}({ schema: schema.partial(), ...otherParameters }))`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            partial: code `() => (${this.partialType.schema})`,
+            // Commenting out to reduce schema size
+            // resolved: code`() => (${this.resolveType.schema})`,
+        };
+    }
+    hashStatements({ depth, variables, }) {
+        return this.partialType.hashStatements({
+            depth: depth + 1,
+            variables: {
+                ...variables,
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    jsonType(parameters) {
+        return this.partialType.jsonType(parameters);
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.partialType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        return this.partialType.jsonZodSchema(parameters);
+    }
+    toJsonExpression({ variables, }) {
+        return this.partialType.toJsonExpression({
+            variables: {
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    toRdfExpression({ variables, }) {
+        return this.partialType.toRdfExpression({
+            variables: {
+                ...variables,
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
+        invariant(resolvedObjectUnionType.memberTypes.length ===
+            partialObjectUnionType.memberTypes.length);
+        const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
+            return code `${resolvedObjectType.discriminantPropertyValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.resolvedObjectUnion })};`;
+        });
+        caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
+        return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "sparqlWherePatternsFunction", null);
+(function (AbstractLazyObjectType) {
+    AbstractLazyObjectType.GraphqlType = AbstractType.GraphqlType;
+    AbstractLazyObjectType.JsonType = AbstractType.JsonType;
+})(AbstractLazyObjectType || (AbstractLazyObjectType = {}));
+//# sourceMappingURL=AbstractLazyObjectType.js.map

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -0,0 +1,24 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractTermType } from "./AbstractTermType.js";
+export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
+    readonly nodeKinds: ReadonlySet<"Literal">;
+    protected readonly languageIn: readonly string[];
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
+    get constrained(): boolean;
+    protected get schemaObject(): {
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: import("ts-poet/build/Code.js").Code;
+    };
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>;
+}
+export declare namespace AbstractLiteralType {
+    type Conversion = AbstractTermType.Conversion;
+    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractTermType.GraphqlType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractTermType.JsonType;
+}
+//# sourceMappingURL=AbstractLiteralType.d.ts.map

package/dist/generators/ts/AbstractLiteralType.js

@@ -0,0 +1,36 @@
+import { AbstractTermType } from "./AbstractTermType.js";
+import { snippets } from "./snippets.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export class AbstractLiteralType extends AbstractTermType {
+    nodeKinds = nodeKinds;
+    languageIn;
+    constructor({ languageIn, ...superParameters }) {
+        super(superParameters);
+        this.languageIn = languageIn;
+    }
+    get constrained() {
+        return super.constrained || this.languageIn.length > 0;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            languageIn: this.languageIn.length > 0 ? this.languageIn.map(literalOf) : undefined,
+        };
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: this.languageIn.length > 0
+                ? code `chain(values => ${snippets.fromRdfLanguageIn}(values, ${JSON.stringify(this.languageIn)}))`
+                : undefined,
+            preferredLanguages: code `chain(values => ${snippets.fromRdfPreferredLanguages}(values, ${variables.preferredLanguages}))`,
+            valueTo: code `chain(values => values.chainMap(value => value.toLiteral()))`,
+        };
+    }
+}
+(function (AbstractLiteralType) {
+    AbstractLiteralType.GraphqlType = AbstractTermType.GraphqlType;
+    AbstractLiteralType.JsonType = AbstractTermType.JsonType;
+})(AbstractLiteralType || (AbstractLiteralType = {}));
+const nodeKinds = new Set(["Literal"]);
+//# sourceMappingURL=AbstractLiteralType.js.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -0,0 +1,32 @@
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for TypeScript numeric types (bigint | number).
+ */
+export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
+    abstract readonly kind: "BigIntType" | "FloatType" | "IntType";
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get name(): string;
+    get schemaType(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    protected get schemaObject(): {
+        in: Code[] | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
+    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonZodSchema"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
+    protected abstract fromRdfResourceValueExpression(variables: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    protected abstract literalOf(value: ValueT): string;
+}
+export declare namespace AbstractNumericType {
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractPrimitiveType.JsonType;
+}
+//# sourceMappingURL=AbstractNumericType.d.ts.map

package/dist/generators/ts/AbstractNumericType.js

@@ -0,0 +1,85 @@
+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 { Memoize } from "typescript-memoize";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for TypeScript numeric types (bigint | number).
+ */
+export class AbstractNumericType extends AbstractPrimitiveType {
+    get filterFunction() {
+        return code `${snippets.filterNumeric}<${this.typeofs[0]}>`;
+    }
+    get filterType() {
+        return code `${snippets.NumericFilter}<${this.typeofs[0]}>`;
+    }
+    get name() {
+        if (this.primitiveIn.length > 0) {
+            return `${this.primitiveIn.map((value) => this.literalOf(value)).join(" | ")}`;
+        }
+        return this.typeofs[0];
+    }
+    get schemaType() {
+        return code `${snippets.NumericSchema}<${this.typeofs[0]}>`;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `${snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0
+                ? this.primitiveIn.map((_) => code `${this.literalOf(_)}`)
+                : undefined,
+        };
+    }
+    jsonZodSchema(_parameters) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return code `${imports.z}.${this.typeofs[0]}()`;
+            case 1:
+                return code `${imports.z}.literal(${this.literalOf(this.primitiveIn[0])})`;
+            default:
+                return code `${imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
+        }
+    }
+    toRdfExpression({ variables, }) {
+        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            languageIn: undefined,
+            preferredLanguages: undefined,
+            valueTo: code `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({
+                variables: { value: code `value` },
+            })}))`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "name", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "sparqlWherePatternsFunction", null);
+(function (AbstractNumericType) {
+    AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
+})(AbstractNumericType || (AbstractNumericType = {}));
+//# sourceMappingURL=AbstractNumericType.js.map

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -0,0 +1,30 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractPrimitiveType<ValueT extends bigint | boolean | Date | string | number> extends AbstractLiteralType {
+    protected readonly datatype: NamedNode;
+    readonly equalsFunction: Code;
+    abstract readonly kind: "BigIntType" | "BooleanType" | "DateTimeType" | "DateType" | "FloatType" | "IntType" | "NumberType" | "StringType";
+    readonly primitiveIn: readonly ValueT[];
+    constructor({ datatype, primitiveIn, ...superParameters }: {
+        datatype: NamedNode;
+        primitiveIn: readonly ValueT[];
+    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    get conversions(): readonly AbstractPrimitiveType.Conversion[];
+    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
+    hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractLiteralType.JsonType;
+    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
+}
+export declare namespace AbstractPrimitiveType {
+    type Conversion = AbstractLiteralType.Conversion;
+    type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractLiteralType.GraphqlType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractLiteralType.JsonType;
+}
+//# sourceMappingURL=AbstractPrimitiveType.d.ts.map

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -0,0 +1,60 @@
+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 { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractPrimitiveType extends AbstractLiteralType {
+    datatype;
+    equalsFunction = code `${snippets.strictEquals}`;
+    primitiveIn;
+    constructor({ datatype, primitiveIn, ...superParameters }) {
+        super(superParameters);
+        this.datatype = datatype;
+        this.primitiveIn = primitiveIn;
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "${this.typeofs[0]}"`,
+                sourceTypeName: this.name,
+                sourceTypeof: this.typeofs[0],
+            },
+        ];
+    }
+    get discriminantProperty() {
+        return Maybe.empty();
+    }
+    fromJsonExpression({ variables, }) {
+        return variables.value;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    hashStatements({ variables, }) {
+        return [code `${variables.hasher}.update(${variables.value}.toString());`];
+    }
+    jsonType() {
+        return new AbstractLiteralType.JsonType(this.name);
+    }
+    toJsonExpression({ variables, }) {
+        return variables.value;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractPrimitiveType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractPrimitiveType.prototype, "jsonType", null);
+(function (AbstractPrimitiveType) {
+    AbstractPrimitiveType.GraphqlType = AbstractLiteralType.GraphqlType;
+    AbstractPrimitiveType.JsonType = AbstractLiteralType.JsonType;
+})(AbstractPrimitiveType || (AbstractPrimitiveType = {}));
+//# sourceMappingURL=AbstractPrimitiveType.js.map

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

@@ -0,0 +1,60 @@
+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 { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ *
+ * ConstantTermT is the type of sh:hasValue and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * 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 graphqlArgs: AbstractType["graphqlArgs"];
+    readonly hasValues: readonly ConstantTermT[];
+    readonly in_: readonly ConstantTermT[];
+    readonly mutable: boolean;
+    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly typeofs: AbstractType["typeofs"];
+    constructor({ hasValues, in_, ...superParameters }: {
+        hasValues: readonly ConstantTermT[];
+        in_: readonly ConstantTermT[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get constrained(): boolean;
+    get conversions(): readonly AbstractType.Conversion[];
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get schema(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    fromRdfExpression(parameters: Parameters<AbstractType["fromRdfExpression"]>[0]): Code;
+    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement(): Maybe<Code>;
+    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    /**
+     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
+     *
+     * hasValues: test whether the values sequence has sh:hasValue values
+     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
+     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
+     *
+     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
+     */
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+        hasValues?: Code;
+        languageIn?: Code;
+        preferredLanguages?: Code;
+        valueTo: Code;
+    };
+}
+export declare namespace AbstractTermType {
+    type Conversion = AbstractType.Conversion;
+    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    const GraphqlType: typeof AbstractType.GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    const JsonType: typeof AbstractType.JsonType;
+    type JsonType = AbstractType.JsonType;
+}
+//# sourceMappingURL=AbstractTermType.d.ts.map

package/dist/generators/ts/AbstractTermType.js

@@ -0,0 +1,171 @@
+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 { NodeKind } from "@shaclmate/shacl-ast";
+import { Maybe, NonEmptyList } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { removeUndefined } from "./removeUndefined.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ *
+ * ConstantTermT is the type of sh:hasValue and sh:in.
+ * RuntimeTermT is the type of values at runtime.
+ *
+ * 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 `${snippets.booleanEquals}`;
+    graphqlArgs = Maybe.empty();
+    hasValues;
+    in_;
+    mutable = false;
+    typeofs = NonEmptyList([
+        "object",
+    ]);
+    constructor({ hasValues, in_, ...superParameters }) {
+        super(superParameters);
+        this.hasValues = hasValues;
+        this.in_ = in_;
+    }
+    get constrained() {
+        return this.hasValues.length > 0 || this.in_.length > 0;
+    }
+    get conversions() {
+        const conversions = [];
+        if (this.nodeKinds.has("Literal")) {
+            conversions.push({
+                conversionExpression: (value) => code `${snippets.literalFactory}.bigint(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "bigint"`,
+                sourceTypeName: code `bigint`,
+                sourceTypeof: "bigint",
+            }, {
+                conversionExpression: (value) => code `${snippets.literalFactory}.boolean(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "boolean"`,
+                sourceTypeName: code `boolean`,
+                sourceTypeof: "boolean",
+            }, {
+                conversionExpression: (value) => code `${snippets.literalFactory}.date(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
+                sourceTypeName: code `Date`,
+                sourceTypeof: "object",
+            }, {
+                conversionExpression: (value) => code `${snippets.literalFactory}.number(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
+                sourceTypeName: code `number`,
+                sourceTypeof: "number",
+            }, {
+                conversionExpression: (value) => code `${snippets.literalFactory}.string(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
+                sourceTypeName: code `string`,
+                sourceTypeof: "string",
+            });
+        }
+        conversions.push({
+            conversionExpression: (value) => value,
+            sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+            sourceTypeName: this.name,
+            sourceTypeof: "object",
+        });
+        return conversions;
+    }
+    get discriminantProperty() {
+        return Maybe.of({
+            name: "termType",
+            ownValues: [...this.nodeKinds].map(NodeKind.toTermType),
+            descendantValues: [],
+            type: "string",
+        });
+    }
+    get schema() {
+        return code `${removeUndefined(this.schemaObject)}`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return code `((_: object) => [])`;
+    }
+    fromRdfExpression(parameters) {
+        // invariant(
+        //   this.nodeKinds.has("Literal") &&
+        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
+        //   "IdentifierType and LiteralType should override",
+        // );
+        const chain = this.fromRdfExpressionChain(parameters);
+        const { variables } = parameters;
+        return joinCode([
+            variables.resourceValues,
+            chain.hasValues,
+            chain.languageIn,
+            chain.preferredLanguages,
+            chain.valueTo,
+        ].filter((_) => _ !== undefined), { on: "." });
+    }
+    hashStatements({ variables, }) {
+        return [
+            code `${variables.hasher}.update(${variables.value}.termType);`,
+            code `${variables.hasher}.update(${variables.value}.value);`,
+        ];
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    toRdfExpression({ variables, }) {
+        return code `[${variables.value}]`;
+    }
+    /**
+     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
+     *
+     * hasValues: test whether the values sequence has sh:hasValue values
+     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
+     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
+     *
+     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
+     */
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression;
+        if (this.in_.length > 0) {
+            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}])`;
+        }
+        else if (this.nodeKinds.size < 3) {
+            const eitherTypeParameters = code `<Error, ${this.name}>`;
+            valueToExpression = code `value.toTerm().chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${NodeKind.toTermType(nodeKind)}":`).join("\n")} return ${imports.Either}.of${eitherTypeParameters}(term);
+  default: return ${imports.Left}${eitherTypeParameters}(new ${imports.Resource}.MistypedTermValueError(${{ actualValue: code `term`, expectedValueType: code `${this.name}`.toCodeString([]), focusResource: variables.resource, propertyPath: variables.propertyPath }}));
+  }})`;
+        }
+        else {
+            valueToExpression = code `value.toTerm()`;
+        }
+        return {
+            hasValues: this.hasValues.length > 0
+                ? code `\
+chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map(rdfjsTermExpression), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
+                : undefined,
+            valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "sparqlConstructTriplesFunction", null);
+(function (AbstractTermType) {
+    AbstractTermType.GraphqlType = AbstractType.GraphqlType;
+    AbstractTermType.JsonType = AbstractType.JsonType;
+})(AbstractTermType || (AbstractTermType = {}));
+//# sourceMappingURL=AbstractTermType.js.map