@shaclmate/compiler 4.0.70 → 4.0.71

package/dist/generators/ts/ObjectType.js

@@ -40,8 +40,7 @@ import { ObjectType_typeGuardFunctionExpression } from "./_ObjectType/ObjectType
 import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionExpression.js";
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
 import { AbstractType } from "./AbstractType.js";
-import { arrayOf, code, def, joinCode } from "./ts-poet-wrapper.js";
-import { tsComment } from "./tsComment.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectType extends AbstractType {
     toRdfTypes;
     discriminantProperty;
@@ -85,141 +84,157 @@ export class ObjectType extends AbstractType {
             ],
         });
     }
-    get declaration() {
-        const name = this.name.extract();
-        if (!name) {
-            return Maybe.empty();
-        }
-        const declarations = [];
-        if (!this.extern) {
-            if (this.configuration.features.has("Object.type")) {
-                declarations.push(code `\
- ${this.comment
-                    .alt(this.label)
-                    .map(tsComment)
-                    .orDefault("")}export type ${name} = ${this.inlineExpression};`);
-            }
-            let staticModuleDeclarations = [];
-            // create
-            if (this.configuration.features.has("Object.create")) {
-                staticModuleDeclarations.push(code `export const create: (${this.constructorParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_createFunctionExpression.call(this)};`, code `export function createUnsafe(${this.constructorParameters.signature}): ${this.expression} {
+    staticModuleDeclarations(name) {
+        let staticModuleDeclarations = {
+            ...super.staticModuleDeclarations(name),
+        };
+        // create
+        if (this.configuration.features.has("Object.create")) {
+            staticModuleDeclarations["create"] =
+                code `export const create: (${this.constructorParameters.signature}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_createFunctionExpression.call(this)};`;
+            staticModuleDeclarations["createUnsafe"] =
+                code `export function createUnsafe(${this.constructorParameters.signature}): ${this.expression} {
   return create(parameters).unsafeCoerce();
-}`);
-            }
-            // equals
-            if (this.configuration.features.has("Object.equals")) {
-                staticModuleDeclarations.push(code `export const equals: (left: ${this.expression}, right: ${this.expression}) => ${this.reusables.snippets.EqualsResult} = ${ObjectType_equalsFunctionExpression.call(this)};`);
-            }
-            // Filter / filter
-            if (this.configuration.features.has("Object.filter")) {
-                staticModuleDeclarations.push(code `export type Filter = ${ObjectType_filterTypeExpression.call(this)};`);
-                staticModuleDeclarations.push(code `export const filter: (filter: ${this.filterType}, value: ${this.expression}) => boolean = ${ObjectType_filterFunctionExpression.call(this)};`);
-            }
-            // GraphQL
-            if (this.configuration.features.has("GraphQL") && !this.synthetic) {
-                staticModuleDeclarations.push(code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`);
-            }
-            // focusSparqlConstructTriples / focusSparqlWherePatterns
-            if (this.configuration.features.has("Object.SPARQL")) {
-                staticModuleDeclarations.push(code `export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = ${ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = ${ObjectType_focusSparqlWherePatternsFunctionExpression.call(this)};`);
-            }
-            // fromJson
-            if (this.configuration.features.has("Object.fromJson")) {
-                staticModuleDeclarations.push(code `export const fromJson: (json: ${this.jsonType().expression}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_fromJsonFunctionExpression.call(this)};`);
-            }
-            // fromRdfResource / fromRdfResourceValues
-            if (this.configuration.features.has("Object.fromRdf")) {
-                staticModuleDeclarations.push(code `export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = ${ObjectType_fromRdfResourceFunctionExpression.call(this)};`, code `export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`, code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}> = 
-  (values, options) => values.chainMap(value => value.toResource().chain(resource => fromRdfResource(resource, options)));`);
-            }
-            // hash
-            if (this.configuration.features.has("Object.hash")) {
-                staticModuleDeclarations.push(code `export const hash = ${ObjectType_hashFunctionExpression.call(this)};`);
-            }
-            // Identifier
-            if (this.configuration.features.has("Object.type")) {
-                staticModuleDeclarations = staticModuleDeclarations.concat(ObjectType_identifierTypeDeclarations.call(this));
+}`;
+        }
+        // equals
+        if (this.configuration.features.has("Object.equals")) {
+            staticModuleDeclarations["equals"] =
+                code `export const equals: (left: ${this.expression}, right: ${this.expression}) => ${this.reusables.snippets.EqualsResult} = ${ObjectType_equalsFunctionExpression.call(this)};`;
+        }
+        // Filter / filter
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations["Filter"] =
+                code `export type Filter = ${ObjectType_filterTypeExpression.call(this)};`;
+            staticModuleDeclarations["filter"] =
+                code `export const filter: (filter: ${this.filterType}, value: ${this.expression}) => boolean = ${ObjectType_filterFunctionExpression.call(this)};`;
+        }
+        // GraphQL
+        if (this.configuration.features.has("GraphQL") && !this.synthetic) {
+            staticModuleDeclarations["GraphQL"] =
+                code `export const GraphQL = ${ObjectType_graphqlTypeExpression.call(this)};`;
+        }
+        // focusSparqlConstructTriples / focusSparqlWherePatterns
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations["focusSparqlConstructTriples"] =
+                code `export const focusSparqlConstructTriples: ${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}> = ${ObjectType_focusSparqlConstructTriplesFunctionExpression.call(this)};`;
+            staticModuleDeclarations["focusSparqlWherePatterns"] =
+                code `export const focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}> = ${ObjectType_focusSparqlWherePatternsFunctionExpression.call(this)};`;
+        }
+        // fromJson
+        if (this.configuration.features.has("Object.fromJson")) {
+            staticModuleDeclarations["fromJson"] =
+                code `export const fromJson: (json: ${this.jsonType().expression}) => ${this.reusables.imports.Either}<Error, ${this.expression}> = ${ObjectType_fromJsonFunctionExpression.call(this)};`;
+        }
+        // fromRdfResource / fromRdfResourceValues
+        if (this.configuration.features.has("Object.fromRdf")) {
+            staticModuleDeclarations["_fromRdfResource"] =
+                code `export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = ${ObjectType_fromRdfResourceFunctionExpression.call(this)};`;
+            staticModuleDeclarations["fromRdfResource"] =
+                code `export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`;
+            staticModuleDeclarations["fromRdfResourceValues"] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}> = 
+  (values, options) => values.chainMap(value => value.toResource().chain(resource => fromRdfResource(resource, options)));`;
+        }
+        // hash
+        if (this.configuration.features.has("Object.hash")) {
+            staticModuleDeclarations["hash"] =
+                code `export const hash = ${ObjectType_hashFunctionExpression.call(this)};`;
+        }
+        // Identifier
+        if (this.configuration.features.has("Object.type")) {
+            staticModuleDeclarations = {
+                ...staticModuleDeclarations,
+                ...ObjectType_identifierTypeDeclarations.call(this),
+            };
+        }
+        // Type guard
+        ObjectType_typeGuardFunctionExpression.call(this).ifJust((typeGuardFunctionExpression) => {
+            staticModuleDeclarations[`is${name}`] =
+                code `export const is${name} = ${typeGuardFunctionExpression};`;
+        });
+        // type Json
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations["JsonType"] =
+                code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`;
+        }
+        // namespace Json
+        {
+            const jsonModuleDeclarations = [];
+            if (this.configuration.features.has("Object.JSON.parse")) {
+                jsonModuleDeclarations.push(ObjectType_jsonParseFunctionDeclaration.call(this));
             }
-            // Type guard
-            ObjectType_typeGuardFunctionExpression.call(this).ifJust((typeGuardFunctionExpression) => {
-                staticModuleDeclarations.push(code `export const is${name} = ${typeGuardFunctionExpression};`);
-            });
-            // type Json
-            if (this.configuration.features.has("Object.JSON.type")) {
-                staticModuleDeclarations.push(code `export type Json = ${ObjectType_jsonTypeExpression.call(this)}`);
+            if (this.configuration.features.has("Object.JSON.schema")) {
+                jsonModuleDeclarations.push(code `export function schema() { return ${ObjectType_jsonSchemaExpression.call(this)} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
             }
-            // namespace Json
-            {
-                const jsonModuleDeclarations = [];
-                if (this.configuration.features.has("Object.JSON.parse")) {
-                    jsonModuleDeclarations.push(ObjectType_jsonParseFunctionDeclaration.call(this));
-                }
-                if (this.configuration.features.has("Object.JSON.schema")) {
-                    jsonModuleDeclarations.push(code `export function schema() { return ${ObjectType_jsonSchemaExpression.call(this)} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
-                }
-                if (this.configuration.features.has("Object.JSON.uiSchema")) {
-                    jsonModuleDeclarations.push(code `export const uiSchema = ${ObjectType_jsonUiSchemaFunctionExpression.call(this)};`);
-                }
-                if (jsonModuleDeclarations.length > 0) {
-                    staticModuleDeclarations.push(code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`);
-                }
+            if (this.configuration.features.has("Object.JSON.uiSchema")) {
+                jsonModuleDeclarations.push(code `export const uiSchema = ${ObjectType_jsonUiSchemaFunctionExpression.call(this)};`);
             }
-            // schema / Schema
-            if (this.configuration.features.has("Object.schema")) {
-                staticModuleDeclarations.push(code `export const schema = ${ObjectType_schemaExpression.call(this)};`, code `export type Schema = typeof schema;`);
+            if (jsonModuleDeclarations.length > 0) {
+                staticModuleDeclarations["JsonNamespace"] =
+                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`;
             }
-            // sparqlConstructQuery / sparqlConstructQueryString
-            if (this.configuration.features.has("Object.SPARQL")) {
-                staticModuleDeclarations.push(ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+        }
+        // schema / Schema
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${ObjectType_schemaExpression.call(this)};`;
+            staticModuleDeclarations["Schema"] =
+                code `export type Schema = typeof schema;`;
+        }
+        // sparqlConstructQuery / sparqlConstructQueryString
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations["sparqlConstructQuery"] =
+                ObjectType_sparqlConstructQueryFunctionDeclaration.call({
                     name,
                     configuration: this.configuration,
                     filterType: this.filterType,
                     reusables: this.reusables,
-                }), ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                });
+            staticModuleDeclarations["sparqlConstructQueryString"] =
+                ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
                     name,
                     configuration: this.configuration,
                     filterType: this.filterType,
                     reusables: this.reusables,
-                }));
-            }
-            // toJson
-            if (this.configuration.features.has("Object.toJson")) {
-                staticModuleDeclarations.push(code `export const toJson: (${this.thisVariable}: ${this.expression}) => ${this.jsonType().expression} = ${ObjectType_toJsonFunctionExpression.call(this)};`);
-            }
-            // toRdfResource
-            if (this.configuration.features.has("Object.toRdf")) {
-                staticModuleDeclarations.push(code `export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = ${ObjectType_toRdfResourceFunctionExpression.call(this)};`, code `export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`);
-            }
-            // toString / toStringRecord
-            if (this.configuration.features.has("Object.toString")) {
-                staticModuleDeclarations.push(code `export const ${this.configuration.syntheticNamePrefix}toString: (${this.thisVariable}: ${this.expression}) => string = ${ObjectType_toStringFunctionExpression.call(this)};`, code `export const toStringRecord: (${this.thisVariable}: ${this.expression}) => Record<string, string> = ${ObjectType_toStringRecordFunctionExpression.call(this)};`);
-            }
-            // valueSparqlConstructTriples / valueSparqlWherePatterns
-            if (this.configuration.features.has("Object.SPARQL")) {
-                staticModuleDeclarations.push(code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this)};`, code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlWherePatternsFunctionExpression.call(this)};`);
-            }
-            if (staticModuleDeclarations.length > 0) {
-                declarations.push(code `\
-export namespace ${def(name)} {
-${joinCode(staticModuleDeclarations, { on: "\n\n" })}
-}`);
-            }
+                });
         }
-        if (declarations.length === 0) {
-            return Maybe.empty();
+        // toJson
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations["toJson"] =
+                code `export const toJson: (${this.thisVariable}: ${this.expression}) => ${this.jsonType().expression} = ${ObjectType_toJsonFunctionExpression.call(this)};`;
+        }
+        // toRdfResource
+        if (this.configuration.features.has("Object.toRdf")) {
+            staticModuleDeclarations["_toRdfResource"] =
+                code `export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = ${ObjectType_toRdfResourceFunctionExpression.call(this)};`;
+            staticModuleDeclarations["toRdfResource"] =
+                code `export const toRdfResource = ${this.reusables.snippets.wrap_ToRdfResourceFunction}(_toRdfResource);`;
         }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+        // toString / toStringRecord
+        if (this.configuration.features.has("Object.toString")) {
+            staticModuleDeclarations[`${this.configuration.syntheticNamePrefix}toString`] =
+                code `export const ${this.configuration.syntheticNamePrefix}toString: (${this.thisVariable}: ${this.expression}) => string = ${ObjectType_toStringFunctionExpression.call(this)};`;
+            staticModuleDeclarations["toStringRecord"] =
+                code `export const toStringRecord: (${this.thisVariable}: ${this.expression}) => Record<string, string> = ${ObjectType_toStringRecordFunctionExpression.call(this)};`;
+        }
+        // valueSparqlConstructTriples / valueSparqlWherePatterns
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations["valueSparqlConstructTriples"] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
+            staticModuleDeclarations["valueSparqlWherePatterns"] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${ObjectType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
+        }
+        return staticModuleDeclarations;
+    }
+    get declaration() {
+        return !this.extern ? super.declaration : Maybe.empty();
     }
     get equalsFunction() {
         return this.name
             .map((name) => code `${name}.equals`)
             .orDefaultLazy(() => ObjectType_equalsFunctionExpression.call(this));
     }
-    get expression() {
-        return this.name
-            .map((name) => code `${name}`)
-            .orDefaultLazy(() => this.inlineExpression);
-    }
     get filterFunction() {
         return this.name
             .map((name) => code `${name}.filter`)
@@ -279,10 +294,8 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
                 }
             }));
     }
-    get schema() {
-        return this.name
-            .map((name) => code `${name}.schema`)
-            .orDefaultLazy(() => ObjectType_schemaExpression.call(this));
+    get schemaExpression() {
+        return ObjectType_schemaExpression.call(this);
     }
     get schemaType() {
         return this.name
@@ -425,9 +438,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], ObjectType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "filterFunction", null);
@@ -463,7 +473,7 @@ __decorate([
 ], ObjectType.prototype, "referencesNamedType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "schema", null);
+], ObjectType.prototype, "schemaExpression", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "schemaType", null);

package/dist/generators/ts/OptionType.d.ts

@@ -11,7 +11,6 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     readonly kind = "Option";
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
-    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfResourceValuesFunction(): Code;
@@ -23,6 +22,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get inlineExpression(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/OptionType.js

@@ -33,9 +33,6 @@ export class OptionType extends AbstractContainerType {
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
-    get expression() {
-        return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
-    }
     get filterFunction() {
         return code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
@@ -72,6 +69,9 @@ export class OptionType extends AbstractContainerType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    get inlineExpression() {
+        return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
+    }
     fromJsonExpression({ variables, }) {
         const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
@@ -118,9 +118,6 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterFunction", null);
@@ -148,6 +145,9 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "jsonType", null);

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

@@ -19,7 +19,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     get schemaType(): Code;
     protected get schemaInitializers(): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
-    literalValueExpression(literal: Literal | string): Code;
+    valueExpression(literal: Literal | string): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -39,12 +39,19 @@ export class StringType extends AbstractPrimitiveType {
         return initializers;
     }
     jsonSchema(parameters) {
-        if (this.decodedIn.length > 1) {
-            return code `${this.reusables.imports.z}.enum(${arrayOf(...this.decodedIn)})`;
+        if (this.in_.length > 1) {
+            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}.enum(${name}.schema.in)`;
+            }
+            else {
+                return code `${this.reusables.imports.z}.enum(${arrayOf(...this.in_.map((value) => this.valueExpression(value)))})`;
+            }
         }
         return super.jsonSchema(parameters);
     }
-    literalValueExpression(literal) {
+    valueExpression(literal) {
         return code `${literalOf(typeof literal === "string" ? literal : literal.value)}`;
     }
     toRdfResourceValuesExpression({ variables, }) {

package/dist/generators/ts/TypeFactory.js

@@ -1,6 +1,6 @@
 import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
-import { LiteralDecoder, literalDatatypeDefinitions } from "@rdfx/literal";
+import { literalDatatypeDefinitions } from "@rdfx/literal";
 import base62 from "@sindresorhus/base62";
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
@@ -341,41 +341,19 @@ export class TypeFactory {
             if (datatypeDefinition) {
                 switch (datatypeDefinition.kind) {
                     case "bigdecimal":
-                        return new BigDecimalType({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBigDecimalLiteral(value).unsafeCoerce()),
-                        });
+                        return new BigDecimalType(typeParameters);
                     case "bigint":
-                        return new BigIntType({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
-                        });
+                        return new BigIntType(typeParameters);
                     case "boolean":
-                        return new BooleanType({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
-                        });
+                        return new BooleanType(typeParameters);
                     case "date":
                     case "datetime":
-                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
-                                ? LiteralDecoder.decodeDateLiteral
-                                : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
-                        });
+                        return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)(typeParameters);
                     case "float":
                     case "int":
-                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
-                                ? LiteralDecoder.decodeFloatLiteral
-                                : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
-                        });
+                        return new (datatypeDefinition.kind === "float" ? FloatType : IntType)(typeParameters);
                     case "string":
-                        return new StringType({
-                            ...typeParameters,
-                            decodedIn: astType.in_.map((value) => LiteralDecoder.decodeStringLiteral(value).unsafeCoerce()),
-                        });
+                        return new StringType(typeParameters);
                 }
             }
             this.logger.warn("unrecognized literal datatype: %s", datatype.value);

package/dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.d.ts

@@ -1,4 +1,4 @@
 import type { ObjectType } from "../ObjectType.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectType_identifierTypeDeclarations(this: ObjectType): readonly Code[];
+export declare function ObjectType_identifierTypeDeclarations(this: ObjectType): Record<string, Code>;
 //# sourceMappingURL=ObjectType_identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_identifierTypeDeclarations.js

@@ -1,13 +1,12 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
 import { code } from "../ts-poet-wrapper.js";
 export function ObjectType_identifierTypeDeclarations() {
     // Bespoke identifier type and associated functions
-    return [
-        code `export type Identifier = ${this.identifierType.expression};`,
-        code `\
+    return singleEntryRecord("Identifier", code `\
+export type Identifier = ${this.identifierType.expression};
 export namespace Identifier {
   export const parse = ${this.identifierType.parseFunction};
   export const stringify = ${this.identifierType.stringifyFunction};
-}`,
-    ];
+}`);
 }
 //# sourceMappingURL=ObjectType_identifierTypeDeclarations.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.70",
+    "@shaclmate/shacl-ast": "4.0.71",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -723,5 +723,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.70"
+  "version": "4.0.71"
 }