@shaclmate/compiler 4.0.52 → 4.0.54

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -6,7 +6,7 @@ import type * as ast from "./ast/index.js";
 import type * as input from "./input/index.js";
 export declare class ShapesGraphToAstTransformer {
     protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
-    protected readonly syntheticAstStructTypesByName: Map<string, ast.StructType>;
+    protected readonly syntheticAstStructTypes: ast.StructType[];
     protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
     constructor({ logger, shapesGraph, }: {

package/dist/ShapesGraphToAstTransformer.js

@@ -5,7 +5,7 @@ import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transfor
 export class ShapesGraphToAstTransformer {
     // Members are protected so they're accessible to functions in other files
     cachedAstTypesByShapeIdentifier = new TermMap();
-    syntheticAstStructTypesByName = new Map();
+    syntheticAstStructTypes = [];
     logger;
     shapesGraph;
     constructor({ logger, shapesGraph, }) {
@@ -41,9 +41,7 @@ export class ShapesGraphToAstTransformer {
                         return acc;
                 }
             }, 0),
-            namedTypes: astNamedTypes.concat([
-                ...this.syntheticAstStructTypesByName.values(),
-            ]),
+            namedTypes: astNamedTypes.concat(this.syntheticAstStructTypes),
         });
     }
 }

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -1,5 +1,5 @@
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { Either, Left } from "purify-ts";
+import { Either, Left, Maybe } from "purify-ts";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 const defaultPropertyShapeNodeKinds = new Set([
     "BlankNode",
@@ -90,6 +90,28 @@ export function shapeNodeKinds(shape, options) {
                     .orDefault([]),
             },
         ],
+        [
+            "sh:node",
+            {
+                includeNodeKinds: shape.node
+                    .chain((node) => this.shapesGraph.nodeShape(node).toMaybe())
+                    .chain((nodeShape) => shapeNodeKinds.call(this, nodeShape).toMaybe())
+                    .map((nodeKinds) => [...nodeKinds])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "shaclmate:resolve",
+            {
+                includeNodeKinds: (shape.$type === "PropertyShape"
+                    ? shape.resolve
+                    : Maybe.empty())
+                    .chain((resolve) => this.shapesGraph.nodeShape(resolve).toMaybe())
+                    .chain((nodeShape) => shapeNodeKinds.call(this, nodeShape).toMaybe())
+                    .map((nodeKinds) => [...nodeKinds])
+                    .orDefault([]),
+            },
+        ],
     ]) {
         for (const excludeNodeKind of excludeNodeKinds ?? []) {
             if (explicitNodeKinds.size > 0 &&

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -60,7 +60,8 @@ function synthesizePartialAstStructType({ identifierType, }) {
             syntheticName = "NamedDefaultPartial";
             break;
     }
-    let partialAstStructType = this.syntheticAstStructTypesByName.get(syntheticName);
+    let partialAstStructType = this.syntheticAstStructTypes.find((syntheticAstStructType) => syntheticAstStructType.name.extract() === syntheticName &&
+        ast.Type.equals(syntheticAstStructType.identifierType, identifierType));
     if (partialAstStructType) {
         return partialAstStructType;
     }
@@ -76,7 +77,7 @@ function synthesizePartialAstStructType({ identifierType, }) {
         toRdfTypes: [],
         tsImports: [],
     });
-    this.syntheticAstStructTypesByName.set(syntheticName, partialAstStructType);
+    this.syntheticAstStructTypes.push(partialAstStructType);
     return partialAstStructType;
 }
 function transformPropertyShapeToAstType(propertyShape, shapeStack) {

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

@@ -10,6 +10,7 @@ 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 { LangStringType } from "./LangStringType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectType } from "./ObjectType.js";
@@ -45,7 +46,7 @@ export declare namespace AbstractContainerType {
     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 | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LangStringType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | StringType | TermType | UnionType<Type>;
     function isItemType(type: Type): type is ItemType;
     const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractType.JsonType;

package/dist/generators/ts/AbstractContainerType.js

@@ -74,6 +74,7 @@ __decorate([
             case "Identifier":
             case "Int":
             case "Iri":
+            case "LangString":
             case "List":
             case "Literal":
             case "Object":

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

@@ -1,7 +1,9 @@
-import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { Maybe } from "purify-ts";
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
+export declare abstract class AbstractDateType extends AbstractTypedLiteralType<Date> {
     protected readonly inlineExpression: Code;
+    readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
@@ -9,15 +11,13 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
         readonly instanceof: "Date";
         readonly typeof: "object";
     }];
-    abstract readonly kind: "DateTime" | "Date";
-    readonly mutable = false;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
-    jsonType(): AbstractPrimitiveType.JsonType;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["fromJsonExpression"]>[0]): Code;
+    jsonType(): AbstractTypedLiteralType.JsonType;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractDateType {
-    type ConversionFunction = AbstractPrimitiveType.ConversionFunction;
+    type ConversionFunction = AbstractTypedLiteralType.ConversionFunction;
 }
 //# sourceMappingURL=AbstractDateType.d.ts.map

package/dist/generators/ts/AbstractDateType.js

@@ -1,14 +1,9 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Memoize } from "typescript-memoize";
-import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class AbstractDateType extends AbstractPrimitiveType {
+import { Maybe } from "purify-ts";
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export class AbstractDateType extends AbstractTypedLiteralType {
     inlineExpression = code `Date`;
+    conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
@@ -18,20 +13,16 @@ export class AbstractDateType extends AbstractPrimitiveType {
             typeof: "object",
         },
     ];
-    mutable = false;
     schemaType = code `${this.reusables.snippets.DateSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}))`;
+        return code `${this.reusables.imports.Either}.of<Error, Date>(new Date(${variables.value}["@value"]))`;
     }
     jsonType() {
-        return new AbstractPrimitiveType.JsonType(code `string`);
+        return new AbstractTypedLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
 }
-__decorate([
-    Memoize()
-], AbstractDateType.prototype, "jsonType", null);
 //# sourceMappingURL=AbstractDateType.js.map

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

@@ -1,12 +1,11 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractTermType } from "./AbstractTermType.js";
 import type { Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class of all types that are literals in RDF.
+ */
 export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
-    protected readonly languageIn: readonly string[];
     readonly nodeKinds: ReadonlySet<"Literal">;
-    constructor({ languageIn, ...superParameters }: {
-        languageIn: readonly string[];
-    } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
     /**
      * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
      *

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,11 +1,9 @@
 import { AbstractTermType } from "./AbstractTermType.js";
+/**
+ * Abstract base class of all types that are literals in RDF.
+ */
 export class AbstractLiteralType extends AbstractTermType {
-    languageIn;
     nodeKinds = nodeKinds;
-    constructor({ languageIn, ...superParameters }) {
-        super(superParameters);
-        this.languageIn = languageIn;
-    }
 }
 (function (AbstractLiteralType) {
     AbstractLiteralType.GraphqlType = AbstractTermType.GraphqlType;

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -10,8 +10,6 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
     get filterType(): Code;
     get schemaType(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get inlineExpression(): Code;
-    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractNumericType {

package/dist/generators/ts/AbstractNumericType.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
@@ -24,22 +24,6 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`;
     }
-    get inlineExpression() {
-        if (this.primitiveIn.length > 0) {
-            return code `${joinCode(this.primitiveIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
-        }
-        return code `${this.jsTypes[0].typeof}`;
-    }
-    jsonSchema(_parameters) {
-        switch (this.primitiveIn.length) {
-            case 0:
-                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
-            case 1:
-                return code `${this.reusables.imports.z}.literal(${this.literalValueExpression(this.primitiveIn[0])})`;
-            default:
-                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalValueExpression(value)})`), { on: "," })}])`;
-        }
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
@@ -56,9 +40,6 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "inlineExpression", null);
 (function (AbstractNumericType) {
     AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
 })(AbstractNumericType || (AbstractNumericType = {}));

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

@@ -1,23 +1,18 @@
-import type { Literal, NamedNode } from "@rdfjs/types";
+import type { Primitive } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractPrimitiveType<ValueT extends bigint | boolean | Date | string | number> extends AbstractLiteralType {
-    protected readonly datatype: NamedNode;
+/**
+ * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
+ */
+export declare abstract class AbstractPrimitiveType<ValueT extends Primitive> extends AbstractTypedLiteralType<ValueT> {
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
-    abstract readonly kind: "BigInt" | "Boolean" | "DateTime" | "Date" | "Float" | "Int" | "NumberType" | "String";
-    readonly primitiveIn: readonly ValueT[];
-    constructor({ datatype, primitiveIn, ...superParameters }: {
-        datatype: NamedNode;
-        primitiveIn: readonly ValueT[];
-    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
-    protected get schemaInitializers(): readonly Code[];
+    protected get inlineExpression(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
+    jsonSchema(_parameters: Parameters<AbstractTypedLiteralType<ValueT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    abstract literalValueExpression(literal: Literal | ValueT): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractPrimitiveType {

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,32 +7,32 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
-export class AbstractPrimitiveType extends AbstractLiteralType {
-    datatype;
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
+ */
+export class AbstractPrimitiveType extends AbstractTypedLiteralType {
     conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
-    primitiveIn;
-    constructor({ datatype, primitiveIn, ...superParameters }) {
-        super(superParameters);
-        this.datatype = datatype;
-        this.primitiveIn = primitiveIn;
-    }
-    get discriminantProperty() {
-        return Maybe.empty();
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.primitiveIn.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalValueExpression(in_)))} as const`);
+    get inlineExpression() {
+        if (this.decodedIn.length > 0) {
+            return code `${joinCode(this.decodedIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
         }
-        return initializers;
+        return code `${this.jsTypes[0].typeof}`;
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
     }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
+    jsonSchema(_parameters) {
+        switch (this.decodedIn.length) {
+            case 0:
+                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
+            case 1:
+                return code `${this.reusables.imports.z}.literal(${this.literalValueExpression(this.decodedIn[0])})`;
+            default:
+                return code `${this.reusables.imports.z}.union(${arrayOf(...this.decodedIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalValueExpression(value)})`))})`;
+        }
     }
     jsonType() {
         return new AbstractLiteralType.JsonType(this.expression);
@@ -41,6 +41,9 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         return variables.value;
     }
 }
+__decorate([
+    Memoize()
+], AbstractPrimitiveType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], AbstractPrimitiveType.prototype, "jsonType", null);

package/dist/generators/ts/AbstractTypedLiteralType.d.ts

@@ -0,0 +1,32 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
+ *  - a language-tagged string literal (datatype = rdf:langString, language = not empty)
+ *  - a typed literal (datatype = anything else, language = empty)
+ */
+export declare abstract class AbstractTypedLiteralType<ValueT> extends AbstractLiteralType {
+    readonly datatype: NamedNode;
+    readonly decodedIn: readonly ValueT[];
+    constructor({ datatype, decodedIn, ...superParameters }: {
+        datatype: NamedNode;
+        readonly decodedIn: readonly ValueT[];
+    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
+    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    protected get schemaInitializers(): readonly Code[];
+    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
+    abstract literalValueExpression(literal: Literal | ValueT): Code;
+}
+export declare namespace AbstractTypedLiteralType {
+    type ConversionFunction = AbstractTermType.ConversionFunction;
+    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractTermType.GraphqlType;
+    type JsType = AbstractTermType.JsType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractTermType.JsonType;
+}
+//# sourceMappingURL=AbstractTypedLiteralType.d.ts.map

package/dist/generators/ts/AbstractTypedLiteralType.js

@@ -0,0 +1,36 @@
+import { Maybe } from "purify-ts";
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { arrayOf, code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
+ *  - a language-tagged string literal (datatype = rdf:langString, language = not empty)
+ *  - a typed literal (datatype = anything else, language = empty)
+ */
+export class AbstractTypedLiteralType extends AbstractLiteralType {
+    datatype;
+    decodedIn;
+    constructor({ datatype, decodedIn, ...superParameters }) {
+        super(superParameters);
+        this.datatype = datatype;
+        this.decodedIn = decodedIn;
+    }
+    get discriminantProperty() {
+        return Maybe.empty();
+    }
+    get schemaInitializers() {
+        let initializers = super.schemaInitializers;
+        if (this.decodedIn.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.decodedIn.map((in_) => this.literalValueExpression(in_)))} as const`);
+        }
+        return initializers;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+}
+(function (AbstractTypedLiteralType) {
+    AbstractTypedLiteralType.GraphqlType = AbstractTermType.GraphqlType;
+    AbstractTypedLiteralType.JsonType = AbstractTermType.JsonType;
+})(AbstractTypedLiteralType || (AbstractTypedLiteralType = {}));
+//# sourceMappingURL=AbstractTypedLiteralType.js.map

package/dist/generators/ts/BigDecimalType.d.ts

@@ -1,8 +1,10 @@
 import type { Literal } from "@rdfjs/types";
+import type { Decimal } from "decimal.js";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class BigDecimalType extends AbstractLiteralType {
+export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
@@ -22,7 +24,7 @@ export declare class BigDecimalType extends AbstractLiteralType {
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
     literalValueExpression(literal: Literal): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -7,8 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
-export class BigDecimalType extends AbstractLiteralType {
+export class BigDecimalType extends AbstractTypedLiteralType {
     inlineExpression = code `${this.reusables.imports.BigDecimal}`;
     conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
@@ -25,22 +26,22 @@ export class BigDecimalType extends AbstractLiteralType {
         return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => new ${this.expression}(${variables.value}))`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => new ${this.expression}(${variables.value}["@value"]))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
     jsonSchema() {
-        return code `${this.reusables.imports.z}.string()`;
+        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.string() })`;
     }
     jsonType() {
-        return new AbstractLiteralType.JsonType(code `string`);
+        return new AbstractLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
     }
     literalValueExpression(literal) {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
     }
     toJsonExpression({ variables, }) {
-        return code `${variables.value}.toFixed()`;
+        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${variables.value}.toFixed() }`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
@@ -49,10 +50,4 @@ export class BigDecimalType extends AbstractLiteralType {
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], BigDecimalType.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], BigDecimalType.prototype, "jsonType", null);
 //# sourceMappingURL=BigDecimalType.js.map

package/dist/generators/ts/BigIntType.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
     jsTypes = [{ typeof: "bigint" }];
     kind = "BigInt";
@@ -18,30 +18,41 @@ export class BigIntType extends AbstractNumericType {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        let expression = code `BigInt(${variables.value})`;
-        if (this.primitiveIn.length > 0) {
+        let expression = code `BigInt(${variables.value}["@value"])`;
+        if (this.decodedIn.length > 0) {
             expression = code `${expression} as ${this.expression}`;
         }
         return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
     }
     jsonSchema(_parameters) {
-        switch (this.primitiveIn.length) {
+        let valueJsonSchema;
+        switch (this.decodedIn.length) {
             case 0:
-                return code `${this.reusables.imports.z}.string()`;
+                valueJsonSchema = code `${this.reusables.imports.z}.string()`;
+                break;
             case 1:
-                return code `${this.reusables.imports.z}.literal(${literalOf(this.primitiveIn[0].toString())})`;
+                valueJsonSchema = code `${this.reusables.imports.z}.literal(${literalOf(this.decodedIn[0].toString())})`;
+                break;
             default:
-                return code `${this.reusables.imports.z}.enum([${joinCode(this.primitiveIn.map((value) => code `${literalOf(value.toString())}`), { on: "," })}])`;
+                valueJsonSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.decodedIn.map((value) => code `${literalOf(value.toString())}`))})`;
+                break;
         }
+        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${valueJsonSchema} })`;
     }
     jsonType() {
-        return new AbstractNumericType.JsonType(code `string`);
+        return new AbstractNumericType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": ${this.decodedIn.length === 0
+            ? "string"
+            : joinCode(this.decodedIn.map((in_) => code `${literalOf(in_.toString())}`), { on: " | " })} }`);
     }
     literalValueExpression(literal) {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
     }
     toJsonExpression({ variables, }) {
-        return code `${variables.value}.toString()`;
+        let valueExpression = code `${variables.value}.toString()`;
+        if (this.decodedIn.length > 0) {
+            valueExpression = code `${valueExpression} as ${joinCode(this.decodedIn.map((in_) => code `${literalOf(in_.toString())}`), { on: " | " })}`;
+        }
+        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${valueExpression} }`;
     }
 }
 __decorate([

package/dist/generators/ts/BooleanType.d.ts

@@ -13,8 +13,6 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly valueSparqlWherePatternsFunction: Code;
     get fromRdfResourceValuesFunction(): Code;
     get schemaType(): Code;
-    protected get inlineExpression(): Code;
-    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
     literalValueExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/BooleanType.js

@@ -22,18 +22,6 @@ export class BooleanType extends AbstractPrimitiveType {
     get schemaType() {
         return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
     }
-    get inlineExpression() {
-        if (this.primitiveIn.length > 0) {
-            return code `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
-        }
-        return code `boolean`;
-    }
-    jsonSchema(_parameters) {
-        if (this.primitiveIn.length === 1) {
-            return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
-        }
-        return code `${this.reusables.imports.z}.boolean()`;
-    }
     literalValueExpression(literal) {
         return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
     }
@@ -47,7 +35,4 @@ __decorate([
 __decorate([
     Memoize()
 ], BooleanType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], BooleanType.prototype, "inlineExpression", null);
 //# sourceMappingURL=BooleanType.js.map

package/dist/generators/ts/DateTimeType.d.ts

@@ -6,7 +6,7 @@ export declare class DateTimeType extends AbstractDateType {
     readonly hashFunction: Code;
     readonly kind = "DateTime";
     get fromRdfResourceValuesFunction(): Code;
-    jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
+    jsonSchema(): Code;
     literalValueExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
 }