@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/collection/components/job-selector/keyboard-handlers.js

@@ -0,0 +1,84 @@
+import { shouldShowManualInputOption } from "./search-logic";
+import log from "loglevel";
+function navigateSuggestions(direction, context) {
+    const { state, activeIndex, listRef, listId, requireSelection, onNavigate } = context;
+    log.debug('[KeyboardHandlers] navigateSuggestions - Direction:', direction);
+    if (state.status !== 'searching' && state.status !== 'multiSelect') {
+        return;
+    }
+    const suggestions = state.suggestions;
+    const inputValue = state.inputValue;
+    const showManualInputOption = shouldShowManualInputOption(suggestions, inputValue, requireSelection);
+    // Total antal valbara alternativ (inkl manuell input om den visas)
+    const totalOptions = suggestions.length + (showManualInputOption ? 1 : 0);
+    if (totalOptions === 0) {
+        return;
+    }
+    const newIndex = direction === 'down'
+        ? (activeIndex + 1) % totalOptions
+        : (activeIndex - 1 + totalOptions) % totalOptions;
+    onNavigate(newIndex);
+    // Scrolla till rätt element
+    // Vi kan inte göra this.listRef.querySelector i denna funktion utan referens, 
+    // men vi har listRef i context.
+    if (listRef) {
+        const optionId = newIndex === suggestions.length
+            ? `${listId}-option-manual-input`
+            : `${listId}-option-${newIndex}`;
+        const activeElement = listRef.querySelector(`#${optionId}`);
+        activeElement?.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+    }
+}
+export function handleKeyboardNavigation(event, context) {
+    const { state, activeIndex, requireSelection, onSelect, onClearSuggestions, onEnterWithoutSelection } = context;
+    log.debug('[KeyboardHandlers] handleKeyDown - Key pressed:', event.key);
+    if (state.status !== 'searching' && state.status !== 'multiSelect') {
+        return;
+    }
+    const suggestions = state.suggestions;
+    const inputValue = state.inputValue;
+    const trimmedInput = inputValue.trim();
+    const showManualInputOption = shouldShowManualInputOption(suggestions, inputValue, requireSelection);
+    const totalOptions = suggestions.length + (showManualInputOption ? 1 : 0);
+    switch (event.key) {
+        case 'ArrowDown':
+            if (totalOptions > 0) {
+                event.preventDefault();
+                navigateSuggestions('down', context);
+            }
+            break;
+        case 'ArrowUp':
+            if (totalOptions > 0) {
+                event.preventDefault();
+                navigateSuggestions('up', context);
+            }
+            break;
+        case 'Enter':
+            event.preventDefault();
+            // Kolla om manuell input-alternativet är markerat
+            if (showManualInputOption && activeIndex === suggestions.length) {
+                // Användaren har navigerat till manuell input-alternativet
+                const manualInputItem = {
+                    id: '',
+                    type: 'ManualInput',
+                    rawLabel: trimmedInput,
+                    displayLabel: trimmedInput,
+                    highlightedLabel: trimmedInput,
+                    score: 1.0,
+                    preferred_label: trimmedInput
+                };
+                onSelect(manualInputItem);
+            }
+            else if (activeIndex > -1 && activeIndex < suggestions.length) {
+                // Användaren har valt ett förslag med piltangenter
+                onSelect(suggestions[activeIndex]);
+            }
+            else if (!requireSelection && trimmedInput !== '') {
+                onEnterWithoutSelection(trimmedInput);
+            }
+            break;
+        case 'Escape':
+            onClearSuggestions();
+            break;
+    }
+}

package/dist/collection/components/job-selector/logic/adapter.utils.js

@@ -0,0 +1,75 @@
+import { LabelFormatter } from "./label-formatter";
+import { segmentsToHtml } from "../search.utils";
+export 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;
+    }
+};

package/dist/collection/components/job-selector/logic/label-formatter.js

