@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/esm/taxonomy-registry-Dw0VR9Aw.js

@@ -0,0 +1,430 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var loglevel$1 = {exports: {}};
+
+/*
+* loglevel - https://github.com/pimterry/loglevel
+*
+* Copyright (c) 2013 Tim Perry
+* Licensed under the MIT license.
+*/
+var loglevel = loglevel$1.exports;
+
+var hasRequiredLoglevel;
+
+function requireLoglevel () {
+	if (hasRequiredLoglevel) return loglevel$1.exports;
+	hasRequiredLoglevel = 1;
+	(function (module) {
+		(function (root, definition) {
+		    if (module.exports) {
+		        module.exports = definition();
+		    } else {
+		        root.log = definition();
+		    }
+		}(loglevel, function () {
+
+		    // Slightly dubious tricks to cut down minimized file size
+		    var noop = function() {};
+		    var undefinedType = "undefined";
+		    var isIE = (typeof window !== undefinedType) && (typeof window.navigator !== undefinedType) && (
+		        /Trident\/|MSIE /.test(window.navigator.userAgent)
+		    );
+
+		    var logMethods = [
+		        "trace",
+		        "debug",
+		        "info",
+		        "warn",
+		        "error"
+		    ];
+
+		    var _loggersByName = {};
+		    var defaultLogger = null;
+
+		    // Cross-browser bind equivalent that works at least back to IE6
+		    function bindMethod(obj, methodName) {
+		        var method = obj[methodName];
+		        if (typeof method.bind === 'function') {
+		            return method.bind(obj);
+		        } else {
+		            try {
+		                return Function.prototype.bind.call(method, obj);
+		            } catch (e) {
+		                // Missing bind shim or IE8 + Modernizr, fallback to wrapping
+		                return function() {
+		                    return Function.prototype.apply.apply(method, [obj, arguments]);
+		                };
+		            }
+		        }
+		    }
+
+		    // Trace() doesn't print the message in IE, so for that case we need to wrap it
+		    function traceForIE() {
+		        if (console.log) {
+		            if (console.log.apply) {
+		                console.log.apply(console, arguments);
+		            } else {
+		                // In old IE, native console methods themselves don't have apply().
+		                Function.prototype.apply.apply(console.log, [console, arguments]);
+		            }
+		        }
+		        if (console.trace) console.trace();
+		    }
+
+		    // Build the best logging method possible for this env
+		    // Wherever possible we want to bind, not wrap, to preserve stack traces
+		    function realMethod(methodName) {
+		        if (methodName === 'debug') {
+		            methodName = 'log';
+		        }
+
+		        if (typeof console === undefinedType) {
+		            return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
+		        } else if (methodName === 'trace' && isIE) {
+		            return traceForIE;
+		        } else if (console[methodName] !== undefined) {
+		            return bindMethod(console, methodName);
+		        } else if (console.log !== undefined) {
+		            return bindMethod(console, 'log');
+		        } else {
+		            return noop;
+		        }
+		    }
+
+		    // These private functions always need `this` to be set properly
+
+		    function replaceLoggingMethods() {
+		        /*jshint validthis:true */
+		        var level = this.getLevel();
+
+		        // Replace the actual methods.
+		        for (var i = 0; i < logMethods.length; i++) {
+		            var methodName = logMethods[i];
+		            this[methodName] = (i < level) ?
+		                noop :
+		                this.methodFactory(methodName, level, this.name);
+		        }
+
+		        // Define log.log as an alias for log.debug
+		        this.log = this.debug;
+
+		        // Return any important warnings.
+		        if (typeof console === undefinedType && level < this.levels.SILENT) {
+		            return "No console available for logging";
+		        }
+		    }
+
+		    // In old IE versions, the console isn't present until you first open it.
+		    // We build realMethod() replacements here that regenerate logging methods
+		    function enableLoggingWhenConsoleArrives(methodName) {
+		        return function () {
+		            if (typeof console !== undefinedType) {
+		                replaceLoggingMethods.call(this);
+		                this[methodName].apply(this, arguments);
+		            }
+		        };
+		    }
+
+		    // By default, we use closely bound real methods wherever possible, and
+		    // otherwise we wait for a console to appear, and then try again.
+		    function defaultMethodFactory(methodName, _level, _loggerName) {
+		        /*jshint validthis:true */
+		        return realMethod(methodName) ||
+		               enableLoggingWhenConsoleArrives.apply(this, arguments);
+		    }
+
+		    function Logger(name, factory) {
+		      // Private instance variables.
+		      var self = this;
+		      /**
+		       * The level inherited from a parent logger (or a global default). We
+		       * cache this here rather than delegating to the parent so that it stays
+		       * in sync with the actual logging methods that we have installed (the
+		       * parent could change levels but we might not have rebuilt the loggers
+		       * in this child yet).
+		       * @type {number}
+		       */
+		      var inheritedLevel;
+		      /**
+		       * The default level for this logger, if any. If set, this overrides
+		       * `inheritedLevel`.
+		       * @type {number|null}
+		       */
+		      var defaultLevel;
+		      /**
+		       * A user-specific level for this logger. If set, this overrides
+		       * `defaultLevel`.
+		       * @type {number|null}
+		       */
+		      var userLevel;
+
+		      var storageKey = "loglevel";
+		      if (typeof name === "string") {
+		        storageKey += ":" + name;
+		      } else if (typeof name === "symbol") {
+		        storageKey = undefined;
+		      }
+
+		      function persistLevelIfPossible(levelNum) {
+		          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();
+
+		          if (typeof window === undefinedType || !storageKey) return;
+
+		          // Use localStorage if available
+		          try {
+		              window.localStorage[storageKey] = levelName;
+		              return;
+		          } catch (ignore) {}
+
+		          // Use session cookie as fallback
+		          try {
+		              window.document.cookie =
+		                encodeURIComponent(storageKey) + "=" + levelName + ";";
+		          } catch (ignore) {}
+		      }
+
+		      function getPersistedLevel() {
+		          var storedLevel;
+
+		          if (typeof window === undefinedType || !storageKey) return;
+
+		          try {
+		              storedLevel = window.localStorage[storageKey];
+		          } catch (ignore) {}
+
+		          // Fallback to cookies if local storage gives us nothing
+		          if (typeof storedLevel === undefinedType) {
+		              try {
+		                  var cookie = window.document.cookie;
+		                  var cookieName = encodeURIComponent(storageKey);
+		                  var location = cookie.indexOf(cookieName + "=");
+		                  if (location !== -1) {
+		                      storedLevel = /^([^;]+)/.exec(
+		                          cookie.slice(location + cookieName.length + 1)
+		                      )[1];
+		                  }
+		              } catch (ignore) {}
+		          }
+
+		          // If the stored level is not valid, treat it as if nothing was stored.
+		          if (self.levels[storedLevel] === undefined) {
+		              storedLevel = undefined;
+		          }
+
+		          return storedLevel;
+		      }
+
+		      function clearPersistedLevel() {
+		          if (typeof window === undefinedType || !storageKey) return;
+
+		          // Use localStorage if available
+		          try {
+		              window.localStorage.removeItem(storageKey);
+		          } catch (ignore) {}
+
+		          // Use session cookie as fallback
+		          try {
+		              window.document.cookie =
+		                encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+		          } catch (ignore) {}
+		      }
+
+		      function normalizeLevel(input) {
+		          var level = input;
+		          if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
+		              level = self.levels[level.toUpperCase()];
+		          }
+		          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+		              return level;
+		          } else {
+		              throw new TypeError("log.setLevel() called with invalid level: " + input);
+		          }
+		      }
+
+		      /*
+		       *
+		       * Public logger API - see https://github.com/pimterry/loglevel for details
+		       *
+		       */
+
+		      self.name = name;
+
+		      self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
+		          "ERROR": 4, "SILENT": 5};
+
+		      self.methodFactory = factory || defaultMethodFactory;
+
+		      self.getLevel = function () {
+		          if (userLevel != null) {
+		            return userLevel;
+		          } else if (defaultLevel != null) {
+		            return defaultLevel;
+		          } else {
+		            return inheritedLevel;
+		          }
+		      };
+
+		      self.setLevel = function (level, persist) {
+		          userLevel = normalizeLevel(level);
+		          if (persist !== false) {  // defaults to true
+		              persistLevelIfPossible(userLevel);
+		          }
+
+		          // NOTE: in v2, this should call rebuild(), which updates children.
+		          return replaceLoggingMethods.call(self);
+		      };
+
+		      self.setDefaultLevel = function (level) {
+		          defaultLevel = normalizeLevel(level);
+		          if (!getPersistedLevel()) {
+		              self.setLevel(level, false);
+		          }
+		      };
+
+		      self.resetLevel = function () {
+		          userLevel = null;
+		          clearPersistedLevel();
+		          replaceLoggingMethods.call(self);
+		      };
+
+		      self.enableAll = function(persist) {
+		          self.setLevel(self.levels.TRACE, persist);
+		      };
+
+		      self.disableAll = function(persist) {
+		          self.setLevel(self.levels.SILENT, persist);
+		      };
+
+		      self.rebuild = function () {
+		          if (defaultLogger !== self) {
+		              inheritedLevel = normalizeLevel(defaultLogger.getLevel());
+		          }
+		          replaceLoggingMethods.call(self);
+
+		          if (defaultLogger === self) {
+		              for (var childName in _loggersByName) {
+		                _loggersByName[childName].rebuild();
+		              }
+		          }
+		      };
+
+		      // Initialize all the internal levels.
+		      inheritedLevel = normalizeLevel(
+		          defaultLogger ? defaultLogger.getLevel() : "WARN"
+		      );
+		      var initialLevel = getPersistedLevel();
+		      if (initialLevel != null) {
+		          userLevel = normalizeLevel(initialLevel);
+		      }
+		      replaceLoggingMethods.call(self);
+		    }
+
+		    /*
+		     *
+		     * Top-level API
+		     *
+		     */
+
+		    defaultLogger = new Logger();
+
+		    defaultLogger.getLogger = function getLogger(name) {
+		        if ((typeof name !== "symbol" && typeof name !== "string") || name === "") {
+		            throw new TypeError("You must supply a name when creating a logger.");
+		        }
+
+		        var logger = _loggersByName[name];
+		        if (!logger) {
+		            logger = _loggersByName[name] = new Logger(
+		                name,
+		                defaultLogger.methodFactory
+		            );
+		        }
+		        return logger;
+		    };
+
+		    // Grab the current global log variable in case of overwrite
+		    var _log = (typeof window !== undefinedType) ? window.log : undefined;
+		    defaultLogger.noConflict = function() {
+		        if (typeof window !== undefinedType &&
+		               window.log === defaultLogger) {
+		            window.log = _log;
+		        }
+
+		        return defaultLogger;
+		    };
+
+		    defaultLogger.getLoggers = function getLoggers() {
+		        return _loggersByName;
+		    };
+
+		    // ES6 default export, for compatibility
+		    defaultLogger['default'] = defaultLogger;
+
+		    return defaultLogger;
+		})); 
+	} (loglevel$1));
+	return loglevel$1.exports;
+}
+
+var loglevelExports = requireLoglevel();
+var log = /*@__PURE__*/getDefaultExportFromCjs(loglevelExports);
+
+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';
+}
+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))));
+}
+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.
+ */
+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. */
+function getRegisteredTaxonomy() {
+    if (registeredTaxonomy.length === 0) {
+        log.warn('[TaxonomyRegistry] Ingen taxonomi är registrerad ännu! Anropa registerTaxonomy(data) först.');
+    }
+    return registeredTaxonomy;
+}
+
+export { getRegisteredTaxonomy as g, isTaxonomyRegistration as i, log as l, registerTaxonomy as r };

