@adyen/adyen-platform-experience-web 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/es/core/Services/analytics/collect-id.js

@@ -1,37 +0,0 @@
-import { httpPost } from "../requests/http.js";
-import Storage from "../../../utils/Storage.js";
-function confirmSessionDurationIsMaxFifteenMinutes(checkoutAttemptIdSession) {
-  if (!(checkoutAttemptIdSession == null ? void 0 : checkoutAttemptIdSession.id))
-    return false;
-  const fifteenMinInMs = 1e3 * 60 * 15;
-  const fifteenMinAgoTimestamp = Date.now() - fifteenMinInMs;
-  return checkoutAttemptIdSession.timestamp > fifteenMinAgoTimestamp;
-}
-const collectId = ({ loadingContext, experiments }) => {
-  let promise;
-  const options = {
-    errorLevel: "silent",
-    loadingContext,
-    path: `v2/analytics/id`
-  };
-  return () => {
-    if (promise)
-      return promise;
-    const storage = new Storage("checkout-attempt-id", window.sessionStorage);
-    const checkoutAttemptIdSession = storage.get();
-    if (checkoutAttemptIdSession && confirmSessionDurationIsMaxFifteenMinutes(checkoutAttemptIdSession)) {
-      return Promise.resolve(checkoutAttemptIdSession.id);
-    }
-    promise = httpPost(options, { experiments }).then((conversion) => {
-      if (conversion.id) {
-        storage.set({ id: conversion.id, timestamp: Date.now() });
-        return conversion.id;
-      }
-      return void 0;
-    }).catch(() => void 0);
-    return promise;
-  };
-};
-export {
-  collectId as default
-};

package/dist/es/core/Services/analytics/log-event.js

