@shaclmate/compiler 4.0.93 → 4.0.95

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

@@ -9,12 +9,20 @@ import { Memoize } from "typescript-memoize";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty {
-    constructorParameter = Maybe.empty();
+    createFunctionParameter = Maybe.empty();
+    /**
+     * The discriminant property is not declared in the object type. It's only added on construction.
+     */
+    declaration = Maybe.empty();
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
+    hashFunctionParameter = Maybe.empty();
+    jsonObjectMember = Maybe.empty();
     kind = "Discriminant";
     mutable = false;
     recursive = false;
+    schema = Maybe.empty();
+    schemaType = Maybe.empty();
     value;
     constructor({ configuration, value, ...superParameters }) {
         super({
@@ -24,38 +32,11 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         });
         this.value = value;
     }
-    get declaration() {
-        return Maybe.of(code `readonly ${this.name}: ${literalOf(this.value)};`);
-    }
-    get hashFunctionParameter() {
-        return Maybe.of(code `readonly ${this.name}?: ${literalOf(this.value)};`);
-    }
-    get jsonName() {
-        return this.configuration.objectDiscriminantProperty.jsonName;
-    }
-    get jsonSchema() {
-        return Maybe.of({
-            key: this.jsonName,
-            schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
-        });
-    }
-    get jsonSignature() {
-        return Maybe.of(code `readonly "${this.jsonName}": ${literalOf(this.value)}`);
-    }
-    get schema() {
-        return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
-    }
-    get schemaType() {
-        return Maybe.of(code `${{ kind: this.kind, value: this.value }}`);
-    }
     get values() {
         return [this.value];
     }
-    get constValue() {
-        return code `${literalOf(this.value)} as const`;
-    }
-    constructorInitializer() {
-        return Maybe.empty();
+    createInitializer() {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.reusables.imports.Right}(${literalOf(this.value)} as const)`);
     }
     equalsExpression() {
         return Maybe.empty();
@@ -63,20 +44,14 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     filterExpression() {
         return Maybe.empty();
     }
-    fromJsonInitializer() {
+    fromJsonObjectInitializer() {
         return Maybe.empty();
     }
     fromRdfResourceValuesInitializer() {
         return Maybe.empty();
     }
-    hashStatements({ variables, }) {
-        return [
-            code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}); }`,
-        ];
-    }
-    jsonUiSchemaElement({ variables, }) {
-        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
-        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+    hashStatements() {
+        return [];
     }
     sparqlConstructTriplesExpression() {
         return Maybe.empty();
@@ -84,10 +59,13 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     sparqlWherePatternsExpression() {
         return Maybe.empty();
     }
-    toJsonInitializer({ variables, }) {
-        return Maybe.of(code `"${this.jsonName}": ${variables.object}.${this.name}`);
+    toJsonObjectInitializer() {
+        return Maybe.empty();
     }
-    toRdfRdfResourceValuesStatements() {
+    toLoggableInitializer() {
+        return Maybe.empty();
+    }
+    toRdfResourceValuesStatements() {
         return [];
     }
     toStringInitializer() {
@@ -96,22 +74,10 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
 }
 __decorate([
     Memoize()
-], ObjectType_DiscriminantProperty.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], ObjectType_DiscriminantProperty.prototype, "hashFunctionParameter", null);
-__decorate([
-    Memoize()
-], ObjectType_DiscriminantProperty.prototype, "jsonName", null);
-__decorate([
-    Memoize()
-], ObjectType_DiscriminantProperty.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], ObjectType_DiscriminantProperty.prototype, "jsonSignature", null);
+], ObjectType_DiscriminantProperty.prototype, "values", null);
 __decorate([
     Memoize()
-], ObjectType_DiscriminantProperty.prototype, "values", null);
+], ObjectType_DiscriminantProperty.prototype, "createInitializer", null);
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "equalsExpression", null);

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

@@ -12,37 +12,36 @@ export declare class ObjectType_IdentifierProperty extends ObjectType_AbstractPr
     constructor({ type, ...superParameters }: {
         type: BlankNodeType | IdentifierType | IriType;
     } & ConstructorParameters<typeof ObjectType_AbstractProperty>[0]);