package/dist/esm/types-DHUftoZJ.js

@@ -0,0 +1,12 @@
+class InvalidSelectionError extends Error {
+    code;
+    invalidIds;
+    constructor(message, code, invalidIds) {
+        super(message);
+        this.name = 'InvalidSelectionError';
+        this.code = code;
+        this.invalidIds = invalidIds;
+    }
+}
+
+export { InvalidSelectionError as I };

package/dist/esm/yrkesvaljaren.js

@@ -0,0 +1,20 @@
+import { p as promiseResolve, g as globalScripts, b as bootstrapLazy } from './index-CGXZllj2.js';
+export { s as setNonce } from './index-CGXZllj2.js';
+
+/*
+ Stencil Client Patch Browser v4.44.1 | MIT Licensed | https://stenciljs.com
+ */
+
+var patchBrowser = () => {
+  const importMeta = import.meta.url;
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await globalScripts();
+  return bootstrapLazy([["job-selector-demo",[[512,"job-selector-demo",{"afHideHeader":[4,"af-hide-header"],"afHidePreamble":[4,"af-hide-preamble"],"variant":[32],"version":[32],"required":[32],"allowFreeText":[32],"history":[32],"size":[32],"framework":[32],"codeInstallationMode":[32],"lastSingleSelection":[32],"lastMultiSelection":[32],"implementationCode":[32],"readmeMainContent":[32],"readmeCodeContent":[32],"availableYvVersions":[32],"latestYvDataVersion":[32],"latestVersion":[32],"latestDate":[32],"latestType":[32],"latestChanges":[32],"isTaxonomyLoading":[32]},[[0,"afJobSelected","handleSelection"]]]]],["geo-valjaren",[[513,"geo-valjaren",{"label":[513,"af-label"],"placeholder":[513,"af-placeholder"],"selectorState":[32]},[[0,"csInput","handleInput"],[0,"csFocus","handleFocus"],[0,"csRequestHistory","handleRequestHistory"],[0,"csSelect","handleSelect"],[0,"csBlur","handleBlur"],[0,"csClear","handleClear"],[0,"csClearHistory","handleCsClearHistory"],[0,"csEditSelection","handleEdit"]]]]],["neobrutal-search",[[513,"neobrutal-search",{"engine":[32],"results":[32],"inputValue":[32],"isLoading":[32],"error":[32],"selectedItem":[32],"isFlipped":[32]}]]],["core-selector",[[785,"core-selector",{"state":[16],"config":[16],"label":[1],"labelDescription":[1,"label-description"],"componentId":[1,"component-id"],"size":[513,"cs-size"],"afFocused":[4,"af-focused"],"activeIndex":[32],"isFocusedInternal":[32],"isNavigatingWithKeyboard":[32],"setFocus":[64]},null,{"afFocused":[{"handleAfFocusedChange":0}],"config":[{"handleConfigChange":0}],"state":[{"handleStateChange":0}]}]]],["digi-service-job-selector",[[593,"digi-service-job-selector",{"name":[513],"taxonomyUrl":[513,"af-taxonomy-url"],"placeholder":[513,"af-placeholder"],"label":[513,"af-label"],"disabled":[516],"enableMultiple":[516,"af-enable-multiple"],"showSearchIcon":[516,"af-show-search-icon"],"errorMessage":[513,"af-error-message"],"labelDescription":[513,"af-label-description"],"required":[516,"af-required"],"manualInput":[516,"af-manual-input"],"history":[516,"af-history"],"popular":[516,"af-popular"],"size":[513,"af-size"],"taxonomyData":[1040],"afFocused":[32],"state":[32],"activeErrorType":[32],"animatingItemId":[32],"updateData":[64],"setSelection":[64],"setFocus":[64],"validate":[64],"checkValidity":[64],"reportValidity":[64],"getValidity":[64],"getValidationMessage":[64]},[[0,"afJobValidationChange","handleFormValidationSync"],[8,"hashchange","handleHashFocus"],[0,"csInput","handleInput"],[0,"csSelect","handleCsSelect"],[0,"csClear","handleCsClear"],[0,"csClearHistory","handleCsClearHistory"],[0,"csRequestHistory","handleCsRequestHistory"],[0,"csLoadMore","handleCsLoadMore"],[0,"csRemoveItem","handleCsRemoveItem"],[0,"csFocus","handleCsFocus"],[0,"csBlur","handleCsBlur"],[0,"csEditSelection","handleCsEditSelection"]],{"required":[{"watchRequired":0}],"manualInput":[{"watchManualInput":0}],"history":[{"watchHistory":0}],"popular":[{"watchPopular":0}],"enableMultiple":[{"watchEnableMultiple":0}],"disabled":[{"watchDisabled":0}],"taxonomyData":[{"watchTaxonomyData":0}]}]]]], options);
+});

