mdld-parse 0.7.0 → 0.7.1

package/README.md

@@ -56,6 +56,7 @@ console.log(result.quads);
 - **🧩 Fragments** - Document structuring with `{=#fragment}`
 - **⚡ Polarity system** - Sophisticated diff authoring with `+` and `-` prefixes
 - **📍 Origin tracking** - Complete provenance with lean quad-to-source mapping
+- **🎯 Elevated statements** - Automatic rdf:Statement pattern detection for "golden" graph extraction
 
 ## 🌟 What is MD-LD?
 
@@ -122,7 +123,24 @@ Each predicate form determines the graph edge:
 | `?p`  | S → O   | `[NASA] {=ex:nasa ?org}`     | object property  |
 | `!p` | O → S    | `[Parent] {=ex:p !hasPart}`  | reverse object   |
 
-## 🎨 Syntax Quick Reference
+## � Elevated Statements
+
+MD-LD automatically detects `rdf:Statement` patterns during parsing and extracts elevated SPO quads for convenient consumption by applications.
+
+### Pattern Detection
+
+When the parser encounters a complete `rdf:Statement` pattern with `rdf:subject`, `rdf:predicate`, and `rdf:object`, it automatically adds the corresponding SPO quad to the `statements` array:
+
+```markdown
+[ex] <http://example.org/>
+
+## Elevated statement {=ex:stmt1 .rdf:Statement}
+**Alice** {+ex:alice ?rdf:subject} *knows* {+ex:knows ?rdf:predicate} **Bob** {+ex:bob ?rdf:object}
+
+Direct statement:**Alice** {=ex:alice} knows **Bob** {?ex:knows +ex:bob} 
+``
+
+## �🎨 Syntax Quick Reference
 
 ### Subject Declaration
 Set current subject (emits no quads):
@@ -180,10 +198,11 @@ Parse MD-LD markdown and return RDF quads with lean origin tracking.
   - `context` (object) — Prefix mappings (default: `{ '@vocab': 'http://www.w3.org/2000/01/rdf-schema#', rdf, rdfs, xsd, sh, prov }`)
   - `dataFactory` (object) — Custom RDF/JS DataFactory
 
-**Returns:** `{ quads, remove, origin, context }`
+**Returns:** `{ quads, remove, statements, origin, context }`
 
 - `quads` — Array of RDF/JS Quads (final resolved graph state)
 - `remove` — Array of RDF/JS Quads (external retractions targeting prior state)
+- `statements` — Array of elevated RDF/JS Quads extracted from rdf:Statement patterns
 - `origin` — Lean origin tracking object with quadIndex for UI navigation
 - `context` — Final context used (includes prefixes)
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.7.0",
+	"version": "0.7.1",
 	"description": "A standards-compliant parser for **MD-LD (Markdown-Linked Data)** — a human-friendly RDF authoring format that extends Markdown with semantic annotations.",
 	"type": "module",
 	"main": "index.js",
@@ -38,8 +38,5 @@
 	"homepage": "https://mdld.js.org",
 	"bugs": {
 		"url": "https://github.com/davay42/mdld-parse/issues"
-	},
-	"devDependencies": {
-		"n3": "^2.0.1"
 	}
 }

package/src/parse.js

@@ -364,7 +364,7 @@ function createBlock(subject, types, predicates, range, attrsRange, valueRange,
     };
 }
 
-function emitQuad(quads, quadBuffer, removeSet, quadIndex, block, subject, predicate, object, dataFactory, meta = null) {
+function emitQuad(quads, quadBuffer, removeSet, quadIndex, block, subject, predicate, object, dataFactory, meta = null, statements = null, statementCandidates = null) {
     if (!subject || !predicate || !object) return;
 
     const quad = dataFactory.quad(subject, predicate, object);
@@ -397,6 +397,9 @@ function emitQuad(quads, quadBuffer, removeSet, quadIndex, block, subject, predi
         quadBuffer.set(quadKey, quad);
         quads.push(quad);
 
+        // Detect rdf:Statement pattern during single-pass parsing
+        detectStatementPatternSinglePass(quad, dataFactory, meta, statements, statementCandidates);
+
         // Create lean origin entry
         const originEntry = {
             blockId: block.id,
@@ -413,6 +416,62 @@ function emitQuad(quads, quadBuffer, removeSet, quadIndex, block, subject, predi
     }
 }
 
+// Extract RDF constants once at module level for efficiency
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+const RDF_STATEMENT = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement';
+const RDF_SUBJECT = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#subject';
+const RDF_PREDICATE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate';
+const RDF_OBJECT = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#object';
+
+function detectStatementPatternSinglePass(quad, dataFactory, meta, statements = null, statementCandidates = null) {
+    // Skip if not called from parse context (for testing compatibility)
+    if (!statements || !statementCandidates) return;
+
+    const predicate = quad.predicate.value;
+
+    // Early filter: only process rdf:Statement related predicates
+    if (predicate !== RDF_TYPE &&
+        predicate !== RDF_SUBJECT &&
+        predicate !== RDF_PREDICATE &&
+        predicate !== RDF_OBJECT) {
+        return;
+    }
+
+    // Check if this quad starts a new rdf:Statement pattern
+    if (predicate === RDF_TYPE && quad.object.value === RDF_STATEMENT) {
+        statementCandidates.set(quad.subject.value, { spo: {} });
+        return;
+    }
+
+    // Check if this quad completes part of an existing rdf:Statement pattern
+    const candidate = statementCandidates.get(quad.subject.value);
+    if (!candidate) return;
+
+    // Direct property assignment instead of switch for better performance
+    if (predicate === RDF_SUBJECT) {
+        candidate.spo.subject = quad.object;
+    } else if (predicate === RDF_PREDICATE) {
+        candidate.spo.predicate = quad.object;
+    } else if (predicate === RDF_OBJECT) {
+        candidate.spo.object = quad.object;
+        // Store the original quad for potential literal extraction
+        candidate.objectQuad = quad;
+    }
+
+    // Check if pattern is complete and create elevated SPO quad
+    if (candidate.spo.subject && candidate.spo.predicate && candidate.spo.object) {
+        // Use the object directly - literal detection happens at parse time
+        const spoQuad = dataFactory.quad(
+            candidate.spo.subject,
+            candidate.spo.predicate,
+            candidate.spo.object
+        );
+        statements.push(spoQuad);
+        // Clean up candidate to avoid duplicate detection
+        statementCandidates.delete(quad.subject.value);
+    }
+}
+
 const resolveFragment = (fragment, state) => {
     if (!state.currentSubject) return null;
     const baseIRI = state.currentSubject.value.split('#')[0];
@@ -444,7 +503,8 @@ const createTypeQuad = (typeIRI, subject, state, block, entryIndex = null) => {
         state.df.namedNode(expandIRI('rdf:type', state.ctx)),
         state.df.namedNode(expandedType),
         state.df,
-        { kind: 'type', token: `.${typeIRI}`, expandedType, entryIndex: typeInfo.entryIndex, remove: typeInfo.remove }
+        { kind: 'type', token: `.${typeIRI}`, expandedType, entryIndex: typeInfo.entryIndex, remove: typeInfo.remove },
+        state.statements, state.statementCandidates
     );
 };
 
@@ -487,7 +547,8 @@ function processPredicateAnnotations(sem, newSubject, previousSubject, localObje
             const P = state.df.namedNode(expandIRI(pred.iri, state.ctx));
             emitQuad(state.quads, state.quadBuffer, state.removeSet, state.origin.quadIndex, block,
                 role.subject, P, role.object, state.df,
-                { kind: 'pred', token: `${pred.form}${pred.iri}`, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex, remove: pred.remove || false }
+                { kind: 'pred', token: `${pred.form}${pred.iri}`, form: pred.form, expandedPredicate: P.value, entryIndex: pred.entryIndex, remove: pred.remove || false },
+                state.statements, state.statementCandidates
             );
         }
     });
@@ -592,7 +653,9 @@ export function parse(text, options = {}) {
         origin: { quadIndex: new Map() },
         currentSubject: null,
         tokens: null,
-        currentTokenIndex: -1
+        currentTokenIndex: -1,
+        statements: [],
+        statementCandidates: new Map() // Track incomplete rdf:Statement patterns
     };
 
     state.tokens = scanTokens(text);
@@ -629,5 +692,5 @@ export function parse(text, options = {}) {
         return !quadKeys.has(key);
     });
 
-    return { quads: state.quads, remove: filteredRemove, origin: state.origin, context: state.ctx };
+    return { quads: state.quads, remove: filteredRemove, statements: state.statements, origin: state.origin, context: state.ctx };
 }