@shaclmate/compiler 4.0.7 → 4.0.9

package/dist/generators/ts/TypeFactory.js

@@ -2,11 +2,13 @@ import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import base62 from "@sindresorhus/base62";
 import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { LiteralDecoder, literalDatatypeDefinitions } from "rdfjs-resource";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
+import * as ast from "../../ast/index.js";
 import { logger } from "../../logger.js";
-import { codeName } from "../codeName.js";
+import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -23,30 +25,41 @@ import { LazyObjectSetType } from "./LazyObjectSetType.js";
 import { LazyObjectType } from "./LazyObjectType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import { NamedUnionType } from "./NamedUnionType.js";
 import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.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";
-import { UnionType } from "./UnionType.js";
-const reservedTsIdentifiers = reservedTsIdentifiers_({
-    includeGlobalProperties: true,
-});
-const tsName = codeName((value) => {
-    // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
-    if (reservedTsIdentifiers.has(value)) {
-        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
-        return `$_${value}$`;
-    }
-    return value.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
-}, syntheticNamePrefix);
 export class TypeFactory {
+    cachedNamedObjectUnionTypesByShapeIdentifier = new TermMap();
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
-    cachedObjectUnionTypesByShapeIdentifier = new TermMap();
+    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,
+            members: ast.ObjectCompoundType.memberObjectTypes(astType).map((objectType) => ({
+                discriminantValue: Maybe.empty(),
+                type: this.createObjectType(objectType),
+            })),
+            name: tsName(astType.name.unsafeCoerce()),
+            recursive: astType.recursive,
+        });
+        this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
+        return namedObjectUnionType;
+    }
     createObjectType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByShapeIdentifier.get(astType.shapeIdentifier);
@@ -55,14 +68,14 @@ export class TypeFactory {
             }
         }
         const identifierType = this.createIdentifierType(astType.identifierType);
-        const staticModuleName = astType.childObjectTypes.length > 0
-            ? `${tsName(astType)}Static`
-            : tsName(astType);
+        const name = tsName(astType.name.unsafeCoerce(), {
+            synthetic: astType.synthetic,
+        });
+        const staticModuleName = astType.childObjectTypes.length > 0 ? `${name}Static` : name;
         const objectType = new ObjectType({
             abstract: astType.abstract,
             comment: astType.comment,
             declarationType: astType.tsObjectDeclarationType,
-            export_: astType.export,
             extern: astType.extern,
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
@@ -72,6 +85,37 @@ export class TypeFactory {
             lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
+            lazyDiscriminantProperty: (objectType) => {
+                // Discriminant property
+                const discriminantOwnValue = !astType.abstract
+                    ? objectType.discriminantValue
+                    : undefined;
+                const discriminantDescendantValues = new Set();
+                for (const descendantObjectType of objectType.descendantObjectTypes) {
+                    if (!descendantObjectType.abstract) {
+                        discriminantDescendantValues.add(descendantObjectType.discriminantValue);
+                    }
+                }
+                return new ObjectType.DiscriminantProperty({
+                    name: `${syntheticNamePrefix}type`,
+                    objectType,
+                    type: new ObjectType.DiscriminantProperty.Type({
+                        descendantValues: [...discriminantDescendantValues].sort(),
+                        mutable: false,
+                        ownValues: discriminantOwnValue ? [discriminantOwnValue] : [],
+                    }),
+                    visibility: "public",
+                });
+            },
+            lazyIdentifierProperty: (objectType) => new ObjectType.IdentifierProperty({
+                identifierMintingStrategy: astType.identifierMintingStrategy,
+                identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                name: `${syntheticNamePrefix}identifier`,
+                objectType,
+                type: identifierType,
+                typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
+                visibility: "public",
+            }),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyProperties: (objectType) => {
                 const properties = astType.properties
@@ -82,36 +126,15 @@ export class TypeFactory {
                     if (left.order > right.order) {
                         return 1;
                     }
-                    return tsName(left).localeCompare(tsName(right));
+                    return tsName(left.name).localeCompare(tsName(right.name));
                 })
                     .map((astProperty) => this.createObjectTypeProperty({
                     astObjectTypeProperty: astProperty,
                     objectType,
                 }));
-                // Type discriminant property
-                const typeDiscriminantOwnValue = !astType.abstract
-                    ? objectType.discriminantValue
-                    : undefined;
-                const typeDiscriminantDescendantValues = new Set();
-                for (const descendantObjectType of objectType.descendantObjectTypes) {
-                    if (!descendantObjectType.abstract) {
-                        typeDiscriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                    }
-                }
-                if (typeDiscriminantOwnValue ||
-                    typeDiscriminantDescendantValues.size > 0) {
-                    properties.splice(0, 0, new ObjectType.TypeDiscriminantProperty({
-                        name: `${syntheticNamePrefix}type`,
-                        objectType,
-                        type: new ObjectType.TypeDiscriminantProperty.Type({
-                            descendantValues: [...typeDiscriminantDescendantValues].sort(),
-                            mutable: false,
-                            ownValues: typeDiscriminantOwnValue
-                                ? [typeDiscriminantOwnValue]
-                                : [],
-                        }),
-                        visibility: "public",
-                    }));
+                if (objectType._discriminantProperty.type.ownValues.length > 0 ||
+                    objectType._discriminantProperty.type.descendantValues.length > 0) {
+                    properties.splice(0, 0, objectType._discriminantProperty);
                 }
                 // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
                 if (objectTypeNeedsIdentifierPrefixProperty(astType)) {
@@ -132,19 +155,11 @@ export class TypeFactory {
                     }));
                 }
                 // Every ObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, new ObjectType.IdentifierProperty({
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                    name: `${syntheticNamePrefix}identifier`,
-                    objectType,
-                    type: identifierType,
-                    typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
-                    visibility: "public",
-                }));
+                properties.splice(0, 0, objectType.identifierProperty);
                 return properties;
             },
