@shaclmate/compiler 4.0.13 → 4.0.15

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -35,6 +35,7 @@ const astListTypePlaceholderItemType = new ast.BlankNodeType({
     name: Maybe.empty(),
     shapeIdentifier: dataFactory.blankNode(),
 });
+const empty = Either.of(Maybe.empty());
 /**
  * Is an ast.ObjectType actually the shape of an RDF list?
  * If so, return the type of its rdf:first.
@@ -42,14 +43,13 @@ const astListTypePlaceholderItemType = new ast.BlankNodeType({
 export function transformShapeToAstListType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        if (shape.kind !== "NodeShape") {
-            return Either.of(Maybe.empty());
+        if (shape.$type !== "NodeShape") {
+            return empty;
         }
         const nodeShape = shape;
-        if (!nodeShape.isList) {
-            return Either.of(Maybe.empty());
-        }
-        return Eithers.chain3(nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.xone).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
+        return Eithers.chain3(nodeShapeIdentifierMintingStrategy.call(this, nodeShape), shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
+            .orDefault([])
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([identifierMintingStrategy, nodeKinds, xone]) => {
             // Put a placeholder in the cache to deal with cyclic references
             // Remove the placeholder if the transformation fails.
             const listType = new ast.ListType({
@@ -60,27 +60,27 @@ export function transformShapeToAstListType(shape, shapeStack) {
                 mutable: nodeShape.mutable.orDefault(false),
                 name: shapeAstTypeName(nodeShape),
                 identifierMintingStrategy,
-                shapeIdentifier: nodeShape.identifier,
+                shapeIdentifier: nodeShape.$identifier,
                 toRdfTypes: nodeShape.toRdfTypes,
             });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.identifier, listType);
+            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier, listType);
             return (() => {
                 let emptyListShape;
                 let nonEmptyListShape;
                 for (const shape of xone) {
-                    if (shape.constraints.hasValues.length === 1 &&
-                        shape.constraints.hasValues[0].equals(rdf.nil)) {
+                    if (shape.hasValues.length === 1 &&
+                        shape.hasValues[0].equals(rdf.nil)) {
                         emptyListShape = shape;
                     }
-                    else if (shape.kind === "NodeShape" &&
-                        shape.constraints.properties.orDefault([]).length >= 2) {
+                    else if (shape.$type === "NodeShape" &&
+                        shape.properties.length >= 2) {
                         nonEmptyListShape = shape;
                     }
                 }
                 if (!emptyListShape || !nonEmptyListShape) {
-                    return Left(new Error(`${nodeShape} does not have an sh:xone with exactly two shapes, one for the empty list and one for the non-empty list`));
+                    return empty;
                 }
-                return nonEmptyListShape.constraints.properties.chain((nonEmptyListShapeProperties) => {
+                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapeProperties) => {
                     let firstPropertyShape;
                     let restPropertyShape;
                     for (const propertyShape of nonEmptyListShapeProperties) {
@@ -95,17 +95,17 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         }
                     }
                     if (!firstPropertyShape) {
-                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:first`));
+                        return empty;
                     }
-                    if (firstPropertyShape.constraints.maxCount.extract() !== 1 ||
-                        firstPropertyShape.constraints.minCount.extract() !== 1) {
+                    if (firstPropertyShape.maxCount.extract() !== 1 ||
+                        firstPropertyShape.minCount.extract() !== 1) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     if (!restPropertyShape) {
-                        return Left(new Error(`${nodeShape} has a non-empty list shape without an sh:property shape whose sh:path is rdf:rest`));
+                        return empty;
                     }
-                    if (restPropertyShape.constraints.maxCount.extract() !== 1 ||
-                        restPropertyShape.constraints.minCount.extract() !== 1) {
+                    if (restPropertyShape.maxCount.extract() !== 1 ||
+                        restPropertyShape.minCount.extract() !== 1) {
                         return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
                     }
                     return transformPropertyShapeToAstObjectTypeProperty
@@ -127,7 +127,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                         })
                             .chain((restProperty) => {
                             if (restProperty.type.kind !== "ListType" ||
-                                !restProperty.type.shapeIdentifier.equals(nodeShape.identifier)) {
+                                !restProperty.type.shapeIdentifier.equals(nodeShape.$identifier)) {
                                 return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
                             }
                             return Either.of(Maybe.of(listType));
@@ -135,7 +135,7 @@ export function transformShapeToAstListType(shape, shapeStack) {
                     });
                 });
             })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.identifier);
+                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier);
             });
         });
     }

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -1,13 +1,16 @@
+import { owl, rdfs } from "@tpluscode/rdf-ns-builders";
 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 +46,141 @@ 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.orDefault([]).length > 0 ||
+            nodeShape.xone.orDefault([]).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.chain5(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(([identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType,]) => {
+            const abstract = nodeShape.abstract.orDefault(false);
+            const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShape.$identifier);
+            const isClass = nodeShape.subClassOf.length > 0 ||
+                descendantNodeShapes.length > 0 || // A node shape that is the object of an rdfs:subClassOf is itself an rdfs:Class
+                nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
+            let fromRdfType;
+            let toRdfTypes;
+            if (!abstract) {
+                fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
+                if (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

@@ -55,12 +55,6 @@ export class AbstractCollectionType extends AbstractContainerType {
             }
         }
         if (this.minCount === 0) {
-            conversions.push({
-                conversionExpression: () => code `[]`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
             if (Object.keys(itemTypeConversionsByTypeof).length <= 1) {
                 // There were no additional conversions with different item typeof's, so we don't need to check .every or do .map
                 // Just check that the original value is an array with typeof "object". Array.isArray() doesn't narrow types for some reason.
@@ -101,7 +95,7 @@ export class AbstractCollectionType extends AbstractContainerType {
                                 case "function":
                                 case "symbol":
                                 case "undefined":
-                                    throw new Error("not implemented");
+                                    throw new Error(`source type check on ${itemTypeof} not implemented`);
                             }
                         },
                         sourceTypeName: code `readonly (${itemTypeofConversion.sourceTypeName})[]`,

package/dist/generators/ts/AbstractTermType.d.ts

@@ -31,6 +31,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
+    get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];

package/dist/generators/ts/AbstractTermType.js

@@ -90,6 +90,9 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get termTypes() {
+        return new Set([...this.nodeKinds].map(NodeKind.toTermType));
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `((_: object) => [])`;
     }
@@ -164,6 +167,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractTermType.prototype, "termTypes", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "valueSparqlConstructTriplesFunction", null);