@adyen/adyen-platform-experience-web 0.1.1 → 1.0.0-beta

package/dist/es/core/Localization/datetime/restamper/restamper.js

@@ -1,42 +1,54 @@
-import { struct as f } from "../../../../utils/common/index.js";
-import { SYSTEM_TIMEZONE as i, BASE_LOCALE as E, BASE_FORMAT_OPTIONS as a, SYSTEM_TIMEZONE_FORMATTER as c } from "./constants.js";
-import { getTimezoneOffsetForTimestamp as O } from "./utils.js";
-const T = (() => {
-  let n, o;
-  i !== void 0 && (n = function() {
-    return this.TIMEZONE;
-  }, o = function(t) {
-    if (t != null)
-      try {
-        const e = new Intl.DateTimeFormat(E, { ...a, timeZone: t }), r = e.resolvedOptions().timeZone;
-        if (this.TIMEZONE === r)
-          return;
-        this.TIMEZONE = r, this.formatter = e;
-      } catch {
+import { struct } from "../../../../utils/common/index.js";
+import { SYSTEM_TIMEZONE, BASE_LOCALE, BASE_FORMAT_OPTIONS, SYSTEM_TIMEZONE_FORMATTER } from "./constants.js";
+import { getTimezoneOffsetForTimestamp } from "./utils.js";
+const restamper = (() => {
+  let getTimeZone;
+  let setTimeZone;
+  if (SYSTEM_TIMEZONE !== void 0) {
+    getTimeZone = function() {
+      return this.TIMEZONE;
+    };
+    setTimeZone = function(timeZone) {
+      if (timeZone != void 0) {
+        try {
+          const nextFormatter = new Intl.DateTimeFormat(BASE_LOCALE, { ...BASE_FORMAT_OPTIONS, timeZone });
+          const nextTimeZone = nextFormatter.resolvedOptions().timeZone;
+          if (this.TIMEZONE === nextTimeZone)
+            return;
+          this.TIMEZONE = nextTimeZone;
+          this.formatter = nextFormatter;
+        } catch (ex) {
+        }
+      } else {
+        this.TIMEZONE = SYSTEM_TIMEZONE;
+        this.formatter = SYSTEM_TIMEZONE_FORMATTER;
       }
-    else
-      this.TIMEZONE = i, this.formatter = c;
-  });
-  function m(...t) {
-    if (t.length === 0)
-      return m.call(this, Date.now());
-    const e = t[0], r = new Date(e).getTime(), s = this.formatter ?? c;
+    };
+  }
+  function restamp(...args) {
+    if (args.length === 0)
+      return restamp.call(this, Date.now());
+    const time = args[0];
+    const timestamp = new Date(time).getTime();
+    const formatter = this.formatter ?? SYSTEM_TIMEZONE_FORMATTER;
     return Object.freeze({
-      formatted: s == null ? void 0 : s.format(r),
-      offset: O(r, s),
-      timestamp: r
+      formatted: formatter == null ? void 0 : formatter.format(timestamp),
+      offset: getTimezoneOffsetForTimestamp(timestamp, formatter),
+      timestamp
     });
   }
   return () => {
-    const t = { TIMEZONE: i }, e = o == null ? void 0 : o.bind(t), r = f({
-      current: { get: n == null ? void 0 : n.bind(t), set: e },
-      system: { value: i }
+    const context = { TIMEZONE: SYSTEM_TIMEZONE };
+    const set = setTimeZone == null ? void 0 : setTimeZone.bind(context);
+    const tz = struct({
+      current: { get: getTimeZone == null ? void 0 : getTimeZone.bind(context), set },
+      system: { value: SYSTEM_TIMEZONE }
     });
-    return Object.defineProperties(m.bind(t), {
-      tz: { get: () => r, set: e }
+    return Object.defineProperties(restamp.bind(context), {
+      tz: { get: () => tz, set }
     });
   };
-})(), h = T;
+})();
 export {
-  h as default
+  restamper as default
 };

package/dist/es/core/Localization/datetime/restamper/restamper.test.js

@@ -0,0 +1,179 @@
+import { h as getWorkerState, c as afterAll, e as afterEach, j as assert, a as beforeAll, b as beforeEach, k as bench, l as chai, m as createExpect, d as describe, g as globalExpect, i as it, o as onTestFailed, s as setupChaiConfig, n as should, p as suite, t as test, v as vi, q as vitest } from "../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+import { REGEX_TZ_OFFSET } from "./constants.js";
+import restamper from "./restamper.js";
+import { NON_DST_TIMEZONES, DST_TIMEZONES } from "./testing/fixtures.js";
+import { getPastDatesMapForEachMonthInYear, runTimezoneTestRoutine } from "./testing/helpers.js";
+const filesCount = /* @__PURE__ */ new Map();
+const cache = /* @__PURE__ */ new Map();
+function runOnce(fn, key) {
+  const filepath = getWorkerState().filepath || "__unknown_files__";
+  if (!key) {
+    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
+    key = String(filesCount.get(filepath));
+  }
+  const id = `${filepath}:${key}`;
+  if (!cache.has(id))
+    cache.set(id, fn());
+  return cache.get(id);
+}
+function isFirstRun() {
+  let firstRun = false;
+  runOnce(() => {
+    firstRun = true;
+  }, "__vitest_first_run__");
+  return firstRun;
+}
+function getRunningMode() {
+  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
+}
+function isWatchMode() {
+  return getRunningMode() === "watch";
+}
+var dist = {};
+(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.expectTypeOf = void 0;
+  const fn = () => true;
+  const expectTypeOf2 = (_actual) => {
+    const nonFunctionProperties = [
+      "parameters",
+      "returns",
+      "resolves",
+      "not",
+      "items",
+      "constructorParameters",
+      "instance",
+      "guards",
+      "asserts"
+    ];
+    const obj = {
+      /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
+      toBeAny: fn,
+      toBeUnknown: fn,
+      toBeNever: fn,
+      toBeFunction: fn,
+      toBeObject: fn,
+      toBeArray: fn,
+      toBeString: fn,
+      toBeNumber: fn,
+      toBeBoolean: fn,
+      toBeVoid: fn,
+      toBeSymbol: fn,
+      toBeNull: fn,
+      toBeUndefined: fn,
+      toBeNullable: fn,
+      toMatchTypeOf: fn,
+      toEqualTypeOf: fn,
+      toBeCallableWith: fn,
+      toBeConstructibleWith: fn,
+      /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
+      extract: exports.expectTypeOf,
+      exclude: exports.expectTypeOf,
+      toHaveProperty: exports.expectTypeOf,
+      parameter: exports.expectTypeOf
+    };
+    const getterProperties = nonFunctionProperties;
+    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
+    return obj;
+  };
+  exports.expectTypeOf = expectTypeOf2;
+})(dist);
+function noop() {
+}
+const assertType = noop;
+/* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  afterAll,
+  afterEach,
+  assert,
+  assertType,
+  beforeAll,
+  beforeEach,
+  bench,
+  chai,
+  createExpect,
+  describe,
+  expect: globalExpect,
+  expectTypeOf: dist.expectTypeOf,
+  getRunningMode,
+  isFirstRun,
+  isWatchMode,
+  it,
+  onTestFailed,
+  runOnce,
+  setupChaiConfig,
+  should,
+  suite,
+  test,
+  vi,
+  vitest
+});
+var expectTypeOf = dist.expectTypeOf;
+describe("restamper", () => {
+  beforeEach((context) => {
+    const _restamper = restamper();
+    Object.defineProperties(context, {
+      currentOffset: { value: _restamper().offset, enumerable: true },
+      restamper: { value: _restamper, enumerable: true },
+      timezone: { value: _restamper.tz, enumerable: true }
+    });
+  });
+  test("should return restamp instance", ({ restamper: restamper2, timezone }) => {
+    const { system: systemTimezone } = timezone;
+    const invalidTimezone = "Unknown/Invalid_TZ";
+    const validTimezone = "Asia/Tokyo";
+    expectTypeOf(restamper2);
+    expectTypeOf(restamper2());
+    expectTypeOf(restamper2(/* @__PURE__ */ new Date("2012-08-22")));
+    expectTypeOf(timezone);
+    globalExpect(restamper2).toHaveProperty("tz");
+    globalExpect(timezone).toHaveProperty("current");
+    globalExpect(timezone).toHaveProperty("system");
+    globalExpect(timezone.system).toBeTypeOf("string");
+    globalExpect(timezone.current).toBeTypeOf("string");
+    globalExpect(timezone.current).toBe(timezone.system);
+    restamper2.tz = validTimezone;
+    globalExpect(timezone.current).toBe(validTimezone);
+    globalExpect(timezone.system).toBe(systemTimezone);
+    restamper2.tz = invalidTimezone;
+    globalExpect(timezone.current).not.toBe(invalidTimezone);
+    globalExpect(timezone.current).toBe(validTimezone);
+    globalExpect(timezone.system).toBe(systemTimezone);
+  });
+  test("should return restamp result for current time (when argument is omitted)", ({ restamper: restamper2 }) => {
+    let result = restamper2();
+    globalExpect(result).toHaveProperty("formatted");
+    globalExpect(result).toHaveProperty("offset");
+    globalExpect(result).toHaveProperty("timestamp");
+    globalExpect(result.offset).toBeTypeOf("number");
+    globalExpect(result.offset).toBe(0);
+    globalExpect(result.timestamp).toBeTypeOf("number");
+    globalExpect(result.timestamp).toBeCloseTo(Date.now(), -2);
+    if (result.formatted !== void 0) {
+      globalExpect(result.formatted).toBeTypeOf("string");
+      globalExpect(REGEX_TZ_OFFSET.test(result.formatted)).toBe(true);
+    }
+  });
+  test("should have correct offsets for non-DST timezones for times in the past", ({ restamper: restamper2 }) => {
+    const pastDatesMap = getPastDatesMapForEachMonthInYear(restamper2);
+    NON_DST_TIMEZONES.forEach((timezoneOffset, timezone) => {
+      restamper2.tz = timezone;
+      pastDatesMap.forEach((systemTimezoneResult, date) => {
+        const result = restamper2(date);
+        runTimezoneTestRoutine(timezoneOffset, systemTimezoneResult, result);
+      });
+    });
+  });
+  test("should have correct offsets for DST timezones for times in the past", ({ restamper: restamper2 }) => {
+    const pastDatesMap = getPastDatesMapForEachMonthInYear(restamper2);
+    DST_TIMEZONES.forEach((timezoneOffsets, timezone) => {
+      restamper2.tz = timezone;
+      let index = 0;
+      for (const [date, systemTimezoneResult] of pastDatesMap) {
+        const result = restamper2(date);
+        const timezoneOffsetForCurrentTime = timezoneOffsets[index++];
+        runTimezoneTestRoutine(timezoneOffsetForCurrentTime, systemTimezoneResult, result);
+      }
+    });
+  });
+});