-            identifierMintingStrategy: astType.identifierMintingStrategy,
-            name: tsName(astType),
+            name,
+            recursive: astType.recursive,
             staticModuleName,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
@@ -152,25 +167,6 @@ export class TypeFactory {
         this.cachedObjectTypesByShapeIdentifier.set(astType.shapeIdentifier, objectType);
         return objectType;
     }
-    createObjectUnionType(astType) {
-        {
-            const cachedObjectUnionType = this.cachedObjectUnionTypesByShapeIdentifier.get(astType.shapeIdentifier);
-            if (cachedObjectUnionType) {
-                return cachedObjectUnionType;
-            }
-        }
-        const objectUnionType = new ObjectUnionType({
-            comment: astType.comment,
-            export_: astType.export,
-            features: astType.tsFeatures,
-            identifierType: this.createIdentifierType(astType.identifierType),
-            label: astType.label,
-            memberTypes: astType.memberObjectTypes.map((objectType) => this.createObjectType(objectType)),
-            name: tsName(astType),
-        });
-        this.cachedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, objectUnionType);
-        return objectUnionType;
-    }
     createType(astType, parameters) {
         switch (astType.kind) {
             case "BlankNodeType":
@@ -193,16 +189,10 @@ export class TypeFactory {
                 return this.createListType(astType);
             case "LiteralType":
                 return this.createLiteralType(astType, parameters);
-            case "ObjectIntersectionType":
-                throw new Error("not implemented");
             case "ObjectType":
                 return this.createObjectType(astType);
-            case "ObjectUnionType":
-                return this.createObjectUnionType(astType);
             case "OptionType":
                 return this.createOptionType(astType);
-            case "PlaceholderType":
-                throw new Error(astType.kind);
             case "SetType":
                 return this.createSetType(astType);
             case "TermType":
@@ -211,6 +201,34 @@ export class TypeFactory {
                 return this.createUnionType(astType);
         }
     }
+    createUnionType(astType) {
+        if (astType.isObjectUnionType()) {
+            return this.createNamedObjectUnionType(astType);
+        }
+        return astType.name
+            .map((name) => new NamedUnionType({
+            comment: astType.comment,
+            features: astType.tsFeatures,
+            identifierType: Maybe.empty(),
+            label: astType.label,
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            name,
+            recursive: astType.recursive,
+        }))
+            .orDefaultLazy(() => new AnonymousUnionType({
+            comment: astType.comment,
+            label: astType.label,
+            identifierType: Maybe.empty(),
+            members: astType.members.map((member) => ({
+                discriminantValue: member.discriminantValue,
+                type: this.createType(member.type),
+            })),
+            recursive: astType.recursive,
+        }));
+    }
     createBlankNodeType(astType) {
         return new BlankNodeType({
             comment: astType.comment,
@@ -408,14 +426,13 @@ export class TypeFactory {
                 return cachedProperty;
             }
         }
-        const name = tsName(astObjectTypeProperty);
         const property = new ObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
             label: astObjectTypeProperty.label,
             mutable: astObjectTypeProperty.mutable,
             objectType,
-            name,
+            name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
             type: this.createType(astObjectTypeProperty.type),
@@ -453,14 +470,6 @@ export class TypeFactory {
             nodeKinds: astType.nodeKinds,
         });
     }
-    createUnionType(astType) {
-        return new UnionType({
-            comment: astType.comment,
-            label: astType.label,
-            memberDiscriminantValues: astType.memberDiscriminantValues,
-            memberTypes: astType.memberTypes.map((astType) => this.createType(astType)),
-        });
-    }
 }
 function objectTypeNeedsIdentifierPrefixProperty(objectType) {
     return objectType.identifierMintingStrategy
@@ -478,4 +487,22 @@ function objectTypeNeedsIdentifierPrefixProperty(objectType) {
     })
         .orDefault(false);
 }