-    get constructorParameter(): Maybe<{
+    get createFunctionParameter(): Maybe<{
         hasQuestionToken: boolean;
         signature: Code;
     }>;
     get declaration(): Maybe<Code>;
-    equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
     get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
     get hashFunctionParameter(): Maybe<Code>;
-    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
-    get jsonSignature(): Maybe<Code>;
+    get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
     private get typeExpression();
     private get typeSchemaVariable();
-    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["constructorInitializer"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonInitializer"]>[0]): Maybe<Code>;
+    createInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["createInitializer"]>[0]): Maybe<Code>;
+    equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
+    filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
+    fromJsonObjectInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonObjectInitializer"]>[0]): Maybe<Code>;
     fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression(): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): Maybe<{
         condition: Code;
         patterns: Code;
     }>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toJsonObjectInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonObjectInitializer"]>[0]): Maybe<Code>;
+    toLoggableInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toLoggableInitializer"]>[0]): Maybe<Code>;
+    toRdfResourceValuesStatements(): readonly Code[];
     toStringInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toStringInitializer"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_IdentifierProperty.d.ts.map

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

@@ -9,7 +9,7 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
     kind = "Identifier";
@@ -20,7 +20,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         super(superParameters);
         this.type = type;
     }
-    get constructorParameter() {
+    get createFunctionParameter() {
         let hasQuestionToken = false;
         const typeExpressions = [code `(() => ${this.typeExpression})`];
         for (const type of this.type.conversionFunction.unsafeCoerce()
@@ -34,28 +34,18 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         }
         return Maybe.of({
             hasQuestionToken,
-            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`,
+            signature: code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: " | " })};`,
         });
     }
     get declaration() {
         return Maybe.of(code `readonly ${this.name}: () => ${this.typeExpression};`);
     }
-    equalsExpression({ variables, }) {
-        return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
-        { equalsFunction: ${this.type.equalsFunction}, name: ${literalOf(this.name)} },
-        [left, ${variables.leftObject}.${this.name}()],
-        [right, ${variables.rightObject}.${this.name}()],
-      )`);
-    }
     get filterProperty() {
         return Maybe.of({
             name: this.name,
             type: this.type.filterType,
         });
     }
-    filterExpression({ variables, }) {
-        return Maybe.of(code `${this.type.filterFunction}(${variables.filter}.${this.name}, ${variables.object}.${this.name}())`);
-    }
     get graphqlField() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         invariant(this.name.startsWith(syntheticNamePrefix));
@@ -63,34 +53,30 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.type.stringifyFunction}(source.${this.name}())`,
+            resolve: code `(source) => ${this.reusables.imports.NTriplesIdentifier}.stringify(source.${this.name}())`,
             type: this.type.graphqlType.expression,
         });
     }
     get hashFunctionParameter() {
         return Maybe.of(code `readonly ${this.name}?: () => ${this.typeExpression};`);
     }
-    get jsonSchema() {
-        let schema;
-        if (this.type.in_.length > 0 && this.type.kind === "Iri") {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            schema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.type.in_.map((iri) => iri.value))})`;
-        }
-        else {
-            schema = code `${this.reusables.imports.z}.string().min(1)`;
-        }
+    get jsonObjectMember() {
         return Maybe.of({
-            key: "@id",
-            schema,
+            description: Maybe.empty(),
+            label: Maybe.empty(),
+            name: "@id",
+            optional: false,
+            recursive: this.recursive,
+            type: this.type.in_.length > 0 && this.type.kind === "Iri"
+                ? this.jsonTypeFactory.createJsonStringType({
+                    in_: this.type.in_.map((iri) => iri.value),
+                })
+                : this.jsonTypeFactory.createJsonStringType({
+                    minLength: 1n,
+                }),
+            uiSchemaElement: Maybe.of(({ variables }) => code `{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/@id\`, type: "Control" }`),
         });
     }
-    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 schema() {
         return Maybe.of(code `{ ${joinCode([code `kind: ${literalOf(this.kind)}`, code `type: ${this.type.schema}`], { on: ", " })} }`);
     }
@@ -110,7 +96,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             .map((name) => code `${name}.schema.properties.${this.name}.type`)
             .orDefaultLazy(() => this.type.schema);
     }
