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

package/dist/es/utils/useForm/reducer.js

@@ -0,0 +1,153 @@
+const omitKeys = (obj, omit) => Object.keys(obj).filter((k) => !omit.includes(k)).reduce((a, c) => {
+  a[c] = obj[c];
+  return a;
+}, {});
+const addKeys = (obj, add, initialValue, defaultData, pendingData) => add.reduce((a, c) => ({ ...a, [c]: a[c] ?? (pendingData == null ? void 0 : pendingData[c]) ?? (defaultData == null ? void 0 : defaultData[c]) ?? initialValue }), obj);
+function init({ schema, defaultData, processField, fieldProblems }) {
+  const getProcessedState = (fieldKey) => {
+    if (!defaultData[fieldKey]) {
+      return { valid: false, errors: null, data: null, fieldProblems: (fieldProblems == null ? void 0 : fieldProblems[fieldKey]) ?? null };
+    }
+    const [formattedValue, validationResult] = processField(
+      { key: fieldKey, value: defaultData[fieldKey], mode: "blur" },
+      { state: { data: defaultData } }
+    );
+    return {
+      valid: validationResult.isValid && !(fieldProblems == null ? void 0 : fieldProblems[fieldKey]) || false,
+      errors: validationResult.hasError() ? validationResult.getError() : null,
+      data: formattedValue,
+      fieldProblems: (fieldProblems == null ? void 0 : fieldProblems[fieldKey]) ?? null
+    };
+  };
+  const formData = schema.reduce(
+    (acc, fieldKey) => {
+      const { valid, errors, data, fieldProblems: fieldProblems2 } = getProcessedState(fieldKey);
+      return {
+        valid: { ...acc.valid, [fieldKey]: valid },
+        errors: { ...acc.errors, [fieldKey]: errors },
+        data: { ...acc.data, [fieldKey]: data },
+        fieldProblems: { ...acc.fieldProblems, [fieldKey]: fieldProblems2 }
+      };
+    },
+    { data: {}, valid: {}, errors: {}, fieldProblems: {} }
+  );
+  return {
+    schema,
+    data: formData.data,
+    valid: formData.valid,
+    errors: formData.errors,
+    fieldProblems: formData.fieldProblems
+  };
+}
+function getReducer(processField) {
+  return function reducer(state, { type, payload }) {
+    var _a, _b, _c, _d, _e;
+    switch (type) {
+      case "setData": {
+        return { ...state, data: { ...state.data, [payload.key]: payload.value } };
+      }
+      case "setValid": {
+        return { ...state, valid: { ...state.valid, [payload.key]: payload.value } };
+      }
+      case "setErrors": {
+        return { ...state, errors: { ...state.errors, [payload.key]: payload.value } };
+      }
+      case "setFieldProblems": {
+        return ((_a = state.schema) == null ? void 0 : _a.reduce(
+          (acc, key) => {
+            var _a2, _b2, _c2;
+            return {
+              ...acc,
+              fieldProblems: { ...state["fieldProblems"], [key]: ((_a2 = payload.fieldProblems) == null ? void 0 : _a2[key]) ?? null },
+              valid: { ...state["valid"], [key]: ((_b2 = state == null ? void 0 : state.valid) == null ? void 0 : _b2[key]) && !((_c2 = payload.fieldProblems) == null ? void 0 : _c2[key]) }
+            };
+          },
+          state
+        )) ?? state;
+      }
+      case "updateField": {
+        const [formattedValue, validation] = processField({ key: payload.key, value: payload.value, mode: payload.mode }, { state });
+        const oldValue = state.data[payload.key];
+        const fieldProblems = { ...state.fieldProblems };
+        if (oldValue !== formattedValue) {
+          fieldProblems[payload.key] = null;
+        }
+        return {
+          ...state,
+          data: { ...state["data"], [payload.key]: formattedValue },
+          errors: { ...state["errors"], [payload.key]: validation.hasError() ? validation.getError() : null },
+          valid: { ...state["valid"], [payload.key]: validation.isValid && !fieldProblems[payload.key] || false },
+          fieldProblems
+        };
+      }
+      case "mergeForm": {
+        const mergedState = {
+          ...state,
+          data: { ...state["data"], ...payload.formValue["data"] },
+          errors: { ...state["errors"], ...payload.formValue["errors"] },
+          valid: { ...state["valid"], ...payload.formValue["valid"] },
+          fieldProblems: { ...state["fieldProblems"], ...payload.formValue["fieldProblems"] }
+        };
+        if (mergedState["valid"]) {
+          mergedState.isValid = Object.values(mergedState.valid).every((isValid) => isValid);
+        }
+        return mergedState;
+      }
+      case "setSchema": {
+        const defaultState = init({
+          schema: payload.schema,
+          defaultData: payload.defaultData,
+          processField,
+          fieldProblems: payload.fieldProblems
+        });
+        const removedSchemaFields = ((_b = state.schema) == null ? void 0 : _b.filter((x) => !payload.schema.includes(x))) ?? [];
+        const newSchemaFields = payload.schema.filter((x) => {
+          var _a2;
+          return !((_a2 = state.schema) == null ? void 0 : _a2.includes(x));
+        });
+        const local = {
+          data: omitKeys(state.data, newSchemaFields),
+          errors: omitKeys(state.errors, newSchemaFields),
+          valid: omitKeys(state.valid, newSchemaFields)
+        };
+        const data = addKeys(
+          omitKeys(state.data, removedSchemaFields),
+          newSchemaFields,
+          null,
+          defaultState.data,
+          (_c = state.local) == null ? void 0 : _c.data
+        );
+        const valid = addKeys(
+          omitKeys(state.valid, removedSchemaFields),
+          newSchemaFields,
+          false,
+          defaultState.valid,
+          (_d = state.local) == null ? void 0 : _d.valid
+        );
+        const errors = addKeys(omitKeys(state.errors, removedSchemaFields), newSchemaFields, null, defaultState.errors, (_e = state.local) == null ? void 0 : _e.errors);
+        return { ...state, schema: payload.schema, data, valid, errors, local };
+      }
+      case "validateForm": {
+        const validationSchema = payload.selectedSchema || (state == null ? void 0 : state.schema) || [];
+        const formValidation = validationSchema.reduce(
+          (acc, cur) => {
+            var _a2;
+            const [, validation] = processField({ key: cur, value: state.data[cur], mode: "blur" }, { state });
+            return {
+              valid: { ...acc["valid"], [cur]: validation.isValid && !((_a2 = state.fieldProblems) == null ? void 0 : _a2[cur]) || false },
+              errors: { ...acc["errors"], [cur]: validation.hasError(true) ? validation.getError(true) : null }
+            };
+          },
+          { valid: state.valid, errors: state.errors }
+        );
+        return { ...state, valid: formValidation.valid, errors: formValidation.errors };
+      }
+      default:
+        throw new Error("Undefined useForm action");
+    }
+  };
+}
+export {
+  getReducer,
+  init
+};

