@lde/pipeline-void 0.2.2

package/README.md

@@ -0,0 +1,46 @@
+# Pipeline VOiD
+
+VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets.
+
+## Analyzers
+
+- **SparqlQueryAnalyzer** — Execute SPARQL CONSTRUCT queries with template substitution
+- **PerClassAnalyzer** — Two-phase analyzer that iterates over classes to avoid timeouts
+
+## SPARQL Queries
+
+Generic VOiD analysis queries included:
+
+| Query                              | Description                           |
+| ---------------------------------- | ------------------------------------- |
+| `triples.rq`                       | Total triple count                    |
+| `subjects.rq`                      | Distinct subjects                     |
+| `properties.rq`                    | Distinct properties                   |
+| `class-partition.rq`               | Classes with entity counts            |
+| `class-properties-subjects.rq`     | Properties per class (subject counts) |
+| `class-properties-objects.rq`      | Properties per class (object counts)  |
+| `class-property-datatypes.rq`      | Per-class datatype partitions         |
+| `class-property-languages.rq`      | Per-class language tags               |
+| `class-property-object-classes.rq` | Per-class object class partitions     |
+| `object-literals.rq`               | Literal object counts                 |
+| `object-uris.rq`                   | URI object counts                     |
+| `object-uri-space.rq`              | Object URI namespaces                 |
+| `subject-uri-space.rq`             | Subject URI namespaces                |
+| `datatypes.rq`                     | Dataset-level datatypes               |
+| `entity-properties.rq`             | Property statistics                   |
+| `licenses.rq`                      | License detection                     |
+
+## Usage
+
+```typescript
+import { SparqlQueryAnalyzer } from '@lde/pipeline-void';
+
+// Load a query from file
+const analyzer = await SparqlQueryAnalyzer.fromFile('triples.rq');
+
+// Execute against a dataset
+const result = await analyzer.execute(dataset);
+if (result instanceof Success) {
+  // result.data contains the VOiD statistics as RDF
+}
+```

package/dist/analyzer.d.ts