-    constructorInitializer({ variables, }) {
+    createInitializer({ variables, }) {
         const nodeKinds = this.type.nodeKinds;
         let conversionFunction;
         if (nodeKinds.size === 2) {
@@ -130,13 +116,21 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         }
         return Maybe.of(code `${this.name}: ${conversionFunction}(${variables.parameters}.${this.name}, ${variables.parameters}.${this.configuration.syntheticNamePrefix}defaultNamespace)`);
     }
-    fromJsonInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.fromJsonExpression({
-            variables: { value: variables.jsonObject },
-        })}`);
+    equalsExpression({ variables, }) {
+        return Maybe.of(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${this.type.equalsFunction.annotatedUsage}, name: ${literalOf(this.name)} },
+        [left, ${variables.leftObject}.${this.name}()],
+        [right, ${variables.rightObject}.${this.name}()],
+      )`);
+    }
+    filterExpression({ variables, }) {
+        return Maybe.of(code `${this.type.filterFunction.annotatedUsage}(${variables.filter}.${this.name}, ${variables.object}.${this.name}())`);
+    }
+    fromJsonObjectInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: (${this.type.fromJsonValueFunction.unannotatedUsage})(${variables.jsonObject}["@id"], { ...${variables.options}, schema: ${this.typeSchemaVariable} })`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction}(
+        return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction.annotatedUsage}(
           ${this.reusables.snippets.rdfResourceIdentifierValues}(${variables.focusResource}),
           { ...${variables.options}, focusResource: ${variables.focusResource}, propertyPath: ${this.rdfjsTermExpression(rdf.subject)}, schema: ${this.typeSchemaVariable} }
         ).chain(values => values.head())`);
@@ -146,16 +140,13 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             code `if (${variables.object}.${this.name}) { ${variables.hasher}.update(${variables.object}.${this.name}().value); }`,
         ];
     }
-    jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(code `{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/@id\`, type: "Control" }`);
-    }
     sparqlConstructTriplesExpression() {
         return Maybe.empty();
     }
     sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
             condition: code `${variables.focusIdentifier}.termType === "Variable"`,
-            patterns: code `${this.type.valueSparqlWherePatternsFunction}(${{
+            patterns: code `${this.type.valueSparqlWherePatternsFunction.annotatedUsage}(${{
                 filter: code `${variables.filter}?.${this.name}`,
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
@@ -166,7 +157,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
             }})`,
         });
     }
-    toJsonInitializer({ variables, }) {
+    toJsonObjectInitializer({ variables, }) {
         const nodeKinds = [...this.type.nodeKinds];
         const valueToNodeKinds = nodeKinds.map((nodeKind) => {
             switch (nodeKind) {
@@ -184,7 +175,10 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
         invariant(valueToNodeKinds.length === 2);
         return Maybe.of(code `"@id": ${variables.object}.${this.name}().termType === "${NodeKind.toTermType(nodeKinds[0])}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
-    toRdfRdfResourceValuesStatements() {
+    toLoggableInitializer({ variables, }) {
+        return Maybe.of(code `${literalOf(this.name)}: ${this.type.toLoggableExpression({ variables: { value: code `${variables.object}.${this.name}()` } })}`);
+    }
+    toRdfResourceValuesStatements() {
         return [];
     }
     toStringInitializer({ variables, }) {
@@ -193,7 +187,7 @@ export class ObjectType_IdentifierProperty extends ObjectType_AbstractProperty {
 }
 __decorate([
     Memoize()
-], ObjectType_IdentifierProperty.prototype, "constructorParameter", null);
+], ObjectType_IdentifierProperty.prototype, "createFunctionParameter", null);
 __decorate([
     Memoize()
 ], ObjectType_IdentifierProperty.prototype, "declaration", null);
@@ -208,10 +202,7 @@ __decorate([
 ], ObjectType_IdentifierProperty.prototype, "hashFunctionParameter", null);
 __decorate([
     Memoize()
-], ObjectType_IdentifierProperty.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], ObjectType_IdentifierProperty.prototype, "jsonSignature", null);
+], ObjectType_IdentifierProperty.prototype, "jsonObjectMember", null);
 __decorate([
     Memoize()
 ], ObjectType_IdentifierProperty.prototype, "typeExpression", null);

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

@@ -3,14 +3,12 @@ import { Maybe } from "purify-ts";
 import { type Code } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
-    readonly constructorParameter: ObjectType_AbstractProperty["constructorParameter"];
+    readonly createFunctionParameter: ObjectType_AbstractProperty["createFunctionParameter"];
     readonly declaration: ObjectType_AbstractProperty["declaration"];
     readonly filterProperty: ObjectType_AbstractProperty["filterProperty"];
     readonly fromRdfType: NamedNode;
     readonly graphqlField: ObjectType_AbstractProperty["graphqlField"];
     readonly hashFunctionParameter: ObjectType_AbstractProperty["hashFunctionParameter"];