package/dist/index.cjs.js

@@ -0,0 +1 @@
+module.exports = require('./cjs/index.cjs.js');

package/dist/index.js

@@ -0,0 +1 @@
+export * from './esm/index.js';

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

@@ -0,0 +1,46 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { GenericItem, SelectorState, SelectorConfig } from './types';
+export declare class CoreSelector {
+    private historyRequestTimer?;
+    disconnectedCallback(): void;
+    static nextId: number;
+    hostElement: HTMLElement;
+    state: SelectorState;
+    config: SelectorConfig;
+    label: string;
+    labelDescription?: string;
+    componentId: string;
+    size: 'small' | 'medium' | 'large';
+    csInput: EventEmitter<string>;
+    csSelect: EventEmitter<GenericItem>;
+    csClear: EventEmitter<void>;
+    csRemoveItem: EventEmitter<GenericItem>;
+    csBlur: EventEmitter<void>;
+    csEditSelection: EventEmitter<void>;
+    csFocus: EventEmitter<void>;
+    csLoadMore: EventEmitter<void>;
+    csClearHistory: EventEmitter<void>;
+    csRequestHistory: EventEmitter<void>;
+    afFocused: boolean;
+    private activeIndex;
+    private isFocusedInternal;
+    private isNavigatingWithKeyboard;
+    setFocus(): Promise<void>;
+    private inputRef;
+    private listRef;
+    private shouldFocusAfterRender;
+    private handleKeyDown;
+    private onWrapperFocusIn;
+    private onWrapperFocusOut;
+    handleAfFocusedChange(newValue: boolean): void;
+    handleConfigChange(newConfig: SelectorConfig): void;
+    handleStateChange(newState: SelectorState, oldState: SelectorState): void;
+    componentDidUpdate(): void;
+    private performFocusRestoration;
+    private handleScroll;
+    private scrollToActive;
+    private handleManualSelect;
+    render(): any;
+    private renderSearchContainer;
+    private renderSuggestionsList;
+}

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

