@shaclmate/compiler 4.0.22 → 4.0.24

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

@@ -0,0 +1,4 @@
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_toStringFunctionOrMethodDeclarations(this: NamedObjectType): readonly Code[];
+//# sourceMappingURL=NamedObjectType_toStringFunctionOrMethodDeclaration.d.ts.map

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

@@ -0,0 +1,66 @@
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function NamedObjectType_toStringFunctionOrMethodDeclarations() {
+    const propertiesToStringRecordProperties = [];
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                propertiesToStringRecordProperties.push(code `...super.${syntheticNamePrefix}propertiesToStrings()`);
+                break;
+            }
+            case "interface": {
+                for (const parentObjectType of this.parentObjectTypes) {
+                    propertiesToStringRecordProperties.push(code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesToStrings(${this.thisVariable})`);
+                }
+                break;
+            }
+        }
+    }
+    for (const property of this.properties) {
+        property
+            .toStringExpression({
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+            .ifJust((propertyToStringExpression) => {
+            propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
+        });
+    }
+    const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;
+    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+    switch (this.declarationType) {
+        case "class": {
+            let propertiesToStringsPreamble = "";
+            let toStringPreamble = "";
+            if (this.parentObjectTypes.length > 0) {
+                propertiesToStringsPreamble = "override ";
+                toStringPreamble = "override ";
+            }
+            propertiesToStringsPreamble = `protected ${propertiesToStringsPreamble}`;
+            return [
+                code `${propertiesToStringsPreamble}${syntheticNamePrefix}propertiesToStrings(): Record<string, string> { return ${propertiesToStringsReturnExpression}; }`,
+                code `${toStringPreamble}toString(): string { return ${toStringReturnExpression(code `this.${syntheticNamePrefix}propertiesToStrings()`)}; }`,
+            ];
+        }
+        case "interface": {
+            return [
+                // Use overloads to allow the function to be attached to an instance or used freestanding
+                code `\
+export function ${syntheticNamePrefix}propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+  return ${propertiesToStringsReturnExpression};
+}`,
+                code `\
+export function ${syntheticNamePrefix}toString(this: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string;
+export function ${syntheticNamePrefix}toString(this: ${this.name} | undefined, ${this.thisVariable}?: ${this.name}): string {
+  return ${toStringReturnExpression(code `${syntheticNamePrefix}propertiesToStrings((${this.thisVariable} ?? this)!)`)};
+}`,
+            ];
+        }
+    }
+}
+//# sourceMappingURL=NamedObjectType_toStringFunctionOrMethodDeclaration.js.map

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

@@ -1,7 +1,6 @@
 import type { Type } from "../Type.js";
 import type { DiscriminantProperty } from "./DiscriminantProperty.js";
-import type { IdentifierPrefixProperty } from "./IdentifierPrefixProperty.js";
 import type { IdentifierProperty } from "./IdentifierProperty.js";
 import type { ShaclProperty } from "./ShaclProperty.js";
-export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | DiscriminantProperty;
+export type Property = IdentifierProperty | ShaclProperty<Type> | DiscriminantProperty;
 //# sourceMappingURL=Property.d.ts.map

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

@@ -6,30 +6,30 @@ import { AbstractProperty } from "./AbstractProperty.js";
 export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<TypeT> {
     private readonly comment;
     private readonly description;
+    private readonly display;
     private readonly label;
     readonly kind = "ShaclProperty";
     readonly mutable: boolean;
     readonly path: PropertyPath;
     readonly recursive: boolean;
-    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }: {
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
+        display: boolean;
         label: Maybe<string>;
         mutable: boolean;
         path: PropertyPath;
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
     get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
+    get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get jsonSchema(): AbstractProperty<TypeT>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<TypeT>["jsonZchema"];
     protected get schemaObject(): {
         path: Code | undefined;
         kind: Code;
@@ -44,6 +44,7 @@ export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<
     sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<TypeT>["toStringExpression"]>[0]): Maybe<Code>;
     private propertyPathToCode;
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

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

@@ -16,15 +16,17 @@ import { AbstractProperty } from "./AbstractProperty.js";
 export class ShaclProperty extends AbstractProperty {
     comment;
     description;
+    display;
     label;
     kind = "ShaclProperty";
     mutable;
     path;
     recursive;
-    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }) {
+    constructor({ comment, description, display, label, mutable, path, recursive, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
+        this.display = display;
         this.label = label;
         this.mutable = mutable;
         this.path = path;
@@ -53,14 +55,11 @@ export class ShaclProperty extends AbstractProperty {
             lhs.push(code `readonly`);
         }
         lhs.push(code `${this.name}`);
-        return Maybe.of(code `${this.comment
+        return code `${this.comment
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`);
-    }
-    get equalsFunction() {
-        return Maybe.of(this.type.equalsFunction);
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`;
     }
     get filterProperty() {
         if (this.visibility !== "public") {
@@ -71,9 +70,6 @@ export class ShaclProperty extends AbstractProperty {
             type: this.type.filterType,
         });
     }
-    get getAccessorDeclaration() {
-        return Maybe.empty();
-    }
     get graphqlField() {
         const args = this.type.graphqlArgs;
         const argsVariable = args.isJust() ? code `args` : code `_args`;
@@ -85,22 +81,29 @@ export class ShaclProperty extends AbstractProperty {
             type: this.type.graphqlType.name,
         });
     }
-    get jsonSignature() {
-        const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
-    }
-    get jsonZchema() {
+    get jsonSchema() {
         let schema = this.type.jsonSchema({
             context: "property",
         });
+        const meta = {
+            id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
+        };
         this.comment.alt(this.description).ifJust((description) => {
-            schema = code `${schema}.describe(${literalOf(description)})`;
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
         });
+        schema = code `${schema}.meta(${meta})`;
         return Maybe.of({
             key: this.name,
             schema,
         });
     }
+    get jsonSignature() {
+        const typeJsonType = this.type.jsonType();
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,
@@ -228,6 +231,12 @@ export class ShaclProperty extends AbstractProperty {
             })}, ${variables.graph});`,
         ];
     }
+    toStringExpression(parameters) {
+        if (!this.display) {
+            return Maybe.empty();
+        }
+        return Maybe.of(this.type.toStringExpression(parameters));
+    }
     propertyPathToCode(propertyPath) {
         switch (propertyPath.termType) {
             case "AlternativePath":
@@ -249,9 +258,6 @@ __decorate([
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], ShaclProperty.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], ShaclProperty.prototype, "filterProperty", null);
@@ -260,8 +266,8 @@ __decorate([
 ], ShaclProperty.prototype, "graphqlField", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonSignature", null);
+], ShaclProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonZchema", null);
+], ShaclProperty.prototype, "jsonSignature", null);
 //# sourceMappingURL=ShaclProperty.js.map

