@shaclmate/compiler 4.0.93 → 4.0.95

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

@@ -0,0 +1,9 @@
+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> {
+  const { schema } = options;
+  return ${snippets.literalFromJsonObject}(jsonObject)
+    .chain(${imports.LiteralDecoder}.decodeIntLiteral)
+    .chain(value => ${snippets.constrainPrimitive}<IntT, number>(value, schema.in)) as ${imports.Either}<Error, IntT>;
+}`);
+//# sourceMappingURL=snippets_intFromJsonObject.js.map

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

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

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

@@ -0,0 +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>> {
+  return ${snippets.iriFromJsonString}(jsonObject["@id"], options);
+}`);
+//# sourceMappingURL=snippets_iriFromJsonObject.js.map

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

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

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

@@ -0,0 +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));
+}`);
+//# sourceMappingURL=snippets_iriFromJsonString.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriToJsonObject`, code `\
+function ${syntheticNamePrefix}iriToJsonObject<IriT extends string = string>(iri: ${imports.NamedNode}<IriT>): ${snippets.IdentifierJsonObject}<IriT> {
+  return { "@id": ${snippets.iriToJsonString}(iri) };
+}`);
+//# sourceMappingURL=snippets_iriToJsonObject.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_iriToJsonString = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriToJsonString`, code `\
+function ${syntheticNamePrefix}iriToJsonString<IriT extends string = string>(iri: ${imports.NamedNode}<IriT>): IriT {
+  return iri.value;
+}`);
+//# sourceMappingURL=snippets_iriToJsonString.js.map

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

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

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

@@ -0,0 +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}> = 
+  (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_langStringFromRdfResourceValues.js

@@ -1,6 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_langStringFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}langStringFromRdfResourceValues`, code `\
-function ${syntheticNamePrefix}langStringFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LangStringSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.Literal}>> {
-  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLangString(options.schema.in)));
-}`);
+const ${syntheticNamePrefix}langStringFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LangStringSchema}> =
+  (values, options) => ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLangString(options.schema.in)));`);
 //# sourceMappingURL=snippets_langStringFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +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}> =
+  (literal) => ({ "@language": literal.language, "@value": literal.value });`);
+//# sourceMappingURL=snippets_langStringToJsonObject.js.map

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

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

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

@@ -0,0 +1,10 @@
+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>> {
+  return (jsonObject, options) => {
+    const { schema, ...otherOptions } = options;
+    const itemFromJsonValueOptions = { schema: schema.itemType, ...otherOptions };
+    return ${imports.Either}.sequence(jsonObject["@list"].map(itemJsonValue => itemFromJsonValue(itemJsonValue, itemFromJsonValueOptions)));
+  }
+}`);
+//# sourceMappingURL=snippets_listFromJsonObject.js.map

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

@@ -1,5 +1,6 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_listSparqlConstructTriples = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
+export const snippets_listSparqlConstructTriples = ({ imports, rdfjsTermExpression, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}listSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets.ValueSparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlConstructTriplesFunction}<${snippets.CollectionFilter}<ItemFilterT>, ${snippets.CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, valueVariable: listVariable, variablePrefix: variablePrefixPrefix }) => {
     let triples: ${imports.sparqljs}.Triple[] = [];
@@ -9,13 +10,13 @@ function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchem
     {
       // ?list rdf:first ?item0
       const item0Variable = variable("Item0");
-      triples.push({ subject: listVariable, predicate: ${snippets.RdfVocabularies}.rdf.first, object: item0Variable });
+      triples.push({ subject: listVariable, predicate: ${rdfjsTermExpression(rdf.first)}, object: item0Variable });
       triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.itemType, valueVariable: item0Variable, variablePrefix: variablePrefix("Item0") }));
     }
 
     {
       // ?list rdf:rest ?rest0
-      triples.push({ subject: listVariable, predicate: ${snippets.RdfVocabularies}.rdf.rest, object: variable("Rest0") });
+      triples.push({ subject: listVariable, predicate: ${rdfjsTermExpression(rdf.rest)}, object: variable("Rest0") });
     }
 
     // Don't do ?list rdf:rest+ ?restN in CONSTRUCT
@@ -24,12 +25,12 @@ function ${syntheticNamePrefix}listSparqlConstructTriples<ItemFilterT, ItemSchem
     {
       // ?rest rdf:first ?itemN
       const itemNVariable = variable("ItemN");
-      triples.push({ subject: restNVariable, predicate: ${snippets.RdfVocabularies}.rdf.first, object: itemNVariable });
+      triples.push({ subject: restNVariable, predicate: ${rdfjsTermExpression(rdf.first)}, object: itemNVariable });
       triples = triples.concat(itemSparqlConstructTriplesFunction({ filter, ignoreRdfType: false, schema: schema.itemType, valueVariable: itemNVariable, variablePrefix: variablePrefix("ItemN") }));
     }
 
     // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
-    triples.push({ subject: restNVariable, predicate: ${snippets.RdfVocabularies}.rdf.rest, object: variable("RestNBasic") });
+    triples.push({ subject: restNVariable, predicate: ${rdfjsTermExpression(rdf.rest)}, object: variable("RestNBasic") });
 
     return triples;
   }

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalFromJsonObject`, code `\
+const ${syntheticNamePrefix}literalFromJsonObject: ${snippets.FromJsonObjectFunction}<${snippets.LiteralJsonObject}, ${imports.Literal}, undefined> = 
+  (jsonObject) => ${imports.Right}(
+    ${imports.dataFactory}.literal(
+      jsonObject["@value"],
+      jsonObject["@language"] !== undefined
+        ? jsonObject["@language"]
+        : (
+            jsonObject["@type"] !== undefined
+            ? ${imports.dataFactory}.namedNode(jsonObject["@type"]!)
+            : undefined
+          )
+    )
+  );`);
+//# sourceMappingURL=snippets_literalFromJsonObject.js.map

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