@@ -1,14 +0,0 @@
-const logEvent = (config) => (event) => {
-  const params = {
-    version: process.env.VERSION,
-    payload_version: 1,
-    platform: "web",
-    locale: config.locale,
-    ...event
-  };
-  const queryString = Object.keys(params).map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`).join("&");
-  new Image().src = `${config.loadingContext}images/analytics.png?${queryString}`;
-};
-export {
-  logEvent as default
-};

package/dist/es/core/Services/analytics/post-telemetry.js

@@ -1,22 +0,0 @@
-import { httpPost } from "../requests/http.js";
-const logTelemetry = (config) => (event) => {
-  const options = {
-    errorLevel: "silent",
-    loadingContext: config.loadingContext,
-    path: `v2/analytics/log`
-  };
-  const telemetryEvent = {
-    version: process.env.VERSION,
-    channel: "Web",
-    locale: config.locale,
-    flavor: "components",
-    userAgent: navigator.userAgent,
-    referrer: window.location.href,
-    screenWidth: window.screen.width,
-    ...event
-  };
-  return httpPost(options, telemetryEvent);
-};
-export {
-  logTelemetry as default
-};

package/dist/es/core/Services/data-set.js

@@ -1 +0,0 @@
-

package/dist/es/core/Services/get-dataset.js

@@ -1,13 +0,0 @@
-import { httpGet } from "./requests/http.js";
-function getDataset(name, loadingContext, locale) {
-  const options = {
-    loadingContext: loadingContext ?? "",
-    errorLevel: "warn",
-    errorMessage: `Dataset ${name} is not available`,
-    path: locale ? `datasets/${name}/${locale}.json` : `datasets/${name}.json`
-  };
-  return httpGet(options);
-}
-export {
-  getDataset as default
-};

package/dist/es/core/Services/requests/endpoints.js

@@ -1,9 +0,0 @@
-const API_ENDPOINTS = {
-  transactions: {
-    getTransactions: "/transactions",
-    getTransactionsById: (id) => `/transactions/${id}`
-  }
-};
-export {
-  API_ENDPOINTS
-};

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

@@ -1,4 +0,0 @@
-import { default as default2 } from "./Session.js";
-export {
-  default2 as default
-};

package/dist/es/core/index.js

@@ -1,36 +0,0 @@
-import { default as default2 } from "./core.js";
-import "./Localization/datetime/restamper/restamper.js";
-import "./Localization/datetime/restamper/constants.js";
-import "../utils/common/index.js";
-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 "./Localization/translations/index.js";
-import "../utils/watchable/index.js";
-export {
-  default2 as Core,
-  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
-};

package/dist/es/hooks/element/useIdentifierString.js

@@ -1,61 +0,0 @@
-import { _, h, T, F, y } from "../../../hooks.module-8565d716.mjs";
-import { isReflex } from "../useReflex/core/utils.js";
-import { createReflexContainer } from "../useReflex/core/reflex.js";
-const EXCESS_SPACE_REGEX = /^\s+|\s+(?=\s|$)/g;
-const uniqueFlatten = (items, uniqueItems = /* @__PURE__ */ new Set()) => {
-  for (const item of items) {
-    if (!Array.isArray(item)) {
-      uniqueItems.delete(item);
-      uniqueItems.add(item);
-    } else
-      uniqueFlatten(item, uniqueItems);
-  }
-  return uniqueItems;
-};
-const useIdentifierString = (...refs) => {
-  const $id = _("");
-  const $cleanups = _([]);
-  const $cachedRefs = _([]);
-  const [shouldRecomputeID, setShouldRecomputeID] = h(true);
-  const reflexAction = T(() => setShouldRecomputeID(true), [setShouldRecomputeID]);
-  const $refs = F(() => {
-    while (true) {
-      const cleanup = $cleanups.current.pop();
-      if (!cleanup)
-        break;
-      cleanup();
-    }
-    const $refs2 = [];
-    for (const ref of uniqueFlatten(refs)) {
-      if (!ref)
-        continue;
-      if (isReflex(ref)) {
-        const container = createReflexContainer();
-        $cleanups.current.push(container.release);
-        container.update(reflexAction, ref);
-      }
-      $refs2.push(ref);
-    }
-    return $refs2;
-  }, [reflexAction, ...refs]);
-  y(() => {
-    var _a;
-    if (shouldRecomputeID || $refs !== $cachedRefs.current) {
-      const IDS = /* @__PURE__ */ new Set();
-      for (const ref of $refs) {
-        const id = ((_a = ref == null ? void 0 : ref.current) == null ? void 0 : _a.id) ?? "";
-        if (!id)
-          continue;
-        IDS.delete(id);
-        IDS.add(id);
-      }
-      $id.current = [...IDS].join(" ").replace(EXCESS_SPACE_REGEX, "");
-      $cachedRefs.current = $refs;
-      setShouldRecomputeID(false);
-    }
-  }, [$refs, shouldRecomputeID, setShouldRecomputeID]);
-  return $id.current;
-};
-export {
-  useIdentifierString as default
-};

package/dist/es/hooks/useBooleanState/index.js

@@ -1,4 +0,0 @@
-import { default as default2 } from "./useBooleanState.js";
-export {
-  default2 as default
-};

package/dist/es/hooks/useCommitAction/index.js

@@ -1,6 +0,0 @@
-import { default as default2 } from "./useCommitAction.js";
-import { C } from "../../../types-e6a6a3ff.mjs";
-export {
-  C as CommitAction,
-  default2 as default
-};

package/dist/es/hooks/useDefinedValue/index.js

@@ -1,4 +0,0 @@
-import { default as default2 } from "./useDefinedValue.js";
-export {
-  default2 as default
-};

package/dist/es/hooks/useDefinedValue/useDefinedValue.js

@@ -1,16 +0,0 @@
-import { _, F } from "../../../hooks.module-8565d716.mjs";
-import { isFunction } from "../../utils/common/index.js";
-const useDefinedValue = (fallback, value) => {
-  const rawValueRef = _(value ?? null);
-  const fallbackFactory = F(() => isFunction(fallback) ? fallback : () => fallback, [fallback]);
-  const definedValue = F(() => {
-    const currentValue = value ?? null;
-    if (rawValueRef.current !== currentValue)
-      rawValueRef.current = currentValue;
-    return rawValueRef.current;
-  }, [value]);
-  return F(() => definedValue ?? fallbackFactory(), [definedValue]);
-};
-export {
-  useDefinedValue as default
-};

package/dist/es/hooks/useMounted/index.js

@@ -1,4 +0,0 @@
-import { default as default2 } from "./useMounted.js";
-export {
-  default2 as default
-};

package/dist/es/hooks/useReactiveState/index.js

@@ -1,4 +0,0 @@
-import { default as default2 } from "./useReactiveState.js";
-export {
-  default2 as default
-};

package/dist/es/hooks/useReflex/core/reflex.test.js

@@ -1,170 +0,0 @@
-import { createIsolatedFauxReflex, createReflexContainer } from "./reflex.js";
-import { REF } from "../constants.js";
-import { isReflex, unwrap } from "./utils.js";
-import { d as describe, b as beforeEach, t as test, g as globalExpect, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-const __reflexAssignmentUpdateTests__ = (reflex, action) => {
-  let previous = reflex.current;
-  let calledTimes = action.mock.calls.length;
-  reflex.current = 10;
-  globalExpect(reflex.current).toBe(10);
-  globalExpect(action).toBeCalledWith(10, previous);
-  globalExpect(action).toBeCalledTimes(++calledTimes);
-  reflex.current = previous = reflex[REF].current;
-  globalExpect(reflex.current).toBe(previous);
-  globalExpect(action).toBeCalledTimes(calledTimes);
-};
-const __reflexInvocationUpdateTests__ = (reflex, action) => {
-  let previous = reflex.current;
-  let calledTimes = action.mock.calls.length;
-  reflex(5);
-  globalExpect(reflex.current).toBe(5);
-  globalExpect(action).toBeCalledWith(5, previous);
-  globalExpect(action).toBeCalledTimes(++calledTimes);
-  reflex(previous = reflex.current);
-  globalExpect(reflex.current).toBe(previous);
-  globalExpect(action).toBeCalledTimes(calledTimes);
-};
-const __reflexInstanceUpdateTests__ = (reflex, action) => {
-  __reflexAssignmentUpdateTests__(reflex, action);
-  __reflexInvocationUpdateTests__(reflex, action);
-};
-describe("createIsolatedFauxReflex", () => {
-  beforeEach((context) => {
-    context.action = vi.fn(() => {
-    });
-    context.reflex = createIsolatedFauxReflex(context.action);
-  });
-  test("should have expected structure + behavior", ({ action, reflex }) => {
-    globalExpect(reflex).toBeTypeOf("function");
-    globalExpect(isReflex(reflex)).toBe(false);
-    globalExpect(unwrap(reflex)).toBe(reflex);
-    globalExpect(reflex[REF]).toBe(reflex);
-    globalExpect(reflex.current).toBeUndefined;
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBe(1);
-    globalExpect(reflex.actions.get(console.log)).toBeUndefined;
-  });
-  test("should update instance and trigger reflex action correctly", ({ action, reflex }) => __reflexInstanceUpdateTests__(reflex, action));
-});
-describe("createReflexContainer", () => {
-  beforeEach((context) => {
-    context.action = vi.fn(() => {
-    });
-    context.container = createReflexContainer();
-  });
-  test("should have expected initial shape", ({ container }) => {
-    globalExpect(container).toHaveProperty("action");
-    globalExpect(container).toHaveProperty("reflex");
-    globalExpect(container.action).toBeUndefined;
-    globalExpect(container.reflex).toBeUndefined;
-  });
-  test("should throw error on attempt to update without reflex action", ({ container }) => {
-    globalExpect(() => {
-      container.update(void 0);
-    }).toThrowError();
-  });
-  test("should still access reflex and action even after release", ({ action, container }) => {
-    container.update(action);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).not.toBeUndefined;
-    let reflex = container.reflex;
-    container.release();
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).toBe(reflex);
-    container.update(action);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).not.toBeUndefined;
-    globalExpect(container.reflex).not.toBe(reflex);
-  });
-  test("should update correctly without a root reflexable", ({ action, container }) => {
-    container.update(action);
-    let reflex = container.reflex;
-    globalExpect(container.action).toBe(action);
-    globalExpect(reflex).not.toBeUndefined;
-    globalExpect(reflex.current).toBeUndefined;
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBe(1);
-    __reflexInstanceUpdateTests__(reflex, action);
-    let previous = reflex.current;
-    container.update(action);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex.current).toBe(previous);
-    const action2 = vi.fn(() => {
-    });
-    container.update(action2);
-    globalExpect(container.action).toBe(action2);
-    globalExpect(container.action).not.toBe(action);
-    globalExpect(container.reflex).not.toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex.current).toBeUndefined;
-    __reflexInstanceUpdateTests__(reflex, action2);
-  });
-  test("should update correctly with root reflexable", ({ action, container }) => {
-    const reflexable = { current: 5 };
-    container.update(action, reflexable);
-    let reflex = container.reflex;
-    globalExpect(container.action).toBe(action);
-    globalExpect(reflex).not.toBeUndefined;
-    globalExpect(isReflex(reflex)).toBe(true);
-    globalExpect(unwrap(reflex)).toBe(reflexable);
-    globalExpect(reflex.current).toBe(reflexable.current);
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBe(1);
-    __reflexInstanceUpdateTests__(reflex, action);
-    let previous = reflex.current;
-    container.update(action, reflexable);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex.current).toBe(previous);
-    container.update(action, reflex);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex.current).toBe(previous);
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBe(1);
-    const reflexable2 = () => {
-    };
-    container.update(action, reflexable2);
-    globalExpect(container.action).toBe(action);
-    globalExpect(container.reflex).not.toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex).not.toBeUndefined;
-    globalExpect(isReflex(reflex)).toBe(true);
-    globalExpect(unwrap(reflex)).toBe(reflexable2);
-    globalExpect(reflex.current).toBeUndefined;
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBe(1);
-    __reflexInvocationUpdateTests__(reflex, action);
-    const action2 = vi.fn(() => {
-    });
-    container.update(action2, reflexable2);
-    globalExpect(container.action).not.toBe(action);
-    globalExpect(container.action).toBe(action2);
-    globalExpect(container.reflex).toBe(reflex);
-    reflex = container.reflex;
-    reflex(previous = 100);
-    globalExpect(reflex).not.toBeUndefined;
-    globalExpect(isReflex(reflex)).toBe(true);
-    globalExpect(unwrap(reflex)).toBe(reflexable2);
-    globalExpect(reflex.current).toBe(previous);
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action)).toBeUndefined;
-    globalExpect(reflex.actions.get(action2)).toBe(1);
-    __reflexInvocationUpdateTests__(reflex, action2);
-    container.update(action2, null);
-    globalExpect(container.action).toBe(action2);
-    globalExpect(container.reflex).not.toBe(reflex);
-    reflex = container.reflex;
-    globalExpect(reflex).not.toBeUndefined;
-    globalExpect(isReflex(reflex)).toBe(false);
-    globalExpect(unwrap(reflex)).toBe(reflex);
-    globalExpect(reflex.current).toBeUndefined;
-    globalExpect(reflex.actions.size).toBe(1);
-    globalExpect(reflex.actions.get(action2)).toBe(1);
-    __reflexInstanceUpdateTests__(reflex, action2);
-  });
-});

package/dist/es/hooks/useReflex/core/registry.test.js

@@ -1,114 +0,0 @@
-import { REF } from "../constants.js";
-import { createReflexRegister } from "./registry.js";
-import { isReflex } from "./utils.js";
-import { d as describe, b as beforeEach, t as test, g as globalExpect, v as vi } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-describe("createReflexRegister", () => {
-  beforeEach((context) => {
-    context.action = vi.fn(() => {
-    });
-    context.ref = { current: 5 };
-    context.register = createReflexRegister();
-  });
-  test("should throw error if reflex action is missing for unregistered ref", ({ ref, register }) => {
-    globalExpect(() => register.bind(ref)).toThrowError();
-  });
-  test("should throw error if trying to unbind action for unregistered ref", ({ action, ref, register }) => {
-    globalExpect(() => register.unbind(ref, action)).toThrowError();
-    const { actions } = register.bind(ref, action);
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBe(1);
-    register.unbind(ref, action);
-    globalExpect(actions.size).toBe(0);
-    globalExpect(actions.get(action)).toBeUndefined;
-    globalExpect(() => register.unbind(ref, action)).toThrowError();
-  });
-  test("should register unknown ref if reflex action is provided", ({ action, ref, register }) => {
-    const reflex = register.bind(ref, action);
-    const { actions } = reflex;
-    globalExpect(isReflex(reflex)).toBe(true);
-    globalExpect(reflex.current).toBe(ref.current);
-    globalExpect(reflex[REF]).toBe(ref);
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBe(1);
-    globalExpect(action).toBeCalledTimes(0);
-    let previous = ref.current;
-    reflex.current = 10;
-    globalExpect(ref.current).toBe(10);
-    globalExpect(ref.current).toBe(reflex.current);
-    globalExpect(action).toBeCalledWith(10, previous);
-    globalExpect(action).toBeCalledTimes(1);
-    reflex.current = previous = ref.current;
-    globalExpect(ref.current).toBe(previous);
-    globalExpect(ref.current).toBe(reflex.current);
-    globalExpect(action).toBeCalledTimes(1);
-    reflex(5);
-    globalExpect(ref.current).toBe(5);
-    globalExpect(ref.current).toBe(reflex.current);
-    globalExpect(action).toBeCalledWith(5, previous);
-    globalExpect(action).toBeCalledTimes(2);
-    reflex(previous = ref.current);
-    globalExpect(ref.current).toBe(previous);
-    globalExpect(ref.current).toBe(reflex.current);
-    globalExpect(action).toBeCalledTimes(2);
-  });
-  test("should increase and decrease binding count for reflex action", ({ action, ref, register }) => {
-    let { actions } = register.bind(ref, action);
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBe(1);
-    ({ actions } = register.bind(ref, action));
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBe(2);
-    register.bind(ref, action);
-    register.bind(ref, action);
-    register.bind(ref, console.log);
-    globalExpect(actions.size).toBe(2);
-    globalExpect(actions.get(action)).toBe(4);
-    globalExpect(actions.get(console.log)).toBe(1);
-    register.unbind(ref, action);
-    register.unbind(ref, action);
-    register.unbind(ref, action);
-    globalExpect(actions.size).toBe(2);
-    globalExpect(actions.get(action)).toBe(1);
-    register.unbind(ref, action);
-    register.bind(ref, console.log);
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBeUndefined;
-    globalExpect(actions.get(console.log)).toBe(2);
-    register.unbind(ref, console.log);
-    register.unbind(ref, console.log);
-    globalExpect(actions.size).toBe(0);
-    globalExpect(actions.get(console.log)).toBeUndefined;
-    globalExpect(() => register.bind(ref)).toThrowError();
-  });
-  test("should trigger reflex action once regardless of binding count", ({ action, ref, register }) => {
-    register.bind(ref, action);
-    register.bind(ref, action);
-    register.bind(ref, action);
-    const reflex = register.bind(ref);
-    const { actions } = reflex;
-    globalExpect(actions.size).toBe(1);
-    globalExpect(actions.get(action)).toBe(3);
-    let previous = ref.current;
-    reflex.current = 10;
-    globalExpect(action).toBeCalledWith(10, previous);
-    globalExpect(action).toBeCalledTimes(1);
-    globalExpect(actions.get(action)).toBe(3);
-    previous = ref.current;
-    reflex(5);
-    globalExpect(action).toBeCalledWith(5, previous);
-    globalExpect(action).toBeCalledTimes(2);
-    globalExpect(actions.get(action)).toBe(3);
-    register.unbind(ref, action);
-    register.unbind(ref, action);
-    register.unbind(ref, action);
-    previous = ref.current;
-    reflex(10);
-    globalExpect(ref.current).not.toBe(10);
-    globalExpect(ref.current).toBe(previous);
-    globalExpect(ref.current).toBe(reflex.current);
-    globalExpect(actions.size).toBe(0);
-    globalExpect(action).toBeCalledTimes(2);
-    globalExpect(actions.get(action)).toBeUndefined;
-    globalExpect(() => register.bind(ref)).toThrowError();
-  });
-});

package/dist/es/hooks/useReflex/core/utils.test.js

@@ -1,59 +0,0 @@
-import { REF } from "../constants.js";
-import { assertReflexAction, isReflex, unwrap } from "./utils.js";
-import { d as describe, t as test, g as globalExpect } from "../../../../vendor-vi.a3ff54b1-5e924357.mjs";
-describe("assertReflexAction", () => {
-  test("should throw for non-callable", () => {
-    globalExpect(() => assertReflexAction()).toThrowError();
-    globalExpect(() => assertReflexAction({})).toThrowError();
-    globalExpect(() => assertReflexAction([])).toThrowError();
-    globalExpect(() => assertReflexAction(null)).toThrowError();
-    globalExpect(() => assertReflexAction("hello")).toThrowError();
-  });
-  test("should not throw for callable", () => {
-    globalExpect(() => assertReflexAction(() => {
-    })).not.toThrowError();
-  });
-});
-describe("isReflex", () => {
-  test("should return false for refs", () => {
-    const refObject = { current: 5 };
-    const refCallback = () => {
-    };
-    globalExpect(isReflex(refObject)).toBe(false);
-    globalExpect(isReflex(refCallback)).toBe(false);
-  });
-  test("should return true for only true reflexes", () => {
-    let reflex = {};
-    globalExpect(isReflex(reflex)).toBe(false);
-    reflex = () => {
-    };
-    globalExpect(isReflex(reflex)).toBe(false);
-    reflex[REF] = { current: 5 };
-    globalExpect(isReflex(reflex)).toBe(false);
-    reflex.current = reflex[REF].current;
-    globalExpect(isReflex(reflex)).toBe(false);
-    reflex.actions = /* @__PURE__ */ new Map();
-    globalExpect(isReflex(reflex)).toBe(true);
-    reflex[REF] = reflex;
-    globalExpect(isReflex(reflex)).toBe(false);
-  });
-});
-describe("unwrap", () => {
-  test("should return refs (the same)", () => {
-    const refObject = { current: 5 };
-    const refCallback = () => {
-    };
-    globalExpect(unwrap(refObject)).toBe(refObject);
-    globalExpect(unwrap(refCallback)).toBe(refCallback);
-  });
-  test("should return root ref for true reflexes", () => {
-    const _ref = { current: 5 };
-    const reflex = () => {
-    };
-    reflex[REF] = _ref;
-    reflex.current = reflex[REF].current;
-    reflex.actions = /* @__PURE__ */ new Map();
-    globalExpect(unwrap(reflex)).toBe(_ref);
-    globalExpect(unwrap(reflex).current).toBe(_ref.current);
-  });
-});

package/dist/es/hooks/useReflex/index.js

@@ -1,8 +0,0 @@
-import { default as default2 } from "./hooks/useReflex.js";
-import { MissingReflexActionError, ReflexError, UnknownRefError } from "./errors.js";
-export {
-  MissingReflexActionError,
-  ReflexError,
-  UnknownRefError,
-  default2 as default
-};

package/dist/es/utils/Storage.js

@@ -1,35 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class Storage {
-  constructor(key, storage = window.localStorage) {
-    __publicField(this, "prefix", "adyen-pe-");
-    __publicField(this, "key");
-    __publicField(this, "storage");
-    this.storage = storage;
-    this.key = this.prefix + key;
-  }
-  get() {
-    const storageItem = this.storage.getItem(this.key);
-    if (storageItem) {
-      try {
-        return JSON.parse(storageItem);
-      } catch (err) {
-        return null;
-      }
-    }
-    return null;
-  }
-  set(value) {
-    this.storage.setItem(this.key, JSON.stringify(value));
-  }
-  remove() {
-    this.storage.removeItem(this.key);
-  }
-}
-export {
-  Storage as default
-};

package/dist/es/utils/Validator/ValidationRuleResult.js

@@ -1,28 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-class ValidationRuleResult {
-  constructor(rule, value, mode, context) {
-    __publicField(this, "shouldValidate");
-    __publicField(this, "isValid");
-    __publicField(this, "errorMessage");
-    this.shouldValidate = mode ? rule.modes.includes(mode) : false;
-    this.isValid = rule.validate(value, context);
-    this.errorMessage = rule.errorMessage ?? "";
-  }
-  /**
-   * Whether the validation is considered an error.
-   * A field is only considered to be an error if the validation rule applies to the current mode i.e. 'blur' or 'input'.
-   * Also, if a validation function returns a null value e.g. when the field is empty, then the field will not be considered to be in error
-   * unless the whole form is being validated
-   */
-  hasError(isValidatingForm = false) {
-    return isValidatingForm ? !this.isValid && this.shouldValidate : this.isValid != null && !this.isValid && this.shouldValidate;
-  }
-}
-export {
-  ValidationRuleResult
-};