@shaclmate/compiler 2.0.22 → 2.0.24

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

@@ -0,0 +1,315 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Maybe } from "purify-ts";
+import "ts-morph";
+import { Memoize } from "typescript-memoize";
+import { invariant } from "ts-invariant";
+import { Import } from "../Import.js";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { Type as _Type } from "../Type.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+function stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType, stubObjectUnionType, variables, }) {
+    invariant(resolvedObjectUnionType.memberTypes.length ===
+        stubObjectUnionType.memberTypes.length);
+    const caseBlocks = resolvedObjectUnionType.memberTypes.map((resolvedObjectType, objectTypeI) => {
+        return `${resolvedObjectType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${stubObjectUnionType.memberTypes[objectTypeI].newExpression({ parameters: variables.value })};`;
+    });
+    caseBlocks.push(`default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
+    return `switch (${variables.value}.${resolvedObjectUnionType.discriminatorProperty.unsafeCoerce().name}) { ${caseBlocks.join("\n")} }`;
+}
+export class LazyShaclProperty extends ShaclProperty {
+    mutable = false;
+    recursive = false;
+    get graphqlField() {
+        const args = this.type.graphqlArgs;
+        const argsVariable = args.isJust() ? "args" : "_args";
+        return Maybe.of({
+            args,
+            description: this.comment.map(JSON.stringify),
+            name: this.name,
+            resolve: `async (source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: `source.${this.name}` } })}`,
+            type: this.type.graphqlName.toString(),
+        });
+    }
+}
+__decorate([
+    Memoize()
+], LazyShaclProperty.prototype, "graphqlField", null);
+(function (LazyShaclProperty) {
+    class Type extends _Type {
+        discriminatorProperty = Maybe.empty();
+        mutable = false;
+        typeof = "object";
+        resolvedType;
+        runtimeClass;
+        stubType;
+        constructor({ stubType, resolvedType, runtimeClass, }) {
+            super();
+            this.stubType = stubType;
+            this.resolvedType = resolvedType;
+            this.runtimeClass = runtimeClass;
+        }
+        get conversions() {
+            return [
+                {
+                    conversionExpression: (value) => value,
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof ${this.runtimeClass.rawName}`,
+                    sourceTypeName: this.name,
+                },
+            ];
+        }
+        get equalsFunction() {
+            return `((left, right) => ${this.stubType.equalsFunction}(left.${this.runtimeClass.stubPropertyName}, right.${this.runtimeClass.stubPropertyName}))`;
+        }
+        get graphqlName() {
+            return this.resolvedType.graphqlName;
+        }
+        hashStatements({ depth, variables, }) {
+            return this.stubType.hashStatements({
+                depth: depth + 1,
+                variables: {
+                    ...variables,
+                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
+                },
+            });
+        }
+        get jsonName() {
+            return this.stubType.jsonName;
+        }
+        jsonUiSchemaElement(parameters) {
+            return this.stubType.jsonUiSchemaElement(parameters);
+        }
+        jsonZodSchema(parameters) {
+            return this.stubType.jsonZodSchema(parameters);
+        }
+        get name() {
+            return this.runtimeClass.name;
+        }
+        snippetDeclarations(parameters) {
+            return this.stubType
+                .snippetDeclarations(parameters)
+                .concat(this.resolvedType.snippetDeclarations(parameters))
+                .concat(this.runtimeClass.snippetDeclaration);
+        }
+        sparqlConstructTemplateTriples(parameters) {
+            return this.stubType.sparqlConstructTemplateTriples(parameters);
+        }
+        sparqlWherePatterns(parameters) {
+            return this.stubType.sparqlWherePatterns(parameters);
+        }
+        toJsonExpression({ variables, }) {
+            return this.stubType.toJsonExpression({
+                variables: {
+                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
+                },
+            });
+        }
+        toRdfExpression({ variables, }) {
+            return this.stubType.toRdfExpression({
+                variables: {
+                    ...variables,
+                    value: `${variables.value}.${this.runtimeClass.stubPropertyName}`,
+                },
+            });
+        }
+        useImports(parameters) {
+            return this.resolvedType.useImports(parameters).concat(Import.PURIFY);
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Type.prototype, "equalsFunction", null);
+    LazyShaclProperty.Type = Type;
+    class ObjectSetType extends Type {
+        constructor({ resolvedType, stubType, }) {
+            super({
+                resolvedType,
+                runtimeClass: {
+                    name: `${syntheticNamePrefix}LazyObjectSet<${resolvedType.itemType.identifierTypeAlias}, ${resolvedType.itemType.name}, ${stubType.itemType.name}>`,
+                    rawName: `${syntheticNamePrefix}LazyObjectSet`,
+                    snippetDeclaration: SnippetDeclarations.LazyObjectSet,
+                    stubPropertyName: "stubs",
+                },
+                stubType,
+            });
+        }
+        get conversions() {
+            const conversions = super.conversions.concat();
+            if (this.stubType.itemType.kind === "ObjectType") {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
+                });
+            }
+            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
+                this.stubType.itemType.kind === "ObjectUnionType" &&
+                this.resolvedType.itemType.memberTypes.length ===
+                    this.stubType.itemType.memberTypes.length) {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} }), resolver: async () => purify.Either.of(${value} as readonly ${this.resolvedType.itemType.name}[]) })`,
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: `readonly ${this.resolvedType.itemType.name}[]`,
+                });
+            }
+            conversions.push({
+                conversionExpression: () => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: [], resolver: async () => { throw new Error("should never be called"); } })`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+            return conversions;
+        }
+        fromJsonExpression(parameters) {
+            return `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.fromJsonExpression(parameters)}, resolver: () => Promise.resolve(purify.Left(new Error("unable to resolve identifiers deserialized from JSON"))) })`;
+        }
+        fromRdfExpression(parameters) {
+            const { variables } = parameters;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifiers) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.objects}({ where: { identifiers, type: "identifiers" }}) })))`;
+        }
+        get graphqlArgs() {
+            return Maybe.of({
+                limit: {
+                    type: "graphql.GraphQLInt",
+                },
+                offset: {
+                    type: "graphql.GraphQLInt",
+                },
+            });
+        }
+        graphqlResolveExpression({ variables, }) {
+            return `(await ${variables.value}.resolve({ limit: ${variables.args}.limit, offset: ${variables.args}.offset })).unsafeCoerce()`;
+        }
+    }
+    __decorate([
+        Memoize()
+    ], ObjectSetType.prototype, "conversions", null);
+    __decorate([
+        Memoize()
+    ], ObjectSetType.prototype, "graphqlArgs", null);
+    LazyShaclProperty.ObjectSetType = ObjectSetType;
+    class SingleObjectType extends Type {
+        fromJsonExpression(parameters) {
+            return `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(purify.Left(new Error(\`unable to resolve identifier \${rdfjsResource.Resource.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
+        }
+        get graphqlArgs() {
+            return Maybe.empty();
+        }
+        graphqlResolveExpression({ variables, }) {
+            return `(await ${variables.value}.resolve()).unsafeCoerce()`;
+        }
+    }
+    class OptionalObjectType extends SingleObjectType {
+        constructor({ resolvedType, stubType, }) {
+            super({
+                resolvedType,
+                runtimeClass: {
+                    name: `${syntheticNamePrefix}LazyOptionalObject<${resolvedType.itemType.identifierTypeAlias}, ${resolvedType.itemType.name}, ${stubType.itemType.name}>`,
+                    rawName: `${syntheticNamePrefix}LazyOptionalObject`,
+                    snippetDeclaration: SnippetDeclarations.LazyOptionalObject,
+                    stubPropertyName: "stub",
+                },
+                stubType,
+            });
+        }
+        get conversions() {
+            const conversions = super.conversions.concat();
+            if (this.stubType.itemType.kind === "ObjectType") {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}.map(object => ${this.stubType.itemType.newExpression({ parameters: "object" })}), resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
+                    sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
+                    sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
+                }, {
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${this.stubType.itemType.newExpression({ parameters: value })}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.itemType.name,
+                });
+            }
+            else if (this.resolvedType.itemType.kind === "ObjectUnionType" &&
+                this.stubType.itemType.kind === "ObjectUnionType" &&
+                this.resolvedType.itemType.memberTypes.length ===
+                    this.stubType.itemType.memberTypes.length) {
+                const maybeMap = `.map(object => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType.itemType, stubObjectUnionType: this.stubType.itemType, variables: { value: "object" } })} })`;
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${value}${maybeMap}, resolver: async () => purify.Either.of((${value} as purify.Maybe<${this.resolvedType.itemType.name}>).unsafeCoerce()) })`,
+                    sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
+                    sourceTypeName: `purify.Maybe<${this.resolvedType.itemType.name}>`,
+                }, {
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.of(${value})${maybeMap}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.itemType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.itemType.name,
+                });
+            }
+            conversions.push({
+                conversionExpression: () => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: purify.Maybe.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+            return conversions;
+        }
+        fromRdfExpression(parameters) {
+            const { variables } = parameters;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.itemType.objectSetMethodNames.object}(identifier) })))`;
+        }
+        graphqlResolveExpression(parameters) {
+            return `${super.graphqlResolveExpression(parameters)}.extractNullable()`;
+        }
+    }
+    __decorate([
+        Memoize()
+    ], OptionalObjectType.prototype, "conversions", null);
+    LazyShaclProperty.OptionalObjectType = OptionalObjectType;
+    class RequiredObjectType extends SingleObjectType {
+        constructor({ resolvedType, stubType, }) {
+            super({
+                resolvedType,
+                runtimeClass: {
+                    name: `${syntheticNamePrefix}LazyRequiredObject<${resolvedType.identifierTypeAlias}, ${resolvedType.name}, ${stubType.name}>`,
+                    rawName: `${syntheticNamePrefix}LazyRequiredObject`,
+                    snippetDeclaration: SnippetDeclarations.LazyRequiredObject,
+                    stubPropertyName: "stub",
+                },
+                stubType,
+            });
+        }
+        get conversions() {
+            const conversions = super.conversions.concat();
+            if (this.stubType.kind === "ObjectType") {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ${this.stubType.newExpression({ parameters: value })}, resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
+                    // Don't check instanceof value since the ObjectType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.name,
+                });
+            }
+            else if (this.resolvedType.kind === "ObjectUnionType" &&
+                this.stubType.kind === "ObjectUnionType" &&
+                this.resolvedType.memberTypes.length ===
+                    this.stubType.memberTypes.length) {
+                conversions.push({
+                    conversionExpression: (value) => `new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}: ((object: ${this.resolvedType.name}) => { ${stubObjectUnionTypeToResolvedObjectUnionTypeSwitchStatement({ resolvedObjectUnionType: this.resolvedType, stubObjectUnionType: this.stubType, variables: { value: "object" } })} })(${value}), resolver: async () => purify.Either.of(${value} as ${this.resolvedType.name}) })`,
+                    // Don't check instanceof value since the ObjectUnionType may be an interface
+                    // Rely on the fact that this will be the last type check on an object
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                    sourceTypeName: this.resolvedType.name,
+                });
+            }
+            return conversions;
+        }
+        fromRdfExpression(parameters) {
+            const { variables } = parameters;
+            return `${this.stubType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.stubPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.stubPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolvedType.objectSetMethodNames.object}(identifier) })))`;
+        }
+    }
+    LazyShaclProperty.RequiredObjectType = RequiredObjectType;
+})(LazyShaclProperty || (LazyShaclProperty = {}));
+//# sourceMappingURL=LazyShaclProperty.js.map

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

@@ -1,33 +1,34 @@
-import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
-import type { PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../../../enums/index.js";
+import type { PropertyVisibility } from "../../../enums/index.js";
 import type { Import } from "../Import.js";
+import type { ObjectType } from "../ObjectType.js";
 import type { Type } from "../Type.js";
-export declare abstract class Property<TypeT extends {
-    readonly mutable: boolean;
-    readonly name: string;
-}> {
-    /**
-     * Optional get accessor to include in a class declaration of the object type.
-     */
-    abstract readonly classGetAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    /**
-     * Optional property declaration to include in a class declaration of the object type.
-     */
-    abstract readonly classPropertyDeclaration: Maybe<OptionalKind<PropertyDeclarationStructure>>;
+export declare abstract class Property<TypeT extends Pick<Type, "mutable" | "name">> {
     /**
      * Optional property to include in the parameters object of a class constructor.
      */
     abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     /**
-     * Function declaration that takes two values of the property and compares them, returning and EqualsResult.
+     * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
      */
-    abstract readonly equalsFunction: string;
+    abstract readonly equalsFunction: Maybe<string>;
     /**
-     * Signature of the property in an interface version of the object.
+     * Optional get accessor to include in a class declaration of the object type.
+     */
+    abstract readonly getAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    /**
+     * GraphQL.js field definition.
      */
-    abstract readonly interfacePropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    abstract readonly graphqlField: Maybe<{
+        args: Maybe<Record<string, {
+            type: string;
+        }>>;
+        description: Maybe<string>;
+        name: string;
+        resolve: string;
+        type: string;
+    }>;
     /**
      * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
      */
@@ -41,14 +42,17 @@ export declare abstract class Property<TypeT extends {
      */
     readonly name: string;
     /**
-     * Reusable function, type, and other declarations that are not particular to this property but that property-specific code
-     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
-     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
-     * as a snippet and reference it.
-     *
-     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     * Optional property declaration to include in a class declaration of the object type.
      */
-    abstract readonly snippetDeclarations: readonly string[];
+    abstract readonly propertyDeclaration: Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    /**
+     * Signature of the property in an interface version of the object.
+     */
+    abstract readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    /**
+     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
+     */
+    abstract readonly recursive: boolean;
     /**
      * Property type
   .   */
@@ -57,16 +61,10 @@ export declare abstract class Property<TypeT extends {
      * Property visibility: private, protected, public.
      */
     readonly visibility: PropertyVisibility;
-    protected readonly dataFactoryVariable: string;
-    protected readonly objectType: {
-        readonly declarationType: TsObjectDeclarationType;
-        readonly features: Set<TsFeature>;
-        readonly mutable: () => boolean;
-    };
-    constructor({ dataFactoryVariable, name, objectType, type, visibility, }: {
-        dataFactoryVariable: string;
+    protected readonly objectType: ObjectType;
+    constructor({ name, objectType, type, visibility, }: {
         name: string;
-        objectType: Property<TypeT>["objectType"];
+        objectType: ObjectType;
         type: TypeT;
         visibility: PropertyVisibility;
     });
@@ -76,11 +74,12 @@ export declare abstract class Property<TypeT extends {
     abstract get declarationImports(): readonly Import[];
     protected static visibilityToScope(visibility: PropertyVisibility): Scope | undefined;
     /**
-     * Statements to assign the parameter of described by constructorParametersPropertySignature to a class member.
+     * Statements to assign the parameter of described by constructorParametersPropertySignature to a class or interface member.
      */
-    abstract classConstructorStatements(parameters: {
+    abstract constructorStatements(parameters: {
         variables: {
             parameter: string;
+            parameters: string;
         };
     }): readonly string[];
     /**
@@ -92,12 +91,13 @@ export declare abstract class Property<TypeT extends {
         };
     }): readonly string[];
     /**
-     * Statements to deserialize RDF for this property to a typed value of the property.
+     * Statements to deserialize this property on the given rdfjsResource.Resource to a typed value of the property.
      */
     abstract fromRdfStatements(parameters: {
         variables: {
             context: string;
             languageIn: string;
+            objectSet: string;
             resource: string;
         };
     }): readonly string[];
@@ -105,14 +105,6 @@ export declare abstract class Property<TypeT extends {
      * Statements to hash this property using a hasher instance.
      */
     abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    /**
-     * Companion to classConstructorStatements with a similar purpose in an interface's create() function.
-     */
-    abstract interfaceConstructorStatements(parameters: {
-        variables: {
-            parameter: string;
-        };
-    }): readonly string[];
     /**
      * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
      */
@@ -132,6 +124,15 @@ export declare abstract class Property<TypeT extends {
         readonly key: string;
         readonly schema: string;
     }>;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this property but that property-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    abstract snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
     /**
      * An array of SPARQL.js CONSTRUCT template triples for this property as strings (so they can incorporate runtime calls).
      */
@@ -146,6 +147,7 @@ export declare abstract class Property<TypeT extends {
      */
     abstract sparqlWherePatterns(parameters: {
         variables: {
+            languageIn: string;
             subject: string;
             variablePrefix: string;
         };
@@ -164,6 +166,5 @@ export declare abstract class Property<TypeT extends {
     abstract toRdfStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "predicate">;
     }): readonly string[];
-    protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 //# sourceMappingURL=Property.d.ts.map

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

@@ -1,5 +1,4 @@
 import { Scope, } from "ts-morph";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
     /**
      * TypeScript identifier-safe name of the property.
@@ -13,10 +12,8 @@ export class Property {
      * Property visibility: private, protected, public.
      */
     visibility;
-    dataFactoryVariable;
     objectType;
-    constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
-        this.dataFactoryVariable = dataFactoryVariable;
+    constructor({ name, objectType, type, visibility, }) {
         this.name = name;
         this.objectType = objectType;
         this.type = type;
@@ -32,11 +29,5 @@ export class Property {
                 return undefined;
         }
     }
-    rdfjsTermExpression(rdfjsTerm) {
-        return rdfjsTermExpression({
-            dataFactoryVariable: this.dataFactoryVariable,
-            rdfjsTerm,
-        });
-    }
 }
 //# sourceMappingURL=Property.js.map

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

@@ -1,44 +1,39 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { IdentifierType } from "../IdentifierType.js";
 import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 import { Property } from "./Property.js";
-export declare class ShaclProperty extends Property<Type> {
-    readonly mutable: boolean;
-    private readonly comment;
-    private readonly description;
-    private readonly label;
-    private readonly path;
-    constructor({ comment, description, label, mutable, path, ...superParameters }: {
+export declare abstract class ShaclProperty<TypeT extends Type> extends Property<TypeT> {
+    protected readonly comment: Maybe<string>;
+    protected readonly description: Maybe<string>;
+    protected readonly label: Maybe<string>;
+    readonly path: rdfjs.NamedNode;
+    constructor({ comment, description, label, path, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
         label: Maybe<string>;
-        mutable: boolean;
         path: rdfjs.NamedNode;
-        type: Type;
-    } & ConstructorParameters<typeof Property>[0]);
-    get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    } & ConstructorParameters<typeof Property<TypeT>>[0]);
+    get equalsFunction(): Maybe<string>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get declarationImports(): readonly Import[];
-    get equalsFunction(): string;
-    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    constructorStatements({ variables, }: Parameters<Property<TypeT>["constructorStatements"]>[0]): readonly string[];
+    fromJsonStatements({ variables, }: Parameters<Property<TypeT>["fromJsonStatements"]>[0]): readonly string[];
+    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
+    hashStatements(parameters: Parameters<Property<TypeT>["hashStatements"]>[0]): readonly string[];
     get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get snippetDeclarations(): readonly string[];
-    private get declarationComment();
-    private get pathExpression();
-    classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];
-    fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
-    fromRdfStatements({ variables, }: Parameters<Property<Type>["fromRdfStatements"]>[0]): readonly string[];
-    hashStatements(parameters: Parameters<Property<Type>["hashStatements"]>[0]): readonly string[];
-    interfaceConstructorStatements({ variables, }: Parameters<Property<Type>["interfaceConstructorStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: Parameters<Property<Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
-    jsonZodSchema(parameters: Parameters<Property<Type>["jsonZodSchema"]>[0]): ReturnType<Property<Type>["jsonZodSchema"]>;
-    sparqlConstructTemplateTriples({ variables, }: Parameters<Property<Type>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ variables, }: Parameters<Property<Type>["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonObjectMember(parameters: Parameters<Property<Type>["toJsonObjectMember"]>[0]): Maybe<string>;
-    toRdfStatements({ variables, }: Parameters<Property<Type>["toRdfStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema(parameters: Parameters<Property<TypeT>["jsonZodSchema"]>[0]): ReturnType<Property<TypeT>["jsonZodSchema"]>;
+    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get declarationImports(): readonly Import[];
+    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    snippetDeclarations(parameters: Parameters<Property<Type>["snippetDeclarations"]>[0]): readonly string[];
+    fromRdfStatements({ variables, }: Parameters<Property<TypeT>["fromRdfStatements"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples({ variables, }: Parameters<Property<TypeT>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ variables, }: Parameters<Property<TypeT>["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonObjectMember(parameters: Parameters<Property<TypeT>["toJsonObjectMember"]>[0]): Maybe<string>;
+    toRdfStatements({ variables, }: Parameters<Property<TypeT>["toRdfStatements"]>[0]): readonly string[];
+    protected get declarationComment(): string | undefined;
+    protected get predicate(): string;
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map