@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/types/components/job-selector/job-selector-controller.d.ts

@@ -0,0 +1,82 @@
+import { ComponentState, TaxonomyItem, SearchResult, JobSelectionItem, JobSelectionReference } from './types';
+export interface ControllerCallbacks {
+    onStateChange: (state: ComponentState) => void;
+    onEmitSelection: (selection: JobSelectionItem | JobSelectionItem[]) => void;
+    onEmitValidation: (payload: {
+        isValid: boolean;
+        errorType: 'required' | 'invalidInput' | null;
+    }) => void;
+    onEmitDataLoadFailed: (error: Error) => void;
+    onEmitStatusChange: (payload: {
+        status: string;
+        message: string;
+    }) => void;
+}
+export interface ControllerConfig {
+    enableMultiple: boolean;
+    required: boolean;
+    requireSelection: boolean;
+    history: boolean;
+    maxHistoryItems: number;
+    minLength: number;
+    maxResults: number;
+    popular?: boolean;
+}
+export type SetSelectionResult = {
+    ok: true;
+    selection: JobSelectionItem[];
+} | {
+    ok: false;
+    invalidIds: string[];
+};
+export declare class JobSelectorController {
+    private callbacks;
+    private config;
+    private state;
+    private taxonomyData;
+    private popularItems;
+    private searchEngine;
+    private debounceTimer?;
+    private validationTimer?;
+    private isTouched;
+    private activeErrorType;
+    constructor(callbacks: ControllerCallbacks, config: ControllerConfig);
+    getState(): ComponentState;
+    getActiveErrorType(): 'required' | 'invalidInput' | null;
+    updateConfig(newConfig: Partial<ControllerConfig>): void;
+    getTaxonomyData(): TaxonomyItem[];
+    destroy(): void;
+    initialize(initialData?: TaxonomyItem[]): Promise<void>;
+    handleFocus(): void;
+    private setStateToActive;
+    handleInput(value: string): void;
+    private performSearch;
+    addToHistory(item: SearchResult): void;
+    clearHistory(): void;
+    private computePopularItems;
+    showHistory(force?: boolean): void;
+    selectItem(item: SearchResult): void;
+    clearSelection(): void;
+    removeItem(item: SearchResult): void;
+    handleBlur(): void;
+    /**
+     * 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?: boolean): boolean;
+    selectItemById(id: string): void;
+    selectItemsByIds(ids?: string[]): void;
+    setSelection(selection: JobSelectionReference[]): SetSelectionResult;
+    editSelection(): void;
+    private checkHasValue;
+    private getCommonState;
+    resetMultiSelection(): void;
+    private updateState;
+    private toSearchResult;
+    toPublicSelection(item: SearchResult): JobSelectionItem;
+    private createManualInputItem;
+    private findExactMatch;
+    handleFreeTextSelection(value: string): void;
+    loadMore(): void;
+    resetSearch(): void;
+}

package/dist/types/components/job-selector/job-selector.d.ts

@@ -0,0 +1,140 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ComponentState, TaxonomyItem, JobSelectionItem, JobSelectionInput, JobSelectorMetadata } from './types';
+import { GenericItem } from '../core-selector/types';
+export declare class JobSelector {
+    hostElement: HTMLElement;
+    internals: ElementInternals;
+    /**
+     * HTML-formulärets fältnamn. Följer standardattributet `name`, på samma sätt som
+     * `<input name="...">`, och används som nyckel när värdet läses via `FormData`.
+     */
+    name: string;
+    /**
+     * Fullständig, explicit URL till en egenhostad datafil.
+     * Utelämna attributet för att använda senaste data automatiskt.
+     */
+    taxonomyUrl?: string;
+    placeholder: string;
+    label: string;
+    /** Om satt till true kan väljaren inte användas med mus eller tangentbord. */
+    disabled: boolean;
+    enableMultiple: boolean;
+    showSearchIcon: boolean;
+    errorMessage?: string;
+    labelDescription?: string;
+    /** Om satt till `true` måste fältet ha ett värde för att vara giltigt. */
+    required: boolean;
+    /** Om satt till `true` tillåts fritext som inte finns i taxonomin. */
+    manualInput: boolean;
+    /**
+     * Aktiverar historiken.
+     * Använder Local Storage för att spara valda yrken i webbläsaren.
+     * Integritet: Data lagras bara lokalt i webbläsaren.
+     * Räckvidd: Historiken delas mellan sidor på samma domän.
+     */
+    history: boolean;
+    /**
+     * Om satt till true visas populära yrken initialt när historiken är tom.
+     */
+    popular: boolean;
+    private maxHistoryItems;
+    private enableSelectionAnimation;
+    private afFocused;
+    private populateInputOnSelect;
+    private maxVisibleRows?;
+    private minLength;
+    private maxResults;
+    private get requireSelection();
+    /**
+     * Storleken på inputfältet.
+     * 'small' | 'medium' | 'large'
+     */
+    size: 'small' | 'medium' | 'large';
+    constructor();
+    state: ComponentState;
+    /**
+     * Spårar vilken typ av fel som är aktivt,
+     * för att kunna visa rätt meddelande.
+     */
+    private activeErrorType;
+    private animatingItemId;
+    private animationTimer?;
+    private cloneSelection;
+    private rebuildValidJobIds;
+    private validateSelectionCandidate;
+    private describeSelectionRejection;
+    private errorCodeForRejection;
+    private rejectSelection;
+    private syncAcceptedSelection;
+    private applySelection;
+    watchRequired(newValue: boolean): void;
+    watchManualInput(newValue: boolean): void;
+    watchHistory(newValue: boolean): void;
+    watchPopular(newValue: boolean): void;
+    watchEnableMultiple(newValue: boolean): void;
+    watchDisabled(newValue: boolean): void;
+    watchTaxonomyData(newValue: TaxonomyItem[]): void;
+    /**
+     * Yrkesdata (taxonomi). Kan injiceras av integratören för deterministisk laddning (t.ex. i testmiljöer).
+     * Om den lämnas tom populeras den internt via det globala registret eller auto-fetch för att exponera aktuell data.
+     */
+    taxonomyData: TaxonomyItem[];
+    afJobSelectedEmitter: EventEmitter<JobSelectionItem[]>;
+    private syncFormValue;
+    handleFormValidationSync(event: CustomEvent<{
+        isValid: boolean;
+        errorType: 'required' | 'invalidInput' | null;
+    }>): void;
+    dataLoadFailedEmitter: EventEmitter<{
+        error: Error;
+    }>;
+    validationChangeEmitter: EventEmitter<{
+        isValid: boolean;
+        errorType: 'required' | 'invalidInput' | null;
+    }>;
+    static nextId: number;
+    private readonly componentId;
+    private observer;
+    private controller;
+    private validJobIds;
+    private lastAcceptedSelection;
+    private restoreAcceptedSelectionAfterDataUpdate;
+    componentWillLoad(): Promise<void>;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    handleHashFocus(): void;
+    handleInput(event: CustomEvent<string>): void;
+    handleCsSelect(event: CustomEvent<GenericItem<JobSelectorMetadata>>): void;
+    handleCsClear(): void;
+    handleCsClearHistory(): void;
+    handleCsRequestHistory(): void;
+    handleCsLoadMore(): void;
+    handleCsRemoveItem(event: CustomEvent<GenericItem<JobSelectorMetadata>>): void;
+    handleCsFocus(): void;
+    handleCsBlur(): void;
+    handleCsEditSelection(): void;
+    /**
+     * Uppdaterar taxonomidatan genom att läsa om från registret.
+     * Används efter att registerTaxonomy() har anropats med ny data.
+     */
+    updateData(): Promise<void>;
+    /**
+     * Sätter ett programatiskt val och returnerar YV:s normaliserade, rika selection.
+     * Strängar som matchar Concept ID-formatet tolkas som taxonomi-id:n; övriga som fritext.
+     */
+    setSelection(input: JobSelectionInput): Promise<JobSelectionItem[]>;
+    setFocus(): Promise<void>;
+    /**
+     * Validerar komponenten manuellt.
+     * @param forceTouch - Om true, tvingas valideringsfel att visas även om användaren inte interagerat med fältet.
+     */
+    validate(forceTouch?: boolean): Promise<boolean>;
+    checkValidity(): Promise<boolean>;
+    reportValidity(): Promise<boolean>;
+    getValidity(): Promise<ValidityState>;
+    getValidationMessage(): Promise<string>;
+    private updateValidity;
+    private _mapSearchResultToGenericItem;
+    private _mapStateToSelectorState;
+    render(): any;
+}