@@ -0,0 +1,41 @@
+import { Dataset } from '@lde/dataset';
+import type { DatasetCore } from '@rdfjs/types';
+/**
+ * Result of a successful analysis.
+ */
+export declare class Success {
+    readonly data: DatasetCore;
+    constructor(data: DatasetCore);
+}
+/**
+ * Analysis failed.
+ */
+export declare class Failure {
+    readonly endpoint: URL;
+    readonly message?: string | undefined;
+    constructor(endpoint: URL, message?: string | undefined);
+}
+/**
+ * Analysis is not supported for this dataset (e.g., no SPARQL distribution).
+ */
+export declare class NotSupported {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Interface for VOiD analyzers.
+ */
+export interface Analyzer {
+    readonly name: string;
+    execute(dataset: Dataset): Promise<Success | Failure | NotSupported>;
+    finish?(): Promise<void>;
+}
+/**
+ * Base class for analyzers with default implementations.
+ */
+export declare abstract class BaseAnalyzer implements Analyzer {
+    abstract readonly name: string;
+    abstract execute(dataset: Dataset): Promise<Success | Failure | NotSupported>;
+    finish(): Promise<void>;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;GAEG;AACH,qBAAa,OAAO;aACU,IAAI,EAAE,WAAW;gBAAjB,IAAI,EAAE,WAAW;CAC9C;AAED;;GAEG;AACH,qBAAa,OAAO;aAEA,QAAQ,EAAE,GAAG;aACb,OAAO,CAAC,EAAE,MAAM;gBADhB,QAAQ,EAAE,GAAG,EACb,OAAO,CAAC,EAAE,MAAM,YAAA;CAEnC;AAED;;GAEG;AACH,qBAAa,YAAY;aACK,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC,CAAC;IACrE,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;GAEG;AACH,8BAAsB,YAAa,YAAW,QAAQ;IACpD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;IAEvE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9B"}

package/dist/analyzer.js

@@ -0,0 +1,37 @@
+/**
+ * Result of a successful analysis.
+ */
+export class Success {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+/**
+ * Analysis failed.
+ */
+export class Failure {
+    endpoint;
+    message;
+    constructor(endpoint, message) {
+        this.endpoint = endpoint;
+        this.message = message;
+    }
+}
+/**
+ * Analysis is not supported for this dataset (e.g., no SPARQL distribution).
+ */
+export class NotSupported {
+    message;
+    constructor(message) {
+        this.message = message;
+    }
+}
+/**
+ * Base class for analyzers with default implementations.
+ */
+export class BaseAnalyzer {
+    async finish() {
+        // Default no-op implementation.
+    }
+}

package/dist/datatypeAnalyzer.d.ts

@@ -0,0 +1,13 @@
+import { PerClassAnalyzer, type PerClassAnalyzerOptions } from './perClassAnalyzer.js';
+/**
+ * Per-class analyzer for datatype partitions.
+ *
+ * Detects which datatypes are used for each property of each class.
+ */
+export declare class DatatypeAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create a DatatypeAnalyzer.
+     */
+    static create(options?: PerClassAnalyzerOptions): Promise<DatatypeAnalyzer>;
+}
+//# sourceMappingURL=datatypeAnalyzer.d.ts.map

package/dist/datatypeAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datatypeAnalyzer.d.ts","sourceRoot":"","sources":["../src/datatypeAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAI/B;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,gBAAgB;IACpD;;OAEG;WACiB,MAAM,CACxB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC;CAI7B"}

package/dist/datatypeAnalyzer.js

@@ -0,0 +1,16 @@
+import { PerClassAnalyzer, } from './perClassAnalyzer.js';
+const QUERY_FILE = 'class-property-datatypes.rq';
+/**
+ * Per-class analyzer for datatype partitions.
+ *
+ * Detects which datatypes are used for each property of each class.
+ */
+export class DatatypeAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create a DatatypeAnalyzer.
+     */
+    static async create(options) {
+        const query = await PerClassAnalyzer.loadQuery(QUERY_FILE);
+        return new DatatypeAnalyzer(QUERY_FILE, query, options);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type Analyzer, BaseAnalyzer, Success, Failure, NotSupported, } from '@lde/pipeline/analyzer';
+export * from './sparqlQueryAnalyzer.js';
+export * from './perClassAnalyzer.js';
+export * from './vocabularyAnalyzer.js';
+export * from './provenance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,5 @@
+export { BaseAnalyzer, Success, Failure, NotSupported, } from '@lde/pipeline/analyzer';
+export * from './sparqlQueryAnalyzer.js';
+export * from './perClassAnalyzer.js';
+export * from './vocabularyAnalyzer.js';
+export * from './provenance.js';

package/dist/languageAnalyzer.d.ts

@@ -0,0 +1,13 @@
+import { PerClassAnalyzer, type PerClassAnalyzerOptions } from './perClassAnalyzer.js';
+/**
+ * Per-class analyzer for language partitions.
+ *
+ * Detects which language tags are used for each property of each class.
+ */
+export declare class LanguageAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create a LanguageAnalyzer.
+     */
+    static create(options?: PerClassAnalyzerOptions): Promise<LanguageAnalyzer>;
+}
+//# sourceMappingURL=languageAnalyzer.d.ts.map

package/dist/languageAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageAnalyzer.d.ts","sourceRoot":"","sources":["../src/languageAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAI/B;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,gBAAgB;IACpD;;OAEG;WACiB,MAAM,CACxB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC;CAI7B"}

package/dist/languageAnalyzer.js

@@ -0,0 +1,16 @@
+import { PerClassAnalyzer, } from './perClassAnalyzer.js';
+const QUERY_FILE = 'class-property-languages.rq';
+/**
+ * Per-class analyzer for language partitions.
+ *
+ * Detects which language tags are used for each property of each class.
+ */
+export class LanguageAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create a LanguageAnalyzer.
+     */
+    static async create(options) {
+        const query = await PerClassAnalyzer.loadQuery(QUERY_FILE);
+        return new LanguageAnalyzer(QUERY_FILE, query, options);
+    }
+}

package/dist/objectClassAnalyzer.d.ts

@@ -0,0 +1,13 @@
+import { PerClassAnalyzer, type PerClassAnalyzerOptions } from './perClassAnalyzer.js';
+/**
+ * Per-class analyzer for object class partitions.
+ *
+ * Detects which classes appear as objects for each property of each class.
+ */
+export declare class ObjectClassAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create an ObjectClassAnalyzer.
+     */
+    static create(options?: PerClassAnalyzerOptions): Promise<ObjectClassAnalyzer>;
+}
+//# sourceMappingURL=objectClassAnalyzer.d.ts.map

