@shaclmate/compiler 4.0.70 → 4.0.71

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -12,7 +12,6 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get equalsFunction(): Code;
-    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
@@ -20,6 +19,7 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     get mutable(): boolean;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
+    protected get inlineExpression(): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/AbstractCollectionType.js

@@ -22,9 +22,6 @@ export class AbstractCollectionType extends AbstractContainerType {
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
-    get expression() {
-        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;
-    }
     get filterFunction() {
         return code `${this.reusables.snippets.filterArray}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
@@ -46,6 +43,9 @@ export class AbstractCollectionType extends AbstractContainerType {
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
     }
+    get inlineExpression() {
+        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;
+    }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
@@ -59,9 +59,6 @@ export class AbstractCollectionType extends AbstractContainerType {
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractCollectionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "filterFunction", null);
@@ -80,6 +77,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "validationFunction", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "inlineExpression", null);
 (function (AbstractCollectionType) {
     AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;

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

@@ -1,4 +1,3 @@
-import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
@@ -24,7 +23,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export declare abstract class AbstractContainerType<ItemTypeT extends AbstractContainerType.ItemType> extends AbstractType {
-    readonly declaration: Maybe<Code>;
     abstract readonly kind: "DefaultValue" | "List" | "Option" | "Set";
     /**
      * Container item type.

package/dist/generators/ts/AbstractContainerType.js

@@ -4,7 +4,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -12,7 +11,6 @@ import { code } from "./ts-poet-wrapper.js";
  * Abstract base class for types that contain other types e.g., ListType, OptionType, SetType.
  */
 export class AbstractContainerType extends AbstractType {
-    declaration = Maybe.empty();
     /**
      * Container item type.
      *

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -13,7 +13,6 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
-    readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
     readonly validationFunction: Maybe<Code>;
@@ -22,7 +21,7 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get equalsFunction(): Code;
-    get expression(): Code;
+    get inlineExpression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;

package/dist/generators/ts/AbstractLazyType.js

@@ -12,7 +12,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyType extends AbstractType {
     partialType;
     resolveType;
-    declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
     validationFunction = Maybe.empty();
@@ -24,7 +23,7 @@ export class AbstractLazyType extends AbstractType {
     get equalsFunction() {
         return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
     }
-    get expression() {
+    get inlineExpression() {
         return this.runtimeClass.name;
     }
     get filterFunction() {

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

@@ -1,17 +1,10 @@
 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> {
     readonly nodeKinds: ReadonlySet<"Literal">;
-    /**
-     * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
-     *
-     * For example, a string would be converted to "thestring".
-     */
-    abstract literalValueExpression(literal: Literal): Code;
 }
 export declare namespace AbstractLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -16,8 +16,13 @@ export class AbstractPrimitiveType extends AbstractTypedLiteralType {
     conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     get inlineExpression() {
-        if (this.decodedIn.length > 0) {
-            return code `${joinCode(this.decodedIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
+        if (this.in_.length > 0) {
+            const name = this.name.extract();
+            if (name && this.configuration.features.has("Object.schema")) {
+                // Reuse the type from schema to cut down code
+                return code `(typeof ${name}.schema)["in"][number]`;
+            }
+            return code `${joinCode(this.in_.map((value) => this.valueExpression(value)), { on: " | " })}`;
         }
         return code `${this.jsTypes[0].typeof}`;
     }
@@ -25,13 +30,21 @@ export class AbstractPrimitiveType extends AbstractTypedLiteralType {
         return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
     }
     jsonSchema(_parameters) {
-        switch (this.decodedIn.length) {
+        switch (this.in_.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)})`))})`;
+                return code `${this.reusables.imports.z}.literal(${this.valueExpression(this.in_[0])})`;
+            default: {
+                const name = this.name.extract();
+                if (name && this.configuration.features.has("Object.schema")) {
+                    // Reuse the type from schema to cut down code
+                    return code `${this.reusables.imports.z}.union(${name}.schema.in.map(_ => ${this.reusables.imports.z}.literal(_)))`;
+                }
+                else {
+                    return code `${this.reusables.imports.z}.union(${arrayOf(...this.in_.map((value) => code `${this.reusables.imports.z}.literal(${this.valueExpression(value)})`))})`;
+                }
+            }
         }
     }
     jsonType() {

package/dist/generators/ts/AbstractTermType.d.ts

@@ -12,7 +12,6 @@ import { type Code } from "./ts-poet-wrapper.js";
  * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
  */
 export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    protected abstract readonly inlineExpression: Code;
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
@@ -26,9 +25,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get declaration(): Maybe<Code>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get expression(): Code;
     get referencesNamedType(): boolean;
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
@@ -37,6 +34,12 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    /**
+     * An expression that converts a compile-time RDF/JS term into a runtime TypeScript value.
+     *
+     * For example, a string would be converted to "thestring".
+     */
+    valueExpression(term: ConstantTermT): Code;
 }
 export declare namespace AbstractTermType {
     type ConversionFunction = AbstractType.ConversionFunction;

package/dist/generators/ts/AbstractTermType.js

@@ -31,9 +31,6 @@ export class AbstractTermType extends AbstractType {
         this.hasValues = hasValues;
         this.in_ = in_;
     }
-    get declaration() {
-        return this.name.map((name) => code `export type ${name} = ${this.inlineExpression};`);
-    }
     get discriminantProperty() {
         return Maybe.of({
             jsonName: "termType",
@@ -41,13 +38,6 @@ export class AbstractTermType extends AbstractType {
             values: [...this.nodeKinds].map(NodeKind.toTermType),
         });
     }
-    get expression() {
-        const name = this.name.extract();
-        if (name) {
-            return code `${name}`;
-        }
-        return this.inlineExpression;
-    }
     get referencesNamedType() {
         return this.name.isJust();
     }
@@ -65,6 +55,9 @@ export class AbstractTermType extends AbstractType {
         if (this.hasValues.length > 0) {
             initializers = initializers.concat(code `hasValues: ${arrayOf(...this.hasValues.map((hasValue) => this.rdfjsTermExpression(hasValue)))}`);
         }
+        if (this.in_.length > 0) {
+            initializers = initializers.concat(code `in: ${arrayOf(...this.in_.map((in_) => this.valueExpression(in_)))} as const`);
+        }
         return initializers;
     }
     jsonUiSchemaElement() {
@@ -76,16 +69,18 @@ export class AbstractTermType extends AbstractType {
     toStringExpression({ variables, }) {
         return code `${variables.value}.toString()`;
     }
+    /**
+     * An expression that converts a compile-time RDF/JS term into a runtime TypeScript value.
+     *
+     * For example, a string would be converted to "thestring".
+     */
+    valueExpression(term) {
+        return this.rdfjsTermExpression(term);
+    }
 }
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "declaration", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "discriminantProperty", null);
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "termTypes", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -1,5 +1,5 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
+import { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
 import type { AbstractType_DiscriminantProperty } from "./_AbstractType/AbstractType_DiscriminantProperty.js";
@@ -15,6 +15,10 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractType {
     protected readonly configuration: TsGenerator.Configuration;
+    /**
+     * Inline TypeScript type expression.
+     */
+    protected abstract readonly inlineExpression: Code;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
     /**
@@ -31,10 +35,6 @@ export declare abstract class AbstractType {
      * If unspecified, uses an identity function (i.e., function identity(value: ThisType): Either<Error, ThisType>).
      */
     abstract readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
-    /**
-     * The declaration of named types.
-     */
-    abstract readonly declaration: Maybe<Code>;
     /**
      * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
      */
@@ -44,10 +44,6 @@ export declare abstract class AbstractType {
      * $EqualsResult.
      */
     abstract readonly equalsFunction: Code;
-    /**
-     * TypeScript type expression.
-     */
-    abstract readonly expression: Code;
     /**
      * A function (reference or literal) that takes a filter of filterType (below) and a value of this type
      * and returns true if the value passes the filter.
@@ -176,6 +172,11 @@ export declare abstract class AbstractType {
         reusables: Reusables;
         shapeIdentifier: BlankNode | NamedNode;
     });
+    /**
+     * The declaration of named types.
+     */
+    get declaration(): Maybe<Code>;
+    get expression(): Code;
     /**
      * TypeScript object describing this type, for runtime use.
      */
@@ -268,6 +269,7 @@ export declare abstract class AbstractType {
         };
     }): Code;
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
+    protected staticModuleDeclarations(_name: string): Record<string, Code>;
 }
 export declare namespace AbstractType {
     type ConversionFunction = AbstractType_ConversionFunction;

package/dist/generators/ts/AbstractType.js

@@ -4,12 +4,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Memoize } from "typescript-memoize";
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
 import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { tsComment } from "./tsComment.js";
 /**
  * Abstract base class all types.
  */
@@ -47,11 +49,44 @@ export class AbstractType {
         });
         this.shapeIdentifier = shapeIdentifier;
     }
+    /**
+     * The declaration of named types.
+     */
+    get declaration() {
+        const name = this.name.extract();
+        if (!name) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `${this.comment
+                .alt(this.label)
+                .map(tsComment)
+                .orDefault("")}export type ${def(name)} = ${this.inlineExpression};`);
+        }
+        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations(name));
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(name)} {
+${joinCode(staticModuleDeclarations
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map((_) => _[1]), { on: "\n\n" })}
+}`);
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get expression() {
+        return this.name
+            .map((name) => code `${name}`)
+            .orDefaultLazy(() => this.inlineExpression);
+    }
     /**
      * TypeScript object describing this type, for runtime use.
      */
     get schema() {
-        return this.schemaExpression;
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefaultLazy(() => this.schemaExpression);
     }
     get schemaExpression() {
         return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
@@ -63,7 +98,21 @@ export class AbstractType {
         return [code `kind: ${literalOf(this.kind)} as const`];
     }
     rdfjsTermExpression;
+    staticModuleDeclarations(_name) {
+        const staticModuleDeclarations = {};
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schemaExpression}`;
+        }
+        return staticModuleDeclarations;
+    }
 }