package/dist/types/components/job-selector/keyboard-handlers.d.ts

@@ -0,0 +1,13 @@
+import { ComponentState, SearchResult } from './types';
+export interface KeyboardNavigationContext {
+    state: ComponentState;
+    requireSelection: boolean;
+    activeIndex: number;
+    listId: string;
+    listRef: HTMLDivElement;
+    onNavigate: (newIndex: number) => void;
+    onSelect: (item: SearchResult) => void;
+    onClearSuggestions: () => void;
+    onEnterWithoutSelection: (value: string) => void;
+}
+export declare function handleKeyboardNavigation(event: KeyboardEvent, context: KeyboardNavigationContext): void;

package/dist/types/components/job-selector/logic/adapter.utils.d.ts

@@ -0,0 +1,12 @@
+import { GenericItem } from '../../core-selector/types';
+import { TaxonomyItem, SearchResult, JobSelectionItem, JobSelectorMetadata } from '../types';
+export declare const TaxonomyAdapter: {
+    /** Maps a raw TaxonomyItem to a GenericItem for the CoreSelector */
+    toGenericItem(item: TaxonomyItem): GenericItem<JobSelectorMetadata>;
+    /** Maps a SearchResult (from our engine) to a GenericItem */
+    searchResultToGenericItem(result: SearchResult, query: string): GenericItem<JobSelectorMetadata>;
+    /** Maps a GenericItem back to our internal SearchResult format */
+    fromGenericItem(item: GenericItem<JobSelectorMetadata>): Partial<SearchResult>;
+    /** Maps an internal item to the public event format */
+    toPublicSelection(item: SearchResult | Partial<SearchResult>): JobSelectionItem;
+};