package/dist/es/core/Localization/datetime/restamper/testing/fixtures.js

@@ -0,0 +1,21 @@
+const TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE = "2021-12-21 10:53:07 AM";
+const DST_TIMEZONES = /* @__PURE__ */ new Map([
+  ["America/Toronto", [-300, -300, -240, -240, -240, -240, -240, -240, -240, -240, -300, -300]],
+  ["Asia/Jerusalem", [120, 120, 120, 180, 180, 180, 180, 180, 180, 180, 120, 120]],
+  ["Australia/Lord_Howe", [660, 660, 660, 630, 630, 630, 630, 630, 630, 660, 660, 660]],
+  ["Europe/Lisbon", [0, 0, 0, 60, 60, 60, 60, 60, 60, 60, 0, 0]],
+  ["Pacific/Chatham", [825, 825, 825, 765, 765, 765, 765, 765, 765, 825, 825, 825]]
+]);
+const NON_DST_TIMEZONES = /* @__PURE__ */ new Map([
+  ["Africa/Lagos", 60],
+  ["America/Phoenix", -420],
+  ["America/Sao_Paulo", -180],
+  ["Asia/Kabul", 270],
+  ["Asia/Tokyo", 540],
+  ["Australia/Eucla", 525]
+]);
+export {
+  DST_TIMEZONES,
+  NON_DST_TIMEZONES,
+  TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE
+};

