Repeated subjects blocks are not merged during parsing into a single `@id` object

[thenonameguy]

Property Aggregation Issue: Multiple Statements for Same Subject Create Separate Nodes

Problem

When the same subject appears in multiple separate Turtle statements, @frogcat/ttl2jsonld creates separate JSON-LD nodes instead of aggregating properties into a single node.

Expected Behavior

Both scenarios should produce a single JSON-LD node with all properties aggregated.

Actual Behavior

Multiple statements create separate nodes, requiring manual property merging.

Minimal Reproduction (9 lines)

import pkg from '@frogcat/ttl2jsonld';
const { parse } = pkg;

// WORKING: Single block = 1 node with all properties
const single = `@prefix : <https://ex.com/> . :r :name "test" ; :desc "desc" .`;
const singleResult = parse(single);
console.log('Single block nodes:', (singleResult['@graph'] || [singleResult]).length); // 1

// BROKEN: Multiple statements = multiple nodes, properties scattered
const multiple = `@prefix : <https://ex.com/> . :r :name "test" . :r :desc "desc" .`;
const multipleResult = parse(multiple);
console.log('Multiple statements nodes:', multipleResult['@graph'].length); // 2 (should be 1)

Output:

Single block nodes: 1
Multiple statements nodes: 2

Impact

This forces consumers to implement manual node merging logic for fragmented Turtle data, which is common in SPARQL CONSTRUCT query results.

Version

@frogcat/ttl2jsonld@0.0.10

[frogcat]

Thanks for raising this question, @thenonameguy !

The current behavior of ttl2jsonld is intentional:
when multiple Turtle statements share the same subject, they are converted into separate JSON-LD objects on a per-statement basis.
This design is meant to keep the conversion process simple and explicit, and to reflect each statement independently.

That said, I do understand the use case you’re describing.
In many situations, it can be more convenient to aggregate all statements that share the same subject into a single JSON-LD node.

From an implementation point of view, this kind of aggregation would not be very complex.
One possible approach could be to add an optional mode like this:

const jsonld = ttl2jsonld.parse(`your turtle here`, { aggregate: true });

When enabled, statements with the same subject could be merged into a single JSON-LD object.

At the moment, ttl2jsonld is intentionally focused on statement-level JSON-LD output, but I’m curious:
would an aggregation option like this be useful for your workflow?
If so, it would be helpful to hear more about how you’d like to use it.

Thanks again for the suggestion!

[thenonameguy]

Hey! Thanks for the reply!

Yes, from a usability perspective this would be a great enhancement.

The proposal sounds fine to me, then I could drop my manual aggregation code in my projects.