@shaclmate/compiler 4.0.96 → 4.0.98

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

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

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

@@ -0,0 +1,28 @@
+import { code, conditionalOutput, joinCode, } from "../ts-poet-wrapper.js";
+export const snippets_FromJsonFunction = ({ configuration, imports, snippets, syntheticNamePrefix, }) => {
+    const options = [code `context?: unknown;`];
+    options.push(code `defaultNamespace?: ${snippets.NamespaceBuilder};`);
+    if (configuration.features.has("ObjectSet")) {
+        options.push(code `objectSet?: ${syntheticNamePrefix}ObjectSet;`);
+    }
+    options.push(code `prefixMap?: ${imports.PrefixMap};`);
+    const joinedOptions = joinCode(options.map((option) => code `        ${option}`), { on: "\n" });
+    return conditionalOutput(`${syntheticNamePrefix}FromJsonFunction`, code `\
+export type ${syntheticNamePrefix}FromJsonFunction<JsonValueT, ValueT, ValueSchemaT> = 
+  [ValueSchemaT] extends [undefined]
+  ? (
+      jsonValue: JsonValueT,
+      options?: {
+${joinedOptions}
+        schema?: unknown;
+      },
+    ) => ${imports.Either}<Error, ValueT>
+  : (
+      jsonValue: JsonValueT,
+      options: {
+${joinedOptions}
+        schema: ValueSchemaT;
+      },
+    ) => ${imports.Either}<Error, ValueT>;`);
+};
+//# sourceMappingURL=snippets_FromJsonFunction.js.map

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

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

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

@@ -0,0 +1,3 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ToJsonFunction = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ToJsonFunction`, code `export type ${syntheticNamePrefix}ToJsonFunction<T, JsonT> = (value: T) => JsonT;`);
+//# sourceMappingURL=snippets_ToJsonFunction.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_arrayFromJsonArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayFromJsonArray`, code `\
-function ${syntheticNamePrefix}arrayFromJsonArray<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonValueFunction}<ItemJsonValueT[] | undefined, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}arrayFromJsonArray<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonValueT[] | undefined, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
   return (jsonArray, options) => {
     if (jsonArray === undefined) {
       return ${imports.Either}.of([]);

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_arrayToJsonArray = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}arrayToJsonArray`, code `\
-function ${syntheticNamePrefix}arrayToJsonArray<ItemT, ItemJsonValueT>(itemToJsonValue: ${snippets.ToJsonValueFunction}<ItemT, ItemJsonValueT>): ${snippets.ToJsonValueFunction}<readonly ItemT[], ItemJsonValueT[]> {
+function ${syntheticNamePrefix}arrayToJsonArray<ItemT, ItemJsonValueT>(itemToJsonValue: ${snippets.ToJsonFunction}<ItemT, ItemJsonValueT>): ${snippets.ToJsonFunction}<readonly ItemT[], ItemJsonValueT[]> {
   return (array) => array.map(itemToJsonValue);
 }`);
 //# sourceMappingURL=snippets_arrayToJsonArray.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromJsonObject`, code `\
-const ${syntheticNamePrefix}bigDecimalFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
+const ${syntheticNamePrefix}bigDecimalFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
   (jsonObject, options) => ${snippets.literalFromJsonObject}(jsonObject, options).chain(${imports.LiteralDecoder}.decodeBigDecimalLiteral);`);
 //# sourceMappingURL=snippets_bigDecimalFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalFromJsonString`, code `\
-const ${syntheticNamePrefix}bigDecimalFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
+const ${syntheticNamePrefix}bigDecimalFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BigDecimal}, ${snippets.NumericSchema}<${imports.BigDecimal}>> = 
   (jsonValue) => ${imports.Either}.encase(() => new ${imports.BigDecimal}(jsonValue));`);
 //# sourceMappingURL=snippets_bigDecimalFromJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalToJsonObject`, code `\
-function ${syntheticNamePrefix}bigDecimalToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<${imports.BigDecimal}, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}bigDecimalToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<${imports.BigDecimal}, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.bigdecimal(value, datatype));
 }`);
 //# sourceMappingURL=snippets_bigDecimalToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigDecimalToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigDecimalToJsonString`, code `\
-const ${syntheticNamePrefix}bigDecimalToJsonString: ${snippets.ToJsonValueFunction}<${imports.BigDecimal}, string> =
+const ${syntheticNamePrefix}bigDecimalToJsonString: ${snippets.ToJsonFunction}<${imports.BigDecimal}, string> =
   (bigDecimal) => bigDecimal.toFixed();`);
 //# sourceMappingURL=snippets_bigDecimalToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntFromJsonObject`, code `\
