@shaclmate/compiler 4.0.33 → 4.0.35

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonSchemaFunctionDeclaration() {
-    if (!this.features.has("json")) {
+    if (!this.configuration.features.has("json")) {
         return Maybe.empty();
     }
     let properties = [];

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonTypeAliasDeclaration() {
-    if (!this.features.has("json")) {
+    if (!this.configuration.features.has("json")) {
         return Maybe.empty();
     }
     const members = [];

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
-    if (!this.features.has("json")) {
+    if (!this.configuration.features.has("json")) {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };

package/dist/generators/ts/_NamedObjectType/NamedObjectType_objectSetMethodNames.d.ts

@@ -1,4 +1,6 @@
+import type { TsGenerator } from "../TsGenerator.js";
 export declare function NamedObjectType_objectSetMethodNames(this: {
+    readonly configuration: TsGenerator.Configuration;
     readonly name: string;
 }): {
     object: string;

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

@@ -1,7 +1,7 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function NamedObjectType_objectSetMethodNames() {
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     const prefixSingular = camelCase(this.name, {
         prefixCharacters: syntheticNamePrefix,
     });

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
-import type { TsFeature } from "../TsFeature.js";
+import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function NamedObjectType_sparqlConstructQueryFunctionDeclaration(this: {
-    readonly features: ReadonlySet<TsFeature>;
+    readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
     readonly name: string;
     readonly reusables: Reusables;

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

@@ -2,7 +2,7 @@ import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_sparqlConstructQueryFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

package/dist/generators/ts/_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
 import type { Reusables } from "../Reusables.js";
-import type { TsFeature } from "../TsFeature.js";
+import type { TsGenerator } from "../TsGenerator.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration(this: {
-    readonly features: ReadonlySet<TsFeature>;
+    readonly configuration: TsGenerator.Configuration;
     readonly filterType: Code;
     readonly name: string;
     readonly reusables: Reusables;

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_sparqlConstructQueryStringFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toJsonFunctionDeclaration() {
-    if (!this.features.has("json")) {
+    if (!this.configuration.features.has("json")) {
         return Maybe.empty();
     }
     const jsonObjectMembers = [];
@@ -10,7 +10,7 @@ export function NamedObjectType_toJsonFunctionDeclaration() {
     }
     if (this.properties.length > 0) {
         jsonObjectMembers.push(...this.properties.flatMap((property) => property
-            .toJsonObjectMemberExpression({
+            .toJsonInitializer({
             variables: {
                 value: property.accessExpression({
                     variables: { object: this.thisVariable },

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

@@ -2,7 +2,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toRdfResourceFunctionDeclaration() {
-    if (!this.features.has("rdf")) {
+    if (!this.configuration.features.has("rdf")) {
         return Maybe.empty();
     }
     const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);

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

@@ -1,27 +1,23 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
 export function NamedObjectType_toStringFunctionDeclarations() {
-    const propertiesToStringRecordProperties = [];
+    let propertiesToStringInitializers = [];
     if (this.parentObjectTypes.length > 0) {
         for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringRecordProperties.push(code `...${parentObjectType.name}._propertiesToStrings(${this.thisVariable})`);
+            propertiesToStringInitializers.push(code `...${parentObjectType.name}._propertiesToStrings(${this.thisVariable})`);
         }
     }
-    for (const property of this.properties) {
-        property
-            .toStringExpression({
-            variables: {
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-            .ifJust((propertyToStringExpression) => {
-            propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
-        });
-    }
-    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
+    propertiesToStringInitializers = propertiesToStringInitializers.concat(this.properties.flatMap((property) => property
+        .toStringInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()));
+    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringInitializers, { on: "," })}})`;
     const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return [
         // Use overloads to allow the function to be attached to an instance or used freestanding
         code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\

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

@@ -21,7 +21,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         path: PropertyPath;
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
-    get constructorParametersSignature(): Maybe<Code>;
+    get constructorParameter(): Maybe<Code>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
@@ -35,16 +35,16 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
         kind: Code;
         type: Code;
     };
-    constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonExpression"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
-    hashStatements(parameters: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
+    constructorInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
-    toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toJsonInitializer(parameters: Parameters<AbstractProperty<TypeT>["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
-    toStringExpression(parameters: Parameters<AbstractProperty<TypeT>["toStringExpression"]>[0]): Maybe<Code>;
+    toStringInitializer(parameters: Parameters<AbstractProperty<TypeT>["toStringInitializer"]>[0]): Maybe<Code>;
     private propertyPathToCode;
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

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

@@ -6,7 +6,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { codeEquals } from "../codeEquals.js";
 import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
 import { AbstractProperty } from "./AbstractProperty.js";
@@ -29,15 +28,19 @@ export class ShaclProperty extends AbstractProperty {
         this.path = path;
         this.recursive = recursive;
     }
-    get constructorParametersSignature() {
+    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 conversion of this.type.conversions) {
-            if (conversion.sourceTypeof === "undefined") {
+        for (const type of conversionFunction.sourceTypes) {
+            if (type.typeof === "undefined") {
                 hasQuestionToken = true;
             }
-            else if (!typeNames.some((typeName) => codeEquals(typeName, conversion.sourceTypeName))) {
-                typeNames.push(code `${conversion.sourceTypeName}`);
+            else {
+                typeNames.push(code `${type.name}`);
             }
         }
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
@@ -99,7 +102,7 @@ export class ShaclProperty extends AbstractProperty {
             ...super.schemaObject,
             // comment: this.comment.map(JSON.stringify).extract(),
             // description: this.description.map(JSON.stringify).extract(),
-            path: this.namedObjectType.features.has("rdf")
+            path: this.configuration.features.has("rdf")
                 ? this.propertyPathToCode(this.path)
                 : undefined,
             // label: this.label.map(JSON.stringify).extract(),
@@ -111,28 +114,35 @@ export class ShaclProperty extends AbstractProperty {
             //     : undefined,
         };
     }
-    constructorStatements({ variables, }) {
-        const typeConversions = this.type.conversions;
-        if (typeConversions.length === 1) {
-            return [code `const ${this.name} = ${variables.parameter};`];
+    constructorInitializer({ variables, }) {
+        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})`;
         }
-        const statements = [code `let ${this.name}: ${this.type.name};`];
-        statements.push(joinCode(typeConversions
-            .map((conversion) => code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`)
-            // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-            .concat(code `{ ${this.name} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
-        return statements;
-    }
-    fromJsonExpression({ variables, }) {
-        return Maybe.of(this.type.fromJsonExpression({
+        return Maybe.of(code `${this.name}: ${rhs}`);
+    }
+    fromJsonInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
             variables: { value: code `${variables.jsonObject}["${this.name}"]` },
-        }));
+        })}`);
     }
-    fromRdfResourceValuesExpression({ variables, }) {
+    fromRdfResourceValuesInitializer({ variables, }) {
         // Assume the property has the correct range and ignore the object's RDF type.
         // This also accommodates the case where the object of a property is a dangling identifier that's not the
         // subject of any statements.
-        return Maybe.of(code `${this.reusables.snippets.shaclPropertyFromRdf}(${{
+        return Maybe.of(code `${this.name}: ${this.reusables.snippets.shaclPropertyFromRdf}(${{
             graph: variables.graph,
             resource: variables.resource,
             propertySchema: code `schema.properties.${this.name}`,
@@ -146,8 +156,10 @@ export class ShaclProperty extends AbstractProperty {
             })})`,
         }})`);
     }
-    hashStatements(parameters) {
-        return this.type.hashStatements(parameters);
+    hashStatements({ variables, }) {
+        return [
+            code `${this.type.hashFunction}(${variables.hasher}, ${variables.value});`,
+        ];
     }
     jsonUiSchemaElement({ variables, }) {
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
@@ -184,7 +196,7 @@ export class ShaclProperty extends AbstractProperty {
             }})`,
         });
     }
-    toJsonObjectMemberExpression(parameters) {
+    toJsonInitializer(parameters) {
         return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
     }
     toRdfRdfResourceValuesStatements({ variables, }) {
@@ -206,11 +218,11 @@ export class ShaclProperty extends AbstractProperty {
             })}, ${variables.graph});`,
         ];
     }
-    toStringExpression(parameters) {
+    toStringInitializer(parameters) {
         if (!this.display) {
             return Maybe.empty();
         }
-        return Maybe.of(this.type.toStringExpression(parameters));
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
     }
     propertyPathToCode(propertyPath) {
         switch (propertyPath.termType) {
@@ -229,7 +241,7 @@ export class ShaclProperty extends AbstractProperty {
 }
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "constructorParametersSignature", null);
+], ShaclProperty.prototype, "constructorParameter", null);
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "declaration", null);

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_DefaultValueSchema.js

@@ -1,7 +1,7 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_DefaultValueSchema = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
-interface ${syntheticNamePrefix}DefaultValueSchema<ItemSchemaT> {
-  readonly defaultValue: ${imports.Literal} | ${imports.NamedNode};
+export const snippets_DefaultValueSchema = ({ syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}DefaultValueSchema`, code `\
+interface ${syntheticNamePrefix}DefaultValueSchema<DefaultValueT, ItemSchemaT> {
+  readonly defaultValue: DefaultValueT;
   readonly item: () => ItemSchemaT;
   readonly kind: "DefaultValue";
 }`);

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

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

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

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_HashFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}HashFunction`, code `\
+export type ${syntheticNamePrefix}HashFunction<HasherT extends ${snippets.Hasher}, ValueT> = (hasher: HasherT, value: ValueT) => HasherT;`);
+//# sourceMappingURL=snippets_HashFunction.js.map

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

@@ -1,32 +1,42 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { code, conditionalOutput, joinCode, } from "../ts-poet-wrapper.js";
 /**
  * Adapter between generated code and the rdfjs-resource PropertyPath.
  */
-export const snippets_PropertyPath = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
+export const snippets_PropertyPath = ({ configuration, imports, snippets, syntheticNamePrefix, }) => {
+    const companionDeclarations = [];
+    if (configuration.features.has("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 `\
+export function filter(_filter: Filter, _value: ${syntheticNamePrefix}PropertyPath): boolean {
+  return true;
+}`);
+    if (configuration.features.has("rdf")) {
+        companionDeclarations.push(code `\
+export const fromRdfResource: ${snippets.FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;`, code `\
+export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
+  values.chain((values) =>
+    values.chainMap((value) =>
+      value
+        .toResource()
+        .chain((resource) => fromRdfResource(resource, options)),
+    ),
+  );`);
+    }
+    companionDeclarations.push(code `export const schema: Readonly<object> = {}`);
+    if (configuration.features.has("rdf")) {
+        companionDeclarations.push(code `\
+export const toRdfResource: ${snippets.ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.toResource;`);
+    }
+    companionDeclarations.push(code `export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;`);
+    return conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
 export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfxResourcePropertyPath};
 
 export namespace ${syntheticNamePrefix}PropertyPath {
-  export type Filter = object;
-
-  export function filter(_filter: Filter, _value: ${syntheticNamePrefix}PropertyPath): boolean {
-    return true;
-  }
-
-  export const fromRdfResource: ${snippets.FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;
-
-  export const fromRdfResourceValues: ${snippets.FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
-    values.chain((values) =>
-      values.chainMap((value) =>
-        value
-          .toResource()
-          .chain((resource) => fromRdfResource(resource, options)),
-      ),
-    );
-
-  export const schema: Readonly<object> = {};
-
-  export const toRdfResource: ${snippets.ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.toResource;
-
-  export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;
+${joinCode(companionDeclarations, { on: "\n\n" })}
 }`);
+};
 //# sourceMappingURL=snippets_PropertyPath.js.map

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.d.ts

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

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToBlankNodeIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToBlankNodeIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToBlankNodeIdentifierProperty(identifier: (() => ${imports.BlankNode}) | ${imports.BlankNode} | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode})> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "undefined": {
+      const captureIdentifier = ${imports.dataFactory}.blankNode();
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToBlankNodeIdentifierProperty.js.map

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToIdentifierProperty = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToIdentifierProperty`, code `\
+function ${syntheticNamePrefix}convertToIdentifierProperty(identifier: (() => ${imports.BlankNode} | ${imports.NamedNode}) | ${imports.BlankNode} | ${imports.NamedNode} | string | undefined): ${imports.Either}<Error, (() => ${imports.BlankNode} | ${imports.NamedNode})> {
+  switch (typeof identifier) {
+    case "function":
+      return ${imports.Either}.of(identifier);
+    case "object": {
+      const captureIdentifier = identifier;
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "string": {
+      const captureIdentifier = ${imports.dataFactory}.namedNode(identifier);
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+    case "undefined": {
+      const captureIdentifier = ${imports.dataFactory}.blankNode();
+      return ${imports.Either}.of(() => captureIdentifier);
+    }
+  }
+}`);
+//# sourceMappingURL=snippets_convertToIdentifierProperty.js.map

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

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

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

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

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

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

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

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