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

package/dist/es/hooks/useModalDetails/useModalDetails.js

@@ -1,35 +1,44 @@
-import { useState as f, useCallback as u, useMemo as h } from "../../external/preact/hooks/dist/hooks.module.js";
-import { hasCallback as k } from "./types.js";
-function o(l) {
-  const [n, r] = f(null), d = u(
-    (e) => {
-      var c;
-      return e && k(l[e.selection.type]) ? {
-        callback: (c = l == null ? void 0 : l[e.selection.type]) != null && c.callback ? (a) => {
-          var s, t;
-          return (t = (s = l[e.selection.type]) == null ? void 0 : s.callback) == null ? void 0 : t.call(s, { showModal: () => r(e), ...a });
-        } : () => {
-          var a;
-          return ((a = l[e.selection.type]) == null ? void 0 : a.showDetails) && r(e);
-        }
-      } : (r(e), {});
+import { h, T, F } from "../../../hooks.module-8565d716.mjs";
+function hasCallback(options) {
+  return "callback" in options;
+}
+function useModalDetails(options) {
+  const [selectedDetail, setSelectedDetail] = h(null);
+  const updateDetails = T(
+    (state) => {
+      var _a;
+      if (state && hasCallback(options[state.selection.type])) {
+        return {
+          callback: ((_a = options == null ? void 0 : options[state.selection.type]) == null ? void 0 : _a.callback) ? (args) => {
+            var _a2, _b;
+            return (_b = (_a2 = options[state.selection.type]) == null ? void 0 : _a2.callback) == null ? void 0 : _b.call(_a2, { showModal: () => setSelectedDetail(state), ...args });
+          } : () => {
+            var _a2;
+            return ((_a2 = options[state.selection.type]) == null ? void 0 : _a2.showDetails) && setSelectedDetail(state);
+          }
+        };
+      }
+      setSelectedDetail(state);
+      return {};
     },
-    [l]
-  ), i = u(() => r(null), []), b = h(() => {
-    const e = {};
-    for (const c in l) {
-      const a = l[c];
-      e[c] = !(a != null && a.showDetails) || !!a.callback;
+    [options]
+  );
+  const resetDetails = T(() => setSelectedDetail(null), []);
+  const detailsToShow = F(() => {
+    const details = {};
+    for (const detail in options) {
+      const selectedDetail2 = options[detail];
+      details[detail] = !(selectedDetail2 == null ? void 0 : selectedDetail2.showDetails) || !!selectedDetail2.callback;
     }
-    return e;
-  }, [l]);
+    return details;
+  }, [options]);
   return {
-    selectedDetail: n,
-    updateDetails: d,
-    detailsToShow: b,
-    resetDetails: i
+    selectedDetail,
+    updateDetails,
+    detailsToShow,
+    resetDetails
   };
 }
 export {
-  o as default
+  useModalDetails as default
 };

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

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

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

@@ -1,10 +1,16 @@
-import { useRef as u, useMemo as n, useEffect as r } from "../../external/preact/hooks/dist/hooks.module.js";
-const o = (s) => {
-  const e = u(!1), t = n(() => s, [s]);
-  return r(() => (e.current = !0, () => {
-    e.current = !1, t && t();
-  }), [t]), e;
-}, c = o;
+import { _, F, p } from "../../../hooks.module-8565d716.mjs";
+const useMounted = (beforeUnmount) => {
+  const $mounted = _(false);
+  const unmount = F(() => beforeUnmount, [beforeUnmount]);
+  p(() => {
+    $mounted.current = true;
+    return () => {
+      $mounted.current = false;
+      unmount && unmount();
+    };
+  }, [unmount]);
+  return $mounted;
+};
 export {
-  c as default
+  useMounted as default
 };

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

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

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

@@ -1,35 +1,61 @@
-import { useRef as o, useMemo as h, useReducer as R, useEffect as T } from "../../external/preact/hooks/dist/hooks.module.js";
-import w from "../useMounted/useMounted.js";
-import { EMPTY_OBJECT as F } from "../../utils/common/constants.js";
-const P = (a = F, f = !0) => {
-  const n = o(f), e = o(Object.freeze({ ...a })), p = o(new Set(Object.keys(e.current))), u = o(/* @__PURE__ */ new Set()), S = w(), [d, j] = h(() => {
-    const r = (c) => {
-      S.current && z(c);
+import { _, F, s, p } from "../../../hooks.module-8565d716.mjs";
+import "../../utils/common/index.js";
+import useMounted from "../useMounted/useMounted.js";
+import { EMPTY_OBJECT } from "../../utils/common/constants.js";
+const useReactiveState = (params = EMPTY_OBJECT, initialStateSameAsDefault = true) => {
+  const $hasDefaultState = _(initialStateSameAsDefault);
+  const $defaultState = _(Object.freeze({ ...params }));
+  const $stateParams = _(new Set(Object.keys($defaultState.current)));
+  const $changedParams = _(/* @__PURE__ */ new Set());
+  const $mounted = useMounted();
+  const [resetState, updateState] = F(() => {
+    const requestStateUpdate = (stateUpdateRequest) => {
+      if (!$mounted.current)
+        return;
+      dispatch(stateUpdateRequest);
     };
     return [
-      () => r("reset"),
-      (c) => r(c)
+      () => requestStateUpdate("reset"),
+      (stateUpdateRequest) => requestStateUpdate(stateUpdateRequest)
     ];
-  }, [S]), [$, z] = R((r, c) => {
-    if (c === "reset")
-      return u.current.clear(), e.current;
-    const s = { ...c }, i = [0];
-    Object.keys(s).forEach((t, O) => {
-      if (!p.current.has(t))
+  }, [$mounted]);
+  const [state, dispatch] = s((state2, stateUpdateRequest) => {
+    if (stateUpdateRequest === "reset") {
+      $changedParams.current.clear();
+      return $defaultState.current;
+    }
+    const stateUpdate = { ...stateUpdateRequest };
+    const stateUpdateFlags = [0];
+    Object.keys(stateUpdate).forEach((key, index) => {
+      if (!$stateParams.current.has(key))
         return;
-      const g = r[t] ?? void 0, b = e.current[t] ?? void 0, l = s[t] ?? b;
-      if (l === g)
+      const currentValue = state2[key] ?? void 0;
+      const defaultValue = $defaultState.current[key] ?? void 0;
+      const updateValue = stateUpdate[key] ?? defaultValue;
+      if (updateValue === currentValue)
         return;
-      const v = Math.floor(O / 32), M = 1 << O % 32;
-      s[t] = l, i[v] |= M, u.current[l === b ? "delete" : "add"](t);
+      const flagIndex = Math.floor(index / 32);
+      const updateFlag = 1 << index % 32;
+      stateUpdate[key] = updateValue;
+      stateUpdateFlags[flagIndex] |= updateFlag;
+      $changedParams.current[updateValue === defaultValue ? "delete" : "add"](key);
     });
-    const m = i.some((t) => t) ? n.current && u.current.size === 0 ? e.current : Object.freeze({ ...r, ...s }) : r;
-    return n.current || (e.current = m, n.current = !0), m;
-  }, e.current), E = h(() => !!u.current.size, []);
-  return T(() => {
-    e.current = Object.freeze({ ...a }), p.current = new Set(Object.keys(e.current)), n.current = f, d();
-  }, [f, a, d]), { canResetState: E, defaultState: e.current, resetState: d, state: $, updateState: j };
-}, x = P;
+    const STATE = stateUpdateFlags.some((flag) => flag) ? $hasDefaultState.current && $changedParams.current.size === 0 ? $defaultState.current : Object.freeze({ ...state2, ...stateUpdate }) : state2;
+    if (!$hasDefaultState.current) {
+      $defaultState.current = STATE;
+      $hasDefaultState.current = true;
+    }
+    return STATE;
+  }, $defaultState.current);
+  const canResetState = F(() => !!$changedParams.current.size, []);
+  p(() => {
+    $defaultState.current = Object.freeze({ ...params });
+    $stateParams.current = new Set(Object.keys($defaultState.current));
+    $hasDefaultState.current = initialStateSameAsDefault;
+    resetState();
+  }, [initialStateSameAsDefault, params, resetState]);
+  return { canResetState, defaultState: $defaultState.current, resetState, state, updateState };
+};
 export {
-  x as default
+  useReactiveState as default
 };

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

@@ -1,4 +1,4 @@
-const o = Symbol("_ref");
+const REF = Symbol("_ref");
 export {
-  o as REF
+  REF
 };

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

@@ -1,66 +1,85 @@
-import { REF as _ } from "../constants.js";
-import i from "./registry.js";
-import { assertReflexAction as d, unwrap as c } from "./utils.js";
-import { struct as p, sameValue as x } from "../../../utils/common/index.js";
-const m = (r) => {
-  d(r);
-  const e = new WeakMap([[r, 1]]), t = (u) => {
-    if (x(n, u))
+import { REF } from "../constants.js";
+import $registry from "./registry.js";
+import { assertReflexAction, unwrap } from "./utils.js";
+import { struct, sameValue } from "../../../utils/common/index.js";
+const createIsolatedFauxReflex = (action) => {
+  assertReflexAction(action);
+  const $actions = new WeakMap([[action, 1]]);
+  const reflex = (instance) => {
+    if (sameValue(_current, instance))
       return;
-    const s = n;
-    r(n = u, s);
+    const previous = _current;
+    action(_current = instance, previous);
   };
-  let n = null;
-  return Object.defineProperties(t, {
-    [_]: { value: t },
+  let _current = null;
+  return Object.defineProperties(reflex, {
+    [REF]: { value: reflex },
     actions: {
-      value: p({
-        get: { value: e.get.bind(e) },
+      value: struct({
+        get: { value: $actions.get.bind($actions) },
         size: { value: 1 }
       })
     },
     current: {
-      get: () => n,
-      set: t
+      get: () => _current,
+      set: reflex
     }
   });
-}, A = () => {
-  let r, e = null, t, n = !1;
-  const u = (l) => {
-    r = void 0, e = null, t = l, n = !1;
-  }, s = () => {
-    n || (a(), n = !0);
-  }, a = () => {
+};
+const createReflexContainer = () => {
+  let _reflex;
+  let _reflexable = null;
+  let _reflexAction;
+  let _released = false;
+  const _refreshContainer = (action) => {
+    _reflex = void 0;
+    _reflexable = null;
+    _reflexAction = action;
+    _released = false;
+  };
+  const _releaseContainer = () => {
+    if (!_released) {
+      _unbindReflexAction();
+      _released = true;
+    }
+  };
+  const _unbindReflexAction = () => {
     try {
-      if (!e)
+      if (!_reflexable)
         return;
-      i.unbind(e, t);
+      $registry.unbind(_reflexable, _reflexAction);
     } catch {
     }
   };
-  return p({
-    action: { get: () => t },
-    reflex: { get: () => r },
-    release: { value: s },
-    update: { value: (l, f) => {
-      d(l), n && u(l);
-      const o = f ?? null;
-      if (t === l && e === o) {
-        if (r)
-          return;
-      } else if (e) {
-        if (x(c(e), c(o))) {
-          r = i.bind(e, l), a(), t = l;
-          return;
-        }
-        a();
+  const _updateContainer = (action, reflexable) => {
+    assertReflexAction(action);
+    if (_released)
+      _refreshContainer(action);
+    const currentReflexable = reflexable == void 0 ? null : reflexable;
+    if (_reflexAction === action && _reflexable === currentReflexable) {
+      if (_reflex)
+        return;
+    } else if (_reflexable) {
+      if (sameValue(unwrap(_reflexable), unwrap(currentReflexable))) {
+        _reflex = $registry.bind(_reflexable, action);
+        _unbindReflexAction();
+        _reflexAction = action;
+        return;
       }
-      t = l, r = (e = o) ? i.bind(e, t) : m(t);
-    } }
+      _unbindReflexAction();
+    }
+    _reflexAction = action;
+    _reflex = (_reflexable = currentReflexable) ? $registry.bind(_reflexable, _reflexAction) : createIsolatedFauxReflex(_reflexAction);
+  };
+  return struct({
+    action: { get: () => _reflexAction },
+    reflex: { get: () => _reflex },
+    release: { value: _releaseContainer },
+    update: { value: _updateContainer }
   });
 };
 export {
-  m as createIsolatedFauxReflex,
-  A as createReflexContainer,
-  A as default
+  createIsolatedFauxReflex,
+  createReflexContainer,
+  createReflexContainer as default
 };

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

@@ -0,0 +1,170 @@
+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.js

@@ -1,65 +1,87 @@
-import { REF as v } from "../constants.js";
-import { UnknownRefError as w } from "../errors.js";
-import { unwrap as a, assertReflexAction as x } from "./utils.js";
-import { struct as b, enumerable as p, isFunction as z, sameValue as k } from "../../../utils/common/index.js";
-const A = (() => {
-  const l = (n, i) => {
-    const r = n.get(i);
-    if (!r)
-      throw new w();
-    return r;
-  }, g = (n, i, r) => {
-    let o, e;
-    const t = a(i);
+import { REF } from "../constants.js";
+import { UnknownRefError } from "../errors.js";
+import { unwrap, assertReflexAction } from "./utils.js";
+import { struct, enumerable, isFunction, sameValue } from "../../../utils/common/index.js";
+const createReflexRegister = (() => {
+  const _getRecordForRef = (register, ref) => {
+    const record = register.get(ref);
+    if (!record)
+      throw new UnknownRefError();
+    return record;
+  };
+  const _bindReflexAction = (register, reflexable, action) => {
+    let record;
+    let actions;
+    const _ref = unwrap(reflexable);
     try {
-      o = l(n, t);
+      record = _getRecordForRef(register, _ref);
     } catch {
-      x(r);
+      assertReflexAction(action);
     }
-    if (o)
-      [, e] = o;
+    if (record)
+      [, actions] = record;
     else {
-      const f = z(t), R = f ? (c) => {
-        t(s = c);
-      } : (c) => {
-        t.current = c, s = t.current;
-      }, u = (c) => {
-        if (e.size === 0)
+      const isCallbackRef = isFunction(_ref);
+      const _updateCurrentInstance = isCallbackRef ? (instance) => {
+        _ref(_current = instance);
+      } : (instance) => {
+        _ref.current = instance;
+        _current = _ref.current;
+      };
+      const reflex = (instance) => {
+        if (actions.size === 0) {
           return;
-        const d = s;
-        if (R(c), !k(s, d))
-          for (const [_] of e)
-            _(s, d);
+        }
+        const previous = _current;
+        _updateCurrentInstance(instance);
+        if (!sameValue(_current, previous)) {
+          for (const [action2] of actions) {
+            action2(_current, previous);
+          }
+        }
       };
-      let s = f ? null : t.current;
-      n.set(t, o = [u, e = /* @__PURE__ */ new Map()]), Object.defineProperties(u, {
-        [v]: { value: t },
+      let _current = isCallbackRef ? null : _ref.current;
+      register.set(_ref, record = [reflex, actions = /* @__PURE__ */ new Map()]);
+      Object.defineProperties(reflex, {
+        [REF]: { value: _ref },
         actions: {
-          value: b({
-            get: { value: e.get.bind(e) },
-            size: { get: () => e.size }
+          value: struct({
+            get: { value: actions.get.bind(actions) },
+            size: { get: () => actions.size }
           })
         },
         current: {
-          get: () => s,
-          set: f ? void 0 : u
+          get: () => _current,
+          set: isCallbackRef ? void 0 : reflex
         }
       });
     }
-    return r && e.set(r, 1 + (e.get(r) || 0)), o[0];
-  }, m = (n, i, r) => {
-    const o = a(i), [, e] = l(n, o), t = e.get(r) || 0;
-    t === 1 ? e.delete(r) : t > 1 && e.set(r, t - 1), e.size === 0 && n.delete(o);
+    if (action) {
+      actions.set(action, 1 + (actions.get(action) || 0));
+    }
+    return record[0];
+  };
+  const _unbindReflexAction = (register, reflexable, action) => {
+    const _ref = unwrap(reflexable);
+    const [, actions] = _getRecordForRef(register, _ref);
+    const bindings = actions.get(action) || 0;
+    if (bindings === 1)
+      actions.delete(action);
+    else if (bindings > 1)
+      actions.set(action, bindings - 1);
+    if (actions.size === 0)
+      register.delete(_ref);
   };
   return () => {
-    const n = /* @__PURE__ */ new WeakMap();
-    return b({
-      bind: p(g.bind(void 0, n)),
-      unbind: p(m.bind(void 0, n))
+    const _register = /* @__PURE__ */ new WeakMap();
+    return struct({
+      bind: enumerable(_bindReflexAction.bind(void 0, _register)),
+      unbind: enumerable(_unbindReflexAction.bind(void 0, _register))
     });
   };
-})(), E = A();
+})();
+const $registry = createReflexRegister();
 export {
-  A as createReflexRegister,
-  E as default
+  createReflexRegister,
+  $registry as default
 };