-    readonly jsonSchema: ObjectType_AbstractProperty["jsonSchema"];
-    readonly jsonSignature: ObjectType_AbstractProperty["jsonSignature"];
     readonly kind = "RdfType";
     readonly mutable = false;
     readonly recursive = false;
@@ -20,18 +18,19 @@ export declare class ObjectType_RdfTypeProperty extends ObjectType_AbstractPrope
         toRdfTypes: readonly NamedNode[];
     } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name">);
     get schema(): Maybe<Code>;
+    get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
     get schemaType(): Maybe<Code>;
-    constructorInitializer(): Maybe<Code>;
+    createInitializer(): Maybe<Code>;
     equalsExpression(): Maybe<Code>;
     filterExpression(): Maybe<Code>;
-    fromJsonInitializer(): Maybe<Code>;
-    fromRdfResourceValuesInitializer(): Maybe<Code>;
+    fromJsonObjectInitializer(): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
     hashStatements(): readonly Code[];
-    jsonUiSchemaElement(): Maybe<Code>;
     sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
-    toJsonInitializer(): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toJsonObjectInitializer(): Maybe<Code>;
+    toLoggableInitializer(): Maybe<Code>;
+    toRdfResourceValuesStatements({ variables, }: Parameters<ObjectType_AbstractProperty["toRdfResourceValuesStatements"]>[0]): readonly Code[];
     toStringInitializer(): Maybe<Code>;
 }
 //# sourceMappingURL=ObjectType_RdfTypeProperty.d.ts.map

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

@@ -7,17 +7,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { code, joinCode } from "../ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
 import { ObjectType_AbstractProperty } from "./ObjectType_AbstractProperty.js";
 export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
-    constructorParameter = Maybe.empty();
+    createFunctionParameter = Maybe.empty();
     declaration = Maybe.empty();
     filterProperty = Maybe.empty();
     fromRdfType;
     graphqlField = Maybe.empty();
     hashFunctionParameter = Maybe.empty();
-    jsonSchema = Maybe.empty();
-    jsonSignature = Maybe.empty();
     kind = "RdfType";
     mutable = false;
     recursive = false;
@@ -34,10 +32,25 @@ export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
     get schema() {
         return Maybe.of(code `${{ fromRdfType: this.rdfjsTermExpression(this.fromRdfType), kind: this.kind, toRdfTypes: this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)) }}`);
     }
+    get jsonObjectMember() {
+        return Maybe.of({
+            description: Maybe.empty(),
+            label: Maybe.empty(),
+            name: "@type",
+            optional: false,
+            recursive: this.recursive,
+            type: this.toRdfTypes.length === 1
+                ? this.jsonTypeFactory.createJsonStringType()
+                : this.jsonTypeFactory.createJsonArrayType(this.jsonTypeFactory.createJsonStringType(), {
+                    minCount: 1n,
+                }),
+            uiSchemaElement: Maybe.empty(),
+        });
+    }
     get schemaType() {
         return Maybe.of(code `${{ fromRdfType: code `${this.reusables.imports.NamedNode}`, kind: this.kind, toRdfTypes: code `readonly ${this.reusables.imports.NamedNode}[]` }}`);
     }
