@shaclmate/compiler 4.0.48 → 4.0.50

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

@@ -1,6 +0,0 @@
-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

@@ -1,241 +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 { 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

@@ -1,22 +0,0 @@
-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

@@ -1,68 +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 { 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

@@ -1,31 +0,0 @@
-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

@@ -1,143 +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 { 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

@@ -1,3 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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