@shaclmate/compiler 4.0.21 → 4.0.23

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -252,6 +252,7 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
         return Either.of(new ast.ObjectType.Property({
             comment: propertyShape.comment,
             description: propertyShape.description,
+            display: propertyShape.display,
             label: propertyShape.label,
             mutable: propertyShape.mutable.orDefault(false),
             name: propertyName.call(this, objectType, propertyShape),

package/dist/ast/ObjectType.d.ts

@@ -133,6 +133,10 @@ export declare namespace ObjectType {
          * Description from sh:description.
          */
         readonly description: Maybe<string>;
+        /**
+         * Should the property and its value be displayed in a toString()-type representation?
+         */
+        readonly display: boolean;
         /**
          * Human-readable label from rdfs:label.
          */
@@ -170,9 +174,10 @@ export declare namespace ObjectType {
          * Visibility: private, protected, public.
          */
         readonly visibility: Visibility;
-        constructor({ comment, description, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
             comment: Maybe<string>;
             description: Maybe<string>;
+            display: boolean;
             label: Maybe<string>;
             mutable: boolean;
             name: string;

package/dist/ast/ObjectType.js

@@ -193,6 +193,10 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Description from sh:description.
          */
         description;
+        /**
+         * Should the property and its value be displayed in a toString()-type representation?
+         */
+        display;
         /**
          * Human-readable label from rdfs:label.
          */
@@ -230,9 +234,10 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          * Visibility: private, protected, public.
          */
         visibility;
-        constructor({ comment, description, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }) {
+        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }) {
             this.comment = comment;
             this.description = description;
+            this.display = display;
             this.label = label;
             this.mutable = mutable;
             this.name = name;

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -45,6 +45,7 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     protected resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }: {
         resolvedNamedObjectUnionType: NamedObjectUnionType;
         partialNamedObjectUnionType: NamedObjectUnionType;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -113,6 +113,13 @@ export class AbstractLazyObjectType extends AbstractType {
             },
         });
     }
+    toStringExpression({ variables, }) {
+        return this.partialType.toStringExpression({
+            variables: {
+                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
+            },
+        });
+    }
     resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType, partialNamedObjectUnionType, variables, }) {
         invariant(resolvedNamedObjectUnionType.members.length ===
             partialNamedObjectUnionType.members.length);

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -15,8 +15,8 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
-    get jsonTypeAliasDeclaration(): Code;
     get jsonSchemaFunctionDeclaration(): Code;
+    get jsonTypeAliasDeclaration(): Code;
     get name(): string;
     get staticModuleName(): string;
     get valueSparqlConstructTriplesFunction(): Code;
@@ -25,9 +25,10 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractType.JsonType;
     jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
 }
 //# sourceMappingURL=AbstractNamedUnionType.d.ts.map

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -47,12 +47,21 @@ ${joinCode(staticModuleDeclarations
     get filterType() {
         return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
     }
+    get jsonSchemaFunctionDeclaration() {
+        const meta = {
+            id: this.name,
+        };
+        this.comment.ifJust((description) => {
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
+        });
+        return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
+    }
     get jsonTypeAliasDeclaration() {
         return code `export type ${syntheticNamePrefix}Json = ${this.inlineJsonType.name}`;
     }
-    get jsonSchemaFunctionDeclaration() {
-        return code `export const schema = () => ${this.inlineJsonSchema};`;
-    }
     get name() {
         return this._name;
     }
@@ -115,6 +124,8 @@ export namespace ${syntheticNamePrefix}Json {
             staticModuleDeclarations[`${syntheticNamePrefix}valueSparqlWherePatterns`] =
                 code `export const ${syntheticNamePrefix}valueSparqlWherePatterns: ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
+        staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+            code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
         return staticModuleDeclarations;
     }
     fromJsonExpression({ variables, }) {
@@ -138,12 +149,6 @@ export namespace ${syntheticNamePrefix}Json {
         }
         return this.inlineHashStatements({ depth, variables });
     }
-    jsonType() {
-        if (this.features.has("json")) {
-            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
-        }
-        return this.inlineJsonType;
-    }
     jsonSchema({ context, }) {
         if (this.features.has("json")) {
             const expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
@@ -154,6 +159,12 @@ export namespace ${syntheticNamePrefix}Json {
         }
         return this.inlineJsonSchema;
     }
+    jsonType() {
+        if (this.features.has("json")) {
+            return new AbstractType.JsonType(`${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        }
+        return this.inlineJsonType;
+    }
     toJsonExpression({ variables, }) {
         if (this.features.has("json")) {
             return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
@@ -167,6 +178,9 @@ export namespace ${syntheticNamePrefix}Json {
         }
         return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
     }
+    toStringExpression({ variables, }) {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}toString(${variables.value})`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/AbstractTermType.d.ts

@@ -38,6 +38,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     /**
      * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
      *

package/dist/generators/ts/AbstractTermType.js

@@ -127,6 +127,9 @@ export class AbstractTermType extends AbstractType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${variables.value}]`;
     }
+    toStringExpression({ variables, }) {
+        return code `${variables.value}.toString()`;
+    }
     /**
      * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
      *

package/dist/generators/ts/AbstractType.d.ts

@@ -79,6 +79,10 @@ export declare abstract class AbstractType {
      * TypeScript type describing .schema.
      */
     abstract readonly schemaType: Code;
+    /**
+     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
+     */
+    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * JavaScript typeof(s) the type.
      */
@@ -217,10 +221,6 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
-    /**
-     * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
-     */
-    abstract readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "NamedNode" | "Literal">;
     /**
      * An expression that converts a property value of this type to a value or an array of values that can be .add'd to a Resource with
      *   resource.add(predicate, convertedValue, graph)
@@ -241,6 +241,14 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
+    /**
+     * An expression that converts a value of this type to a human-readable string (toString).
+     */
+    abstract toStringExpression(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
 }
 export declare namespace AbstractType {
     interface Conversion {

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -37,6 +37,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineName(): Code;
     protected get inlineToJsonFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
+    protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
     protected get inlineValueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {

package/dist/generators/ts/AbstractUnionType.js

@@ -430,6 +430,16 @@ ${joinCode(this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if ($
 
   throw new Error("unable to serialize to RDF");
 }) satisfies ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineToStringFunction() {
+        return code `\
+((value: ${this.name}): string => {
+${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
+            variables: { value: unwrap(code `value`) },
+        })}; }`))}
+
+  throw new Error("unable to serialize to string");
+})`;
     }
     get inlineValueSparqlConstructTriplesFunction() {
         return code `\

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -18,9 +18,10 @@ export declare class AnonymousUnionType extends AbstractUnionType<Type> {
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
     hashStatements(parameters: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractType.JsonType;
     jsonSchema(_parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
 }
 //# sourceMappingURL=AnonymousUnionType.d.ts.map

package/dist/generators/ts/AnonymousUnionType.js

@@ -39,12 +39,12 @@ export class AnonymousUnionType extends AbstractUnionType {
     hashStatements(parameters) {
         return this.inlineHashStatements(parameters);
     }
-    jsonType() {
-        return this.inlineJsonType;
-    }
     jsonSchema(_parameters) {
         return this.inlineJsonSchema;
     }
+    jsonType() {
+        return this.inlineJsonType;
+    }
     toJsonExpression({ variables, }) {
         return code `${this.inlineToJsonFunction}(${variables.value})`;
     }
@@ -52,5 +52,8 @@ export class AnonymousUnionType extends AbstractUnionType {
         const { value: valueVariable, ...otherVariables } = variables;
         return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
     }
+    toStringExpression({ variables, }) {
+        return code `${this.inlineToStringFunction}(${variables.value})`;
+    }
 }
 //# sourceMappingURL=AnonymousUnionType.js.map

package/dist/generators/ts/DefaultValueType.d.ts

@@ -35,11 +35,12 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression(parameters: Parameters<AbstractType["toStringExpression"]>[0]): Code;
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;

package/dist/generators/ts/DefaultValueType.js

@@ -133,15 +133,15 @@ export class DefaultValueType extends AbstractContainerType {
     hashStatements(parameters) {
         return this.itemType.hashStatements(parameters);
     }
+    jsonSchema(parameters) {
+        return this.itemType.jsonSchema(parameters);
+    }
     jsonType(parameters) {
         return this.itemType.jsonType(parameters);
     }
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
-    jsonSchema(parameters) {
-        return this.itemType.jsonSchema(parameters);
-    }
     toJsonExpression(parameters) {
         return this.itemType.toJsonExpression(parameters);
     }
@@ -151,6 +151,9 @@ export class DefaultValueType extends AbstractContainerType {
             .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`)
             .orDefault(code `${this.itemType.toRdfResourceValuesExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
     }
+    toStringExpression(parameters) {
+        return this.itemType.toStringExpression(parameters);
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/ListType.d.ts

@@ -36,6 +36,7 @@ export declare class ListType<ItemTypeT extends ListType.ItemType> extends Abstr
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace ListType {
     type ItemType = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | NamedObjectUnionType | NamedUnionType | NamedObjectType | StringType | TermType;

package/dist/generators/ts/ListType.js

@@ -108,6 +108,9 @@ export class ListType extends AbstractCollectionType {
   },
 ).listResource.identifier : ${rdfjsTermExpression(rdf.nil, { logger: this.logger })}]`;
     }
+    toStringExpression({ variables, }) {
+        return code `\`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\``;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/NamedObjectType.d.ts

@@ -97,6 +97,7 @@ export declare class NamedObjectType extends AbstractType {
         parameters: Code;
     }): Code;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     protected ensureAtMostOneSuperObjectType(): void;
     private readonly lazyAncestorObjectTypes;

package/dist/generators/ts/NamedObjectType.js

@@ -39,6 +39,7 @@ import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_Name
 import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
 import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toStringFunctionOrMethodDeclarations } from "./_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.js";
 import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
 import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
@@ -135,6 +136,8 @@ export class NamedObjectType extends AbstractType {
                 ? NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
                 : []), ...(this.declarationType === "interface"
                 ? NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
+                : []), ...(this.declarationType === "interface"
+                ? NamedObjectType_toStringFunctionOrMethodDeclarations.call(this)
                 : []), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
@@ -307,6 +310,14 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
                 return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
+    toStringExpression({ variables, }) {
+        switch (this.declarationType) {
+            case "class":
+                return code `${variables.value}.toString()`;
+            case "interface":
+                return code `${this.staticModuleName}.${syntheticNamePrefix}toString(${variables.value})`;
+        }
+    }
     toRdfResourceValuesExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":

package/dist/generators/ts/OptionType.d.ts

@@ -29,6 +29,7 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace OptionType {
     type ItemType = AbstractContainerType.ItemType;

package/dist/generators/ts/OptionType.js

@@ -138,6 +138,9 @@ export class OptionType extends AbstractContainerType {
         }
         return toRdfExpression;
     }
+    toStringExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })})).extract()`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/SetType.d.ts

@@ -9,6 +9,7 @@ export declare class SetType<ItemTypeT extends SetType.ItemType> extends Abstrac
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;

package/dist/generators/ts/SetType.js

@@ -57,6 +57,9 @@ export class SetType extends AbstractCollectionType {
             variables: { ...variables, value: code `item` },
         })})`;
     }
