@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/AbstractIdentifierType.js

@@ -0,0 +1,25 @@
+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 { AbstractTermType } from "./AbstractTermType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractIdentifierType extends AbstractTermType {
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
+    stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
+    get graphqlType() {
+        return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    }
+    graphqlResolveExpression({ variables: { value }, }) {
+        return code `${this.reusables.imports.NTriplesTerm}.stringify(${value})`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractIdentifierType.prototype, "graphqlType", null);
+//# sourceMappingURL=AbstractIdentifierType.js.map

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -0,0 +1,67 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { OptionType } from "./OptionType.js";
+import type { SetType } from "./SetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
+    protected readonly partialType: PartialTypeT;
+    protected readonly resolveType: ResolveTypeT;
+    protected abstract readonly runtimeClass: {
+        readonly name: Code;
+        readonly partialPropertyName: string;
+        readonly rawName: Code;
+    };
+    readonly declaration: Maybe<Code>;
+    readonly discriminantProperty: AbstractType["discriminantProperty"];
+    readonly mutable = false;
+    readonly validationFunction: Maybe<Code>;
+    constructor({ partialType, resolveType, ...superParameters }: {
+        partialType: PartialTypeT;
+        resolveType: ResolveTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get equalsFunction(): Code;
+    get expression(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
+    get jsTypes(): readonly AbstractType.JsType[];
+    get recursive(): boolean;
+    get referencesNamedType(): boolean;
+    get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
+        partialType: ObjectTypeT;
+        resolveType: ObjectTypeT;
+    }): Code;
+    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
+        resolvedObjectUnionType: ObjectUnionType;
+        partialObjectUnionType: ObjectUnionType;
+        variables: {
+            resolvedObjectUnion: Code;
+        };
+    }): Code;
+}
+export declare namespace AbstractLazyType {
+    type ItemTypeConstraint = ObjectType | ObjectUnionType;
+    type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
+    type ResolveTypeConstraint = PartialTypeConstraint;
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    const GraphqlType: typeof AbstractType.GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    const JsonType: typeof AbstractType.JsonType;
+    type JsonType = AbstractType.JsonType;
+}
+//# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/generators/ts/AbstractLazyType.js

@@ -0,0 +1,154 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class AbstractLazyType extends AbstractType {
+    partialType;
+    resolveType;
+    declaration = Maybe.empty();
+    discriminantProperty = Maybe.empty();
+    mutable = false;
+    validationFunction = Maybe.empty();
+    constructor({ partialType, resolveType, ...superParameters }) {
+        super(superParameters);
+        this.partialType = partialType;
+        this.resolveType = resolveType;
+    }
+    get equalsFunction() {
+        return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
+    }
+    get expression() {
+        return this.runtimeClass.name;
+    }
+    get filterFunction() {
+        return code `((filter: ${this.filterType}, value: ${this.expression}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
+    }
+    get filterType() {
+        return this.partialType.filterType;
+    }
+    get graphqlType() {
+        return this.resolveType.graphqlType;
+    }
+    get hashFunction() {
+        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
+    }
+    get jsTypes() {
+        return [
+            {
+                className: this.runtimeClass.rawName,
+                instanceof: "class",
+                typeof: "object",
+            },
+        ];
+    }
+    get recursive() {
+        return this.partialType.recursive;
+    }
+    get referencesNamedType() {
+        return this.partialType.referencesNamedType;
+    }
+    get schemaType() {
+        return code `${{
+            kind: this.kind,
+            partialType: this.partialType.schemaType,
+        }}`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.partialType.toRdfResourceValueTypes;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partialType }))`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partialType }))`;
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
+    }
+    jsonSchema(parameters) {
+        return this.partialType.jsonSchema(parameters);
+    }
+    jsonType(parameters) {
+        return this.partialType.jsonType(parameters);
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.partialType.jsonUiSchemaElement(parameters);
+    }
+    toJsonExpression({ variables, }) {
+        return this.partialType.toJsonExpression({
+            variables: {
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return this.partialType.toRdfResourceValuesExpression({
+            variables: {
+                ...variables,
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    toStringExpression({ variables, }) {
+        return this.partialType.toStringExpression({
+            variables: {
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
+    resolveToPartialFunction({ partialType, resolveType, }) {
+        if (partialType.kind === "Object") {
+            return code `${partialType.name.unsafeCoerce()}.createUnsafe`;
+        }
+        invariant(partialType.kind === "ObjectUnion");
+        invariant(resolveType.kind === "ObjectUnion");
+        invariant(partialType.members.length === resolveType.members.length);
+        const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name.unsafeCoerce()}.createUnsafe(resolved);`;
+        });
+        caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
+        return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
+    }
+    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
+        invariant(resolvedObjectUnionType.members.length ===
+            partialObjectUnionType.members.length);
+        const caseBlocks = resolvedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.name.unsafeCoerce()}.create(${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()
+], AbstractLazyType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "jsTypes", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "valueSparqlWherePatternsFunction", null);
+(function (AbstractLazyType) {
+    AbstractLazyType.GraphqlType = AbstractType.GraphqlType;
+    AbstractLazyType.JsonType = AbstractType.JsonType;
+})(AbstractLazyType || (AbstractLazyType = {}));
+//# sourceMappingURL=AbstractLazyType.js.map

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

