@lde/pipeline-void 0.2.34 → 0.2.35

package/dist/index.d.ts

@@ -3,4 +3,5 @@ export * from './sparqlQueryAnalyzer.js';
 export * from './perClassAnalyzer.js';
 export * from './vocabularyAnalyzer.js';
 export * from './provenance.js';
+export * from './uriSpaceExecutor.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -3,3 +3,4 @@ export * from './sparqlQueryAnalyzer.js';
 export * from './perClassAnalyzer.js';
 export * from './vocabularyAnalyzer.js';
 export * from './provenance.js';
+export * from './uriSpaceExecutor.js';

package/dist/uriSpaceExecutor.d.ts

@@ -0,0 +1,18 @@
+import { Dataset, Distribution } from '@lde/dataset';
+import { NotSupported, type Executor, type ExecuteOptions } from '@lde/pipeline';
+import type { Quad } from '@rdfjs/types';
+/**
+ * Executor decorator that consumes `void:Linkset` quads from the inner executor,
+ * matches each `void:objectsTarget` against configured URI spaces using `startsWith`,
+ * aggregates triple counts per matched space, and emits filtered `void:Linkset` quads.
+ *
+ * Inner quads are consumed and replaced with aggregated output — unmatched URI spaces
+ * are discarded.
+ */
+export declare class UriSpaceExecutor implements Executor {
+    private readonly inner;
+    private readonly uriSpaces;
+    constructor(inner: Executor, uriSpaces: ReadonlyMap<string, readonly Quad[]>);
+    execute(dataset: Dataset, distribution: Distribution, options?: ExecuteOptions): Promise<AsyncIterable<Quad> | NotSupported>;
+}
+//# sourceMappingURL=uriSpaceExecutor.d.ts.map

package/dist/uriSpaceExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uriSpaceExecutor.d.ts","sourceRoot":"","sources":["../src/uriSpaceExecutor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAgBzC;;;;;;;GAOG;AACH,qBAAa,gBAAiB,YAAW,QAAQ;IAE7C,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBADT,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC;IAG5D,OAAO,CACX,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,YAAY,EAC1B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC;CAO/C"}

package/dist/uriSpaceExecutor.js

@@ -0,0 +1,81 @@
+import { NotSupported, } from '@lde/pipeline';
+import { DataFactory } from 'n3';
+const { namedNode, quad, literal, blankNode } = DataFactory;
+const RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+const VOID = 'http://rdfs.org/ns/void#';
+const XSD = 'http://www.w3.org/2001/XMLSchema#';
+const rdfType = namedNode(`${RDF}type`);
+const voidLinkset = namedNode(`${VOID}Linkset`);
+const voidSubjectsTarget = namedNode(`${VOID}subjectsTarget`);
+const voidObjectsTarget = namedNode(`${VOID}objectsTarget`);
+const voidTriples = namedNode(`${VOID}triples`);
+const xsdInteger = namedNode(`${XSD}integer`);
+/**
+ * Executor decorator that consumes `void:Linkset` quads from the inner executor,
+ * matches each `void:objectsTarget` against configured URI spaces using `startsWith`,
+ * aggregates triple counts per matched space, and emits filtered `void:Linkset` quads.
+ *
+ * Inner quads are consumed and replaced with aggregated output — unmatched URI spaces
+ * are discarded.
+ */
+export class UriSpaceExecutor {
+    inner;
+    uriSpaces;
+    constructor(inner, uriSpaces) {
+        this.inner = inner;
+        this.uriSpaces = uriSpaces;
+    }
+    async execute(dataset, distribution, options) {
+        const result = await this.inner.execute(dataset, distribution, options);
+        if (result instanceof NotSupported) {
+            return result;
+        }
+        return withUriSpaces(result, dataset.iri.toString(), this.uriSpaces);
+    }
+}
+async function* withUriSpaces(quads, datasetIri, uriSpaces) {
+    // Group inner quads by subject (each subject = one Linkset).
+    const linksets = new Map();
+    for await (const q of quads) {
+        let group = linksets.get(q.subject.value);
+        if (group === undefined) {
+            group = [];
+            linksets.set(q.subject.value, group);
+        }
+        group.push(q);
+    }
+    // Extract objectsTarget and triples count per Linkset,
+    // match against configured URI spaces, and aggregate counts.
+    const aggregated = new Map();
+    for (const group of linksets.values()) {
+        const objectsTarget = group.find((q) => q.predicate.equals(voidObjectsTarget))?.object.value;
+        const triplesValue = group.find((q) => q.predicate.equals(voidTriples))
+            ?.object.value;
+        if (objectsTarget === undefined || triplesValue === undefined)
+            continue;
+        const count = parseInt(triplesValue, 10);
+        for (const [uriSpace, metadata] of uriSpaces) {
+            if (objectsTarget.startsWith(uriSpace)) {
+                const existing = aggregated.get(uriSpace);
+                aggregated.set(uriSpace, {
+                    count: (existing?.count ?? 0) + count,
+                    metadata,
+                });
+                break;
+            }
+        }
+    }
+    // Emit aggregated Linkset quads.
+    const datasetNode = namedNode(datasetIri);
+    for (const [uriSpace, { count, metadata }] of aggregated) {
+        const linksetNode = blankNode();
+        const uriSpaceNode = namedNode(uriSpace);
+        yield quad(linksetNode, rdfType, voidLinkset);
+        yield quad(linksetNode, voidSubjectsTarget, datasetNode);
+        yield quad(linksetNode, voidObjectsTarget, uriSpaceNode);
+        yield quad(linksetNode, voidTriples, literal(count.toString(), xsdInteger));
+        for (const metadataQuad of metadata) {
+            yield metadataQuad;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline-void",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
   "repository": {
     "url": "https://github.com/ldengine/lde",