package/dist/objectClassAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectClassAnalyzer.d.ts","sourceRoot":"","sources":["../src/objectClassAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAC;AAI/B;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,gBAAgB;IACvD;;OAEG;WACiB,MAAM,CACxB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,mBAAmB,CAAC;CAIhC"}

package/dist/objectClassAnalyzer.js

@@ -0,0 +1,16 @@
+import { PerClassAnalyzer, } from './perClassAnalyzer.js';
+const QUERY_FILE = 'class-property-object-classes.rq';
+/**
+ * Per-class analyzer for object class partitions.
+ *
+ * Detects which classes appear as objects for each property of each class.
+ */
+export class ObjectClassAnalyzer extends PerClassAnalyzer {
+    /**
+     * Create an ObjectClassAnalyzer.
+     */
+    static async create(options) {
+        const query = await PerClassAnalyzer.loadQuery(QUERY_FILE);
+        return new ObjectClassAnalyzer(QUERY_FILE, query, options);
+    }
+}

package/dist/perClassAnalyzer.d.ts

@@ -0,0 +1,51 @@
+import { type ExecutableDataset } from '@lde/pipeline';
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import { BaseAnalyzer, Success, Failure, NotSupported } from '@lde/pipeline/analyzer';
+export interface PerClassAnalyzerOptions {
+    /**
+     * Timeout for SPARQL queries in milliseconds.
+     * @default 300000 (5 minutes)
+     */
+    timeout?: number;
+    /**
+     * Custom SparqlEndpointFetcher instance.
+     */
+    fetcher?: SparqlEndpointFetcher;
+    /**
+     * Maximum number of classes to analyze.
+     * @default 1000
+     */
+    maxClasses?: number;
+}
+/**
+ * Two-phase analyzer that first retrieves classes, then runs a query for each class.
+ *
+ * This approach prevents timeouts and OOM errors on large datasets by splitting
+ * the analysis into smaller queries per class.
+ *
+ * Supports template substitution:
+ * - `#subjectFilter#` — replaced with the dataset's subject filter (if any)
+ * - `#namedGraph#` — replaced with `FROM <graph>` clause if the distribution has a named graph
+ * - `?dataset` — replaced with the dataset IRI
+ * - `<#class#>` — replaced with the current class IRI
+ */
+export declare class PerClassAnalyzer extends BaseAnalyzer {
+    readonly name: string;
+    private readonly fetcher;
+    private readonly executor;
+    private readonly maxClasses;
+    constructor(name: string, query: string, options?: PerClassAnalyzerOptions);
+    /**
+     * Create an analyzer from a query file in the queries directory.
+     *
+     * @param filename Query filename (e.g., 'class-property-datatypes.rq')
+     * @param options Optional analyzer options
+     */
+    static fromFile(filename: string, options?: PerClassAnalyzerOptions): Promise<PerClassAnalyzer>;
+    execute(dataset: ExecutableDataset): Promise<Success | Failure | NotSupported>;
+    private getClasses;
+}
+export declare function createDatatypeAnalyzer(options?: PerClassAnalyzerOptions): Promise<PerClassAnalyzer>;
+export declare function createLanguageAnalyzer(options?: PerClassAnalyzerOptions): Promise<PerClassAnalyzer>;
+export declare function createObjectClassAnalyzer(options?: PerClassAnalyzerOptions): Promise<PerClassAnalyzer>;
+//# sourceMappingURL=perClassAnalyzer.d.ts.map

package/dist/perClassAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perClassAnalyzer.d.ts","sourceRoot":"","sources":["../src/perClassAnalyzer.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EACL,YAAY,EACZ,OAAO,EACP,OAAO,EACP,YAAY,EACb,MAAM,wBAAwB,CAAC;AAIhC,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;aAM9B,IAAI,EAAE,MAAM;IAL9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IACnD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAGlB,IAAI,EAAE,MAAM,EAC5B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,uBAAuB;IAgBnC;;;;;OAKG;WACiB,QAAQ,CAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC;IAKf,OAAO,CAClB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;YAiC9B,UAAU;CAkCzB;AAED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAE3B;AAED,wBAAgB,sBAAsB,CACpC,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAE3B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/dist/perClassAnalyzer.js

