@shaclmate/compiler 4.0.32 → 4.0.34

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

@@ -0,0 +1,31 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLazyObjectOption = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectOption`, code `\
+function ${syntheticNamePrefix}convertToLazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
+  return (_schema: unknown, value: ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ${imports.Maybe}<ResolvedObjectT> | ResolvedObjectT | undefined): ${imports.Either}<Error, ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+    switch (typeof value) {
+      case "object": {
+        if (value instanceof ${snippets.LazyObjectOption}) {
+          return ${imports.Either}.of(value);
+        }
+
+        if (${imports.Maybe}.isMaybe(value)) {
+          return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
+            partial: value.map(resolvedToPartial),
+            resolver: async () => ${imports.Right}(value.unsafeCoerce())
+          }));
+        }
+
+        return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
+          partial: ${imports.Maybe}.of(resolvedToPartial(value)),
+          resolver: async () => ${imports.Right}(value)
+        }));
+      }
+      case "undefined":
+        return ${imports.Either}.of(new ${snippets.LazyObjectOption}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
+          partial: ${imports.Maybe}.empty(),
+          resolver: async () => { throw new Error("should never be called"); }
+        }));
+    }
+  };
+}`);
+//# sourceMappingURL=snippets_convertToLazyObjectOption.js.map

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

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

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

@@ -0,0 +1,25 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToLazyObjectSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObjectSet`, code `\
+function ${syntheticNamePrefix}convertToLazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }>(resolvedToPartial: (resolved: ResolvedObjectT) => PartialObjectT) {
+  return (_schema: unknown, value: ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | readonly ResolvedObjectT[] | undefined): ${imports.Either}<Error, ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+    switch (typeof value) {
+      case "object": {
+        if (value instanceof ${snippets.LazyObjectSet}) {
+          return ${imports.Either}.of(value);
+        }
+
+        const captureValue = value;
+        return ${imports.Either}.of(new ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
+          partials: value.map(resolvedToPartial),
+          resolver: async () => ${imports.Right}(captureValue)
+        }));
+      }
+      case "undefined":
+        return ${imports.Either}.of(new ${snippets.LazyObjectSet}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>({
+          partials: [],
+          resolver: async () => ${imports.Right}([])
+        }));
+    }
+  };
+}`);
+//# sourceMappingURL=snippets_convertToLazyObjectSet.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMaybe`, code `\
+function ${syntheticNamePrefix}convertToMaybe<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
+  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, value: ItemSourceT | ${imports.Maybe}<ItemTargetT> | undefined): ${imports.Either}<Error, ${imports.Maybe}<ItemTargetT>> => {
+    switch (typeof value) {
+      case "object": {
+        if (${imports.Maybe}.isMaybe(value)) {
+          return ${imports.Either}.of(value as ${imports.Maybe}<ItemTargetT>);
+        }
+        break;
+      }
+      case "undefined":
+        return ${imports.Either}.of(${imports.Maybe}.empty());
+    }
+
+    return convertToItem(schema.item(), value).map(${imports.Maybe}.of);
+  }
+}`);
+//# sourceMappingURL=snippets_convertToMaybe.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToMutableArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToMutableArray`, code `\
+function ${syntheticNamePrefix}convertToMutableArray<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
+  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetT[]> => {
+    return (typeof value === "undefined" ? ${imports.Either}.of<Error, ItemTargetT[]>([]) : ${imports.Either}.sequence(value.map(item => convertToItem(schema.item(), item))))
+      .chain(array => {
+        if (schema.minCount !== undefined && array.length < schema.minCount) {
+          return ${imports.Left}(new Error(\`array has length (\${array.length}) less than minCount (\${schema.minCount})\`));
+        }
+        return ${imports.Either}.of(array);
+      });
+  }
+}`);
+//# sourceMappingURL=snippets_convertToMutableArray.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToNumeric = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToNumeric`, code `\
+function ${syntheticNamePrefix}convertToNumeric<ValueT extends bigint | number>(_schema: ${snippets.NumericSchema}<ValueT>, value: ValueT): ${imports.Either}<Error, ValueT> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToNumeric.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToObject = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToObject`, code `\
+function ${syntheticNamePrefix}convertToObject<ValueT extends object>(_schema: unknown, value: ValueT): ${imports.Either}<Error, ValueT> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToObject.js.map

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

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

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

