@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/TsGenerator.js

@@ -8,17 +8,28 @@ import { IriType } from "./IriType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
 import { Reusables } from "./Reusables.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
     typeFactory;
+    configuration;
     logger;
     reusables;
-    constructor({ logger }) {
+    constructor({ configuration, logger, }) {
+        if (!configuration) {
+            configuration = TsGenerator.Configuration.default_;
+        }
+        this.configuration = {
+            ...configuration,
+            features: TsGenerator.Configuration.inferFeatures(configuration.features),
+        };
         this.logger = logger;
-        this.reusables = new Reusables({ logger });
+        this.reusables = new Reusables({
+            configuration: this.configuration,
+            logger,
+        });
         this.typeFactory = new TypeFactory({
+            configuration: this.configuration,
             logger,
             reusables: this.reusables,
         });
@@ -52,7 +63,7 @@ export class TsGenerator {
             case 0:
                 break;
             case 1:
-                declarations.push(code `type ${syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                declarations.push(code `type ${this.configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
                 break;
             default: {
                 const uberObjectUnionType = this.synthesizeUberObjectUnionType(namedObjectTypesToposorted.toReversed());
@@ -89,6 +100,7 @@ export class TsGenerator {
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
                 comment: Maybe.empty(),
+                configuration: this.configuration,
                 label: Maybe.empty(),
                 logger: this.logger,
                 reusables: this.reusables,
@@ -99,6 +111,7 @@ export class TsGenerator {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
                         comment: Maybe.empty(),
+                        configuration: this.configuration,
                         label: Maybe.empty(),
                         logger: this.logger,
                         reusables: this.reusables,
@@ -107,6 +120,7 @@ export class TsGenerator {
                 case "IRI":
                     identifierType = new IriType({
                         comment: Maybe.empty(),
+                        configuration: this.configuration,
                         hasValues: [],
                         in_: [],
                         label: Maybe.empty(),
@@ -118,13 +132,7 @@ export class TsGenerator {
         }
         return new NamedObjectUnionType({
             comment: Maybe.empty(),
-            features: filteredNamedObjectTypes.reduce((features, namedObjectType) => {
-                for (const feature of namedObjectType.features) {
-                    features.add(feature);
-                }
-                features.delete("graphql");
-                return features;
-            }, new Set()),
+            configuration: this.configuration,
             identifierType,
             label: Maybe.empty(),
             logger: this.logger,
@@ -132,10 +140,31 @@ export class TsGenerator {
                 discriminantValue: Maybe.empty(),
                 type: namedObjectType,
             })),
-            name: `${syntheticNamePrefix}Object`,
+            name: `${this.configuration.syntheticNamePrefix}Object`,
             recursive: false,
             reusables: this.reusables,
+            synthetic: true,
         });
     }
 }
+(function (TsGenerator) {
+    let Configuration;
+    (function (Configuration) {
+        Configuration.default_ = {
+            features: new Set(["create", "equals", "hash", "json", "rdf"]),
+            syntheticNamePrefix: "$",
+        };
+        function inferFeatures(features) {
+            const inferredFeatures = new Set(features);
+            if (inferredFeatures.has("graphql") || inferredFeatures.has("sparql")) {
+                inferredFeatures.add("rdf");
+            }
+            if (inferredFeatures.has("json") || inferredFeatures.has("rdf")) {
+                inferredFeatures.add("create");
+            }
+            return inferredFeatures;
+        }
+        Configuration.inferFeatures = inferFeatures;
+    })(Configuration = TsGenerator.Configuration || (TsGenerator.Configuration = {}));
+})(TsGenerator || (TsGenerator = {}));
 //# sourceMappingURL=TsGenerator.js.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -6,19 +6,22 @@ import { NamedObjectType } from "./NamedObjectType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { NamedUnionType } from "./NamedUnionType.js";
 import type { Reusables } from "./Reusables.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
+    private readonly configuration;
+    private readonly logger;
+    private readonly reusables;
     private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
-    private readonly logger;
-    private readonly reusables;
-    constructor({ logger, reusables }: {
+    constructor({ configuration, logger, reusables, }: {
+        configuration: TsGenerator.Configuration;
         logger: Logger;
         reusables: Reusables;
     });
-    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
     createNamedObjectType(astType: ast.ObjectType): NamedObjectType;
+    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
@@ -36,5 +39,6 @@ export declare class TypeFactory {
     private createOptionType;
     private createSetType;
     private createTermType;
+    private tsName;
 }
 //# sourceMappingURL=TypeFactory.d.ts.map

package/dist/generators/ts/TypeFactory.js

@@ -30,43 +30,20 @@ import { NamedUnionType } from "./NamedUnionType.js";
 import { OptionType } from "./OptionType.js";
 import { SetType } from "./SetType.js";
 import { StringType } from "./StringType.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TermType } from "./TermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class TypeFactory {
+    configuration;
+    logger;
+    reusables;
     cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
-    logger;
-    reusables;
-    constructor({ logger, reusables }) {
+    constructor({ configuration, logger, reusables, }) {
+        this.configuration = configuration;
         this.logger = logger;
         this.reusables = reusables;
     }
-    createNamedObjectUnionType(astType) {
-        {
-            const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedNamedObjectUnionType) {
-                return cachedNamedObjectUnionType;
-            }
-        }
-        const namedObjectUnionType = new NamedObjectUnionType({
-            comment: astType.comment,
-            features: astType.tsFeatures,
-            identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
-            label: astType.label,
-            logger: this.logger,
-            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
-                discriminantValue: Maybe.empty(),
-                type: this.createNamedObjectType(namedObjectType),
-            })),
-            name: tsName(astType.name.unsafeCoerce()),
-            recursive: astType.recursive,
-            reusables: this.reusables,
-        });
-        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
-        return namedObjectUnionType;
-    }
     createNamedObjectType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
@@ -75,13 +52,13 @@ export class TypeFactory {
             }
         }
         const identifierType = this.createIdentifierType(astType.identifierType);
-        const name = tsName(astType.name.unsafeCoerce(), {
+        const name = this.tsName(astType.name.unsafeCoerce(), {
             synthetic: astType.synthetic,
         });
         const namedObjectType = new NamedObjectType({
             comment: astType.comment,
+            configuration: this.configuration,
             extern: astType.extern,
-            features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
@@ -95,8 +72,9 @@ export class TypeFactory {
                     discriminantDescendantValues.add(descendantObjectType.discriminantValue);
                 }
                 return new NamedObjectType.DiscriminantProperty({
+                    configuration: this.configuration,
                     logger: this.logger,
-                    name: `${syntheticNamePrefix}type`,
+                    name: `${this.configuration.syntheticNamePrefix}type`,
                     namedObjectType,
                     reusables: this.reusables,
                     type: new NamedObjectType.DiscriminantProperty.Type({
@@ -116,7 +94,7 @@ export class TypeFactory {
                     if (left.order > right.order) {
                         return 1;
                     }
-                    return tsName(left.name).localeCompare(tsName(right.name));
+                    return this.tsName(left.name).localeCompare(this.tsName(right.name));
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
@@ -124,8 +102,9 @@ export class TypeFactory {
                 }));
                 properties.splice(0, 0, namedObjectType._discriminantProperty);
                 properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
+                    configuration: this.configuration,
                     logger: this.logger,
-                    name: `${syntheticNamePrefix}identifier`,
+                    name: `${this.configuration.syntheticNamePrefix}identifier`,
                     namedObjectType,
                     reusables: this.reusables,
                     type: identifierType,
@@ -143,6 +122,31 @@ export class TypeFactory {
         this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectType);
         return namedObjectType;
     }
+    createNamedObjectUnionType(astType) {
+        {
+            const cachedNamedObjectUnionType = this.cachedNamedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
+            if (cachedNamedObjectUnionType) {
+                return cachedNamedObjectUnionType;
+            }
+        }
+        const namedObjectUnionType = new NamedObjectUnionType({
+            comment: astType.comment,
+            configuration: this.configuration,
+            identifierType: this.createIdentifierType(ast.ObjectCompoundType.identifierType(astType)),
+            label: astType.label,
+            logger: this.logger,
+            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((namedObjectType) => ({
+                discriminantValue: Maybe.empty(),
+                type: this.createNamedObjectType(namedObjectType),
+            })),
+            name: this.tsName(astType.name.unsafeCoerce()),
+            recursive: astType.recursive,
+            reusables: this.reusables,
+            synthetic: astType.synthetic,
+        });
+        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
+        return namedObjectUnionType;
+    }
     createType(astType, parameters) {
         switch (astType.kind) {
             case "BlankNodeType":
@@ -184,7 +188,7 @@ export class TypeFactory {
         return astType.name
             .map((name) => new NamedUnionType({
             comment: astType.comment,
-            features: astType.tsFeatures,
+            configuration: this.configuration,
             identifierType: Maybe.empty(),
             label: astType.label,
             logger: this.logger,
@@ -198,6 +202,7 @@ export class TypeFactory {
         }))
             .orDefaultLazy(() => new AnonymousUnionType({
             comment: astType.comment,
+            configuration: this.configuration,
             label: astType.label,
             identifierType: Maybe.empty(),
             logger: this.logger,
@@ -212,6 +217,7 @@ export class TypeFactory {
     createBlankNodeType(astType) {
         return new BlankNodeType({
             comment: astType.comment,
+            configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
             reusables: this.reusables,
@@ -224,6 +230,7 @@ export class TypeFactory {
         invariant(DefaultValueType.isItemType(itemType));
         return new DefaultValueType({
             comment: astType.comment,
+            configuration: this.configuration,
             defaultValue: astType.defaultValue,
             itemType,
             label: astType.label,
@@ -238,6 +245,7 @@ export class TypeFactory {
             case "IdentifierType":
                 return new IdentifierType({
                     comment: astType.comment,
+                    configuration: this.configuration,
                     label: astType.label,
                     logger: this.logger,
                     reusables: this.reusables,
@@ -249,6 +257,7 @@ export class TypeFactory {
     createIriType(astType) {
         return new IriType({
             comment: astType.comment,
+            configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
@@ -259,6 +268,7 @@ export class TypeFactory {
     createLazyObjectOptionType(astType) {
         return new LazyObjectOptionType({
             comment: astType.comment,
+            configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
             partialType: this.createOptionType(astType.partialType),
@@ -269,6 +279,7 @@ export class TypeFactory {
     createLazyObjectSetType(astType) {
         return new LazyObjectSetType({
             comment: astType.comment,
+            configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
             partialType: this.createSetType(astType.partialType),
@@ -279,6 +290,7 @@ export class TypeFactory {
     createLazyObjectType(astType) {
         return new LazyObjectType({
             comment: astType.comment,
+            configuration: this.configuration,
             label: astType.label,
             logger: this.logger,
             partialType: this.createType(astType.partialType),
@@ -291,6 +303,7 @@ export class TypeFactory {
         invariant(ListType.isItemType(itemType));
         return new ListType({
             comment: astType.comment,
+            configuration: this.configuration,
             identifierNodeKind: astType.identifierNodeKind,
             itemType,
             label: astType.label,
@@ -327,6 +340,7 @@ export class TypeFactory {
                     case "bigdecimal":
                         return new BigDecimalType({
                             comment: astType.comment,
+                            configuration: this.configuration,
                             hasValues: astType.hasValues,
                             in_: astType.in_,
                             label: astType.label,
@@ -337,6 +351,7 @@ export class TypeFactory {
                     case "bigint":
                         return new BigIntType({
                             comment: astType.comment,
+                            configuration: this.configuration,
                             datatype,
                             hasValues: astType.hasValues,
                             in_: astType.in_,
@@ -349,6 +364,7 @@ export class TypeFactory {
                     case "boolean":
                         return new BooleanType({
                             comment: astType.comment,
+                            configuration: this.configuration,
                             datatype,
                             hasValues: astType.hasValues,
                             label: astType.label,
@@ -362,6 +378,7 @@ export class TypeFactory {
                     case "datetime":
                         return new (datatypeDefinition.kind === "date" ? DateType : DateTimeType)({
                             comment: astType.comment,
+                            configuration: this.configuration,
                             datatype,
                             hasValues: astType.hasValues,
                             in_: astType.in_,
@@ -377,6 +394,7 @@ export class TypeFactory {
                     case "int":
                         return new (datatypeDefinition.kind === "float" ? FloatType : IntType)({
                             comment: astType.comment,
+                            configuration: this.configuration,
                             datatype,
                             hasValues: astType.hasValues,
                             in_: astType.in_,
@@ -392,6 +410,7 @@ export class TypeFactory {
                         if (!datatype.equals(rdf.langString)) {
                             return new StringType({
                                 comment: astType.comment,
+                                configuration: this.configuration,
                                 datatype,
                                 hasValues: astType.hasValues,
                                 in_: astType.in_,
@@ -420,6 +439,7 @@ export class TypeFactory {
         // }
         return new LiteralType({
             comment: astType.comment,
+            configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
@@ -437,13 +457,14 @@ export class TypeFactory {
         }
         const property = new NamedObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
+            configuration: this.configuration,
             description: astObjectTypeProperty.description,
             display: astObjectTypeProperty.display,
             label: astObjectTypeProperty.label,
             logger: this.logger,
             mutable: astObjectTypeProperty.mutable,
             namedObjectType,
-            name: tsName(astObjectTypeProperty.name),
+            name: this.tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
             reusables: this.reusables,
@@ -457,6 +478,7 @@ export class TypeFactory {
         invariant(OptionType.isItemType(itemType));
         return new OptionType({
             comment: astType.comment,
+            configuration: this.configuration,
             itemType,
             label: astType.label,
             logger: this.logger,
@@ -468,6 +490,7 @@ export class TypeFactory {
         invariant(SetType.isItemType(itemType));
         return new SetType({
             comment: astType.comment,
+            configuration: this.configuration,
             itemType,
             label: astType.label,
             logger: this.logger,
@@ -479,6 +502,7 @@ export class TypeFactory {
     createTermType(astType) {
         return new TermType({
             comment: astType.comment,
+            configuration: this.configuration,
             hasValues: astType.hasValues,
             in_: astType.in_,
             label: astType.label,
@@ -487,21 +511,21 @@ export class TypeFactory {
             reusables: this.reusables,
         });
     }
-}
-function tsName(name, options) {
-    if (name[0] === "$") {
-        return name;
-    }
-    // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
-    if (reservedTsIdentifiers.has(name)) {
-        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
-        return `$_${name}$`;
-    }
-    let tsName = name.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
-    if (options?.synthetic) {
-        tsName = `${syntheticNamePrefix}${tsName}`;
+    tsName(name, options) {
+        if (name[0] === "$") {
+            return name;
+        }
+        // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
+        if (reservedTsIdentifiers.has(name)) {
+            // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+            return `$_${name}$`;
+        }
+        let tsName = name.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
+        if (options?.synthetic) {
+            tsName = `${this.configuration.syntheticNamePrefix}${tsName}`;
+        }
+        return tsName;
     }
-    return tsName;
 }
 const reservedTsIdentifiers = reservedTsIdentifiers_({
     includeGlobalProperties: true,

package/dist/generators/ts/ZodGenerator.js

@@ -3,14 +3,17 @@ import * as ast from "../../ast/index.js";
 import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
 import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
 import { Reusables } from "./Reusables.js";
+import { TsGenerator } from "./TsGenerator.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ZodGenerator {
     reusables;
     typeFactory;
     constructor({ logger }) {
-        this.reusables = new Reusables({ logger });
+        const configuration = TsGenerator.Configuration.default_;
+        this.reusables = new Reusables({ configuration, logger });
         this.typeFactory = new TypeFactory({
+            configuration,
             logger,
             reusables: this.reusables,
         });
@@ -20,10 +23,10 @@ export class ZodGenerator {
         for (const namedObjectType of ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => this.typeFactory.createNamedObjectType(astObjectType))) {
             declarations.push(code `\
 export namespace ${namedObjectType.name} {
-  ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
+  ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.call(namedObjectType).toList())}
 
   export namespace Json {
-    ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.bind(namedObjectType)().toList())}
+    ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.call(namedObjectType).toList())}
   }
 }`);
         }

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

@@ -3,17 +3,18 @@ import type { Logger } from "ts-log";
 import type { NamedObjectType } from "../NamedObjectType.js";
 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 AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
+    protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly namedObjectType: NamedObjectType;
     protected readonly reusables: Reusables;
-    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
     /**
-     * Optional property to include in the parameters object of a class constructor.
+     * Optional parameter to include in the parameters object of constructor function.
      */
-    abstract readonly constructorParametersSignature: Maybe<Code>;
+    abstract readonly constructorParameter: Maybe<Code>;
     /**
      * Property declaration to include in a class or interface declaration of the object type.
      */
@@ -38,18 +39,18 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         type: Code;
     }>;
     /**
-     * zod Object key: schema pair on the property serialized by toJsonObjectMember.
+     * zod object key: schema.
      */
     abstract readonly jsonSchema: Maybe<{
         readonly key: string;
         readonly schema: Code;
     }>;
     /**
-     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     * Signature of the property when serialized to JSON.
      */
     abstract readonly jsonSignature: Maybe<Code>;
     /**
-     * Property type discriminator e.g., "ShaclProperty".
+     * Property type discriminant e.g., "ShaclProperty".
      */
     abstract readonly kind: string;
     /**
@@ -68,7 +69,8 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property type
   .   */
     readonly type: TypeT;
-    constructor({ logger, name, namedObjectType, reusables, type, }: {
+    constructor({ configuration, logger, name, namedObjectType, reusables, type, }: {
+        configuration: TsGenerator.Configuration;
         logger: Logger;
         name: string;
         namedObjectType: NamedObjectType;
@@ -92,26 +94,25 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         };
     }): Code;
     /**
-     * Statements to assign the parameter of described by constructorParametersSignature to a class or interface member.
+     * Initializer (name: value) from a constructor parameter.
      */
-    abstract constructorStatements(parameters: {
+    abstract constructorInitializer(parameters: {
         variables: {
-            parameter: Code;
             parameters: Code;
         };
-    }): readonly Code[];
+    }): Maybe<Code>;
     /**
-     * Expression to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
+     * Initializer (name: value) from a JSON object.
      */
-    abstract fromJsonExpression(parameters: {
+    abstract fromJsonInitializer(parameters: {
         variables: {
             jsonObject: Code;
         };
     }): Maybe<Code>;
     /**
-     * Expression to deserialize this property on the given rdfjsResource.Resource to a Either<Error, this property type>.
+     * Initializer (name: value) from a rdfjsResource.Resource to a Either<Error, this property type>.
      */
-    abstract fromRdfResourceValuesExpression(parameters: {
+    abstract fromRdfResourceValuesInitializer(parameters: {
         variables: {
             context: Code;
             graph: Code;
@@ -123,7 +124,12 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Statements to hash this property using a hasher instance.
      */
-    abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly Code[];
+    abstract hashStatements(parameters: {
+        variables: {
+            hasher: Code;
+            value: Code;
+        };
+    }): readonly Code[];
     /**
      * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
      */
@@ -176,9 +182,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         patterns: Code;
     }>;
     /**
-     * Expression to serialize a property to a JSON object member.
+     * Initializer (name: value) to JSON.
      */
-    abstract toJsonObjectMemberExpression(parameters: {
+    abstract toJsonInitializer(parameters: {
         variables: {
             value: Code;
         };
@@ -190,12 +196,13 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
     }): readonly Code[];
     /**
-     * Expression to serialize this property to a human-readable string (toString).
+     * Initializer (name: value) to serialize this property to a human-readable string (toString).
      */
-    abstract toStringExpression(parameters: {
+    abstract toStringInitializer(parameters: {
         variables: {
             value: Code;
         };
     }): Maybe<Code>;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
 }
 //# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -10,10 +10,10 @@ import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
+    configuration;
     logger;
     namedObjectType;
     reusables;
-    rdfjsTermExpression;
     /**
      * TypeScript identifier-safe name of the property.
      */
@@ -22,7 +22,8 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    constructor({ logger, name, namedObjectType, reusables, type, }) {
+    constructor({ configuration, logger, name, namedObjectType, reusables, type, }) {
+        this.configuration = configuration;
         this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
@@ -54,6 +55,7 @@ export class AbstractProperty {
     accessExpression({ variables }) {
         return code `${variables.object}.${this.name}`;
     }
+    rdfjsTermExpression;
 }
 __decorate([
     Memoize()