package/dist/types/components/job-selector/logic/label-formatter.d.ts

@@ -0,0 +1,4 @@
+import { TextSegment } from '../../core-selector/types';
+export declare const LabelFormatter: {
+    format: (label: string, query: string, occupationLabel?: string) => TextSegment[];
+};

package/dist/types/components/job-selector/logic/search.engine.d.ts

@@ -0,0 +1,21 @@
+import { TaxonomyItem, JobSelectionItem, JobSelectorMetadata } from '../types';
+import { GenericItem } from '../../core-selector/types';
+export interface IPublicSearchEngine {
+    search(query: string, maxResults?: number): JobSelectionItem[];
+}
+export declare class TaxonomySearchEngine implements IPublicSearchEngine {
+    private fuseInstance;
+    private items;
+    constructor(data: TaxonomyItem[]);
+    /**
+     * Public API: Performs a search and returns clean, official domain objects.
+     * This is what external consumers (headless) should use.
+     */
+    search(query: string, maxResults?: number): JobSelectionItem[];
+    /**
+     * Internal API: Performs a search and returns GenericItems for the CoreSelector UI ("Bucky").
+     * Includes highlighting, grouping and internal metadata.
+     */
+    searchAsGeneric(query: string, maxResults?: number): GenericItem<JobSelectorMetadata>[];
+    updateData(newData: TaxonomyItem[]): void;
+}

package/dist/types/components/job-selector/search-logic.d.ts

@@ -0,0 +1,17 @@
+import { SearchResult } from './types';
+/**
+ * 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 declare function shouldShowManualInputOption(suggestions: SearchResult[], inputValue: string, requireSelection: boolean): boolean;

package/dist/types/components/job-selector/search.utils.d.ts

@@ -0,0 +1,10 @@
+import Fuse from 'fuse.js';
+import { TaxonomyItem, SearchResult } from './types';
+import { FormattedText } from '../core-selector/types';
+export declare const normalizeForComparison: (text: string | undefined | null) => string;
+export declare function formatDisplayLabel(item: TaxonomyItem): string;
+export declare function getLabel(item: TaxonomyItem): string;
+export declare function sortResultsStrict(results: SearchResult[]): SearchResult[];
+export declare function segmentsToHtml(segments: FormattedText): string;
+export declare const styleParentheticalText: (text: string | undefined | null) => string;
+export declare function searchConcepts(query: string, items: TaxonomyItem[], fuseInstance: Fuse<TaxonomyItem>, maxResults: number): SearchResult[];

package/dist/types/components/job-selector/suggestions-list.d.ts

@@ -0,0 +1,13 @@
+import { SearchResult } from './types';
+interface SuggestionsListProps {
+    suggestions: SearchResult[];
+    inputValue: string;
+    activeIndex: number;
+    listId: string;
+    requireSelection: boolean;
+    onSelect: (item: SearchResult) => void;
+    onMouseEnter: (index: number) => void;
+    setListRef: (el: HTMLDivElement | undefined) => void;
+}
+export declare const SuggestionsList: (props: SuggestionsListProps) => any;
+export {};

package/dist/types/components/job-selector/taxonomy-registry.d.ts

@@ -0,0 +1,20 @@
+import { TaxonomyItem } from './types';
+interface TaxonomyRegistration {
+    data: TaxonomyItem[];
+    metadata?: {
+        labour_market_taxonomy_version?: unknown;
+    };
+    taxonomyVersion?: unknown;
+}
+export declare function isTaxonomyItem(value: unknown): value is TaxonomyItem;
+export declare function isTaxonomyRegistration(value: unknown): value is TaxonomyRegistration;
+/**
+ * Registrerar validerad taxonomidata för webbkomponenten.
+ * Ogiltig data ersätter aldrig en tidigare giltig registrering.
+ */
+export declare function registerTaxonomy(data: unknown): void;
+/** Hämtar den registrerade taxonomin. */
+export declare function getRegisteredTaxonomy(): TaxonomyItem[];
+/** Endast för testning: återställer registret. */
+export declare function __resetRegistry(): void;
+export {};