-    constructorInitializer() {
+    createInitializer() {
         return Maybe.empty();
     }
     equalsExpression() {
@@ -46,18 +59,15 @@ export class ObjectType_RdfTypeProperty extends ObjectType_AbstractProperty {
     filterExpression() {
         return Maybe.empty();
     }
-    fromJsonInitializer() {
+    fromJsonObjectInitializer() {
         return Maybe.empty();
     }
-    fromRdfResourceValuesInitializer() {
-        return Maybe.empty();
+    fromRdfResourceValuesInitializer({ variables, }) {
+        return Maybe.of(code `${this.name}: !${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.focusResource}, ${arrayOf(code `(${this.schemaVariable}).fromRdfType`)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`);
     }
     hashStatements() {
         return [];
     }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
-    }
     sparqlConstructTriplesExpression({ variables, }) {
         const rdfClassVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
         const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
@@ -99,20 +109,43 @@ type: "optional" as const
             })}]`,
         });
     }
-    toJsonInitializer() {
+    toJsonObjectInitializer() {
+        return Maybe.of(code `"@type":
+          ${this.toRdfTypes.length === 1
+            ? code `${literalOf(this.toRdfTypes[0].value)}`
+            : code `${arrayOf(...this.toRdfTypes.map((toRdfType) => toRdfType.value))}`}`);
+    }
+    toLoggableInitializer() {
         return Maybe.empty();
     }
-    toRdfRdfResourceValuesStatements() {
-        return [];
+    toRdfResourceValuesStatements({ variables, }) {
+        return [
+            code `\
+if (!${variables.ignoreRdfType}) {
+  ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.schemaVariable}.toRdfTypes, ${variables.graph});
+}`,
+        ];
     }
     toStringInitializer() {
         return Maybe.empty();
     }
 }
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "jsonObjectMember", null);
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "schemaType", null);
 __decorate([
     Memoize()
 ], ObjectType_RdfTypeProperty.prototype, "equalsExpression", null);
 __decorate([
     Memoize()
 ], ObjectType_RdfTypeProperty.prototype, "filterExpression", null);
+__decorate([
+    Memoize()
+], ObjectType_RdfTypeProperty.prototype, "toJsonObjectInitializer", null);
 //# sourceMappingURL=ObjectType_RdfTypeProperty.js.map

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

@@ -8,22 +8,24 @@ export declare class ObjectType_ShaclProperty<TypeT extends Type> extends Object
     private readonly description;
     private readonly display;
     private readonly label;
+    private readonly minCount;
     readonly kind = "Shacl";
     readonly mutable: boolean;
     readonly path: PropertyPath;
     readonly recursive: boolean;
     readonly type: TypeT;
-    constructor({ comment, description, display, label, mutable, path, recursive, type, ...superParameters }: {
+    constructor({ comment, description, display, label, minCount, mutable, path, recursive, type, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
         display: boolean;
         label: Maybe<string>;
+        minCount: bigint;
         mutable: boolean;
         path: PropertyPath;
         recursive: boolean;
         type: TypeT;
     } & ConstructorParameters<typeof ObjectType_AbstractProperty>[0]);
-    get constructorParameter(): Maybe<{
+    get createFunctionParameter(): Maybe<{
         hasQuestionToken: boolean;
         signature: Code;
     }>;
@@ -34,23 +36,21 @@ export declare class ObjectType_ShaclProperty<TypeT extends Type> extends Object
     }>;
     get graphqlField(): ObjectType_AbstractProperty["graphqlField"];
     get hashFunctionParameter(): Maybe<Code>;
-    get jsonSchema(): ObjectType_AbstractProperty["jsonSchema"];
-    get jsonSignature(): Maybe<Code>;
+    get jsonObjectMember(): ObjectType_AbstractProperty["jsonObjectMember"];
     get schema(): Maybe<Code>;
     get schemaType(): Maybe<Code>;
-    private get schemaVariable();
     private get typeSchemaVariable();
-    constructorInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["constructorInitializer"]>[0]): Maybe<Code>;
+    createInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["createInitializer"]>[0]): Maybe<Code>;
     equalsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["equalsExpression"]>[0]): Maybe<Code>;
     filterExpression({ variables, }: Parameters<ObjectType_AbstractProperty["filterExpression"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromJsonObjectInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromJsonObjectInitializer"]>[0]): Maybe<Code>;
     fromRdfResourceValuesInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<ObjectType_AbstractProperty["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<ObjectType_AbstractProperty["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     sparqlConstructTriplesExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
     sparqlWherePatternsExpression({ variables, }: Parameters<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>[0]): ReturnType<ObjectType_AbstractProperty["sparqlWherePatternsExpression"]>;
-    toJsonInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements({ variables, }: Parameters<ObjectType_AbstractProperty["toRdfRdfResourceValuesStatements"]>[0]): readonly Code[];
+    toJsonObjectInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toJsonObjectInitializer"]>[0]): Maybe<Code>;
+    toLoggableInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toLoggableInitializer"]>[0]): Maybe<Code>;
+    toRdfResourceValuesStatements({ variables, }: Parameters<ObjectType_AbstractProperty["toRdfResourceValuesStatements"]>[0]): readonly Code[];
     toStringInitializer({ variables, }: Parameters<ObjectType_AbstractProperty["toStringInitializer"]>[0]): Maybe<Code>;
     private propertyPathToCode;
 }