@shaclmate/compiler 4.0.34 → 4.0.36

package/dist/generators/ts/_NamedObjectType/ShaclProperty.js

@@ -29,9 +29,13 @@ export class ShaclProperty extends AbstractProperty {
         this.recursive = recursive;
     }
     get constructorParameter() {
+        const conversionFunction = this.type.conversionFunction.extract();
+        if (!conversionFunction) {
+            return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+        }
         let hasQuestionToken = false;
         const typeNames = [];
-        for (const type of this.type.conversionFunction.sourceTypes) {
+        for (const type of conversionFunction.sourceTypes) {
             if (type.typeof === "undefined") {
                 hasQuestionToken = true;
             }
@@ -98,7 +102,9 @@ export class ShaclProperty extends AbstractProperty {
             ...super.schemaObject,
             // comment: this.comment.map(JSON.stringify).extract(),
             // description: this.description.map(JSON.stringify).extract(),
-            path: this.configuration.features.has("rdf")
+            path: this.configuration.features.has("Object.fromRdf") ||
+                this.configuration.features.has("Object.toRdf") ||
+                this.configuration.features.has("Object.SPARQL")
                 ? this.propertyPathToCode(this.path)
                 : undefined,
             // label: this.label.map(JSON.stringify).extract(),
@@ -111,7 +117,23 @@ export class ShaclProperty extends AbstractProperty {
         };
     }
     constructorInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.conversionFunction.code}(schema.properties.${this.name}.type(), ${variables.parameters}.${this.name})`);
+        const parameterVariable = code `${variables.parameters}.${this.name}`;
+        const conversionFunction = this.type.conversionFunction.extract()?.code;
+        const validationFunction = this.type.validationFunction.extract();
+        let rhs;
+        if (conversionFunction && validationFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), value))`;
+        }
+        else if (conversionFunction) {
+            rhs = code `${conversionFunction}(${parameterVariable})`;
+        }
+        else if (validationFunction) {
+            rhs = code `${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type(), ${parameterVariable})`;
+        }
+        else {
+            rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
+        }
+        return Maybe.of(code `${this.name}: ${rhs}`);
     }
     fromJsonInitializer({ variables, }) {
         return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
@@ -191,7 +213,7 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = this.propertyPathToCode(this.path);
+        const propertyPath = code `${this.namedObjectType.name}.schema.properties.${this.name}.path`;
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },

package/dist/generators/ts/_NamedObjectType/identifierTypeDeclarations.js

@@ -1,5 +1,8 @@
 import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
