@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/AbstractType.d.ts

@@ -0,0 +1,267 @@
+import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Typeof } from "./Typeof.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class all types.
+ */
+export declare abstract class AbstractType {
+    /**
+     * Comment from rdfs:comment.
+     */
+    readonly comment: Maybe<string>;
+    /**
+     * Expressions that convert a source type or types to this type. It should include the type itself.
+     */
+    abstract readonly conversions: readonly AbstractType.Conversion[];
+    /**
+     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     */
+    abstract readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
+    /**
+     * A function (reference or declaration) that compares two property values of this type, returning a
+     * $EqualsResult.
+     */
+    abstract readonly equalsFunction: Code;
+    /**
+     * A function (reference or declaration) that takes a filter of filterType (below) and a value of this type
+     * and returns true if the value passes the filter.
+     */
+    abstract readonly filterFunction: Code;
+    /**
+     * Composite type for filtering instances of this type e.g., SomeObject.Filter with filters for each property.
+     */
+    abstract readonly filterType: Code;
+    /**
+     * Declarations for GraphQL arguments to pass to this the graphqlResolveExpression.
+     */
+    abstract readonly graphqlArgs: Maybe<Record<string, {
+        type: Code;
+    }>>;
+    /**
+     * GraphQL-compatible version of the type.
+     */
+    abstract readonly graphqlType: AbstractType.GraphqlType;
+    /**
+     * Type discriminator.
+     */
+    abstract readonly kind: string;
+    /**
+     * Label from rdfs:label.
+     */
+    readonly label: Maybe<string>;
+    /**
+     * Is a value of this type mutable?
+     */
+    abstract readonly mutable: boolean;
+    /**
+     * TypeScript name of the type.
+     */
+    abstract readonly name: Code | string;
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    abstract readonly schema: Code;
+    /**
+     * TypeScript type describing .schema.
+     */
+    abstract readonly schemaType: Code;
+    /**
+     * A SparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property of this type.
+     *
+     * The function takes a parameters object (type: SparqlConstructTriplesFunctionParameters) with the following parameters:
+     * - filter?: an instance of filterType
+     * - ignoreRdfType?: boolean
+     * - schema: instance of this.schemaType
+     * - valueVariable: rdfjs.Variable of the value of this type
+     * - variablePrefix: prefix to use for new variables
+     */
+    abstract readonly sparqlConstructTriplesFunction: Code;
+    /**
+     * A SparqlWherePatternsFunction (reference or declaration) that returns an array of SparqlPattern's for a property of this type.
+     *
+     * The function takes a parameters object (type: SparqlWherePatternsFunctionParameters) with the following parameters:
+     * - filter?: an instance of filterType
+     * - preferredLanguages: array of preferred language code (strings); may be empty
+     * - propertyPatterns: array of sparqljs.Pattern's for the property; may be empty
+     * - schema: instance of this.schemaType
+     * - valueVariable: rdfjs.Variable of the value of this type
+     * - variablePrefix: prefix to use for new variables
+     */
+    abstract readonly sparqlWherePatternsFunction: Code;
+    /**
+     * JavaScript typeof(s) the type.
+     */
+    abstract readonly typeofs: NonEmptyList<Typeof>;
+    constructor({ comment, label, }: {
+        comment: Maybe<string>;
+        label: Maybe<string>;
+    });
+    /**
+     * Helper to compose the result of schema along the type hierarchy.
+     */
+    protected get schemaObject(): {
+        kind: Code;
+    };
+    /**
+     * An expression that converts this type's JSON type to a value of this type. It doesn't return a Either because the JSON has
+     * already been validated and converted to the expected JSON type with Zod.
+     */
+    abstract fromJsonExpression(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    /**
+     * An expression that converts a Either<Error, rdfjsResource.Resource.Values> to a
+     * Either<Error, rdfjsResource.Resource.Values<this type>>.
+     *
+     * These expressions are used to deserialize property values in an ObjectType, either directly (a property with this Type) or indirectly (a property with a Type like OptionType
+     * that has a type parameter of this Type).
+     *
+     * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
+     * to be considered valid. Similar
+     *
+     * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
+     * (if it exists) is always of the first preferred language.
+     *
+     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     *   context: unanticipated properties (...) passed to Object.fromRdf
+     *   graph: DefaultGraph | NamedNode | undefined to match (subject, predicate, object) triples in; if undefined, match triples in all graphs
+     *   ignoreRdfType: whether the RDF type of objects/object unions should be ignored
+     *   objectSet: the ObjectSet passed to Object.fromRdf
+     *   preferredLanguages: the preferred languages array (e.g., ["en"]) passed to Object.fromRdf
+     *   propertyPath: the PropertyPath of the object's property
+     *   resource: the Resource passed to Object.fromRdf
+     *   resourceValues: the Either<Error, rdfjsResource.Resource.Values> to be converted to values of this type
+     */
+    abstract fromRdfExpression(parameters: {
+        variables: {
+            context: Code;
+            graph: Code;
+            ignoreRdfType?: boolean;
+            objectSet: Code;
+            preferredLanguages: Code;
+            propertyPath: Code;
+            resource: Code;
+            resourceValues: Code;
+        };
+    }): Code;
+    /**
+     * An expression that resolves a value of this type in the GraphQL server.
+     */
+    abstract graphqlResolveExpression(parameters: {
+        variables: {
+            args: Code;
+            value: Code;
+        };
+    }): Code;
+    /**
+     * Statements that use hasher.update to hash a property value of this type.
+     */
+    abstract hashStatements(parameters: {
+        depth: number;
+        variables: {
+            hasher: Code;
+            value: Code;
+        };
+    }): readonly Code[];
+    /**
+     * JSON-compatible version of the type.
+     */
+    abstract jsonType(parameters?: {
+        includeDiscriminantProperty?: boolean;
+    }): AbstractType.JsonType;
+    /**
+     * Element object for a JSON Forms UI schema.
+     */
+    abstract jsonUiSchemaElement(parameters: {
+        variables: {
+            scopePrefix: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Zod schema for the JSON type of this type.
+     *
+     * This method is called in two contexts:
+     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
+     * "type": from another Type e.g., an OptionType or UnionType
+     *
+     * z.lazy() should only be returned for "property".
+     */
+    abstract jsonZodSchema(parameters: {
+        includeDiscriminantProperty?: boolean;
+        context: "property" | "type";
+    }): Code;
+    /**
+     * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
+     * of the correct JSON-LD context.
+     */
+    abstract toJsonExpression(parameters: {
+        includeDiscriminantProperty?: boolean;
+        variables: {
+            value: Code;
+        };
+    }): Code;
+    /**
+     * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
+     *   resource.add(predicate, convertedValue, graph)
+     *
+     * variables are runtime variables, most derived from the parameters of the ObjectType's fromRdf function:
+     *   graph: DefaultGraph | NamedNode | undefined to .add to; if undefined, add to the default graph
+     *   propertyPath: predicate path (NamedNode) or InversePath on a predicate path
+     *   resource: the Resource to .add to
+     *   resourceSet: ResourceSet for any new Resources needed while conversion (of e.g., nested objects)
+     *   value: value of this type, to be converted to (BlankNode | Literal | NamedNode | bigint | boolean | number | string) or an array of the same
+     */
+    abstract toRdfExpression(parameters: {
+        variables: {
+            graph: Code;
+            propertyPath: Code;
+            resource: Code;
+            resourceSet: Code;
+            value: Code;
+        };
+    }): Code;
+}
+export declare namespace AbstractType {
+    interface Conversion {
+        readonly conversionExpression: (value: Code) => Code;
+        readonly sourceTypeCheckExpression: (value: Code) => Code;
+        readonly sourceTypeName: Code | string;
+        readonly sourceTypeof: Typeof;
+    }
+    interface DiscriminantProperty {
+        readonly name: string;
+        readonly ownValues: readonly string[];
+        readonly descendantValues: readonly string[];
+    }
+    class GraphqlType {
+        /**
+         * Is the type nullable in GraphQL?
+         */
+        readonly nullable: boolean;
+        /**
+         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         */
+        readonly nullableName: Code;
+        constructor(nullableName: Code, parameters?: {
+            nullable: boolean;
+        });
+        get name(): Code;
+    }
+    class JsonType {
+        /**
+         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
+         */
+        readonly optional: boolean;
+        /**
+         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         */
+        readonly requiredName: Code | string;
+        constructor(requiredName: Code | string, parameters?: {
+            optional: boolean;
+        });
+        get name(): Code | string;
+    }
+}
+//# sourceMappingURL=AbstractType.d.ts.map

package/dist/generators/ts/AbstractType.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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { imports } from "./imports.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class all types.
+ */
+export class AbstractType {
+    /**
+     * Comment from rdfs:comment.
+     */
+    comment;
+    /**
+     * Label from rdfs:label.
+     */
+    label;
+    constructor({ comment, label, }) {
+        this.comment = comment;
+        this.label = label;
+    }
+    /**
+     * Helper to compose the result of schema along the type hierarchy.
+     */
+    get schemaObject() {
+        invariant(this.kind.endsWith("Type"));
+        return {
+            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))} as const`,
+        };
+    }
+}
+(function (AbstractType) {
+    class GraphqlType {
+        /**
+         * Is the type nullable in GraphQL?
+         */
+        nullable;
+        /**
+         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         */
+        nullableName;
+        constructor(nullableName, parameters) {
+            this.nullable = !!parameters?.nullable;
+            this.nullableName = nullableName;
+        }
+        get name() {
+            return this.nullable
+                ? this.nullableName
+                : code `new ${imports.GraphQLNonNull}(${this.nullableName})`;
+        }
+    }
+    __decorate([
+        Memoize()
+    ], GraphqlType.prototype, "name", null);
+    AbstractType.GraphqlType = GraphqlType;
+    class JsonType {
+        /**
+         * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
+         */
+        optional;
+        /**
+         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         */
+        requiredName;
+        constructor(requiredName, parameters) {
+            this.optional = !!parameters?.optional;
+            this.requiredName = requiredName;
+        }
+        get name() {
+            return this.optional
+                ? code `(${this.requiredName}) | undefined`
+                : this.requiredName;
+        }
+    }
+    __decorate([
+        Memoize()
+    ], JsonType.prototype, "name", null);
+    AbstractType.JsonType = JsonType;
+})(AbstractType || (AbstractType = {}));
+//# sourceMappingURL=AbstractType.js.map

package/dist/generators/ts/BigDecimalType.d.ts

@@ -0,0 +1,21 @@
+import { type Code } from "ts-poet";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+export declare class BigDecimalType extends AbstractLiteralType {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly kind = "BigDecimalType";
+    readonly name: Code;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    get conversions(): readonly AbstractLiteralType.Conversion[];
+    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;
+    jsonZodSchema(): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
+    toRdfExpression({ variables, }: Parameters<AbstractLiteralType["toRdfExpression"]>[0]): Code;
+}
+//# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -0,0 +1,91 @@
+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 { code } from "ts-poet";
+import { Memoize } from "typescript-memoize";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+export class BigDecimalType extends AbstractLiteralType {
+    filterFunction = code `${snippets.filterBigDecimal}`;
+    filterType = code `${snippets.NumericFilter}<${imports.BigDecimal}>`;
+    graphqlType = new AbstractLiteralType.GraphqlType(code `${imports.GraphQLString}`);
+    kind = "BigDecimalType";
+    name = code `${imports.BigDecimal}`;
+    schemaType = code `${snippets.NumericSchema}<${imports.BigDecimal}>`;
+    sparqlWherePatternsFunction = code `${snippets.bigDecimalSparqlWherePatterns}`;
+    get conversions() {
+        return [
+            // {
+            //   conversionExpression: (value) =>
+            //     code`new ${imports.BigDecimal}(${value}.toString())`,
+            //   sourceTypeCheckExpression: (value) =>
+            //     code`typeof ${value} === "bigint"`,
+            //   sourceTypeName: code`bigint`,
+            //   sourceTypeof: "bigint",
+            // },
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: code `${imports.BigDecimal}`,
+                sourceTypeof: "object",
+            },
+            // {
+            //   conversionExpression: (value) =>
+            //     code`new ${imports.BigDecimal}(${value})`,
+            //   sourceTypeCheckExpression: (value) =>
+            //     code`typeof ${value} === "number"`,
+            //   sourceTypeName: code`number`,
+            //   sourceTypeof: "number",
+            // },
+            // {
+            //   conversionExpression: (value) =>
+            //     code`new ${imports.BigDecimal}(${value})`,
+            //   sourceTypeCheckExpression: (value) =>
+            //     code`typeof ${value} === "string"`,
+            //   sourceTypeName: code`string`,
+            //   sourceTypeof: "string",
+            // },
+        ];
+    }
+    fromJsonExpression({ variables, }) {
+        return code `new ${imports.BigDecimal}(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.toFixed()`;
+    }
+    hashStatements({ variables, }) {
+        return [code `${variables.hasher}.update(${variables.value}.toFixed());`];
+    }
+    jsonType() {
+        return new AbstractLiteralType.JsonType("string");
+    }
+    jsonZodSchema() {
+        return code `${imports.z}.string()`;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.toFixed()`;
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${snippets.decodeBigDecimalLiteral})))`,
+        };
+    }
+    toRdfExpression({ variables, }) {
+        return code `[${snippets.bigDecimalLiteral}(${variables.value})]`;
+    }
+}
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "jsonType", null);
+__decorate([
+    Memoize()
+], BigDecimalType.prototype, "jsonZodSchema", null);
+//# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.d.ts

@@ -0,0 +1,15 @@
+import { NonEmptyList } from "purify-ts";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class BigIntType extends AbstractNumericType<bigint> {
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly kind = "BigIntType";
+    readonly typeofs: NonEmptyList<"bigint">;
+    fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
+    jsonZodSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonZodSchema"]>[0]): Code;
+    jsonType(): AbstractNumericType.JsonType;
+    toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
+    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromRdfResourceValueExpression"]>[0]): Code;
+    protected literalOf(value: bigint): string;
+}
+//# sourceMappingURL=BigIntType.d.ts.map

package/dist/generators/ts/BigIntType.js

@@ -0,0 +1,49 @@
+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 { NonEmptyList } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { AbstractNumericType } from "./AbstractNumericType.js";
+import { imports } from "./imports.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class BigIntType extends AbstractNumericType {
+    graphqlType = new AbstractNumericType.GraphqlType(code `${imports.GraphQLBigInt}`);
+    kind = "BigIntType";
+    typeofs = NonEmptyList(["bigint"]);
+    fromJsonExpression({ variables, }) {
+        let expression = code `BigInt(${variables.value})`;
+        if (this.primitiveIn.length > 0) {
+            expression = code `${expression} as ${this.name}`;
+        }
+        return expression;
+    }
+    jsonZodSchema(_parameters) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return code `${imports.z}.string()`;
+            case 1:
+                return code `${imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
+            default:
+                return code `${imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
+        }
+    }
+    jsonType() {
+        return new AbstractNumericType.JsonType(code `string`);
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.toString()`;
+    }
+    fromRdfResourceValueExpression({ variables, }) {
+        return code `${variables.value}.toBigInt(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `${_}n`).join(", ")}] as const` : ""})`;
+    }
+    literalOf(value) {
+        return `${value.toString()}n`;
+    }
+}
+__decorate([
+    Memoize()
+], BigIntType.prototype, "jsonType", null);
+//# sourceMappingURL=BigIntType.js.map

package/dist/generators/ts/BlankNodeType.d.ts

@@ -0,0 +1,26 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly fromStringFunction: Code;
+    readonly kind = "BlankNodeType";
+    readonly name: Code;
+    readonly nodeKinds: ReadonlySet<"BlankNode">;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
+    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
+    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): {
+        valueTo: Code;
+        hasValues?: Code;
+        languageIn?: Code;
+        preferredLanguages?: Code;
+    };
+}
+//# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/generators/ts/BlankNodeType.js

@@ -0,0 +1,61 @@
+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 { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class BlankNodeType extends AbstractIdentifierType {
+    filterFunction = code `${snippets.filterBlankNode}`;
+    filterType = code `${snippets.BlankNodeFilter}`;
+    fromStringFunction = code `export const fromString = ${snippets.blankNodeFromString};`;
+    kind = "BlankNodeType";
+    name = code `${imports.BlankNode}`;
+    nodeKinds = nodeKinds;
+    schemaType = code `${snippets.BlankNodeSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.blankNodeSparqlWherePatterns}`;
+    constructor(superParameters) {
+        super({
+            ...superParameters,
+            hasValues: [],
+            in_: [],
+        });
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "BlankNode"`
+            : "";
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
+    jsonZodSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${imports.z}.literal("BlankNode")`
+            : "";
+        return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1)${discriminantProperty} })`;
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${variables.value}.termType`
+            : "";
+        return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: code `chain(values => values.chainMap(value => value.toBlankNode()))`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], BlankNodeType.prototype, "jsonType", null);
+const nodeKinds = new Set(["BlankNode"]);
+//# sourceMappingURL=BlankNodeType.js.map

package/dist/generators/ts/BooleanType.d.ts

@@ -1,14 +1,22 @@
-import { PrimitiveType } from "./PrimitiveType.js";
-import type { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-export declare class BooleanType extends PrimitiveType<boolean> {
+import { NonEmptyList } from "purify-ts";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class BooleanType extends AbstractPrimitiveType<boolean> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "BooleanType";
-    readonly typeof = "boolean";
-    get conversions(): readonly Type.Conversion[];
-    get graphqlName(): Type.GraphqlName;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    readonly typeofs: NonEmptyList<"boolean">;
     get name(): string;
-    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    protected fromRdfExpressionChain({ variables, }: Parameters<TermType["fromRdfExpressionChain"]>[0]): ReturnType<TermType["fromRdfExpressionChain"]>;
-    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
+    protected get schemaObject(): {
+        in: boolean[] | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
+    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonZodSchema"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map