@shaclmate/compiler 4.0.22 → 4.0.24

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

@@ -239,7 +239,7 @@ ${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if ($
 ${joinCode([
             ...this.identifierType
                 .map((identifierType) => code `\
-if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier)) {
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
   return false;
 }`)
                 .toList(),
@@ -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

@@ -1,6 +1,4 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
@@ -22,13 +20,11 @@ import type { TermType } from "./TermType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
-    private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
     readonly kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
     get valueSparqlConstructTriplesFunction(): Code;
@@ -36,6 +32,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

@@ -12,14 +12,12 @@ import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ListType extends AbstractCollectionType {
-    identifierMintingStrategy;
     identifierNodeKind;
     toRdfTypes;
     kind = "ListType";
-    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
+    constructor({ identifierNodeKind, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
-        this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
         this.toRdfTypes = toRdfTypes;
     }
     get valueSparqlConstructTriplesFunction() {
@@ -48,43 +46,26 @@ export class ListType extends AbstractCollectionType {
         return new AbstractCollectionType.JsonType(code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        let listIdentifier;
+        let mintListIdentifierFunction;
+        let mintSubListIdentifierFunction;
         let resourceTypeName;
-        let subListIdentifier;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
-                listIdentifier =
-                    subListIdentifier = code `${imports.dataFactory}.blankNode()`;
+                mintListIdentifierFunction =
+                    mintSubListIdentifierFunction = code `(() => ${imports.dataFactory}.blankNode())`;
                 resourceTypeName = code `${imports.Resource}<${imports.BlankNode}>`;
                 break;
             }
             case "IRI": {
-                switch (this.identifierMintingStrategy) {
-                    case "blankNode":
-                        throw new RangeError(this.identifierMintingStrategy);
-                    case "sha256":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (hasher, item) => {
-          ${joinCode(this.itemType.hashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `item` } }).concat())}
-          return hasher;
-        },
-        ${imports.sha256}.create(),
-      )}\`)`;
-                        break;
-                    case "uuidv4":
-                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${imports.uuid}.v4()}\`)`;
-                        break;
-                }
                 resourceTypeName = code `${imports.Resource}<${imports.NamedNode}>`;
-                subListIdentifier = code `${imports.dataFactory}.namedNode(\`\${listResource.identifier.value}:\${itemIndex}\`)`;
-                break;
+                throw new RangeError("list IRI minting is unsupported");
             }
         }
         return code `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.resource(${subListIdentifier});
+      const newSubListResource = ${variables.resourceSet}.resource(${mintSubListIdentifierFunction}());
       currentSubListResource!.add(${rdfjsTermExpression(rdf.rest, { logger: this.logger })}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
@@ -101,13 +82,16 @@ export class ListType extends AbstractCollectionType {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.resource(${listIdentifier}),
+    listResource: resourceSet.resource(${mintListIdentifierFunction}()),
   } as {
     currentSubListResource: ${resourceTypeName} | null;
     listResource: ${resourceTypeName};
   },
 ).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

@@ -3,7 +3,6 @@ import { Maybe, NonEmptyList } from "purify-ts";
 import type { TsFeature } from "../../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import type { Property as _Property } from "./_NamedObjectType/Property.js";
 import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
@@ -29,7 +28,7 @@ export declare class NamedObjectType extends AbstractType {
     readonly staticModuleName: string;
     readonly synthetic: boolean;
     readonly typeofs: NonEmptyList<"object">;
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
@@ -42,7 +41,6 @@ export declare class NamedObjectType extends AbstractType {
         lazyAncestorObjectTypes: () => readonly NamedObjectType[];
         lazyChildObjectTypes: () => readonly NamedObjectType[];
         lazyDiscriminantProperty: (namedObjectType: NamedObjectType) => NamedObjectType.DiscriminantProperty;
-        lazyIdentifierProperty: (namedObjectType: NamedObjectType) => NamedObjectType.IdentifierProperty;
         lazyDescendantObjectTypes: () => readonly NamedObjectType[];
         lazyParentObjectTypes: () => readonly NamedObjectType[];
         lazyProperties: (namedObjectType: NamedObjectType) => readonly NamedObjectType.Property[];
@@ -67,12 +65,9 @@ export declare class NamedObjectType extends AbstractType {
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
-    get identifierProperty(): NamedObjectType.IdentifierProperty;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
-    get ownProperties(): readonly NamedObjectType.Property[];
-    get ownShaclProperties(): readonly NamedObjectType.ShaclProperty<Type>[];
     get parentObjectTypes(): readonly NamedObjectType[];
     get properties(): readonly NamedObjectType.Property[];
     get schema(): Code;
@@ -97,19 +92,17 @@ 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;
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;
     private readonly lazyDiscriminantProperty;
-    private readonly lazyIdentifierProperty;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
 export declare namespace NamedObjectType {
-    const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
-    type IdentifierPrefixProperty = _IdentifierPrefixProperty;
     const IdentifierProperty: typeof _IdentifierProperty;
     type IdentifierProperty = _IdentifierProperty;
     type ObjectSetMethodNames = {

package/dist/generators/ts/NamedObjectType.js

@@ -9,7 +9,6 @@ import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
 import { NamedObjectType_classDeclaration } from "./_NamedObjectType/NamedObjectType_classDeclaration.js";
@@ -39,6 +38,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";
@@ -62,7 +62,7 @@ export class NamedObjectType extends AbstractType {
     staticModuleName;
     synthetic;
     typeofs = NonEmptyList(["object"]);
-    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.declarationType = declarationType;
@@ -76,7 +76,6 @@ export class NamedObjectType extends AbstractType {
         this.lazyChildObjectTypes = lazyChildObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyDiscriminantProperty = lazyDiscriminantProperty;
-        this.lazyIdentifierProperty = lazyIdentifierProperty;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
         this.name = name;
@@ -135,6 +134,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 `\
@@ -186,9 +187,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get graphqlType() {
         return new AbstractType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
     }
-    get identifierProperty() {
-        return this.lazyIdentifierProperty(this);
-    }
     get identifierTypeAlias() {
         return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
@@ -198,18 +196,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get objectSetMethodNames() {
         return NamedObjectType_objectSetMethodNames.call(this);
     }
-    get ownProperties() {
-        if (this.parentObjectTypes.length === 0) {
-            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminant properties
-            // for all of its subtypes in the hierarchy.
-            // invariant(this.properties.length >= 2, this.name);
-            return this.properties;
-        }
-        return this.ownShaclProperties;
-    }
-    get ownShaclProperties() {
-        return this.properties.filter((property) => property.kind === "ShaclProperty");
-    }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
     }
@@ -307,6 +293,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":
@@ -324,7 +318,6 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     lazyChildObjectTypes;
     lazyDescendantObjectTypes;
     lazyDiscriminantProperty;
-    lazyIdentifierProperty;
     lazyParentObjectTypes;
     lazyProperties;
 }
@@ -370,9 +363,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "identifierProperty", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "identifierTypeAlias", null);
@@ -382,12 +372,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownProperties", null);
-__decorate([
-    Memoize()
-], NamedObjectType.prototype, "ownShaclProperties", null);
 __decorate([
     Memoize()
 ], NamedObjectType.prototype, "parentObjectTypes", null);
@@ -419,7 +403,6 @@ __decorate([
     Memoize()
 ], NamedObjectType.prototype, "jsonType", null);
 (function (NamedObjectType) {
-    NamedObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
     NamedObjectType.IdentifierProperty = _IdentifierProperty;
     NamedObjectType.ShaclProperty = _ShaclProperty;
     NamedObjectType.DiscriminantProperty = _DiscriminantProperty;

package/dist/generators/ts/NamedObjectUnionType.js

@@ -142,7 +142,7 @@ export namespace ${syntheticNamePrefix}Identifier {
     get schemaVariableStatement() {
         const commonPropertiesByName = {};
         this.concreteMembers.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.ownProperties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.ownProperties))) {
+            for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
                 if (memberTypeProperty.kind !== "ShaclProperty") {
                     continue;
                 }

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()