@shaclmate/compiler 4.0.76 → 4.0.77

package/dist/generators/ts/AbstractCollectionType.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
@@ -41,7 +41,7 @@ export class AbstractCollectionType extends AbstractContainerType {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
     get validationFunction() {
-        return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
+        return Maybe.of(code `${this._mutable ? this.reusables.snippets.validateMutableArray : this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
     }
     get inlineExpression() {
         return code `${!this._mutable ? "readonly " : ""}(${this.itemType.expression})[]`;

package/dist/generators/ts/IdentifierType.js

@@ -24,7 +24,7 @@ export class IdentifierType extends AbstractIdentifierType {
             },
             {
                 // To NamedNode
-                expression: code `string`,
+                expression: code `(keyof ${this.configuration.syntheticNamePrefix}DefaultNamespaceT & string)`,
                 jsType: { typeof: "string" },
             },
             {

package/dist/generators/ts/IriType.js

@@ -19,10 +19,14 @@ export class IriType extends AbstractIdentifierType {
     get conversionFunction() {
         invariant(this.jsTypes.length === 1);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToIri}<${this.valueTypeExpression}>`,
+            code: this.in_.length > 0
+                ? code `${this.reusables.snippets.convertToInIri}<${this.valueTypeExpression}>`
+                : code `${this.reusables.snippets.convertToIri}`,
             sourceTypes: [
                 {
-                    expression: this.valueTypeExpression,
+                    expression: this.in_.length > 0
+                        ? this.valueTypeExpression
+                        : code `(keyof ${this.configuration.syntheticNamePrefix}DefaultNamespaceT & string)`,
                     jsType: { typeof: "string" },
                 },
                 {

package/dist/generators/ts/ListType.js

@@ -8,7 +8,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
     identifierNodeKind;
     toRdfTypes;
@@ -24,7 +24,7 @@ export class ListType extends AbstractCollectionType {
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
-            code: code `${this.reusables.snippets.convertToList}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            code: code `${this._mutable ? this.reusables.snippets.convertToMutableList : this.reusables.snippets.convertToList}(${itemConversionFunction.code})`,
             sourceTypes: [
                 {
                     expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,

package/dist/generators/ts/ObjectType.d.ts

@@ -65,7 +65,7 @@ export declare class ObjectType extends AbstractType {
         type: {
             expression: Code;
         };
-        variable: string;
+        variable: Code;
     };
     protected get createFunction(): Code;
     protected get thisVariable(): Code;

package/dist/generators/ts/ObjectType.js

@@ -88,13 +88,14 @@ export class ObjectType extends AbstractType {
         let staticModuleDeclarations = {
             ...super.staticModuleDeclarations(name),
         };
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         // 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)};`;
+                code `export const create = ${ObjectType_createFunctionExpression.call(this)};`;
             staticModuleDeclarations["createUnsafe"] =
-                code `export function createUnsafe(${this.constructorParameters.signature}): ${this.expression} {
-  return create(parameters).unsafeCoerce();
+                code `export function createUnsafe<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${this.constructorParameters.signature}): ${this.expression} {
+  return create(${this.constructorParameters.variable}).unsafeCoerce();
 }`;
         }
         // equals
@@ -213,8 +214,8 @@ export class ObjectType extends AbstractType {
         }
         // 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[`${syntheticNamePrefix}toString`] =
+                code `export const ${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)};`;
         }
@@ -323,7 +324,10 @@ export class ObjectType extends AbstractType {
     }
     get constructorParameters() {
         let hasQuestionToken = true;
-        const propertySignatures = [];
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        const propertySignatures = [
+            code `readonly ${syntheticNamePrefix}defaultNamespace?: ${syntheticNamePrefix}DefaultNamespaceT;`,
+        ];
         for (const property of this.properties) {
             property.constructorParameter.ifJust((propertyConstructorParameter) => {
                 hasQuestionToken =
@@ -331,7 +335,6 @@ export class ObjectType extends AbstractType {
                 propertySignatures.push(propertyConstructorParameter.signature);
             });
         }
-        invariant(propertySignatures.length > 0);
         const typeExpression = code `{ ${joinCode(propertySignatures)} }`;
         return {
             hasQuestionToken,
@@ -339,7 +342,7 @@ export class ObjectType extends AbstractType {
             type: {
                 expression: typeExpression,
             },
-            variable: "parameters",
+            variable: code `parameters`,
         };
     }
     get createFunction() {

package/dist/generators/ts/SetType.js

@@ -8,7 +8,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     jsTypes = [
@@ -30,10 +30,14 @@ export class SetType extends AbstractCollectionType {
         const sourceTypes = [];
         if (itemConversionFunction.sourceTypes.some((sourceType) => sourceType.jsType.typeof === "object" &&
             sourceType.jsType.instanceof === "Array")) {
-            conversionFunction = this.reusables.snippets.convertToArraySet;
+            conversionFunction = this._mutable
+                ? this.reusables.snippets.convertToMutableArraySet
+                : this.reusables.snippets.convertToArraySet;
         }
         else {
-            conversionFunction = this.reusables.snippets.convertToScalarSet;
+            conversionFunction = this._mutable
+                ? this.reusables.snippets.convertToMutableScalarSet
+                : this.reusables.snippets.convertToScalarSet;
             // Convert from a single item
             sourceTypes.push(...itemConversionFunction.sourceTypes);
         }
@@ -50,7 +54,7 @@ export class SetType extends AbstractCollectionType {
             });
         }
         return Maybe.of({
-            code: code `${conversionFunction}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            code: code `${conversionFunction}(${itemConversionFunction.code})`,
             sourceTypes,
         });
     }

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

@@ -43,6 +43,7 @@ export declare class Snippets {
     get LiteralSchema(): Snippet;
     get MaybeFilter(): Snippet;
     get MaybeSchema(): Snippet;
+    get NamespaceBuilder(): Snippet;
     get NumericFilter(): Snippet;
     get NumericSchema(): Snippet;
     get PropertyPath(): Snippet;
@@ -80,6 +81,8 @@ export declare class Snippets {
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;
     get convertToIdentifierProperty(): Snippet;
+    get convertToInIri(): Snippet;
+    get convertToInIriIdentifierProperty(): Snippet;
     get convertToIri(): Snippet;
     get convertToIriIdentifierProperty(): Snippet;
     get convertToLangString(): Snippet;
@@ -89,6 +92,9 @@ export declare class Snippets {
     get convertToList(): Snippet;
     get convertToLiteral(): Snippet;
     get convertToMaybe(): Snippet;
+    get convertToMutableArraySet(): Snippet;
+    get convertToMutableList(): Snippet;
+    get convertToMutableScalarSet(): Snippet;
     get convertToScalarSet(): Snippet;
     get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
@@ -175,6 +181,7 @@ export declare class Snippets {
     get toIsoDateString(): Snippet;
     get validateArray(): Snippet;
     get validateMaybe(): Snippet;
+    get validateMutableArray(): Snippet;
     get wrap_FromRdfResourceFunction(): Snippet;
     get wrap_ToRdfResourceFunction(): Snippet;
     protected get snippets(): Snippets;

package/dist/generators/ts/Snippets.js

@@ -32,6 +32,8 @@ import { snippets_convertToBlankNode } from "./_snippets/snippets_convertToBlank
 import { snippets_convertToBlankNodeIdentifierProperty } from "./_snippets/snippets_convertToBlankNodeIdentifierProperty.js";
 import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIdentifier.js";
 import { snippets_convertToIdentifierProperty } from "./_snippets/snippets_convertToIdentifierProperty.js";
+import { snippets_convertToInIri } from "./_snippets/snippets_convertToInIri.js";
+import { snippets_convertToInIriIdentifierProperty } from "./_snippets/snippets_convertToInIriIdentifierProperty.js";
 import { snippets_convertToIri } from "./_snippets/snippets_convertToIri.js";
 import { snippets_convertToIriIdentifierProperty } from "./_snippets/snippets_convertToIriIdentifierProperty.js";
 import { snippets_convertToLangString } from "./_snippets/snippets_convertToLangString.js";
@@ -41,6 +43,9 @@ import { snippets_convertToLazySet } from "./_snippets/snippets_convertToLazySet
 import { snippets_convertToList } from "./_snippets/snippets_convertToList.js";
 import { snippets_convertToLiteral } from "./_snippets/snippets_convertToLiteral.js";
 import { snippets_convertToMaybe } from "./_snippets/snippets_convertToMaybe.js";
+import { snippets_convertToMutableArraySet } from "./_snippets/snippets_convertToMutableArraySet.js";
+import { snippets_convertToMutableList } from "./_snippets/snippets_convertToMutableList.js";
+import { snippets_convertToMutableScalarSet } from "./_snippets/snippets_convertToMutableScalarSet.js";
 import { snippets_convertToScalarSet } from "./_snippets/snippets_convertToScalarSet.js";
 import { snippets_convertWithDefaultValue } from "./_snippets/snippets_convertWithDefaultValue.js";
 import { snippets_DateFilter } from "./_snippets/snippets_DateFilter.js";
@@ -121,6 +126,7 @@ import { snippets_maybeSparqlWherePatterns } from "./_snippets/snippets_maybeSpa
 import { snippets_monkeyPatchObject } from "./_snippets/snippets_monkeyPatchObject.js";
 import { snippets_mutableListFromRdfResourceValues } from "./_snippets/snippets_mutableListFromRdfResourceValues.js";
 import { snippets_mutableSetFromRdfResourceValues } from "./_snippets/snippets_mutableSetFromRdfResourceValues.js";
+import { snippets_NamespaceBuilder } from "./_snippets/snippets_NamespaceBuilder.js";
 import { snippets_NumericFilter } from "./_snippets/snippets_NumericFilter.js";
 import { snippets_NumericSchema } from "./_snippets/snippets_NumericSchema.js";
 import { snippets_normalizeSparqlWherePatterns } from "./_snippets/snippets_normalizeSparqlWherePatterns.js";
@@ -168,6 +174,7 @@ import { snippets_ValueSparqlConstructTriplesFunction } from "./_snippets/snippe
 import { snippets_ValueSparqlWherePatternsFunction } from "./_snippets/snippets_ValueSparqlWherePatternsFunction.js";
 import { snippets_validateArray } from "./_snippets/snippets_validateArray.js";
 import { snippets_validateMaybe } from "./_snippets/snippets_validateMaybe.js";
+import { snippets_validateMutableArray } from "./_snippets/snippets_validateMutableArray.js";
 import { snippets_wrap_FromRdfResourceFunction } from "./_snippets/snippets_wrap_FromRdfResourceFunction.js";
 import { snippets_wrap_ToRdfResourceFunction } from "./_snippets/snippets_wrap_ToRdfResourceFunction.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
@@ -274,6 +281,9 @@ export class Snippets {
     get MaybeSchema() {
         return this.snippet(snippets_MaybeSchema);
     }
+    get NamespaceBuilder() {
+        return this.snippet(snippets_NamespaceBuilder);
+    }
     get NumericFilter() {
         return this.snippet(snippets_NumericFilter);
     }
@@ -385,6 +395,12 @@ export class Snippets {
     get convertToIdentifierProperty() {
         return this.snippet(snippets_convertToIdentifierProperty);
     }
+    get convertToInIri() {
+        return this.snippet(snippets_convertToInIri);
+    }
+    get convertToInIriIdentifierProperty() {
+        return this.snippet(snippets_convertToInIriIdentifierProperty);
+    }
     get convertToIri() {
         return this.snippet(snippets_convertToIri);
     }
@@ -412,6 +428,15 @@ export class Snippets {
     get convertToMaybe() {
         return this.snippet(snippets_convertToMaybe);
     }
+    get convertToMutableArraySet() {
+        return this.snippet(snippets_convertToMutableArraySet);
+    }
+    get convertToMutableList() {
+        return this.snippet(snippets_convertToMutableList);
+    }
+    get convertToMutableScalarSet() {
+        return this.snippet(snippets_convertToMutableScalarSet);
+    }
     get convertToScalarSet() {
         return this.snippet(snippets_convertToScalarSet);
     }
@@ -686,6 +711,9 @@ export class Snippets {
     get validateMaybe() {
         return this.snippet(snippets_validateMaybe);
     }
+    get validateMutableArray() {
+        return this.snippet(snippets_validateMutableArray);
+    }
     get wrap_FromRdfResourceFunction() {
         return this.snippet(snippets_wrap_FromRdfResourceFunction);
     }
@@ -803,6 +831,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "MaybeSchema", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "NamespaceBuilder", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "NumericFilter", null);
@@ -914,6 +945,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToIdentifierProperty", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToInIri", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToInIriIdentifierProperty", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToIri", null);
@@ -941,6 +978,15 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToMaybe", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToMutableArraySet", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToMutableList", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToMutableScalarSet", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToScalarSet", null);
@@ -1196,6 +1242,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "validateMaybe", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "validateMutableArray", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "wrap_FromRdfResourceFunction", null);

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

@@ -109,13 +109,14 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             if (nodeKinds.has("BlankNode")) {
                 conversionFunction = code `${this.reusables.snippets.convertToBlankNodeIdentifierProperty}`;
             }
+            else if (this.type.in_.length > 0) {
+                conversionFunction = code `${this.reusables.snippets.convertToInIriIdentifierProperty}<${joinCode(this.type.in_.map((in_) => code `${literalOf(in_.value)}`), { on: " | " })}>`;
+            }
             else {
-                conversionFunction = code `${this.reusables.snippets.convertToIriIdentifierProperty}<${this.type.in_.length > 0
-                    ? joinCode(this.type.in_.map((in_) => code `${literalOf(in_.value)}`), { on: " | " })
-                    : "string"}>`;
+                conversionFunction = code `${this.reusables.snippets.convertToIriIdentifierProperty}`;
             }
         }
-        return Maybe.of(code `${this.name}: ${conversionFunction}(${variables.parameters}.${this.name})`);
+        return Maybe.of(code `${this.name}: ${conversionFunction}(${variables.parameters}.${this.name}, ${variables.parameters}.${this.configuration.syntheticNamePrefix}defaultNamespace)`);
     }
     fromJsonInitializer({ variables, }) {
         return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({

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

@@ -143,14 +143,15 @@ export class ObjectType_ShaclProperty extends ObjectType_AbstractProperty {
     }
     constructorInitializer({ variables, }) {
         const parameterVariable = code `${variables.parameters}.${this.name}`;
+        const defaultNamespaceVariable = code `${variables.parameters}.${this.configuration.syntheticNamePrefix}defaultNamespace`;
         const conversionFunction = this.type.conversionFunction.extract()?.code;
         const validationFunction = this.type.validationFunction.extract();
         let rhs;
         if (conversionFunction && validationFunction) {
-            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.typeSchemaVariable}, value))`;
+            rhs = code `${conversionFunction}(${parameterVariable}, ${defaultNamespaceVariable}).chain(value => ${validationFunction}(${this.typeSchemaVariable}, value))`;
         }
         else if (conversionFunction) {
-            rhs = code `${conversionFunction}(${parameterVariable})`;
+            rhs = code `${conversionFunction}(${parameterVariable}, ${defaultNamespaceVariable})`;
         }
         else if (validationFunction) {
             rhs = code `${validationFunction}(${this.typeSchemaVariable}, ${parameterVariable})`;

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

@@ -1,7 +1,7 @@
 import { invariant } from "ts-invariant";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function ObjectType_createFunctionExpression() {
-    const parametersVariable = code `parameters${this.constructorParameters.hasQuestionToken ? "?" : ""}`;
+    const parametersVariable = code `${this.constructorParameters.variable}${this.constructorParameters.hasQuestionToken ? "?" : ""}`;
     const propertyInitializers = this.properties.flatMap((property) => property
         .constructorInitializer({
         variables: { parameters: parametersVariable },
@@ -23,6 +23,7 @@ export function ObjectType_createFunctionExpression() {
     if (Object.keys(monkeyPatchMethods).length > 0) {
         returnExpression = code `${returnExpression}.map(object => ${this.reusables.snippets.monkeyPatchObject}(object, ${monkeyPatchMethods}))`;
     }
-    return code `((parameters${this.name.map(() => code ``).orDefaultLazy(() => code `: ${this.constructorParameters.type.expression}`)}) => ${returnExpression})`;
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    return code `(<${syntheticNamePrefix}DefaultNamespaceT extends ${this.reusables.snippets.NamespaceBuilder} = ${this.reusables.snippets.NamespaceBuilder}>(${parametersVariable}: ${this.constructorParameters.type.expression})${this.name.map((name) => code `: ${this.reusables.imports.Either}<Error, ${name}>`).orDefault(code ``)} => ${returnExpression})`;
 }
 //# sourceMappingURL=ObjectType_createFunctionExpression.js.map

package/dist/generators/ts/_snippets/snippets_ConversionFunction.js

@@ -1,4 +1,4 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_ConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ConversionFunction`, code `\
-type ${syntheticNamePrefix}ConversionFunction<SourceT, TargetT> = (source: SourceT) => ${imports.Either}<Error, TargetT>;`);
+export const snippets_ConversionFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ConversionFunction`, code `\
+type ${syntheticNamePrefix}ConversionFunction<SourceT, TargetT, DefaultNamespaceT extends ${snippets.NamespaceBuilder} = ${snippets.NamespaceBuilder}> = (source: SourceT, defaultNamespace?: DefaultNamespaceT) => ${imports.Either}<Error, TargetT>;`);
 //# sourceMappingURL=snippets_ConversionFunction.js.map

package/dist/generators/ts/_snippets/snippets_NamespaceBuilder.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_NamespaceBuilder: SnippetFactory;
+//# sourceMappingURL=snippets_NamespaceBuilder.d.ts.map

package/dist/generators/ts/_snippets/snippets_NamespaceBuilder.js

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_NamespaceBuilder = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}NamespaceBuilder`, code `\
+/**
+ * NamespaceBuilder type excerpted from @rdfjs/namespace (MIT license) in lieu of a type import.
+ */
+type ${syntheticNamePrefix}NamespaceBuilder<TermNames extends string = any> = Record<TermNames, NamedNode> & {
+    (property?: TemplateStringsArray | TermNames): ${imports.NamedNode};
+};`);
+//# sourceMappingURL=snippets_NamespaceBuilder.js.map

package/dist/generators/ts/_snippets/snippets_convertToArraySet.js

@@ -1,8 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToArraySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArraySet`, code `\
-function ${syntheticNamePrefix}convertToArraySet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
-  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
-  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => 
-    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, ItemTargetArrayT>;
+function ${syntheticNamePrefix}convertToArraySet<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<readonly ItemSourceT[] | undefined, readonly ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace)))) as ${imports.Either}<Error, readonly ItemTargetT[]>;
 }`);
 //# sourceMappingURL=snippets_convertToArraySet.js.map

package/dist/generators/ts/_snippets/snippets_convertToBlankNode.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToBlankNode = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNode`, code `\
-function ${syntheticNamePrefix}convertToBlankNode(value: ${imports.BlankNode} | undefined): ${imports.Either}<Error, ${imports.BlankNode}> {
+export const snippets_convertToBlankNode = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNode`, code `\
+const ${syntheticNamePrefix}convertToBlankNode: ${snippets.ConversionFunction}<${imports.BlankNode} | undefined, ${imports.BlankNode}> = (value) => {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

package/dist/generators/ts/_snippets/snippets_convertToBlankNodeIdentifierProperty.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToBlankNodeIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNodeIdentifierProperty`, code `\
-function ${syntheticNamePrefix}convertToBlankNodeIdentifierProperty(identifier: (() => ${imports.BlankNode}) | ${imports.BlankNode} | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode})> {
+export const snippets_convertToBlankNodeIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNodeIdentifierProperty`, code `\
+const ${syntheticNamePrefix}convertToBlankNodeIdentifierProperty: ${snippets.ConversionFunction}<(() => ${imports.BlankNode}) | ${imports.BlankNode} | undefined, () => ${imports.BlankNode}> = (identifier) => {
   switch (typeof identifier) {
     case "function":
       return ${imports.Either}.of(identifier);

package/dist/generators/ts/_snippets/snippets_convertToIdentifier.js

@@ -1,11 +1,11 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIdentifier = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifier`, code `\
-function ${syntheticNamePrefix}convertToIdentifier(value: ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> {
+export const snippets_convertToIdentifier = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifier`, code `\
+function ${syntheticNamePrefix}convertToIdentifier<DefaultNamespaceT extends ${snippets.NamespaceBuilder} = ${snippets.NamespaceBuilder}>(value: ${imports.BlankNode} | ${imports.NamedNode} | (keyof DefaultNamespaceT & string) | undefined, defaultNamespace?: DefaultNamespaceT): ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(${imports.dataFactory}.namedNode(value));
+      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
     case "undefined":
       return ${imports.Either}.of(${imports.dataFactory}.blankNode());
   }

package/dist/generators/ts/_snippets/snippets_convertToIdentifierProperty.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifierProperty`, code `\
-function ${syntheticNamePrefix}convertToIdentifierProperty(identifier: (() => ${imports.BlankNode} | ${imports.NamedNode}) | ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode} | ${imports.NamedNode})> {
+export const snippets_convertToIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIdentifierProperty<DefaultNamespaceT extends ${snippets.NamespaceBuilder} = ${snippets.NamespaceBuilder}>(identifier: (() => ${imports.BlankNode} | ${imports.NamedNode}) | ${imports.BlankNode} | ${imports.NamedNode} | (keyof DefaultNamespaceT & string) | undefined, defaultNamespace?: DefaultNamespaceT): ${imports.Either}<Error, () => ${imports.BlankNode} | ${imports.NamedNode}> {
   switch (typeof identifier) {
     case "function":
       return ${imports.Either}.of(identifier);
@@ -9,7 +9,7 @@ function ${syntheticNamePrefix}convertToIdentifierProperty(identifier: (() => ${
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string": {
-      const captureIdentifier = ${imports.dataFactory}.namedNode(identifier);
+      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "undefined": {

package/dist/generators/ts/_snippets/snippets_convertToInIri.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToInIri: SnippetFactory;
+//# sourceMappingURL=snippets_convertToInIri.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToInIri.js

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToInIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToInIri`, code `\
+function ${syntheticNamePrefix}convertToInIri<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+  switch (typeof value) {
+    case "object":
+      return ${imports.Either}.of(value);
+    case "string":
+      return ${imports.Either}.of(${imports.dataFactory}.namedNode<IriT>(value));
+  }
+}`);
+//# sourceMappingURL=snippets_convertToInIri.js.map