+__decorate([
+    Memoize()
+], AbstractType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], AbstractType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], AbstractType.prototype, "schema", null);

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

@@ -2,7 +2,7 @@ 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";
+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)
@@ -10,15 +10,12 @@ import { type Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractTypedLiteralType<ValueT> extends AbstractLiteralType {
     readonly datatype: NamedNode;
-    readonly decodedIn: readonly ValueT[];
-    constructor({ datatype, decodedIn, ...superParameters }: {
+    constructor({ datatype, ...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;
+    abstract valueExpression(literal: Literal | ValueT): Code;
 }
 export declare namespace AbstractTypedLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;

package/dist/generators/ts/AbstractTypedLiteralType.js

@@ -1,7 +1,6 @@
 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)
@@ -9,22 +8,13 @@ import { arrayOf, code } from "./ts-poet-wrapper.js";
  */
 export class AbstractTypedLiteralType extends AbstractLiteralType {
     datatype;
-    decodedIn;
-    constructor({ datatype, decodedIn, ...superParameters }) {
+    constructor({ datatype, ...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;
     }

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

@@ -23,7 +23,7 @@ export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    literalValueExpression(literal: Literal): Code;
+    valueExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
 }

package/dist/generators/ts/BigDecimalType.js

@@ -37,7 +37,7 @@ export class BigDecimalType extends AbstractTypedLiteralType {
     jsonType() {
         return new AbstractLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/BigIntType.d.ts

@@ -8,10 +8,11 @@ export declare class BigIntType extends AbstractNumericType<bigint> {
     readonly kind = "BigInt";
     get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    private get decodedIn();
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;
-    literalValueExpression(literal: bigint | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
+    valueExpression(literal: bigint | Literal): Code;
 }
 //# sourceMappingURL=BigIntType.d.ts.map

package/dist/generators/ts/BigIntType.js

@@ -17,9 +17,12 @@ export class BigIntType extends AbstractNumericType {
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
     }
+    get decodedIn() {
+        return this.in_.map((in_) => LiteralDecoder.decodeBigIntLiteral(in_).unsafeCoerce());
+    }
     fromJsonExpression({ variables, }) {
         let expression = code `BigInt(${variables.value}["@value"])`;
-        if (this.decodedIn.length > 0) {
+        if (this.in_.length > 0) {
             expression = code `${expression} as ${this.expression}`;
         }
         return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
@@ -44,16 +47,16 @@ export class BigIntType extends AbstractNumericType {
             ? "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, }) {
         let valueExpression = code `${variables.value}.toString()`;
-        if (this.decodedIn.length > 0) {
+        if (this.in_.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} }`;
     }
+    valueExpression(literal) {
+        return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
+    }
 }
 __decorate([
     Memoize()
@@ -61,6 +64,9 @@ __decorate([
 __decorate([
     Memoize()
 ], BigIntType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], BigIntType.prototype, "decodedIn", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "jsonType", null);

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

@@ -13,7 +13,7 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly valueSparqlWherePatternsFunction: Code;
     get fromRdfResourceValuesFunction(): Code;
     get schemaType(): Code;
-    literalValueExpression(literal: boolean | Literal): Code;
+    valueExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -22,7 +22,7 @@ export class BooleanType extends AbstractPrimitiveType {
     get schemaType() {
         return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
     }
     toRdfResourceValuesExpression({ variables, }) {

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

@@ -7,7 +7,7 @@ export declare class DateTimeType extends AbstractDateType {
     readonly kind = "DateTime";
     get fromRdfResourceValuesFunction(): Code;
     jsonSchema(): Code;
-    literalValueExpression(literal: Date | Literal): Code;
+    valueExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -18,7 +18,7 @@ export class DateTimeType extends AbstractDateType {
     jsonSchema() {
         return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.iso.datetime() })`;
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DateType.d.ts

@@ -7,7 +7,7 @@ export declare class DateType extends AbstractDateType {
     readonly kind = "Date";
     get fromRdfResourceValuesFunction(): Code;
     jsonSchema(): Code;
-    literalValueExpression(literal: Date | Literal): Code;
+    valueExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -19,7 +19,7 @@ export class DateType extends AbstractDateType {
     jsonSchema() {
         return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.iso.date() })`;
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
     toJsonExpression({ variables, }) {

package/dist/generators/ts/DefaultValueType.d.ts

@@ -57,7 +57,6 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
-    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfResourceValuesFunction(): Code;
@@ -68,6 +67,7 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get inlineExpression(): Code;
     protected get schemaInitializers(): Code[];
     private get defaultValueExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;