+    toStringExpression({ variables, }) {
+        return code `(${variables.value}.length > 0 ? \`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\` : undefined)`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/TypeFactory.js

@@ -455,6 +455,7 @@ export class TypeFactory {
         const property = new NamedObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
+            display: astObjectTypeProperty.display,
             label: astObjectTypeProperty.label,
             logger: this.logger,
             mutable: astObjectTypeProperty.mutable,

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

@@ -42,17 +42,17 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         resolve: Code;
         type: Code;
     }>;
-    /**
-     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
-     */
-    abstract readonly jsonSignature: Maybe<Code>;
     /**
      * zod Object key: schema pair on the property serialized by toJsonObjectMember.
      */
-    abstract readonly jsonZchema: Maybe<{
+    abstract readonly jsonSchema: Maybe<{
         readonly key: string;
         readonly schema: Code;
     }>;
+    /**
+     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     */
+    abstract readonly jsonSignature: Maybe<Code>;
     /**
      * Property type discriminator e.g., "ShaclProperty".
      */
@@ -190,5 +190,13 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     abstract toRdfRdfResourceValuesStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
     }): readonly Code[];
+    /**
+     * Expression to serialize this property to a human-readable string (toString).
+     */
+    abstract toStringExpression(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Maybe<Code>;
 }
 //# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -14,8 +14,8 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
         type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get declaration(): Maybe<Code>;