package/dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToInIriIdentifierProperty: SnippetFactory;
+//# sourceMappingURL=snippets_convertToInIriIdentifierProperty.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.js

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToInIriIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToInIriIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToInIriIdentifierProperty<InIriT extends string>(identifier: (() => ${imports.NamedNode}<InIriT>) | ${imports.NamedNode}<InIriT> | InIriT, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, (() => ${imports.NamedNode}<InIriT>)> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "string": {
+      const captureIdentifier = ${imports.dataFactory}.namedNode<InIriT>(identifier);
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToInIriIdentifierProperty.js.map

package/dist/generators/ts/_snippets/snippets_convertToIri.js

@@ -1,11 +1,11 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIri = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
-function ${syntheticNamePrefix}convertToIri<IriT extends string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+export const snippets_convertToIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
+function ${syntheticNamePrefix}convertToIri<DefaultNamespaceT extends ${snippets.NamespaceBuilder} = ${snippets.NamespaceBuilder}>(value: ${imports.NamedNode} | (keyof DefaultNamespaceT & string), defaultNamespace?: DefaultNamespaceT): ${imports.Either}<Error, ${imports.NamedNode}> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(${imports.dataFactory}.namedNode<IriT>(value));
+      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
   }
 }`);
 //# sourceMappingURL=snippets_convertToIri.js.map

package/dist/generators/ts/_snippets/snippets_convertToIriIdentifierProperty.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIriIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriIdentifierProperty`, code `\
-function ${syntheticNamePrefix}convertToIriIdentifierProperty<IriT extends string = string>(identifier: (() => ${imports.NamedNode}<IriT>) | ${imports.NamedNode}<IriT> | IriT): ${imports.Either}<Error, (() => ${imports.NamedNode}<IriT>)> {
+export const snippets_convertToIriIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIriIdentifierProperty<DefaultNamespaceT extends ${snippets.NamespaceBuilder} = ${snippets.NamespaceBuilder}>(identifier: (() => ${imports.NamedNode}) | ${imports.NamedNode} | (keyof DefaultNamespaceT & string), defaultNamespace?: DefaultNamespaceT): ${imports.Either}<Error, (() => ${imports.NamedNode})> {
   switch (typeof identifier) {
     case "function":
       return ${imports.Either}.of(identifier);
@@ -9,7 +9,7 @@ function ${syntheticNamePrefix}convertToIriIdentifierProperty<IriT extends strin
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string": {
-      const captureIdentifier = ${imports.dataFactory}.namedNode<IriT>(identifier);
+      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
       return ${imports.Either}.of(() => captureIdentifier);
     }
   }

package/dist/generators/ts/_snippets/snippets_convertToLangString.js

@@ -1,7 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToLangString = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLangString`, code `\
-function ${syntheticNamePrefix}convertToLangString(value: ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
+export const snippets_convertToLangString = ({ imports, rdfjsTermExpression, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLangString`, code `\
+const ${syntheticNamePrefix}convertToLangString: ${snippets.ConversionFunction}<${imports.Literal}, ${imports.Literal}> = (value) => {
   if (!value.datatype.equals(${rdfjsTermExpression(rdf.langString)})) {
     return ${imports.Left}(new Error(\`expected Literal to have rdf:langString datatype, not \${value.datatype.value}\`));
   }

package/dist/generators/ts/_snippets/snippets_convertToLazy.js

@@ -3,8 +3,8 @@ export const snippets_convertToLazy = ({ imports, snippets, syntheticNamePrefix,
 function ${syntheticNamePrefix}convertToLazy<PartialT, ResolvedT>(
   isPartial: (object: PartialT | ResolvedT) => object is PartialT,
   resolvedToPartial: (resolved: ResolvedT) => PartialT
-) {
-  return (value: ${snippets.Lazy}<PartialT, ResolvedT> | PartialT | ResolvedT): ${imports.Either}<Error, ${snippets.Lazy}<PartialT, ResolvedT>> => {
+): ${snippets.ConversionFunction}<${snippets.Lazy}<PartialT, ResolvedT> | PartialT | ResolvedT, ${snippets.Lazy}<PartialT, ResolvedT>> {
+  return (value) => {
     if (value instanceof ${snippets.Lazy}) {
       return ${imports.Either}.of(value);
     }

package/dist/generators/ts/_snippets/snippets_convertToLazyOption.js

@@ -3,8 +3,8 @@ export const snippets_convertToLazyOption = ({ imports, snippets, syntheticNameP
 function ${syntheticNamePrefix}convertToLazyOption<PartialT, ResolvedT>(
   isPartial: (object: PartialT | ResolvedT) => object is PartialT,
   resolvedToPartial: (resolved: ResolvedT) => PartialT
-) {
-  return (value: ${snippets.LazyOption}<PartialT, ResolvedT> | ${imports.Maybe}<PartialT> | ${imports.Maybe}<ResolvedT> | PartialT | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazyOption}<PartialT, ResolvedT>> => {
+): ${snippets.ConversionFunction}<${snippets.LazyOption}<PartialT, ResolvedT> | ${imports.Maybe}<PartialT> | ${imports.Maybe}<ResolvedT> | PartialT | ResolvedT | undefined, ${snippets.LazyOption}<PartialT, ResolvedT>> {
+  return (value) => {
     if (value instanceof ${snippets.LazyOption}) {
       return ${imports.Either}.of(value);
     }

package/dist/generators/ts/_snippets/snippets_convertToLazySet.js

@@ -3,8 +3,8 @@ export const snippets_convertToLazySet = ({ imports, snippets, syntheticNamePref
 function ${syntheticNamePrefix}convertToLazySet<PartialT, ResolvedT>(
   isPartial: (object: PartialT | ResolvedT) => object is PartialT,
   resolvedToPartial: (resolved: ResolvedT) => PartialT
-) {
-  return (value: ${snippets.LazySet}<PartialT, ResolvedT> | readonly PartialT[] | readonly ResolvedT[] | PartialT | ResolvedT | undefined): ${imports.Either}<Error, ${snippets.LazySet}<PartialT, ResolvedT>> => {
+): ${snippets.ConversionFunction}<${snippets.LazySet}<PartialT, ResolvedT> | readonly PartialT[] | readonly ResolvedT[] | PartialT | ResolvedT | undefined, ${snippets.LazySet}<PartialT, ResolvedT>>  {
+  return (value) => {
     if (typeof value === "undefined") {
       return ${imports.Either}.of(new ${snippets.LazySet}<PartialT, ResolvedT>({
         partials: [],

package/dist/generators/ts/_snippets/snippets_convertToList.js

@@ -1,7 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToList = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToList`, code `\
-function ${syntheticNamePrefix}convertToList<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
-  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
-  return (value: readonly ItemSourceT[]): ${imports.Either}<Error, ItemTargetArrayT> => ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+function ${syntheticNamePrefix}convertToList<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<readonly ItemSourceT[], readonly ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace))) as ${imports.Either}<Error, readonly ItemTargetT[]>;
 }`);
 //# sourceMappingURL=snippets_convertToList.js.map