@@ -0,0 +1,14 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToReadonlyArray = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToReadonlyArray`, code `\
+function ${syntheticNamePrefix}convertToReadonlyArray<ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
+  return (schema: ${snippets.CollectionSchema}<ItemSchemaT>, value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, readonly ItemTargetT[]> => {
+    return (typeof value === "undefined" ? ${imports.Either}.of<Error, readonly ItemTargetT[]>([]) : ${imports.Either}.sequence(value.map(item => convertToItem(schema.item(), item))))
+      .chain(array => {
+        if (schema.minCount !== undefined && array.length < schema.minCount) {
+          return ${imports.Left}(new Error(\`array has length (\${array.length}) less than minCount (\${schema.minCount})\`));
+        }
+        return ${imports.Either}.of(array);
+      });
+  }
+}`);
+//# sourceMappingURL=snippets_convertToReadonlyArray.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToString`, code `\
+function ${syntheticNamePrefix}convertToString<ValueT extends string>(_schema: ${snippets.StringSchema}, value: ValueT): ${imports.Either}<Error, ValueT> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToString.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToTerm = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToTerm`, code `\
+function ${syntheticNamePrefix}convertToTerm<ValueT extends ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>(_schema: ${snippets.TermSchema}, value: ValueT): ${imports.Either}<Error, ValueT> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToTerm.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToUnion = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToUnion`, code `\
+function ${syntheticNamePrefix}convertToUnion<ValueT>(_schema: unknown, value: ValueT): ${imports.Either}<Error, ValueT> {
+  return ${imports.Either}.of(value);
+}`);
+//# sourceMappingURL=snippets_convertToUnion.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertWithDefaultValue = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertWithDefaultValue`, code `\
+function ${syntheticNamePrefix}convertWithDefaultValue<DefaultValueT extends ItemSourceT, ItemSchemaT, ItemSourceT, ItemTargetT>(convertToItem: (schema: ItemSchemaT, value: ItemSourceT) => ${imports.Either}<Error, ItemTargetT>) {
+  return (schema: ${snippets.DefaultValueSchema}<DefaultValueT, ItemSchemaT>, value: ItemSourceT | undefined): ${imports.Either}<Error, ItemTargetT> => {
+    if (typeof value === "undefined") {
+      return convertToItem(schema.item(), schema.defaultValue);
+    }
+    return convertToItem(schema.item(), value);
+  }
+}`);
+//# sourceMappingURL=snippets_convertWithDefaultValue.js.map

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_defaultValueSparqlWherePatterns = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}defaultValueSparqlWherePatterns`, code `\
-function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets.DefaultValueSchema}<ItemSchemaT>> {  
+function ${syntheticNamePrefix}defaultValueSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets.ValueSparqlWherePatternsFunction}<ItemFilterT, ${snippets.DefaultValueSchema}<unknown, ItemSchemaT>> {  
   return ({ schema, ...otherParameters }) => {
     const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets.liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, schema: schema.item() }));
     return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashArray = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashArray`, code `\
+function ${syntheticNamePrefix}hashArray<HasherT extends ${snippets.Hasher}, ItemT>(hashItem: ${snippets.HashFunction}<HasherT, ItemT>): ${snippets.HashFunction}<HasherT, readonly ItemT[]> {
+  return (hasher, value) => {
+    for (const item of value) {
+      hashItem(hasher, item);
+    }
+    return hasher;
+  }
+}`);
+//# sourceMappingURL=snippets_hashArray.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashBigDecimal = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashBigDecimal`, code `\
+function ${syntheticNamePrefix}hashBigDecimal<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: ${imports.BigDecimal}): HasherT {
+  hasher.update(value.toFixed());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashBigDecimal.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashBoolean = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashBoolean`, code `\
+function ${syntheticNamePrefix}hashBoolean<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: boolean): HasherT {
+  hasher.update(value.toString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashBoolean.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashDate = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashDate`, code `\
+function ${syntheticNamePrefix}hashDate<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: Date): HasherT {
+  hasher.update(${snippets.toIsoDateString}(value));
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashDate.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashDateTime = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashDateTime`, code `\
+function ${syntheticNamePrefix}hashDateTime<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: Date): HasherT {
+  hasher.update(value.toISOString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashDateTime.js.map

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

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

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

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashMaybe`, code `\
+function ${syntheticNamePrefix}hashMaybe<HasherT extends ${snippets.Hasher}, ItemT>(hashItem: ${snippets.HashFunction}<HasherT, ItemT>): ${snippets.HashFunction}<HasherT, ${imports.Maybe}<ItemT>> {
+  return (hasher, value) => {
+    value.ifJust(value => {
+      hashItem(hasher, value);
+    });
+    return hasher;
+  }
+}`);
+//# sourceMappingURL=snippets_hashMaybe.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashNumeric = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashNumeric`, code `\
+function ${syntheticNamePrefix}hashNumeric<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: bigint | number): HasherT {
+  hasher.update(value.toString());
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashNumeric.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashString = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashString`, code `\
+function ${syntheticNamePrefix}hashString<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: string): HasherT {
+  hasher.update(value);
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashString.js.map

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

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

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

@@ -0,0 +1,12 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_hashTerm = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}hashTerm`, code `\
+function ${syntheticNamePrefix}hashTerm<HasherT extends ${snippets.Hasher}>(hasher: HasherT, value: ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}): HasherT {
+  hasher.update(value.termType);
+  hasher.update(value.value);
+  if (value.termType === "Literal") {
+    hasher.update(value.datatype.value);
+    hasher.update(value.language);
+  }
+  return hasher;
+}`);
+//# sourceMappingURL=snippets_hashTerm.js.map

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

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

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

@@ -0,0 +1,6 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_toIsoDateString = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}toIsoDateString`, code `\
+export function ${syntheticNamePrefix}toIsoDateString(date: Date): string {
+  return date.toISOString().replace(/T.*$/, '')
+}`);
+//# sourceMappingURL=snippets_toIsoDateString.js.map

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -3,7 +3,7 @@ import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function graphqlSchemaVariableStatement(this: TsGenerator, parameters: {
+export declare function graphqlSchemaVariableStatement(this: TsGenerator, { namedObjectTypes, namedObjectUnionTypes, }: {
     namedObjectTypes: readonly NamedObjectType[];
     namedObjectUnionTypes: NamedObjectUnionType[];
 }): Maybe<Code>;

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 function graphqlQueryObjectType({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `new ${this.reusables.imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
         ...namedObjectTypes,
         ...namedObjectUnionTypes,
@@ -68,12 +68,15 @@ async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${nam
         return fields;
     }, {})} })`;
 }
-export function graphqlSchemaVariableStatement(parameters) {
-    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => namedObjectType.features.has("graphql") && !namedObjectType.synthetic);
-    const namedObjectUnionTypes = parameters.namedObjectUnionTypes.filter((namedObjectUnionType) => namedObjectUnionType.features.has("graphql"));
+export function graphqlSchemaVariableStatement({ namedObjectTypes, namedObjectUnionTypes, }) {
+    if (!this.configuration.features.has("graphql")) {
+        return Maybe.empty();
+    }
+    namedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.synthetic);
     if (namedObjectTypes.length === 0) {
         return Maybe.empty();
     }
+    namedObjectUnionTypes = namedObjectUnionTypes.filter((namedObjectUnionType) => !namedObjectUnionType.synthetic);
     return Maybe.of(code `\
 export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query: ${graphqlQueryObjectType.call(this, { namedObjectTypes: namedObjectTypes, namedObjectUnionTypes })} });
 `);

package/dist/generators/ts/objectSetDeclarations.js

@@ -3,38 +3,8 @@ import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetCl
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
 export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
     const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
-    let namedObjectTypesWithRdfFeatureCount = 0;
-    let namedObjectTypesWithSparqlFeatureCount = 0;
-    for (const namedObjectType of namedObjectTypes) {
-        if (!namedObjectType.features.has("rdf") &&
-            !namedObjectType.features.has("sparql")) {
-            continue;
-        }
-        if (namedObjectType.features.has("rdf")) {
-            namedObjectTypesWithRdfFeatureCount++;
-        }
-        if (namedObjectType.features.has("sparql")) {
-            namedObjectTypesWithSparqlFeatureCount++;
-        }
-    }
-    let namedObjectUnionTypesWithRdfFeatureCount = 0;
-    let namedObjectUnionTypesWithSparqlFeatureCount = 0;
-    for (const namedObjectUnionType of namedObjectUnionTypes) {
-        if (!namedObjectUnionType.features.has("rdf") &&
-            !namedObjectUnionType.features.has("sparql")) {
-            continue;
-        }
-        if (namedObjectUnionType.features.has("rdf")) {
-            namedObjectUnionTypesWithRdfFeatureCount++;
-        }
-        if (namedObjectUnionType.features.has("sparql")) {
-            namedObjectUnionTypesWithSparqlFeatureCount++;
-        }
-    }
-    if (namedObjectTypesWithRdfFeatureCount === 0 &&
-        namedObjectTypesWithSparqlFeatureCount === 0 &&
-        namedObjectUnionTypesWithRdfFeatureCount === 0 &&
-        namedObjectUnionTypesWithSparqlFeatureCount === 0) {
+    if (!this.configuration.features.has("rdf") &&
+        !this.configuration.features.has("sparql")) {
         return [];
     }
     const declarations = [
@@ -43,13 +13,13 @@ export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters })
             namedObjectUnionTypes,
         }),
     ];