@@ -0,0 +1,26 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractTermType } from "./AbstractTermType.js";
+import type { Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
+    protected readonly languageIn: readonly string[];
+    readonly nodeKinds: ReadonlySet<"Literal">;
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
+    /**
+     * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
+     *
+     * For example, a string would be converted to "thestring".
+     */
+    abstract literalValueExpression(literal: Literal): Code;
+}
+export declare namespace AbstractLiteralType {
+    type ConversionFunction = AbstractTermType.ConversionFunction;
+    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractTermType.GraphqlType;
+    type JsType = AbstractTermType.JsType;
+    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,15 @@
+import { AbstractTermType } from "./AbstractTermType.js";
+export class AbstractLiteralType extends AbstractTermType {
+    languageIn;
+    nodeKinds = nodeKinds;
+    constructor({ languageIn, ...superParameters }) {
+        super(superParameters);
+        this.languageIn = languageIn;
+    }
+}
+(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,21 @@
+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> {
+    readonly hashFunction: Code;
+    abstract readonly kind: "BigInt" | "Float" | "Int";
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get schemaType(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    protected get inlineExpression(): Code;
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
+}
+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,65 @@
+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 { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for TypeScript numeric types (bigint | number).
+ */
+export class AbstractNumericType extends AbstractPrimitiveType {
+    hashFunction = code `${this.reusables.snippets.hashNumeric}`;
+    get filterFunction() {
+        return code `${this.reusables.snippets.filterNumeric}<${this.expression}>`;
+    }
+    get filterType() {
+        return code `${this.reusables.snippets.NumericFilter}<${this.expression}>`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.NumericSchema}<${this.expression}>`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`;
+    }
+    get inlineExpression() {
+        if (this.primitiveIn.length > 0) {
+            return code `${joinCode(this.primitiveIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
+        }
+        return code `${this.jsTypes[0].typeof}`;
+    }
+    jsonSchema(_parameters) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
+            case 1:
+                return code `${this.reusables.imports.z}.literal(${this.literalValueExpression(this.primitiveIn[0])})`;
+            default:
+                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalValueExpression(value)})`), { on: "," })}])`;
+        }
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "inlineExpression", null);
+(function (AbstractNumericType) {
+    AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
+})(AbstractNumericType || (AbstractNumericType = {}));
+//# sourceMappingURL=AbstractNumericType.js.map

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -0,0 +1,36 @@
+import type { Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractObjectSetType {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
+    protected readonly namedObjectTypes: readonly ObjectType[];
+    protected readonly namedObjectUnionTypes: readonly ObjectUnionType[];
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        namedObjectTypes: readonly ObjectType[];
+        namedObjectUnionTypes: readonly ObjectUnionType[];
+        reusables: Reusables;
+    });
+    abstract readonly declaration: Code;
+    protected methodSignatures(namedObjectType: {
+        readonly filterType: Code;
+        readonly identifierTypeAlias: Code;
+        readonly name: Maybe<string>;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+    }, options?: {
+        parameterNamePrefix?: string;
+        queryT?: string;
+    }): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, {
+        readonly name: string;
+        readonly parameters: Code;
+        readonly returnType: Code;
+    }>>;
+}
+//# sourceMappingURL=AbstractObjectSetType.d.ts.map

package/dist/generators/ts/AbstractObjectSetType.js

@@ -0,0 +1,44 @@
+import { code } from "./ts-poet-wrapper.js";
+export class AbstractObjectSetType {
+    configuration;
+    logger;
+    reusables;
+    namedObjectTypes;
+    namedObjectUnionTypes;
+    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.namedObjectTypes = namedObjectTypes;
+        this.namedObjectUnionTypes = namedObjectUnionTypes;
+        this.reusables = reusables;
+    }
+    methodSignatures(namedObjectType, options) {
+        const parameterNamePrefix = options?.parameterNamePrefix ?? "";
+        const queryT = options?.queryT ??
+            `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
+        const methodNames = namedObjectType.objectSetMethodNames;
+        return {
+            object: {
+                name: methodNames.object,
+                parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name.unsafeCoerce()}>>`,
+            },
+            objectCount: {
+                name: methodNames.objectCount,
+                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
+            },
+            objectIdentifiers: {
+                name: methodNames.objectIdentifiers,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
+            },
+            objects: {
+                name: methodNames.objects,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name.unsafeCoerce()}[]>>`,
+            },
+        };
+    }
+}
+//# sourceMappingURL=AbstractObjectSetType.js.map

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