package/dist/generators/ts/_snippets/snippets_LazyObject.js

@@ -5,7 +5,7 @@ export const snippets_LazyObject = conditionalOutput(`${syntheticNamePrefix}Lazy
 /**
  * Type of lazy properties that return a single required object. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partial: PartialObjectT;
   private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
@@ -18,7 +18,7 @@ export class ${syntheticNamePrefix}LazyObject<ObjectIdentifierT extends ${import
   }
 
   resolve(options?: { preferredLanguages?: readonly string[] }): Promise<${imports.Either}<Error, ResolvedObjectT>> {
-    return this.resolver(this.partial.${syntheticNamePrefix}identifier, options);
+    return this.resolver(this.partial.${syntheticNamePrefix}identifier(), options);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObject.js.map

package/dist/generators/ts/_snippets/snippets_LazyObjectOption.js

@@ -5,7 +5,7 @@ export const snippets_LazyObjectOption = conditionalOutput(`${syntheticNamePrefi
 /**
  * Type of lazy properties that return a single optional object. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partial: ${imports.Maybe}<PartialObjectT>;
   private readonly resolver: (identifier: ObjectIdentifierT, options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, ResolvedObjectT>>;
 
@@ -21,7 +21,7 @@ export class ${syntheticNamePrefix}LazyObjectOption<ObjectIdentifierT extends ${
     if (this.partial.isNothing()) {
       return ${imports.Right}(${imports.Maybe}.empty());
     }
-    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier, options)).map(${imports.Maybe}.of);
+    return (await this.resolver(this.partial.unsafeCoerce().${syntheticNamePrefix}identifier(), options)).map(${imports.Maybe}.of);
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectOption.js.map

package/dist/generators/ts/_snippets/snippets_LazyObjectSet.js

@@ -5,7 +5,7 @@ export const snippets_LazyObjectSet = conditionalOutput(`${syntheticNamePrefix}L
 /**
  * Type of lazy properties that return a set of objects. This is a class instead of an interface so it can be instanceof'd elsewhere.
  */
-export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: ObjectIdentifierT }> {
+export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}, PartialObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }, ResolvedObjectT extends { ${syntheticNamePrefix}identifier: () => ObjectIdentifierT }> {
   readonly partials: readonly PartialObjectT[];
   private readonly resolver: (identifiers: readonly ObjectIdentifierT[], options?: { preferredLanguages?: readonly string[] }) => Promise<${imports.Either}<Error, readonly ResolvedObjectT[]>>;
 
@@ -36,7 +36,7 @@ export class ${syntheticNamePrefix}LazyObjectSet<ObjectIdentifierT extends ${imp
       offset = 0;
     }
 
-    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier), { preferredLanguages: options?.preferredLanguages });
+    return await this.resolver(this.partials.slice(offset, offset + limit).map(partial => partial.${syntheticNamePrefix}identifier()), { preferredLanguages: options?.preferredLanguages });
   }
 }`);
 //# sourceMappingURL=snippets_LazyObjectSet.js.map

package/dist/generators/ts/_snippets/snippets_PropertyPath.js

@@ -8,7 +8,7 @@ import { snippets_ToRdfResourceFunction } from "./snippets_ToRdfResourceFunction
  * Adapter between generated code and the rdfjs-resource PropertyPath.
  */
 export const snippets_PropertyPath = conditionalOutput(`${syntheticNamePrefix}PropertyPath`, code `\