-function ${syntheticNamePrefix}bigIntFromJsonObject<BigIntT extends bigint>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
+function ${syntheticNamePrefix}bigIntFromJsonObject<BigIntT extends bigint>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeBigIntLiteral)

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntFromJsonString`, code `\
-function ${syntheticNamePrefix}bigIntFromJsonString<JsonValueT extends string, BigIntT extends bigint>(jsonValue: JsonValueT, options: Parameters<${snippets.FromJsonValueFunction}<string, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
+function ${syntheticNamePrefix}bigIntFromJsonString<JsonValueT extends string, BigIntT extends bigint>(jsonValue: JsonValueT, options: Parameters<${snippets.FromJsonFunction}<string, BigIntT, ${snippets.NumericSchema}<BigIntT>>>[1]): ${imports.Either}<Error, BigIntT> {
   const { schema } = options;
   return ${imports.Either}.encase(() => BigInt(jsonValue) as BigIntT)
     .chain(value => ${snippets.constrainPrimitive}<BigIntT, bigint>(value, schema.in)) as ${imports.Either}<Error, BigIntT>;

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntToJsonObject`, code `\
-function ${syntheticNamePrefix}bigIntToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<bigint, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}bigIntToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<bigint, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.bigint(value, datatype));
 }`);
 //# sourceMappingURL=snippets_bigIntToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_bigIntToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}bigIntToJsonString`, code `\
-const ${syntheticNamePrefix}bigIntToJsonString: ${snippets.ToJsonValueFunction}<bigint, string> =
+const ${syntheticNamePrefix}bigIntToJsonString: ${snippets.ToJsonFunction}<bigint, string> =
   (bigInt) => bigInt.toString();`);
 //# sourceMappingURL=snippets_bigIntToJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromJsonObject`, code `\
-const ${syntheticNamePrefix}blankNodeFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode}, undefined> = 
+const ${syntheticNamePrefix}blankNodeFromJsonObject: ${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode}, undefined> = 
   (jsonObject) => ${snippets.blankNodeFromJsonString}(jsonObject["@id"]);`);
 //# sourceMappingURL=snippets_blankNodeFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeFromJsonString`, code `\
-const ${syntheticNamePrefix}blankNodeFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BlankNode}, undefined> = 
+const ${syntheticNamePrefix}blankNodeFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BlankNode}, undefined> = 
   (jsonValue) => ${imports.Right}(${imports.dataFactory}.blankNode(jsonValue.substring(2)));`);
 //# sourceMappingURL=snippets_blankNodeFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeToJsonObject`, code `\
-const ${syntheticNamePrefix}blankNodeToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.BlankNode}, ${snippets.IdentifierJsonObject}> =
+const ${syntheticNamePrefix}blankNodeToJsonObject: ${snippets.ToJsonFunction}<${imports.BlankNode}, ${snippets.IdentifierJsonObject}> =
   (blankNode) => ({ "@id": ${snippets.blankNodeToJsonString}(blankNode) });`);
 //# sourceMappingURL=snippets_blankNodeToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_blankNodeToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}blankNodeToJsonString`, code `\
-const ${syntheticNamePrefix}blankNodeToJsonString: ${snippets.ToJsonValueFunction}<${imports.BlankNode}, string> =
+const ${syntheticNamePrefix}blankNodeToJsonString: ${snippets.ToJsonFunction}<${imports.BlankNode}, string> =
   (blankNode) => \`_:\${blankNode.value}\`;`);
 //# sourceMappingURL=snippets_blankNodeToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_booleanFromJsonBoolean = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanFromJsonBoolean`, code `\
