@rdfx/builder 0.0.32 → 0.0.34

package/dist/sh.js

@@ -1,56 +1,61 @@
 import dataFactory from "@rdfx/data-factory";
-import { sh_PropertyShape } from "./shapes.js";
-import { toIri } from "./toIri.js";
-export function sh({ namespace, }) {
-    return {
-        PropertyShape: ($identifier, parameters) => {
-            // Order of default population matters here.
-            const { cardinality: cardinalityParameter, classes: classesParameter, in_: inParameter, path: pathParameter, node: nodeParameter, resolve: resolveParameter, ...otherParameters } = parameters;
-            let $identifierTerm;
-            switch (typeof $identifier) {
-                case "object":
-                    $identifierTerm = $identifier;
-                    break;
-                case "string":
-                    $identifierTerm = toIri($identifier, namespace);
-                    break;
-                case "undefined":
-                    $identifierTerm = dataFactory.blankNode();
-                    break;
-                default:
-                    throw new RangeError(typeof $identifier);
-            }
-            let in_;
-            // let inConceptScheme: ConceptScheme<any> | undefined;
-            // if (inParameter) {
-            //   if (Array.isArray(inParameter)) {
-            //     in_ = inParameter;
-            //   } else {
-            //     inConceptScheme = inParameter as ConceptScheme<any>;
-            //     in_ = Object.values(inConceptScheme.concepts).map(
-            //       (concept) => concept.identifier,
-            //     );
-            //   }
-            // }
-            let path;
-            switch (typeof pathParameter) {
-                case "object":
-                    path = pathParameter;
-                    break;
-                case "string":
-                    path = toIri(pathParameter, namespace);
-                    break;
-                case "undefined":
-                    if ($identifierTerm.termType === "BlankNode") {
-                        throw new Error("must specify a path if identifier is a BlankNode/undefined");
-                    }
-                    path = $identifierTerm;
-                    break;
-                default:
-                    throw new RangeError(typeof pathParameter);
+import { LiteralFactory } from "@rdfx/literal";
+import { sh as _namespace, owl, rdfs } from "@tpluscode/rdf-ns-builders";
+import { sh_NodeShape, sh_PropertyShape, } from "./shapes.js";
+const literalFactory = new LiteralFactory({ dataFactory });
+function convertIn(in_) {
+    if (!in_) {
+        return undefined;
+    }
+    if (Array.isArray(in_)) {
+        const inArray = in_;
+        return inArray.map((item) => {
+            if (typeof item === "object") {
+                if (item instanceof Date) {
+                    return literalFactory.date(item);
+                }
+                return item;
             }
-            let maxCount;
-            let minCount;
+            return literalFactory.primitive(item);
+        });
+    }
+    const inConceptScheme = in_;
+    return inConceptScheme.concepts.map((concept) => concept.termType === "NamedNode" ? concept : concept.$identifier());
+}
+function convertNodeKind(nodeKind) {
+    if (!nodeKind) {
+        return undefined;
+    }
+    if (typeof nodeKind === "object") {
+        return nodeKind;
+    }
+    return _namespace[nodeKind];
+}
+export function sh({ namespace, toIdentifier, toIri, toIriArray, }) {
+    function PropertyShape($identifier, parameters) {
+        // Order of default population matters here.
+        const { cardinality: cardinalityParameter, class: classParameter, in_: inParameter, path: pathParameter, node: nodeParameter, nodeKind: nodeKindParameter, resolve: resolveParameter, ...otherParameters } = parameters ?? {};
+        const $identifierTerm = toIdentifier($identifier);
+        let path;
+        switch (typeof pathParameter) {
+            case "object":
+                path = pathParameter;
+                break;
+            case "string":
+                path = toIri(pathParameter);
+                break;
+            case "undefined":
+                if ($identifierTerm.termType === "BlankNode") {
+                    throw new Error("must specify a path if identifier is a BlankNode/undefined");
+                }
+                path = $identifierTerm;
+                break;
+            default:
+                throw new RangeError(typeof pathParameter);
+        }
+        let maxCount;
+        let minCount;
+        if (cardinalityParameter) {
             switch (cardinalityParameter) {
                 case "optional":
                     maxCount = 1n;
@@ -62,28 +67,94 @@ export function sh({ namespace, }) {
                 case "set":
                     break;
             }
-            let classes;
-            if (parameters.classes) {
-                classes = parameters.classes.map((class_) => toIri(class_, namespace));
+        }
+        return sh_PropertyShape.createUnsafe({
+            ...otherParameters,
+            $identifier: $identifierTerm,
+            class_: classParameter ? toIriArray(classParameter) : undefined,
+            in_: convertIn(inParameter),
+            maxCount,
+            minCount,
+            node: nodeParameter ? toIri(nodeParameter) : undefined,
+            nodeKind: nodeKindParameter
+                ? convertNodeKind(nodeKindParameter)
+                : undefined,
+            path,
+            resolve: resolveParameter ? toIri(resolveParameter) : undefined,
+        });
+    }
+    return {
+        namespace: _namespace,
+        NodeShape: ($identifier, parameters) => {
+            const nodeShapeIdentifier = toIdentifier($identifier);
+            let { implicitClassTarget, in_: inParameter, nodeKind: nodeKindParameter, properties: propertiesParameter, shaclmateName, type: typeParameter, xone: xoneParameter, ...otherParameters } = parameters ?? {};
+            let properties;
+            if (propertiesParameter) {
+                if (Array.isArray(propertiesParameter)) {
+                    properties = propertiesParameter.map((property) => {
+                        if (typeof property === "string") {
+                            return toIri(property);
+                        }
+                        return property;
+                    });
+                }
+                else {
+                    properties = Object.entries(propertiesParameter).map(([key, propertyParameters]) => {
+                        let { $identifier, path, name, shaclmateName, ...otherPropertyParameters } = propertyParameters;
+                        // Order of checks here is important.
+                        let identifierTerm;
+                        if ($identifier) {
+                            identifierTerm = toIdentifier($identifier);
+                        }
+                        else {
+                            if (nodeShapeIdentifier.termType === "NamedNode") {
+                                identifierTerm = dataFactory.namedNode(`${nodeShapeIdentifier.value}-${key}`);
+                            }
+                            else {
+                                identifierTerm = dataFactory.blankNode();
+                            }
+                        }
+                        if (!name && !shaclmateName) {
+                            name = key;
+                        }
+                        if (!path) {
+                            path = namespace(key);
+                        }
+                        return PropertyShape(identifierTerm, {
+                            ...otherPropertyParameters,
+                            name,
+                            path,
+                            shaclmateName,
+                        });
+                    });
+                }
+            }
+            if (!shaclmateName && typeof $identifier === "string") {
+                shaclmateName = $identifier;
+            }
+            let type;
+            if (typeParameter) {
+                type = toIriArray(typeParameter).concat();
+                if (implicitClassTarget &&
+                    !type.some((type) => type.equals(rdfs.Class) || type.equals(owl.Class))) {
+                    type.push(rdfs.Class);
+                }
+            }
+            else if (implicitClassTarget) {
+                type = [rdfs.Class];
             }
-            // else if (inConceptScheme) {
-            //   classes = [(namespace as any)(inConceptScheme.className)];
-            // }
-            const finalParameters = {
+            return sh_NodeShape.createUnsafe({
                 ...otherParameters,
-                $identifier: $identifierTerm,
-                classes,
-                in_,
-                maxCount,
-                minCount,
-                node: nodeParameter ? toIri(nodeParameter, namespace) : undefined,
-                path,
-                resolve: resolveParameter
-                    ? toIri(resolveParameter, namespace)
-                    : undefined,
-            };
-            return sh_PropertyShape.createUnsafe(finalParameters);
+                $identifier: nodeShapeIdentifier,
+                in_: convertIn(inParameter),
+                nodeKind: convertNodeKind(nodeKindParameter),
+                properties,
+                shaclmateName,
+                type,
+                xone: xoneParameter ? xoneParameter.map(toIri) : undefined,
+            });
         },
+        PropertyShape,
     };
 }
 //# sourceMappingURL=sh.js.map