package/dist/es/utils/useForm/useForm.js

@@ -0,0 +1,85 @@
+import { F, s, T, p } from "../../../hooks.module-8565d716.mjs";
+import Validator from "../Validator/Validator.js";
+import { init, getReducer } from "./reducer.js";
+import { isFunction } from "../common/index.js";
+function useForm(props) {
+  const { rules = {}, formatters = {}, defaultData = {}, fieldProblems = {}, schema = [] } = props;
+  const validator = F(() => new Validator(rules), [rules]);
+  const processField = ({ key, value, mode }, fieldContext) => {
+    var _a;
+    const formatterFn = ((_a = formatters == null ? void 0 : formatters[key]) == null ? void 0 : _a.formatter) ? formatters[key].formatter : formatters == null ? void 0 : formatters[key];
+    const formattedValue = formatterFn && isFunction(formatterFn) ? formatterFn(value ?? "", fieldContext) : value;
+    const validationResult = validator.validate({ key, value: formattedValue, mode }, fieldContext);
+    return [formattedValue, validationResult];
+  };
+  const [state, dispatch] = s(
+    getReducer(processField),
+    { defaultData, schema: schema ?? [], processField, fieldProblems },
+    init
+  );
+  const isValid = F(() => {
+    var _a;
+    return (_a = state.schema) == null ? void 0 : _a.reduce((acc, val) => (acc && state.valid[val]) ?? false, true);
+  }, [state.schema, state.valid]);
+  const getTargetValue = (key, e) => {
+    var _a;
+    if (!e.target)
+      return null;
+    if (((_a = e.target) == null ? void 0 : _a.type) === "checkbox") {
+      return !state.data[key];
+    }
+    return e.target.value;
+  };
+  const handleChangeFor = (key, mode) => {
+    return (e) => {
+      const value = getTargetValue(key, e);
+      dispatch({ type: "updateField", payload: { key, value, mode } });
+    };
+  };
+  const triggerValidation = T((selectedSchema = null) => {
+    dispatch({ type: "validateForm", payload: { selectedSchema } });
+  }, []);
+  const setErrors = T(
+    (key, value) => dispatch({ type: "setErrors", payload: { key, value } }),
+    []
+  );
+  const setValid = T(
+    (key, value) => dispatch({ type: "setValid", payload: { key, value } }),
+    []
+  );
+  const setData = T(
+    (key, value) => dispatch({ type: "setData", payload: { key, value } }),
+    []
+  );
+  const setSchema = T(
+    (schema2) => dispatch({ type: "setSchema", payload: { schema: schema2, defaultData } }),
+    [state.schema, defaultData]
+  );
+  const mergeForm = T((formValue) => dispatch({ type: "mergeForm", payload: { formValue } }), []);
+  const setFieldProblems = T(
+    (fieldProblems2) => dispatch({ type: "setFieldProblems", payload: { fieldProblems: fieldProblems2 } }),
+    [state.schema, defaultData]
+  );
+  p(() => {
+    setFieldProblems(fieldProblems ?? {});
+  }, [JSON.stringify(fieldProblems)]);
+  return {
+    handleChangeFor,
+    triggerValidation,
+    setSchema,
+    setData,
+    setValid,
+    setErrors,
+    isValid,
+    mergeForm,
+    setFieldProblems,
+    schema: state.schema,
+    valid: state.valid,
+    errors: state.errors,
+    data: state.data,
+    fieldProblems: state.fieldProblems
+  };
+}
+export {
+  useForm as default
+};