-function ${syntheticNamePrefix}booleanFromJsonBoolean<BooleanT extends boolean>(jsonBoolean: BooleanT, _options: Parameters<${snippets.FromJsonValueFunction}<BooleanT, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
+function ${syntheticNamePrefix}booleanFromJsonBoolean<BooleanT extends boolean>(jsonBoolean: BooleanT, _options: Parameters<${snippets.FromJsonFunction}<BooleanT, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
   return ${imports.Either}.of(jsonBoolean);
 }`);
 //# sourceMappingURL=snippets_booleanFromJsonBoolean.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_booleanFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}booleanFromJsonObject`, code `\
-function ${syntheticNamePrefix}booleanFromJsonObject<BooleanT extends boolean>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
+function ${syntheticNamePrefix}booleanFromJsonObject<BooleanT extends boolean>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, BooleanT, ${snippets.BooleanSchema}<BooleanT>>>[1]): ${imports.Either}<Error, BooleanT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeBooleanLiteral)

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

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIdentifier<DefaultNamespaceT extends ${s
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
+      return ${snippets.iriFromString}(value, { defaultNamespace });
     case "undefined":
       return ${imports.Either}.of(${imports.dataFactory}.blankNode());
   }

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

@@ -8,10 +8,8 @@ function ${syntheticNamePrefix}convertToIdentifierProperty<DefaultNamespaceT ext
       const captureIdentifier = identifier;
       return ${imports.Either}.of(() => captureIdentifier);
     }
-    case "string": {
-      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
-      return ${imports.Either}.of(() => captureIdentifier);
-    }
+    case "string":
+      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
     case "undefined": {
       const captureIdentifier = ${imports.dataFactory}.blankNode();
       return ${imports.Either}.of(() => captureIdentifier);

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

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIri<DefaultNamespaceT extends ${snippets
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${imports.Either}.of(defaultNamespace ? defaultNamespace(value) : ${imports.dataFactory}.namedNode(value));
+      return ${snippets.iriFromString}(value, { defaultNamespace });
   }
 }`);
 //# sourceMappingURL=snippets_convertToIri.js.map

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

@@ -9,8 +9,7 @@ function ${syntheticNamePrefix}convertToIriIdentifierProperty<DefaultNamespaceT
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string": {
-      const captureIdentifier = defaultNamespace ? defaultNamespace(identifier) : ${imports.dataFactory}.namedNode(identifier);
-      return ${imports.Either}.of(() => captureIdentifier);
+      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
     }
   }
 }`);

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIriLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriLiteral`, code `\
+function ${syntheticNamePrefix}convertToIriLiteral<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_convertToIriLiteral.js.map

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIriLiteralIdentifierProperty = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIriLiteralIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIriLiteralIdentifierProperty<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_convertToIriLiteralIdentifierProperty.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateFromJsonObject`, code `\
-const ${syntheticNamePrefix}dateFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
+const ${syntheticNamePrefix}dateFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
   (jsonObject) => ${snippets.literalFromJsonObject}(jsonObject).chain(${imports.LiteralDecoder}.decodeDateLiteral);`);
 //# sourceMappingURL=snippets_dateFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateFromJsonString`, code `\
-const ${syntheticNamePrefix}dateFromJsonString: ${snippets.FromJsonValueFunction}<string, Date, ${snippets.DateSchema}> = 
+const ${syntheticNamePrefix}dateFromJsonString: ${snippets.FromJsonFunction}<string, Date, ${snippets.DateSchema}> = 
   (jsonValue) => ${imports.Either}.encase(() => new Date(jsonValue));`);
 //# sourceMappingURL=snippets_dateFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateTimeFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateTimeFromJsonObject`, code `\
-const ${syntheticNamePrefix}dateTimeFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
+const ${syntheticNamePrefix}dateTimeFromJsonObject: ${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, Date, undefined> = 
   (jsonObject) => ${snippets.literalFromJsonObject}(jsonObject).chain(${imports.LiteralDecoder}.decodeDateTimeLiteral);`);
 //# sourceMappingURL=snippets_dateTimeFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateTimeToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateTimeToJsonString`, code `\
-const ${syntheticNamePrefix}dateTimeToJsonString: ${snippets.ToJsonValueFunction}<Date, string> =
+const ${syntheticNamePrefix}dateTimeToJsonString: ${snippets.ToJsonFunction}<Date, string> =
   (date) => date.toISOString();`);
 //# sourceMappingURL=snippets_dateTimeToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateToJsonObject`, code `\
-function ${syntheticNamePrefix}dateToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<Date, ${snippets.TypedLiteralJsonObject}> {
+function ${syntheticNamePrefix}dateToJsonObject(datatype: ${imports.NamedNode}): ${snippets.ToJsonFunction}<Date, ${snippets.TypedLiteralJsonObject}> {
   return (value) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.date(value, datatype));
 }`);
 //# sourceMappingURL=snippets_dateToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_dateToJsonString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}dateToJsonString`, code `\