package/dist/es/core/Localization/datetime/restamper/testing/helpers.js

@@ -0,0 +1,27 @@
+import { TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE } from "./fixtures.js";
+import { getGMTSuffixForTimezoneOffset, getSystemTimezoneGMTSuffixFromTimezoneOffsets } from "../utils.js";
+import { g as globalExpect } from "../../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+const getPastDatesMapForEachMonthInYear = (restamper) => {
+  const pastDate = new Date(TIMEZONE_PAST_DATES_TEST_ORIGIN_DATE);
+  return new Map(
+    Array.from({ length: 12 }, () => {
+      pastDate.setMonth(pastDate.getMonth() + 1);
+      return [pastDate.toISOString(), restamper(pastDate)];
+    })
+  );
+};
+const runTimezoneTestRoutine = (timezoneOffset, systemTimezoneResult, result) => {
+  if (result.formatted !== void 0) {
+    const TimezoneGMTSuffix = getGMTSuffixForTimezoneOffset(timezoneOffset);
+    globalExpect(result.formatted).toMatch(TimezoneGMTSuffix);
+  }
+  if (systemTimezoneResult.formatted !== void 0) {
+    const SystemTimezoneGMTSuffix = getSystemTimezoneGMTSuffixFromTimezoneOffsets(timezoneOffset, result.offset);
+    globalExpect(systemTimezoneResult.formatted).toMatch(SystemTimezoneGMTSuffix);
+  }
+  globalExpect(result.timestamp).toBe(systemTimezoneResult.timestamp);
+};
+export {
+  getPastDatesMapForEachMonthInYear,
+  runTimezoneTestRoutine
+};

