@arbetsformedlingen/yrkesvaljaren 2.0.5

package/dist/cjs/taxonomy-registry-DVmuDUpM.js

@@ -0,0 +1,435 @@
+'use strict';
+
+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;
+}
+
+exports.getRegisteredTaxonomy = getRegisteredTaxonomy;
+exports.isTaxonomyRegistration = isTaxonomyRegistration;
+exports.log = log;
+exports.registerTaxonomy = registerTaxonomy;

package/dist/cjs/types-CtHBl6Ra.js

@@ -0,0 +1,14 @@
+'use strict';
+
+class InvalidSelectionError extends Error {
+    code;
+    invalidIds;
+    constructor(message, code, invalidIds) {
+        super(message);
+        this.name = 'InvalidSelectionError';
+        this.code = code;
+        this.invalidIds = invalidIds;
+    }
+}
+
+exports.InvalidSelectionError = InvalidSelectionError;

package/dist/cjs/yrkesvaljaren.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var index = require('./index-BOuTGlEp.js');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/*
+ Stencil Client Patch Browser v4.44.1 | MIT Licensed | https://stenciljs.com
+ */
+
+var patchBrowser = () => {
+  const importMeta = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('yrkesvaljaren.cjs.js', document.baseURI).href));
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return index.promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await index.globalScripts();
+  return index.bootstrapLazy([["job-selector-demo.cjs",[[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.cjs",[[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.cjs",[[513,"neobrutal-search",{"engine":[32],"results":[32],"inputValue":[32],"isLoading":[32],"error":[32],"selectedItem":[32],"isFlipped":[32]}]]],["core-selector.cjs",[[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.cjs",[[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);
+});
+
+exports.setNonce = index.setNonce;

package/dist/collection/collection-manifest.json

@@ -0,0 +1,15 @@
+{
+  "entries": [
+    "components/core-selector/core-selector.js",
+    "components/geovaljaren/geovaljaren.js",
+    "components/job-selector/job-selector.js"
+  ],
+  "mixins": [],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "4.44.1",
+    "typescriptVersion": "5.8.3"
+  },
+  "collections": [],
+  "bundles": []
+}