-const ${syntheticNamePrefix}dateToJsonString: ${snippets.ToJsonValueFunction}<Date, string> =
+const ${syntheticNamePrefix}dateToJsonString: ${snippets.ToJsonFunction}<Date, string> =
   (date) => ${snippets.toIsoDateString}(date);`);
 //# sourceMappingURL=snippets_dateToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueFromJsonObject = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueFromJsonObject`, code `\
-function ${syntheticNamePrefix}defaultValueFromJsonObject<ItemJsonObjectT extends object, ItemT, ItemSchemaT>(itemFromJsonObject: ${snippets.FromJsonObjectFunction}<ItemJsonObjectT, ItemT, ItemSchemaT>): ${snippets.FromJsonObjectFunction}<ItemJsonObjectT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}defaultValueFromJsonObject<ItemJsonObjectT extends object, ItemT, ItemSchemaT>(itemFromJsonObject: ${snippets.FromJsonFunction}<ItemJsonObjectT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonObjectT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
   return (jsonObject, options) => {
     const { schema, ...otherOptions } = options;
     return itemFromJsonObject(jsonObject, { schema: schema.itemType, ...otherOptions });

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueFromJsonValue = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueFromJsonValue`, code `\
-function ${syntheticNamePrefix}defaultValueFromJsonValue<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}defaultValueFromJsonValue<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {
   return (jsonValue, options) => {
     const { schema, ...otherOptions } = options;
     return itemFromJsonValue(jsonValue, { schema: schema.itemType, ...otherOptions });

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_floatFromJsonNumber = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}floatFromJsonNumber`, code `\
-function ${syntheticNamePrefix}floatFromJsonNumber<FloatT extends number>(jsonNumber: FloatT, _options: Parameters<${snippets.FromJsonValueFunction}<FloatT, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
+function ${syntheticNamePrefix}floatFromJsonNumber<FloatT extends number>(jsonNumber: FloatT, _options: Parameters<${snippets.FromJsonFunction}<FloatT, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
   return ${imports.Either}.of(jsonNumber);
 }`);
 //# sourceMappingURL=snippets_floatFromJsonNumber.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_floatFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}floatFromJsonObject`, code `\
-function ${syntheticNamePrefix}floatFromJsonObject<FloatT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
+function ${syntheticNamePrefix}floatFromJsonObject<FloatT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, FloatT, ${snippets.NumericSchema}<FloatT>>>[1]): ${imports.Either}<Error, FloatT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeFloatLiteral)

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierFromJsonObject`, code `\
-const ${syntheticNamePrefix}identifierFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
+const ${syntheticNamePrefix}identifierFromJsonObject: ${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
   (jsonObject, options) => ${snippets.identifierFromJsonString}(jsonObject["@id"], options);`);
 //# sourceMappingURL=snippets_identifierFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierFromJsonString`, code `\
-const ${syntheticNamePrefix}identifierFromJsonString: ${snippets.FromJsonValueFunction}<string, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
+const ${syntheticNamePrefix}identifierFromJsonString: ${snippets.FromJsonFunction}<string, ${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierSchema}> = 
   (jsonString, options) => jsonString.startsWith("_:") ? ${snippets.blankNodeFromJsonString}(jsonString, options) as ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}> : ${snippets.iriFromJsonString}(jsonString, options) as ${imports.Either}<Error, ${imports.BlankNode} | ${imports.NamedNode}>;`);
 //# sourceMappingURL=snippets_identifierFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierToJsonObject`, code `\
-const ${syntheticNamePrefix}identifierToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierJsonObject}> =
+const ${syntheticNamePrefix}identifierToJsonObject: ${snippets.ToJsonFunction}<${imports.BlankNode} | ${imports.NamedNode}, ${snippets.IdentifierJsonObject}> =
   (identifier) => identifier.termType === "BlankNode" ? ${snippets.blankNodeToJsonObject}(identifier) : ${snippets.iriToJsonObject}(identifier);`);
 //# sourceMappingURL=snippets_identifierToJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_identifierToJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}identifierToJsonString`, code `\
-const ${syntheticNamePrefix}identifierToJsonString: ${snippets.ToJsonValueFunction}<${imports.BlankNode} | ${imports.NamedNode}, string> =
+const ${syntheticNamePrefix}identifierToJsonString: ${snippets.ToJsonFunction}<${imports.BlankNode} | ${imports.NamedNode}, string> =
   (identifier) => identifier.termType === "BlankNode" ? ${snippets.blankNodeToJsonString}(identifier) : ${snippets.iriToJsonString}(identifier);`);
 //# sourceMappingURL=snippets_identifierToJsonString.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_intFromJsonNumber = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}intFromJsonNumber`, code `\