package/dist/es/core/Localization/datetime/restamper/utils.js

@@ -1,30 +1,48 @@
-import { mod as r } from "../../../../utils/common/index.js";
-import { SYSTEM_TIMEZONE_FORMATTER as c, REGEX_TZ_OFFSET as i } from "./constants.js";
-import { EMPTY_ARRAY as E } from "../../../../utils/common/constants.js";
-const p = /\+(?=-)|([+-]00:00)/g, O = new RegExp("(?<=^\\D?)(\\d)$"), S = ([t, e]) => (Math.abs(t * 60) + e) * (t < 0 ? -1 : 1), _ = (t) => Object.freeze([
-  Math.floor(t / 60),
+import { mod } from "../../../../utils/common/index.js";
+import { REGEX_TZ_OFFSET, SYSTEM_TIMEZONE_FORMATTER } from "./constants.js";
+import { EMPTY_ARRAY } from "../../../../utils/common/constants.js";
+const REGEX_GMT_OFFSET_UNWANTED_SUBSTRINGS = /\+(?=-)|([+-]00:00)/g;
+const REGEX_TZ_SINGLE_DIGIT_OFFSET = new RegExp("(?<=^\\D?)(\\d)$");
+const computeTimezoneOffsetInMinutes = ([offsetHours, offsetMinutes]) => (Math.abs(offsetHours * 60) + offsetMinutes) * (offsetHours < 0 ? -1 : 1);
+const computeTimezoneOffsetsFromMinutes = (timezoneOffsetInMinutes) => Object.freeze([
+  Math.floor(timezoneOffsetInMinutes / 60),
   // offset hours
-  r(t, 60)
+  mod(timezoneOffsetInMinutes, 60)
   // offset minutes
-]), M = (t) => parseInt(t, 10) || 0, g = (t) => `GMT+${_(t).map((o) => `${o}`.replace(O, "0$1")).join(":")}`.replace(p, ""), T = (t) => {
-  var s;
-  const e = ((s = t == null ? void 0 : t.match(i)) == null ? void 0 : s[0].split(":", 2).map(M)) ?? E;
-  return S(e.concat(0, 0).slice(0, 2));
-}, F = (t, e = c) => {
-  var n;
-  const s = T((n = c) == null ? void 0 : n.format(t));
-  return T(e == null ? void 0 : e.format(t)) - s;
-}, m = (t, e, s = 1) => {
-  const { offset: o, timestamp: n } = t(e), f = new Date(n);
-  return f.setMinutes(f.getMinutes() - o * s);
-}, R = (t, e) => m(t, e, 1), z = (t, e) => m(t, e, -1);
+]);
+const parseTimezoneOffset = (offset) => parseInt(offset, 10) || 0;
+const getGMTSuffixForTimezoneOffset = (timezoneOffset) => {
+  const offsets = computeTimezoneOffsetsFromMinutes(timezoneOffset);
+  const offsetString = offsets.map((offset) => `${offset}`.replace(REGEX_TZ_SINGLE_DIGIT_OFFSET, "0$1")).join(":");
+  return `GMT+${offsetString}`.replace(REGEX_GMT_OFFSET_UNWANTED_SUBSTRINGS, "");
+};
+const getSystemTimezoneGMTSuffixFromTimezoneOffsets = (timezoneOffset, timezoneOffsetRelativeToSystem) => getGMTSuffixForTimezoneOffset(timezoneOffset - timezoneOffsetRelativeToSystem);
+const getTimezoneOffsetFromFormattedDateString = (date) => {
+  var _a;
+  const offsets = ((_a = date == null ? void 0 : date.match(REGEX_TZ_OFFSET)) == null ? void 0 : _a[0].split(":", 2).map(parseTimezoneOffset)) ?? EMPTY_ARRAY;
+  return computeTimezoneOffsetInMinutes(offsets.concat(0, 0).slice(0, 2));
+};
+const getTimezoneOffsetForTimestamp = (timestamp, timezoneFormatter = SYSTEM_TIMEZONE_FORMATTER) => {
+  var _a;
+  const systemOffset = getTimezoneOffsetFromFormattedDateString((_a = SYSTEM_TIMEZONE_FORMATTER) == null ? void 0 : _a.format(timestamp));
+  const timezoneOffset = getTimezoneOffsetFromFormattedDateString(timezoneFormatter == null ? void 0 : timezoneFormatter.format(timestamp));
+  return timezoneOffset - systemOffset;
+};
+const restamp = (restamper, time, direction = 1) => {
+  const { offset, timestamp } = restamper(time);
+  const date = new Date(timestamp);
+  return date.setMinutes(date.getMinutes() - offset * direction);
+};
+const systemToTimezone = (restamper, time) => restamp(restamper, time, 1);
+const timezoneToSystem = (restamper, time) => restamp(restamper, time, -1);
 export {
-  S as computeTimezoneOffsetInMinutes,
-  _ as computeTimezoneOffsetsFromMinutes,
-  g as getGMTSuffixForTimezoneOffset,
-  F as getTimezoneOffsetForTimestamp,
-  T as getTimezoneOffsetFromFormattedDateString,
-  M as parseTimezoneOffset,
-  R as systemToTimezone,
-  z as timezoneToSystem
+  computeTimezoneOffsetInMinutes,
+  computeTimezoneOffsetsFromMinutes,
+  getGMTSuffixForTimezoneOffset,
+  getSystemTimezoneGMTSuffixFromTimezoneOffsets,
+  getTimezoneOffsetForTimestamp,
+  getTimezoneOffsetFromFormattedDateString,
+  parseTimezoneOffset,
+  systemToTimezone,
+  timezoneToSystem
 };

