@shaclmate/compiler 4.0.32 → 4.0.34

package/dist/generators/ts/NamedObjectType.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { camelCase } from "change-case";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
@@ -40,12 +40,10 @@ import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "
 import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class NamedObjectType extends AbstractType {
     toRdfTypes;
     extern;
-    features;
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
@@ -53,11 +51,10 @@ export class NamedObjectType extends AbstractType {
     name;
     recursive;
     synthetic;
-    typeofs = NonEmptyList(["object"]);
-    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
+    typeofs = ["object"];
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.extern = extern;
-        this.features = features;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         // Lazily initialize some members in getters to avoid recursive construction
@@ -81,22 +78,23 @@ export class NamedObjectType extends AbstractType {
     get childObjectTypes() {
         return this.lazyChildObjectTypes();
     }
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.name,
-                sourceTypeof: "object",
-            },
-        ];
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToObject}`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+            ],
+        };
     }
     get declaration() {
         const declarations = [];
         if (!this.extern) {
             const staticModuleDeclarations = [];
             declarations.push(NamedObjectType_interfaceDeclaration.call(this));
-            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
+            staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionDeclaration.call(this).toList(), ...NamedObjectType_hashFunctionDeclarations.call(this));
             const jsonModuleDeclarations = [
                 ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
                 ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
@@ -106,17 +104,17 @@ export class NamedObjectType extends AbstractType {
                 ? [
                     code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
                 ]
-                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind({
-                features: this.features,
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
-            })().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind({
-                features: this.features,
+            }).toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
-            })().toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+            }).toList(), ...NamedObjectType_toJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_toStringFunctionDeclarations.call(this), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.name)} {
@@ -161,6 +159,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this.name}.GraphQL`, this.reusables);
     }
+    get hashFunction() {
+        return code `${this.name}.hash`;
+    }
     get identifierTypeAlias() {
         return code `${this.name}.Identifier`;
     }
@@ -168,7 +169,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.properties.some((property) => property.mutable);
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call({
+            configuration: this.configuration,
+            name: this.name,
+        });
     }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
@@ -218,9 +222,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    hashStatements({ variables, }) {
-        return [code `${this.name}.hash(${variables.value}, ${variables.hasher});`];
-    }
     jsonSchema({ context, }) {
         let expression = code `${this.name}.Json.schema()`;
         if (context === "property" &&
@@ -238,12 +239,12 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     toJsonExpression({ variables, }) {
         return code `${this.name}.toJson(${variables.value})`;
     }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
-    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.name}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
     }
+    toStringExpression({ variables, }) {
+        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
+    }
     lazyAncestorObjectTypes;
     lazyChildObjectTypes;
     lazyDescendantObjectTypes;
@@ -262,7 +263,7 @@ __decorate([
 ], NamedObjectType.prototype, "childObjectTypes", null);
 __decorate([
     Memoize()
-], NamedObjectType.prototype, "conversions", null);
+], NamedObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
@@ -293,6 +294,9 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "identifierTypeAlias", null);

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -9,8 +9,10 @@ export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedOb
     #private;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "NamedObjectUnionType";
