@rdfx/builder 0.0.30 → 0.0.31

package/dist/skos.d.ts

@@ -0,0 +1,21 @@
+import type { NamespaceBuilder } from "@rdfjs/namespace";
+import type { NamedNode } from "@rdfjs/types";
+import { skos_Concept, skos_ConceptScheme } from "./shapes.js";
+export interface ConvertibleConceptParameters<ConceptIriString extends string> extends Omit<Parameters<typeof skos_Concept.createUnsafe>[0], "$identifier" | "broader" | "termType"> {
+    readonly broader?: ConvertibleRelatedConcepts<ConceptIriString>;
+}
+type ConvertibleRelatedConcepts<ConceptIriString> = ConceptIriString | NamedNode | skos_Concept | readonly (ConceptIriString | NamedNode | skos_Concept)[];
+export declare function skos<NamespaceT extends NamespaceBuilder>({ namespace, }: {
+    namespace: NamespaceT;
+}): {
+    Concept: ($identifier: NamedNode | (keyof NamespaceT & string), parameters?: ConvertibleConceptParameters<keyof NamespaceT & string>) => skos_Concept;
+    ConceptScheme: <ConceptsRecordT extends { [K in keyof ConceptsRecordT]: Omit<ConvertibleConceptParameters<Extract<keyof ConceptsRecordT, string>>, "broader" | "notation"> & {
+        readonly $identifier?: (keyof NamespaceT & string) | NamedNode;
+        readonly broader?: ConvertibleRelatedConcepts<Extract<keyof ConceptsRecordT, string>> | undefined;
+        readonly notation?: boolean | ConvertibleConceptParameters<Extract<keyof T, string>>["notation"];
+    }; }>($identifier: NamedNode | (keyof NamespaceT & string), parameters?: Omit<Parameters<typeof skos_ConceptScheme.createUnsafe>[0], "$identifier" | "concepts" | "termType" | "topConcepts"> & {
+        readonly concepts?: ConceptsRecordT;
+    }) => skos_ConceptScheme;
+};
+export {};
+//# sourceMappingURL=skos.d.ts.map

package/dist/skos.js

@@ -0,0 +1,56 @@
+import dataFactory from "@rdfx/data-factory";
+import { skos_Concept, skos_ConceptScheme } from "./shapes.js";
+import { toIri } from "./toIri.js";
+function convertRelatedConcepts(relatedConcepts, toIri) {
+    if (!relatedConcepts) {
+        return [];
+    }
+    return (Array.isArray(relatedConcepts)
+        ? relatedConcepts
+        : [relatedConcepts]).map((relatedConcept) => {
+        if (typeof relatedConcept === "string") {
+            return toIri(relatedConcept);
+        }
+        return relatedConcept;
+    });
+}
+export function skos({ namespace, }) {
+    function ConceptBuilder($identifier, parameters) {
+        const { broader: broaderParameter, ...otherParameters } = parameters ?? {};
+        return skos_Concept.createUnsafe({
+            ...otherParameters,
+            $identifier: toIri($identifier, namespace),
+            broader: convertRelatedConcepts(broaderParameter, (key) => toIri(key, namespace)),
+        });
+    }
+    return {
+        Concept: ConceptBuilder,
+        ConceptScheme: ($identifier, parameters) => {
+            const { concepts: conceptsRecord, ...otherParameters } = parameters ?? {};
+            const conceptSchemeIdentifier = toIri($identifier, namespace);
+            const conceptsRecordKeyToIri = (conceptsRecordKey) => dataFactory.namedNode(`${conceptSchemeIdentifier.value}_${conceptsRecordKey}`);
+            const concepts = [];
+            for (const [conceptsRecordKey, conceptsRecordValue] of Object.entries(conceptsRecord ?? {})) {
+                concepts.push(ConceptBuilder(conceptsRecordValue.$identifier
+                    ? toIri(conceptsRecordValue.$identifier, namespace)
+                    : conceptsRecordKeyToIri(conceptsRecordKey), {
+                    ...conceptsRecordValue,
+                    broader: convertRelatedConcepts(conceptsRecordValue.broader, conceptsRecordKeyToIri),
+                    notation: typeof conceptsRecordValue.notation === "boolean" &&
+                        conceptsRecordValue.notation
+                        ? [dataFactory.literal(conceptsRecordKey)]
+                        : conceptsRecordValue.notation,
+                }));
+            }
+            return skos_ConceptScheme.createUnsafe({
+                ...otherParameters,
+                $identifier: conceptSchemeIdentifier,
+                concepts,
+                topConcepts: concepts
+                    .filter((concept) => concept.broader.length === 0)
+                    .map((concept) => concept.$identifier()),
+            });
+        },
+    };
+}
+//# sourceMappingURL=skos.js.map

package/dist/toIri.d.ts

@@ -1,4 +1,4 @@
 import type { NamespaceBuilder } from "@rdfjs/namespace";
 import type { NamedNode } from "@rdfjs/types";
-export declare function toIri<NamespaceT extends NamespaceBuilder>(iri: keyof NamespaceT | NamedNode, namespace: NamespaceT): NamedNode;
+export declare function toIri<NamespaceT extends NamespaceBuilder>(iri: (keyof NamespaceT & string) | NamedNode, namespace: NamespaceT): NamedNode;
 //# sourceMappingURL=toIri.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@rdfx/data-factory": "0.0.30",
-    "@rdfx/resource": "0.0.30",
+    "@rdfx/data-factory": "0.0.31",
+    "@rdfx/resource": "0.0.31",
     "@rdfjs/namespace": "~2.0.1",
     "@rdfjs/types": "~2.0.1",
     "@types/rdfjs__namespace": "~2.0.10",
@@ -9,9 +9,13 @@
     "ts-invariant": "~0.10.3"
   },
   "devDependencies": {
-    "@rdfx/fs": "0.0.30",
-    "@shaclmate/compiler": "4.0.52",
+    "@rdfx/fs": "0.0.31",
+    "@rdfx/resource": "0.0.31",
+    "@rdfjs/dataset": "~2.0.2",
+    "@shaclmate/compiler": "4.0.65",
+    "@shaclmate/validator": "4.0.65",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
+    "@types/rdfjs__dataset": "~2.0.7",
     "ts-log": "~3.0.2"
   },
   "files": [
@@ -37,5 +41,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.0.30"
+  "version": "0.0.31"
 }