@postnord/pn-marketweb-components 2.1.8 → 2.1.9

package/components/MarketWebContextService.js

@@ -0,0 +1,316 @@
+class FetchHelper {
+  constructor(namespace = "") {
+    this.storagePrefix = "";
+    this.store = {
+      get: (key, permanentStorageFirst = false) => {
+        const firstProfider = permanentStorageFirst ? window.localStorage : window.sessionStorage;
+        const secondProvider = permanentStorageFirst ? window.sessionStorage : window.localStorage;
+        let value = firstProfider.getItem(`${this.storagePrefix}-${key}`);
+        if (!value) {
+          value = secondProvider.getItem(`${this.storagePrefix}-${key}`);
+        }
+        if (!value) {
+          return value;
+        }
+        if (value.indexOf('{') === 0) {
+          try {
+            return JSON.parse(value);
+          }
+          catch (e) {
+          }
+        }
+        if (value.indexOf(',') !== -1) {
+          return value.split(',');
+        }
+        return value;
+      },
+      set: (key, value, permanent = false) => {
+        const provider = permanent ? window.localStorage : window.sessionStorage;
+        if (typeof value === "object" && typeof value.length === "undefined") {
+          provider.setItem(`${this.storagePrefix}-${key}`, JSON.stringify(value));
+          return;
+        }
+        provider.setItem(`${this.storagePrefix}-${key}`, value);
+      },
+      remove: (key) => {
+        window.sessionStorage.removeItem(`${this.storagePrefix}-${key}`);
+      },
+    };
+    this.storagePrefix = namespace;
+  }
+  async fetchJson(input, init = {}, useCache = false, onCacheUpdated = null) {
+    const requestPromise = new Promise(async (resolve) => {
+      let doFetchRequest = true;
+      const url = (typeof input === "string") ? input : input.url;
+      const cacheKey = url;
+      let jsonData = null;
+      let cachedData = null;
+      if (useCache) {
+        cachedData = this.store.get(cacheKey);
+        // If the data was stored in session storage, then we don't need to do a full request
+        if (cachedData && !cachedData.permanent) {
+          doFetchRequest = false;
+        }
+        if (cachedData && cachedData.data) {
+          jsonData = cachedData.data;
+          resolve(jsonData);
+        }
+      }
+      if (doFetchRequest) {
+        const response = await window.fetch(input, init);
+        jsonData = await response.json();
+        resolve(jsonData);
+        if (useCache) {
+          if (typeof onCacheUpdated === "function" && cachedData != null) {
+            onCacheUpdated(jsonData);
+          }
+          this.store.set(cacheKey, this.wrapJson(jsonData, true), true);
+          this.store.set(cacheKey, this.wrapJson(jsonData, false), false);
+        }
+      }
+    });
+    return requestPromise;
+  }
+  wrapJson(data, permanent = false) {
+    const now = new Date();
+    return {
+      timestamp: now.getTime(),
+      time: now.toISOString(),
+      data: data,
+      permanent: permanent
+    };
+  }
+}
+
+class MarketWebContextService {
+  constructor(href = window.location.href) {
+    this.href = "";
+    this.market = "";
+    this.language = "";
+    this.environment = "";
+    this.url = null;
+    this.allowedLanguages = ["sv", "da", "fi", "no", "en", "de"];
+    this.allowedMarkets = ["se", "dk", "fi", "no", "com", "de", "tpl"];
+    this.wwwMarkets = ["se", "dk", "fi", "no", "de", "com"];
+    this.developmentDomains = ["localhost", ".local", "local.", ".dev", "dev."];
+    this.markets = {
+      "se": {
+        fallbackLanguage: "sv",
+        integration: 'se-integration.postnord.com',
+        preproduction: 'se-preproduction.postnord.com',
+        production: 'se-production.postnord.com',
+        live: 'www.postnord.se'
+      },
+      "dk": {
+        fallbackLanguage: "da",
+        integration: 'dk-integration.postnord.com',
+        preproduction: 'dk-preproduction.postnord.com',
+        production: 'dk-production.postnord.com',
+        live: 'www.postnord.dk'
+      },
+      "fi": {
+        fallbackLanguage: "fi",
+        integration: 'fi-integration.postnord.com',
+        preproduction: 'fi-preproduction.postnord.com',
+        production: 'fi-production.postnord.com',
+        live: 'www.postnord.fi'
+      },
+      "no": {
+        fallbackLanguage: "no",
+        integration: 'no-integration.postnord.com',
+        preproduction: 'no-preproduction.postnord.com',
+        production: 'no-production.postnord.com',
+        live: 'www.postnord.no'
+      },
+      "com": {
+        fallbackLanguage: "en",
+        integration: 'com-integration.postnord.com',
+        preproduction: 'com-preproduction.postnord.com',
+        production: 'com-production.postnord.com',
+        live: 'www.postnord.com'
+      },
+      "de": {
+        fallbackLanguage: "en",
+        integration: 'de-integration.postnord.com',
+        preproduction: 'de-preproduction.postnord.com',
+        production: 'de-production.postnord.com',
+        live: 'www.postnord.de'
+      },
+      "tpl": {
+        fallbackLanguage: "sv",
+        integration: 'tpl-integration.postnord.com',
+        preproduction: 'tpl-preproduction.postnord.com',
+        production: 'tpl-production.postnord.com',
+        live: 'tpl.postnord.com'
+      },
+    };
+    this.environmentTypes = ["integration", "preproduction", "production"];
+    this.environments = {
+      "production": {
+        "name": "production",
+        "url": "https://www.postnord.xx/"
+      },
+      "preproduction": {
+        "name": "preproduction",
+        "url": "https://com-preproduction.postnord.com/"
+      },
+      "integration": {
+        "name": "integration",
+        "url": "https://com-integration.postnord.com/"
+      }
+    };
+    this.href = href;
+    this.url = new URL(this.href);
+  }
+  async getLanguage() {
+    if (this.language) {
+      return this.language;
+    }
+    await this.resolveLanguage();
+    return this.language;
+  }
+  async getMarket() {
+    if (this.market) {
+      return this.market;
+    }
+    await this.resolveMarket();
+    return this.market;
+  }
+  async getEndpoint(environmentName, marketName = "") {
+    let url = this.environments.production.url;
+    if (this.markets[marketName] && this.markets[marketName][environmentName]) {
+      if (environmentName === 'production' && window.location.hostname.indexOf(this.markets[marketName]['live']) === 0) {
+        // If the environment is production and we're on the www domain we'll use that
+        return `https://` + this.markets[marketName]['live'];
+      }
+      if (window.location.hostname.indexOf(this.markets[marketName][environmentName]) === 0) {
+        return `https://` + this.markets[marketName][environmentName];
+      }
+    }
+    // Old solution to match URLs. Not bulletproof
+    if (this.environments[environmentName]) {
+      url = this.environments[environmentName].url;
+      if (environmentName === this.environments.production.name) {
+        if (this.wwwMarkets.indexOf(marketName) !== -1) {
+          // Handles www.postnord.xx domains
+          url = url.replace(".xx", "." + marketName);
+        }
+        else {
+          url = url.replace(".xx", ".com"); // Expect URL to end in postnord.com
+          url = url.replace("www.", marketName + ".");
+        }
+      }
+    }
+    return url;
+  }
+  async getEnvironmentName() {
+    const likelyEnvironment = this.environmentTypes.filter(x => this.url.hostname.indexOf(('-' + x)) !== -1)[0];
+    if (likelyEnvironment) {
+      this.environment = likelyEnvironment;
+      return this.environment;
+    }
+    if (this.url.hostname.indexOf('www.') !== -1) {
+      this.environment = this.environments.production.name;
+      return this.environment;
+    }
+    this.environment = this.environments.integration.name;
+    return this.environment;
+  }
+  isDevEnvironment() {
+    const matchedDevEnvironment = this.developmentDomains.filter(x => this.url.hostname.indexOf(x) !== -1)[0];
+    return matchedDevEnvironment.length > 0;
+  }
+  async resolveMarket() {
+    // Resolve market from www domains
+    if (this.href.indexOf("//www.") !== -1) {
+      const domainRoot = this.url.hostname.substring(this.url.hostname.lastIndexOf('.') + 1, this.url.hostname.length);
+      if (domainRoot && this.markets[domainRoot]) {
+        this.market = domainRoot;
+      }
+      else {
+        console.warn("Unable to define market from www. domain", this.href);
+      }
+    }
+    // Check if domains are on one of the integration/preproduction/production environments urls
+    const likelyEnvironment = this.environmentTypes.filter(x => this.url.hostname.indexOf(('-' + x)) !== -1);
+    if (!this.market && likelyEnvironment && likelyEnvironment.length > 0) {
+      const matchedEnvironment = likelyEnvironment[0];
+      const marketPrefix = this.url.hostname.substring(0, this.url.hostname.indexOf('-' + matchedEnvironment));
+      if (marketPrefix && this.markets[marketPrefix]) {
+        this.market = marketPrefix;
+      }
+      else {
+        console.warn("Unable to define market from preset environment names", this.href);
+      }
+    }
+    if (!this.market) {
+      if (this.url.hostname.indexOf('www') === -1 && this.url.hostname.indexOf('.postnord.') > 0) {
+        const start = this.url.hostname.indexOf('.') !== this.url.hostname.indexOf('.postnord') ? this.url.hostname.indexOf('.') : 0;
+        const potentialMarket = this.url.hostname.substring(start, this.url.hostname.indexOf('.postnord.'));
+        // Break down the subdomain to the word closest to .postnord. and take that word. 
+        // Supports sub-sub domain down to 1 level.
+        if (this.allowedMarkets.indexOf(potentialMarket) !== -1) {
+          this.market = potentialMarket;
+          return;
+        }
+      }
+    }
+    // Check if we're on a development environment    
+    if (!this.market) {
+      const matchedDevEnvironment = this.developmentDomains.filter(x => this.url.hostname.indexOf(x) !== -1)[0];
+      if (!matchedDevEnvironment) {
+        // Fallback to first allowed market
+        this.market = this.allowedMarkets[0];
+        return;
+      }
+      const urlWithoutDomain = this.href.replace(matchedDevEnvironment, "");
+      // We see if the dev environment contains something like /dk
+      let matchedMarket = this.allowedMarkets.filter(x => {
+        const typesOfFallback = ['.' + x, x + '.', '/' + x + '/']; // Ex /dk, dk.html, /dk/
+        const matchedTypeOfFallback = typesOfFallback.filter(y => urlWithoutDomain.indexOf(y) !== -1);
+        return matchedTypeOfFallback.length > 0;
+      })[0];
+      if (matchedMarket) {
+        this.market = matchedMarket;
+      }
+      else {
+        // We do a similar filter for subpaths but for language this time
+        let filteredMarket = Object.entries(this.markets).filter((item) => {
+          const typesOfFallback = ['.' + item[1].fallbackLanguage, item[1].fallbackLanguage + '.', '/' + item[1].fallbackLanguage + '/']; // Ex /dk, dk.html, /dk/
+          const matchedTypeOfFallback = typesOfFallback.filter(y => urlWithoutDomain.indexOf(y) !== -1);
+          return matchedTypeOfFallback.length > 0;
+        })[0];
+        if (filteredMarket && filteredMarket[0]) {
+          this.market = filteredMarket[0];
+        }
+      }
+    }
+    if (!this.market) {
+      console.info("Was unable to detect market, used fallback");
+      this.market = this.allowedMarkets[0];
+    }
+  }
+  async resolveLanguage() {
+    var _a, _b, _c, _d;
+    if (this.language) {
+      return;
+    }
+    const potentialLanguages = [
+      (_a = document.querySelector("html[lang]")) === null || _a === void 0 ? void 0 : _a.getAttribute("lang"),
+      (_b = document.querySelector('[http-equiv="content-language"][content]')) === null || _b === void 0 ? void 0 : _b.getAttribute("content"),
+      (_c = document.querySelector('[property="og:locale"][content]')) === null || _c === void 0 ? void 0 : _c.getAttribute("content"),
+      (_d = document.querySelector("[lang]")) === null || _d === void 0 ? void 0 : _d.getAttribute("lang"),
+    ];
+    potentialLanguages.filter(x => x).forEach((language) => {
+      if (this.allowedLanguages.indexOf(language)) {
+        this.language = language;
+        return;
+      }
+    });
+    if (!this.language && this.market) {
+      this.language = this.markets[this.market].fallbackLanguage;
+    }
+  }
+}
+
+export { FetchHelper as F, MarketWebContextService as M };

package/components/_commonjsHelpers.js

@@ -0,0 +1,32 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function createCommonjsModule(fn, basedir, module) {
+	return module = {
+		path: basedir,
+		exports: {},
+		require: function (path, base) {
+			return commonjsRequire();
+		}
+	}, fn(module, module.exports), module.exports;
+}
+
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
+}
+
+export { commonjsGlobal as a, commonjsRequire as b, createCommonjsModule as c, getAugmentedNamespace as g };