@shaclmate/compiler 4.0.12 → 4.0.14

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -2,12 +2,14 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
+import { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
 import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
 import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
+import { shapeOntology } from "./shapeOntology.js";
 import { transformPropertyShapeToAstObjectTypeProperty } from "./transformPropertyShapeToAstObjectTypeProperty.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 function isObjectTypePropertyRequired(property) {
@@ -43,135 +45,137 @@ function isObjectTypePropertyRequired(property) {
 export function transformShapeToAstObjectType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        if (shape.kind !== "NodeShape") {
+        if (shape.$type !== "NodeShape") {
             return Either.of(Maybe.empty());
         }
         const nodeShape = shape;
-        if (nodeShape.identifier.termType !== "NamedNode") {
+        if (nodeShape.and.length > 0 || nodeShape.xone.length > 0) {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain2(nodeShape.constraints.and, nodeShape.constraints.xone).chain(([andShapes, xoneShapes]) => {
-            if (andShapes.length > 0 || xoneShapes.length > 0) {
-                return Either.of(Maybe.empty());
-            }
-            return Eithers.chain9(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
-                ? Either.of(nodeShape.tsObjectDeclarationType)
-                : nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType))).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
-                const abstract = nodeShape.abstract.orDefault(false);
-                let fromRdfType;
-                let toRdfTypes;
-                if (!abstract) {
-                    fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-                    if (nodeShape.isClass &&
-                        nodeShape.identifier.termType === "NamedNode") {
-                        fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.identifier));
-                    }
-                    toRdfTypes = nodeShape.toRdfTypes.concat();
-                    if (toRdfTypes.length === 0) {
-                        toRdfTypes.push(...nodeShape.rdfType.toList());
-                    }
-                    // Ensure toRdfTypes has fromRdfType
-                    fromRdfType.ifJust((fromRdfType) => {
-                        if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
-                            toRdfTypes.push(fromRdfType);
-                        }
-                    });
-                }
-                else {
-                    fromRdfType = Maybe.empty();
-                    toRdfTypes = [];
-                }
-                if (nodeKinds.has("Literal")) {
-                    return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
+        if (nodeShape.$identifier.termType !== "NamedNode") {
+            return Either.of(Maybe.empty());
+        }
+        return Eithers.chain9(Either.sequence(nodeShape.ancestorClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.childClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.descendantClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), Either.sequence(nodeShape.parentClassIris.map((nodeShapeIdentifier) => this.shapesGraph.nodeShape(nodeShapeIdentifier))), nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape), nodeShape.tsObjectDeclarationType.isJust()
+            ? Either.of(nodeShape.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri))
+            : shapeOntology
+                .call(this, nodeShape)
+                .map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType.map(TsObjectDeclarationType.fromIri)))).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
+            const abstract = nodeShape.abstract.orDefault(false);
+            let fromRdfType;
+            let toRdfTypes;
+            if (!abstract) {
+                fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+                if (nodeShape.isClass &&
+                    nodeShape.$identifier.termType === "NamedNode") {
+                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.$identifier));
                 }