package/dist/es/utils/useForm/useForm.test.js

@@ -0,0 +1,107 @@
+import useForm from "./useForm.js";
+import { u, a as renderHook } from "../../../index-2c0f6175.mjs";
+import { d as describe, b as beforeEach, i as it, g as globalExpect } from "../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe.skip("useForm", () => {
+  const defaultSchema = ["firstName", "lastName"];
+  const defaultData = { firstName: "John" };
+  describe("schema", () => {
+    let useFormHook;
+    beforeEach(() => {
+      const { result } = renderHook(() => useForm({ schema: defaultSchema }));
+      useFormHook = result;
+    });
+    it("should set a default schema", () => {
+      globalExpect(useFormHook.current.schema).toEqual(defaultSchema);
+      globalExpect(useFormHook.current.data[defaultSchema[0]]).toEqual(null);
+      globalExpect(useFormHook.current.errors[defaultSchema[0]]).toEqual(null);
+      globalExpect(useFormHook.current.valid[defaultSchema[0]]).toEqual(false);
+      globalExpect(useFormHook.current.data[defaultSchema[1]]).toEqual(null);
+      globalExpect(useFormHook.current.valid[defaultSchema[1]]).toEqual(false);
+      globalExpect(useFormHook.current.errors[defaultSchema[1]]).toEqual(null);
+    });
+    it("should update the schema", () => {
+      u(() => {
+        useFormHook.current.setSchema(["email"]);
+      });
+      globalExpect(useFormHook.current.schema).toEqual(["email"]);
+      globalExpect(useFormHook.current.data["email"]).toEqual(null);
+      globalExpect(useFormHook.current.valid["email"]).toEqual(false);
+      globalExpect(useFormHook.current.errors["email"]).toEqual(null);
+    });
+  });
+  describe("defaultData", () => {
+    it("should set defaultData", () => {
+      const { result } = renderHook(() => useForm({ schema: defaultSchema, defaultData }));
+      globalExpect(result.current.data.firstName).toEqual(defaultData.firstName);
+      globalExpect(result.current.data.lastName).toEqual(null);
+    });
+    it("should set default data after changing the schema", () => {
+      const { result } = renderHook(() => useForm({ schema: defaultSchema, defaultData }));
+      u(() => {
+        result.current.setSchema(["email"]);
+      });
+      globalExpect(result.current.data["firstName"]).toEqual(void 0);
+      globalExpect(result.current.valid["firstName"]).toEqual(void 0);
+      globalExpect(result.current.errors["firstName"]).toEqual(void 0);
+      u(() => {
+        result.current.setSchema(["firstName", "email"]);
+      });
+      globalExpect(result.current.data["firstName"]).toEqual(defaultData.firstName);
+      globalExpect(result.current.valid["firstName"]).toEqual(true);
+      globalExpect(result.current.errors["firstName"]).toEqual(null);
+    });
+  });
+  describe("handleChangeFor", () => {
+    const firstNameValue = "John";
+    it("should handle changes for a field", () => {
+      const { result } = renderHook(() => useForm({ schema: defaultSchema }));
+      u(() => {
+        result.current.handleChangeFor("firstName")(firstNameValue);
+      });
+      globalExpect(result.current.data.firstName).toBe(firstNameValue);
+      globalExpect(result.current.valid.firstName).toBe(true);
+      globalExpect(result.current.errors.firstName).toBe(null);
+    });
+    it("should format the value of a field using formatters", () => {
+      const formatterMock = jest.fn();
+      const { result } = renderHook(() => useForm({ schema: defaultSchema, formatters: { firstName: formatterMock } }));
+      u(() => {
+        result.current.handleChangeFor("firstName")(firstNameValue);
+      });
+      const fieldContext = {
+        state: {
+          data: {
+            firstName: null,
+            lastName: null
+          },
+          errors: {
+            firstName: null,
+            lastName: null
+          },
+          schema: ["firstName", "lastName"],
+          valid: {
+            firstName: false,
+            lastName: false
+          },
+          fieldProblems: {
+            firstName: null,
+            lastName: null
+          }
+        }
+      };
+      globalExpect(formatterMock).toHaveBeenCalledWith(firstNameValue, fieldContext);
+    });
+    it("should set the value of a checkbox", () => {
+      const { result } = renderHook(() => useForm({ schema: defaultSchema }));
+      const mockEvent = { target: { type: "checkbox" } };
+      u(() => {
+        result.current.handleChangeFor("firstName")(mockEvent);
+      });
+      globalExpect(result.current.data.firstName).toEqual(true);
+      u(() => {
+        result.current.handleChangeFor("firstName")(mockEvent);
+      });
+      globalExpect(result.current.data.firstName).toEqual(false);
+    });
+  });
+});