@@ -1,6 +1,5 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_literalFromRdfResourceValues = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalFromRdfResourceValues`, code `\
-function ${syntheticNamePrefix}literalFromRdfResourceValues(values: ${imports.Resource}.Values, options: Parameters<${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LiteralSchema}>>[1]): ${imports.Either}<Error, ${imports.Resource}.Values<${imports.Literal}>> {
-  return ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLiteral(options.schema.in)));
-}`);
+const ${syntheticNamePrefix}literalFromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${imports.Literal}, ${snippets.LiteralSchema}> =
+  (values, options) => ${snippets.termLikeFromRdfResourceValues}(values, options).chain(values => values.chainMap(value => value.toLiteral(options.schema.in)));`);
 //# sourceMappingURL=snippets_literalFromRdfResourceValues.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_literalToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}literalToJsonObject`, code `\
+const ${syntheticNamePrefix}literalToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.Literal}, ${snippets.LiteralJsonObject}> =
+  (literal) => {
+    const jsonObject: ${snippets.LiteralJsonObject} = { "@value": literal.value };
+    if (literal.language.length > 0) {
+      jsonObject["@language"] = literal.language;
+    }
+    if (literal.datatype.value !== "${xsd.string.value}") {
+      jsonObject["@type"] = literal.datatype.value;
+    }
+    return jsonObject;
+  }`);
+//# sourceMappingURL=snippets_literalToJsonObject.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeFromJsonObject`, code `\
+function ${syntheticNamePrefix}maybeFromJsonObject<ItemJsonObjectT extends object, ItemT, ItemSchemaT>(itemFromJsonObject: ${snippets.FromJsonObjectFunction}<ItemJsonObjectT, ItemT, ItemSchemaT>): ${snippets.FromJsonObjectFunction}<ItemJsonObjectT | undefined, ${imports.Maybe}<ItemT>, ${snippets.MaybeSchema}<ItemSchemaT>> {
+  return (value, options) => {
+    if (value === undefined) {
+      return ${imports.Either}.of(${imports.Maybe}.empty());
+    }
+    const { schema, ...otherOptions } = options;
+    return itemFromJsonObject(value, { schema: schema.itemType, ...otherOptions }).map(value => ${imports.Maybe}.of(value));
+  };
+}`);
+//# sourceMappingURL=snippets_maybeFromJsonObject.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeFromJsonValue = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeFromJsonValue`, code `\
+function ${syntheticNamePrefix}maybeFromJsonValue<ItemJsonValueT, ItemT, ItemSchemaT>(itemFromJsonValue: ${snippets.FromJsonValueFunction}<ItemJsonValueT, ItemT, ItemSchemaT>): ${snippets.FromJsonValueFunction}<ItemJsonValueT | undefined, ${imports.Maybe}<ItemT>, ${snippets.MaybeSchema}<ItemSchemaT>> {
+  return (value, options) => {
+    if (value === undefined) {
+      return ${imports.Either}.of(${imports.Maybe}.empty());
+    }
+    const { schema, ...otherOptions } = options;
+    return itemFromJsonValue(value, { schema: schema.itemType, ...otherOptions }).map(value => ${imports.Maybe}.of(value));
+  };
+}`);
+//# sourceMappingURL=snippets_maybeFromJsonValue.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeToJsonObject`, code `\
+function ${syntheticNamePrefix}maybeToJsonObject<ItemT, ItemJsonObjectT extends object>(itemToJsonObject: ${snippets.ToJsonObjectFunction}<ItemT, ItemJsonObjectT>): ${snippets.ToJsonObjectFunction}<${imports.Maybe}<ItemT>, ItemJsonObjectT | undefined> {
+  return (value) => value.map(value => itemToJsonObject(value)).extract();
+}`);
+//# sourceMappingURL=snippets_maybeToJsonObject.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_maybeToJsonValue = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}maybeToJsonValue`, code `\
+function ${syntheticNamePrefix}maybeToJsonValue<ItemT, ItemJsonValueT>(itemToJsonValue: ${snippets.ToJsonValueFunction}<ItemT, ItemJsonValueT>): ${snippets.ToJsonValueFunction}<${imports.Maybe}<ItemT>, ItemJsonValueT | undefined> {
+  return (value) => value.map(value => itemToJsonValue(value)).extract();
+}`);
+//# sourceMappingURL=snippets_maybeToJsonValue.js.map

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

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

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

@@ -0,0 +1,3 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_missingResolver = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}missingResolver`, code `async function ${syntheticNamePrefix}missingResolver<ResolvedT>(): Promise<${imports.Either}<Error, ResolvedT>> { return ${imports.Left}(new Error("unable to resolve partial")); }`);
+//# sourceMappingURL=snippets_missingResolver.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_primitiveToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}primitiveToJsonObject`, code `\
+function ${syntheticNamePrefix}primitiveToJsonObject<PrimitiveT extends boolean | number | string>(datatype: ${imports.NamedNode}): ${snippets.ToJsonObjectFunction}<PrimitiveT, ${snippets.TypedLiteralJsonObject}> {
+  return (primitive) => ${snippets.typedLiteralToJsonObject}(${snippets.literalFactory}.primitive(primitive, datatype));
+}`);
+//# sourceMappingURL=snippets_primitiveToJsonObject.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_primitiveToJsonValue = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}primitiveToJsonValue`, code `\
+function ${syntheticNamePrefix}primitiveToJsonValue<PrimitiveT extends boolean | number | string>(primitive: PrimitiveT): PrimitiveT {
+  return primitive;
+}`);
+//# sourceMappingURL=snippets_primitiveToJsonValue.js.map

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