package/dist/types/components/job-selector/test-data.mock.d.ts

@@ -0,0 +1,7 @@
+import { TaxonomyItem } from './types';
+/**
+ * En kontrollerad och statisk datamängd för enhetstester.
+ * Denna data är designad för att testa specifika logikregler
+ * och ska inte ändras om inte logiken den testar ändras.
+ */
+export declare const mockSearchTestData: TaxonomyItem[];

package/dist/types/components/job-selector/types.d.ts

@@ -0,0 +1,107 @@
+import type { FormattedText } from '../core-selector/types';
+export type ComponentStatus = 'loading' | 'error' | 'searching' | 'showingHistory' | 'itemSelected' | 'multiSelect' | 'multiSelectShowingHistory';
+export type ValidationStatus = 'idle' | 'error' | 'success';
+export interface BaseState {
+    status: ComponentStatus;
+    dataSource?: 'registry' | 'api';
+    dataSourceDate?: string;
+    validation?: ValidationStatus;
+    validationContext?: 'from-error';
+    isPopularView?: boolean;
+}
+export interface LoadingState extends BaseState {
+    status: 'loading';
+}
+export interface ErrorState extends BaseState {
+    status: 'error';
+    message: string;
+}
+export interface SearchingState extends BaseState {
+    status: 'searching';
+    inputValue: string;
+    suggestions: SearchResult[];
+}
+export interface ShowingHistoryState extends BaseState {
+    status: 'showingHistory';
+    inputValue: string;
+    historyItems: SearchResult[];
+    validation: ValidationStatus;
+}
+export interface ItemSelectedState extends BaseState {
+    status: 'itemSelected';
+    selectedItem: SearchResult;
+    inputValue: string;
+}
+export interface MultiSelectState extends BaseState {
+    status: 'multiSelect';
+    inputValue: string;
+    selectedItems: SearchResult[];
+    suggestions: SearchResult[];
+}
+export interface MultiSelectShowingHistoryState extends BaseState {
+    status: 'multiSelectShowingHistory';
+    inputValue: string;
+    selectedItems: SearchResult[];
+    historyItems: SearchResult[];
+}
+export type ComponentState = LoadingState | ErrorState | SearchingState | ShowingHistoryState | ItemSelectedState | MultiSelectState | MultiSelectShowingHistoryState;
+export interface TaxonomyItem {
+    id: string;
+    type: 'job-title' | 'occupation-name';
+    preferred_label: string;
+    ssyk_level_4_id?: string;
+    ssyk_code_2012?: string;
+    occupation_name_id?: string;
+    occupation_name_preferred_label?: string;
+    weight?: number;
+}
+export interface SearchResult extends Omit<TaxonomyItem, 'type'> {
+    type: TaxonomyItem['type'] | 'ManualInput' | 'unknown';
+    rawLabel: string;
+    displayLabel: string;
+    highlightedLabel: string;
+    score: number;
+    displaySegments?: FormattedText;
+    occupationLabel?: string;
+    occupationId?: string;
+    isSelected?: boolean;
+    weight?: number;
+}
+export interface JobSelectorMetadata {
+    original?: SearchResult | TaxonomyItem;
+    originalResult?: SearchResult;
+    type?: string;
+    weight?: number;
+    [key: string]: unknown;
+}
+export interface RawTaxonomyDataResponse {
+    concepts: TaxonomyItem[];
+}
+export interface OccupationNameSelectionItem {
+    type: 'occupation-name';
+    id: string;
+    preferred_label: string;
+}
+export type JobSelectionItem = {
+    type: 'job-title' | 'occupation-name';
+    id: string;
+    preferred_label: string;
+    ssyk_code_2012?: string;
+    related?: OccupationNameSelectionItem;
+} | {
+    type: 'manual-input';
+    id: null;
+    preferred_label: string;
+};
+export type JobSelectionReference = {
+    id: string;
+} | Extract<JobSelectionItem, {
+    type: 'manual-input';
+}>;
+export type JobSelectionInput = string | string[] | JobSelectionItem[];
+export type InvalidSelectionErrorCode = 'unknown-id' | 'invalid-input' | 'manual-input-disabled' | 'multiple-disabled';
+export declare class InvalidSelectionError extends Error {
+    readonly code: InvalidSelectionErrorCode;
+    readonly invalidIds?: string[];
+    constructor(message: string, code: InvalidSelectionErrorCode, invalidIds?: string[]);
+}