package/dist/es/utils/uuid.js

@@ -1,9 +1,9 @@
-function n() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (r) => {
-    const x = Math.random() * 16 | 0;
-    return (r == "x" ? x : x & 3 | 8).toString(16);
+function uuidv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
   });
 }
 export {
-  n as default
+  uuidv4 as default
 };

package/dist/es/utils/uuid.test.js

@@ -0,0 +1,13 @@
+import uuidv4 from "./uuid.js";
+import { d as describe, t as test, g as globalExpect } from "../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("uuid", () => {
+  test("should generate a UUID of 36 characters", () => {
+    const id = uuidv4();
+    globalExpect(id.length).toBe(36);
+  });
+  test("UUIDs are unique", () => {
+    const id = uuidv4();
+    const id2 = uuidv4();
+    globalExpect(id).not.toBe(id2);
+  });
+});

package/dist/es/utils/validator-utils.js

@@ -1,5 +1,46 @@
-const s = (t) => !!(t == null || /^[\s]*$/.test(t)), n = (t) => typeof t == "string" || t instanceof String;
+const MAX_LENGTH = 30;
+const getMaxLengthByFieldAndCountry = (formattingRules, field, country, ignoreIfFormatterExists) => {
+  var _a, _b, _c, _d;
+  if (ignoreIfFormatterExists && ((_b = (_a = formattingRules[country]) == null ? void 0 : _a[field]) == null ? void 0 : _b.formatter)) {
+    return null;
+  }
+  const maxLength = (_d = (_c = formattingRules[country]) == null ? void 0 : _c[field]) == null ? void 0 : _d.maxlength;
+  return maxLength ? maxLength : MAX_LENGTH;
+};
+const isEmpty = (input) => !!(input == null || /^[\s]*$/.test(input));
+const isString = (input) => typeof input === "string" || input instanceof String;
+const hasText = (input) => isString(input) && !isEmpty(input);
+const SPECIAL_CHARS = "?\\-\\+_=!@#$%^&*(){}~<>\\[\\]\\/\\\\";
+const getFormattingRegEx = (specChars, flags = "g") => new RegExp(`[${specChars}]`, flags);
+const getValidatingRegEx = (specChars, exclude) => new RegExp(`^[${exclude ? "^" : ""}${specChars}]+$`);
+const CHARACTER_PATTERNS = {
+  digitsHyphen: /^[\d-]+$/,
+  noHtml: /^[^<>&]+$/,
+  alphaNum: /^\d[a-zA-Z0-9]{6,11}$/,
+  noSpecialChars: getValidatingRegEx(SPECIAL_CHARS, true)
+};
+const exactLength = (input, length) => {
+  if (isEmpty(input)) {
+    return true;
+  }
+  return input.length === length;
+};
+const validateForSpecialChars = (name) => {
+  var _a;
+  const hasNoLength = !name.length;
+  return ((_a = CHARACTER_PATTERNS.noSpecialChars) == null ? void 0 : _a.test(name)) || hasNoLength;
+};
+const trimValWithOneSpace = (val) => val.trimStart().replace(/\s+/g, " ");
 export {
-  s as isEmpty,
-  n as isString
+  CHARACTER_PATTERNS,
+  SPECIAL_CHARS,
+  exactLength,
+  getFormattingRegEx,
+  getMaxLengthByFieldAndCountry,
+  getValidatingRegEx,
+  hasText,
+  isEmpty,
+  isString,
+  trimValWithOneSpace,
+  validateForSpecialChars
 };