@@ -0,0 +1,118 @@
+export 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(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;
+    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(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(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;
+}

package/dist/collection/components/job-selector/logic/search.engine.js

@@ -0,0 +1,50 @@
+import Fuse from "fuse.js";
+import { searchConcepts } from "../search.utils";
+import { FUSE_OPTIONS } from "../constants";
+import { TaxonomyAdapter } from "./adapter.utils";
+export class TaxonomySearchEngine {
+    fuseInstance = null;
+    items = [];
+    constructor(data) {
+        this.items = data;
+        this.fuseInstance = new Fuse(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(newData, FUSE_OPTIONS);
+    }
+}

package/dist/collection/components/job-selector/search-logic.js

@@ -0,0 +1,35 @@
+const GOOD_MATCH_MIN_SCORE = 0.9;
+/**
+ * Determines whether the "Manual Input" option should be shown in the suggestions list.
+ *
+ * Logic:
+ * 1. If requireSelection is true, never show manual input option.
+ * 2. If input is empty/whitespace, never show manual input option.
+ * 3. If there's an exact match (case-insensitive) in suggestions, don't show (avoid duplicates).
+ * 4. If the best suggestion has a "good" direct score, don't show.
+ * 5. Otherwise, show the manual input option.
+ *
+ * @param suggestions - Array of search results from the taxonomy search
+ * @param inputValue - Current user input value
+ * @param requireSelection - Whether selection from taxonomy is required
+ * @returns true if manual input option should be displayed
+ */
+export function shouldShowManualInputOption(suggestions, inputValue, requireSelection) {
+    // Rule 1: If selection is required, never allow manual input
+    if (requireSelection)
+        return false;
+    // Rule 2: Empty input = no manual input option
+    const trimmedInput = inputValue.trim();
+    if (trimmedInput === '')
+        return false;
+    // Rule 3: Check for exact match (avoid duplicate entries)
+    const lowerInput = trimmedInput.toLowerCase();
+    const exactMatch = suggestions.some((s) => s.rawLabel.toLowerCase() === lowerInput ||
+        s.displayLabel.toLowerCase() === lowerInput);
+    if (exactMatch)
+        return false;
+    // Rule 4: Check "registry quality" - only show manual input for poor matches.
+    const bestScore = suggestions.length > 0 ? (suggestions[0].score ?? 0) : 0;
+    const hasGoodMatch = bestScore >= GOOD_MATCH_MIN_SCORE;
+    return !hasGoodMatch;
+}

package/dist/collection/components/job-selector/search.utils.js

@@ -0,0 +1,224 @@
+import { MIN_INPUT_LENGTH } from "./constants";
+import log from "loglevel";
+import { LabelFormatter } from "./logic/label-formatter";
+const MAX_WEAK_FUZZY_RESULTS = 3;
+const MIN_FUZZY_SCORE = 0.4;
+const MAX_FUZZY_SCORE = 0.84;
+if (process.env.NODE_ENV === 'test') {
+    log.setLevel(log.levels.SILENT);
+}
+else {
+    log.setLevel(log.levels.DEBUG); // Set log level to DEBUG for development/testing
+}
+export const normalizeForComparison = (text) => {
+    if (!text) {
+        return '';
+    }
+    const normalized = text.toLowerCase().trim();
+    return normalized;
+};
+export function formatDisplayLabel(item) {
+    if (item.occupation_name_preferred_label) {
+        return `${item.preferred_label || ''} (${item.occupation_name_preferred_label})`;
+    }
+    return item.preferred_label || '';
+}
+;
+export function getLabel(item) {
+    return item.preferred_label || '';
+}
+export 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');
+    });
+}
+export 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`.
+export 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,
+    };
+}
+export function searchConcepts(query, items, fuseInstance, maxResults) {
+    if (!fuseInstance) {
+        return [];
+    }
+    if (!items || !Array.isArray(items)) {
+        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 [];
+}

package/dist/collection/components/job-selector/suggestions-list.js

@@ -0,0 +1,31 @@
+import { h } from "@stencil/core";
+import { shouldShowManualInputOption } from "./search-logic";
+import log from "loglevel";
+export const SuggestionsList = (props) => {
+    const { suggestions, inputValue, activeIndex, listId, requireSelection, onSelect, onMouseEnter, setListRef } = props;
+    const showManualInput = shouldShowManualInputOption(suggestions, inputValue, requireSelection);
+    log.debug('[SuggestionsList] Rendering list. Count:', suggestions.length, 'Show manual input:', showManualInput);
+    const renderSuggestion = (suggestion, index) => {
+        const isActive = index === activeIndex;
+        return (h("div", { role: "option", id: `${listId}-option-${index}`, "aria-selected": isActive ? 'true' : 'false', class: { 'suggestion-item': true, 'active-suggestion': isActive }, onClick: () => onSelect(suggestion), onMouseEnter: () => onMouseEnter(index) }, suggestion.displaySegments ? (h("span", null, suggestion.displaySegments.map((segment, segmentIndex) => (h("span", { key: segmentIndex, class: {
+                'match-highlight': !!segment.isMatch,
+                'metadata-dimmed': !!segment.isMetadata
+            } }, segment.text))))) : (h("span", null, suggestion.displayLabel || suggestion.rawLabel))));
+    };
+    return (h("div", { class: "suggestions-box", ref: el => setListRef(el), id: listId, role: "listbox", onMouseDown: e => e.preventDefault() }, suggestions.map((suggestion, index) => renderSuggestion(suggestion, index)), showManualInput && (h("div", { role: "option", id: `${listId}-option-manual-input`, "aria-selected": activeIndex === suggestions.length ? 'true' : 'false', class: {
+            'suggestion-item': true,
+            'suggestion-item-manual-input': true,
+            'active-suggestion': activeIndex === suggestions.length
+        }, onClick: () => {
+            const manualInputItem = {
+                id: '',
+                type: 'ManualInput',
+                rawLabel: inputValue.trim(),
+                displayLabel: inputValue.trim(),
+                highlightedLabel: inputValue.trim(),
+                score: 1.0,
+                preferred_label: inputValue.trim()
+            };
+            onSelect(manualInputItem);
+        }, onMouseEnter: () => onMouseEnter(suggestions.length) }, h("span", null, "Ange annat yrke \"", h("strong", null, inputValue.trim()), "\"")))));
+};

package/dist/collection/components/job-selector/taxonomy-registry.js

@@ -0,0 +1,60 @@
+import log from "loglevel";
+let registeredTaxonomy = [];
+let registeredVersion = null;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+export function isTaxonomyItem(value) {
+    if (!isRecord(value))
+        return false;
+    return (isNonEmptyString(value.id)
+        && (value.type === 'job-title' || value.type === 'occupation-name')
+        && isNonEmptyString(value.preferred_label)
+        && isOptionalString(value.ssyk_level_4_id)
+        && isOptionalString(value.ssyk_code_2012)
+        && isOptionalString(value.occupation_name_id)
+        && isOptionalString(value.occupation_name_preferred_label)
+        && (value.weight === undefined || (typeof value.weight === 'number' && Number.isFinite(value.weight))));
+}
+export function isTaxonomyRegistration(value) {
+    if (!isRecord(value) || !Array.isArray(value.data) || value.data.length === 0) {
+        return false;
+    }
+    return value.data.every((item) => isTaxonomyItem(item));
+}
+/**
+ * Registrerar validerad taxonomidata för webbkomponenten.
+ * Ogiltig data ersätter aldrig en tidigare giltig registrering.
+ */
+export function registerTaxonomy(data) {
+    if (!isTaxonomyRegistration(data)) {
+        log.error('[TaxonomyRegistry] Felaktigt format på taxonomidata vid registrering.');
+        return;
+    }
+    registeredTaxonomy = data.data.map((item) => ({ ...item }));
+    const metadataVersion = isRecord(data.metadata)
+        ? data.metadata.labour_market_taxonomy_version
+        : undefined;
+    registeredVersion = metadataVersion !== undefined
+        ? String(metadataVersion)
+        : (data.taxonomyVersion !== undefined ? String(data.taxonomyVersion) : 'unknown');
+    log.debug(`[TaxonomyRegistry] Taxonomi version ${registeredVersion} registrerades med ${registeredTaxonomy.length} yrken.`);
+}
+/** Hämtar den registrerade taxonomin. */
+export function getRegisteredTaxonomy() {
+    if (registeredTaxonomy.length === 0) {
+        log.warn('[TaxonomyRegistry] Ingen taxonomi är registrerad ännu! Anropa registerTaxonomy(data) först.');
+    }
+    return registeredTaxonomy;
+}
+/** Endast för testning: återställer registret. */
+export function __resetRegistry() {
+    registeredTaxonomy = [];
+    registeredVersion = null;
+}