@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/AbstractCollectionType.js

@@ -0,0 +1,235 @@
+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 { snippets_isReadonlyBigIntArray } from "./_snippets/snippets_isReadonlyBigIntArray.js";
+import { snippets_isReadonlyBooleanArray } from "./_snippets/snippets_isReadonlyBooleanArray.js";
+import { snippets_isReadonlyNumberArray } from "./_snippets/snippets_isReadonlyNumberArray.js";
+import { snippets_isReadonlyObjectArray } from "./_snippets/snippets_isReadonlyObjectArray.js";
+import { snippets_isReadonlyStringArray } from "./_snippets/snippets_isReadonlyStringArray.js";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { codeEquals } from "./codeEquals.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for ListType and SetType.
+ */
+export class AbstractCollectionType extends AbstractContainerType {
+    _mutable;
+    minCount;
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    typeofs = NonEmptyList(["object"]);
+    constructor({ minCount, mutable, ...superParameters }) {
+        super(superParameters);
+        this.minCount = minCount;
+        invariant(this.minCount >= 0);
+        this._mutable = mutable;
+        if (mutable) {
+            invariant(this.minCount === 0);
+        }
+    }
+    get conversions() {
+        const conversions = [];
+        // Try to do some conversions from types itemType can be converted to
+        // For example, if itemType is a NamedNode, it can be converted from a string, so here we'd accept:
+        // readonly NamedNode[] (no conversion)
+        // readonly string[] (map to NamedNodes)
+        // We only consider discriminating by (item) typeof. For example, the types above could be discriminated by the branches
+        // array.every(item => typeof item === "object")
+        // array.every(item => typeof item === "string")
+        const itemTypeConversionsByTypeof = {};
+        if (this.itemType.typeofs.length === 1) {
+            itemTypeConversionsByTypeof[this.itemType.typeofs[0]] = {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === ${this.itemType.typeofs[0]}`,
+                sourceTypeName: this.itemType.name,
+                sourceTypeof: this.itemType.typeofs[0],
+            };
+            for (const itemTypeConversion of this.itemType.conversions) {
+                if (!itemTypeConversionsByTypeof[itemTypeConversion.sourceTypeof]) {
+                    itemTypeConversionsByTypeof[itemTypeConversion.sourceTypeof] =
+                        itemTypeConversion;
+                }
+            }
+        }
+        if (this.minCount === 0) {
+            conversions.push({
+                conversionExpression: () => code `[]`,
+                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+                sourceTypeName: code `undefined`,
+                sourceTypeof: "undefined",
+            });
+            if (Object.keys(itemTypeConversionsByTypeof).length <= 1) {
+                // There were no additional conversions with different item typeof's, so we don't need to check .every or do .map
+                // Just check that the original value is an array with typeof "object". Array.isArray() doesn't narrow types for some reason.
+                conversions.push({
+                    conversionExpression: (value) => 
+                    // Defensive copy
+                    code `${value}${this.mutable ? ".concat()" : ""}`,
+                    sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                    sourceTypeName: code `readonly (${this.itemType.name})[]`,
+                    sourceTypeof: "object",
+                });
+            }
+            else {
+                // There were additional conversions with different item typeof's.
+                // We do .every (per above) to discriminate array types with different item typeof's and .map to convert the array at runtime.
+                for (const [itemTypeof, itemTypeofConversion] of Object.entries(itemTypeConversionsByTypeof)) {
+                    const itemVariable = code `item`;
+                    conversions.push({
+                        conversionExpression: (value) => {
+                            const itemTypeConversionExpression = itemTypeofConversion.conversionExpression(itemVariable);
+                            return !codeEquals(itemTypeConversionExpression, itemVariable)
+                                ? code `${value}.map(item => ${itemTypeConversionExpression})`
+                                : // Defensive copy
+                                    code `${value}${this.mutable ? ".concat()" : ""}`;
+                        },
+                        sourceTypeCheckExpression: (value) => {
+                            switch (itemTypeof) {
+                                case "bigint":
+                                    return code `${snippets_isReadonlyBigIntArray}(${value})`;
+                                case "boolean":
+                                    return code `${snippets_isReadonlyBooleanArray}(${value})`;
+                                case "number":
+                                    return code `${snippets_isReadonlyNumberArray}(${value})`;
+                                case "object":
+                                    return code `${snippets_isReadonlyObjectArray}(${value})`;
+                                case "string":
+                                    return code `${snippets_isReadonlyStringArray}(${value})`;
+                                case "function":
+                                case "symbol":
+                                case "undefined":
+                                    throw new Error("not implemented");
+                            }
+                        },
+                        sourceTypeName: code `readonly (${itemTypeofConversion.sourceTypeName})[]`,
+                        sourceTypeof: itemTypeofConversion.sourceTypeof,
+                    });
+                }
+            }
+        }
+        else {
+            // minCount > 0
+            // Don't try to do any item type conversions here (yet).
+            conversions.push({
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `${imports.NonEmptyList}.isNonEmpty(${value})`,
+                sourceTypeName: this.name,
+                sourceTypeof: "object",
+            });
+        }
+        return conversions;
+    }
+    get equalsFunction() {
+        return code `((left, right) => ${snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get filterFunction() {
+        return code `${snippets.filterArray}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+    }
+    get filterType() {
+        return code `${snippets.CollectionFilter}<${this.itemType.filterType}>`;
+    }
+    get graphqlType() {
+        return new AbstractContainerType.GraphqlType(code `new ${imports.GraphQLList}(${this.itemType.graphqlType.name})`);
+    }
+    get mutable() {
+        return this._mutable || this.itemType.mutable;
+    }
+    get name() {
+        if (this._mutable) {
+            return code `(${this.itemType.name})[]`;
+        }
+        if (this.minCount === 0) {
+            return code `readonly (${this.itemType.name})[]`;
+        }
+        return code `${imports.NonEmptyList}<${this.itemType.name}>`;
+    }
+    get schemaType() {
+        return code `${snippets.CollectionSchema}<${this.itemType.schemaType}>`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            minCount: this.minCount > 0 ? this.minCount : undefined,
+        };
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (!this._mutable && this.minCount > 0) {
+            expression = code `${imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
+        }
+        const valueVariable = code `item`;
+        const itemFromJsonExpression = this.itemType.fromJsonExpression({
+            variables: { value: valueVariable },
+        });
+        return codeEquals(itemFromJsonExpression, valueVariable)
+            ? expression
+            : code `${expression}.map(item => (${itemFromJsonExpression}))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    hashStatements({ depth, variables, }) {
+        return [
+            code `for (const item${depth} of ${variables.value}) { ${joinCode(this.itemType
+                .hashStatements({
+                depth: depth + 1,
+                variables: {
+                    hasher: variables.hasher,
+                    value: code `item${depth}`,
+                },
+            })
+                .concat())} }`,
+        ];
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        let schema = code `${this.itemType.jsonZodSchema(parameters)}.array()`;
+        if (this.minCount > 0) {
+            schema = code `${schema}.nonempty().min(${this.minCount})`;
+        }
+        else {
+            schema = code `${schema}.default(() => [])`;
+        }
+        return schema;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "name", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "schemaType", null);
+(function (AbstractCollectionType) {
+    AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
+    AbstractCollectionType.isItemType = AbstractContainerType.isItemType;
+    AbstractCollectionType.JsonType = AbstractContainerType.JsonType;
+})(AbstractCollectionType || (AbstractCollectionType = {}));
+//# sourceMappingURL=AbstractCollectionType.js.map

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -0,0 +1,51 @@
+import { AbstractType } from "./AbstractType.js";
+import type { BigDecimalType } from "./BigDecimalType.js";
+import type { BigIntType } from "./BigIntType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { BooleanType } from "./BooleanType.js";
+import type { DateTimeType } from "./DateTimeType.js";
+import type { DateType } from "./DateType.js";
+import type { FloatType } from "./FloatType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IntType } from "./IntType.js";
+import type { IriType } from "./IriType.js";
+import type { ListType } from "./ListType.js";
+import type { LiteralType } from "./LiteralType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { StringType } from "./StringType.js";
+import type { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
+/**
+ * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
+ */
+export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
+    abstract readonly kind: "DefaultValueType" | "ListType" | "OptionType" | "SetType";
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType: ItemTypeT;
+    constructor({ itemType, ...superParameters }: {
+        itemType: ItemTypeT;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get schema(): Code;
+    protected get schemaObject(): {
+        item: Code;
+        kind: Code;
+    };
+}
+export declare namespace AbstractContainerType {
+    type Conversion = AbstractType.Conversion;
+    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    const GraphqlType: typeof AbstractType.GraphqlType;
+    type GraphqlType = AbstractType.GraphqlType;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | ListType<ListType.ItemType> | LiteralType | ObjectType | ObjectUnionType | StringType | TermType | UnionType;
+    function isItemType(type: Type): type is ItemType;
+    const JsonType: typeof AbstractType.JsonType;
+    type JsonType = AbstractType.JsonType;
+}
+//# sourceMappingURL=AbstractContainerType.d.ts.map

package/dist/generators/ts/AbstractContainerType.js

@@ -0,0 +1,72 @@
+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 { AbstractType } from "./AbstractType.js";
+import { removeUndefined } from "./removeUndefined.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
+ */
+export class AbstractContainerType extends AbstractType {
+    /**
+     * Container item type.
+     *
+     * Mutable to support cycle-handling logic in the compiler.
+     */
+    itemType;
+    constructor({ itemType, ...superParameters }) {
+        super(superParameters);
+        this.itemType = itemType;
+    }
+    get schema() {
+        return code `${removeUndefined(this.schemaObject)}`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            item: code `() => (${this.itemType.schema})`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], AbstractContainerType.prototype, "schema", null);
+(function (AbstractContainerType) {
+    AbstractContainerType.GraphqlType = AbstractType.GraphqlType;
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BigDecimalType":
+            case "BigIntType":
+            case "BlankNodeType":
+            case "BooleanType":
+            case "DateTimeType":
+            case "DateType":
+            case "FloatType":
+            case "IdentifierType":
+            case "IntType":
+            case "IriType":
+            case "ListType":
+            case "LiteralType":
+            case "ObjectType":
+            case "ObjectUnionType":
+            case "StringType":
+            case "TermType":
+            case "UnionType":
+                return true;
+            case "DefaultValueType":
+            case "LazyObjectOptionType":
+            case "LazyObjectSetType":
+            case "LazyObjectType":
+            case "OptionType":
+            case "SetType":
+                return false;
+        }
+    }
+    AbstractContainerType.isItemType = isItemType;
+    AbstractContainerType.JsonType = AbstractType.JsonType;
+})(AbstractContainerType || (AbstractContainerType = {}));
+//# sourceMappingURL=AbstractContainerType.js.map

package/dist/generators/ts/AbstractDateType.d.ts

@@ -0,0 +1,31 @@
+import { NonEmptyList } from "purify-ts";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
+    readonly equalsFunction: Code;
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    abstract readonly kind: "DateTimeType" | "DateType";
+    readonly mutable = false;
+    readonly name = "Date";
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    readonly typeofs: NonEmptyList<"object">;
+    get conversions(): readonly AbstractPrimitiveType.Conversion[];
+    protected get schemaObject(): {
+        in: Code[] | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
+    fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
+    hashStatements({ variables, }: Parameters<AbstractPrimitiveType<Date>["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractPrimitiveType.JsonType;
+    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfExpressionChain"]>;
+    protected abstract fromRdfResourceValueExpression(variables: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+}
+//# sourceMappingURL=AbstractDateType.d.ts.map

package/dist/generators/ts/AbstractDateType.js

@@ -0,0 +1,71 @@
+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 { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export class AbstractDateType extends AbstractPrimitiveType {
+    equalsFunction = code `${snippets.dateEquals}`;
+    filterFunction = code `${snippets.filterDate}`;
+    filterType = code `${snippets.DateFilter}`;
+    mutable = false;
+    name = "Date";
+    schemaType = code `${snippets.DateSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.dateSparqlWherePatterns}`;
+    typeofs = NonEmptyList(["object"]);
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
+                sourceTypeName: this.name,
+                sourceTypeof: "object",
+            },
+        ];
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0
+                ? this.primitiveIn.map((inValue) => code `new Date(${literalOf(inValue.toISOString())})`)
+                : undefined,
+        };
+    }
+    fromJsonExpression({ variables, }) {
+        return code `new Date(${variables.value})`;
+    }
+    hashStatements({ variables, }) {
+        return [
+            code `${variables.hasher}.update(${variables.value}.toISOString());`,
+        ];
+    }
+    jsonType() {
+        return new AbstractPrimitiveType.JsonType(code `string`);
+    }
+    toRdfExpression({ variables, }) {
+        return code `[${snippets.literalFactory}.date(${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()
+], AbstractDateType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractDateType.prototype, "jsonType", null);
+//# sourceMappingURL=AbstractDateType.js.map

package/dist/generators/ts/AbstractDeclaredType.d.ts

@@ -0,0 +1,23 @@
+import type { TsFeature } from "../../enums/index.js";
+import { AbstractType } from "./AbstractType.js";
+import type { Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractDeclaredType extends AbstractType {
+    abstract readonly declaration: Code;
+    readonly export: boolean;
+    readonly features: ReadonlySet<TsFeature>;
+    readonly name: string;
+    constructor({ export_, features, name, ...superParameters }: {
+        export_: boolean;
+        features: ReadonlySet<TsFeature>;
+        name: string;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+}
+export declare namespace AbstractDeclaredType {
+    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=AbstractDeclaredType.d.ts.map

package/dist/generators/ts/AbstractDeclaredType.js

@@ -0,0 +1,17 @@
+import { AbstractType } from "./AbstractType.js";
+export class AbstractDeclaredType extends AbstractType {
+    export;
+    features;
+    name;
+    constructor({ export_, features, name, ...superParameters }) {
+        super(superParameters);
+        this.export = export_;
+        this.features = features;
+        this.name = name;
+    }
+}
+(function (AbstractDeclaredType) {
+    AbstractDeclaredType.GraphqlType = AbstractType.GraphqlType;
+    AbstractDeclaredType.JsonType = AbstractType.JsonType;
+})(AbstractDeclaredType || (AbstractDeclaredType = {}));
+//# sourceMappingURL=AbstractDeclaredType.js.map

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -0,0 +1,14 @@
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import { type Code } from "ts-poet";
+import { AbstractTermType } from "./AbstractTermType.js";
+export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
+    abstract readonly fromStringFunction: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
+    abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
+    readonly toStringFunction: Code;
+    get conversions(): readonly AbstractTermType.Conversion[];
+    graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
+}
+//# sourceMappingURL=AbstractIdentifierType.d.ts.map

package/dist/generators/ts/AbstractIdentifierType.js

@@ -0,0 +1,38 @@
+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 { AbstractTermType } from "./AbstractTermType.js";
+import { imports } from "./imports.js";
+export class AbstractIdentifierType extends AbstractTermType {
+    graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
+    toStringFunction = // Re-export rdfjsResource.Resource.Identifier.toString
+     code `\
+// biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
+export const toString = ${imports.Resource}.Identifier.toString`;
+    get conversions() {
+        const conversions = super.conversions.concat();
+        if (this.nodeKinds.has("IRI")) {
+            conversions.push({
+                conversionExpression: (value) => code `${imports.dataFactory}.namedNode(${value})`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
+                sourceTypeName: this.in_.length > 0
+                    ? code `${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}`
+                    : code `string`,
+                sourceTypeof: "string",
+            });
+        }
+        return conversions;
+    }
+    graphqlResolveExpression({ variables: { value }, }) {
+        return code `${imports.Resource}.Identifier.toString(${value})`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractIdentifierType.prototype, "conversions", null);
+//# sourceMappingURL=AbstractIdentifierType.js.map

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -0,0 +1,63 @@
+import { Maybe, NonEmptyList } 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 AbstractLazyObjectType<PartialTypeT extends AbstractLazyObjectType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyObjectType.ResolveTypeConstraint> extends AbstractType {
+    protected readonly partialType: PartialTypeT;
+    protected readonly resolveType: ResolveTypeT;
+    protected readonly runtimeClass: {
+        readonly name: Code;
+        readonly partialPropertyName: string;
+        readonly rawName: Code;
+    };
+    readonly discriminantProperty: AbstractType["discriminantProperty"];
+    readonly mutable = false;
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ partialType, resolveType, runtimeClass, ...superParameters }: {
+        partialType: PartialTypeT;
+        resolveType: ResolveTypeT;
+        runtimeClass: AbstractLazyObjectType<ResolveTypeT, PartialTypeT>["runtimeClass"];
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get conversions(): readonly AbstractType.Conversion[];
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get name(): Code;
+    get schema(): Code;
+    get schemaType(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    protected get schemaObject(): {
+        partial: Code;
+        kind: Code;
+    };
+    hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema(parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractType["toRdfExpression"]>[0]): Code;
+    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
+        resolvedObjectUnionType: ObjectUnionType;
+        partialObjectUnionType: ObjectUnionType;
+        variables: {
+            resolvedObjectUnion: Code;
+        };
+    }): Code;
+}
+export declare namespace AbstractLazyObjectType {
+    type ObjectTypeConstraint = ObjectType | ObjectUnionType;
+    type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
+    type ResolveTypeConstraint = PartialTypeConstraint;
+    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=AbstractLazyObjectType.d.ts.map