-function ${syntheticNamePrefix}intFromJsonNumber<IntT extends number>(jsonNumber: IntT, _options: Parameters<${snippets.FromJsonValueFunction}<IntT, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
+function ${syntheticNamePrefix}intFromJsonNumber<IntT extends number>(jsonNumber: IntT, _options: Parameters<${snippets.FromJsonFunction}<IntT, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
   return ${imports.Either}.of(jsonNumber);
 }`);
 //# sourceMappingURL=snippets_intFromJsonNumber.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_intFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}intFromJsonObject`, code `\
-function ${syntheticNamePrefix}intFromJsonObject<IntT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TypedLiteralJsonObject}, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
+function ${syntheticNamePrefix}intFromJsonObject<IntT extends number>(jsonObject: ${snippets.TypedLiteralJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.TypedLiteralJsonObject}, IntT, ${snippets.NumericSchema}<IntT>>>[1]): ${imports.Either}<Error, IntT> {
   const { schema } = options;
   return ${snippets.literalFromJsonObject}(jsonObject)
     .chain(${imports.LiteralDecoder}.decodeIntLiteral)

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_iriFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriFromJsonObject`, code `\
-function ${syntheticNamePrefix}iriFromJsonObject<IriT extends string = string>(jsonObject: ${snippets.IdentifierJsonObject}<IriT>, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.IdentifierJsonObject}<IriT>, ${imports.NamedNode}<IriT>, ${snippets.IriSchema}<IriT>>>[1]): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+function ${syntheticNamePrefix}iriFromJsonObject(jsonObject: ${snippets.IdentifierJsonObject}, options: Parameters<${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}, ${imports.NamedNode}, ${snippets.IriSchema}>>[1]): ${imports.Either}<Error, ${imports.NamedNode}> {
   return ${snippets.iriFromJsonString}(jsonObject["@id"], options);
 }`);
 //# sourceMappingURL=snippets_iriFromJsonObject.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_iriFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriFromJsonString`, code `\
