@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/GraphqlSchema.js

@@ -1,87 +0,0 @@
-import { code } from "./ts-poet-wrapper.js";
-export class GraphqlSchema {
-    configuration;
-    reusables;
-    namedObjectTypes;
-    namedObjectUnionTypes;
-    constructor({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
-        this.configuration = configuration;
-        this.namedObjectTypes = namedObjectTypes;
-        this.namedObjectUnionTypes = namedObjectUnionTypes;
-        this.reusables = reusables;
-    }
-    get declaration() {
-        return code `\
-export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${this.graphqlQueryObjectType} });
-`;
-    }
-    get graphqlQueryObjectType() {
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
-            ...this.namedObjectTypes,
-            ...this.namedObjectUnionTypes,
-        ].reduce((fields, namedObjectType) => {
-            fields[namedObjectType.objectSetMethodNames.object] = {
-                args: {
-                    identifier: {
-                        type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID})`,
-                    },
-                },
-                resolve: code `\
-  async (_source, args: { identifier: string }, { objectSet }): Promise<${namedObjectType.expression}> => 
-    (await ${this.reusables.imports.EitherAsync}<Error, ${namedObjectType.expression}>(async ({ liftEither }) => 
-      liftEither(await objectSet.${namedObjectType.objectSetMethodNames.object}(await liftEither(${namedObjectType.identifierTypeAlias}.parse(args.identifier))))
-    )).unsafeCoerce()`,
-                type: namedObjectType.graphqlType.expression,
-            };
-            fields[namedObjectType.objectSetMethodNames.objectIdentifiers] = {
-                args: {
-                    limit: {
-                        type: code `${this.reusables.imports.GraphQLInt}`,
-                    },
-                    offset: {
-                        type: code `${this.reusables.imports.GraphQLInt}`,
-                    },
-                },
-                resolve: code `\
-   async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
-    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.stringify)`,
-                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${this.reusables.imports.GraphQLString}))`,
-            };
-            fields[namedObjectType.objectSetMethodNames.objects] = {
-                args: {
-                    identifiers: {
-                        type: code `new ${this.reusables.imports.GraphQLList}(new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLID}))`,
-                    },
-                    limit: {
-                        type: code `${this.reusables.imports.GraphQLInt}`,
-                    },
-                    offset: {
-                        type: code `${this.reusables.imports.GraphQLInt}`,
-                    },
-                },
-                resolve: code `\
-  async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${namedObjectType.expression}[]> =>
-  (await ${this.reusables.imports.EitherAsync}<Error, readonly ${namedObjectType.expression}[]>(async ({ liftEither }) => {
-    let filter: ${namedObjectType.filterType} | undefined;
-    if (args.identifiers) {
-      const identifiers: ${namedObjectType.identifierTypeAlias}[] = [];
-      for (const identifierArg of args.identifiers) {
-        identifiers.push(await liftEither(${namedObjectType.identifierTypeAlias}.parse(identifierArg)));
-      }
-      filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
-    }
-    return await liftEither(await objectSet.${namedObjectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
-  })).unsafeCoerce()`,
-                type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${namedObjectType.graphqlType.expression}))`,
-            };
-            fields[namedObjectType.objectSetMethodNames.objectCount] = {
-                resolve: code `\
-  async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${namedObjectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
-                type: code `new ${this.reusables.imports.GraphQLNonNull}(${this.reusables.imports.GraphQLInt})`,
-            };
-            return fields;
-        }, {})} })`;
-    }
-}
-//# sourceMappingURL=GraphqlSchema.js.map

package/dist/generators/ts/IdentifierType.d.ts

@@ -1,23 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
-import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
-    protected readonly inlineExpression: Code;
-    readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly filterFunction: Code;
-    readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
-    readonly kind = "Identifier";
-    readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    readonly parseFunction: Code;
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
-    constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-}
-//# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -1,83 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
-export class IdentifierType extends AbstractIdentifierType {
-    inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
-    conversionFunction = Maybe.of({
-        code: code `${this.reusables.snippets.convertToIdentifier}`,
-        sourceTypes: [
-            {
-                expression: code `${this.reusables.imports.BlankNode}`,
-                jsType: this.jsTypes[0],
-            },
-            {
-                expression: code `${this.reusables.imports.NamedNode}`,
-                jsType: this.jsTypes[0],
-            },
-            {
-                // To NamedNode
-                expression: code `string`,
-                jsType: { typeof: "string" },
-            },
-            {
-                // To BlankNode
-                expression: code `undefined`,
-                jsType: { typeof: "undefined" },
-            },
-        ],
-    });
-    filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
-    filterType = code `${this.reusables.snippets.IdentifierFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.identifierFromRdfResourceValues}`;
-    kind = "Identifier";
-    nodeKinds = nodeKinds;
-    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
-    schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
-    constructor(parameters) {
-        super({
-            ...parameters,
-            hasValues: [],
-            in_: [],
-        });
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...this.nodeKinds)})`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "BlankNode" | "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${variables.value}.termType as ${[...this.nodeKinds].map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`).join(" | ")}`
-            : "";
-        const valueToBlankNode = code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
-        const valueToNamedNode = code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
-        return code `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
-    }
-}
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "jsonType", null);
-const nodeKinds = new Set([
-    "BlankNode",
-    "IRI",
-]);
-//# sourceMappingURL=IdentifierType.js.map

package/dist/generators/ts/Imports.d.ts

@@ -1,40 +0,0 @@
-export declare class Imports {
-    readonly BigDecimal: import("ts-poet/build/Import.js").Import;
-    readonly BlankNode: import("ts-poet/build/Import.js").Import;
-    readonly dataFactory: import("ts-poet/build/Import.js").Import;
-    readonly DatasetCore: import("ts-poet/build/Import.js").Import;
-    readonly datasetFactory: import("ts-poet/build/Import.js").Import;
-    readonly Either: import("ts-poet/build/Import.js").Import;
-    readonly EitherAsync: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLBigInt: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLBoolean: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLDate: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLDateTime: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLFloat: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLID: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLInt: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLList: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLNonNull: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLObjectType: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLSchema: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLString: import("ts-poet/build/Import.js").Import;
-    readonly GraphQLUnionType: import("ts-poet/build/Import.js").Import;
-    readonly Left: import("ts-poet/build/Import.js").Import;
-    readonly Literal: import("ts-poet/build/Import.js").Import;
-    readonly LiteralFactory: import("ts-poet/build/Import.js").Import;
-    readonly Maybe: import("ts-poet/build/Import.js").Import;
-    readonly NamedNode: import("ts-poet/build/Import.js").Import;
-    readonly NonEmptyList: import("ts-poet/build/Import.js").Import;
-    readonly NTriplesIdentifier: import("ts-poet/build/Import.js").Import;
-    readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
-    readonly Quad: import("ts-poet/build/Import.js").Import;
-    readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
-    readonly RdfxResourcePropertyPath: import("ts-poet/build/Import.js").Import;
-    readonly Resource: import("ts-poet/build/Import.js").Import;
-    readonly ResourceSet: import("ts-poet/build/Import.js").Import;
-    readonly Right: import("ts-poet/build/Import.js").Import;
-    readonly sparqljs: import("ts-poet/build/Import.js").Import;
-    readonly Variable: import("ts-poet/build/Import.js").Import;
-    readonly z: import("ts-poet/build/Import.js").Import;
-}
-//# sourceMappingURL=Imports.d.ts.map

package/dist/generators/ts/Imports.js

@@ -1,41 +0,0 @@
-import { imp } from "./ts-poet-wrapper.js";
-export class Imports {
-    BigDecimal = imp("Decimal:BigDecimal@decimal.js");
-    BlankNode = imp("BlankNode@@rdfjs/types");
-    dataFactory = imp("dataFactory=@rdfx/data-factory");
-    DatasetCore = imp("DatasetCore@@rdfjs/types");
-    datasetFactory = imp("datasetFactory=@rdfjs/dataset");
-    Either = imp("Either@purify-ts");
-    EitherAsync = imp("EitherAsync@purify-ts");
-    GraphQLBigInt = imp("BigInt:GraphQLBigInt@graphql-scalars");
-    GraphQLBoolean = imp("GraphQLBoolean@graphql");
-    GraphQLDate = imp("Date:GraphQLDate@graphql-scalars");
-    GraphQLDateTime = imp("DateTime:GraphQLDateTime@graphql-scalars");
-    GraphQLFloat = imp("GraphQLFloat@graphql");
-    GraphQLID = imp("GraphQLID@graphql");
-    GraphQLInt = imp("GraphQLInt@graphql");
-    GraphQLList = imp("GraphQLList@graphql");
-    GraphQLNonNull = imp("GraphQLNonNull@graphql");
-    GraphQLObjectType = imp("GraphQLObjectType@graphql");
-    GraphQLSchema = imp("GraphQLSchema@graphql");
-    GraphQLString = imp("GraphQLString@graphql");
-    GraphQLUnionType = imp("GraphQLUnionType@graphql");
-    Left = imp("Left@purify-ts");
-    Literal = imp("Literal@@rdfjs/types");
-    LiteralFactory = imp("LiteralFactory@@rdfx/literal");
-    Maybe = imp("Maybe@purify-ts");
-    NamedNode = imp("NamedNode@@rdfjs/types");
-    NonEmptyList = imp("NonEmptyList@purify-ts");
-    NTriplesIdentifier = imp("NTriplesIdentifier@@rdfx/string");
-    NTriplesTerm = imp("NTriplesTerm@@rdfx/string");
-    Quad = imp("Quad@@rdfjs/types");
-    Quad_Graph = imp("Quad_Graph@@rdfjs/types");
-    RdfxResourcePropertyPath = imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource");
-    Resource = imp("Resource@@rdfx/resource");
-    ResourceSet = imp("ResourceSet@@rdfx/resource");
-    Right = imp("Right@purify-ts");
-    sparqljs = imp("sparqljs*sparqljs");
-    Variable = imp("Variable@@rdfjs/types");
-    z = imp("z@zod");
-}
-//# sourceMappingURL=Imports.js.map

package/dist/generators/ts/IntType.d.ts

@@ -1,13 +0,0 @@
-import type { Literal } from "@rdfjs/types";
-import { AbstractNumericType } from "./AbstractNumericType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class IntType extends AbstractNumericType<number> {
-    readonly jsTypes: readonly [{
-        readonly typeof: "number";
-    }];
-    readonly kind = "Int";
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
-    literalValueExpression(literal: Literal | number): Code;
-}
-//# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -1,30 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { LiteralDecoder } from "@rdfx/literal";
-import { Memoize } from "typescript-memoize";
-import { AbstractNumericType } from "./AbstractNumericType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class IntType extends AbstractNumericType {
-    jsTypes = [{ typeof: "number" }];
-    kind = "Int";
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`;
-    }
-    get graphqlType() {
-        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
-    }
-    literalValueExpression(literal) {
-        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
-    }
-}
-__decorate([
-    Memoize()
-], IntType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], IntType.prototype, "graphqlType", null);
-//# sourceMappingURL=IntType.js.map

