@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/cjs/search.engine-D0cMelRi.js

@@ -0,0 +1,489 @@
+'use strict';
+
+var fuse = require('./fuse-BTLNKxuL.js');
+var taxonomyRegistry = require('./taxonomy-registry-DVmuDUpM.js');
+
+// Minimum number of characters required to trigger search
+const MIN_INPUT_LENGTH = 1;
+// Debounce time for search input (ms)
+const DEBOUNCE_TIME = 100; // ms - Återställt till 250 baserat på sok-box.tsx initialt
+// Default maximum number of results to display
+const MAX_RESULTS = 10;
+// Configuration for Fuse.js
+const FUSE_OPTIONS = {
+    keys: ['preferred_label'], // Ändrat från 'label' till 'preferred_label' för att matcha datastrukturen
+    includeScore: true,
+    ignoreDiacritics: true, // Lägg till för att matcha t.ex. vard -> vård
+    ignoreFieldNorm: true, // Lägg till för att ignorera fältlängd vid poängsättning
+    threshold: 0.6, // Behåll 0.6
+    minMatchCharLength: MIN_INPUT_LENGTH, // Refererar till konstant ovan
+    ignoreLocation: true, // Match anywhere in the string
+    distance: 100, // Allow matches further apart
+};
+// UI Text Strings
+const PLACEHOLDER_TEXT = "T.ex. frisör, vårdbiträde, snickare"; // Uppdaterad standardplaceholder enligt Figma-design
+
+const LabelFormatter = {
+    format: (label, query, occupationLabel) => {
+        // 1. Highlight the main label based on query
+        const labelSegments = highlightText(label, query);
+        // 2. Append occupation label if it exists (the "metadata" part)
+        if (occupationLabel) {
+            return [
+                ...labelSegments,
+                { text: ' ', isMatch: false },
+                { text: `(${occupationLabel})`, isMetadata: true }
+            ];
+        }
+        return labelSegments;
+    }
+};
+function calculateEditDistance$1(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findBestFuzzySubstring$1(text, qToken) {
+    const lowerText = text.toLowerCase();
+    const targetLen = qToken.length;
+    let bestDist = 99;
+    let bestStart = -1;
+    let bestLen = 0;
+    const minLen = Math.max(3, targetLen - 2);
+    const maxLen = Math.min(lowerText.length, targetLen + 2);
+    for (let start = 0; start <= lowerText.length - minLen; start++) {
+        for (let len = minLen; len <= maxLen && start + len <= lowerText.length; len++) {
+            const sub = lowerText.slice(start, start + len);
+            const dist = calculateEditDistance$1(qToken, sub);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestStart = start;
+                bestLen = len;
+            }
+        }
+    }
+    const maxAllowedDist = Math.max(2, Math.floor(targetLen * 0.25));
+    if (bestDist <= maxAllowedDist && bestStart !== -1) {
+        return { start: bestStart, length: bestLen };
+    }
+    return null;
+}
+/**
+ * Highlights matches in text based on query.
+ * Supports multi-word queries.
+ */
+function highlightText(text, query) {
+    if (!text)
+        return [];
+    if (!query || query.trim().length === 0) {
+        return [{ text, isMatch: false }];
+    }
+    const lowerText = text.toLowerCase();
+    const tokens = query.toLowerCase().split(/\s+/).filter(t => t.length > 0);
+    // Set of indices in the original text that should be highlighted
+    const highlightedIndices = new Set();
+    tokens.forEach(token => {
+        let startIndex = 0;
+        while ((startIndex = lowerText.indexOf(token, startIndex)) !== -1) {
+            for (let i = 0; i < token.length; i++) {
+                highlightedIndices.add(startIndex + i);
+            }
+            startIndex += token.length;
+        }
+    });
+    if (highlightedIndices.size === 0) {
+        // Fuzzy highlight fallback: Hitta bästa matchande delsträng i sammansatta ord eller felstavningar
+        tokens.forEach(qToken => {
+            const match = findBestFuzzySubstring$1(text, qToken);
+            if (match) {
+                for (let i = 0; i < match.length; i++) {
+                    highlightedIndices.add(match.start + i);
+                }
+            }
+        });
+    }
+    if (highlightedIndices.size === 0) {
+        return [{ text, isMatch: false }];
+    }
+    const segments = [];
+    let currentSegmentText = '';
+    let currentIsMatch = highlightedIndices.has(0);
+    for (let i = 0; i < text.length; i++) {
+        const isMatch = highlightedIndices.has(i);
+        if (isMatch !== currentIsMatch) {
+            // Push previous segment
+            if (currentSegmentText.length > 0) {
+                segments.push({ text: currentSegmentText, isMatch: currentIsMatch });
+            }
+            // Start new segment
+            currentSegmentText = text[i];
+            currentIsMatch = isMatch;
+        }
+        else {
+            currentSegmentText += text[i];
+        }
+    }
+    // Push the last segment
+    if (currentSegmentText.length > 0) {
+        segments.push({ text: currentSegmentText, isMatch: currentIsMatch });
+    }
+    return segments;
+}
+
+const MAX_WEAK_FUZZY_RESULTS = 3;
+const MIN_FUZZY_SCORE = 0.4;
+const MAX_FUZZY_SCORE = 0.84;
+{
+    taxonomyRegistry.log.setLevel(taxonomyRegistry.log.levels.DEBUG); // Set log level to DEBUG for development/testing
+}
+const normalizeForComparison = (text) => {
+    if (!text) {
+        return '';
+    }
+    const normalized = text.toLowerCase().trim();
+    return normalized;
+};
+function formatDisplayLabel(item) {
+    if (item.occupation_name_preferred_label) {
+        return `${item.preferred_label || ''} (${item.occupation_name_preferred_label})`;
+    }
+    return item.preferred_label || '';
+}
+function sortResultsStrict(results) {
+    return results.sort((a, b) => {
+        const scoreA = a.score ?? 0;
+        const scoreB = b.score ?? 0;
+        if (scoreA !== scoreB) {
+            return scoreB - scoreA;
+        }
+        const weightA = a.weight ?? 0;
+        const weightB = b.weight ?? 0;
+        if (weightA !== weightB) {
+            // Buggen är fixad här
+            return weightB - weightA;
+        }
+        return a.displayLabel.localeCompare(b.displayLabel, 'sv');
+    });
+}
+function segmentsToHtml(segments) {
+    return segments.map(seg => {
+        if (seg.isMatch) {
+            return `<strong>${seg.text}</strong>`;
+        }
+        if (seg.isMetadata) {
+            return `<span class="occupation-variant-label">${seg.text}</span>`;
+        }
+        return seg.text;
+    }).join('');
+}
+// Keep export for controller compatibility (it was used there)
+// But implement using new logic or just re-export if we want to keep it simple?
+// The controller passes HTML to it.
+// Actually, `styleParentheticalText` took a string (HTML) and did regex replacement.
+// If the controller uses it on `item.displayLabel` (which is plain text usually, or mapped),
+// the controller does: `const historyItem = { ...item, highlightedLabel: styleParentheticalText(item.displayLabel) };`
+// `displayLabel` for "Frontend (System)" is "Frontend (System)".
+// If we run that through `segmentsToHtml(LabelFormatter.format(label, ''))`, we get the same result!
+// So let's re-implement `styleParentheticalText` using `LabelFormatter`.
+const styleParentheticalText = (text) => {
+    if (!text)
+        return '';
+    return text.replace(/ (\([^)]+\))/g, ' <span class="occupation-variant-label">$1</span>');
+};
+function getDirectScore(normalizedLabel, normalizedQuery, searchTokens) {
+    if (normalizedLabel === normalizedQuery) {
+        return 1.0;
+    }
+    if (searchTokens.length > 1) {
+        return searchTokens.every(token => normalizedLabel.includes(token)) ? 0.98 : null;
+    }
+    if (normalizedLabel.startsWith(normalizedQuery)) {
+        return 0.99;
+    }
+    if (normalizedLabel.includes(normalizedQuery)) {
+        return 0.95;
+    }
+    return null;
+}
+function calculateEditDistance(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+function findBestFuzzySubstring(text, qToken) {
+    const lowerText = text.toLowerCase();
+    const targetLen = qToken.length;
+    let bestDist = 99;
+    const minLen = Math.max(3, targetLen - 2);
+    const maxLen = Math.min(lowerText.length, targetLen + 2);
+    for (let start = 0; start <= lowerText.length - minLen; start++) {
+        for (let len = minLen; len <= maxLen && start + len <= lowerText.length; len++) {
+            const sub = lowerText.slice(start, start + len);
+            const dist = calculateEditDistance(qToken, sub);
+            if (dist < bestDist) {
+                bestDist = dist;
+            }
+        }
+    }
+    const maxAllowedDist = Math.max(2, Math.floor(targetLen * 0.25));
+    return bestDist <= maxAllowedDist ? bestDist : null;
+}
+function isSingleWordOrCompoundRoot(query, label) {
+    const normQ = query.toLowerCase().trim();
+    const normL = label.toLowerCase().trim();
+    if (normL.includes(' ')) {
+        const dist = calculateEditDistance(normQ, normL);
+        return dist <= Math.max(2, Math.floor(normQ.length * 0.25)) && Math.abs(normQ.length - normL.length) <= 2;
+    }
+    const subDist = findBestFuzzySubstring(normL, normQ);
+    return subDist !== null;
+}
+function createSearchResult(item, query, score) {
+    const displayLabel = formatDisplayLabel(item);
+    const displaySegments = LabelFormatter.format(item.preferred_label || '', query, item.occupation_name_preferred_label);
+    return {
+        id: item.id,
+        type: item.type,
+        preferred_label: item.preferred_label || '',
+        rawLabel: item.preferred_label || '',
+        displayLabel,
+        highlightedLabel: segmentsToHtml(displaySegments),
+        displaySegments,
+        weight: item.weight ?? 0,
+        score,
+        occupationId: item.occupation_name_id,
+        occupationLabel: item.occupation_name_preferred_label,
+        ssyk_level_4_id: item.ssyk_level_4_id,
+        ssyk_code_2012: item.ssyk_code_2012,
+    };
+}
+function searchConcepts(query, items, fuseInstance, maxResults) {
+    if (!fuseInstance) {
+        return [];
+    }
+    if (!items || !Array.isArray(items)) {
+        taxonomyRegistry.log.warn('[searchConcepts] Ogiltig items array.');
+        return [];
+    }
+    if (!query || query.length < MIN_INPUT_LENGTH) {
+        return [];
+    }
+    const normalizedQuery = normalizeForComparison(query);
+    const searchTokens = normalizedQuery.split(' ').filter(t => t.length > 0);
+    const directResults = [];
+    const processedIds = new Set();
+    for (const item of items) {
+        const normalizedLabel = normalizeForComparison(item.preferred_label);
+        const score = getDirectScore(normalizedLabel, normalizedQuery, searchTokens);
+        if (score !== null) {
+            directResults.push(createSearchResult(item, query, score));
+            processedIds.add(item.id);
+        }
+    }
+    if (directResults.length > 0) {
+        return sortResultsStrict(directResults).slice(0, maxResults);
+    }
+    // Fuzzy är ren fallback när inga direkta träffar finns.
+    if (fuseInstance) {
+        const fuseSearchOutput = fuseInstance.search(normalizedQuery);
+        if (fuseSearchOutput.length === 0) {
+            return [];
+        }
+        const bestRawScore = fuseSearchOutput[0].score ?? 1.0;
+        const candidateResults = [];
+        let hasStrongRootMatch = false;
+        for (const fr of fuseSearchOutput) {
+            if (processedIds.has(fr.item.id)) {
+                continue;
+            }
+            const rawScore = fr.score ?? 1.0;
+            const baseFuzzyScore = 1 - rawScore;
+            if (baseFuzzyScore < MIN_FUZZY_SCORE) {
+                continue;
+            }
+            // Strikt gap-filter: Tillåt aldrig träffar som har mer än 0.12 sämre råpoäng än bästa träffen
+            if (rawScore > bestRawScore + 0.12) {
+                continue;
+            }
+            const label = normalizeForComparison(fr.item.preferred_label);
+            const weight = fr.item.weight ?? 0;
+            // Hitta om etiketten innehåller en rotterm eller sammansatt del som matchar sökningen
+            const isRootMatch = isSingleWordOrCompoundRoot(normalizedQuery, label);
+            if (isRootMatch && rawScore <= 0.25) {
+                hasStrongRootMatch = true;
+            }
+            let score = baseFuzzyScore * 0.70 + (weight * 0.10);
+            if (isRootMatch) {
+                score += 0.12;
+            }
+            const boundedScore = Math.min(MAX_FUZZY_SCORE, Math.max(MIN_FUZZY_SCORE, score));
+            candidateResults.push(createSearchResult(fr.item, query, boundedScore));
+            processedIds.add(fr.item.id);
+        }
+        const sortedFuzzy = sortResultsStrict(candidateResults);
+        if (sortedFuzzy.length === 0) {
+            return [];
+        }
+        // Dynamiskt maxantal vid fuzzy-sökningar:
+        // - Stark rotmatchning (t.ex. injenjör, barlnmorska): Visa upp till 5 relevanta förslag så att fritextfältet syns utan att skrolla.
+        // - Svag/osäker matchning (t.ex. böla fölkja, pensionär): Visa MAX 3 träffar.
+        const limit = hasStrongRootMatch ? Math.min(5, maxResults) : Math.min(MAX_WEAK_FUZZY_RESULTS, maxResults);
+        return sortedFuzzy.slice(0, limit);
+    }
+    return [];
+}
+
+const TaxonomyAdapter = {
+    /** Maps a raw TaxonomyItem to a GenericItem for the CoreSelector */
+    toGenericItem(item) {
+        return {
+            id: item.id,
+            label: item.preferred_label || '',
+            description: item.occupation_name_preferred_label,
+            metadata: {
+                original: item,
+                type: item.type,
+                ssyk_level_4_id: item.ssyk_level_4_id,
+                weight: item.weight
+            }
+        };
+    },
+    /** Maps a SearchResult (from our engine) to a GenericItem */
+    searchResultToGenericItem(result, query) {
+        const segments = LabelFormatter.format(result.preferred_label || '', query, result.occupation_name_preferred_label);
+        return {
+            id: result.id,
+            label: result.preferred_label || '',
+            displaySegments: segments,
+            highlightedLabel: segmentsToHtml(segments),
+            metadata: {
+                original: result,
+                ssyk_level_4_id: result.ssyk_level_4_id,
+                weight: result.weight
+            }
+        };
+    },
+    /** Maps a GenericItem back to our internal SearchResult format */
+    fromGenericItem(item) {
+        return {
+            id: item.id,
+            preferred_label: item.label,
+            weight: item.metadata?.weight,
+            ...item.metadata?.original
+        };
+    },
+    /** Maps an internal item to the public event format */
+    toPublicSelection(item) {
+        const id = item.id || '';
+        const preferredLabel = item.preferred_label || item.rawLabel || '';
+        if (!id) {
+            return {
+                type: 'manual-input',
+                id: null,
+                preferred_label: preferredLabel,
+            };
+        }
+        if (item.type !== 'job-title' && item.type !== 'occupation-name') {
+            throw new Error(`Ogiltig intern yrkestyp för ${id}: ${item.type}`);
+        }
+        const selection = {
+            type: item.type,
+            id,
+            preferred_label: preferredLabel,
+        };
+        if (item.ssyk_code_2012) {
+            selection.ssyk_code_2012 = item.ssyk_code_2012;
+        }
+        const occupationId = item.occupation_name_id || item.occupationId;
+        const occupationLabel = item.occupation_name_preferred_label || item.occupationLabel;
+        if (item.type === 'job-title' && occupationId && occupationLabel) {
+            selection.related = {
+                type: 'occupation-name',
+                id: occupationId,
+                preferred_label: occupationLabel,
+            };
+        }
+        return selection;
+    }
+};
+
+class TaxonomySearchEngine {
+    fuseInstance = null;
+    items = [];
+    constructor(data) {
+        this.items = data;
+        this.fuseInstance = new fuse.entry_default(data, FUSE_OPTIONS);
+    }
+    /**
+     * Public API: Performs a search and returns clean, official domain objects.
+     * This is what external consumers (headless) should use.
+     */
+    search(query, maxResults = 10) {
+        if (!this.fuseInstance)
+            return [];
+        const results = searchConcepts(query, this.items, this.fuseInstance, maxResults);
+        // Map directly to public selection objects
+        return results.map(result => TaxonomyAdapter.toPublicSelection(result));
+    }
+    /**
+     * Internal API: Performs a search and returns GenericItems for the CoreSelector UI ("Bucky").
+     * Includes highlighting, grouping and internal metadata.
+     */
+    searchAsGeneric(query, maxResults = 10) {
+        if (!this.fuseInstance)
+            return [];
+        // Use the existing robust search function
+        const results = searchConcepts(query, this.items, this.fuseInstance, maxResults);
+        // Adapt SearchResult -> GenericItem
+        return results.map(result => ({
+            id: result.id,
+            label: result.displayLabel, // Use the formatted label (e.g. "Nurse (Healthcare)")
+            description: result.occupationLabel,
+            group: result.type === 'job-title' ? 'Yrke' : 'Yrkesgrupp',
+            metadata: {
+                originalResult: result, // Keep full original result for consumers
+                highlightedLabel: result.highlightedLabel,
+                score: result.score,
+                weight: result.weight
+            }
+        }));
+    }
+    updateData(newData) {
+        this.items = newData;
+        this.fuseInstance = new fuse.entry_default(newData, FUSE_OPTIONS);
+    }
+}
+
+exports.DEBOUNCE_TIME = DEBOUNCE_TIME;
+exports.LabelFormatter = LabelFormatter;
+exports.MAX_RESULTS = MAX_RESULTS;
+exports.MIN_INPUT_LENGTH = MIN_INPUT_LENGTH;
+exports.PLACEHOLDER_TEXT = PLACEHOLDER_TEXT;
+exports.TaxonomyAdapter = TaxonomyAdapter;
+exports.TaxonomySearchEngine = TaxonomySearchEngine;
+exports.segmentsToHtml = segmentsToHtml;
+exports.styleParentheticalText = styleParentheticalText;