@shaclmate/compiler 4.0.33 → 4.0.35

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
-    readonly constructorParametersSignature: Maybe<Code>;
+    readonly constructorParameter: Maybe<Code>;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
     readonly kind = "DiscriminantProperty";
@@ -15,17 +15,17 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     get jsonName(): string;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    private get initializer();
-    constructorStatements(): readonly Code[];
-    fromJsonExpression(): Maybe<Code>;
-    fromRdfResourceValuesExpression(): Maybe<Code>;
+    private get constValue();
+    constructorInitializer(): Maybe<Code>;
+    fromJsonInitializer(): Maybe<Code>;
+    fromRdfResourceValuesInitializer(): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toJsonInitializer({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringExpression(): Maybe<Code>;
+    toStringInitializer(): Maybe<Code>;
 }
 export declare namespace DiscriminantProperty {
     class Type {

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

@@ -10,7 +10,7 @@ import { removeUndefined } from "../removeUndefined.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
-    constructorParametersSignature = Maybe.empty();
+    constructorParameter = Maybe.empty();
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
     kind = "DiscriminantProperty";
@@ -36,16 +36,16 @@ export class DiscriminantProperty extends AbstractProperty {
     get jsonSignature() {
         return Maybe.of(code `readonly "${this.jsonName}": ${this.type.name}`);
     }
-    get initializer() {
+    get constValue() {
         return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
-    constructorStatements() {
-        return [code `const ${this.name} = ${this.initializer};`];
+    constructorInitializer() {
+        return Maybe.empty();
     }
-    fromJsonExpression() {
+    fromJsonInitializer() {
         return Maybe.empty();
     }
-    fromRdfResourceValuesExpression() {
+    fromRdfResourceValuesInitializer() {
         return Maybe.empty();
     }
     hashStatements({ variables, }) {
@@ -59,7 +59,7 @@ export class DiscriminantProperty extends AbstractProperty {
             return Maybe.empty();
         }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
-        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
     sparqlConstructTriplesExpression() {
         return Maybe.empty();
@@ -67,13 +67,13 @@ export class DiscriminantProperty extends AbstractProperty {
     sparqlWherePatternsExpression() {
         return Maybe.empty();
     }
-    toJsonObjectMemberExpression({ variables, }) {
+    toJsonInitializer({ variables, }) {
         return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
     }
-    toStringExpression() {
+    toStringInitializer() {
         return Maybe.empty();
     }
 }

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

@@ -13,7 +13,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
         type: BlankNodeType | IdentifierType | IriType;
         typeAlias: Code;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
-    get constructorParametersSignature(): Maybe<Code>;
+    get constructorParameter(): Maybe<Code>;
     get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
@@ -23,9 +23,9 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
-    constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonExpression"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
+    constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
@@ -33,8 +33,8 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
         condition: Code;
         patterns: Code;
     }>;
-    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
+    toStringInitializer(parameters: Parameters<AbstractProperty<IdentifierType>["toStringInitializer"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map

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

@@ -9,9 +9,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { codeEquals } from "../codeEquals.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class IdentifierProperty extends AbstractProperty {
     typeAlias;
@@ -22,13 +20,16 @@ export class IdentifierProperty extends AbstractProperty {
         super(superParameters);
         this.typeAlias = typeAlias;
     }
-    get constructorParametersSignature() {
-        const hasQuestionToken = this.type.nodeKinds.has("BlankNode");
+    get constructorParameter() {
+        let hasQuestionToken = false;
         const typeNames = [code `(() => ${this.typeAlias})`];
-        for (const conversion of this.type.conversions) {
-            if (conversion.sourceTypeof !== "undefined" &&
-                !typeNames.some((typeName) => codeEquals(typeName, conversion.sourceTypeName))) {
-                typeNames.push(code `${conversion.sourceTypeName}`);
+        for (const type of this.type.conversionFunction.unsafeCoerce()
+            .sourceTypes) {
+            if (type.typeof === "undefined") {
+                hasQuestionToken = true;
+            }
+            else {
+                typeNames.push(code `${type.name}`);
             }
         }
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
@@ -43,6 +44,7 @@ export class IdentifierProperty extends AbstractProperty {
         });
     }
     get graphqlField() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         invariant(this.name.startsWith(syntheticNamePrefix));
         return Maybe.of({
             args: Maybe.empty(),
@@ -76,37 +78,32 @@ export class IdentifierProperty extends AbstractProperty {
     accessExpression({ variables, }) {
         return code `${variables.object}.${this.name}()`;
     }
-    constructorStatements({ variables, }) {
-        const parameterVariable = code `${this.name}Parameter`;
-        const statements = [
-            // Pull out the parameter so the function can capture it if necessary.
-            code `const ${parameterVariable} = ${variables.parameter};`,
-            code `let ${this.name}: () => ${this.typeAlias};`,
-        ];
-        const typeConversions = this.type.conversions;
-        const conversionBranches = [
-            code `if (typeof ${parameterVariable} === "function") { ${this.name} = ${parameterVariable}; }`,
-        ];
-        for (const conversion of typeConversions) {
-            invariant(conversion.sourceTypeof !== "function");
-            invariant(conversion.sourceTypeof !== "undefined");
-            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${this.name} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
+    constructorInitializer({ variables, }) {
+        const nodeKinds = this.type.nodeKinds;
+        let conversionFunction;
+        if (nodeKinds.size === 2) {
+            conversionFunction = code `${this.reusables.snippets.convertToIdentifierProperty}`;
         }
-        if (this.type.nodeKinds.has("BlankNode")) {
-            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${this.reusables.imports.dataFactory}.blankNode(); ${this.name} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
+        else {
+            invariant(nodeKinds.size === 1);
+            if (nodeKinds.has("BlankNode")) {
+                conversionFunction = code `${this.reusables.snippets.convertToBlankNodeIdentifierProperty}`;
+            }
+            else {
+                conversionFunction = code `${this.reusables.snippets.convertToIriIdentifierProperty}<${this.type.in_.length > 0
+                    ? joinCode(this.type.in_.map((in_) => code `${literalOf(in_.value)}`), { on: " | " })
+                    : "string"}>`;
+            }
         }
-        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        conversionBranches.push(code `{ ${this.name} = (${parameterVariable}) satisfies never;\n }`);
-        statements.push(joinCode(conversionBranches, { on: " else " }));
-        return statements;
+        return Maybe.of(code `${this.name}: ${conversionFunction}(${variables.parameters}.${this.name})`);
     }
-    fromJsonExpression({ variables, }) {
-        return Maybe.of(this.type.fromJsonExpression({
+    fromJsonInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
             variables: { value: variables.jsonObject },
-        }));
+        })}`);
     }
-    fromRdfResourceValuesExpression({ variables, }) {
-        return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
+    fromRdfResourceValuesInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 propertyPath: this.rdfjsTermExpression(rdf.subject),
@@ -137,7 +134,7 @@ export class IdentifierProperty extends AbstractProperty {
             }})`,
         });
     }
-    toJsonObjectMemberExpression({ variables, }) {
+    toJsonInitializer({ variables, }) {
         const nodeKinds = [...this.type.nodeKinds];
         const valueToNodeKinds = nodeKinds.map((nodeKind) => {
             switch (nodeKind) {
@@ -158,13 +155,13 @@ export class IdentifierProperty extends AbstractProperty {
     toRdfRdfResourceValuesStatements() {
         return [];
     }
-    toStringExpression(parameters) {
-        return Maybe.of(this.type.toStringExpression(parameters));
+    toStringInitializer(parameters) {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
     }
 }
 __decorate([
     Memoize()
-], IdentifierProperty.prototype, "constructorParametersSignature", null);
+], IdentifierProperty.prototype, "constructorParameter", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "declaration", null);

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

@@ -1,12 +1,11 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function NamedObjectType_createFunctionDeclaration() {
-    if (!this.features.has("create")) {
+    if (!this.configuration.features.has("create")) {
         return Maybe.empty();
     }
-    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParameter.toList());
     const parametersType = [];
     if (parametersPropertySignatures.length > 0) {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
@@ -17,40 +16,44 @@ export function NamedObjectType_createFunctionDeclaration() {
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
     }
-    const propertyInitializers = [];
-    const omitPropertyNames = [];
-    const propertyStatements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
-    }
     const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
         parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);
     const parametersVariable = code `parameters${parametersHasQuestionToken ? "?" : ""}`;
-    for (const property of this.properties) {
-        const thisPropertyStatements = property.constructorStatements({
-            variables: {
-                parameter: code `${parametersVariable}.${property.name}`,
-                parameters: parametersVariable,
-            },
+    const parametersSignature = code `parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}`;
+    const chains = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        chains.push({
+            expression: code `${parentObjectType.name}.create(parameters)`,
+            variable: `super${parentObjectTypeI}`,
         });
-        if (thisPropertyStatements.length > 0) {
-            propertyInitializers.push(property.name);
-            propertyStatements.push(...thisPropertyStatements);
-        }
-        else {
-            omitPropertyNames.push(property.name);
-        }
-    }
+    });
+    const propertyInitializers = this.properties.flatMap((property) => property
+        .constructorInitializer({
+        variables: { parameters: parametersVariable },
+    })
+        .toList());
     invariant(propertyInitializers.length > 0);
-    invariant(propertyStatements.length > 0);
+    chains.push({
+        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
+        variable: "properties",
+    });
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return Maybe.of(code `\
-export function create(parameters${parametersHasQuestionToken ? "?" : ""}: ${joinCode(parametersType, { on: " & " })}): ${omitPropertyNames.length === 0 ? this.name : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`} {
-  ${joinCode(propertyStatements)}
-  const ${syntheticNamePrefix}object = { ${propertyInitializers.join(", ")} };
-  if (!globalThis.Object.prototype.hasOwnProperty.call(${syntheticNamePrefix}object, "toString")) {
-    (${syntheticNamePrefix}object as any).toString = ${syntheticNamePrefix}toString;
+export function create(${parametersSignature}): ${this.reusables.imports.Either}<Error, ${this.name}> {
+  return ${chains.toReversed().reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `\
+{
+  const finalObject = { ${chains
+        .map((chain) => `...${chain.variable}`)
+        .join(", ")}, ${this._discriminantProperty.name}: ${literalOf(this.discriminantValue)} as const };
+  if (!globalThis.Object.prototype.hasOwnProperty.call(finalObject, "toString")) {
+    (finalObject as any).toString = ${syntheticNamePrefix}toString;
   }
-  return ${syntheticNamePrefix}object;
+  return finalObject;
+}`)};
+}
+  
+export function createUnsafe(${parametersSignature}): ${this.name} {
+  return create(parameters).unsafeCoerce();
 }`);
 }
 //# sourceMappingURL=NamedObjectType_createFunctionDeclaration.js.map

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

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

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

@@ -7,7 +7,7 @@ const variables = {
     variablePrefix: code `parameters.variablePrefix`,
 };
 export function NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;

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

@@ -8,7 +8,7 @@ const variables = {
     variablePrefix: code `parameters.variablePrefix`,
 };
 export function NamedObjectType_focusSparqlWherePatternsFunctionDeclaration() {
-    if (!this.features.has("sparql")) {
+    if (!this.configuration.features.has("sparql")) {
         return Maybe.empty();
     }
     const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;

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

@@ -1,31 +1,43 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-const variables = {
-    jsonObject: code `${syntheticNamePrefix}json`,
-};
 export function NamedObjectType_fromJsonFunctionDeclaration() {
-    if (!this.features.has("json")) {
+    if (!this.configuration.features.has("json")) {
         return Maybe.empty();
     }
-    const initializers = [];
-    const statements = [];
-    this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.name}.fromJson(${variables.jsonObject})`);
+    const variables = {
+        jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
+    };
+    const chains = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        chains.push({
+            expression: code `${parentObjectType.name}.fromJson(${variables.jsonObject})`,
+            variable: `super${parentObjectTypeI}`,
+        });
     });
-    for (const property of this.properties) {
-        property
-            .fromJsonExpression({
-            variables,
-        })
-            .ifJust((propertyFromJsonExpression) => {
-            initializers.push(code `${property.name}: ${propertyFromJsonExpression}`);
+    const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
+    if (propertyInitializers.length > 0) {
+        chains.push({
+            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
+            variable: "properties",
         });
     }
-    statements.push(code `return create({ ${joinCode(initializers, { on: ", " })} });`);
+    let returnExpression;
+    switch (chains.length) {
+        case 0:
+            returnExpression = code `create({})`;
+            break;
+        case 1:
+            returnExpression = code `(${chains[0].expression}).chain(create)`;
+            break;
+        default:
+            returnExpression = code `${chains
+                .reverse()
+                .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create({ ${chains.map((chain) => `...${chain.variable}`).join(", ")} }))`)}`;
+            break;
+    }
     return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.name} {
-${joinCode(statements, { on: "\n" })}
+export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> {
+  return ${returnExpression};
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

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

@@ -1,27 +1,27 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-const optionsVariable = `_${syntheticNamePrefix}options`;
-const variables = {
-    context: code `${optionsVariable}.context`,
-    graph: code `${optionsVariable}.graph`,
-    ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
-    objectSet: code `${optionsVariable}.objectSet`,
-    preferredLanguages: code `${optionsVariable}.preferredLanguages`,
-    resource: code `${syntheticNamePrefix}resource`,
-};
-const propertyFromRdfResourceValuesExpressionVariable = {
-    context: variables.context,
-    graph: variables.graph,
-    objectSet: variables.objectSet,
-    preferredLanguages: variables.preferredLanguages,
-    resource: variables.resource,
-};
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
-    if (!this.features.has("rdf")) {
+    if (!this.configuration.features.has("rdf")) {
         return Maybe.empty();
     }
+    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+    const optionsVariable = `_${syntheticNamePrefix}options`;
+    const variables = {
+        context: code `${optionsVariable}.context`,
+        graph: code `${optionsVariable}.graph`,
+        ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
+        objectSet: code `${optionsVariable}.objectSet`,
+        preferredLanguages: code `${optionsVariable}.preferredLanguages`,
+        resource: code `${syntheticNamePrefix}resource`,
+    };
+    const propertyFromRdfResourceValuesExpressionVariable = {
+        context: variables.context,
+        graph: variables.graph,
+        objectSet: variables.objectSet,
+        preferredLanguages: variables.preferredLanguages,
+        resource: variables.resource,
+    };
     const chains = [];
     const partials = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
@@ -60,20 +60,14 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
             variable: `_rdfTypeCheck`,
         });
     });
-    const propertyFromRdfResourceValuesExpressions = {};
-    for (const property of this.properties) {
-        property
-            .fromRdfResourceValuesExpression({
-            variables: propertyFromRdfResourceValuesExpressionVariable,
-        })
-            .ifJust((propertyFromRdfResourceValuesExpression) => {
-            propertyFromRdfResourceValuesExpressions[property.name] =
-                propertyFromRdfResourceValuesExpression;
-        });
-    }
-    if (Object.keys(propertyFromRdfResourceValuesExpressions).length > 0) {
+    const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
+        .fromRdfResourceValuesInitializer({
+        variables: propertyFromRdfResourceValuesExpressionVariable,
+    })
+        .toList());
+    if (Object.keys(propertyFromRdfResourceValuesInitializers).length > 0) {
         chains.push({
-            expression: code `${this.reusables.snippets.sequenceRecord}(${propertyFromRdfResourceValuesExpressions})`,
+            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
             variable: "properties",
         });
         partials.push("properties");
@@ -90,19 +84,19 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
             partialsJoined = code `{ ${partials.map((partial) => `...${partial}`).join(", ")} }`;
             break;
     }
-    const statements = [];
+    let returnExpression;
     const resultExpression = code `create(${partialsJoined})`;
     if (chains.length === 0) {
-        statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
+        returnExpression = code `${this.reusables.imports.Right}(${resultExpression})`;
     }
     else {
-        statements.push(code `return ${chains
+        returnExpression = code `${chains
             .reverse()
-            .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `(${resultExpression})`)}`);
+            .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`;
     }
     return Maybe.of(code `\
 export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.name}> = (${variables.resource}, ${optionsVariable}) => {
-${joinCode(statements)}
+  return ${returnExpression};
 }
 
 export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);

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

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

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

@@ -1,7 +1,7 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_fromRdfTypeVariableStatement() {
-    if (!this.features.has("rdf")) {
+    if (!this.configuration.features.has("rdf")) {
         return Maybe.empty();
     }
     return this.fromRdfType.map((fromRdfType) => code `\

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

@@ -1,15 +1,14 @@
 import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_graphqlTypeVariableStatement() {
-    if (!this.features.has("graphql")) {
+    if (!this.configuration.features.has("graphql")) {
         return Maybe.empty();
     }
     if (this.synthetic) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${{
+export const GraphQL = new ${this.reusables.imports.GraphQLObjectType}<${this.name}, { objectSet: ${this.configuration.syntheticNamePrefix}ObjectSet }>(${{
         description: this.comment.extract(),
         fields: code `() => (${this.properties.reduce((fields, property) => {
             property.graphqlField.ifJust((field) => {

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

@@ -1,12 +1,11 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-const hasherVariable = code `_hasher`;
+const hasherVariable = code `hasher`;
 export function NamedObjectType_hashFunctionDeclarations() {
-    if (!this.features.has("hash")) {
+    if (!this.configuration.features.has("hash")) {
         return [];
     }
     const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
         ? property.hashStatements({
-            depth: 0,
             variables: {
                 hasher: hasherVariable,
                 value: property.accessExpression({
@@ -18,15 +17,14 @@ export function NamedObjectType_hashFunctionDeclarations() {
     const hashShaclPropertiesStatements = [];
     const hashStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+        hashShaclPropertiesStatements.push(code `${parentObjectType.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
     }
-    hashStatements.push(code `${this.name}.hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
+    hashStatements.push(code `${this.name}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
     hashStatements.push(...this.properties
         .filter((property) => property.kind !== "ShaclProperty")
         .flatMap((property) => property.hashStatements({
-        depth: 0,
         variables: {
             hasher: hasherVariable,
             value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
@@ -35,11 +33,11 @@ export function NamedObjectType_hashFunctionDeclarations() {
     hashStatements.push(code `return ${hasherVariable};`);
     return [
         code `\
-export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
   ${joinCode(hashStatements)}
 }`,
         code `\
-export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${this.thisVariable}: ${this.name}, ${hasherVariable}: HasherT): HasherT {
+export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.name}): HasherT {
   ${joinCode(hashShaclPropertiesStatements)}
 }`,
     ];

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

@@ -1,8 +1,7 @@
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code } from "../ts-poet-wrapper.js";
 export function NamedObjectType_isTypeFunctionDeclaration() {
     return code `\
-export function is${this.name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+export function is${this.name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
   switch (object.${this._discriminantProperty.name}) {
     ${this._discriminantProperty.type.descendantValues
         .concat(this._discriminantProperty.type.ownValues)

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

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