@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/collection/components/job-selector/job-selector-controller.js

@@ -0,0 +1,835 @@
+import { TaxonomyAdapter } from "./logic/adapter.utils";
+import { HistoryService } from "./history-service";
+import { getRegisteredTaxonomy } from "./taxonomy-registry";
+import { segmentsToHtml } from "./search.utils";
+import { DEBOUNCE_TIME, MAX_RESULTS } from "./constants";
+import log from "loglevel";
+// NEW IMPORTS
+import { TaxonomySearchEngine } from "./logic/search.engine";
+import { LabelFormatter } from "./logic/label-formatter";
+export class JobSelectorController {
+    callbacks;
+    config;
+    state = { status: 'loading' };
+    taxonomyData = [];
+    popularItems = [];
+    // REPLACED: private fuseInstance: Fuse<TaxonomyItem> | null = null;
+    searchEngine = null;
+    debounceTimer;
+    validationTimer;
+    isTouched = false;
+    activeErrorType = null;
+    constructor(callbacks, config) {
+        this.callbacks = callbacks;
+        this.config = config;
+    }
+    // --- PUBLIC API ---
+    getState() {
+        return this.state;
+    }
+    getActiveErrorType() {
+        return this.activeErrorType;
+    }
+    // --- CONFIG UPDATE ---
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        // Kör validering om reglerna för obligatoriskt fält eller fritext ändras.
+        if (newConfig.required !== undefined || newConfig.requireSelection !== undefined) {
+            this.runValidation();
+        }
+    }
+    getTaxonomyData() {
+        // Return internal data if already loaded
+        if (this.taxonomyData.length > 0)
+            return this.taxonomyData;
+        // Try to fetch from registry (handles late registration)
+        const registeredData = getRegisteredTaxonomy();
+        if (registeredData && registeredData.length > 0) {
+            log.debug('[Controller] getTaxonomyData - Late initializing from registry');
+            this.taxonomyData = registeredData;
+            this.popularItems = this.computePopularItems(this.taxonomyData);
+            this.searchEngine = new TaxonomySearchEngine(this.taxonomyData);
+        }
+        return this.taxonomyData;
+    }
+    destroy() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = undefined;
+        }
+        if (this.validationTimer) {
+            clearTimeout(this.validationTimer);
+            this.validationTimer = undefined;
+        }
+    }
+    // --- INITIALIZATION ---
+    async initialize(initialData) {
+        log.debug('[Controller] initialize - START', { hasInitialData: !!initialData });
+        this.updateState({ status: 'loading' });
+        const registeredData = (initialData && initialData.length > 0) ? initialData : getRegisteredTaxonomy();
+        if (registeredData && registeredData.length > 0) {
+            log.debug('[Controller] initialize - Loaded taxonomy from registry');
+            this.setStateToActive(registeredData, 'registry', new Date().toISOString());
+        }
+        else {
+            log.warn('[Controller] initialize - No taxonomy found in registry. Has registerTaxonomy() been called?');
+            this.updateState({ status: 'error', message: 'Kunde inte hitta yrkesdata. Kontrollera att komponenten är initierad korrekt.' });
+        }
+    }
+    handleFocus() {
+        this.isTouched = true;
+    }
+    setStateToActive(data, source, sourceDate) {
+        this.taxonomyData = data;
+        this.popularItems = this.computePopularItems(this.taxonomyData);
+        // NEW: Initialize the separated SearchEngine
+        this.searchEngine = new TaxonomySearchEngine(this.taxonomyData);
+        // OLD: this.fuseInstance = new Fuse(this.taxonomyData, FUSE_OPTIONS);
+        const commonState = { dataSource: source, dataSourceDate: sourceDate };
+        if (this.config.enableMultiple) {
+            this.updateState({
+                status: 'multiSelect',
+                inputValue: '',
+                selectedItems: [],
+                suggestions: [],
+                validation: 'idle',
+                ...commonState
+            });
+            return;
+        }
+        this.updateState({ status: 'searching', inputValue: '', suggestions: [], validation: 'idle', ...commonState });
+    }
+    // --- SEARCH ---
+    handleInput(value) {
+        this.isTouched = true;
+        log.debug('[Controller] handleInput - Value:', value);
+        // Reset validation on input
+        const wasInError = this.state.validation === 'error';
+        const validationContext = wasInError || this.state.validationContext === 'from-error' ? 'from-error' : undefined;
+        clearTimeout(this.debounceTimer);
+        if (value.trim() === '') {
+            if (this.config.enableMultiple) {
+                const currentSelected = 'selectedItems' in this.state ? this.state.selectedItems : [];
+                this.updateState({
+                    status: 'multiSelect',
+                    inputValue: '',
+                    selectedItems: currentSelected,
+                    suggestions: [],
+                    validation: 'idle',
+                    validationContext, // BEVARA CONTEXT
+                    ...this.getCommonState()
+                });
+            }
+            else {
+                this.updateState({
+                    status: 'searching',
+                    inputValue: '',
+                    suggestions: [],
+                    validation: 'idle',
+                    validationContext, // BEVARA CONTEXT
+                    ...this.getCommonState()
+                });
+            }
+            this.showHistory();
+            return;
+        }
+        switch (this.state.status) {
+            case 'multiSelect':
+            case 'multiSelectShowingHistory': {
+                const selectedItems = 'selectedItems' in this.state ? this.state.selectedItems : [];
+                this.updateState({
+                    status: 'multiSelect',
+                    inputValue: value,
+                    selectedItems,
+                    suggestions: 'suggestions' in this.state ? this.state.suggestions : ('historyItems' in this.state ? this.state.historyItems : []),
+                    validation: 'idle',
+                    validationContext,
+                    dataSource: 'dataSource' in this.state ? this.state.dataSource : undefined,
+                    dataSourceDate: 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined
+                });
+                break;
+            }
+            case 'itemSelected':
+            case 'searching':
+            case 'showingHistory': {
+                this.updateState({
+                    status: 'searching',
+                    inputValue: value,
+                    suggestions: 'suggestions' in this.state ? this.state.suggestions : ('historyItems' in this.state ? this.state.historyItems : []),
+                    validation: 'idle',
+                    validationContext,
+                    dataSource: 'dataSource' in this.state ? this.state.dataSource : undefined,
+                    dataSourceDate: 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined
+                });
+                break;
+            }
+            case 'loading':
+            case 'error':
+                return; // Interaction not allowed or ignored
+            default: {
+                const _exhaustive = this.state;
+                return _exhaustive;
+            }
+        }
+        if (value.length >= this.config.minLength) {
+            this.debounceTimer = setTimeout(() => this.performSearch(value), DEBOUNCE_TIME);
+        }
+    }
+    performSearch(value) {
+        if (!this.searchEngine)
+            return;
+        switch (this.state.status) {
+            case 'searching':
+            case 'multiSelect': {
+                const genericResults = this.searchEngine.searchAsGeneric(value, this.config.maxResults);
+                const results = genericResults.flatMap(g => g.metadata?.originalResult ? [g.metadata.originalResult] : []);
+                // Do not filter out selected items here - allow UI to handle grey-out
+                this.updateState({ ...this.state, suggestions: results });
+                break;
+            }
+            case 'loading':
+            case 'error':
+            case 'itemSelected':
+            case 'showingHistory':
+            case 'multiSelectShowingHistory':
+                return; // Nothing to search from here
+            default: {
+                const _exhaustive = this.state;
+                return _exhaustive;
+            }
+        }
+    }
+    // --- HISTORY HANDLING ---
+    addToHistory(item) {
+        if (!this.config.history)
+            return;
+        // Reload history from cache to ensure we have the latest state from other instances
+        const historyItems = HistoryService.loadHistory();
+        // Clone item and reset highlightedLabel to displayLabel (removes bolding)
+        // AND apply grey styling to parenthesis (via DisplaySegments)
+        const unhighlightedSegments = LabelFormatter.format(item.rawLabel, '', item.occupationLabel);
+        const historyItem = {
+            ...item,
+            displaySegments: unhighlightedSegments,
+            // Legacy support: construct HTML string for fallback
+            highlightedLabel: segmentsToHtml(unhighlightedSegments)
+        };
+        // Filter out existing item with same ID (to move it to top)
+        const filtered = historyItems.filter((h) => {
+            if (h.id && historyItem.id)
+                return h.id !== historyItem.id;
+            return h.rawLabel !== historyItem.rawLabel;
+        });
+        // Add to top and limit
+        const newHistory = [historyItem, ...filtered].slice(0, this.config.maxHistoryItems);
+        HistoryService.saveHistory(newHistory);
+    }
+    clearHistory() {
+        HistoryService.clearHistory();
+        this.showHistory(true);
+    }
+    computePopularItems(data, limit = this.config.maxResults || MAX_RESULTS) {
+        if (!data || data.length === 0)
+            return [];
+        const hasWeights = data.some(t => typeof t.weight === 'number' && t.weight > 0);
+        if (!hasWeights) {
+            return data.slice(0, limit);
+        }
+        const sorted = [...data].sort((a, b) => (b.weight ?? 0) - (a.weight ?? 0));
+        const seen = new Set();
+        const popular = [];
+        for (const item of sorted) {
+            const key = item.occupation_name_preferred_label || item.preferred_label;
+            if (!seen.has(key)) {
+                seen.add(key);
+                popular.push(item);
+            }
+            if (popular.length === limit)
+                break;
+        }
+        return popular;
+    }
+    showHistory(force = false) {
+        if (this.state.status === 'loading' || this.state.status === 'error')
+            return;
+        if (!this.config.history)
+            return;
+        const historyItems = HistoryService.loadHistory();
+        let displayItems = historyItems;
+        let isPopular = false;
+        if (historyItems.length === 0) {
+            if (this.config.popular === false) {
+                displayItems = [];
+            }
+            else {
+                if (this.popularItems.length === 0 && this.taxonomyData.length > 0) {
+                    this.popularItems = this.computePopularItems(this.taxonomyData);
+                }
+                // Provide some popular items if history is empty (and we have taxonomy data)
+                displayItems = this.popularItems.map(t => this.toSearchResult(t));
+                isPopular = true;
+            }
+        }
+        // Lazy Validation: Filter items against current taxonomy and config
+        const validatedHistory = displayItems.filter((item) => {
+            // 1. Check if it's a ManualInput item
+            if (item.type === 'ManualInput') {
+                return !this.config.requireSelection;
+            }
+            // 2. Check if it's a valid Taxonomy item (must exist in current data)
+            // Note: We use this.taxonomyData which is already loaded
+            const exists = this.taxonomyData.some(t => t.id === item.id);
+            return exists;
+        });
+        const filteredHistory = validatedHistory.map((item) => {
+            const unhighlightedSegments = LabelFormatter.format(item.rawLabel, '', item.occupationLabel);
+            return {
+                ...item,
+                displaySegments: unhighlightedSegments,
+                highlightedLabel: segmentsToHtml(unhighlightedSegments)
+            };
+        });
+        const { dataSource, dataSourceDate } = this.getCommonState();
+        const currentInputValue = 'inputValue' in this.state ? this.state.inputValue : '';
+        // If we have input text, we don't want to show history unless explicitly in a history state
+        // OR if we are forcing it (e.g. from editSelection)
+        if (!force && currentInputValue.trim() !== '' && this.state.status !== 'showingHistory' && this.state.status !== 'multiSelectShowingHistory') {
+            return;
+        }
+        if (this.config.enableMultiple) {
+            const selectedItems = 'selectedItems' in this.state ? this.state.selectedItems : [];
+            const wasInError = this.state.validation === 'error' || this.state.validationContext === 'from-error';
+            const validationContext = wasInError ? 'from-error' : undefined;
+            const validation = 'validation' in this.state ? this.state.validation : 'idle';
+            this.updateState({
+                status: 'multiSelectShowingHistory',
+                selectedItems,
+                historyItems: filteredHistory,
+                inputValue: currentInputValue,
+                validation,
+                validationContext,
+                dataSource,
+                dataSourceDate,
+                isPopularView: isPopular // Flag for view
+            });
+        }
+        else {
+            const wasInError = this.state.validation === 'error' || this.state.validationContext === 'from-error';
+            const validationContext = wasInError ? 'from-error' : undefined;
+            const validation = 'validation' in this.state ? this.state.validation : 'idle';
+            this.updateState({
+                status: 'showingHistory',
+                historyItems: filteredHistory,
+                inputValue: currentInputValue,
+                validation,
+                validationContext,
+                dataSource,
+                dataSourceDate,
+                isPopularView: isPopular // Flag for view
+            });
+        }
+    }
+    // --- SELECTION ---
+    selectItem(item) {
+        log.debug('[Controller] selectItem', item);
+        // Add to history
+        this.isTouched = true;
+        this.addToHistory(item);
+        // Standardized Success Message Logic:
+        // Check for error state before update to allow transition to success.
+        // This applies to ALL selection events (Single, Multi, History, Search).
+        const wasInError = this.state.validation === 'error' || this.state.validationContext === 'from-error';
+        const nextValidationContext = wasInError ? 'from-error' : undefined;
+        switch (this.state.status) {
+            case 'multiSelect':
+            case 'multiSelectShowingHistory': {
+                const dataSource = 'dataSource' in this.state ? this.state.dataSource : undefined;
+                const dataSourceDate = 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined;
+                const currentSelected = 'selectedItems' in this.state ? this.state.selectedItems : [];
+                // Prevent duplicates
+                const existingIndex = currentSelected.findIndex(existing => {
+                    if (existing.id && item.id)
+                        return existing.id === item.id;
+                    return existing.rawLabel === item.rawLabel;
+                });
+                if (existingIndex > -1) {
+                    // Already selected - skip to avoid double addition or accidental removal in this context
+                    return;
+                }
+                const newItems = [...currentSelected, item];
+                // Uppdatera state: rensa input och förslag
+                this.updateState({
+                    ...this.state,
+                    status: 'multiSelect',
+                    selectedItems: newItems,
+                    inputValue: '',
+                    suggestions: [],
+                    validation: 'idle',
+                    validationContext: nextValidationContext, // Use centralized context
+                    dataSource,
+                    dataSourceDate
+                });
+                this.callbacks.onEmitSelection(newItems.map(i => this.toPublicSelection(i)));
+                this.showHistory(true);
+                break;
+            }
+            case 'searching':
+            case 'showingHistory': {
+                const dataSource = 'dataSource' in this.state ? this.state.dataSource : undefined;
+                const dataSourceDate = 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined;
+                this.updateState({
+                    status: 'itemSelected',
+                    selectedItem: item,
+                    inputValue: item.preferred_label, // Keep label as text
+                    validation: 'idle',
+                    validationContext: nextValidationContext, // Use centralized context
+                    dataSource,
+                    dataSourceDate,
+                });
+                this.callbacks.onEmitSelection(this.toPublicSelection(item));
+                if (this.config.enableMultiple) {
+                    this.showHistory(true);
+                }
+                break;
+            }
+            case 'loading':
+            case 'error':
+                // Do nothing in these states
+                break;
+            case 'itemSelected': {
+                const dataSource = 'dataSource' in this.state ? this.state.dataSource : undefined;
+                const dataSourceDate = 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined;
+                this.updateState({
+                    ...this.state,
+                    status: 'itemSelected',
+                    selectedItem: item,
+                    inputValue: item.preferred_label,
+                    validation: 'idle',
+                    validationContext: nextValidationContext,
+                    dataSource,
+                    dataSourceDate,
+                });
+                this.callbacks.onEmitSelection(this.toPublicSelection(item));
+                break;
+            }
+            default: {
+                const _exhaustive = this.state;
+                log.warn('[Controller] selectItem - Unexpected state:', _exhaustive);
+            }
+        }
+        this.runValidation();
+    }
+    clearSelection() {
+        if (this.state.status !== 'itemSelected')
+            return;
+        this.isTouched = true;
+        const currentInputValue = this.state.inputValue || '';
+        this.updateState({
+            status: 'searching',
+            inputValue: currentInputValue,
+            suggestions: [],
+            validation: 'idle',
+            ...this.getCommonState()
+        });
+        this.callbacks.onEmitSelection([]); // Empty array instead of null
+        // Try to show history if enabled
+        this.showHistory();
+        this.runValidation();
+    }
+    removeItem(item) {
+        switch (this.state.status) {
+            case 'multiSelect':
+            case 'multiSelectShowingHistory': {
+                const newItems = this.state.selectedItems.filter(i => {
+                    if (i.id && item.id)
+                        return i.id !== item.id;
+                    return i.rawLabel !== item.rawLabel;
+                });
+                this.isTouched = true;
+                this.updateState({ ...this.state, selectedItems: newItems });
+                this.callbacks.onEmitSelection(newItems.map(i => this.toPublicSelection(i)));
+                // Try to show history if enabled (since we are likely still focused)
+                const inputValue = 'inputValue' in this.state ? this.state.inputValue : '';
+                if (inputValue === '') {
+                    this.showHistory();
+                }
+                this.runValidation();
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // --- BLUR & VALIDATION ---
+    handleBlur() {
+        this.isTouched = true;
+        if (this.state.status === 'searching') {
+            const trimmedValue = (this.state.inputValue || '').trim();
+            if (trimmedValue !== '') {
+                const exactMatch = this.findExactMatch(trimmedValue);
+                if (exactMatch) {
+                    this.selectItem(this.toSearchResult(exactMatch));
+                    return;
+                }
+            }
+        }
+        // In TEA/FSM, handleBlur should focus on state transitions and validation,
+        // rather than side-effects like clearing UI data.
+        // We transition back to primary states (searching/multiSelect) but KEEP suggestions.
+        switch (this.state.status) {
+            case 'searching':
+            case 'showingHistory':
+                this.updateState({
+                    ...this.state,
+                    status: 'searching',
+                    inputValue: 'inputValue' in this.state ? this.state.inputValue : '',
+                    suggestions: []
+                });
+                break;
+            case 'multiSelect':
+            case 'multiSelectShowingHistory': {
+                this.updateState({
+                    ...this.state,
+                    status: 'multiSelect',
+                    inputValue: 'inputValue' in this.state ? this.state.inputValue : '',
+                    suggestions: []
+                });
+                break;
+            }
+            case 'loading':
+            case 'error':
+            case 'itemSelected':
+                break;
+            default: {
+                const _exhaustive = this.state;
+                return _exhaustive;
+            }
+        }
+        this.runValidation();
+    }
+    /**
+     * Validerar nuvarande värde och sätter eventuella valideringsfel.
+     * @param forceTouch - Tvingar valideringen att köras (och därmed visa fel) även om fältet inte tidigare blivit rört (touched). Default är false.
+     */
+    runValidation(forceTouch = false) {
+        if (forceTouch) {
+            this.isTouched = true;
+        }
+        if (!this.isTouched)
+            return true;
+        if (this.state.status === 'loading' || this.state.status === 'error')
+            return true;
+        const hasValue = this.checkHasValue();
+        let isValid = true;
+        let newErrorType = null;
+        // Check for invalid input (text that doesn't match a selection)
+        // This applies in both single 'searching' mode and 'multiSelect' mode
+        const isSearchingOrMulti = this.state.status === 'searching' || this.state.status === 'multiSelect' || this.state.status === 'multiSelectShowingHistory';
+        const inputValue = 'inputValue' in this.state ? this.state.inputValue : '';
+        const hasInputText = inputValue.trim() !== '';
+        if (isSearchingOrMulti && hasInputText) {
+            // New rule: If there is text in the box that isn't confirmed as a selection, it's ALWAYS an error
+            // regardless of whether manual input is enabled or not.
+            // The user MUST confirm by selecting the manual input option.
+            isValid = false;
+            newErrorType = 'invalidInput';
+        }
+        else if (this.config.required && !hasValue) {
+            isValid = false;
+            newErrorType = 'required';
+        }
+        this.activeErrorType = newErrorType;
+        // Strict FSM for validation state
+        // Rules:
+        // 1. Error only if invalid.
+        // 2. Idle if valid (never use success to avoid aggressive green checks).
+        // Valid state: only show success if recovering from an error (Red -> Green pattern) AND we actually have a value.
+        const wasInError = this.state.validation === 'error' || this.state.validationContext === 'from-error';
+        let validationState;
+        if (!isValid) {
+            validationState = newErrorType === 'invalidInput' || forceTouch || wasInError ? 'error' : 'idle';
+        }
+        else if (wasInError && hasValue) {
+            validationState = 'success';
+        }
+        else {
+            validationState = 'idle';
+        }
+        if (validationState === 'success') {
+            clearTimeout(this.validationTimer);
+            this.validationTimer = setTimeout(() => {
+                // Only clear if still success (user hasn't messed up again)
+                const isSuccess = 'validation' in this.state && this.state.validation === 'success';
+                const allowedStatus = ['itemSelected', 'multiSelect', 'multiSelectShowingHistory'].includes(this.state.status);
+                if (allowedStatus && isSuccess) {
+                    this.updateState({ ...this.state, validation: 'idle', validationContext: undefined });
+                }
+                this.validationTimer = undefined;
+            }, 3000);
+        }
+        // Update state based on current status (respecting type definitions)
+        switch (this.state.status) {
+            case 'searching':
+                this.updateState({ ...this.state, validation: validationState });
+                break;
+            case 'showingHistory':
+                this.updateState({ ...this.state, validation: validationState });
+                break;
+            case 'multiSelect':
+                // Allow error AND success states for multiSelect
+                this.updateState({ ...this.state, validation: validationState });
+                break;
+            case 'multiSelectShowingHistory':
+                this.updateState({ ...this.state, validation: validationState });
+                break;
+            case 'itemSelected':
+                // ItemSelected does not support 'error'. But checkHasValue() returns true, so isValid is true.
+                if (validationState !== 'error') {
+                    this.updateState({ ...this.state, validation: validationState });
+                }
+                break;
+            default: {
+                // If we reach here, we must have handled all states that aren't 'loading' or 'error'
+                // But TypeScript needs to know that.
+                const _exhaustive = this.state;
+                return _exhaustive;
+            }
+        }
+        this.callbacks.onEmitValidation({ isValid, errorType: newErrorType });
+        return isValid;
+    }
+    selectItemById(id) {
+        if (!id || this.config.enableMultiple || !this.taxonomyData)
+            return;
+        const itemToSelect = this.taxonomyData.find(t => t.id === id);
+        if (itemToSelect) {
+            const searchResult = this.toSearchResult(itemToSelect);
+            const dataSource = 'dataSource' in this.state ? this.state.dataSource : undefined;
+            const dataSourceDate = 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined;
+            this.updateState({
+                status: 'itemSelected',
+                selectedItem: searchResult,
+                inputValue: searchResult.preferred_label,
+                validation: 'idle',
+                dataSource,
+                dataSourceDate,
+            });
+        }
+        this.runValidation();
+    }
+    selectItemsByIds(ids) {
+        if (!ids || !this.config.enableMultiple || !this.taxonomyData)
+            return;
+        const taxonomyItems = ids.map(id => this.taxonomyData.find(item => item.id === id));
+        if (taxonomyItems.some((item) => !item))
+            return;
+        const newSelectedItems = taxonomyItems
+            .filter((item) => !!item)
+            .map(item => this.toSearchResult(item));
+        switch (this.state.status) {
+            case 'multiSelect':
+            case 'multiSelectShowingHistory':
+                this.updateState({
+                    ...this.state,
+                    selectedItems: newSelectedItems
+                });
+                break;
+            default:
+                break;
+        }
+        this.runValidation();
+    }
+    setSelection(selection) {
+        const invalidIds = [];
+        const selectedItems = selection.map((item) => {
+            if (item.id !== null) {
+                const taxonomyItem = this.taxonomyData.find((taxonomy) => taxonomy.id === item.id);
+                if (!taxonomyItem) {
+                    invalidIds.push(item.id);
+                    return undefined;
+                }
+                return this.toSearchResult(taxonomyItem);
+            }
+            return this.createManualInputItem(item.preferred_label);
+        });
+        if (invalidIds.length > 0) {
+            return { ok: false, invalidIds };
+        }
+        const resolvedItems = selectedItems;
+        const commonState = this.getCommonState();
+        if (this.config.enableMultiple) {
+            this.updateState({
+                ...this.state,
+                status: 'multiSelect',
+                selectedItems: resolvedItems,
+                inputValue: '',
+                suggestions: [],
+                validation: 'idle',
+                ...commonState
+            });
+        }
+        else if (resolvedItems.length === 1) {
+            const selectedItem = resolvedItems[0];
+            this.updateState({
+                status: 'itemSelected',
+                selectedItem,
+                inputValue: selectedItem.preferred_label,
+                validation: 'idle',
+                ...commonState
+            });
+        }
+        else {
+            this.updateState({
+                status: 'searching',
+                inputValue: '',
+                suggestions: [],
+                validation: 'idle',
+                ...commonState
+            });
+        }
+        this.runValidation();
+        return { ok: true, selection: resolvedItems.map((item) => this.toPublicSelection(item)) };
+    }
+    editSelection() {
+        const selectedItem = this.state.selectedItem;
+        if (this.state.status !== 'itemSelected' || !selectedItem || !this.searchEngine)
+            return;
+        // Transition to searching first to ensure input shows up
+        const professionLabel = selectedItem.displayLabel;
+        const { dataSource, dataSourceDate } = this.state;
+        // Rule: On activation, show search results for the current string instead of history
+        const genericResults = this.searchEngine.searchAsGeneric(professionLabel, this.config.maxResults);
+        const searchResults = genericResults.flatMap(g => g.metadata?.originalResult ? [g.metadata.originalResult] : []);
+        this.updateState({
+            status: 'searching',
+            inputValue: professionLabel,
+            suggestions: searchResults,
+            validation: 'idle',
+            dataSource,
+            dataSourceDate
+        });
+    }
+    checkHasValue() {
+        switch (this.state.status) {
+            case 'itemSelected':
+                return true;
+            case 'multiSelect':
+            case 'multiSelectShowingHistory':
+                return this.state.selectedItems.length > 0;
+            case 'searching':
+            case 'showingHistory': {
+                const inputValue = 'inputValue' in this.state ? this.state.inputValue : '';
+                return !this.config.requireSelection && inputValue.trim() !== '';
+            }
+            case 'loading':
+            case 'error':
+                return false;
+            default: {
+                const _exhaustive = this.state;
+                return _exhaustive;
+            }
+        }
+    }
+    getCommonState() {
+        return {
+            dataSource: 'dataSource' in this.state ? this.state.dataSource : undefined,
+            dataSourceDate: 'dataSourceDate' in this.state ? this.state.dataSourceDate : undefined
+        };
+    }
+    resetMultiSelection() {
+        const commonState = this.getCommonState();
+        this.updateState({
+            ...this.state,
+            status: 'multiSelect',
+            selectedItems: [],
+            inputValue: '',
+            suggestions: [],
+            validation: 'idle',
+            ...commonState
+        });
+        this.callbacks.onEmitSelection([]);
+    }
+    // --- HELPERS ---
+    updateState(newState) {
+        this.state = newState;
+        this.callbacks.onStateChange(newState);
+    }
+    toSearchResult(item) {
+        return {
+            ...item,
+            rawLabel: item.preferred_label,
+            displayLabel: item.occupation_name_preferred_label
+                ? `${item.preferred_label} (${item.occupation_name_preferred_label})`
+                : item.preferred_label,
+            highlightedLabel: item.preferred_label,
+            score: 3.0,
+            // Map v2 fields to match SearchResult interface expectations if needed
+            occupationLabel: item.occupation_name_preferred_label,
+            occupationId: item.occupation_name_id,
+            ssyk_level_4_id: item.ssyk_level_4_id,
+            ssyk_code_2012: item.ssyk_code_2012
+        };
+    }
+    toPublicSelection(item) {
+        return TaxonomyAdapter.toPublicSelection(item);
+    }
+    createManualInputItem(value) {
+        return {
+            id: '',
+            type: 'ManualInput',
+            preferred_label: value,
+            rawLabel: value,
+            displayLabel: value,
+            highlightedLabel: value,
+            score: 1.0
+        };
+    }
+    findExactMatch(value) {
+        return this.taxonomyData.find(item => {
+            const displayLabel = item.occupation_name_preferred_label
+                ? `${item.preferred_label} (${item.occupation_name_preferred_label})`
+                : item.preferred_label;
+            return displayLabel.toLowerCase() === value.toLowerCase() || item.preferred_label.toLowerCase() === value.toLowerCase();
+        });
+    }
+    // --- FREETEXT HANDLING (used by keyboard handler) ---
+    handleFreeTextSelection(value) {
+        if (!value)
+            return;
+        this.isTouched = true;
+        const exactMatch = this.findExactMatch(value);
+        if (exactMatch) {
+            this.selectItem(this.toSearchResult(exactMatch));
+        }
+        else {
+            this.selectItem(this.createManualInputItem(value));
+        }
+    }
+    loadMore() {
+        // Increment maxResults or handle paging if supported by searchEngine
+        this.config.maxResults += 10;
+        const inputValue = 'inputValue' in this.state ? this.state.inputValue : '';
+        if (inputValue) {
+            this.performSearch(inputValue);
+        }
+    }
+    resetSearch() {
+        switch (this.state.status) {
+            case 'searching':
+            case 'multiSelect':
+                this.updateState({ ...this.state, inputValue: '', suggestions: [] });
+                this.showHistory(true);
+                break;
+            case 'showingHistory':
+            case 'multiSelectShowingHistory':
+                // Already showing history, just ensure input is empty
+                this.updateState({ ...this.state, inputValue: '' });
+                break;
+            case 'itemSelected':
+                this.clearSelection();
+                break;
+            default:
+                break;
+        }
+    }
+}