@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/SparqlObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=SparqlObjectSetType.d.ts.map

package/dist/generators/ts/SparqlObjectSetType.js

@@ -0,0 +1,241 @@
+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 { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class SparqlObjectSetType extends AbstractObjectSetType {
+    get declaration() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const parameters = {
+            constructObjectType: code `namedObjectType: {\
+  focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
+  fromRdfResource:  ${this.reusables.snippets.FromRdfResourceFunction}<ObjectT>;
+  sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; } & Omit<${this.reusables.imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${this.reusables.imports.sparqljs}.GeneratorOptions) => string;
+}`,
+            query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+            selectObjectTypeType: code `namedObjectType: { focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
+        };
+        const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${this.reusables.imports.Quad}[]>; }`;
+        const typeParameters = {
+            ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
+            ObjectFilterT: code `ObjectFilterT`,
+            ObjectIdentifierT: code `ObjectIdentifierT extends ${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode}`,
+        };
+        return code `\
+export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
+  readonly #countVariable = ${this.reusables.imports.dataFactory}.variable!("count");;
+  readonly #graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}>;
+  readonly #objectVariable = ${this.reusables.imports.dataFactory}.variable!("object");
+  readonly #sparqlClient: ${sparqlClientType};
+  readonly #sparqlGenerator = new ${this.reusables.imports.sparqljs}.Generator();
+
+  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${this.reusables.imports.Quad_Graph}, ${this.reusables.imports.Variable}> }) {
+    this.#graph = options?.graph;
+    this.#sparqlClient = sparqlClient;
+  }
+
+${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((namedObjectType) => {
+            const methodSignatures = this.methodSignatures(namedObjectType, {
+                queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
+            });
+            const runtimeObjectType = namedObjectType.expression;
+            return [
+                code `\
+async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
+  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages })).map(objects => objects[0]);
+}`,
+                code `\
+async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
+  return this.#objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+                code `\
+async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
+  return this.#objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+                code `\
+async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
+  return this.#objects<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+}`,
+            ];
+        }), { on: "\n\n" })}
+
+  #mapBindingsToCount(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): ${this.reusables.imports.Either}<Error, number> {
+    if (bindings.length === 0) {
+      return ${this.reusables.imports.Left}(new Error("empty result rows"));
+    }
+    if (bindings.length > 1) {
+      return ${this.reusables.imports.Left}(new Error("more than one result row"));
+    }
+    const count = bindings[0][variable];
+    if (count === undefined) {
+      return ${this.reusables.imports.Left}(new Error("no 'count' variable in result row"));
+    }
+    if (count.termType !== "Literal") {
+      return ${this.reusables.imports.Left}(new Error("'count' variable is not a Literal"));
+    }
+    const parsedCount = Number.parseInt(count.value, 10);
+    if (Number.isNaN(parsedCount)) {
+      return ${this.reusables.imports.Left}(new Error("'count' variable is NaN"));
+    }
+    return ${this.reusables.imports.Right}(parsedCount);
+  }
+
+  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${this.reusables.imports.BlankNode} | ${this.reusables.imports.Literal} | ${this.reusables.imports.NamedNode}>[], variable: string): readonly ${this.reusables.imports.NamedNode}[] {
+    const identifiers: ${this.reusables.imports.NamedNode}[] = [];
+    for (const bindings_ of bindings) {
+      const identifier = bindings_[variable];
+      if (
+        identifier !== undefined &&
+        identifier.termType === "NamedNode"
+      ) {
+        identifiers.push(identifier);
+      }
+    }
+    return identifiers;
+  }
+
+  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+    if (query?.identifiers) {
+      return ${this.reusables.imports.Right}(query.identifiers);
+    }
+
+    const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+    if (limit <= 0) {
+      return ${this.reusables.imports.Right}([]);
+    }
+
+    let offset = query?.offset ?? 0;
+    if (offset < 0) {
+      offset = 0;
+    }
+
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
+    if (wherePatterns.length === 0) {
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
+    }
+
+    const selectQueryString = \
+      this.#sparqlGenerator.stringify({
+        distinct: true,
+        limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
+        offset,
+        order: query?.order ? query.order(this.#objectVariable).concat() : [{ expression: this.#objectVariable }],
+        prefixes: {},
+        queryType: "SELECT",
+        type: "query",
+        variables: [this.#objectVariable],
+        where: wherePatterns.concat()
+      });
+      
+    return ${this.reusables.imports.EitherAsync}(async () =>
+      this.#mapBindingsToIdentifiers(
+        await this.#sparqlClient.queryBindings(selectQueryString),
+        this.#objectVariable.value,
+      ) as readonly ObjectIdentifierT[],
+    );  
+  }
+
+  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, readonly ObjectT[]>> {
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) => {
+      const identifiers = await liftEither(await this.#objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
+      if (identifiers.length === 0) {
+        return [];
+      }
+
+      const constructQueryString = namedObjectType.sparqlConstructQueryString({
+        subject: this.#objectVariable,
+        where: [{
+          type: "values" as const,
+          values: identifiers.map((identifier) => {
+            const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
+            valuePatternRow["?object"] = identifier as ${this.reusables.imports.NamedNode};
+            return valuePatternRow;
+          }),
+        }]
+      });
+
+      const quads = await this.#sparqlClient.queryQuads(constructQueryString);
+
+      const dataset = ${this.reusables.imports.datasetFactory}.dataset(quads.concat());
+      const objects: ObjectT[] = [];
+      for (const identifier of identifiers) {
+        objects.push(await liftEither(namedObjectType.fromRdfResource(new ${this.reusables.imports.Resource}({ dataFactory: ${this.reusables.imports.dataFactory}, dataset: dataset, identifier: identifier as ${this.reusables.imports.NamedNode} }), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
+      }
+      return objects;
+    });
+  }
+
+  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${this.reusables.imports.Either}<Error, number>> {
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
+    if (wherePatterns.length === 0) {
+      return ${this.reusables.imports.Left}(new Error("no SPARQL WHERE patterns for count"));
+    }
+
+    const selectQueryString = \
+      this.#sparqlGenerator.stringify({
+        prefixes: {},
+        queryType: "SELECT",
+        type: "query",
+        variables: [
+          {
+            expression: {
+              aggregation: "COUNT",
+              distinct: true,
+              expression: this.#objectVariable,
+              type: "aggregate",
+            },
+            variable: this.#countVariable,
+          },
+        ],
+        where: wherePatterns.concat()
+      });
+
+    return ${this.reusables.imports.EitherAsync}(async ({ liftEither }) =>
+      liftEither(
+        this.#mapBindingsToCount(
+          await this.#sparqlClient.queryBindings(selectQueryString),
+          this.#countVariable.value,
+        ),
+      ),
+    );
+  }
+
+  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${this.reusables.imports.sparqljs}.Pattern[] {
+    // Patterns should be most to least specific.
+    let patterns: ${this.reusables.imports.sparqljs}.Pattern[] = [];
+
+    if (query?.where) {
+      patterns = patterns.concat(query.where(this.#objectVariable));
+    }
+
+    patterns = patterns.concat(namedObjectType.focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
+
+    patterns = ${this.reusables.snippets.normalizeSparqlWherePatterns}(patterns).concat();
+
+    const graph = query?.graph ?? this.#graph;
+    if (graph) {
+      switch (graph.termType) {
+        case "DefaultGraph":
+          return patterns; // Patterns without a GRAPH pattern around them query the default graph
+        case "NamedNode":
+          return [{ name: graph, patterns, type: "graph" }];
+      }
+    }
+    // Union of all graphs: { ... patterns covering default graph ... } UNION { GRAPH ?g { ... patterns covering named graphs ... } }
+    return [{ patterns: [{ patterns, type: "group" }, { name: ${this.reusables.imports.dataFactory}.variable!("g"), patterns, type: "graph" }], type: "union" }];
+  }
+}
+  
+export namespace ${syntheticNamePrefix}SparqlObjectSet {
+  export type Query<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}> = ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT> & { readonly order?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Ordering[]; readonly where?: (objectVariable: ${this.reusables.imports.Variable}) => readonly ${this.reusables.imports.sparqljs}.Pattern[] };
+}`;
+    }
+}
+__decorate([
+    Memoize()
+], SparqlObjectSetType.prototype, "declaration", null);
+//# sourceMappingURL=SparqlObjectSetType.js.map

package/dist/generators/ts/StringType.d.ts

@@ -0,0 +1,22 @@
+import type { Literal } from "@rdfjs/types";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class StringType extends AbstractPrimitiveType<string> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "string";
+    }];
+    readonly kind = "String";
+    readonly valueSparqlWherePatternsFunction: Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get schemaType(): Code;
+    protected get inlineExpression(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
+    literalValueExpression(literal: Literal | string): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
+}
+//# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -0,0 +1,68 @@
+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 { xsd } from "@tpluscode/rdf-ns-builders";
+import { Memoize } from "typescript-memoize";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
+export class StringType extends AbstractPrimitiveType {
+    filterFunction = code `${this.reusables.snippets.filterString}`;
+    filterType = code `${this.reusables.snippets.StringFilter}`;
+    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashString}`;
+    jsTypes = [
+        {
+            typeof: "string",
+        },
+    ];
+    kind = "String";
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.stringFromRdfResourceValues}<${this.expression}>`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
+    }
+    get inlineExpression() {
+        if (this.primitiveIn.length > 0) {
+            return code `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
+        }
+        return code `string`;
+    }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.languageIn.length > 0) {
+            initializers = initializers.concat(code `languageIn: ${arrayOf(...this.languageIn)}`);
+        }
+        return initializers;
+    }
+    jsonSchema(_parameters) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return code `${this.reusables.imports.z}.string()`;
+            case 1:
+                return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
+            default:
+                return code `${this.reusables.imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
+        }
+    }
+    literalValueExpression(literal) {
+        return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
+    }
+}
+__decorate([
+    Memoize()
+], StringType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "inlineExpression", null);
+//# sourceMappingURL=StringType.js.map

package/dist/generators/ts/TermType.d.ts

@@ -0,0 +1,31 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractTermType {
+    readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
+    readonly filterFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
+    readonly kind = "Term";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly valueSparqlWherePatternsFunction: Code;
+    constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
+        nodeKinds: ReadonlySet<NodeKind>;
+    });
+    get fromRdfResourceValuesFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractTermType.GraphqlType;
+    get schemaType(): Code;
+    protected get inlineExpression(): Code;
+    protected get schemaInitializers(): Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractTermType.JsonType;
+    toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
+}
+//# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -0,0 +1,143 @@
+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 { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+export class TermType extends AbstractTermType {
+    conversionFunction = Maybe.empty();
+    filterFunction = code `${this.reusables.snippets.filterTerm}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
+    kind = "Term";
+    nodeKinds;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
+    constructor({ nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.nodeKinds = nodeKinds;
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`;
+    }
+    get filterType() {
+        return code `${this.reusables.snippets.TermFilter}<${this.expression}>`;
+    }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.TermSchema}<${this.expression}>`;
+    }
+    get inlineExpression() {
+        return code `(${joinCode([...this.nodeKinds]
+            .map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                    return this.reusables.imports.BlankNode;
+                case "IRI":
+                    return this.reusables.imports.NamedNode;
+                case "Literal":
+                    return this.reusables.imports.Literal;
+                default:
+                    nodeKind;
+                    throw new RangeError(nodeKind);
+            }
+        })
+            .map((import_) => code `${import_}`), { on: " | " })})`;
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`);
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
+            ...this.nodeKinds,
+        ].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+                    break;
+                case "IRI":
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression == null
+                ? valueToNodeKind
+                : code `((${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? (${valueToNodeKind}) : (${expression}))`;
+        }, null)})`;
+    }
+    graphqlResolveExpression(_parameters) {
+        throw new Error("not implemented");
+    }
+    jsonSchema(_parameters) {
+        return code `${this.reusables.imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                case "IRI":
+                    return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1), termType: ${this.reusables.imports.z}.literal("${NodeKind.toTermType(nodeKind)}") })`;
+                case "Literal":
+                    return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional(), "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string(), termType: ${this.reusables.imports.z}.literal("Literal") })`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        }), { on: "," })}])`;
+    }
+    jsonType() {
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
+            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
+    }
+    toJsonExpression({ variables, }) {
+        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = code `{ "@id": \`_:\${${variables.value}.value}\`, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
+                    break;
+                case "IRI":
+                    valueToNodeKind = code `{ "@id": ${variables.value}.value, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression === null
+                ? valueToNodeKind
+                : code `(${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? ${valueToNodeKind} : ${expression}`;
+        }, null);
+    }
+}
+__decorate([
+    Memoize()
+], TermType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "jsonType", null);
+//# sourceMappingURL=TermType.js.map

package/dist/generators/ts/TsFeature.d.ts

@@ -0,0 +1,3 @@
+export type TsFeature = (typeof TS_FEATURES)[number];
+export declare const TS_FEATURES: readonly ["GraphQL", "JSON", "Object.create", "Object.equals", "Object.filter", "Object.fromJson", "Object.fromRdf", "Object.hash", "Object.JSON", "Object.JSON.type", "Object.JSON.parse", "Object.JSON.schema", "Object.JSON.uiSchema", "Object.RDF", "Object.schema", "Object.SPARQL", "Object.toJson", "Object.toRdf", "Object.toString", "Object.type", "ObjectSet", "RDF", "RdfjsDatasetObjectSet", "SPARQL", "SparqlObjectSet"];
+//# sourceMappingURL=TsFeature.d.ts.map

package/dist/generators/ts/TsFeature.js

@@ -0,0 +1,28 @@
+export const TS_FEATURES = [
+    "GraphQL",
+    "JSON",
+    "Object.create",
+    "Object.equals",
+    "Object.filter",
+    "Object.fromJson",
+    "Object.fromRdf",
+    "Object.hash",
+    "Object.JSON",
+    "Object.JSON.type",
+    "Object.JSON.parse",
+    "Object.JSON.schema",
+    "Object.JSON.uiSchema",
+    "Object.RDF",
+    "Object.schema",
+    "Object.SPARQL",
+    "Object.toJson",
+    "Object.toRdf",
+    "Object.toString",
+    "Object.type",
+    "ObjectSet",
+    "RDF",
+    "RdfjsDatasetObjectSet",
+    "SPARQL",
+    "SparqlObjectSet",
+];
+//# sourceMappingURL=TsFeature.js.map

package/dist/generators/ts/TsGenerator.d.ts

@@ -0,0 +1,30 @@
+import type { Logger } from "ts-log";
+import type * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+import type { TsFeature } from "./TsFeature.js";
+export declare class TsGenerator implements Generator {
+    private readonly configuration?;
+    private readonly logger;
+    constructor({ configuration, logger, }: {
+        configuration?: Partial<TsGenerator.Configuration>;
+        logger: Logger;
+    });
+    generate(ast_: ast.Ast): string;
+    private objectSetTypeDeclarations;
+    /**
+     * Synthesize the $Object union.
+     */
+    private synthesizeUberObjectUnionType;
+}
+export declare namespace TsGenerator {
+    interface Configuration {
+        readonly features: ReadonlySet<TsFeature>;
+        readonly finalized: true;
+        readonly syntheticNamePrefix: string;
+    }
+    namespace Configuration {
+        const default_: Omit<Configuration, "finalized">;
+        function finalize(ast: ast.Ast, partialConfiguration?: Partial<Configuration>): Configuration;
+    }
+}
+//# sourceMappingURL=TsGenerator.d.ts.map