-function ${syntheticNamePrefix}iriFromJsonString<IriT extends string = string>(jsonValue: IriT, _options: Parameters<${snippets.FromJsonValueFunction}<IriT, ${imports.NamedNode}<IriT>, object>>[1]): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
-  return ${imports.Either}.of(${imports.dataFactory}.namedNode(jsonValue));
+function ${syntheticNamePrefix}iriFromJsonString(jsonString: string, options: Parameters<${snippets.FromJsonFunction}<string, ${imports.NamedNode}, object>>[1]): ${imports.Either}<Error, ${imports.NamedNode}> {
+  return ${snippets.iriFromString}(jsonString, options);
 }`);
 //# sourceMappingURL=snippets_iriFromJsonString.js.map

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

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

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

@@ -0,0 +1,76 @@
+import { code, conditionalOutput, joinCode, literalOf, } from "../ts-poet-wrapper.js";
+export const snippets_iriFromString = ({ imports, snippets, syntheticNamePrefix, }) => {
+    const leadingDoubleSlashSchemes = [
+        "file",
+        "ftp",
+        "http",
+        "https",
+        "git",
+        "irc",
+        "ldap",
+        "postgres",
+        "rtsp",
+        "sftp",
+        "smb",
+        "ssh",
+        "ws",
+        "wss",
+    ];
+    return conditionalOutput(`${syntheticNamePrefix}iriFromString`, code `\
+export function ${syntheticNamePrefix}iriFromString(
+  string: string,
+  options?: {
+    defaultNamespace?: ${snippets.NamespaceBuilder};
+    prefixMap?: ${imports.PrefixMap};
+  }
+): ${imports.Either}<Error, ${imports.NamedNode}> {
+  if (string.trim().length === 0) {
+    return ${imports.Left}(new Error("empty/blank IRI"));
+  }
+
+  const defaultNamespace = options?.defaultNamespace;
+
+  const colonIndex = string.indexOf(":");
+  if (colonIndex === -1) {
+    // No : in the string.
+    if (defaultNamespace) {
+      return ${imports.Right}(defaultNamespace(string));
+    } else {
+      return ${imports.Left}(new Error(\`ill-formed IRI: \${string}\`));
+    }
+  }
+
+  const prefix = string.substring(0, colonIndex);
+  const path = string.substring(colonIndex + 1);
+  if (path.length === 0) {
+    return ${imports.Left}(new Error(\`ill-formed IRI: \${string}\`));
+  }
+
+  // Absolute IRIs with scheme:// always win over prefixes with the same name.
+  switch (prefix.toLowerCase()) {
+${joinCode(leadingDoubleSlashSchemes.map((scheme) => code `    case ${literalOf(scheme)}:`, { on: "\n" }))}
+    if (path.startsWith("//")) {
+      return ${imports.Right}(${imports.dataFactory}.namedNode(string));
+    }
+    break;
+  }
+
+  const prefixMap = options?.prefixMap;
+  if (prefixMap) {
+    const prefixNamespace = prefixMap.get(prefix);
+    if (prefixNamespace !== undefined) {
+      return ${imports.Right}(
+        ${imports.dataFactory}.namedNode(\`\${prefixNamespace.value}\${path}\`),
+      );
+    }
+  }
+
+  if (prefix.length === 0 && defaultNamespace) {
+    // a "" prefixMap entry takes precedence, above.
+    return ${imports.Right}(defaultNamespace(path));
+  }
+
+  return ${imports.Right}(${imports.dataFactory}.namedNode(string));
+}`);
+};
+//# sourceMappingURL=snippets_iriFromString.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriLiteralFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriLiteralFromJsonObject`, code `\
+function ${syntheticNamePrefix}iriLiteralFromJsonObject<IriT extends string>(jsonObject: ${snippets.IdentifierJsonObject}<IriT>, options: Parameters<${snippets.FromJsonFunction}<${snippets.IdentifierJsonObject}<IriT>, ${imports.NamedNode}<IriT>, ${snippets.IriSchema}<IriT>>>[1]): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+  return ${snippets.iriLiteralFromJsonString}(jsonObject["@id"], options);
+}`);
+//# sourceMappingURL=snippets_iriLiteralFromJsonObject.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriLiteralFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriLiteralFromJsonString`, code `\
+function ${syntheticNamePrefix}iriLiteralFromJsonString<IriT extends string>(jsonString: IriT, _options: Parameters<${snippets.FromJsonFunction}<IriT, ${imports.NamedNode}<IriT>, object>>[1]): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+  return ${imports.Right}(${imports.dataFactory}.namedNode(jsonString));
+}`);
+//# sourceMappingURL=snippets_iriLiteralFromJsonString.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_langStringFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}langStringFromJsonObject`, code `\
-const ${syntheticNamePrefix}langStringFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.LangStringJsonObject}, ${imports.Literal}, ${snippets.LangStringSchema}> = 
+const ${syntheticNamePrefix}langStringFromJsonObject: ${snippets.FromJsonFunction}<${snippets.LangStringJsonObject}, ${imports.Literal}, ${snippets.LangStringSchema}> = 
   (jsonObject) => ${imports.Either}.of<Error, ${imports.Literal}>(${imports.dataFactory}.literal(jsonObject["@value"], jsonObject["@language"]))`);
 //# sourceMappingURL=snippets_langStringFromJsonObject.js.map

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

@@ -1,5 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_langStringToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}langStringToJsonObject`, code `\
-const ${syntheticNamePrefix}langStringToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.Literal}, ${snippets.LangStringJsonObject}> =
+const ${syntheticNamePrefix}langStringToJsonObject: ${snippets.ToJsonFunction}<${imports.Literal}, ${snippets.LangStringJsonObject}> =
   (literal) => ({ "@language": literal.language, "@value": literal.value });`);
 //# sourceMappingURL=snippets_langStringToJsonObject.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_listFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listFromJsonObject`, code `\
-function ${syntheticNamePrefix}listFromJsonObject<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonObjectFunction}<{ "@list": ItemJsonValueT[] }, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
+function ${syntheticNamePrefix}listFromJsonObject<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonFunction}<{ "@list": ItemJsonValueT[] }, ItemT[], ${snippets.CollectionSchema}<ItemSchemaT>> {
   return (jsonObject, options) => {
     const { schema, ...otherOptions } = options;
     const itemFromJsonValueOptions = { schema: schema.itemType, ...otherOptions };