@@ -0,0 +1 @@
+export type { FormattedText, GenericItem, SelectorConfig, SelectorSize, SelectorState, TextSegment, ValidationStatus, } from '@taxonomy/core/selector-types';

package/dist/types/components/design-compat/af-icon.d.ts

@@ -0,0 +1,7 @@
+export type AfIconName = 'check' | 'search' | 'x';
+interface AfIconProps {
+    name: AfIconName;
+    class?: string | Record<string, boolean>;
+}
+export declare const AfIcon: ({ name, class: className }: AfIconProps) => any;
+export {};

package/dist/types/components/design-compat/af-label.d.ts

@@ -0,0 +1,8 @@
+interface AfLabelProps {
+    label: string;
+    forId: string;
+    description?: string;
+    required?: boolean;
+}
+export declare const AfLabel: ({ label, forId, description, required }: AfLabelProps) => any;
+export {};

package/dist/types/components/design-compat/af-tag.d.ts

@@ -0,0 +1,8 @@
+interface AfTagProps {
+    key?: string;
+    text: string;
+    breakWords?: boolean;
+    onRemove: () => void;
+}
+export declare const AfTag: ({ text, breakWords, onRemove }: AfTagProps) => any;
+export {};

package/dist/types/components/design-compat/af-validation-message.d.ts