@@ -0,0 +1,105 @@
+import { SparqlConstructExecutor, substituteQueryTemplates, readQueryFile, collect, } from '@lde/pipeline';
+import { Store } from 'n3';
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BaseAnalyzer, Success, Failure, NotSupported, } from '@lde/pipeline/analyzer';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Two-phase analyzer that first retrieves classes, then runs a query for each class.
+ *
+ * This approach prevents timeouts and OOM errors on large datasets by splitting
+ * the analysis into smaller queries per class.
+ *
+ * Supports template substitution:
+ * - `#subjectFilter#` — replaced with the dataset's subject filter (if any)
+ * - `#namedGraph#` — replaced with `FROM <graph>` clause if the distribution has a named graph
+ * - `?dataset` — replaced with the dataset IRI
+ * - `<#class#>` — replaced with the current class IRI
+ */
+export class PerClassAnalyzer extends BaseAnalyzer {
+    name;
+    fetcher;
+    executor;
+    maxClasses;
+    constructor(name, query, options) {
+        super();
+        this.name = name;
+        this.fetcher =
+            options?.fetcher ??
+                new SparqlEndpointFetcher({
+                    timeout: options?.timeout ?? 300_000,
+                });
+        this.maxClasses = options?.maxClasses ?? 1000;
+        this.executor = new SparqlConstructExecutor({
+            query,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            fetcher: this.fetcher,
+        });
+    }
+    /**
+     * Create an analyzer from a query file in the queries directory.
+     *
+     * @param filename Query filename (e.g., 'class-property-datatypes.rq')
+     * @param options Optional analyzer options
+     */
+    static async fromFile(filename, options) {
+        const query = await readQueryFile(resolve(__dirname, 'queries', filename));
+        return new PerClassAnalyzer(filename, query, options);
+    }
+    async execute(dataset) {
+        const sparqlDistribution = dataset.getSparqlDistribution();
+        if (sparqlDistribution === null) {
+            return new NotSupported('No SPARQL distribution available');
+        }
+        const store = new Store();
+        try {
+            // Phase 1: Get all classes.
+            const classes = await this.getClasses(sparqlDistribution, dataset);
+            // Phase 2: Run query for each class via SparqlConstructExecutor.
+            for (const classIri of classes) {
+                const result = await this.executor.execute(dataset, {
+                    bindings: { '<#class#>': `<${classIri}>` },
+                });
+                if (result instanceof NotSupported) {
+                    return result;
+                }
+                store.addQuads([...(await collect(result))]);
+            }
+        }
+        catch (e) {
+            const accessUrl = sparqlDistribution.accessUrl;
+            return new Failure(accessUrl ?? new URL('unknown://'), e instanceof Error ? e.message : undefined);
+        }
+        return new Success(store);
+    }
+    async getClasses(distribution, dataset) {
+        const classQuery = substituteQueryTemplates(`SELECT DISTINCT ?class
+       #namedGraph#
+       WHERE {
+         #subjectFilter#
+         ?s a ?class .
+       }
+       LIMIT ${this.maxClasses}`, distribution, dataset);
+        const bindings = await this.fetcher.fetchBindings(distribution.accessUrl.toString(), classQuery);
+        const classes = [];
+        for await (const binding of bindings) {
+            // Bindings are Record<string, RDF.Term>.
+            const bindingRecord = binding;
+            const classValue = bindingRecord['class'];
+            if (classValue && classValue.termType === 'NamedNode') {
+                classes.push(classValue.value);
+            }
+        }
+        return classes;
+    }
+}
+export function createDatatypeAnalyzer(options) {
+    return PerClassAnalyzer.fromFile('class-property-datatypes.rq', options);
+}
+export function createLanguageAnalyzer(options) {
+    return PerClassAnalyzer.fromFile('class-property-languages.rq', options);
+}
+export function createObjectClassAnalyzer(options) {
+    return PerClassAnalyzer.fromFile('class-property-object-classes.rq', options);
+}

package/dist/provenance.d.ts

