@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/AbstractType.js

@@ -14,10 +14,6 @@ export class AbstractType {
     configuration;
     logger;
     reusables;
-    /**
-     * Alias for this type.
-     */
-    alias;
     /**
      * Comment from rdfs:comment.
      */
@@ -26,23 +22,35 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ alias, comment, configuration, label, logger, reusables, }) {
-        this.alias = alias;
+    /**
+     * Name for this type.
+     */
+    name;
+    /**
+     * Identifier of the shape this type was derived from.
+     */
+    shapeIdentifier;
+    constructor({ comment, configuration, label, logger, name, reusables, shapeIdentifier, }) {
         this.comment = comment;
         this.configuration = configuration;
         this.label = label;
         this.logger = logger;
+        this.name = name;
         this.reusables = reusables;
         this.rdfjsTermExpression = rdfjsTermExpression.bind({
             imports: this.reusables.imports,
             logger: this.logger,
             snippets: this.reusables.snippets,
         });
+        this.shapeIdentifier = shapeIdentifier;
     }
     /**
      * TypeScript object describing this type, for runtime use.
      */
     get schema() {
+        return this.schemaExpression;
+    }
+    get schemaExpression() {
         return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
     }
     /**
@@ -56,6 +64,9 @@ export class AbstractType {
 __decorate([
     Memoize()
 ], AbstractType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractType.prototype, "schemaExpression", null);
 (function (AbstractType) {
     class GraphqlType {
         /**
@@ -63,47 +74,62 @@ __decorate([
          */
         nullable;
         /**
-         * The name of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
+         * The expression of the type when it's nullable -- so it should never include "new graphql.GraphQLNonNull(...)" around it.
          */
-        nullableName;
+        nullableExpression;
         reusables;
-        constructor(nullableName, reusables, options) {
+        constructor(nullableExpression, reusables, options) {
             this.nullable = !!options?.nullable;
-            this.nullableName = nullableName;
+            this.nullableExpression = nullableExpression;
             this.reusables = reusables;
         }
-        get name() {
+        get expression() {
             return this.nullable
-                ? this.nullableName
-                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableName})`;
+                ? this.nullableExpression
+                : code `new ${this.reusables.imports.GraphQLNonNull}(${this.nullableExpression})`;
         }
     }
     __decorate([
         Memoize()
-    ], GraphqlType.prototype, "name", null);
+    ], GraphqlType.prototype, "expression", null);
     AbstractType.GraphqlType = GraphqlType;
+    let JsType;
+    (function (JsType) {
+        function equals(left, right) {
+            if (left.typeof !== right.typeof) {
+                return false;
+            }
+            if (left.typeof === "object" &&
+                right.typeof === "object" &&
+                left.instanceof !== right.instanceof) {
+                return false;
+            }
+            return true;
+        }
+        JsType.equals = equals;
+    })(JsType = AbstractType.JsType || (AbstractType.JsType = {}));
     class JsonType {
         /**
          * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
          */
         optional;
         /**
-         * The name of the type when it's required i.e. -- so it should never include "| undefined".
+         * The expression of the type when it's required i.e. -- so it should never include "| undefined".
          */
-        requiredName;
-        constructor(requiredName, parameters) {
+        requiredExpression;
+        constructor(requiredExpression, parameters) {
             this.optional = !!parameters?.optional;
-            this.requiredName = requiredName;
+            this.requiredExpression = requiredExpression;
         }
-        get name() {
+        get expression() {
             return this.optional
-                ? code `(${this.requiredName}) | undefined`
-                : this.requiredName;
+                ? code `(${this.requiredExpression}) | undefined`
+                : this.requiredExpression;
         }
     }
     __decorate([
         Memoize()
-    ], JsonType.prototype, "name", null);
+    ], JsonType.prototype, "expression", null);
     AbstractType.JsonType = JsonType;
 })(AbstractType || (AbstractType = {}));
 //# sourceMappingURL=AbstractType.js.map

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

@@ -3,11 +3,16 @@ import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
@@ -16,9 +21,8 @@ export declare class BigDecimalType extends AbstractLiteralType {
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
-    literalExpression(literal: Literal): Code;
+    literalValueExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -9,11 +9,15 @@ import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
+    inlineExpression = code `${this.reusables.imports.BigDecimal}`;
     conversionFunction = Maybe.empty();
-    expression = code `${this.reusables.imports.BigDecimal}`;
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.bigDecimalFromRdfResourceValues}`;
     hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
@@ -30,9 +34,9 @@ export class BigDecimalType extends AbstractLiteralType {
         return code `${this.reusables.imports.z}.string()`;
     }
     jsonType() {
-        return new AbstractLiteralType.JsonType("string");
+        return new AbstractLiteralType.JsonType(code `string`);
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
     }
     toJsonExpression({ variables, }) {
@@ -41,12 +45,6 @@ export class BigDecimalType extends AbstractLiteralType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${this.reusables.snippets.decodeBigDecimalLiteral})))`,
-        };
-    }
 }
 __decorate([
     Memoize()

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

@@ -2,14 +2,16 @@ import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
+    readonly jsTypes: {
+        readonly typeof: "bigint";
+    }[];
     readonly kind = "BigInt";
-    readonly typeofs: "bigint"[];
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;
-    literalExpression(literal: bigint | Literal): Code;
+    literalValueExpression(literal: bigint | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromRdfResourceValueExpression"]>[0]): Code;
 }
 //# sourceMappingURL=BigIntType.d.ts.map

package/dist/generators/ts/BigIntType.js

@@ -9,8 +9,11 @@ import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
+    jsTypes = [{ typeof: "bigint" }];
     kind = "BigInt";
-    typeofs = ["bigint"];
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`;
+    }
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
     }
