@shaclmate/compiler 4.0.90 → 4.0.92

package/dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.d.ts

@@ -4,8 +4,8 @@ import type { Reusables } from "../Reusables.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import type { TsGenerator } from "../TsGenerator.js";
 import type { Type } from "../Type.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
+import type { Code } from "../ts-poet-wrapper.js";
+export declare abstract class ObjectType_AbstractProperty {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly objectType: {
@@ -22,7 +22,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
     /**
      * Property declaration to include in the type declaration of the ObjectType.
      */
-    abstract readonly declaration: Code;
+    abstract readonly declaration: Maybe<Code>;
     /**
      * Optional property in the ObjectType's filter.
      */
@@ -47,7 +47,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *
      * Only specified if different from declaration.
      */
-    abstract readonly hashFunctionParameter: Code;
+    abstract readonly hashFunctionParameter: Maybe<Code>;
     /**
      * zod object key: schema.
      */
@@ -83,11 +83,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      * TypeScript type describing .schema.
      */
     abstract readonly schemaType: Maybe<Code>;
-    /**
-     * Property type
-  .   */
-    readonly type: TypeT;
-    constructor({ configuration, logger, name, objectType, reusables, type, }: {
+    constructor({ configuration, logger, name, objectType, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         name: string;
@@ -95,22 +91,36 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
             readonly name: Maybe<string>;
         };
         reusables: Reusables;
-        type: TypeT;
     });
     /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     * Initializer (name: value) from a constructor parameter.
      */
-    accessExpression({ variables }: {
+    abstract constructorInitializer(parameters: {
         variables: {
-            object: Code;
+            parameters: Code;
         };
-    }): Code;
+    }): Maybe<Code>;
     /**
-     * Initializer (name: value) from a constructor parameter.
+     * An expression that compares two values of this property, returning a $EqualsResult.
      */
-    abstract constructorInitializer(parameters: {
+    abstract equalsExpression(parameters: {
         variables: {
-            parameters: Code;
+            leftObject: Code;
+            rightObject: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Expression to filter this property using an instance of the ObjectType's filter.
+     *
+     * Parameters:
+     *   variables: runtime variables
+     *     - filter: an instance of the object's filterType or undefined
+     *     - object: an instance of the object
+     */
+    abstract filterExpression(parameters: {
+        variables: {
+            filter: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     /**
@@ -136,7 +146,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
     abstract hashStatements(parameters: {
         variables: {
             hasher: Code;
-            value: Code;
+            object: Code;
         };
     }): readonly Code[];
     /**
@@ -154,6 +164,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *   variables: runtime variables
      *     - filter: an instance of the object's filterType or undefined
      *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - ignoreRdfType: whether the RDF type of objects/object unions should be ignored
      *     - variablePrefix: prefix to use for new SPARQL variables
      *
      * Returns a (runtime) array of sparqljs.Triple.
@@ -162,6 +173,7 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
         variables: {
             filter: Code;
             focusIdentifier: Code;
+            ignoreRdfType: Code;
             variablePrefix: Code;
         };
     }): Maybe<Code>;
@@ -172,6 +184,8 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      *   variables: (at runtime)
      *     - filter: an instance of the object's filterType or undefined
      *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - ignoreRdfType: whether the RDF type of objects/object unions should be ignored
+     *     - schema: an instance of the object's schema if available
      *     - preferredLanguages: array of preferred language code (strings)
      *     - variablePrefix: prefix to use for new SPARQL variables
      *
@@ -183,7 +197,9 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
         variables: {
             filter: Code;
             focusIdentifier: Code;
+            ignoreRdfType: Code;
             preferredLanguages: Code;
+            schema: Maybe<Code>;
             variablePrefix: Code;
         };
     }): Maybe<{
@@ -195,21 +211,23 @@ export declare abstract class ObjectType_AbstractProperty<TypeT extends Pick<Typ
      */
     abstract toJsonInitializer(parameters: {
         variables: {
-            value: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     /**
      * Statements to serialize this property to an RDF resource.
      */
     abstract toRdfRdfResourceValuesStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
+        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath" | "value"> & {
+            object: Code;
+        };
     }): readonly Code[];
     /**
      * Initializer (name: value) to serialize this property to a human-readable string (toString).
      */
     abstract toStringInitializer(parameters: {
         variables: {
-            value: Code;
+            object: Code;
         };
     }): Maybe<Code>;
     protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;

package/dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.js

@@ -1,5 +1,4 @@
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { code } from "../ts-poet-wrapper.js";
 export class ObjectType_AbstractProperty {
     configuration;
     logger;
@@ -9,29 +8,18 @@ export class ObjectType_AbstractProperty {
      * TypeScript identifier-safe name of the property.
      */
     name;
-    /**
-     * Property type
-  .   */
-    type;
-    constructor({ configuration, logger, name, objectType, reusables, type, }) {
+    constructor({ configuration, logger, name, objectType, reusables, }) {
         this.configuration = configuration;
         this.logger = logger;
         this.name = name;
         this.objectType = objectType;
         this.reusables = reusables;
-        this.type = type;
         this.rdfjsTermExpression = rdfjsTermExpression.bind({
             imports: this.reusables.imports,
             logger: this.logger,
             snippets: this.reusables.snippets,
         });
     }
-    /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
-     */
-    accessExpression({ variables }) {
-        return code `${variables.object}.${this.name}`;
-    }
     rdfjsTermExpression;
 }
 //# sourceMappingURL=ObjectType_AbstractProperty.js.map

package/dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.d.ts

@@ -1,45 +1,37 @@
 import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
-export declare class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type> {
-    readonly constructorParameter: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["constructorParameter"];
-    readonly declaration: Code;
-    readonly filterProperty: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["filterProperty"];
-    readonly graphqlField: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["graphqlField"];
-    readonly hashFunctionParameter: Code;
+export declare class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
+    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
+    readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
     readonly value: string;
     constructor({ configuration, value, ...superParameters }: {
         value: string;
-    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name" | "type">);
+    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
+    get declaration(): Maybe<Code>;
+    get hashFunctionParameter(): Maybe<Code>;
     get jsonName(): string;
-    get jsonSchema(): ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonSchema"];
+    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
     get values(): readonly string[];
     private get constValue();
     constructorInitializer(): Maybe<Code>;
+    equalsExpression(): Maybe<Code>;
+    filterExpression(): Maybe<Code>;
     fromJsonInitializer(): Maybe<Code>;
     fromRdfResourceValuesInitializer(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression(): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
+    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer(): Maybe<Code>;
 }
-export declare namespace ObjectType_DiscriminantProperty {
-    class Type {
-        readonly value: string;
-        readonly filterFunction: Code;
-        readonly mutable = false;
-        constructor(value: string);
-        get expression(): Code;
-        get schema(): Code;
-    }
-}
 //# sourceMappingURL=ObjectType_DiscriminantProperty.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.js

@@ -10,10 +10,8 @@ import { code, literalOf } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
     constructorParameter = Maybe.empty();
-    declaration = code `readonly ${this.name}: ${this.type.expression};`;
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
-    hashFunctionParameter = code `readonly ${this.name}?: ${this.type.expression};`;
     kind = "Discriminant";
     mutable = false;
     recursive = false;
@@ -23,10 +21,15 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
             ...superParameters,
             configuration,
             name: configuration.objectDiscriminantProperty.name,
-            type: new ObjectType_DiscriminantProperty.Type(value),
         });
         this.value = value;
     }
+    get declaration() {
+        return Maybe.of(code `readonly ${this.name}: ${literalOf(this.value)};`);
+    }
+    get hashFunctionParameter() {
+        return Maybe.of(code `readonly ${this.name}?: ${literalOf(this.value)};`);
+    }
     get jsonName() {
         return this.configuration.objectDiscriminantProperty.jsonName;
     }
@@ -37,7 +40,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         });
     }
     get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
+        return Maybe.of(code `readonly "${this.jsonName}": ${literalOf(this.value)}`);
     }
     get schema() {
         return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
@@ -54,6 +57,12 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     constructorInitializer() {
         return Maybe.empty();
     }
+    equalsExpression() {
+        return Maybe.empty();
+    }
+    filterExpression() {
+        return Maybe.empty();
+    }
     fromJsonInitializer() {
         return Maybe.empty();
     }
@@ -62,7 +71,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     }
     hashStatements({ variables, }) {
         return [
-            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}); }`,
+            code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}); }`,
         ];
     }
     jsonUiSchemaElement({ variables, }) {
@@ -76,7 +85,7 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         return Maybe.empty();
     }
     toJsonInitializer({ variables, }) {
-        return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
+        return Maybe.of(code `"${this.jsonName}": ${variables.object}.${this.name}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
@@ -85,6 +94,12 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         return Maybe.empty();
     }
 }
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "hashFunctionParameter", null);
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "jsonName", null);
@@ -97,27 +112,10 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "values", null);
-(function (ObjectType_DiscriminantProperty) {
-    class Type {
-        value;
-        filterFunction = code `nonextant`;
-        mutable = false;
-        constructor(value) {
-            this.value = value;
-        }
-        get expression() {
-            return code `${literalOf(this.value)}`;
-        }
-        get schema() {
-            throw new Error("should never be called");
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Type.prototype, "expression", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "schema", null);
-    ObjectType_DiscriminantProperty.Type = Type;
-})(ObjectType_DiscriminantProperty || (ObjectType_DiscriminantProperty = {}));
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "equalsExpression", null);
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "filterExpression", null);
 //# sourceMappingURL=ObjectType_DiscriminantProperty.js.map

package/dist/generators/ts/_ObjectType/ObjectType_IdentifierProperty.d.ts

@@ -4,40 +4,45 @@ import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
-export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty<BlankNodeType | IdentifierType | IriType> {
+export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     readonly kind = "Identifier";
     readonly mutable = false;
     readonly recursive = false;
+    readonly type: BlankNodeType | IdentifierType | IriType;
+    constructor({ type, ...superParameters }: {
+        type: BlankNodeType | IdentifierType | IriType;
+    } & ConstructorParameters<typeof ObjectType_AbstractProperty>[0]);
     get constructorParameter(): Maybe<{
         hasQuestionToken: boolean;
         signature: Code;
     }>;
-    get declaration(): Code;
+    get declaration(): Maybe<Code>;
+    equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get graphqlField(): ObjectType_AbstractProperty<IdentifierType>["graphqlField"];
-    get hashFunctionParameter(): Code;
-    get jsonSchema(): ObjectType_AbstractProperty<IdentifierType>["jsonSchema"];
+    filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
+    get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
+    get hashFunctionParameter(): Maybe<Code>;
+    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
     private get typeExpression();
     private get typeSchemaVariable();
-    accessExpression({ variables, }: Parameters<ObjectType_AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
-    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["sparqlWherePatternsExpression"]>[0]): Maybe<{
+    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): Maybe<{
         condition: Code;
         patterns: Code;
     }>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty<IdentifierType>["toJsonInitializer"]>[0]): Maybe<Code>;
+    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringInitializer(parameters: Parameters<ObjectType_AbstractProperty<IdentifierType>["toStringInitializer"]>[0]): Maybe<Code>;
+    toStringInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toStringInitializer"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_IdentifierProperty.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_IdentifierProperty.js

@@ -15,6 +15,11 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     kind = "Identifier";
     mutable = false;
     recursive = false;
+    type;
+    constructor({ type, ...superParameters }) {
+        super(superParameters);
+        this.type = type;
+    }
     get constructorParameter() {
         let hasQuestionToken = false;
         const typeExpressions = [code `(() => ${this.typeExpression})`];
@@ -33,7 +38,14 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         });
     }
     get declaration() {
-        return code `readonly ${this.name}: () => ${this.typeExpression};`;
+        return Maybe.of(code `readonly ${this.name}: () => ${this.typeExpression};`);
+    }
+    equalsExpression({ variables, }) {
+        return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${this.type.equalsFunction}, name: ${literalOf(this.name)} },
+        [left, ${variables.leftObject}.${this.name}()],
+        [right, ${variables.rightObject}.${this.name}()],
+      )`);
     }
     get filterProperty() {
         return Maybe.of({
@@ -41,6 +53,9 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             type: this.type.filterType,
         });
     }
+    filterExpression({ variables, }) {
+        return Maybe.of(code `${this.type.filterFunction}(${variables.filter}.${this.name}, ${variables.object}.${this.name}())`);
+    }
     get graphqlField() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         invariant(this.name.startsWith(syntheticNamePrefix));
@@ -48,12 +63,12 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.type.stringifyFunction}(${this.accessExpression({ variables: { object: code `source` } })})`,
+            resolve: code `(source) => ${this.type.stringifyFunction}(source.${this.name}())`,
             type: this.type.graphqlType.expression,
         });
     }
     get hashFunctionParameter() {
-        return code `readonly ${this.name}?: () => ${this.typeExpression};`;
+        return Maybe.of(code `readonly ${this.name}?: () => ${this.typeExpression};`);
     }
     get jsonSchema() {
         let schema;
@@ -95,9 +110,6 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             .map((name) => code `${name}.schema.properties.${this.name}.type`)
             .orDefaultLazy(() => this.type.schema);
     }
-    accessExpression({ variables, }) {
-        return code `${variables.object}.${this.name}()`;
-    }
     constructorInitializer({ variables, }) {
         const nodeKinds = this.type.nodeKinds;
         let conversionFunction;
@@ -131,7 +143,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     }
     hashStatements({ variables, }) {
         return [
-            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}().value); }`,
+            code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}().value); }`,
         ];
     }
     jsonUiSchemaElement({ variables, }) {
@@ -159,9 +171,9 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         const valueToNodeKinds = nodeKinds.map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":
-                    return code `\`_:\${${variables.value}.value}\``;
+                    return code `\`_:\${${variables.object}.${this.name}().value}\``;
                 case "IRI":
-                    return code `${variables.value}.value`;
+                    return code `${variables.object}.${this.name}().value`;
                 default:
                     throw new RangeError(nodeKind);
             }
@@ -170,13 +182,13 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             return Maybe.of(code `"@id": ${valueToNodeKinds[0]}`);
         }
         invariant(valueToNodeKinds.length === 2);