-                let identifierType;
-                const identifierTypeProperties = {
-                    comment: Maybe.empty(),
-                    label: Maybe.empty(),
-                    name: Maybe.empty(),
-                    shapeIdentifier: nodeShape.identifier,
-                };
-                if (nodeKinds.size === 2) {
-                    invariant(nodeShape.identifierIn.length === 0);
-                    identifierType = new ast.IdentifierType(identifierTypeProperties);
+                toRdfTypes = nodeShape.toRdfTypes.concat();
+                if (toRdfTypes.length === 0) {
+                    toRdfTypes.push(...nodeShape.rdfType.toList());
                 }
-                else {
-                    switch ([...nodeKinds][0]) {
-                        case "BlankNode":
-                            invariant(nodeShape.identifierIn.length === 0);
-                            identifierType = new ast.BlankNodeType(identifierTypeProperties);
-                            break;
-                        case "IRI":
-                            identifierType = new ast.IriType({
-                                ...identifierTypeProperties,
-                                hasValues: [],
-                                in_: nodeShape.identifierIn,
-                            });
-                            break;
-                        case "Literal":
-                            throw new Error("should never happen");
+                // Ensure toRdfTypes has fromRdfType
+                fromRdfType.ifJust((fromRdfType) => {
+                    if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                        toRdfTypes.push(fromRdfType);
                     }
-                }
-                invariant(identifierType);
-                // Put a placeholder in the cache to deal with cyclic references
-                // Remove the placeholder if the transformation fails.
-                // If this node shape's properties (directly or indirectly) refer to the node shape itself,
-                // we'll return this placeholder.
-                const objectType = new ast.ObjectType({
-                    abstract,
-                    comment: nodeShape.comment,
-                    extern: nodeShape.extern.orDefault(false),
-                    fromRdfType,
-                    label: nodeShape.label,
-                    identifierType,
-                    identifierMintingStrategy,
-                    name: shapeAstTypeName(nodeShape),
-                    shapeIdentifier: nodeShape.identifier,
-                    synthetic: false,
-                    toRdfTypes,
-                    tsFeatures,
-                    tsImports: nodeShape.tsImports,
-                    tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
                 });
-                this.cachedAstTypesByShapeIdentifier.set(nodeShape.identifier, objectType);
-                return (() => {
-                    // Populate ancestor and descendant object types
-                    const relatedObjectTypes = (relatedNodeShapes) => {
-                        return relatedNodeShapes
-                            .flatMap((relatedNodeShape) => transformShapeToAstType
-                            .call(this, relatedNodeShape, new ShapeStack())
-                            .toMaybe()
-                            .toList())
-                            .filter((astType) => astType.kind === "ObjectType");
-                    };
-                    objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
-                    objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
-                    objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
-                    objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
-                    // Populate properties
-                    for (const propertyShape of propertyShapes) {
-                        const propertyEither = transformPropertyShapeToAstObjectTypeProperty.call(this, {
-                            objectType,
-                            propertyShape,
-                        });
-                        if (propertyEither.isLeft()) {
-                            return propertyEither;
-                        }
-                        propertyEither.ifRight((property) => {
-                            objectType.addProperties(property);
+            }
+            else {
+                fromRdfType = Maybe.empty();
+                toRdfTypes = [];
+            }
+            if (nodeKinds.has("Literal")) {
+                return Left(new Error(`${nodeShape} should not have a nodeKind "Literal"`));
+            }
+            let identifierType;
+            const identifierTypeProperties = {
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                name: Maybe.empty(),
+                shapeIdentifier: nodeShape.$identifier,
+            };
+            if (nodeKinds.size === 2) {
+                invariant(nodeShape.in_.isNothing());
+                identifierType = new ast.IdentifierType(identifierTypeProperties);
+            }
+            else {
+                switch ([...nodeKinds][0]) {
+                    case "BlankNode":
+                        invariant(nodeShape.in_.isNothing());
+                        identifierType = new ast.BlankNodeType(identifierTypeProperties);
+                        break;
+                    case "IRI":
+                        identifierType = new ast.IriType({
+                            ...identifierTypeProperties,
+                            hasValues: [],
+                            in_: nodeShape.in_
+                                .orDefault([])
+                                .filter((_) => _.termType === "NamedNode"),
                         });
+                        break;
+                    default:
+                        throw new Error("should never happen");
+                }
+            }
+            invariant(identifierType);
+            // Put a placeholder in the cache to deal with cyclic references
+            // Remove the placeholder if the transformation fails.
+            // If this node shape's properties (directly or indirectly) refer to the node shape itself,
+            // we'll return this placeholder.
+            const objectType = new ast.ObjectType({
+                abstract,
+                comment: nodeShape.comment,
+                extern: nodeShape.extern.orDefault(false),
+                fromRdfType,
+                label: nodeShape.label,
+                identifierType,
+                identifierMintingStrategy,
+                name: shapeAstTypeName(nodeShape),
+                shapeIdentifier: nodeShape.$identifier,
+                synthetic: false,
+                toRdfTypes,
+                tsFeatures,
+                tsImports: nodeShape.tsImports,
+                tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
+            });
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier, objectType);
+            return (() => {
+                // Populate ancestor and descendant object types
+                const relatedObjectTypes = (relatedNodeShapes) => {
+                    return relatedNodeShapes
+                        .flatMap((relatedNodeShape) => transformShapeToAstType
+                        .call(this, relatedNodeShape, new ShapeStack())
+                        .toMaybe()
+                        .toList())
+                        .filter((astType) => astType.kind === "ObjectType");
+                };
+                objectType.addAncestorObjectTypes(...relatedObjectTypes(ancestorNodeShapes));
+                objectType.addChildObjectTypes(...relatedObjectTypes(childNodeShapes));
+                objectType.addDescendantObjectTypes(...relatedObjectTypes(descendantNodeShapes));
+                objectType.addParentObjectTypes(...relatedObjectTypes(parentNodeShapes));
+                // Populate properties
+                for (const propertyShape of propertyShapes) {
+                    const propertyEither = transformPropertyShapeToAstObjectTypeProperty.call(this, {
+                        objectType,
+                        propertyShape,
+                    });
+                    if (propertyEither.isLeft()) {
+                        return propertyEither;
                     }
-                    if (!objectType.abstract &&
-                        !objectType.extern &&
-                        objectType.fromRdfType.isNothing() &&
-                        !objectType.properties.some(isObjectTypePropertyRequired)) {
-                        return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
-                    }
-                    objectType.sortProperties();
-                    return Either.of(Maybe.of(objectType));
-                })().ifLeft(() => {
-                    this.cachedAstTypesByShapeIdentifier.delete(nodeShape.identifier);
-                });
+                    propertyEither.ifRight((property) => {
+                        objectType.addProperties(property);
+                    });
+                }
+                if (!objectType.abstract &&
+                    !objectType.extern &&
+                    objectType.fromRdfType.isNothing() &&
+                    !objectType.properties.some(isObjectTypePropertyRequired)) {
+                    return Left(new Error(`${nodeShape} has no required properties and no implicitly required rdf:type`));
+                }
+                objectType.sortProperties();
+                return Either.of(Maybe.of(objectType));
+            })().ifLeft(() => {
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstTermType.js

@@ -8,14 +8,14 @@ import { shapeNodeKinds } from "./shapeNodeKinds.js";
 export function transformShapeToAstTermType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return shapeNodeKinds(shape).chain((nodeKinds) => {
+        return shapeNodeKinds.call(this, shape).chain((nodeKinds) => {
             const hasValues = shapeStack.constraints.hasValues;
             const in_ = shapeStack.constraints.in_;
             const astAbstractTypeProperties = {
                 comment: Maybe.empty(),
                 name: Maybe.empty(),
                 label: Maybe.empty(),
-                shapeIdentifier: shape.identifier,
+                shapeIdentifier: shape.$identifier,
             };
             let termType;
             if (nodeKinds.size === 1) {
@@ -35,14 +35,16 @@ export function transformShapeToAstTermType(shape, shapeStack) {
                     case "Literal":
                         termType = new ast.LiteralType({
                             ...astAbstractTypeProperties,
-                            datatype: shape.constraints.datatype,
+                            datatype: shape.datatype,
                             hasValues: hasValues.filter((_) => _.termType === "Literal"),
                             in_: in_.filter((_) => _.termType === "Literal"),
-                            languageIn: [...new Set(shape.constraints.languageIn)],
-                            maxExclusive: shape.constraints.maxExclusive,
-                            maxInclusive: shape.constraints.maxInclusive,
-                            minExclusive: shape.constraints.minExclusive,
-                            minInclusive: shape.constraints.minInclusive,
+                            languageIn: shape.languageIn
+                                .map((languageIn) => [...new Set(languageIn)])
+                                .orDefault([]),
+                            maxExclusive: shape.maxExclusive,
+                            maxInclusive: shape.maxInclusive,
+                            minExclusive: shape.minExclusive,
+                            minInclusive: shape.minInclusive,
                         });
                         break;
                 }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstType.js

@@ -13,7 +13,7 @@ const tryTransformShapeToAstTypeMethods = [
  * not the other transformShapeToAst*Type functions directly.
  */
 export function transformShapeToAstType(shape, shapeStack) {
-    const astType = this.cachedAstTypesByShapeIdentifier.get(shape.identifier);
+    const astType = this.cachedAstTypesByShapeIdentifier.get(shape.$identifier);
     if (astType) {
         return Either.of(astType);
     }
@@ -28,14 +28,14 @@ export function transformShapeToAstType(shape, shapeStack) {
         }
         const astType = either.unsafeCoerce().extract();
         if (astType) {
-            this.cachedAstTypesByShapeIdentifier.set(shape.identifier, astType);
+            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, astType);
             return Either.of(astType);
         }
     }
     return transformShapeToAstTermType
         .call(this, shape, shapeStack)
         .ifRight((astType) => {
-        this.cachedAstTypesByShapeIdentifier.set(shape.identifier, astType);
+        this.cachedAstTypesByShapeIdentifier.set(shape.$identifier, astType);
     });
 }
 //# sourceMappingURL=transformShapeToAstType.js.map

package/dist/ast/ObjectType.d.ts

@@ -3,9 +3,9 @@ import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
 import { PropertyPath } from "rdfjs-resource";
 import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import type { PropertyVisibility } from "../enums/PropertyVisibility.js";
 import type { TsFeature } from "../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
+import type { Visibility } from "../enums/Visibility.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -146,7 +146,7 @@ export declare namespace ObjectType {
         /**
          * Visibility: private, protected, public.
          */
-        readonly visibility: PropertyVisibility;
+        readonly visibility: Visibility;
         constructor({ comment, description, label, mutable, name, objectType, order, path, shapeIdentifier, type, visibility, }: {
             comment: Maybe<string>;
             description: Maybe<string>;
@@ -158,7 +158,7 @@ export declare namespace ObjectType {
             path: PropertyPath;
             shapeIdentifier: BlankNode | NamedNode;
             type: Type;
-            visibility: PropertyVisibility;
+            visibility: Visibility;
         });
         equals(other: Property): boolean;
         /**

package/dist/enums/IdentifierMintingStrategy.d.ts

@@ -1,5 +1,9 @@
+import type { NamedNode } from "@rdfjs/types";
 /**
  * TypeScript enum corresponding to shaclmate:identifierMintingStrategy, for simpler manipulation.
  */
 export type IdentifierMintingStrategy = "blankNode" | "sha256" | "uuidv4";
+export declare namespace IdentifierMintingStrategy {
+    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256" | "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4">): IdentifierMintingStrategy;
+}
 //# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/dist/enums/IdentifierMintingStrategy.js

@@ -1,2 +1,18 @@
-export {};
+export var IdentifierMintingStrategy;
+(function (IdentifierMintingStrategy) {
+    function fromIri(iri) {
+        switch (iri.value) {
+            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
+                return "blankNode";
+            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
+                return "sha256";
+            case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
+                return "uuidv4";
+            default:
+                iri.value;
+                throw new RangeError(iri.value);
+        }
+    }
+    IdentifierMintingStrategy.fromIri = fromIri;
+})(IdentifierMintingStrategy || (IdentifierMintingStrategy = {}));
 //# sourceMappingURL=IdentifierMintingStrategy.js.map

package/dist/enums/TsObjectDeclarationType.d.ts

@@ -1,5 +1,9 @@
+import type { NamedNode } from "@rdfjs/types";
 /**
  * TypeScript enum corresponding to shaclmate:tsObjectDeclarationType, for simpler manipulation.
  */
 export type TsObjectDeclarationType = "class" | "interface";
+export declare namespace TsObjectDeclarationType {
+    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class" | "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface">): TsObjectDeclarationType;
+}
 //# sourceMappingURL=TsObjectDeclarationType.d.ts.map

package/dist/enums/TsObjectDeclarationType.js

@@ -1,2 +1,16 @@
-export {};
+export var TsObjectDeclarationType;
+(function (TsObjectDeclarationType) {
+    function fromIri(iri) {
+        switch (iri.value) {
+            case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
+                return "class";
+            case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface":
+                return "interface";
+            default:
+                iri.value;
+                throw new RangeError(iri.value);
+        }
+    }
+    TsObjectDeclarationType.fromIri = fromIri;
+})(TsObjectDeclarationType || (TsObjectDeclarationType = {}));
 //# sourceMappingURL=TsObjectDeclarationType.js.map

package/dist/enums/Visibility.d.ts

@@ -0,0 +1,6 @@
+import type { NamedNode } from "@rdfjs/types";
+export type Visibility = "private" | "protected" | "public";
+export declare namespace Visibility {
+    function fromIri(iri: NamedNode<"http://purl.org/shaclmate/ontology#_Visibility_Private" | "http://purl.org/shaclmate/ontology#_Visibility_Protected" | "http://purl.org/shaclmate/ontology#_Visibility_Public">): Visibility;
+}
+//# sourceMappingURL=Visibility.d.ts.map

package/dist/enums/Visibility.js

@@ -0,0 +1,18 @@
+export var Visibility;
+(function (Visibility) {
+    function fromIri(iri) {
+        switch (iri.value) {
+            case "http://purl.org/shaclmate/ontology#_Visibility_Private":
+                return "private";
+            case "http://purl.org/shaclmate/ontology#_Visibility_Protected":
+                return "protected";
+            case "http://purl.org/shaclmate/ontology#_Visibility_Public":
+                return "public";
+            default:
+                iri.value;
+                throw new RangeError(iri.value);
+        }
+    }
+    Visibility.fromIri = fromIri;
+})(Visibility || (Visibility = {}));
+//# sourceMappingURL=Visibility.js.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -196,7 +196,10 @@ export class AbstractCollectionType extends AbstractContainerType {
             schema = code `${schema}.nonempty().min(${this.minCount})`;
         }
         else {
-            schema = code `${schema}.default(() => [])`;
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
         }
         return schema;
     }

package/dist/generators/ts/AbstractUnionType.js

@@ -296,9 +296,9 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
                 return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
-                })), { on: "," })}])`;
+                })), { on: "," })}]).readonly()`;
             case "typeof":
-                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}])`;
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
                 throw this.discriminant;
         }

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

@@ -1,5 +1,5 @@
 import type { Maybe } from "purify-ts";
-import type { PropertyVisibility } from "../../../enums/PropertyVisibility.js";
+import type { Visibility } from "../../../enums/Visibility.js";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
@@ -74,12 +74,12 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Property visibility: private, protected, public.
      */
-    readonly visibility: PropertyVisibility;
+    readonly visibility: Visibility;
     constructor({ name, namedObjectType, type, visibility, }: {
         name: string;
         namedObjectType: NamedObjectType;
         type: TypeT;
-        visibility: PropertyVisibility;
+        visibility: Visibility;
     });
     /**
      * TypeScript object describing this type, for runtime use.

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

@@ -6,25 +6,19 @@ export function NamedObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.features.has("json")) {
         return Maybe.empty();
     }
-    const mergeZodObjectSchemas = [];
+    let properties = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(parentObjectType.jsonSchema({ context: "type" }));
+        properties.push(code `...${parentObjectType.jsonSchema({ context: "type" })}.shape`);
     }
     if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(code `${imports.z}.object({ ${joinCode(this.properties
+        properties = properties.concat(this.properties
             .flatMap((property) => property.jsonZchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`), { on: "," })} })`);
+            .map(({ key, schema }) => code `"${key}": ${schema}`));
     }
+    // ${this.properties.every((property) => !property.mutable) ? `.readonly()` : ""}
     return Maybe.of(code `\
 export function schema() {
-  return ${mergeZodObjectSchemas.length > 0
-        ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-            if (merged === null) {
-                return zodObjectSchema;
-            }
-            return code `${merged}.merge(${zodObjectSchema})`;
-        }, null)
-        : `${imports.z}.object()`} satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
+  return ${imports.z}.object({${joinCode(properties, { on: "," })}}) satisfies ${imports.z}.ZodType<${syntheticNamePrefix}Json>;
 }`);
 }
 //# sourceMappingURL=NamedObjectType_jsonSchemaFunctionDeclaration.js.map

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

@@ -101,7 +101,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get jsonSignature() {
         const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `readonly ${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
     }
     get jsonZchema() {
         let schema = this.type.jsonSchema({

package/dist/input/NodeShape.d.ts

@@ -1,49 +1,11 @@
 import type { NamedNode } from "@rdfjs/types";
-import { NodeShape as ShaclAstNodeShape } from "@shaclmate/shacl-ast";
-import { Either, type Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
-import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type * as generated from "./generated.js";
-import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
-import type { Shape } from "./Shape.js";
-export declare class NodeShape extends ShaclAstNodeShape<any, Ontology, PropertyGroup, PropertyShape, Shape> {
-    private readonly ancestorClassIris;
-    private readonly childClassIris;
-    private readonly descendantClassIris;
-    private readonly generatedNodeShape;
-    private readonly parentClassIris;
-    readonly isClass: boolean;
-    readonly isList: boolean;
-    readonly kind = "NodeShape";
-    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedNodeShape, isClass, isList, parentClassIris, shapesGraph, }: {
-        ancestorClassIris: readonly NamedNode[];
-        generatedNodeShape: generated.NodeShape;
-        childClassIris: readonly NamedNode[];
-        descendantClassIris: readonly NamedNode[];
-        isClass: boolean;
-        isList: boolean;
-        parentClassIris: readonly NamedNode[];
-        shapesGraph: ShapesGraph;
-    });
-    get abstract(): Maybe<boolean>;
-    get ancestorNodeShapes(): Either<Error, readonly NodeShape[]>;
-    get childNodeShapes(): Either<Error, readonly NodeShape[]>;
-    get comment(): Maybe<string>;
-    get descendantNodeShapes(): Either<Error, readonly NodeShape[]>;
-    get discriminantValue(): Maybe<string>;
-    get extern(): Maybe<boolean>;
-    get fromRdfType(): Maybe<NamedNode>;
-    get identifierIn(): readonly NamedNode[];
-    get identifierMintingStrategy(): Maybe<IdentifierMintingStrategy>;
-    get label(): Maybe<string>;
-    get mutable(): Maybe<boolean>;
-    get parentNodeShapes(): Either<Error, readonly NodeShape[]>;
-    get rdfType(): Maybe<NamedNode>;
-    get shaclmateName(): Maybe<string>;
-    get toRdfTypes(): readonly NamedNode[];
-    get tsFeatureExcludes(): readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-    get tsFeatureIncludes(): readonly NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
-    get tsImports(): readonly string[];
-    get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
-}
+export type NodeShape = generated.NodeShape & Readonly<{
+    ancestorClassIris: readonly NamedNode[];
+    childClassIris: readonly NamedNode[];
+    descendantClassIris: readonly NamedNode[];
+    isClass: boolean;
+    isList: boolean;
+    parentClassIris: readonly NamedNode[];
+}>;
 //# sourceMappingURL=NodeShape.d.ts.map