mdld-parse 0.5.5 → 0.6.0

package/src/generate.js

@@ -1,4 +1,17 @@
-import { shortenIRI, expandIRI, quadIndexKey, createSlotInfo, DEFAULT_CONTEXT } from './utils.js';
+import { shortenIRI, expandIRI, quadIndexKey, createUnifiedSlot, DEFAULT_CONTEXT, DataFactory } from './utils.js';
+
+// Helper functions for cleaner term type checking
+function isLiteral(term) {
+    return term?.termType === 'Literal';
+}
+
+function isNamedNode(term) {
+    return term?.termType === 'NamedNode';
+}
+
+function isRdfType(term) {
+    return term?.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+}
 
 
 function extractLocalName(iri) {
@@ -25,37 +38,37 @@ export function generate(quads, context = {}) {
 
     const subjectGroups = groupQuadsBySubject(normalizedQuads);
 
-    const { text, blocks, quadIndex } = buildDeterministicMDLD(subjectGroups, fullContext);
+    const { text, quadMap } = buildDeterministicMDLD(subjectGroups, fullContext);
 
     return {
         text,
-        origin: { blocks, quadIndex },
+        origin: { quadMap },
         context: fullContext
     };
 }
 
 function normalizeAndSortQuads(quads) {
     return quads
-        .map(quad => ({
-            subject: { termType: quad.subject.termType, value: quad.subject.value },
-            predicate: { termType: quad.predicate.termType, value: quad.predicate.value },
-            object: quad.object.termType === 'Literal'
-                ? {
-                    termType: 'Literal',
-                    value: quad.object.value,
-                    language: quad.object.language || null,
-                    datatype: quad.object.datatype || { termType: 'NamedNode', value: 'http://www.w3.org/2001/XMLSchema#string' }
-                }
-                : { termType: 'NamedNode', value: quad.object.value }
-        }))
+        .map(quad => {
+            // Use DataFactory.fromTerm to ensure proper RDF/JS compatibility
+            const normSubject = DataFactory.fromTerm(quad.subject);
+            const normPredicate = DataFactory.fromTerm(quad.predicate);
+            const normObject = DataFactory.fromTerm(quad.object);
+
+            return {
+                subject: normSubject,
+                predicate: normPredicate,
+                object: normObject
+            };
+        })
         .sort((a, b) => {
             // Deterministic sorting: subject -> predicate -> object
             const sComp = a.subject.value.localeCompare(b.subject.value);
             if (sComp !== 0) return sComp;
             const pComp = a.predicate.value.localeCompare(b.predicate.value);
             if (pComp !== 0) return pComp;
-            const oA = a.object.termType === 'Literal' ? a.object.value : a.object.value;
-            const oB = b.object.termType === 'Literal' ? b.object.value : b.object.value;
+            const oA = isLiteral(a.object) ? a.object.value : a.object.value;
+            const oB = isLiteral(b.object) ? b.object.value : b.object.value;
             return oA.localeCompare(oB);
         });
 }
@@ -74,8 +87,7 @@ function groupQuadsBySubject(quads) {
 function buildDeterministicMDLD(subjectGroups, context) {
     let text = '';
     let currentPos = 0;
-    const blocks = new Map();
-    const quadIndex = new Map();
+    const quadMap = new Map();
 
     // Add prefixes first (deterministic order), but exclude default context prefixes
     const sortedPrefixes = Object.entries(context).sort(([a], [b]) => a.localeCompare(b));
@@ -83,14 +95,6 @@ function buildDeterministicMDLD(subjectGroups, context) {
         // Skip default context prefixes - they're implicit in MDLD
         if (prefix !== '@vocab' && !prefix.startsWith('@') && !DEFAULT_CONTEXT[prefix]) {
             const prefixDecl = `[${prefix}] <${namespace}>\n`;
-            const blockId = generateBlockId();
-            blocks.set(blockId, {
-                id: blockId,
-                range: { start: currentPos, end: currentPos + prefixDecl.length },
-                subject: null,
-                entries: [{ kind: 'prefix', prefix, namespace, raw: prefixDecl.trim() }],
-                carrierType: 'prefix'
-            });
             text += prefixDecl;
             currentPos += prefixDecl.length;
         }
@@ -108,10 +112,10 @@ function buildDeterministicMDLD(subjectGroups, context) {
         const subjectQuads = subjectGroups.get(subjectIRI);
         const shortSubject = shortenIRI(subjectIRI, context);
 
-        // Separate types, literals, and objects
-        const types = subjectQuads.filter(q => q.predicate.value === 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-        const literals = subjectQuads.filter(q => q.object.termType === 'Literal' && q.predicate.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-        const objects = subjectQuads.filter(q => q.object.termType === 'NamedNode' && q.predicate.value !== 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        // Separate types, literals, and objects using helper functions
+        const types = subjectQuads.filter(q => isRdfType(q.predicate));
+        const literals = subjectQuads.filter(q => isLiteral(q.object) && !isRdfType(q.predicate));
+        const objects = subjectQuads.filter(q => isNamedNode(q.object) && !isRdfType(q.predicate));
 
         // Generate heading
         const localSubjectName = extractLocalName(subjectIRI);
@@ -120,28 +124,23 @@ function buildDeterministicMDLD(subjectGroups, context) {
             : '';
 
         const headingText = `# ${localSubjectName} {=${shortSubject}${typeAnnotations}}\n\n`;
-        const blockId = generateBlockId();
+
         const headingBlock = {
-            id: blockId,
+            id: generateBlockId(),
             range: { start: currentPos, end: currentPos + headingText.length },
             subject: subjectIRI,
-            entries: [
-                { kind: 'subject', raw: `=${shortSubject}`, expandedSubject: subjectIRI },
-                ...types.map((t, i) => ({
-                    kind: 'type',
-                    raw: '.' + extractLocalName(t.object.value),
-                    expandedType: t.object.value,
-                    entryIndex: i
-                }))
-            ],
-            carrierType: 'heading'
+            types: types.map(t => t.object.value),
+            predicates: [],
+            context: { ...context },
+            carrierType: 'heading',
+            attrsRange: { start: currentPos + headingText.indexOf('{'), end: currentPos + headingText.indexOf('}') + 1 },
+            valueRange: { start: currentPos + 2, end: currentPos + 2 + localSubjectName.length }
         };
-        blocks.set(blockId, headingBlock);
 
-        // Add type quads to index
+        // Add type quads to quadMap
         types.forEach((quad, i) => {
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(blockId, i, {
+            quadMap.set(key, createUnifiedSlot(headingBlock, i, {
                 kind: 'type',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -158,34 +157,30 @@ function buildDeterministicMDLD(subjectGroups, context) {
             const predShort = shortenIRI(quad.predicate.value, context);
             let annotation = predShort;
 
+            // Use DataFactory XSD constants for datatype comparison
+            const xsdString = 'http://www.w3.org/2001/XMLSchema#string';
             if (quad.object.language) {
                 annotation += ` @${quad.object.language}`;
-            } else if (quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
+            } else if (quad.object.datatype.value !== xsdString) {
                 annotation += ` ^^${shortenIRI(quad.object.datatype.value, context)}`;
             }
 
             const literalText = `[${quad.object.value}] {${annotation}}\n`;
-            const literalBlockId = generateBlockId();
             const literalBlock = {
-                id: literalBlockId,
+                id: generateBlockId(),
                 range: { start: currentPos, end: currentPos + literalText.length },
                 subject: subjectIRI,
-                entries: [{
-                    kind: 'property',
-                    raw: annotation,
-                    expandedPredicate: quad.predicate.value,
-                    form: '',
-                    entryIndex: 0
-                }],
+                types: [],
+                predicates: [{ iri: quad.predicate.value, form: '' }],
+                context: { ...context },
                 carrierType: 'span',
                 valueRange: { start: currentPos + 1, end: currentPos + 1 + quad.object.value.length },
                 attrsRange: { start: currentPos + literalText.indexOf('{'), end: currentPos + literalText.indexOf('}') + 1 }
             };
-            blocks.set(literalBlockId, literalBlock);
 
-            // Add to quad index
+            // Add to quadMap
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(literalBlockId, 0, {
+            quadMap.set(key, createUnifiedSlot(literalBlock, 0, {
                 kind: 'pred',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -200,29 +195,25 @@ function buildDeterministicMDLD(subjectGroups, context) {
         // Add objects (deterministic order)
         const sortedObjects = objects.sort((a, b) => a.predicate.value.localeCompare(b.predicate.value));
         for (const quad of sortedObjects) {
-            const predShort = shortenIRI(quad.predicate.value, context);
             const objShort = shortenIRI(quad.object.value, context);
-            const localName = extractLocalName(quad.object.value);
+            const predShort = shortenIRI(quad.predicate.value, context);
+            const objectText = `[${objShort}] {+${objShort} ?${predShort}}\n`;
 
-            const objectText = `[${localName}] {+${objShort} ?${predShort}}\n`;
-            const objectBlockId = generateBlockId();
             const objectBlock = {
-                id: objectBlockId,
+                id: generateBlockId(),
                 range: { start: currentPos, end: currentPos + objectText.length },
                 subject: subjectIRI,
-                entries: [{
-                    kind: 'object',
-                    raw: objShort,
-                    expandedObject: quad.object.value,
-                    entryIndex: 0
-                }],
-                carrierType: 'span'
+                types: [],
+                predicates: [{ iri: quad.predicate.value, form: '?' }],
+                context: { ...context },
+                carrierType: 'span',
+                valueRange: { start: currentPos + 1, end: currentPos + 1 + objShort.length },
+                attrsRange: { start: currentPos + objectText.indexOf('{'), end: currentPos + objectText.indexOf('}') + 1 }
             };
-            blocks.set(objectBlockId, objectBlock);
 
-            // Add to quad index
+            // Add to quadMap
             const key = quadIndexKey(quad.subject, quad.predicate, quad.object);
-            quadIndex.set(key, createSlotInfo(objectBlockId, 0, {
+            quadMap.set(key, createUnifiedSlot(objectBlock, 0, {
                 kind: 'pred',
                 subject: quad.subject,
                 predicate: quad.predicate,
@@ -234,13 +225,11 @@ function buildDeterministicMDLD(subjectGroups, context) {
             currentPos += objectText.length;
         }
 
-        if (sortedLiterals.length > 0 || sortedObjects.length > 0) {
-            text += '\n';
-            currentPos += 1;
-        }
+        text += '\n';
+        currentPos += 1;
     }
 
-    return { text: text.trim(), blocks, quadIndex };
+    return { text, quadMap };
 }
 
 function generateBlockId() {

package/src/index.js

@@ -2,6 +2,7 @@ export { parse } from './parse.js';
 export { applyDiff } from './applyDiff.js';
 export { generate } from './generate.js';
 export { locate } from './locate.js';
+export { render } from './render.js';
 export {
     DEFAULT_CONTEXT,
     DataFactory,

package/src/locate.js

@@ -17,7 +17,7 @@ export function locate(quad, origin, text = '', context = {}) {
         origin = parseResult.origin;
     }
 
-    if (!quad || !origin || !origin.quadIndex || !origin.blocks) {
+    if (!quad || !origin || !origin.quadMap) {
         return null;
     }
 
@@ -27,57 +27,40 @@ export function locate(quad, origin, text = '', context = {}) {
         return null;
     }
 
-    // Generate the quad key to lookup in quadIndex
+    // Generate the quad key to lookup in quadMap
     const quadKey = quadIndexKey(normalizedQuad.subject, normalizedQuad.predicate, normalizedQuad.object);
 
-    // Find the slot information in quadIndex
-    const slotInfo = origin.quadIndex.get(quadKey);
+    // Find the slot information in quadMap
+    const slotInfo = origin.quadMap.get(quadKey);
     if (!slotInfo) {
         return null;
     }
 
-    // Get the block information
-    const block = origin.blocks.get(slotInfo.blockId);
-    if (!block) {
-        return null;
-    }
+    // In unified structure, slotInfo contains all block information
+    const block = slotInfo;
 
-    // Extract the actual text content based on carrier type and entry
+    // Extract the actual text content based on carrier type
     let contentRange = null;
     let content = '';
 
     if (block.carrierType === 'heading') {
-        // For headings, use the block's main range
-        contentRange = block.range;
-        content = text.substring(block.range.start, block.range.end);
-    } else if (block.carrierType === 'blockquote' || block.carrierType === 'list' || block.carrierType === 'span') {
-        // For blockquotes, lists, and spans, extract from block range
-        contentRange = block.range;
-        content = text.substring(block.range.start, block.range.end);
-
-        // For blockquotes, try to extract the specific carrier content from entries
-        if (slotInfo.entryIndex != null && block.entries && block.entries[slotInfo.entryIndex]) {
-            const entry = block.entries[slotInfo.entryIndex];
-            if (entry.raw) {
-                // For blockquotes, the entry.raw contains the full carrier text
-                // Extract just the content part before the annotation
-                const annotationStart = entry.raw.indexOf('{');
-                if (annotationStart !== -1) {
-                    const carrierContent = entry.raw.substring(0, annotationStart).trim();
-                    // Find this content in the block text
-                    const contentStart = text.indexOf(carrierContent, block.range.start);
-                    if (contentStart !== -1) {
-                        const contentEnd = contentStart + carrierContent.length;
-                        contentRange = { start: contentStart, end: contentEnd };
-                        content = text.substring(contentStart, contentEnd);
-                    }
-                }
-            }
+        // For headings, use the value range for the heading text
+        contentRange = block.valueRange;
+        content = text.substring(block.valueRange.start, block.valueRange.end);
+    } else if (block.carrierType === 'emphasis' || block.carrierType === 'blockquote' || block.carrierType === 'list' || block.carrierType === 'span') {
+        // For emphasis, blockquotes, lists, and spans, use the value range
+        if (block.valueRange) {
+            contentRange = block.valueRange;
+            content = text.substring(block.valueRange.start, block.valueRange.end);
+        } else {
+            // Fallback to block range
+            contentRange = block.range;
+            content = text.substring(block.range.start, block.range.end);
         }
     }
 
     return {
-        blockId: slotInfo.blockId,
+        blockId: slotInfo.id,
         entryIndex: slotInfo.entryIndex,
         kind: slotInfo.kind,
         subject: normalizedQuad.subject,