package/dist/generators/ts/_snippets/snippets_convertToLiteral.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLiteral`, code `\
-function ${syntheticNamePrefix}convertToLiteral(value: bigint | boolean | Date | number | string | ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
+const ${syntheticNamePrefix}convertToLiteral: ${snippets.ConversionFunction}<bigint | boolean | Date | number | string | ${imports.Literal}, ${imports.Literal}> = (value) => {
   if (typeof value === "object") {
     if (value instanceof Date) {
       return ${imports.Either}.of(${snippets.literalFactory}.date(value));

package/dist/generators/ts/_snippets/snippets_convertToMaybe.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMaybe`, code `\
-function ${syntheticNamePrefix}convertToMaybe<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>) {
-  return (value: ItemSourceT | ${imports.Maybe}<ItemTargetT> | undefined): ${imports.Either}<Error, ${imports.Maybe}<ItemTargetT>> => {
+function ${syntheticNamePrefix}convertToMaybe<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<ItemSourceT | ${imports.Maybe}<ItemTargetT> | undefined, ${imports.Maybe}<ItemTargetT>, DefaultNamespaceT> {
+  return (value, defaultNamespace) => {
     switch (typeof value) {
       case "object": {
         if (${imports.Maybe}.isMaybe(value)) {
@@ -13,7 +13,7 @@ function ${syntheticNamePrefix}convertToMaybe<ItemSourceT, ItemTargetT>(convertT
         return ${imports.Either}.of(${imports.Maybe}.empty());
     }
 
-    return convertToItem(value).map(${imports.Maybe}.of);
+    return convertToItem(value, defaultNamespace).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_convertToMaybe.js.map

package/dist/generators/ts/_snippets/snippets_convertToMutableArraySet.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToMutableArraySet: SnippetFactory;
+//# sourceMappingURL=snippets_convertToMutableArraySet.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToMutableArraySet.js

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToMutableArraySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMutableArraySet`, code `\
+function ${syntheticNamePrefix}convertToMutableArraySet<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>): ${snippets.ConversionFunction}<readonly ItemSourceT[] | undefined, ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace)))) as ${imports.Either}<Error, ItemTargetT[]>;
+}`);
+//# sourceMappingURL=snippets_convertToMutableArraySet.js.map

package/dist/generators/ts/_snippets/snippets_convertToMutableList.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToMutableList: SnippetFactory;
+//# sourceMappingURL=snippets_convertToMutableList.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToMutableList.js

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToMutableList = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMutableList`, code `\
+function ${syntheticNamePrefix}convertToMutableList<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<readonly ItemSourceT[], ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace))) as ${imports.Either}<Error, ItemTargetT[]>;
+}`);
+//# sourceMappingURL=snippets_convertToMutableList.js.map

package/dist/generators/ts/_snippets/snippets_convertToMutableScalarSet.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToMutableScalarSet: SnippetFactory;
+//# sourceMappingURL=snippets_convertToMutableScalarSet.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToMutableScalarSet.js

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToMutableScalarSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMutableScalarSet`, code `\
+function ${syntheticNamePrefix}convertToMutableScalarSet<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<ItemSourceT | readonly ItemSourceT[] | undefined, ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => {
+    if (typeof value === "undefined") {
+      return ${imports.Either}.of<Error, ItemTargetT[]>([] as unknown as ItemTargetT[]);
+    }
+    if (Array.isArray(value)) {
+      return ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace))) as ${imports.Either}<Error, ItemTargetT[]>;
+    }
+    return convertToItem(value as ItemSourceT, defaultNamespace).map(value => [value]) as ${imports.Either}<Error, ItemTargetT[]>;
+  };
+}`);
+//# sourceMappingURL=snippets_convertToMutableScalarSet.js.map

package/dist/generators/ts/_snippets/snippets_convertToScalarSet.js

@@ -1,15 +1,14 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToScalarSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToScalarSet`, code `\
-function ${syntheticNamePrefix}convertToScalarSet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
-  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
-  return (value: ItemSourceT | readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => {
+function ${syntheticNamePrefix}convertToScalarSet<DefaultNamespaceT extends ${snippets.NamespaceBuilder}, ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT, DefaultNamespaceT>): ${snippets.ConversionFunction}<ItemSourceT | readonly ItemSourceT[] | undefined, readonly ItemTargetT[], DefaultNamespaceT> {
+  return (value, defaultNamespace) => {
     if (typeof value === "undefined") {
-      return ${imports.Either}.of<Error, ItemTargetArrayT>([] as unknown as ItemTargetArrayT);
+      return ${imports.Either}.of<Error, readonly ItemTargetT[]>([] as unknown as readonly ItemTargetT[]);
     }
     if (Array.isArray(value)) {
-      return ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+      return ${imports.Either}.sequence(value.map(value => convertToItem(value, defaultNamespace))) as ${imports.Either}<Error, readonly ItemTargetT[]>;
     }
-    return convertToItem(value as ItemSourceT).map(value => [value]) as ${imports.Either}<Error, ItemTargetArrayT>;
+    return convertToItem(value as ItemSourceT).map(value => [value]) as ${imports.Either}<Error, readonly ItemTargetT[]>;
   };
 }`);
 //# sourceMappingURL=snippets_convertToScalarSet.js.map