+    if (!this.configuration.features.has("Object.type")) {
+        return [];
+    }
     const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
     if (ancestorObjectTypeWithSameIdentifierType) {
         // This object type's identifier type has the same identifier type as an ancestor object type,

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

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

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

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

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

@@ -4,17 +4,19 @@ import { code, conditionalOutput, joinCode, } from "../ts-poet-wrapper.js";
  */
 export const snippets_PropertyPath = ({ configuration, imports, snippets, syntheticNamePrefix, }) => {
     const companionDeclarations = [];
-    if (configuration.features.has("equals")) {
+    if (configuration.features.has("Object.equals")) {
         companionDeclarations.push(code `\
 export function equals(left: ${syntheticNamePrefix}PropertyPath, right: ${syntheticNamePrefix}PropertyPath): ${snippets.EqualsResult} {
   return ${snippets.EqualsResult}.fromBooleanEqualsResult(left, right, ${imports.RdfxResourcePropertyPath}.equals(left, right));
 }`);
     }
-    companionDeclarations.push(code `export type Filter = object`, code `\
+    if (configuration.features.has("Object.filter")) {
+        companionDeclarations.push(code `export type Filter = object`, code `\
 export function filter(_filter: Filter, _value: ${syntheticNamePrefix}PropertyPath): boolean {
   return true;
 }`);
-    if (configuration.features.has("rdf")) {
+    }
+    if (configuration.features.has("Object.fromRdf")) {
         companionDeclarations.push(code `\
 export const fromRdfResource: ${snippets.FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;`, code `\
 export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
@@ -26,12 +28,16 @@ export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${
     ),
   );`);
     }
-    companionDeclarations.push(code `export const schema: Readonly<object> = {}`);
-    if (configuration.features.has("rdf")) {
+    if (configuration.features.has("Object.schema")) {
+        companionDeclarations.push(code `export const schema: Readonly<object> = {}`);
+    }
+    if (configuration.features.has("Object.toRdf")) {
         companionDeclarations.push(code `\
 export const toRdfResource: ${snippets.ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.toResource;`);
     }
-    companionDeclarations.push(code `export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;`);
+    if (configuration.features.has("Object.toString")) {
+        companionDeclarations.push(code `export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;`);
+    }
     return conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
 export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfxResourcePropertyPath};
 

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_ValidationFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}ValidationFunction`, code `\
+type ${syntheticNamePrefix}ValidationFunction<SchemaT, ValueT> = (schema: SchemaT, value: ValueT) => ${imports.Either}<Error, ValueT>;`);
+//# sourceMappingURL=snippets_ValidationFunction.js.map

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_convertToIri = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
-function ${syntheticNamePrefix}convertToIri<IriT extends string = string>(_schema: ${snippets.IriSchema}, value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
+export const snippets_convertToIri = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIri`, code `\
+function ${syntheticNamePrefix}convertToIri<IriT extends string = string>(value: IriT | ${imports.NamedNode}<IriT>): ${imports.Either}<Error, ${imports.NamedNode}<IriT>> {
   switch (typeof value) {
     case "object":
       return ${imports.Either}.of(value);

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

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLazyObject = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLazyObject`, code `\
 function ${syntheticNamePrefix}convertToLazyObject<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.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ResolvedObjectT): ${imports.Either}<Error, ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
+  return (value: ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT> | ResolvedObjectT): ${imports.Either}<Error, ${snippets.LazyObject}<ObjectIdentifierT, PartialObjectT, ResolvedObjectT>> => {
     if (value instanceof ${snippets.LazyObject}) {
       return ${imports.Either}.of(value);
     }

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

@@ -1,7 +1,7 @@
 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>> => {
+  return (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}) {

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

@@ -1,7 +1,7 @@
 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>> => {
+  return (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}) {

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

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_convertToLiteral = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToLiteral`, code `\
-function ${syntheticNamePrefix}convertToLiteral(_schema: ${snippets.LiteralSchema}, value: bigint | boolean | Date | number | string | ${imports.Literal}): ${imports.Either}<Error, ${imports.Literal}> {
+function ${syntheticNamePrefix}convertToLiteral(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));

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

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

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

@@ -1,11 +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> => {
+function ${syntheticNamePrefix}convertWithDefaultValue<ItemSourceT, ItemTargetT>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, defaultValue: ItemSourceT) {
+  return (value: ItemSourceT | undefined): ${imports.Either}<Error, ItemTargetT> => {
     if (typeof value === "undefined") {
-      return convertToItem(schema.item(), schema.defaultValue);
+      return convertToItem(defaultValue);
     }
-    return convertToItem(schema.item(), value);
+    return convertToItem(value);
   }
 }`);
 //# sourceMappingURL=snippets_convertWithDefaultValue.js.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_validateMaybe = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}validateMaybe`, code `\
+function ${syntheticNamePrefix}validateMaybe<ItemSchemaT, ItemValueT>(validateItem: ${snippets.ValidationFunction}<ItemSchemaT, ItemValueT>) {
+  return (schema: ${snippets.MaybeSchema}<ItemSchemaT>, valueMaybe: ${imports.Maybe}<ItemValueT>): ${imports.Either}<Error, ${imports.Maybe}<ItemValueT>> =>
+    valueMaybe.map(value => validateItem(schema.item(), value).map(() => valueMaybe)).orDefault(${imports.Either}.of(valueMaybe));
+}`);
+//# sourceMappingURL=snippets_validateMaybe.js.map

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -69,7 +69,7 @@ async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${nam
     }, {})} })`;
 }
 export function graphqlSchemaVariableStatement({ namedObjectTypes, namedObjectUnionTypes, }) {
-    if (!this.configuration.features.has("graphql")) {
+    if (!this.configuration.features.has("GraphQL")) {
         return Maybe.empty();
     }
     namedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.synthetic);

package/dist/generators/ts/objectSetDeclarations.js

@@ -3,23 +3,20 @@ import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetCl
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
 export function objectSetDeclarations({ namedObjectUnionTypes, ...parameters }) {
     const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
-    if (!this.configuration.features.has("rdf") &&
-        !this.configuration.features.has("sparql")) {
-        return [];
-    }
-    const declarations = [
-        objectSetInterfaceDeclaration.call(this, {
+    const declarations = [];
+    if (this.configuration.features.has("ObjectSet")) {
+        declarations.push(objectSetInterfaceDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
-        }),
-    ];
-    if (this.configuration.features.has("rdf")) {
+        }));
+    }
+    if (this.configuration.features.has("RdfjsDatasetObjectSet")) {
         declarations.push(rdfjsDatasetObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,
         }));
     }
-    if (this.configuration.features.has("sparql")) {
+    if (this.configuration.features.has("SparqlObjectSet")) {
         declarations.push(sparqlObjectSetClassDeclaration.call(this, {
             namedObjectTypes: namedObjectTypes,
             namedObjectUnionTypes,

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,6 +1,5 @@
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.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 `\
@@ -40,11 +39,6 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
 
   ${joinCode([
         ...[...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-            if (!this.configuration.features.has("rdf")) {
-                return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
-                    namedObjectType,
-                }));
-            }
             const methodSignatures = objectSetMethodSignatures.call(this, {
                 namedObjectType,
             });

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -1,6 +1,5 @@
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.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 = {
@@ -32,11 +31,6 @@ export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePre
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
-        if (!this.configuration.features.has("sparql")) {
-            return Object.values(unsupportedObjectSetMethodDeclarations.call(this, {
-                namedObjectType,
-            }));
-        }
         const methodSignatures = objectSetMethodSignatures.call(this, {
             namedObjectType,
             queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,

package/dist/input/generated.d.ts

@@ -178,7 +178,7 @@ export interface PropertyShape {
 }
 export declare namespace PropertyShape {
     function create(parameters: {
-        readonly $identifier?: (() => PropertyShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly comment?: string | Maybe<string>;
@@ -217,7 +217,7 @@ export declare namespace PropertyShape {
         readonly xone?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
     }): Either<Error, PropertyShape>;
     function createUnsafe(parameters: {
-        readonly $identifier?: (() => PropertyShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly comment?: string | Maybe<string>;
@@ -708,12 +708,12 @@ export interface PropertyGroup {
 }
 export declare namespace PropertyGroup {
     function create(parameters?: {
-        readonly $identifier?: (() => PropertyGroup.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyGroup.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Either<Error, PropertyGroup>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => PropertyGroup.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => PropertyGroup.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): PropertyGroup;
@@ -784,12 +784,12 @@ export interface Ontology {
 }
 export declare namespace Ontology {
     function create(parameters?: {
-        readonly $identifier?: (() => Ontology.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => Ontology.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Either<Error, Ontology>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => Ontology.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => Ontology.Identifier) | BlankNode | NamedNode | string;
         readonly comment?: string | Maybe<string>;
         readonly label?: string | Maybe<string>;
     }): Ontology;
@@ -896,7 +896,7 @@ export interface NodeShape {
 }
 export declare namespace NodeShape {
     function create(parameters?: {
-        readonly $identifier?: (() => NodeShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => NodeShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly closed?: boolean | Maybe<boolean>;
@@ -937,7 +937,7 @@ export declare namespace NodeShape {
         readonly xone?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
     }): Either<Error, NodeShape>;
     function createUnsafe(parameters?: {
-        readonly $identifier?: (() => NodeShape.Identifier) | (BlankNode | NamedNode) | string;
+        readonly $identifier?: (() => NodeShape.Identifier) | BlankNode | NamedNode | string;
         readonly and?: readonly (BlankNode | NamedNode | string | undefined)[] | Maybe<readonly (BlankNode | NamedNode)[]>;
         readonly classes?: readonly (string | NamedNode)[];
         readonly closed?: boolean | Maybe<boolean>;