-export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfjsResourcePropertyPath};
+export type ${syntheticNamePrefix}PropertyPath = ${imports.RdfxResourcePropertyPath};
 
 export namespace ${syntheticNamePrefix}PropertyPath {
   export type $Filter = object;
@@ -17,7 +17,7 @@ export namespace ${syntheticNamePrefix}PropertyPath {
     return true;
   }
 
-  export const ${syntheticNamePrefix}fromRdfResource: ${snippets_FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.fromResource;
+  export const ${syntheticNamePrefix}fromRdfResource: ${snippets_FromRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.fromResource;
 
   export const $fromRdfResourceValues: ${snippets_FromRdfResourceValuesFunction}<${syntheticNamePrefix}PropertyPath> = (values, options) =>
     values.chain((values) =>
@@ -30,6 +30,8 @@ export namespace ${syntheticNamePrefix}PropertyPath {
 
   export const $schema: Readonly<object> = {};
 
-  export const ${syntheticNamePrefix}toRdfResource: ${snippets_ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfjsResourcePropertyPath}.toResource;
+  export const ${syntheticNamePrefix}toRdfResource: ${snippets_ToRdfResourceFunction}<${syntheticNamePrefix}PropertyPath> = ${imports.RdfxResourcePropertyPath}.toResource;
+
+  export const ${syntheticNamePrefix}toString = ${imports.RdfxResourcePropertyPath}.toString;
 }`);
 //# sourceMappingURL=snippets_PropertyPath.js.map

package/dist/generators/ts/_snippets/snippets_compactRecord.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_compactRecord: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_compactRecord.d.ts.map

package/dist/generators/ts/_snippets/snippets_compactRecord.js

@@ -0,0 +1,16 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_compactRecord = conditionalOutput(`${syntheticNamePrefix}compactRecord`, code `\
+/**
+ * Remove undefined values from a record.
+ */  
+function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
+  return \
+    Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+      if (propertyValue !== undefined) {
+        definedProperties[propertyName as KeyT] = propertyValue as ValueT;
+      }
+      return definedProperties;
+    }, {} as Record<KeyT, ValueT>);
+}`);
+//# sourceMappingURL=snippets_compactRecord.js.map

package/dist/generators/ts/_snippets/{parseIri.d.ts → snippets_parseIri.d.ts}

@@ -1,2 +1,2 @@
 export declare const snippets_parseIri: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
-//# sourceMappingURL=parseIri.d.ts.map
+//# sourceMappingURL=snippets_parseIri.d.ts.map

package/dist/generators/ts/_snippets/{parseIri.js → snippets_parseIri.js}

@@ -9,4 +9,4 @@ export function ${syntheticNamePrefix}parseIri(identifier: string): ${imports.Ei
       .chain((identifier) => (identifier.termType === "NamedNode") ? ${imports.Right}(identifier) : ${imports.Left}(new Error("expected identifier to be NamedNode"))) \
     as ${imports.Either}<Error, ${imports.NamedNode}>;
 }`);
-//# sourceMappingURL=parseIri.js.map
+//# sourceMappingURL=snippets_parseIri.js.map

package/dist/generators/ts/imports.d.ts

