mdld-parse 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mdld-parse",
-	"version": "0.7.2",
+	"version": "0.7.4",
 	"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",

package/src/constants.js

@@ -0,0 +1,30 @@
+/**
+ * Shared utilities for MD-LD Parser and Renderer
+ * Ensures DRY code and consistent CommonMark processing
+ */
+
+
+
+export const DEFAULT_CONTEXT = {
+    '@vocab': "http://www.w3.org/2000/01/rdf-schema#",
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+    xsd: 'http://www.w3.org/2001/XMLSchema#',
+    sh: "http://www.w3.org/ns/shacl#",
+    prov: 'http://www.w3.org/ns/prov#'
+};
+
+// CommonMark patterns - shared between parser and renderer
+export const URL_REGEX = /^(https?|ftp|mailto|tag|nih|urn|uuid|did|web|ipfs|ipns|data|file|urn:uuid):/;
+export const FENCE_REGEX = /^(`{3,}|~{3,})(.*)/;
+export const PREFIX_REGEX = /^\[([^\]]+)\]\s*<([^>]+)>/;
+export const HEADING_REGEX = /^(#{1,6})\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
+export const UNORDERED_LIST_REGEX = /^(\s*)([-*+]|\d+\.)\s+(.+?)(?:\s*(\{[^}]+\}))?\s*$/;
+export const BLOCKQUOTE_REGEX = /^>\s+(.+?)(?:\s*(\{[^}]+\}))?$/;
+export const STANDALONE_SUBJECT_REGEX = /^\s*\{=(.*?)\}\s*$/;
+
+// Pre-compiled carrier patterns for performance
+export const CARRIER_PATTERN_ARRAY = [
+    ['EMPHASIS', /[*__`]+(.+?)[*__`]+\s*\{([^}]+)\}/y],
+    ['CODE_SPAN', /``(.+?)``\s*\{([^}]+)\}/y]
+];

package/src/generate.js

@@ -1,20 +1,26 @@
-import { shortenIRI, expandIRI, 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';
-}
-
+import { shortenIRI, expandIRI, DataFactory } from './utils.js';
+import { DEFAULT_CONTEXT } from './constants.js';
+import {
+    isLiteral,
+    collectUsedPrefixes,
+    sortQuadsByPredicate,
+    generatePrefixDeclaration,
+    generateLiteralText,
+    generateObjectText,
+    filterQuadsByType
+} from './shared.js';
+
+export function extractLocalName(iri, ctx = {}) {
+    if (!iri) return iri;
+
+    // Check for exact prefix matches first
+    for (const [prefix, namespace] of Object.entries(ctx)) {
+        if (iri.startsWith(namespace) || iri.startsWith(namespace.slice(0, -1))) {
+            return iri.substring(namespace.length);
+        }
+    }
 
-function extractLocalName(iri) {
+    // Fallback to original logic for local names
     const separators = ['#', '/', ':'];
     for (const sep of separators) {
         const lastSep = iri.lastIndexOf(sep);
@@ -82,14 +88,14 @@ function groupQuadsBySubject(quads) {
 
 function buildDeterministicMDLD(subjectGroups, context) {
     let text = '';
+    const usedPrefixes = collectUsedPrefixes(subjectGroups, context);
 
     // Add prefixes first (deterministic order), but exclude default context prefixes
     const sortedPrefixes = Object.entries(context).sort(([a], [b]) => a.localeCompare(b));
     for (const [prefix, namespace] of sortedPrefixes) {
         // Skip default context prefixes - they're implicit in MDLD
-        if (prefix !== '@vocab' && !prefix.startsWith('@') && !DEFAULT_CONTEXT[prefix]) {
-            const prefixDecl = `[${prefix}] <${namespace}>\n`;
-            text += prefixDecl;
+        if (prefix !== '@vocab' && !prefix.startsWith('@') && !DEFAULT_CONTEXT[prefix] && usedPrefixes.has(prefix)) {
+            text += generatePrefixDeclaration(prefix, namespace);
         }
     }
 
@@ -104,47 +110,25 @@ function buildDeterministicMDLD(subjectGroups, context) {
         const subjectQuads = subjectGroups.get(subjectIRI);
         const shortSubject = shortenIRI(subjectIRI, context);
 
-        // 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));
+        // Separate types, literals, and objects using shared utility
+        const { types, literals, objects } = filterQuadsByType(subjectQuads);
 
         // Generate heading
-        const localSubjectName = extractLocalName(subjectIRI);
+        const localSubjectName = extractLocalName(subjectIRI, context);
         const typeAnnotations = types.length > 0
-            ? ' ' + types.map(t => '.' + extractLocalName(t.object.value)).sort().join(' ')
+            ? ' ' + types.map(t => '.' + shortenIRI(t.object.value, context)).sort().join(' ')
             : '';
 
-        const headingText = `# ${localSubjectName} {=${shortSubject}${typeAnnotations}}\n\n`;
-
-        text += headingText;
-
-        // Add literals (deterministic order)
-        const sortedLiterals = literals.sort((a, b) => a.predicate.value.localeCompare(b.predicate.value));
-        for (const quad of sortedLiterals) {
-            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 !== xsdString) {
-                annotation += ` ^^${shortenIRI(quad.object.datatype.value, context)}`;
-            }
+        text += `# ${localSubjectName} {=${shortSubject}${typeAnnotations}}\n`;
 
-            const literalText = `[${quad.object.value}] {${annotation}}\n`;
-            text += literalText;
-        }
+        // Add literals and objects using shared utilities
+        sortQuadsByPredicate(literals).forEach(quad => {
+            text += generateLiteralText(quad, context);
+        });
 