package/dist/types/components/job-selector/validation-message.d.ts

@@ -0,0 +1,8 @@
+interface ValidationMessageProps {
+    validation: 'idle' | 'error' | 'success';
+    activeErrorType: 'required' | 'invalidInput' | null;
+    errorMessage?: string;
+    errorMessageId: string;
+}
+export declare const ValidationMessage: (props: ValidationMessageProps) => any;
+export {};

package/dist/types/components/job-selector-demo/job-selector-demo.d.ts

@@ -0,0 +1,55 @@
+export declare class YrkesvaljarenDemo {
+    el: HTMLElement;
+    variant: 'single' | 'multi';
+    version: string;
+    required: boolean;
+    allowFreeText: boolean;
+    history: boolean;
+    size: 'small' | 'medium' | 'large';
+    framework: 'html' | 'angular' | 'react';
+    codeInstallationMode: 'latest' | 'versioned';
+    afHideHeader: boolean;
+    afHidePreamble: boolean;
+    lastSingleSelection: string;
+    lastMultiSelection: string;
+    implementationCode: string;
+    readmeMainContent: string;
+    readmeCodeContent: any[];
+    availableYvVersions: string[];
+    latestYvDataVersion: string;
+    latestVersion: string;
+    latestDate: string;
+    latestType: string;
+    latestChanges: string;
+    isTaxonomyLoading: boolean;
+    private singleBox;
+    private multiBox;
+    private latestYvDataUrl;
+    componentWillLoad(): Promise<void>;
+    loadDataPackageManifest(): Promise<void>;
+    getTaxonomyUrls(): string[];
+    fetchFirstOk(urls: string[]): Promise<Response>;
+    getExampleDataPackageName(): string;
+    refreshTaxonomy(): Promise<void>;
+    loadChangelog(): Promise<void>;
+    componentDidLoad(): void;
+    componentDidUpdate(): void;
+    triggerHighlight(): void;
+    handleSelection(event: CustomEvent): void;
+    loadMarkdown(): Promise<void>;
+    updateCodeBlock(): void;
+    handleVariantChange(e: any): void;
+    handleVersionChange(e: any): Promise<void>;
+    handleRequiredChange(e: any): void;
+    handleFreeTextChange(e: any): void;
+    handleHistoryChange(e: any): void;
+    handleSizeChange(e: any): void;
+    handleFrameworkChange(e: any): void;
+    handleCodeInstallationModeChange(e: any): void;
+    handleCopyCode(): void;
+    render(): any;
+    getInstallationCommandPart1(): string;
+    getInstallationCommandPart2(): string;
+    getSetupCommand(): string;
+    getUsageCommand(): string;
+}

package/dist/types/components/neobrutal-search/neobrutal-search.d.ts

@@ -0,0 +1,18 @@
+import { TaxonomySearchEngine } from '../job-selector/logic/search.engine';
+export declare class NeobrutalSearch {
+    el: HTMLElement;
+    engine: TaxonomySearchEngine | null;
+    results: any[];
+    inputValue: string;
+    isLoading: boolean;
+    error: string;
+    selectedItem: any | null;
+    isFlipped: boolean;
+    componentWillLoad(): Promise<void>;
+    componentDidUpdate(): void;
+    highlightCode(): void;
+    handleInput(event: Event): void;
+    handleSelect(item: any): void;
+    toggleFlip(): void;
+    render(): any;
+}