-    if (namedObjectTypesWithRdfFeatureCount > 0) {
+    if (this.configuration.features.has("rdf")) {
         declarations.push(rdfjsDatasetObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));
     }
-    if (namedObjectTypesWithSparqlFeatureCount > 0) {
+    if (this.configuration.features.has("sparql")) {
         declarations.push(sparqlObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -1,7 +1,7 @@
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export function objectSetInterfaceDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return code `\
 export interface ${syntheticNamePrefix}ObjectSet {
   ${joinCode(namedObjectTypes

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -1,9 +1,9 @@
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code } from "./ts-poet-wrapper.js";
 export function objectSetMethodSignatures(parameters) {
     const { namedObjectType } = parameters;
     const parameterNamePrefix = parameters?.parameterNamePrefix ?? "";
-    const queryT = parameters.queryT ?? `${syntheticNamePrefix}ObjectSet.Query`;
+    const queryT = parameters.queryT ??
+        `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
     const methodNames = namedObjectType.objectSetMethodNames;
     return {
         object: {

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,8 +1,8 @@
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     const namedObjectTypeType = code `\
 {
   filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
@@ -40,7 +40,7 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
 
   ${joinCode([
         ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-            if (!namedObjectType.features.has("rdf")) {
+            if (!this.configuration.features.has("rdf")) {
                 return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
                     namedObjectType,
                 }));

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -1,8 +1,8 @@
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectUnionTypes, }) {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     const parameters = {
         constructObjectType: code `namedObjectType: {\
   focusSparqlWherePatterns: ${this.reusables.snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT>;
@@ -32,7 +32,7 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-        if (!namedObjectType.features.has("sparql")) {
+        if (!this.configuration.features.has("sparql")) {
             return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
                 namedObjectType,
             }));

package/dist/input/ShapesGraph.d.ts

@@ -3,7 +3,6 @@ import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Ast } from "../ast/Ast.js";
 import type { Generator } from "../generators/Generator.js";
-import type { TsFeature } from "../generators/ts/TsFeature.js";
 import * as generated from "./generated.js";
 export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
     protected readonly typeFunctions: {
@@ -18,15 +17,13 @@ export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape
     compile(parameters: {
         generator: Generator;
         logger: Logger;
-        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     }): Either<Error, string>;
     static builder(): ShapesGraph.Builder;
     /**
      * Transform the shapes graph to an AST.
      */
-    toAst({ logger, tsFeaturesDefault, }: {
+    toAst({ logger }: {
         logger: Logger;
-        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     }): Either<Error, Ast>;
 }
 export declare namespace ShapesGraph {
@@ -38,10 +35,10 @@ export declare namespace ShapesGraph {
             readonly PropertyShape: typeof generated.PropertyShape;
         };
         build(): ShapesGraph;
-        nodeShape(parameters?: Parameters<typeof generated.NodeShape.create>[0]): generated.NodeShape;
-        ontology(parameters?: Parameters<typeof generated.Ontology.create>[0]): generated.Ontology;
-        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.create>[0]): generated.PropertyGroup;
-        propertyShape(parameters: Parameters<typeof generated.PropertyShape.create>[0]): generated.PropertyShape;
+        nodeShape(parameters?: Parameters<typeof generated.NodeShape.createUnsafe>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.createUnsafe>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.createUnsafe>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.createUnsafe>[0]): generated.PropertyShape;
     }
 }
 //# sourceMappingURL=ShapesGraph.d.ts.map