-        return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
+        return Maybe.of(code `"@id": ${variables.object}.${this.name}().termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
     }
-    toStringInitializer(parameters) {
-        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression(parameters)}`);
+    toStringInitializer({ variables, }) {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toStringExpression({ variables: { value: code `${variables.object}.${this.name}()` } })}`);
     }
 }
 __decorate([

package/dist/generators/ts/_ObjectType/ObjectType_Property.d.ts

@@ -1,6 +1,7 @@
 import type { Type } from "../Type.js";
 import type { ObjectType_DiscriminantProperty } from "./ObjectType_DiscriminantProperty.js";
 import type { ObjectType_IdentifierProperty } from "./ObjectType_IdentifierProperty.js";
+import type { ObjectType_RdfTypeProperty } from "./ObjectType_RdfTypeProperty.js";
 import type { ObjectType_ShaclProperty } from "./ObjectType_ShaclProperty.js";
-export type ObjectType_Property = ObjectType_IdentifierProperty | ObjectType_ShaclProperty<Type> | ObjectType_DiscriminantProperty;
+export type ObjectType_Property = ObjectType_IdentifierProperty | ObjectType_ShaclProperty<Type> | ObjectType_DiscriminantProperty | ObjectType_RdfTypeProperty;
 //# sourceMappingURL=ObjectType_Property.d.ts.map

package/dist/generators/ts/_ObjectType/ObjectType_RdfTypeProperty.d.ts

@@ -0,0 +1,37 @@
+import type { NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { type Code } from "../ts-poet-wrapper.js";
+import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
+export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
+    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly declaration: ObjectType_AbstractProperty["declaration"];
+    readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
+    readonly fromRdfType: NamedNode;
+    readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
+    readonly hashFunctionParameter: ObjectType_AbstractProperty["hashFunctionParameter"];
+    readonly jsonSchema: ObjectType_AbstractProperty["jsonSchema"];
+    readonly jsonSignature: ObjectType_AbstractProperty["jsonSignature"];
+    readonly kind = "RdfType";
+    readonly mutable = false;
+    readonly recursive = false;
+    readonly toRdfTypes: readonly NamedNode[];
+    constructor({ configuration, fromRdfType, toRdfTypes, ...superParameters }: {
+        fromRdfType: NamedNode;
+        toRdfTypes: readonly NamedNode[];
+    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    constructorInitializer(): Maybe<Code>;
+    equalsExpression(): Maybe<Code>;
+    filterExpression(): Maybe<Code>;
+    fromJsonInitializer(): Maybe<Code>;
+    fromRdfResourceValuesInitializer(): Maybe<Code>;
+    hashStatements(): readonly Code[];
+    jsonUiSchemaElement(): Maybe<Code>;
+    sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
+    toJsonInitializer(): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringInitializer(): Maybe<Code>;
+}
+//# sourceMappingURL=ObjectType_RdfTypeProperty.d.ts.map