package/dist/generators/ts/_snippets/snippets_convertWithDefaultValue.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertWithDefaultValue = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertWithDefaultValue`, code `\
-function ${syntheticNamePrefix}convertWithDefaultValue<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, defaultValue: ItemSourceT) {
-  return (value: ItemSourceT | undefined): ${imports.Either}<Error, ItemTargetT> => {
+export const snippets_convertWithDefaultValue = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertWithDefaultValue`, code `\
+function ${syntheticNamePrefix}convertWithDefaultValue<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, defaultValue: ItemSourceT): ${snippets.ConversionFunction}<ItemSourceT | undefined, ItemTargetT> {
+  return (value) => {
     if (typeof value === "undefined") {
       return convertToItem(defaultValue);
     }

package/dist/generators/ts/_snippets/snippets_identityConversionFunction.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_identityConversionFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityConversionFunction`, code `\
-function ${syntheticNamePrefix}identityConversionFunction<T>(value: T): ${imports.Either}<Error, T> {
+export const snippets_identityConversionFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identityConversionFunction`, code `\
+function ${syntheticNamePrefix}identityConversionFunction<T>(value: T, _defaultNamespace?: ${snippets.NamespaceBuilder}): ${imports.Either}<Error, T> {
   return ${imports.Either}.of(value);
 }`);
 //# sourceMappingURL=snippets_identityConversionFunction.js.map

package/dist/generators/ts/_snippets/snippets_validateArray.js

@@ -1,13 +1,12 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_validateArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateArray`, code `\
-function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT, Readonly extends boolean>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>, _readonly: Readonly) {
-  type EitherR = Readonly extends true ? ReadonlyArray<ItemValueT> : Array<ItemValueT>;
-  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, valueArray: readonly ItemValueT[]): ${imports.Either}<Error, EitherR> => {
+function ${syntheticNamePrefix}validateArray<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>): ${snippets.ValidationFunction}<${snippets.CollectionSchema}<ItemSchemaT>, readonly ItemValueT[]> {
+  return (schema, valueArray) => {
     if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
-      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, EitherR>;
+      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, readonly ItemValueT[]>;
     }
 
-    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, EitherR>;
+    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, readonly ItemValueT[]>;
   }
 }`);
 //# sourceMappingURL=snippets_validateArray.js.map

package/dist/generators/ts/_snippets/snippets_validateMutableArray.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_validateMutableArray: SnippetFactory;
+//# sourceMappingURL=snippets_validateMutableArray.d.ts.map

package/dist/generators/ts/_snippets/snippets_validateMutableArray.js

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateMutableArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMutableArray`, code `\
+function ${syntheticNamePrefix}validateMutableArray<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>): ${snippets.ValidationFunction}<${snippets.CollectionSchema}<ItemSchemaT>, ItemValueT[]> {
+  return (schema, valueArray) => {
+    if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
+      return ${imports.Left}(new Error(\`value array has length (\${valueArray.length}) less than minCount (\${schema.minCount})\`)) as ${imports.Either}<Error, ItemValueT[]>;
+    }
+
+    return ${imports.Either}.sequence(valueArray.map(value => validateItem(schema.itemType, value))) as ${imports.Either}<Error, ItemValueT[]>;
+  }
+}`);
+//# sourceMappingURL=snippets_validateMutableArray.js.map

package/package.json

@@ -1,11 +1,11 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.76",
+    "@shaclmate/shacl-ast": "4.0.77",
     "@rdfjs/types": "~2.0.1",
-    "@rdfx/collection": "0.0.38",
-    "@rdfx/data-factory": "0.0.38",
-    "@rdfx/literal": "0.0.38",
-    "@rdfx/resource": "0.0.38",
+    "@rdfx/collection": "0.0.42",
+    "@rdfx/data-factory": "0.0.42",
+    "@rdfx/literal": "0.0.42",
+    "@rdfx/resource": "0.0.42",
     "@sindresorhus/base62": "~0.1.0",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "change-case": "~5.4.4",
@@ -19,8 +19,8 @@
     "typescript-memoize": "~1.1.1"
   },
   "devDependencies": {
-    "@rdfx/fs": "0.0.38",
-    "@rdfx/serializers": "0.0.38"
+    "@rdfx/fs": "0.0.42",
+    "@rdfx/serializers": "0.0.42"
   },
   "files": [
     "dist/Compiler.d.ts",
@@ -409,6 +409,8 @@
     "dist/generators/ts/_snippets/snippets_MaybeFilter.js",
     "dist/generators/ts/_snippets/snippets_MaybeSchema.d.ts",
     "dist/generators/ts/_snippets/snippets_MaybeSchema.js",
+    "dist/generators/ts/_snippets/snippets_NamespaceBuilder.d.ts",
+    "dist/generators/ts/_snippets/snippets_NamespaceBuilder.js",
     "dist/generators/ts/_snippets/snippets_NumericFilter.d.ts",
     "dist/generators/ts/_snippets/snippets_NumericFilter.js",
     "dist/generators/ts/_snippets/snippets_NumericSchema.d.ts",
@@ -483,6 +485,10 @@
     "dist/generators/ts/_snippets/snippets_convertToIdentifier.js",
     "dist/generators/ts/_snippets/snippets_convertToIdentifierProperty.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToIdentifierProperty.js",
+    "dist/generators/ts/_snippets/snippets_convertToInIri.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToInIri.js",
+    "dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToInIriIdentifierProperty.js",
     "dist/generators/ts/_snippets/snippets_convertToIri.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToIri.js",
     "dist/generators/ts/_snippets/snippets_convertToIriIdentifierProperty.d.ts",
@@ -501,6 +507,12 @@
     "dist/generators/ts/_snippets/snippets_convertToLiteral.js",
     "dist/generators/ts/_snippets/snippets_convertToMaybe.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToMaybe.js",
+    "dist/generators/ts/_snippets/snippets_convertToMutableArraySet.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToMutableArraySet.js",
+    "dist/generators/ts/_snippets/snippets_convertToMutableList.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToMutableList.js",
+    "dist/generators/ts/_snippets/snippets_convertToMutableScalarSet.d.ts",
+    "dist/generators/ts/_snippets/snippets_convertToMutableScalarSet.js",
     "dist/generators/ts/_snippets/snippets_convertToScalarSet.d.ts",
     "dist/generators/ts/_snippets/snippets_convertToScalarSet.js",
     "dist/generators/ts/_snippets/snippets_convertWithDefaultValue.d.ts",
@@ -671,6 +683,8 @@
     "dist/generators/ts/_snippets/snippets_validateArray.js",
     "dist/generators/ts/_snippets/snippets_validateMaybe.d.ts",
     "dist/generators/ts/_snippets/snippets_validateMaybe.js",
+    "dist/generators/ts/_snippets/snippets_validateMutableArray.d.ts",
+    "dist/generators/ts/_snippets/snippets_validateMutableArray.js",
     "dist/generators/ts/_snippets/snippets_wrap_FromRdfResourceFunction.d.ts",
     "dist/generators/ts/_snippets/snippets_wrap_FromRdfResourceFunction.js",
     "dist/generators/ts/_snippets/snippets_wrap_ToRdfResourceFunction.d.ts",
@@ -715,5 +729,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.76"
+  "version": "4.0.77"
 }