package/dist/es/utils/watchable/constants.js

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

package/dist/es/utils/watchable/core/Watchable.js

@@ -1,62 +1,100 @@
-var p = (i, t, s) => {
-  if (!t.has(i))
-    throw TypeError("Cannot " + s);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
-var e = (i, t, s) => (p(i, t, "read from private field"), s ? s.call(i) : t.get(i)), f = (i, t, s) => {
-  if (t.has(i))
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(i) : t.set(i, s);
-}, l = (i, t, s, n) => (p(i, t, "write to private field"), n ? n.call(i, s) : t.set(i, s), s);
-import { createWatchableIdleCallbacks as m, createLiveWatchableState as W } from "./helpers.js";
-import { UNWATCH_SIGNAL as _ } from "../constants.js";
-import { sameValue as z, noop as S } from "../../common/index.js";
-var o, a, r, u, h;
-class v {
-  constructor(t = {}) {
-    f(this, o, void 0);
-    f(this, a, void 0);
-    f(this, r, void 0);
-    f(this, u, /* @__PURE__ */ new WeakMap());
-    f(this, h, /* @__PURE__ */ new Map());
-    l(this, o, m()), l(this, a, W(t)), this.notifyWatchers = this.notifyWatchers.bind(this), this.watch = this.watch.bind(this);
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _idleCallbacks, _liveState, _lastStateSnapshot, _unwatchCallbacks, _watchCallbacks;
+import { createWatchableIdleCallbacks, createLiveWatchableState } from "./helpers.js";
+import { UNWATCH_SIGNAL } from "../constants.js";
+import { sameValue, noop } from "../../common/index.js";
+class __Watchable__ {
+  constructor(watchableAtoms = {}) {
+    __privateAdd(this, _idleCallbacks, void 0);
+    __privateAdd(this, _liveState, void 0);
+    __privateAdd(this, _lastStateSnapshot, void 0);
+    __privateAdd(this, _unwatchCallbacks, /* @__PURE__ */ new WeakMap());
+    __privateAdd(this, _watchCallbacks, /* @__PURE__ */ new Map());
+    __privateSet(this, _idleCallbacks, createWatchableIdleCallbacks());
+    __privateSet(this, _liveState, createLiveWatchableState(watchableAtoms));
+    this.notifyWatchers = this.notifyWatchers.bind(this);
+    this.watch = this.watch.bind(this);
   }
   get idle() {
-    return e(this, h).size === 0;
+    return __privateGet(this, _watchCallbacks).size === 0;
   }
   get idleCallbacks() {
-    return e(this, o);
+    return __privateGet(this, _idleCallbacks);
   }
   get snapshot() {
-    return e(this, r) ?? Object.freeze({ ...e(this, a) });
+    return __privateGet(this, _lastStateSnapshot) ?? Object.freeze({ ...__privateGet(this, _liveState) });
   }
-  notifyWatchers(t) {
-    if (e(this, h).size === 0)
+  notifyWatchers(signal) {
+    if (__privateGet(this, _watchCallbacks).size === 0)
       return;
-    if (t === _)
-      return e(this, h).forEach((n, d) => d(t)), !0;
-    const s = e(this, r);
-    l(this, r, Object.freeze({ ...e(this, a) }));
-    for (const n of Object.keys(e(this, r)))
-      if (!z(e(this, r)[n], s[n]))
-        return e(this, h).forEach((d, c) => c(e(this, r))), !0;
-    return !1;
+    if (signal === UNWATCH_SIGNAL) {
+      __privateGet(this, _watchCallbacks).forEach((_, cb) => cb(signal));
+      return true;
+    }
+    const currentSnapshot = __privateGet(this, _lastStateSnapshot);
+    __privateSet(this, _lastStateSnapshot, Object.freeze({ ...__privateGet(this, _liveState) }));
+    for (const key of Object.keys(__privateGet(this, _lastStateSnapshot))) {
+      if (sameValue(__privateGet(this, _lastStateSnapshot)[key], currentSnapshot[key]))
+        continue;
+      __privateGet(this, _watchCallbacks).forEach((_, cb) => cb(__privateGet(this, _lastStateSnapshot)));
+      return true;
+    }
+    return false;
   }
-  watch(t) {
-    if (!t)
-      return S;
-    let s = e(this, u).get(t);
-    const n = e(this, h).get(t) || 0, d = this.idle;
-    if (!s) {
-      let c = () => {
-        const b = e(this, h).get(t) || 0;
-        b === 1 ? (c = void 0, e(this, u).delete(t), e(this, h).delete(t), e(this, h).size === 0 && (l(this, r, void 0), e(this, o).idle())) : b > 1 && e(this, h).set(t, b - 1);
+  watch(watchCallback) {
+    if (!watchCallback)
+      return noop;
+    let unwatchCallback = __privateGet(this, _unwatchCallbacks).get(watchCallback);
+    const callbackUnwatchCallbacksCount = __privateGet(this, _watchCallbacks).get(watchCallback) || 0;
+    const willResume = this.idle;
+    if (!unwatchCallback) {
+      let unwatch = () => {
+        const callbackUnwatchCallbacksCount2 = __privateGet(this, _watchCallbacks).get(watchCallback) || 0;
+        if (callbackUnwatchCallbacksCount2 === 1) {
+          unwatch = void 0;
+          __privateGet(this, _unwatchCallbacks).delete(watchCallback);
+          __privateGet(this, _watchCallbacks).delete(watchCallback);
+          if (__privateGet(this, _watchCallbacks).size === 0) {
+            __privateSet(this, _lastStateSnapshot, void 0);
+            __privateGet(this, _idleCallbacks).idle();
+          }
+        } else if (callbackUnwatchCallbacksCount2 > 1) {
+          __privateGet(this, _watchCallbacks).set(watchCallback, callbackUnwatchCallbacksCount2 - 1);
+        }
       };
-      e(this, u).set(t, s = () => c == null ? void 0 : c());
+      __privateGet(this, _unwatchCallbacks).set(watchCallback, unwatchCallback = () => unwatch == null ? void 0 : unwatch());
+    }
+    __privateGet(this, _watchCallbacks).set(watchCallback, callbackUnwatchCallbacksCount + 1);
+    if (willResume) {
+      __privateSet(this, _lastStateSnapshot, Object.freeze({ ...__privateGet(this, _liveState) }));
+      __privateGet(this, _idleCallbacks).resume();
     }
-    return e(this, h).set(t, n + 1), d && (l(this, r, Object.freeze({ ...e(this, a) })), e(this, o).resume()), t(e(this, r)), s;
+    watchCallback(__privateGet(this, _lastStateSnapshot));
+    return unwatchCallback;
   }
 }
-o = new WeakMap(), a = new WeakMap(), r = new WeakMap(), u = new WeakMap(), h = new WeakMap();
+_idleCallbacks = new WeakMap();
+_liveState = new WeakMap();
+_lastStateSnapshot = new WeakMap();
+_unwatchCallbacks = new WeakMap();
+_watchCallbacks = new WeakMap();
 export {
-  v as default
+  __Watchable__ as default
 };