@@ -1,5 +1,6 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_sparqlInstancesOfPattern = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlInstancesOfPattern`, code `\
+export const snippets_sparqlInstancesOfPattern = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sparqlInstancesOfPattern`, code `\
 /**
  * A sparqljs.Pattern that's the equivalent of ?subject rdf:type/rdfs:subClassOf* ?rdfType .
  */
@@ -10,9 +11,9 @@ function ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType, subject }: {
         subject,
         predicate: {
           items: [
-            ${snippets.RdfVocabularies}.rdf.type,
+            ${rdfjsTermExpression(rdf.type)},
             {
-              items: [${snippets.RdfVocabularies}.rdfs.subClassOf],
+              items: [${rdfjsTermExpression(rdfs.subClassOf)}],
               pathType: "*",
               type: "path",
             },

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

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

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

@@ -0,0 +1,9 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_stringFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringFromJsonObject`, code `\
+function ${syntheticNamePrefix}stringFromJsonObject<StringT extends string>(jsonObject: ${snippets.LiteralJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.LiteralJsonObject}, StringT, ${snippets.StringSchema}<StringT>>>[1]): ${imports.Either}<Error, StringT> {
+  const { schema } = options;
+  return ${snippets.literalFromJsonObject}(jsonObject)
+    .chain(${imports.LiteralDecoder}.decodeStringLiteral)
+    .chain(value => ${snippets.constrainPrimitive}<StringT, string>(value, schema.in)) as ${imports.Either}<Error, StringT>;
+}`);
+//# sourceMappingURL=snippets_stringFromJsonObject.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_stringFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}stringFromJsonString`, code `\
+function ${syntheticNamePrefix}stringFromJsonString<StringT extends string>(jsonString: StringT, _options: Parameters<${snippets.FromJsonValueFunction}<StringT, StringT, ${snippets.StringSchema}<StringT>>>[1]): ${imports.Either}<Error, StringT> {
+  return ${imports.Either}.of(jsonString);
+}`);
+//# sourceMappingURL=snippets_stringFromJsonString.js.map

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

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

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

@@ -0,0 +1,31 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_termFromJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termFromJsonObject`, code `\
+function ${syntheticNamePrefix}termFromJsonObject<TermT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(jsonObject: ${snippets.TermJsonObject}, options: Parameters<${snippets.FromJsonObjectFunction}<${snippets.TermJsonObject}, TermT, ${snippets.TermSchema}<TermT>>>[1]): ${imports.Either}<Error, TermT> {
+  const { schema } = options;
+
+  for (const termType of schema.types) {
+    switch (termType) {
+      case "BlankNode": {
+        if ("@id" in jsonObject && jsonObject["@id"].startsWith("_:")) {
+          return ${snippets.blankNodeFromJsonObject}(jsonObject) as ${imports.Either}<Error, TermT>;
+        }
+        break;
+      }
+      case "Literal": {
+        if ("@value" in jsonObject) {
+          return ${snippets.literalFromJsonObject}(jsonObject) as ${imports.Either}<Error, TermT>;
+        }
+        break;
+      }
+      case "NamedNode": {
+        if ("@id" in jsonObject && !jsonObject["@id"].startsWith("_:")) {
+          return ${snippets.iriFromJsonObject}(jsonObject, { ...options, schema: { kind: "Iri" } }) as ${imports.Either}<Error, TermT>;
+        }
+        break;
+      }
+    }
+  }
+
+  return ${imports.Left}(new Error("unable to deserialize term from JSON"));
+}`);
+//# sourceMappingURL=snippets_termFromJsonObject.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_termToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}termToJsonObject`, code `\
+const ${syntheticNamePrefix}termToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}, ${snippets.TermJsonObject}> =
+  (term) => {
+    switch (term.termType) {
+      case "BlankNode":
+        return ${snippets.blankNodeToJsonObject}(term);
+      case "NamedNode":
+        return ${snippets.iriToJsonObject}(term);
+      case "Literal":
+        return ${snippets.literalToJsonObject}(term);
+    }
+  };`);
+//# sourceMappingURL=snippets_termToJsonObject.js.map

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

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

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

@@ -0,0 +1,5 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_typedLiteralToJsonObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}typedLiteralToJsonObject`, code `\
+const ${syntheticNamePrefix}typedLiteralToJsonObject: ${snippets.ToJsonObjectFunction}<${imports.Literal}, ${snippets.TypedLiteralJsonObject}> =
+  (literal) => ({ "@type": literal.datatype.value, "@value": literal.value });`);
+//# sourceMappingURL=snippets_typedLiteralToJsonObject.js.map

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

@@ -1,14 +1,34 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}wrap_ToRdfResourceFunction`, code `\
-function ${syntheticNamePrefix}wrap_ToRdfResourceFunction<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends { ${syntheticNamePrefix}identifier: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<ObjectT, IdentifierT> {
+export const snippets_wrap_ToRdfResourceFunction = ({ imports, snippets, syntheticNamePrefix, }) => {
+    const functionName = `${syntheticNamePrefix}wrap_ToRdfResourceFunction`;
+    const identifierPropertyName = `${syntheticNamePrefix}identifier`;
+    return conditionalOutput(functionName, code `\
+function ${functionName}<
+  IdentifierT extends ${imports.Resource}.Identifier,
+  ObjectT extends { ${identifierPropertyName}: () => IdentifierT },
+>(
+  _toRdfResourceFunction: ${syntheticNamePrefix}_ToRdfResourceFunction<IdentifierT, ObjectT>,
+): ${syntheticNamePrefix}ToRdfResourceFunction<IdentifierT, ObjectT>;
+function ${functionName}<
+  _IdentifierT extends ${imports.BlankNode},
+  ObjectT extends object,
+>(
+  _toRdfResourceFunction: ${syntheticNamePrefix}_ToRdfResourceFunction<${imports.BlankNode}, ObjectT>,
+): ${syntheticNamePrefix}ToRdfResourceFunction<${imports.BlankNode}, ObjectT>;
+function ${functionName}<IdentifierT extends ${imports.Resource}.Identifier, ObjectT extends object & { ${identifierPropertyName}?: () => IdentifierT }>(_toRdfResourceFunction: ${snippets._ToRdfResourceFunction}<IdentifierT, ObjectT>): ${snippets.ToRdfResourceFunction}<IdentifierT, ObjectT> {
   return (object, options) => {
     let { graph, ignoreRdfType = false, resourceSet } = (options ?? {});
     if (!resourceSet) {
       resourceSet = new ${imports.ResourceSet}({ dataFactory: ${imports.dataFactory}, dataset: ${imports.datasetFactory}.dataset() });
     }
-    const resource = resourceSet.resource(object.${syntheticNamePrefix}identifier());
+    const resource = (
+      object.${identifierPropertyName}
+        ? resourceSet.resource(object.${identifierPropertyName}())
+        : resourceSet.resource(${imports.dataFactory}.blankNode())
+    ) as ${imports.Resource}<IdentifierT>;
     _toRdfResourceFunction({ graph, ignoreRdfType, object, resource, resourceSet });
     return resource;
   };
 }`);
+};
 //# sourceMappingURL=snippets_wrap_ToRdfResourceFunction.js.map

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

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

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

@@ -0,0 +1,16 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_zValidator = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}zValidator`, code `\
+const ${syntheticNamePrefix}zValidator = <
+  T extends ${imports.ZodType},
+  Target extends keyof ${imports.HonoValidationTargets},
+>(
+  target: Target,
+  schema: T,
+) =>
+  ${imports.honoZodValidator}(target, schema, (result, c) => {
+    if (!result.success) {
+      return c.json({ ...${snippets.errorToProblemDetailsJson}(result.error), status: 400, title: "Request validation error" }, 400, { "Content-Type": "application/problem+json" });
+    }
+    return undefined;
+  });`);
+//# sourceMappingURL=snippets_zValidator.js.map