+    get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZchema"];
     private get abstract();
     private get initializer();
     private get override();
@@ -28,6 +28,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(): Maybe<Code>;
 }
 export declare namespace DiscriminantProperty {
     class Type {

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

@@ -36,10 +36,7 @@ export class DiscriminantProperty extends AbstractProperty {
                 throw new Error("should never reach this point");
         }
     }
-    get jsonSignature() {
-        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
-    }
-    get jsonZchema() {
+    get jsonSchema() {
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
@@ -47,6 +44,9 @@ export class DiscriminantProperty extends AbstractProperty {
                 : code `${imports.z}.literal(${literalOf(this.type.values[0])})`,
         });
     }
+    get jsonSignature() {
+        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
+    }
     get abstract() {
         return this.namedObjectType.abstract;
     }
@@ -98,13 +98,16 @@ export class DiscriminantProperty extends AbstractProperty {
     toRdfRdfResourceValuesStatements() {
         return [];
     }
+    toStringExpression() {
+        return Maybe.empty();
+    }
 }
 __decorate([
     Memoize()
-], DiscriminantProperty.prototype, "jsonSignature", null);
+], DiscriminantProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
-], DiscriminantProperty.prototype, "jsonZchema", null);
+], DiscriminantProperty.prototype, "jsonSignature", null);
 (function (DiscriminantProperty) {
     class Type {
         filterFunction = code `nonextant`;

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

@@ -6,8 +6,8 @@ export declare class IdentifierPrefixProperty extends AbstractProperty<StringTyp
     private readonly own;
     readonly filterProperty: AbstractProperty<StringType>["filterProperty"];
     readonly graphqlField: AbstractProperty<StringType>["graphqlField"];
+    readonly jsonSchema: AbstractProperty<StringType>["jsonSchema"];
     readonly jsonSignature: Maybe<Code>;
-    readonly jsonZchema: AbstractProperty<StringType>["jsonZchema"];
     readonly kind = "IdentifierPrefixProperty";
     readonly mutable = false;
     readonly recursive = false;
@@ -28,5 +28,6 @@ export declare class IdentifierPrefixProperty extends AbstractProperty<StringTyp
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<StringType>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(): Maybe<Code>;
 }
 //# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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

@@ -15,8 +15,8 @@ export class IdentifierPrefixProperty extends AbstractProperty {
     own;
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
+    jsonSchema = Maybe.empty();
     jsonSignature = Maybe.empty();
-    jsonZchema = Maybe.empty();
     kind = "IdentifierPrefixProperty";
     mutable = false;
     recursive = false;
@@ -82,6 +82,9 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
     toRdfRdfResourceValuesStatements() {
         return [];
     }
+    toStringExpression() {
+        return Maybe.empty();
+    }
 }
 __decorate([
     Memoize()

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

@@ -28,13 +28,14 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<IdentifierType>["jsonZchema"];
+    get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     private get abstract();
     private get declarationModifiers();
     private get declarationName();
     private get override();
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

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

@@ -147,7 +147,7 @@ export class IdentifierProperty extends AbstractProperty {
         }
         return Maybe.of(code `readonly "@id": string`);
     }
-    get jsonZchema() {
+    get jsonSchema() {
         let schema;
         if (this.type.in_.length > 0 && this.type.kind === "IriType") {
             // Treat sh:in as a union of the IRIs
@@ -279,6 +279,9 @@ export class IdentifierProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
+    toStringExpression(parameters) {
+        return Maybe.of(this.type.toStringExpression(parameters));
+    }
     fromRdfResourceValuesExpression({ variables, }) {
         return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
@@ -358,7 +361,7 @@ __decorate([
 ], IdentifierProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], IdentifierProperty.prototype, "jsonZchema", null);
+], IdentifierProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "declarationModifiers", null);