mdld-parse 0.4.1 → 0.4.3

package/src/serialize.js

@@ -94,80 +94,68 @@ function updateAttrsDatatypeLang(tokens, newLit, ctx) {
     return predicatesAndTypes;
 }
 
-// Slot abstraction for cleaner operations
-class Slot {
-    constructor(block, entry, kind = null) {
-        this.block = block;
-        this.entry = entry;
-        this.kind = kind || entry?.kind;
-        this.entryIndex = entry?.entryIndex;
-        this.isVacant = entry?.isVacant || false;
-        this.form = entry?.form;
+// Direct slot operations - no class abstraction needed
+function removeTokenFromSlot(entry, tokens, ctx, quad) {
+    if (!entry) return { tokens, removed: false };
+
+    if (entry.kind === 'object') {
+        const objectIRI = shortenIRI(quad.object.value, ctx);
+        return removeObjectToken(tokens, objectIRI);
+    } else if (entry.kind === 'softFragment') {
+        const fragment = entry.fragment;
+        return removeSoftFragmentToken(tokens, fragment);
+    } else if (entry.kind === 'type' && quad.predicate.value.endsWith('rdf-syntax-ns#type')) {
+        const expectedType = entry.expandedType || quad.object.value;
+        return removeOneToken(tokens, t => {
+            if (!t.startsWith('.')) return false;
+            const raw = t.slice(1);
+            return expandIRI(raw, ctx) === expectedType;
+        });
+    } else {
+        const expectedPred = entry.expandedPredicate || quad.predicate.value;
+        const expectedForm = entry.form;
+        return removeOneToken(tokens, t => {
+            const m = String(t).match(/^(\^\?|\^|\?|)(.+)$/);
+            if (!m) return false;
+            const form = m[1] || '';
+            const raw = m[2];
+            if (expectedForm != null && form !== expectedForm) return false;
+            return expandIRI(raw, ctx) === expectedPred;
+        });
     }
+}
 
-    removeToken(tokens, ctx, quad) {
-        if (!this.entry) return { tokens, removed: false };
-
-        if (this.kind === 'object') {
-            const objectIRI = shortenIRI(quad.object.value, ctx);
-            return removeObjectToken(tokens, objectIRI);
-        } else if (this.kind === 'softFragment') {
-            const fragment = this.entry.fragment;
-            return removeSoftFragmentToken(tokens, fragment);
-        } else if (this.kind === 'type' && quad.predicate.value.endsWith('rdf-syntax-ns#type')) {
-            const expectedType = this.entry.expandedType || quad.object.value;
-            return removeOneToken(tokens, t => {
-                if (!t.startsWith('.')) return false;
-                const raw = t.slice(1);
-                return expandIRI(raw, ctx) === expectedType;
-            });
-        } else {
-            const expectedPred = this.entry.expandedPredicate || quad.predicate.value;
-            const expectedForm = this.entry.form;
-            return removeOneToken(tokens, t => {
-                const m = String(t).match(/^(\^\?|\^|\?|)(.+)$/);
-                if (!m) return false;
-                const form = m[1] || '';
-                const raw = m[2];
-                if (expectedForm != null && form !== expectedForm) return false;
-                return expandIRI(raw, ctx) === expectedPred;
-            });
+function addTokenToSlot(tokens, ctx, quad) {
+    if (quad.predicate.value.endsWith('rdf-syntax-ns#type') && quad.object?.termType === 'NamedNode') {
+        const typeShort = shortenIRI(quad.object.value, ctx);
+        const typeToken = typeShort.includes(':') || !typeShort.startsWith('http') ? `.${typeShort}` : null;
+        if (typeToken && !tokens.includes(typeToken)) {
+            return [...tokens, typeToken];
         }
-    }
-
-    addToken(tokens, ctx, quad) {
-        if (quad.predicate.value.endsWith('rdf-syntax-ns#type') && quad.object?.termType === 'NamedNode') {
-            const typeShort = shortenIRI(quad.object.value, ctx);
-            const typeToken = typeShort.includes(':') || !typeShort.startsWith('http') ? `.${typeShort}` : null;
-            if (typeToken && !tokens.includes(typeToken)) {
-                return [...tokens, typeToken];
-            }
-        } else if (quad.object.termType === 'NamedNode') {
-            const objectShort = shortenIRI(quad.object.value, ctx);
-            const isSoftFragment = quad.object.value.includes('#');
-            const fragment = isSoftFragment ? quad.object.value.split('#')[1] : null;
+    } else if (quad.object.termType === 'NamedNode') {
+        const objectShort = shortenIRI(quad.object.value, ctx);
+        const isSoftFragment = quad.object.value.includes('#');
+        const fragment = isSoftFragment ? quad.object.value.split('#')[1] : null;
 
-            if (isSoftFragment) {
-                return addSoftFragmentToken(tokens, fragment);
-            } else {
-                return addObjectToken(tokens, objectShort);
-            }
-        } else if (quad.object.termType === 'Literal') {
-            // For literal predicates, we need to add the predicate token
-            const predShort = shortenIRI(quad.predicate.value, ctx);
-            if (!tokens.includes(predShort)) {
-                return [...tokens, predShort];
-            }
+        if (isSoftFragment) {
+            return addSoftFragmentToken(tokens, fragment);
+        } else {
+            return addObjectToken(tokens, objectShort);
+        }
+    } else if (quad.object.termType === 'Literal') {
+        const predShort = shortenIRI(quad.predicate.value, ctx);
+        if (!tokens.includes(predShort)) {
+            return [...tokens, predShort];
         }
-        return tokens;
     }
+    return tokens;
+}
 
-    markVacant(quad) {
-        if (this.entry && this.entry.slotId) {
-            return markSlotAsVacant(this.entry, quad.object);
-        }
-        return null;
+function markEntryAsVacant(entry, quad) {
+    if (entry && entry.slotId) {
+        return markSlotAsVacant(entry, quad.object);
     }
+    return null;
 }
 
 export function serialize({ text, diff, origin, options = {} }) {
@@ -345,10 +333,8 @@ function materializeEdits(plan, text, ctx, base) {
 
     // Materialize deletes
     for (const { quad, entry, block } of plan.deletes) {
-        const slot = new Slot(block, entry);
-
         // Mark slot as vacant
-        const vacantSlot = slot.markVacant(quad);
+        const vacantSlot = markEntryAsVacant(entry, quad);
         if (vacantSlot && block) {
             const blockInfo = {
                 id: entry.blockId,
@@ -378,9 +364,9 @@ function materializeEdits(plan, text, ctx, base) {
             }
         }
 
-        // Handle token-based removals using Slot abstraction
+        // Handle token-based removals using direct functions
         const tokens = normalizeAttrsTokens(span.text);
-        const { tokens: updated, removed } = slot.removeToken(tokens, ctx, quad);
+        const { tokens: updated, removed } = removeTokenFromSlot(entry, tokens, ctx, quad);
 
         if (removed) {
             const newText = updated.length === 0 ? '{}' : writeAttrsTokens(updated);
@@ -428,8 +414,7 @@ function materializeEdits(plan, text, ctx, base) {
 
             // Normal annotation block, add tokens
             const existingTokens = blockTokensFromEntries(targetBlock) || tokens;
-            const slot = new Slot(targetBlock, null);
-            let updated = slot.addToken(existingTokens, ctx, quad);
+            let updated = addTokenToSlot(existingTokens, ctx, quad);
 
             // For literal predicates with datatypes, we need to add datatype token too
             if (quad.object.termType === 'Literal' && quad.object.datatype && quad.object.datatype.value !== 'http://www.w3.org/2001/XMLSchema#string') {
@@ -460,32 +445,28 @@ function applyEdits(text, edits, ctx, base) {
     // Extract vacant slots before reparsing
     const vacantSlots = new Map();
     base?.quadIndex?.forEach((slot, key) => {
-        if (slot.isVacant) {
-            vacantSlots.set(key, slot);
-        }
+        if (slot.isVacant) vacantSlots.set(key, slot);
     });
 
     const reparsed = parse(result, { context: ctx });
 
     // Merge vacant slots back
     vacantSlots.forEach((vacantSlot, key) => {
-        if (!reparsed.origin.blocks.has(vacantSlot.blockId)) {
-            const blockInfo = vacantSlot.blockInfo;
-            if (blockInfo) {
-                const emptyBlock = {
-                    id: blockInfo.id,
-                    range: blockInfo.range || { start: 0, end: 0 },
-                    attrsRange: blockInfo.attrsRange,
-                    valueRange: blockInfo.valueRange,
-                    carrierType: blockInfo.carrierType || 'span',
-                    subject: blockInfo.subject || '',
-                    types: [],
-                    predicates: [],
-                    entries: [],
-                    context: blockInfo.context || { ...ctx }
-                };
-                reparsed.origin.blocks.set(vacantSlot.blockId, emptyBlock);
-            }
+        if (!reparsed.origin.blocks.has(vacantSlot.blockId) && vacantSlot.blockInfo) {
+            const { blockInfo } = vacantSlot;
+            const emptyBlock = {
+                id: blockInfo.id,
+                range: blockInfo.range || { start: 0, end: 0 },
+                attrsRange: blockInfo.attrsRange,
+                valueRange: blockInfo.valueRange,
+                carrierType: blockInfo.carrierType || 'span',
+                subject: blockInfo.subject || '',
+                types: [],
+                predicates: [],
+                entries: [],
+                context: blockInfo.context || { ...ctx }
+            };
+            reparsed.origin.blocks.set(vacantSlot.blockId, emptyBlock);
         }
         reparsed.origin.quadIndex.set(key, vacantSlot);
     });

package/src/utils.js

@@ -76,14 +76,13 @@ export function parseSemanticBlock(raw) {
             const relEnd = relStart + token.length;
             const entryIndex = result.entries.length;
 
-            // Handle special tokens first
+            // Handle special tokens
             if (token === '=') {
                 result.subject = 'RESET';
                 result.entries.push({ kind: 'subjectReset', relRange: { start: relStart, end: relEnd }, raw: token });
                 continue;
             }
 
-            // Handle '=' pattern for subject declarations (not reset)
             if (token.startsWith('=') && !token.startsWith('=#')) {
                 const iri = token.substring(1);
                 result.subject = iri;
@@ -95,41 +94,32 @@ 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
-                    };
-
-                    if (config.extract) {
-                        const extracted = config.extract(token);
-                        if (config.kind === 'fragment') {
-                            result.subject = `=#${extracted}`;
-                            entry.fragment = extracted;
-                        } else if (config.kind === 'softFragment') {
-                            result.object = `#${extracted}`;
-                            entry.fragment = extracted;
-                        } else if (config.kind === 'object') {
-                            result.object = extracted;
-                            entry.iri = extracted;
-                        } else if (config.kind === 'datatype') {
-                            if (!result.language) result.datatype = extracted;
-                            entry.datatype = extracted;
-                        } else if (config.kind === 'language') {
-                            result.language = extracted;
-                            result.datatype = null;
-                            entry.language = extracted;
-                        } else if (config.kind === 'type') {
-                            result.types.push({ iri: extracted, entryIndex });
-                            entry.iri = extracted;
-                        } else if (config.kind === 'property') {
-                            result.predicates.push({ iri: extracted, form: config.form, entryIndex });
-                            entry.iri = extracted;
-                            entry.form = config.form;
-                        }
-                    } else {
-                        // For '=' pattern (subjectReset handled above)
-                        if (config.kind === 'subjectReset') continue;
+                    const entry = { kind: config.kind, relRange: { start: relStart, end: relEnd }, raw: token };
+                    const extracted = config.extract(token);
+
+                    if (config.kind === 'fragment') {
+                        result.subject = `=#${extracted}`;
+                        entry.fragment = extracted;
+                    } else if (config.kind === 'softFragment') {
+                        result.object = `#${extracted}`;
+                        entry.fragment = extracted;
+                    } else if (config.kind === 'object') {
+                        result.object = extracted;
+                        entry.iri = extracted;
+                    } else if (config.kind === 'datatype') {
+                        if (!result.language) result.datatype = extracted;
+                        entry.datatype = extracted;
+                    } else if (config.kind === 'language') {
+                        result.language = extracted;
+                        result.datatype = null;
+                        entry.language = extracted;
+                    } else if (config.kind === 'type') {
+                        result.types.push({ iri: extracted, entryIndex });
+                        entry.iri = extracted;
+                    } else if (config.kind === 'property') {
+                        result.predicates.push({ iri: extracted, form: config.form, entryIndex });
+                        entry.iri = extracted;
+                        entry.form = config.form;
                     }
 
                     result.entries.push(entry);
@@ -138,7 +128,7 @@ export function parseSemanticBlock(raw) {
                 }
             }
 
-            // Handle default case (no pattern match)
+            // 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 });
@@ -192,69 +182,42 @@ export function parseQuadIndexKey(key) {
     }
 }
 
-export function createSemanticSlotId(subject, predicate) {
-    return hash(`${subject.value}|${predicate.value}`);
-}
-
-// Consolidated quad management
-export function createQuadManager() {
+// Direct slot management functions - no factory needed
+export function createSlotInfo(blockId, entryIndex, meta = {}) {
+    const slotId = meta.subject && meta.predicate ? hash(`${meta.subject.value}|${meta.predicate.value}`) : null;
     return {
-        createSlot: (blockId, entryIndex, meta = {}) => {
-            const slotId = meta.subject && meta.predicate ? createSemanticSlotId(meta.subject, meta.predicate) : null;
-            return {
-                blockId,
-                entryIndex,
-                slotId,
-                isVacant: false,
-                lastValue: null,
-                vacantSince: null,
-                ...meta
-            };
-        },
-
-        markVacant: (slotInfo, deletedValue) => {
-            if (!slotInfo) return null;
-            return {
-                ...slotInfo,
-                isVacant: true,
-                lastValue: deletedValue,
-                vacantSince: Date.now()
-            };
-        },
-
-        findVacant: (quadIndex, subject, predicate) => {
-            const targetSlotId = createSemanticSlotId(subject, predicate);
-            return Array.from(quadIndex.values())
-                .find(slot => slot.slotId === targetSlotId && slot.isVacant);
-        },
-
-        occupy: (slotInfo, newValue) => {
-            if (!slotInfo || !slotInfo.isVacant) return null;
-            return {
-                ...slotInfo,
-                isVacant: false,
-                lastValue: newValue,
-                vacantSince: null
-            };
-        }
+        blockId,
+        entryIndex,
+        slotId,
+        isVacant: false,
+        lastValue: null,
+        vacantSince: null,
+        ...meta
     };
 }
 
-// Backward compatibility exports
-export function createSlotInfo(blockId, entryIndex, meta = {}) {
-    return createQuadManager().createSlot(blockId, entryIndex, meta);
-}
-
 export function markSlotAsVacant(slotInfo, deletedValue) {
-    return createQuadManager().markVacant(slotInfo, deletedValue);
+    return slotInfo ? {
+        ...slotInfo,
+        isVacant: true,
+        lastValue: deletedValue,
+        vacantSince: Date.now()
+    } : null;
 }
 
 export function findVacantSlot(quadIndex, subject, predicate) {
-    return createQuadManager().findVacant(quadIndex, subject, predicate);
+    const targetSlotId = hash(`${subject.value}|${predicate.value}`);
+    return Array.from(quadIndex.values())
+        .find(slot => slot.slotId === targetSlotId && slot.isVacant);
 }
 
 export function occupySlot(slotInfo, newValue) {
-    return createQuadManager().occupy(slotInfo, newValue);
+    return slotInfo && slotInfo.isVacant ? {
+        ...slotInfo,
+        isVacant: false,
+        lastValue: newValue,
+        vacantSince: null
+    } : null;
 }
 
 export function normalizeAttrsTokens(attrsText) {
@@ -271,32 +234,23 @@ export function removeOneToken(tokens, matchFn) {
     return i === -1 ? { tokens, removed: false } : { tokens: [...tokens.slice(0, i), ...tokens.slice(i + 1)], removed: true };
 }
 
-// Consolidated token management
-function manageToken(tokens, action, tokenType, value) {
-    const token = tokenType === 'object' ? `+${value}` :
-        tokenType === 'softFragment' ? `+#${value}` : value;
-
-    switch (action) {
-        case 'add': return tokens.includes(token) ? tokens : [...tokens, token];
-        case 'remove': return removeOneToken(tokens, t => t === token);
-        default: return tokens;
-    }
-}
-
+// Direct token management - no wrapper function needed
 export function addObjectToken(tokens, iri) {
-    return manageToken(tokens, 'add', 'object', iri);
+    const token = `+${iri}`;
+    return tokens.includes(token) ? tokens : [...tokens, token];
 }
 
 export function removeObjectToken(tokens, iri) {
-    return manageToken(tokens, 'remove', 'object', iri);
+    return removeOneToken(tokens, t => t === `+${iri}`);
 }
 
 export function addSoftFragmentToken(tokens, fragment) {
-    return manageToken(tokens, 'add', 'softFragment', fragment);
+    const token = `+#${fragment}`;
+    return tokens.includes(token) ? tokens : [...tokens, token];
 }
 
 export function removeSoftFragmentToken(tokens, fragment) {
-    return manageToken(tokens, 'remove', 'softFragment', fragment);
+    return removeOneToken(tokens, t => t === `+#${fragment}`);
 }
 
 export function createLiteral(value, datatype, language, context, dataFactory) {