@@ -29,13 +29,11 @@ export declare const imports: {
     readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
     readonly Quad: import("ts-poet/build/Import.js").Import;
     readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
-    readonly RdfjsResourcePropertyPath: import("ts-poet/build/Import.js").Import;
+    readonly RdfxResourcePropertyPath: import("ts-poet/build/Import.js").Import;
     readonly Resource: import("ts-poet/build/Import.js").Import;
     readonly ResourceSet: import("ts-poet/build/Import.js").Import;
     readonly Right: import("ts-poet/build/Import.js").Import;
-    readonly sha256: import("ts-poet/build/Import.js").Import;
     readonly sparqljs: import("ts-poet/build/Import.js").Import;
-    readonly uuid: import("ts-poet/build/Import.js").Import;
     readonly Variable: import("ts-poet/build/Import.js").Import;
     readonly z: import("ts-poet/build/Import.js").Import;
 };

package/dist/generators/ts/imports.js

@@ -30,13 +30,11 @@ export const imports = {
     NTriplesTerm: imp("NTriplesTerm@@rdfx/string"),
     Quad: imp("Quad@@rdfjs/types"),
     Quad_Graph: imp("Quad_Graph@@rdfjs/types"),
-    RdfjsResourcePropertyPath: imp("PropertyPath:RdfjsResourcePropertyPath@@rdfx/resource"),
+    RdfxResourcePropertyPath: imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource"),
     Resource: imp("Resource@@rdfx/resource"),
     ResourceSet: imp("ResourceSet@@rdfx/resource"),
     Right: imp("Right@purify-ts"),
-    sha256: imp("sha256@js-sha256"),
     sparqljs: imp("sparqljs*sparqljs"),
-    uuid: imp("uuid*uuid"),
     Variable: imp("Variable@@rdfjs/types"),
     z: imp("z@zod"),
 };

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -15,7 +15,7 @@ export function rdfjsDatasetObjectSetClassDeclaration({ namedObjectTypes, namedO
         query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
     };
     const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
         ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
     };
@@ -79,7 +79,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
                 // objectIdentifiersSync
                 code `\
 ${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]> {
-  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier()));
 }`,
                 // objects
                 code `\

package/dist/generators/ts/snippets.d.ts

@@ -12,6 +12,7 @@ export declare const snippets: {
     booleanSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     CollectionFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     CollectionSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+    compactRecord: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     dateEquals: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     DateFilter: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
     DateSchema: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;

package/dist/generators/ts/snippets.js

@@ -1,4 +1,3 @@
-import { snippets_parseIri } from "./_snippets/parseIri.js";
 import { snippets_arrayEquals } from "./_snippets/snippets_arrayEquals.js";
 import { snippets_arrayIntersection } from "./_snippets/snippets_arrayIntersection.js";
 import { snippets_BlankNodeFilter } from "./_snippets/snippets_BlankNodeFilter.js";
@@ -12,6 +11,7 @@ import { snippets_booleanEquals } from "./_snippets/snippets_booleanEquals.js";
 import { snippets_booleanSparqlWherePatterns } from "./_snippets/snippets_booleanSparqlWherePatterns.js";
 import { snippets_CollectionFilter } from "./_snippets/snippets_CollectionFilter.js";
 import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema.js";
+import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
 import { snippets_DateFilter } from "./_snippets/snippets_DateFilter.js";
 import { snippets_DateSchema } from "./_snippets/snippets_DateSchema.js";
 import { snippets_DefaultValueSchema } from "./_snippets/snippets_DefaultValueSchema.js";
@@ -76,6 +76,7 @@ import { snippets_PropertiesFromRdfResourceFunction } from "./_snippets/snippets
 import { snippets_PropertyPath } from "./_snippets/snippets_PropertyPath.js";
 import { snippets_parseBlankNode } from "./_snippets/snippets_parseBlankNode.js";
 import { snippets_parseIdentifier } from "./_snippets/snippets_parseIdentifier.js";
+import { snippets_parseIri } from "./_snippets/snippets_parseIri.js";
 import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
 import { snippets_ShaclPropertySchema } from "./_snippets/snippets_ShaclPropertySchema.js";
 import { snippets_SparqlFilterPattern } from "./_snippets/snippets_SparqlFilterPattern.js";
@@ -118,6 +119,7 @@ export const snippets = {
     booleanSparqlWherePatterns: snippets_booleanSparqlWherePatterns,
     CollectionFilter: snippets_CollectionFilter,
     CollectionSchema: snippets_CollectionSchema,
+    compactRecord: snippets_compactRecord,
     dateEquals: snippets_dateEquals,
     DateFilter: snippets_DateFilter,
     DateSchema: snippets_DateSchema,

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -15,7 +15,7 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
         selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
     const typeParameters = {
-        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
         ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
     };