@@ -0,0 +1,18 @@
+import type { DatasetCore } from '@rdfjs/types';
+/**
+ * Add PROV-O provenance metadata to a dataset.
+ *
+ * Adds:
+ * - `<iri> a prov:Entity`
+ * - `<iri> prov:wasGeneratedBy _:activity`
+ * - `_:activity a prov:Activity`
+ * - `_:activity prov:startedAtTime "..."^^xsd:dateTime`
+ * - `_:activity prov:endedAtTime "..."^^xsd:dateTime`
+ *
+ * @param data The dataset to add provenance to
+ * @param iri The IRI of the entity
+ * @param startedAt Start time of the activity
+ * @param endedAt End time of the activity
+ */
+export declare function withProvenance(data: DatasetCore, iri: string, startedAt: Date, endedAt: Date): DatasetCore;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAiBhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,IAAI,EACf,OAAO,EAAE,IAAI,GACZ,WAAW,CAwBb"}

package/dist/provenance.js

@@ -0,0 +1,35 @@
+import { DataFactory, Store } from 'n3';
+const { namedNode, literal, blankNode, quad } = DataFactory;
+const RDF_TYPE = namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+const PROV_ENTITY = namedNode('http://www.w3.org/ns/prov#Entity');
+const PROV_ACTIVITY = namedNode('http://www.w3.org/ns/prov#Activity');
+const PROV_WAS_GENERATED_BY = namedNode('http://www.w3.org/ns/prov#wasGeneratedBy');
+const PROV_STARTED_AT_TIME = namedNode('http://www.w3.org/ns/prov#startedAtTime');
+const PROV_ENDED_AT_TIME = namedNode('http://www.w3.org/ns/prov#endedAtTime');
+const XSD_DATE_TIME = namedNode('http://www.w3.org/2001/XMLSchema#dateTime');
+/**
+ * Add PROV-O provenance metadata to a dataset.
+ *
+ * Adds:
+ * - `<iri> a prov:Entity`
+ * - `<iri> prov:wasGeneratedBy _:activity`
+ * - `_:activity a prov:Activity`
+ * - `_:activity prov:startedAtTime "..."^^xsd:dateTime`
+ * - `_:activity prov:endedAtTime "..."^^xsd:dateTime`
+ *
+ * @param data The dataset to add provenance to
+ * @param iri The IRI of the entity
+ * @param startedAt Start time of the activity
+ * @param endedAt End time of the activity
+ */
+export function withProvenance(data, iri, startedAt, endedAt) {
+    const store = new Store([...data]);
+    const subject = namedNode(iri);
+    const activity = blankNode();
+    store.addQuad(quad(subject, RDF_TYPE, PROV_ENTITY));
+    store.addQuad(quad(subject, PROV_WAS_GENERATED_BY, activity));
+    store.addQuad(quad(activity, RDF_TYPE, PROV_ACTIVITY));
+    store.addQuad(quad(activity, PROV_STARTED_AT_TIME, literal(startedAt.toISOString(), XSD_DATE_TIME)));
+    store.addQuad(quad(activity, PROV_ENDED_AT_TIME, literal(endedAt.toISOString(), XSD_DATE_TIME)));
+    return store;
+}

package/dist/sparqlQueryAnalyzer.d.ts

@@ -0,0 +1,38 @@
+import { type ExecutableDataset } from '@lde/pipeline';
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import { BaseAnalyzer, Success, Failure, NotSupported } from '@lde/pipeline/analyzer';
+export interface SparqlQueryAnalyzerOptions {
+    /**
+     * Timeout for SPARQL queries in milliseconds.
+     * @default 300000 (5 minutes)
+     */
+    timeout?: number;
+    /**
+     * Custom SparqlEndpointFetcher instance.
+     */
+    fetcher?: SparqlEndpointFetcher;
+}
+/**
+ * Analyzer that executes a SPARQL CONSTRUCT query against a dataset's SPARQL endpoint.
+ *
+ * Supports template substitution:
+ * - `#subjectFilter#` — replaced with the dataset's subject filter (if any)
+ * - `#namedGraph#` — replaced with `FROM <graph>` clause if the distribution has a named graph
+ * - `?dataset` — replaced with the dataset IRI
+ *
+ * This class wraps the SparqlConstructExecutor from @lde/pipeline.
+ */
+export declare class SparqlQueryAnalyzer extends BaseAnalyzer {
+    readonly name: string;
+    private readonly executor;
+    constructor(name: string, query: string, options?: SparqlQueryAnalyzerOptions);
+    /**
+     * Create an analyzer from a query file in the queries directory.
+     *
+     * @param filename Query filename (e.g., 'triples.rq')
+     * @param options Optional analyzer options
+     */
+    static fromFile(filename: string, options?: SparqlQueryAnalyzerOptions): Promise<SparqlQueryAnalyzer>;
+    execute(dataset: ExecutableDataset): Promise<Success | Failure | NotSupported>;
+}
+//# sourceMappingURL=sparqlQueryAnalyzer.d.ts.map