package/dist/es/core/Localization/index.js

@@ -0,0 +1,32 @@
+import { L } from "../../../index-c88cd37e.mjs";
+import { all_locales, ar, cs_CZ, da_DK, de_DE, el_GR, en_US, es_ES, fi_FI, fr_FR, hr_HR, hu_HU, it_IT, ja_JP, ko_KR, nl_NL, no_NO, pl_PL, pt_BR, pt_PT, ro_RO, ru_RU, sk_SK, sl_SI, sv_SE, zh_CN, zh_TW } from "./translations/index.js";
+export {
+  all_locales,
+  ar,
+  cs_CZ,
+  da_DK,
+  de_DE,
+  L as default,
+  el_GR,
+  en_US,
+  es_ES,
+  fi_FI,
+  fr_FR,
+  hr_HR,
+  hu_HU,
+  it_IT,
+  ja_JP,
+  ko_KR,
+  nl_NL,
+  no_NO,
+  pl_PL,
+  pt_BR,
+  pt_PT,
+  ro_RO,
+  ru_RU,
+  sk_SK,
+  sl_SI,
+  sv_SE,
+  zh_CN,
+  zh_TW
+};

package/dist/es/core/Localization/localization-utils.js

@@ -1,33 +1,9 @@
-import { loadTranslations as i, formatLocale as a, parseLocale as l } from "./utils.js";
-import { FALLBACK_LOCALE as c } from "./constants/locale.js";
-import { EXCLUDE_PROPS as n } from "./constants/localization.js";
-import { struct as p, isFunction as s } from "../../utils/common/index.js";
-import f from "./Localization.js";
-function h() {
-  let e = this.locale, t = e, o = this.supportedLocales;
-  return p({
-    load: { value: (r) => i(e, this.preferredTranslations, r) },
-    locale: {
-      get: () => e,
-      set: (r) => {
-        t = r, e = a(r) || l(r, o) || c;
-      }
-    },
-    supportedLocales: {
-      get: () => e,
-      set(r) {
-        o = r, this.locale = t;
-      }
-    }
-  });
-}
-function O() {
-  const e = {};
-  for (const [t, o] of Object.entries(Object.getOwnPropertyDescriptors(f.prototype)))
-    n.includes(t) || (s(o.get) ? e[t] = { get: o.get.bind(this) } : s(o.value) ? e[t] = { value: o.value.bind(this) } : e[t] = { get: () => this[t] });
-  return e;
-}
+import "./utils.js";
+import "./constants/locale.js";
+import "./constants/localization.js";
+import "../../utils/common/index.js";
+import { c, g } from "../../../index-c88cd37e.mjs";
 export {
-  h as createTranslationsLoader,
-  O as getLocalizationProxyDescriptors
+  c as createTranslationsLoader,
+  g as getLocalizationProxyDescriptors
 };