+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}`;
+    }
+    return tsName;
+}
+const reservedTsIdentifiers = reservedTsIdentifiers_({
+    includeGlobalProperties: true,
+});
 //# sourceMappingURL=TypeFactory.js.map

package/dist/generators/ts/ZodGenerator.js

@@ -1,8 +1,7 @@
+import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
 import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
 import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
-import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
-import { ObjectUnionType_jsonZodSchemaFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js";
 import { snippets } from "./snippets.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
@@ -19,12 +18,13 @@ ${joinCode([
             ], { on: "\n\n" })}
 }`);
         }
-        for (const objectUnionType of ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType))) {
+        for (const astNamedUnionType of ast_.namedUnionTypes.map((astNamedUnionType) => this.typeFactory.createUnionType(astNamedUnionType))) {
+            invariant(astNamedUnionType.kind !== "AnonymousUnionType");
             declarations.push(code `\
-export namespace ${objectUnionType.staticModuleName} {
+export namespace ${astNamedUnionType.staticModuleName} {
 ${joinCode([
-                ...ObjectUnionType_jsonTypeAliasDeclaration.bind(objectUnionType)().toList(),
-                ...ObjectUnionType_jsonZodSchemaFunctionDeclaration.bind(objectUnionType)().toList(),
+                astNamedUnionType.jsonTypeAliasDeclaration,
+                astNamedUnionType.jsonZodSchemaFunctionDeclaration,
             ], { on: "\n\n" })}
 }`);
         }

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

@@ -109,7 +109,7 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Expression to deserialize this property on the given rdfjsResource.Resource to a Either<Error, this property type>.
      */
-    abstract fromRdfExpression(parameters: {
+    abstract fromRdfResourceValuesExpression(parameters: {
         variables: {
             context: Code;
             graph: Code;
@@ -184,8 +184,8 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Statements to serialize this property to an RDF resource.
      */
-    abstract toRdfStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "propertyPath">;
+    abstract toRdfRdfResourceValuesStatements(parameters: {
+        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
     }): readonly Code[];
 }
 //# sourceMappingURL=AbstractProperty.d.ts.map

package/dist/generators/ts/_ObjectType/{TypeDiscriminantProperty.d.ts → DiscriminantProperty.d.ts}

@@ -1,35 +1,35 @@
 import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
-export declare class TypeDiscriminantProperty extends AbstractProperty<TypeDiscriminantProperty.Type> {
+export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
     readonly constructorParametersSignature: Maybe<Code>;
     readonly equalsFunction: Maybe<Code>;
-    readonly filterProperty: AbstractProperty<TypeDiscriminantProperty.Type>["filterProperty"];
+    readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
     readonly getAccessorDeclaration: Maybe<Code>;
-    readonly graphqlField: AbstractProperty<TypeDiscriminantProperty.Type>["graphqlField"];
-    readonly kind = "TypeDiscriminantProperty";
+    readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
+    readonly kind = "DiscriminantProperty";
     readonly mutable = false;
     readonly recursive = false;
     constructor({ type, ...superParameters }: {
-        type: TypeDiscriminantProperty.Type;
+        type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get declaration(): Maybe<Code>;
     get jsonSignature(): Maybe<Code>;
-    get jsonZodSchema(): AbstractProperty<TypeDiscriminantProperty.Type>["jsonZodSchema"];
+    get jsonZodSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZodSchema"];
     private get abstract();
     private get initializer();
     private get override();
     constructorStatements(): readonly Code[];
     fromJsonStatements(): readonly Code[];
-    fromRdfExpression(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesExpression(): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<TypeDiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
+    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
-export declare namespace TypeDiscriminantProperty {
+export declare namespace DiscriminantProperty {
     class Type {
         readonly filterFunction: Code;
         readonly mutable: boolean;
@@ -45,4 +45,4 @@ export declare namespace TypeDiscriminantProperty {
         get values(): string[];
     }
 }
-//# sourceMappingURL=TypeDiscriminantProperty.d.ts.map
+//# sourceMappingURL=DiscriminantProperty.d.ts.map

package/dist/generators/ts/_ObjectType/{TypeDiscriminantProperty.js → DiscriminantProperty.js}

@@ -12,13 +12,13 @@ import { removeUndefined } from "../removeUndefined.js";
 import { snippets } from "../snippets.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
-export class TypeDiscriminantProperty extends AbstractProperty {
+export class DiscriminantProperty extends AbstractProperty {
     constructorParametersSignature = Maybe.empty();
     equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
     filterProperty = Maybe.empty();
     getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
-    kind = "TypeDiscriminantProperty";
+    kind = "DiscriminantProperty";
     mutable = false;
     recursive = false;
     constructor({ type, ...superParameters }) {
@@ -72,7 +72,7 @@ export class TypeDiscriminantProperty extends AbstractProperty {
             ? [code `const ${this.name} = ${this.initializer};`]
             : [];
     }
-    fromRdfExpression() {
+    fromRdfResourceValuesExpression() {
         return !this.abstract && this.objectType.declarationType === "interface"
             ? Maybe.of(code `${imports.Right}<${literalOf(this.objectType.discriminantValue)}>(${this.initializer})`)
             : Maybe.empty();
@@ -93,17 +93,17 @@ export class TypeDiscriminantProperty extends AbstractProperty {
     toJsonObjectMemberExpression({ variables, }) {
         return Maybe.of(code `${this.name}: ${variables.value}`);
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }
 __decorate([
     Memoize()
-], TypeDiscriminantProperty.prototype, "jsonSignature", null);
+], DiscriminantProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], TypeDiscriminantProperty.prototype, "jsonZodSchema", null);
-(function (TypeDiscriminantProperty) {
+], DiscriminantProperty.prototype, "jsonZodSchema", null);
+(function (DiscriminantProperty) {
     class Type {
         filterFunction = code `nonextant`;
         mutable;
@@ -137,6 +137,6 @@ __decorate([
     __decorate([
         Memoize()
     ], Type.prototype, "values", null);
-    TypeDiscriminantProperty.Type = Type;
-})(TypeDiscriminantProperty || (TypeDiscriminantProperty = {}));
-//# sourceMappingURL=TypeDiscriminantProperty.js.map
+    DiscriminantProperty.Type = Type;
+})(DiscriminantProperty || (DiscriminantProperty = {}));
+//# sourceMappingURL=DiscriminantProperty.js.map

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

@@ -21,12 +21,12 @@ export declare class IdentifierPrefixProperty extends AbstractProperty<StringTyp
     get getAccessorDeclaration(): Maybe<Code>;
     constructorStatements({ variables, }: Parameters<AbstractProperty<StringType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements(): readonly Code[];
-    fromRdfExpression(): Maybe<Code>;
+    fromRdfResourceValuesExpression(): Maybe<Code>;
     hashStatements(): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<StringType>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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

@@ -61,7 +61,7 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
     fromJsonStatements() {
         return [];
     }
-    fromRdfExpression() {
+    fromRdfResourceValuesExpression() {
         return Maybe.empty();
     }
     hashStatements() {
@@ -79,7 +79,7 @@ protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name}
     toJsonObjectMemberExpression() {
         return Maybe.empty();
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }

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

@@ -35,7 +35,7 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     private get override();
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
-    fromRdfExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfExpression"]>[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>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
@@ -44,6 +44,6 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
         patterns: Code;
     }>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
-    toRdfStatements(): readonly Code[];
+    toRdfRdfResourceValuesStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map

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

@@ -143,6 +143,9 @@ export class IdentifierProperty extends AbstractProperty {
         });
     }
     get jsonSignature() {
+        if (this.type.in_.length > 0) {
+            return Maybe.of(code `readonly "@id": ${this.type.in_.map((iri) => `"${iri.value}"`).join(" | ")}`);
+        }
         return Maybe.of(code `readonly "@id": string`);
     }
     get jsonZodSchema() {
@@ -277,8 +280,8 @@ export class IdentifierProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
-    fromRdfExpression({ variables, }) {
-        return Maybe.of(code `${this.type.fromRdfExpression({
+    fromRdfResourceValuesExpression({ variables, }) {
+        return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
                 propertyPath: rdfjsTermExpression(rdf.subject),
@@ -298,7 +301,7 @@ export class IdentifierProperty extends AbstractProperty {
     sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
             condition: code `${variables.focusIdentifier}.termType === "Variable"`,
-            patterns: code `${this.type.sparqlWherePatternsFunction}(${{
+            patterns: code `${this.type.valueSparqlWherePatternsFunction}(${{
                 filter: code `${variables.filter}?.${this.name}`,
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
@@ -327,7 +330,7 @@ export class IdentifierProperty extends AbstractProperty {
         invariant(valueToNodeKinds.length === 2);
         return Maybe.of(code `"@id": ${variables.value}.termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
-    toRdfStatements() {
+    toRdfRdfResourceValuesStatements() {
         return [];
     }
 }

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

@@ -5,7 +5,7 @@ import { tsComment } from "../tsComment.js";
 import { ObjectType_equalsFunctionOrMethodDeclaration } from "./ObjectType_equalsFunctionOrMethodDeclaration.js";
 import { ObjectType_hashFunctionOrMethodDeclarations } from "./ObjectType_hashFunctionOrMethodDeclarations.js";
 import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./ObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./ObjectType_toRdfFunctionOrMethodDeclaration.js";
+import { ObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./ObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
 function ObjectType_constructorDeclaration() {
     const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersSignature.toList());
     const parametersType = [];
@@ -47,16 +47,16 @@ export function ObjectType_classDeclaration() {
 ${this.comment
         .alt(this.label)
         .map(tsComment)
-        .orDefault("")}${this.export ? "export " : ""}${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
+        .orDefault("")}export ${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
 ${joinCode([
         ...this.properties.flatMap((property) => property.declaration.toList()),
-        ObjectType_constructorDeclaration.bind(this)(),
+        ObjectType_constructorDeclaration.call(this),
         ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
-        ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_hashFunctionOrMethodDeclarations.bind(this)(),
-        ...ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList(),
-        ...ObjectType_toStringMethodDeclaration.bind(this)().toList(),
+        ...ObjectType_equalsFunctionOrMethodDeclaration.call(this).toList(),
+        ...ObjectType_hashFunctionOrMethodDeclarations.call(this),
+        ...ObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),
+        ...ObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList(),
+        ...ObjectType_toStringMethodDeclaration.call(this).toList(),
     ], { on: "\n\n" })}
 }`;
 }

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectType_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectType): Maybe<Code>;
+//# sourceMappingURL=ObjectType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map