package/dist/sparqlQueryAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparqlQueryAnalyzer.d.ts","sourceRoot":"","sources":["../src/sparqlQueryAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAG9D,OAAO,EACL,YAAY,EACZ,OAAO,EACP,OAAO,EACP,YAAY,EACb,MAAM,wBAAwB,CAAC;AAIhC,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,SAAQ,YAAY;aAIjC,IAAI,EAAE,MAAM;IAH9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;gBAGjC,IAAI,EAAE,MAAM,EAC5B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,0BAA0B;IAiBtC;;;;;OAKG;WACiB,QAAQ,CAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC,mBAAmB,CAAC;IAKlB,OAAO,CAClB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;CAqB7C"}

package/dist/sparqlQueryAnalyzer.js

@@ -0,0 +1,60 @@
+import { SparqlConstructExecutor, collect, readQueryFile, } from '@lde/pipeline';
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BaseAnalyzer, Success, Failure, NotSupported, } from '@lde/pipeline/analyzer';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Analyzer that executes a SPARQL CONSTRUCT query against a dataset's SPARQL endpoint.
+ *
+ * Supports template substitution:
+ * - `#subjectFilter#` — replaced with the dataset's subject filter (if any)
+ * - `#namedGraph#` — replaced with `FROM <graph>` clause if the distribution has a named graph
+ * - `?dataset` — replaced with the dataset IRI
+ *
+ * This class wraps the SparqlConstructExecutor from @lde/pipeline.
+ */
+export class SparqlQueryAnalyzer extends BaseAnalyzer {
+    name;
+    executor;
+    constructor(name, query, options) {
+        super();
+        this.name = name;
+        const fetcher = options?.fetcher ??
+            new SparqlEndpointFetcher({
+                timeout: options?.timeout ?? 300_000,
+            });
+        this.executor = new SparqlConstructExecutor({
+            query,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            fetcher: fetcher, // Types differ between package instances
+        });
+    }
+    /**
+     * Create an analyzer from a query file in the queries directory.
+     *
+     * @param filename Query filename (e.g., 'triples.rq')
+     * @param options Optional analyzer options
+     */
+    static async fromFile(filename, options) {
+        const query = await readQueryFile(resolve(__dirname, 'queries', filename));
+        return new SparqlQueryAnalyzer(filename, query, options);
+    }
+    async execute(dataset) {
+        const sparqlDistribution = dataset.getSparqlDistribution();
+        if (sparqlDistribution === null) {
+            return new NotSupported('No SPARQL distribution available');
+        }
+        try {
+            const result = await this.executor.execute(dataset);
+            if (result instanceof NotSupported) {
+                return result;
+            }
+            const store = await collect(result);
+            return new Success(store);
+        }
+        catch (e) {
+            return new Failure(sparqlDistribution.accessUrl ?? new URL('unknown://'), e instanceof Error ? e.message : undefined);
+        }
+    }
+}

package/dist/vocabularyAnalyzer.d.ts

@@ -0,0 +1,17 @@
+import { Dataset } from '@lde/dataset';
+import { type Analyzer, Success, type Failure, type NotSupported } from '@lde/pipeline/analyzer';
+/**
+ * Decorator analyzer that enriches results with `void:vocabulary` triples.
+ *
+ * Wraps another analyzer, runs it, then inspects `void:property` triples
+ * to detect known vocabulary prefixes and add corresponding `void:vocabulary`
+ * triples to the result.
+ */
+export declare class VocabularyAnalyzer implements Analyzer {
+    private readonly inner;
+    readonly name: string;
+    constructor(inner: Analyzer);
+    execute(dataset: Dataset): Promise<Success | Failure | NotSupported>;
+    finish(): Promise<void>;
+}
+//# sourceMappingURL=vocabularyAnalyzer.d.ts.map