@@ -34,16 +37,16 @@ export class BigIntType extends AbstractNumericType {
     jsonType() {
         return new AbstractNumericType.JsonType(code `string`);
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toString()`;
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return code `${variables.value}.toBigInt(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `${_}n`).join(", ")}] as const` : ""})`;
-    }
 }
+__decorate([
+    Memoize()
+], BigIntType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], BigIntType.prototype, "graphqlType", null);

package/dist/generators/ts/BlankNodeType.d.ts

@@ -3,10 +3,11 @@ import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
+    protected readonly inlineExpression: Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly fromRdfResourceValuesFunction: Code;
     readonly kind = "BlankNode";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly parseFunction: Code;
@@ -17,11 +18,5 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfResourceValuesExpressionChain"]>[0]): {
-        valueTo: Code;
-        hasValues?: Code;
-        languageIn?: Code;
-        preferredLanguages?: Code;
-    };
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/generators/ts/BlankNodeType.js

@@ -9,22 +9,23 @@ import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
+    inlineExpression = code `${this.reusables.imports.BlankNode}`;
     conversionFunction = Maybe.of({
         code: code `${this.reusables.snippets.convertToBlankNode}`,
         sourceTypes: [
             {
                 expression: code `${this.reusables.imports.BlankNode}`,
-                typeof: "object",
+                jsType: this.jsTypes[0],
             },
             {
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             },
         ],
     });
-    expression = code `${this.reusables.imports.BlankNode}`;
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
+    fromRdfResourceValuesFunction = code `${this.reusables.snippets.blankNodeFromRdfResourceValues}`;
     kind = "BlankNode";
     nodeKinds = nodeKinds;
     parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
@@ -58,12 +59,6 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            valueTo: code `chain(values => values.chainMap(value => value.toBlankNode()))`,
-        };
-    }
 }
 __decorate([
     Memoize()

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

@@ -6,14 +6,16 @@ export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "boolean";
+    }];
     readonly kind = "Boolean";
-    readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    get expression(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get schemaType(): Code;
+    protected get inlineExpression(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
-    literalExpression(literal: boolean | Literal): Code;
+    literalValueExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -13,43 +13,41 @@ export class BooleanType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashBoolean}`;
+    jsTypes = [{ typeof: "boolean" }];
     kind = "Boolean";
-    typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    get expression() {
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`;
+    }
+    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`;
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
-    }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
             return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
         }
         return code `${this.reusables.imports.z}.boolean()`;
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: code `chain(values => values.chainMap(value => value.toBoolean(${this.primitiveIn.length === 1 ? `[${this.primitiveIn[0]}] as const` : ""})))`,
-        };
-    }
 }
 __decorate([
     Memoize()
-], BooleanType.prototype, "expression", null);
+], BooleanType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "inlineExpression", null);
 //# sourceMappingURL=BooleanType.js.map

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

@@ -5,9 +5,9 @@ export declare class DateTimeType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "DateTime";
+    get fromRdfResourceValuesFunction(): Code;
     jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
-    literalExpression(literal: Date | Literal): Code;
+    literalValueExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -1,21 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDateTime}`;
     kind = "DateTime";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.dateTimeFromRdfResourceValues}`;
+    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.datetime()`;
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toISOString()`;
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return code `${variables.value}.toDateTime(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
-    }
 }
