mdld-parse 0.6.0 → 0.7.0

package/src/utils.js

@@ -262,6 +262,9 @@ export function expandIRI(term, ctx) {
         result = t;
     } else if (t.includes(':')) {
         const [prefix, ref] = t.split(':', 2);
+        if (prefix && !ctx[prefix] && prefix !== '@vocab') {
+            console.warn(`Undefined prefix "${prefix}" in IRI "${t}" - treating as literal`);
+        }
         result = ctx[prefix] ? ctx[prefix] + ref : t;
     } else {
         result = (ctx['@vocab'] || '') + t;
@@ -314,19 +317,32 @@ export function parseSemanticBlock(raw) {
         let m;
 
         while ((m = re.exec(cleaned)) !== null) {
-            const token = m[0];
+            let token = m[0];
             const relStart = 1 + m.index;
             const relEnd = relStart + token.length;
             const entryIndex = result.entries.length;
 
+            // Handle remove polarity - strip leading - and set remove flag
+            let remove = false;
+            if (token.startsWith('-') && token.length > 1) {
+                remove = true;
+                token = token.slice(1);
+            }
+
             // Handle special tokens
             if (token === '=') {
+                if (remove) {
+                    console.warn('-= is not valid, subject declarations have no polarity');
+                }
                 result.subject = 'RESET';
                 result.entries.push({ kind: 'subjectReset', relRange: { start: relStart, end: relEnd }, raw: token });
                 continue;
             }
 
             if (token.startsWith('=') && !token.startsWith('=#')) {
+                if (remove) {
+                    console.warn('-= is not valid, subject declarations have no polarity');
+                }
                 const iri = token.substring(1);
                 result.subject = iri;
                 result.entries.push({ kind: 'subject', iri, relRange: { start: relStart, end: relEnd }, raw: token });
@@ -337,7 +353,7 @@ export function parseSemanticBlock(raw) {
             let processed = false;
             for (const [pattern, config] of Object.entries(TOKEN_PATTERNS)) {
                 if (token.startsWith(pattern)) {
-                    const entry = { kind: config.kind, relRange: { start: relStart, end: relEnd }, raw: token };
+                    const entry = { kind: config.kind, relRange: { start: relStart, end: relEnd }, raw: m[0] };
                     const extracted = config.extract(token);
 
                     if (config.kind === 'fragment') {
@@ -347,22 +363,36 @@ export function parseSemanticBlock(raw) {
                         result.object = `#${extracted}`;
                         entry.fragment = extracted;
                     } else if (config.kind === 'object') {
+                        if (remove) {
+                            console.warn('-+ is not valid, object declarations have no polarity');
+                            remove = false;
+                        }
                         result.object = extracted;
                         entry.iri = extracted;
                     } else if (config.kind === 'datatype') {
+                        if (remove) {
+                            console.warn('-^^ is not valid, datatype modifiers have no polarity');
+                            remove = false;
+                        }
                         if (!result.language) result.datatype = extracted;
                         entry.datatype = extracted;
                     } else if (config.kind === 'language') {
+                        if (remove) {
+                            console.warn('-@ is not valid, language modifiers have no polarity');
+                            remove = false;
+                        }
                         result.language = extracted;
                         result.datatype = null;
                         entry.language = extracted;
                     } else if (config.kind === 'type') {
-                        result.types.push({ iri: extracted, entryIndex });
+                        result.types.push({ iri: extracted, entryIndex, remove });
                         entry.iri = extracted;
+                        entry.remove = remove;
                     } else if (config.kind === 'property') {
-                        result.predicates.push({ iri: extracted, form: config.form, entryIndex });
+                        result.predicates.push({ iri: extracted, form: config.form, entryIndex, remove });
                         entry.iri = extracted;
                         entry.form = config.form;
+                        entry.remove = remove;
                     }
 
                     result.entries.push(entry);
@@ -373,8 +403,8 @@ export function parseSemanticBlock(raw) {
 
             // Default case (no pattern match)
             if (!processed) {
-                result.predicates.push({ iri: token, form: '', entryIndex });
-                result.entries.push({ kind: 'property', iri: token, form: '', relRange: { start: relStart, end: relEnd }, raw: token });
+                result.predicates.push({ iri: token, form: '', entryIndex, remove });
+                result.entries.push({ kind: 'property', iri: token, form: '', relRange: { start: relStart, end: relEnd }, raw: m[0], remove });
             }
         }
 
@@ -392,121 +422,8 @@ export function quadIndexKey(subject, predicate, object) {
     return JSON.stringify([subject.value, predicate.value, objKey]);
 }
 
-export function normalizeQuad(q) {
-    if (!q) return null;
-    const { subject, predicate, object } = q;
-    if (object?.termType === 'Literal') {
-        const language = typeof object.language === 'string' ? object.language : '';
-        const datatype = object.datatype || { termType: 'NamedNode', value: 'http://www.w3.org/2001/XMLSchema#string' };
-        return { ...q, subject, predicate, object: { ...object, language, datatype } };
-    }
-    return { ...q, subject, predicate, object };
-}
-
-export function objectSignature(o) {
-    if (!o) return '';
-    if (o.termType === 'Literal') {
-        return JSON.stringify({ t: 'Literal', v: o.value, lang: o.language || '', dt: o.datatype?.value || '' });
-    }
-    return JSON.stringify({ t: o.termType, v: o.value });
-}
-
 export function quadToKeyForOrigin(q) {
-    const nq = normalizeQuad(q);
-    return nq ? quadIndexKey(nq.subject, nq.predicate, nq.object) : null;
-}
-
-export function parseQuadIndexKey(key) {
-    try {
-        const [s, p, objKey] = JSON.parse(key);
-        return { s, p, o: JSON.parse(objKey) };
-    } catch {
-        return null;
-    }
-}
-
-// Direct slot management functions - unified with block data
-export function createUnifiedSlot(block, entryIndex, meta = {}) {
-    const slotId = meta.subject && meta.predicate ? hash(`${meta.subject.value}|${meta.predicate.value}`) : null;
-    return {
-        // Block metadata
-        id: block.id,
-        range: block.range,
-        attrsRange: block.attrsRange,
-        valueRange: block.valueRange,
-        carrierType: block.carrierType,
-        subject: block.subject,
-        types: block.types,
-        predicates: block.predicates,
-        context: block.context,
-
-        // Slot metadata
-        entryIndex,
-        slotId,
-        isVacant: false,
-        lastValue: null,
-        vacantSince: null,
-
-        // Quad metadata
-        ...meta
-    };
-}
-
-export function markSlotAsVacant(slotInfo, deletedValue) {
-    return slotInfo ? {
-        ...slotInfo,
-        isVacant: true,
-        lastValue: deletedValue,
-        vacantSince: Date.now()
-    } : null;
-}
-
-export function findVacantSlot(quadMap, subject, predicate) {
-    const targetSlotId = hash(`${subject.value}|${predicate.value}`);
-    return Array.from(quadMap.values())
-        .find(slot => slot.slotId === targetSlotId && slot.isVacant);
-}
-
-export function occupySlot(slotInfo, newValue) {
-    return slotInfo && slotInfo.isVacant ? {
-        ...slotInfo,
-        isVacant: false,
-        lastValue: newValue,
-        vacantSince: null
-    } : null;
-}
-
-export function normalizeAttrsTokens(attrsText) {
-    const cleaned = String(attrsText || '').replace(/^\s*\{|\}\s*$/g, '').trim();
-    return cleaned ? cleaned.split(/\s+/).filter(Boolean) : [];
-}
-
-export function writeAttrsTokens(tokens) {
-    return `{${tokens.join(' ').trim()}}`;
-}
-
-export function removeOneToken(tokens, matchFn) {
-    const i = tokens.findIndex(matchFn);
-    return i === -1 ? { tokens, removed: false } : { tokens: [...tokens.slice(0, i), ...tokens.slice(i + 1)], removed: true };
-}
-
-// Direct token management - no wrapper function needed
-export function addObjectToken(tokens, iri) {
-    const token = `+${iri}`;
-    return tokens.includes(token) ? tokens : [...tokens, token];
-}
-
-export function removeObjectToken(tokens, iri) {
-    return removeOneToken(tokens, t => t === `+${iri}`);
-}
-
-export function addSoftFragmentToken(tokens, fragment) {
-    const token = `+#${fragment}`;
-    return tokens.includes(token) ? tokens : [...tokens, token];
-}
-
-export function removeSoftFragmentToken(tokens, fragment) {
-    return removeOneToken(tokens, t => t === `+#${fragment}`);
+    return q ? quadIndexKey(q.subject, q.predicate, q.object) : null;
 }
 
 export function createLiteral(value, datatype, language, context, dataFactory) {