@@ -0,0 +1,32 @@
+import type { Literal, 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 conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
+    readonly equalsFunction: Code;
+    abstract readonly kind: "BigInt" | "Boolean" | "DateTime" | "Date" | "Float" | "Int" | "NumberType" | "String";
+    readonly primitiveIn: readonly ValueT[];
+    constructor({ datatype, primitiveIn, ...superParameters }: {
+        datatype: NamedNode;
+        primitiveIn: readonly ValueT[];
+    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    protected get schemaInitializers(): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
+    jsonType(): AbstractLiteralType.JsonType;
+    abstract literalValueExpression(literal: Literal | ValueT): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
+}
+export declare namespace AbstractPrimitiveType {
+    type ConversionFunction = AbstractLiteralType.ConversionFunction;
+    type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
+    type JsType = AbstractLiteralType.JsType;
+    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,51 @@
+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 { arrayOf, code } from "./ts-poet-wrapper.js";
+export class AbstractPrimitiveType extends AbstractLiteralType {
+    datatype;
+    conversionFunction = Maybe.empty();
+    equalsFunction = code `${this.reusables.snippets.strictEquals}`;
+    primitiveIn;
+    constructor({ datatype, primitiveIn, ...superParameters }) {
+        super(superParameters);
+        this.datatype = datatype;
+        this.primitiveIn = primitiveIn;
+    }
+    get discriminantProperty() {
+        return Maybe.empty();
+    }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.primitiveIn.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalValueExpression(in_)))} as const`);
+        }
+        return initializers;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonType() {
+        return new AbstractLiteralType.JsonType(this.expression);
+    }
+    toJsonExpression({ variables, }) {
+        return variables.value;
+    }
+}
+__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,50 @@
+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 Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
+ *
+ * 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 {
+    protected abstract readonly inlineExpression: Code;
+    readonly equalsFunction: Code;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly hasValues: readonly ConstantTermT[];
+    readonly hashFunction: Code;
+    readonly in_: readonly ConstantTermT[];
+    readonly mutable: boolean;
+    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly recursive = false;
+    readonly validationFunction: Maybe<Code>;
+    constructor({ hasValues, in_, ...superParameters }: {
+        hasValues: readonly ConstantTermT[];
+        in_: readonly ConstantTermT[];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get declaration(): Maybe<Code>;
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get expression(): Code;
+    get referencesNamedType(): boolean;
+    get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
+    get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
+    get valueSparqlConstructTriplesFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    jsonUiSchemaElement(): Maybe<Code>;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+}
+export declare namespace AbstractTermType {
+    type ConversionFunction = AbstractType.ConversionFunction;
+    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    const GraphqlType: typeof AbstractType.GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type JsType = AbstractType.JsType;
+    const JsonType: typeof AbstractType.JsonType;
+    type JsonType = AbstractType.JsonType;
+}
+//# sourceMappingURL=AbstractTermType.d.ts.map