package/dist/generators/ts/rdfjsTermExpression.d.ts

@@ -7,5 +7,5 @@ export declare function rdfjsTermExpression(this: {
     imports: Imports;
     logger: Logger;
     snippets: Snippets;
-}, rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): Code;
+}, rdfjsTerm: BlankNode | Literal | NamedNode | Variable): Code;
 //# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/dist/generators/ts/rdfjsTermExpression.js

@@ -1,4 +1,4 @@
-import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
+import { xsd } from "@tpluscode/rdf-ns-builders";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export function rdfjsTermExpression(rdfjsTerm) {
     switch (rdfjsTerm.termType) {
@@ -13,59 +13,10 @@ export function rdfjsTermExpression(rdfjsTerm) {
             }
             return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression.call(this, rdfjsTerm.datatype)})`;
         case "NamedNode": {
-            if (rdfjsTerm.value.startsWith(rdf[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
-                switch (unqualifiedName) {
-                    case "first":
-                    case "langString":
-                    case "nil":
-                    case "rest":
-                    case "subject":
-                    case "type":
-                        return code `${this.snippets.RdfVocabularies}.rdf.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
-                }
-            }
-            else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
-                switch (unqualifiedName) {
-                    case "subClassOf":
-                        return code `${this.snippets.RdfVocabularies}.rdfs.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
-                }
-            }
-            else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
-                const unqualifiedName = rdfjsTerm.value.substring(xsd[""].value.length);
-                switch (unqualifiedName) {
-                    case "boolean":
-                    case "byte":
-                    case "float":
-                    case "date":
-                    case "dateTime":
-                    case "dateTimeStamp":
-                    case "decimal":
-                    case "double":
-                    case "int":
-                    case "integer":
-                    case "long":
-                    case "negativeInteger":
-                    case "nonNegativeInteger":
-                    case "nonPositiveInteger":
-                    case "positiveInteger":
-                    case "short":
-                    case "string":
-                    case "unsignedByte":
-                    case "unsignedInt":
-                    case "unsignedLong":
-                    case "unsignedShort":
-                        return code `${this.snippets.RdfVocabularies}.xsd.${unqualifiedName}`;
-                    default:
-                        this.logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
-                }
-            }
-            return code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
+            return this.snippets
+                .rdfjsNamedNode(rdfjsTerm)
+                .map((snippet) => code `${snippet}`)
+                .orDefault(code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`);
         }
         case "Variable":
             return code `${this.imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;