package/dist/generators/ts/IriType.d.ts

@@ -1,23 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class IriType extends AbstractIdentifierType<NamedNode> {
-    readonly filterFunction: Code;
-    readonly filterType: Code;
-    readonly kind = "Iri";
-    readonly nodeKinds: ReadonlySet<"IRI">;
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
-    get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get fromRdfResourceValuesFunction(): Code;
-    get parseFunction(): Code;
-    protected get inlineExpression(): Code;
-    protected get schemaInitializers(): readonly Code[];
-    private get valueTypeExpression();
-    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<NamedNode>["toJsonExpression"]>[0]): Code;
-}
-//# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -1,112 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
-export class IriType extends AbstractIdentifierType {
-    filterFunction = code `${this.reusables.snippets.filterIri}`;
-    filterType = code `${this.reusables.snippets.IriFilter}`;
-    kind = "Iri";
-    nodeKinds = nodeKinds;
-    schemaType = code `${this.reusables.snippets.IriSchema}<${this.valueTypeExpression}>`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
-    get conversionFunction() {
-        invariant(this.jsTypes.length === 1);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
-            sourceTypes: [
-                {
-                    expression: this.valueTypeExpression,
-                    jsType: { typeof: "string" },
-                },
-                {
-                    expression: this.expression,
-                    jsType: this.jsTypes[0],
-                },
-            ],
-        });
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.iriFromRdfResourceValues}<${this.valueTypeExpression}>`;
-    }
-    get parseFunction() {
-        if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.expression});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
-        }
-        return code `${this.reusables.snippets.parseIri}`;
-    }
-    get inlineExpression() {
-        if (this.in_.length > 0) {
-            return code `${this.reusables.imports.NamedNode}<${this.valueTypeExpression}>`;
-        }
-        return code `${this.reusables.imports.NamedNode}`;
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.in_.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.rdfjsTermExpression(in_)))}`);
-        }
-        return initializers;
-    }
-    get valueTypeExpression() {
-        return this.in_.length > 0
-            ? code `(${this.in_.map((in_) => `"${in_.value}"`).join(" | ")})`
-            : code `string`;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"]))`;
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        let idSchema;
-        if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            idSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((iri) => iri.value))})`;
-        }
-        else {
-            idSchema = code `${this.reusables.imports.z}.string().min(1)`;
-        }
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("NamedNode")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.valueTypeExpression}${discriminantProperty} }`);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${variables.value}.termType`
-            : "";
-        return code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
-    }
-}
-__decorate([
-    Memoize()
-], IriType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "parseFunction", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "inlineExpression", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "valueTypeExpression", null);
-__decorate([
-    Memoize()
-], IriType.prototype, "jsonType", null);
-const nodeKinds = new Set(["IRI"]);
-//# sourceMappingURL=IriType.js.map

package/dist/generators/ts/LazyOptionType.d.ts

@@ -1,36 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractLazyType } from "./AbstractLazyType.js";
-import type { OptionType } from "./OptionType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
-declare const Super: (abstract new ({ partialType, resolveType, ...superParameters }: {
-    partialType: OptionType<AbstractLazyType.ItemTypeConstraint>;
-    resolveType: OptionType<AbstractLazyType.ItemTypeConstraint>;
-} & {
-    name: Maybe<string>;
-    comment: Maybe<string>;
-    configuration: import("./TsGenerator.js").TsGenerator.Configuration;
-    label: Maybe<string>;
-    logger: import("ts-log").Logger;
-    reusables: import("./Reusables.js").Reusables;
-    shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode;
-}) => AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>) & {
-    readonly GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
-    readonly JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
-    JsType: typeof import("./AbstractType.js").AbstractType.JsType;
-};
-export declare class LazyOptionType extends Super {
-    readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazyOption";
-    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
-    protected get runtimeClass(): {
-        name: Code;
-        partialPropertyName: string;
-        rawName: Code;
-    };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-}
-export {};
-//# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -1,75 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractLazyType } from "./AbstractLazyType.js";
-import { code } from "./ts-poet-wrapper.js";
-const Super = (AbstractLazyType);
-export class LazyOptionType extends Super {
-    graphqlArgs = Maybe.empty();
-    kind = "LazyOption";
-    get conversionFunction() {
-        invariant(this.jsTypes.length === 1);
-        invariant(this.resolveType.jsTypes.length === 1);
-        invariant(this.resolveType.itemType.jsTypes.length === 1);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToLazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
-            sourceTypes: [
-                {
-                    expression: this.expression,
-                    jsType: this.jsTypes[0],
-                },
-                {
-                    expression: this.resolveType.expression,
-                    jsType: this.resolveType.jsTypes[0],
-                },
-                {
-                    expression: this.resolveType.itemType.expression,
-                    jsType: this.resolveType.itemType.jsTypes[0],
-                },
-                {
-                    expression: code `undefined`,
-                    jsType: { typeof: "undefined" },
-                },
-            ],
-        });
-    }
-    get runtimeClass() {
-        return {
-            name: code `${this.reusables.snippets.LazyOption}<${this.partialType.itemType.expression}, ${this.resolveType.itemType.expression}>`,
-            partialPropertyName: "partial",
-            rawName: code `${this.reusables.snippets.LazyOption}`,
-        };
-    }
-    fromJsonExpression(parameters) {
-        return code `${this.partialType.fromJsonExpression(parameters)}.map(partial => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: partial, resolver: (partial) => Promise.resolve(${this.reusables.imports.Left}(new Error(\`unable to resolve \${partial} deserialized from JSON\`))) }))`;
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `\
-(
-    (
-      (values, { objectSet, schema, ...otherOptions }) =>
-        ${this.partialType.fromRdfResourceValuesFunction}(values, { ...otherOptions, objectSet, schema: schema.partialType })
-          .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (partial, options) => objectSet.${this.resolveType.itemType.objectSetMethodNames.object}(partial.${this.configuration.syntheticNamePrefix}identifier(), options) })))
-    ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>
-)`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;
-    }
-}
-__decorate([
-    Memoize()
-], LazyOptionType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], LazyOptionType.prototype, "runtimeClass", null);
-__decorate([
-    Memoize()
-], LazyOptionType.prototype, "fromRdfResourceValuesFunction", null);
-//# sourceMappingURL=LazyOptionType.js.map

package/dist/generators/ts/LazySetType.d.ts

@@ -1,20 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractLazyType } from "./AbstractLazyType.js";
-import type { SetType } from "./SetType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>> {
-    readonly graphqlArgs: Super["graphqlArgs"];
-    readonly kind = "LazySet";
-    get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
-    protected get runtimeClass(): {
-        name: Code;
-        partialPropertyName: string;
-        rawName: Code;
-    };
-    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-}
-type Super = AbstractLazyType<SetType<AbstractLazyType.ItemTypeConstraint>, SetType<AbstractLazyType.ItemTypeConstraint>>;
-export {};
-//# sourceMappingURL=LazySetType.d.ts.map