package/dist/vocabularyAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabularyAnalyzer.d.ts","sourceRoot":"","sources":["../src/vocabularyAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,OAAO,EACL,KAAK,QAAQ,EACb,OAAO,EACP,KAAK,OAAO,EACZ,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAiChC;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,QAAQ;IAGrC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEA,KAAK,EAAE,QAAQ;IAI/B,OAAO,CAClB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;IAU/B,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAGrC"}

package/dist/vocabularyAnalyzer.js

@@ -0,0 +1,75 @@
+import { DataFactory, Store } from 'n3';
+import { Success, } from '@lde/pipeline/analyzer';
+const { namedNode, quad } = DataFactory;
+const VOID = 'http://rdfs.org/ns/void#';
+const voidProperty = namedNode(`${VOID}property`);
+const voidVocabulary = namedNode(`${VOID}vocabulary`);
+/**
+ * Known vocabulary namespace prefixes mapped to their canonical URIs.
+ */
+const vocabularyPrefixes = new Map([
+    ['http://schema.org/', 'http://schema.org/'],
+    ['https://schema.org/', 'https://schema.org/'],
+    [
+        'https://www.ica.org/standards/RiC/ontology#',
+        'https://www.ica.org/standards/RiC/ontology#',
+    ],
+    [
+        'http://www.cidoc-crm.org/cidoc-crm/',
+        'http://www.cidoc-crm.org/cidoc-crm/',
+    ],
+    ['http://purl.org/ontology/bibo/', 'http://purl.org/ontology/bibo/'],
+    ['http://purl.org/dc/elements/1.1/', 'http://purl.org/dc/elements/1.1/'],
+    ['http://purl.org/dc/terms/', 'http://purl.org/dc/terms/'],
+    ['http://purl.org/dc/dcmitype/', 'http://purl.org/dc/dcmitype/'],
+    [
+        'http://www.w3.org/2004/02/skos/core#',
+        'http://www.w3.org/2004/02/skos/core#',
+    ],
+    ['http://xmlns.com/foaf/0.1/', 'http://xmlns.com/foaf/0.1/'],
+]);
+/**
+ * Decorator analyzer that enriches results with `void:vocabulary` triples.
+ *
+ * Wraps another analyzer, runs it, then inspects `void:property` triples
+ * to detect known vocabulary prefixes and add corresponding `void:vocabulary`
+ * triples to the result.
+ */
+export class VocabularyAnalyzer {
+    inner;
+    name;
+    constructor(inner) {
+        this.inner = inner;
+        this.name = inner.name;
+    }
+    async execute(dataset) {
+        const result = await this.inner.execute(dataset);
+        if (!(result instanceof Success)) {
+            return result;
+        }
+        const enriched = addVocabularyTriples(result.data, dataset.iri.toString());
+        return new Success(enriched);
+    }
+    async finish() {
+        await this.inner.finish?.();
+    }
+}
+function addVocabularyTriples(data, datasetIri) {
+    const store = new Store([...data]);
+    const datasetNode = namedNode(datasetIri);
+    // Collect unique vocabulary URIs from void:property triples.
+    const detectedVocabularies = new Set();
+    for (const q of store.match(null, voidProperty, null)) {
+        const propertyUri = q.object.value;
+        for (const [prefix, vocabUri] of vocabularyPrefixes) {
+            if (propertyUri.startsWith(prefix)) {
+                detectedVocabularies.add(vocabUri);
+                break;
+            }
+        }
+    }
+    for (const vocabUri of detectedVocabularies) {
+        store.addQuad(quad(datasetNode, voidVocabulary, namedNode(vocabUri)));
+    }
+    return store;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lde/pipeline-void",
+  "version": "0.2.2",
+  "description": "VOiD (Vocabulary of Interlinked Datasets) statistical analysis for RDF datasets",
+  "repository": {
+    "url": "git+https://github.com/ldengine/lde.git",
+    "directory": "packages/pipeline-void"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "development": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@lde/dataset": "0.6.1",
+    "@lde/pipeline": "0.6.2",
+    "@rdfjs/types": "^2.0.1",
+    "fetch-sparql-endpoint": "^6.0.0",
+    "n3": "^1.17.0",
+    "tslib": "^2.3.0"
+  }
+}