+__decorate([
+    Memoize()
+], DateTimeType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=DateTimeType.js.map

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

@@ -6,9 +6,9 @@ export declare class DateType extends AbstractDateType {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
     readonly kind = "Date";
+    get fromRdfResourceValuesFunction(): Code;
     jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
-    literalExpression(literal: Date | Literal): Code;
+    literalValueExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
-    protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -1,4 +1,11 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { LiteralDecoder } from "@rdfx/literal";
+import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { code } from "./ts-poet-wrapper.js";
@@ -6,17 +13,20 @@ export class DateType extends AbstractDateType {
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashDate}`;
     kind = "Date";
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.dateFromRdfResourceValues}`;
+    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.date()`;
     }
-    literalExpression(literal) {
+    literalValueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
     toJsonExpression({ variables, }) {
         return code `${this.reusables.snippets.toIsoDateString}(${variables.value})`;
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return code `${variables.value}.toDate(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
-    }
 }
+__decorate([
+    Memoize()
+], DateType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=DateType.js.map

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

@@ -9,8 +9,45 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly defaultValue: Literal | NamedNode;
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly jsTypes: readonly AbstractType.JsType[] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | {
+        readonly typeof: "bigint";
+    }[] | readonly [{
+        readonly typeof: "boolean";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Date";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly typeof: "number";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly typeof: "string";
+    }] | readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "DefaultValue";
-    readonly typeofs: "object"[];
     readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
@@ -20,16 +57,17 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): Code[];
     private get defaultValueExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;

package/dist/generators/ts/DefaultValueType.js

@@ -13,8 +13,8 @@ export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
+    jsTypes = this.itemType.jsTypes;
     kind = "DefaultValue";
-    typeofs = ["object"];
     validationFunction = this.itemType.validationFunction;
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
@@ -25,10 +25,10 @@ export class DefaultValueType extends AbstractContainerType {
         return Maybe.of({
             code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code}, ${this.defaultValueExpression})`,
             sourceTypes: itemConversionFunction.sourceTypes
-                .filter((sourceType) => sourceType.typeof !== "undefined")
+                .filter((sourceType) => sourceType.jsType.typeof !== "undefined")
                 .concat({
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             }),
         });
     }
@@ -44,6 +44,9 @@ export class DefaultValueType extends AbstractContainerType {
     get filterType() {
         return this.itemType.filterType;
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get graphqlType() {
         return this.itemType.graphqlType;
     }
@@ -54,7 +57,10 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.mutable;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.expression}, ${this.itemType.schemaType}>`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
@@ -63,7 +69,7 @@ export class DefaultValueType extends AbstractContainerType {
         return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaInitializers() {
-        return super.schemaInitializers.concat(code `defaultValue: ${this.defaultValueExpression}`);
+        return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
     }
     get defaultValueExpression() {
         switch (this.itemType.kind) {
@@ -79,19 +85,11 @@ export class DefaultValueType extends AbstractContainerType {
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
-        return this.itemType.literalExpression(this.defaultValue);
+        return this.itemType.literalValueExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
     }
-    fromRdfResourceValuesExpression({ variables, }) {
-        return this.itemType.fromRdfResourceValuesExpression({
-            variables: {
-                ...variables,
-                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.rdfjsTermExpression(this.defaultValue) }}).toValues())`,
-            },
-        });
-    }
     graphqlResolveExpression(parameters) {
         return this.itemType.graphqlResolveExpression(parameters);
     }
@@ -118,6 +116,9 @@ export class DefaultValueType extends AbstractContainerType {
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "schemaType", null);