@@ -0,0 +1,9 @@
+export type AfValidationVariant = 'error' | 'success' | 'warning';
+interface AfValidationMessageProps {
+    variant: AfValidationVariant;
+    class?: string;
+    id?: string;
+    role?: string;
+}
+export declare const AfValidationMessage: (props: AfValidationMessageProps, children: any[]) => any;
+export {};

package/dist/types/components/design-compat/index.d.ts

@@ -0,0 +1,5 @@
+export { AfIcon } from './af-icon';
+export { AfLabel } from './af-label';
+export { AfTag } from './af-tag';
+export { AfValidationMessage } from './af-validation-message';
+export type { AfValidationVariant } from './af-validation-message';

package/dist/types/components/geovaljaren/geovaljaren.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { GenericItem, SelectorState } from '../core-selector/types';
+export declare class Geovaljaren {
+    label: string;
+    placeholder: string;
+    selectorState: SelectorState;
+    selectionEmitter: EventEmitter<GenericItem | null>;
+    private config;
+    private engine;
+    private allGeoItems;
+    componentWillLoad(): Promise<void>;
+    private showHistory;
+    private addToHistory;
+    private clearHistory;
+    handleInput(event: CustomEvent<string>): void;
+    handleFocus(): void;
+    handleRequestHistory(): void;
+    handleSelect(event: CustomEvent<GenericItem>): void;
+    handleBlur(): void;
+    handleClear(): void;
+    handleCsClearHistory(): void;
+    handleEdit(): void;
+    render(): any;
+}