-    constructor({ identifierType, ...superParameters }: {
+    readonly synthetic: boolean;
+    constructor({ identifierType, synthetic, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
+        synthetic: boolean;
     } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
     get graphqlType(): AbstractType.GraphqlType;
     get identifierTypeAlias(): Code;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -14,15 +14,16 @@ import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from ".
 import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
 import { AbstractType } from "./AbstractType.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class NamedObjectUnionType extends AbstractNamedUnionType {
     #identifierType;
     graphqlArgs = Maybe.empty();
     kind = "NamedObjectUnionType";
-    constructor({ identifierType, ...superParameters }) {
+    synthetic;
+    constructor({ identifierType, synthetic, ...superParameters }) {
         super({ ...superParameters, identifierType: Maybe.of(identifierType) });
         this.#identifierType = identifierType;
+        this.synthetic = synthetic;
     }
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this._name}.GraphQL`, this.reusables);
@@ -31,7 +32,10 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         return code `${this.name}.Identifier`;
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call(this);
+        return NamedObjectType_objectSetMethodNames.call({
+            configuration: this.configuration,
+            name: this.name,
+        });
     }
     get schema() {
         return code `${this.name}.schema`;
@@ -50,7 +54,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
             ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                features: this.features,
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
@@ -58,7 +62,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
                 .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
                 .orDefault({}),
             ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                features: this.features,
+                configuration: this.configuration,
                 filterType: this.filterType,
                 name: this.name,
                 reusables: this.reusables,
@@ -69,7 +73,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         };
     }
     get focusSparqlConstructTriplesFunctionDeclaration() {
-        if (!this.features.has("sparql")) {
+        if (!this.configuration.features.has("sparql")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
@@ -78,7 +82,7 @@ export function focusSparqlConstructTriples({ filter, focusIdentifier, variableP
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
-        if (!this.features.has("sparql")) {
+        if (!this.configuration.features.has("sparql")) {
             return {};
         }
         return singleEntryRecord(`focusSparqlWherePatterns`, code `\
@@ -88,7 +92,7 @@ ${joinCode([
             code `\
 if (focusIdentifier.termType === "Variable") {
   patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
-      filter: filter?.${syntheticNamePrefix}identifier,
+      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
       ignoreRdfType: false,
       preferredLanguages,
       propertyPatterns: [],
@@ -106,7 +110,7 @@ if (focusIdentifier.termType === "Variable") {
 }`);
     }
     get fromRdfResourceFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
+        if (!this.configuration.features.has("rdf")) {
             return {};
         }
         return singleEntryRecord(`fromRdfResource`, code `\
@@ -119,14 +123,17 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         }, null)};`);
     }
     get graphqlTypeVariableStatement() {
-        if (!this.features.has("graphql")) {
+        if (!this.configuration.features.has("graphql")) {
+            return {};
+        }
+        if (this.synthetic) {
             return {};
         }
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
             name: this.name,
-            resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+            resolveType: code `(value: ${this.name}) => value.${this.configuration.syntheticNamePrefix}type`,
             types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
@@ -139,11 +146,11 @@ export namespace Identifier {
 }`);
     }
     get isTypeFunctionDeclaration() {
-        if (this._name === `${syntheticNamePrefix}Object`) {
+        if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
         return singleEntryRecord(`is${this._name}`, code `\
-    export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+    export function is${this._name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
       return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
     }`);
     }
@@ -185,7 +192,7 @@ ${{
         }} as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
+        if (!this.configuration.features.has("rdf")) {
             return {};
         }
         return singleEntryRecord(`toRdfResource`, code `\

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

@@ -1,14 +1,15 @@
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
     readonly kind = "OptionType";
-    readonly typeofs: NonEmptyList<"object">;
-    get conversions(): readonly AbstractContainerType.Conversion[];
+    readonly typeofs: "object"[];
+    get conversionFunction(): AbstractContainerType.ConversionFunction;
     get equalsFunction(): Code;
     get filterFunction(): Code;
+    get hashFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get mutable(): boolean;
@@ -23,7 +24,6 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/OptionType.js

@@ -4,45 +4,29 @@ 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, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import { codeEquals } from "./codeEquals.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "OptionType";
-    typeofs = NonEmptyList(["object"]);
-    get conversions() {
-        const conversions = [];
-        conversions.push({
-            conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-            sourceTypeName: this.name,
-            sourceTypeof: "object",
-        });
-        for (const itemTypeConversion of this.itemType.conversions) {
-            conversions.push({
-                ...itemTypeConversion,
-                conversionExpression: (value) => code `${this.reusables.imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
-            });
-        }
-        // Unless itemType is a list, it should only have a conversion from undefined if it has a
-        // defaultValue. Per the CST->AST transformation logic, a type with a defaultValue
-        // should never be wrapped in an OptionType.
-        invariant(!conversions.some((conversion) => conversion.sourceTypeof === "undefined") || this.itemType instanceof AbstractCollectionType);
-        if (!conversions.some((conversion) => conversion.sourceTypeof === "undefined")) {
-            conversions.push({
-                conversionExpression: () => code `${this.reusables.imports.Maybe}.empty()`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
-        }
-        return conversions;
+    typeofs = ["object"];
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction;
+        return {
+            code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
+            sourceTypes: itemConversionFunction.sourceTypes.concat({
+                name: this.name,
+                typeof: "object",
+            }, {
+                name: code `undefined`,
+                typeof: "undefined",
+            }),
+        };
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -50,6 +34,9 @@ export class OptionType extends AbstractContainerType {
     get filterFunction() {
         return code `${this.reusables.snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
+    get hashFunction() {
+        return code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction})`;
+    }
     get filterType() {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
@@ -97,19 +84,6 @@ export class OptionType extends AbstractContainerType {
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
-    hashStatements({ depth, variables, }) {
-        return [
-            code `${variables.value}.ifJust((value${depth}) => { ${joinCode(this.itemType
-                .hashStatements({
-                depth: depth + 1,
-                variables: {
-                    hasher: variables.hasher,
-                    value: code `value${depth}`,
-                },
-            })
-                .concat())} });`,
-        ];
-    }
     jsonType(parameters) {
         const itemTypeJsonType = this.itemType.jsonType(parameters);
         invariant(!itemTypeJsonType.optional);
@@ -142,13 +116,16 @@ export class OptionType extends AbstractContainerType {
 }
 __decorate([
     Memoize()
-], OptionType.prototype, "conversions", null);
+], OptionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterType", null);

package/dist/generators/ts/Reusables.d.ts

@@ -1,10 +1,12 @@
 import type { Logger } from "ts-log";
 import { Imports } from "./Imports.js";
 import { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
 export declare class Reusables {
     readonly imports: Imports;
     readonly snippets: Snippets;
-    constructor({ logger }: {
+    constructor({ configuration, logger, }: {
+        configuration: TsGenerator.Configuration;
         logger: Logger;
     });
 }

package/dist/generators/ts/Reusables.js

@@ -3,9 +3,10 @@ import { Snippets } from "./Snippets.js";
 export class Reusables {
     imports;
     snippets;
-    constructor({ logger }) {
+    constructor({ configuration, logger, }) {
         this.imports = new Imports();
         this.snippets = new Snippets({
+            configuration,
             imports: this.imports,
             logger,
         });

package/dist/generators/ts/SetType.d.ts

@@ -3,7 +3,6 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "SetType";
-    get conversions(): readonly AbstractCollectionType.Conversion[];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -11,18 +11,6 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "SetType";
-    get conversions() {
-        const conversions = [];
-        if (this.minCount === 0n) {
-            conversions.push({
-                conversionExpression: () => code `[]`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
-        }
-        return conversions.concat(super.conversions);
-    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
@@ -31,17 +19,11 @@ export class SetType extends AbstractCollectionType {
     }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        const chain = [
+        return joinCode([
             this.itemType.fromRdfResourceValuesExpression(parameters),
-        ];
-        if (this.minCount === 0n || this._mutable) {
-            chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
-        }
-        else {
-            chain.push(code `chain(values => ${this.reusables.imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${variables.resource}.identifier} is an empty set\`)))`);
-        }
-        chain.push(code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
-        return joinCode(chain, { on: "." });
+            code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`,
+            code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
+        ], { on: "." });
     }
     jsonType() {
         const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;

package/dist/generators/ts/SnippetFactory.d.ts

@@ -3,8 +3,10 @@ import type { Logger } from "ts-log";
 import type { Imports } from "./Imports.js";
 import type { Snippet } from "./Snippet.js";
 import type { Snippets } from "./Snippets.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Code } from "./ts-poet-wrapper.js";
 export type SnippetFactory = (parameters: {
+    configuration: TsGenerator.Configuration;
     imports: Imports;
     logger: Logger;
     rdfjsTermExpression: (rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">) => Code;

package/dist/generators/ts/Snippets.d.ts

@@ -1,11 +1,14 @@
 import type { Logger } from "ts-log";
 import type { Imports } from "./Imports.js";
 import type { Snippet } from "./Snippet.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class Snippets {
-    protected readonly imports: Imports;
-    protected readonly logger: Logger;
-    constructor({ imports, logger }: {
+    private readonly configuration;
+    private readonly imports;
+    private readonly logger;
+    constructor({ configuration, imports, logger, }: {
+        configuration: TsGenerator.Configuration;
         imports: Imports;
         logger: Logger;
     });
@@ -23,6 +26,7 @@ export declare class Snippets {
     get FocusSparqlWherePatternsFunction(): Snippet;
     get FromRdfResourceFunction(): Snippet;
     get FromRdfResourceValuesFunction(): Snippet;
+    get HashFunction(): Snippet;
     get Hasher(): Snippet;
     get IdentifierFilter(): Snippet;
     get IdentifierSchema(): Snippet;
@@ -63,6 +67,29 @@ export declare class Snippets {
     get booleanEquals(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
+    get convertToBigDecimal(): Snippet;
+    get convertToBlankNode(): Snippet;
+    get convertToBlankNodeIdentifierProperty(): Snippet;
+    get convertToBoolean(): Snippet;
+    get convertToDate(): Snippet;
+    get convertToDateTime(): Snippet;
+    get convertToIdentifier(): Snippet;
+    get convertToIdentifierProperty(): Snippet;
+    get convertToIri(): Snippet;
+    get convertToIriIdentifierProperty(): Snippet;
+    get convertToLazyObject(): Snippet;
+    get convertToLazyObjectOption(): Snippet;
+    get convertToLazyObjectSet(): Snippet;
+    get convertToLiteral(): Snippet;
+    get convertToMaybe(): Snippet;
+    get convertToMutableArray(): Snippet;
+    get convertToNumeric(): Snippet;
+    get convertToObject(): Snippet;
+    get convertToReadonlyArray(): Snippet;
+    get convertToString(): Snippet;
+    get convertToTerm(): Snippet;
+    get convertToUnion(): Snippet;
+    get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
     get dateSparqlWherePatterns(): Snippet;
     get decodeBigDecimalLiteral(): Snippet;
@@ -82,14 +109,18 @@ export declare class Snippets {
     get filterTerm(): Snippet;
     get fromRdfLanguageIn(): Snippet;
     get fromRdfPreferredLanguages(): Snippet;
+    get hashArray(): Snippet;
+    get hashBigDecimal(): Snippet;
+    get hashBoolean(): Snippet;
+    get hashDate(): Snippet;
+    get hashDateTime(): Snippet;
+    get hashMaybe(): Snippet;
+    get hashNumeric(): Snippet;
+    get hashString(): Snippet;
+    get hashTerm(): Snippet;
     get identifierSparqlWherePatterns(): Snippet;
     get ifUsed(): Code[];
     get iriSparqlWherePatterns(): Snippet;
-    get isReadonlyBigIntArray(): Snippet;
-    get isReadonlyBooleanArray(): Snippet;
-    get isReadonlyNumberArray(): Snippet;
-    get isReadonlyObjectArray(): Snippet;
-    get isReadonlyStringArray(): Snippet;
     get liftSparqlPatterns(): Snippet;
     get listSparqlConstructTriples(): Snippet;
     get listSparqlWherePatterns(): Snippet;
@@ -119,6 +150,7 @@ export declare class Snippets {
     get termFilterSparqlPatterns(): Snippet;
     get termSchemaSparqlPatterns(): Snippet;
     get termSparqlWherePatterns(): Snippet;
+    get toIsoDateString(): Snippet;
     get wrap_FromRdfResourceFunction(): Snippet;
     get wrap_ToRdfResourceFunction(): Snippet;
     protected get snippets(): Snippets;