-        // Add objects (deterministic order)
-        const sortedObjects = objects.sort((a, b) => a.predicate.value.localeCompare(b.predicate.value));
-        for (const quad of sortedObjects) {
-            const objShort = shortenIRI(quad.object.value, context);
-            const predShort = shortenIRI(quad.predicate.value, context);
-            const objectText = `[${objShort}] {+${objShort} ?${predShort}}\n`;
-            text += objectText;
-        }
+        sortQuadsByPredicate(objects).forEach(quad => {
+            text += generateObjectText(quad, context);
+        });
 
         text += '\n';
     }

package/src/index.js

@@ -3,8 +3,8 @@ export { merge } from './merge.js';
 export { generate } from './generate.js';
 export { locate } from './locate.js';
 export { render } from './render.js';
+export { DEFAULT_CONTEXT } from './constants.js';
 export {
-    DEFAULT_CONTEXT,
     DataFactory,
     hash,
     expandIRI,

package/src/locate.js

@@ -18,21 +18,6 @@ export function locate(quad, origin) {
         return null;
     }
 
-    // Find the origin entry in quadIndex
-    const entry = origin.quadIndex.get(quadKey);
-    if (!entry) {
-        return null;
-    }
-
-    // Return the lean origin entry structure
-    return {
-        blockId: entry.blockId,
-        range: entry.range,
-        carrierType: entry.carrierType,
-        subject: entry.subject,
-        predicate: entry.predicate,
-        context: entry.context,
-        value: entry.value,
-        polarity: entry.polarity
-    };
+    // Return the origin entry directly - no need to create new object
+    return origin.quadIndex.get(quadKey) || null;
 }

package/src/merge.js

@@ -1,15 +1,14 @@
 import { parse } from './parse.js';
-import { DEFAULT_CONTEXT } from './utils.js';
+import { quadIndexKey } from './shared.js';
+import { DEFAULT_CONTEXT } from './constants.js';
 
 /**
- * Creates a unique key for quad identity matching
+ * Creates a unique key for quad identity matching - using shared utility
  * @param {Quad} quad 
  * @returns {string}
  */
 function quadKey(quad) {
-    const datatype = quad.object.datatype?.value || '';
-    const language = quad.object.language || '';
-    return `${quad.subject.value}|${quad.predicate.value}|${quad.object.value}|${datatype}|${language}`;
+    return quadIndexKey(quad.subject, quad.predicate, quad.object);
 }
 
 /**