package/dist/types/components/geovaljaren/logic/adapter.utils.d.ts

@@ -0,0 +1,7 @@
+import { GenericItem } from '../../core-selector/types';
+export declare const GeoAdapter: {
+    /**
+     * Transforms the pendlingskommuner JSON data structure into GenericItems.
+     */
+    toGenericItems: (jsonData: any) => GenericItem[];
+};

package/dist/types/components/geovaljaren/logic/data.utils.d.ts

@@ -0,0 +1,7 @@
+import { GenericItem } from '../../core-selector/types';
+export declare const GeoDataService: {
+    /**
+     * Simulates an async fetch of geo data
+     */
+    fetchAll: () => Promise<GenericItem[]>;
+};

package/dist/types/components/geovaljaren/logic/history-service.d.ts

@@ -0,0 +1,6 @@
+import { GenericItem } from '../../core-selector/types';
+export declare const GeoHistoryService: {
+    saveHistory(history: GenericItem[]): void;
+    loadHistory(): GenericItem[];
+    clearHistory(): void;
+};

package/dist/types/components/geovaljaren/logic/search.engine.d.ts

@@ -0,0 +1,7 @@
+import { GenericItem } from '../../core-selector/types';
+export declare class SearchEngine {
+    private fuse;
+    constructor(data: GenericItem[]);
+    search(query: string, maxResults?: number): GenericItem[];
+    updateIndex(newData: GenericItem[]): void;
+}

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

@@ -0,0 +1,4 @@
+declare module '*.json' {
+  const value: any;
+  export default value;
+}

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

@@ -0,0 +1,13 @@
+import { IFuseOptions } from 'fuse.js';
+import { TaxonomyItem } from './types';
+export declare const MIN_INPUT_LENGTH = 1;
+export declare const DEBOUNCE_TIME = 100;
+export declare const MAX_RESULTS = 10;
+export declare const FUSE_OPTIONS: IFuseOptions<TaxonomyItem>;
+export declare const PLACEHOLDER_TEXT = "T.ex. fris\u00F6r, v\u00E5rdbitr\u00E4de, snickare";
+export declare const NO_RESULTS_TEXT = "Inga resultat matchade din s\u00F6kning.";
+export declare const VALIDATION_ERROR_REQUIRED_FIELD = "Du m\u00E5ste g\u00F6ra ett val";
+export declare const VALIDATION_ERROR_EMPTY_FIELD = "V\u00E4lj ett yrke fr\u00E5n listan";
+export declare const CLEAR_BUTTON_LABEL_TEXT = "Rensa s\u00F6kf\u00E4lt";
+export declare const REMOVE_ITEM_LABEL_TEXT_PREFIX = "Ta bort";
+export declare const POSITIVE_VALIDATION_TEXT = "Valt yrke";

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

@@ -0,0 +1,6 @@
+import { SearchResult } from './types';
+export declare const HistoryService: {
+    saveHistory(history: SearchResult[]): void;
+    loadHistory(): SearchResult[];
+    clearHistory(): void;
+};