@milaboratories/uikit 2.10.37 → 2.10.39

package/dist/composition/useTheme.js

@@ -1,27 +1,26 @@
-import { computed as m, ref as h, watch as l, unref as s, onMounted as u, onUnmounted as c } from "vue";
-import { toList as w, mapIterable as f } from "../helpers/iterators.js";
-import { useLocalStorage as v } from "./useLocalStorage.js";
-const r = /* @__PURE__ */ new Set();
-window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (e) => {
-  w(f(r.values(), (t) => t(e.matches ? "dark" : "light")));
+import { mapIterable as e, toList as t } from "../helpers/iterators.js";
+import { useLocalStorage as n } from "./useLocalStorage.js";
+import { computed as r, onMounted as i, onUnmounted as a, ref as o, unref as s, watch as c } from "vue";
+var l = /* @__PURE__ */ new Set();
+window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", (n) => {
+	t(e(l.values(), (e) => e(n.matches ? "dark" : "light")));
 });
-const g = window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light", d = h(g), o = v("theme");
-function T(e) {
-  const t = m(() => o.value ? o.value : d.value), n = (a) => {
-    d.value = a, e == null || e(a);
-  };
-  function i() {
-    o.value = t.value === "light" ? "dark" : (t.value === "dark", "light");
-  }
-  return l(t, (a) => {
-    e == null || e(s(a));
-  }), u(() => {
-    r.add(n);
-  }), c(() => {
-    r.delete(n);
-  }), [t, i];
+var u = o(window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light"), d = n("theme");
+function f(e) {
+	let t = r(() => d.value ? d.value : u.value), n = (t) => {
+		u.value = t, e?.(t);
+	};
+	function o() {
+		d.value = t.value === "light" ? "dark" : (t.value, "light");
+	}
+	return c(t, (t) => {
+		e?.(s(t));
+	}), i(() => {
+		l.add(n);
+	}), a(() => {
+		l.delete(n);
+	}), [t, o];
 }
-export {
-  T as useTheme
-};
-//# sourceMappingURL=useTheme.js.map
+export { f as useTheme };
+
+//# sourceMappingURL=useTheme.js.map

package/dist/composition/useTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTheme.js","sources":["../../src/composition/useTheme.ts"],"sourcesContent":["import { computed, onMounted, onUnmounted, ref, unref, watch } from \"vue\";\nimport { mapIterable, toList } from \"../helpers/iterators\";\nimport { useLocalStorage } from \"./useLocalStorage\";\n\ntype Theme = \"light\" | \"dark\";\n\ntype Callback = (mode: Theme) => void;\n\nconst cm = new Set<Callback>();\n\nif (window.matchMedia) {\n  window.matchMedia(\"(prefers-color-scheme: dark)\").addEventListener(\"change\", (e) => {\n    toList(mapIterable(cm.values(), (cb) => cb(e.matches ? \"dark\" : \"light\")));\n  });\n}\n\nconst init =\n  window.matchMedia && window.matchMedia(\"(prefers-color-scheme: dark)\").matches ? \"dark\" : \"light\";\n\nconst browserTheme = ref<Theme>(init);\nconst savedTheme = useLocalStorage<Theme>(\"theme\");\n\nexport function useTheme(_cb?: Callback) {\n  const theme = computed<Theme>(() => {\n    return savedTheme.value ? savedTheme.value : browserTheme.value;\n  });\n\n  const cb = (theme: Theme) => {\n    browserTheme.value = theme;\n    _cb?.(theme);\n  };\n\n  function toggleTheme() {\n    savedTheme.value =\n      theme.value === \"light\" ? \"dark\" : theme.value === \"dark\" ? \"light\" : \"light\";\n  }\n\n  watch(theme, (v) => {\n    _cb?.(unref(v));\n  });\n\n  onMounted(() => {\n    cm.add(cb);\n  });\n\n  onUnmounted(() => {\n    cm.delete(cb);\n  });\n\n  return [theme, toggleTheme] as const;\n}\n"],"names":["cm","toList","mapIterable","cb","init","browserTheme","ref","savedTheme","useLocalStorage","useTheme","_cb","theme","computed","toggleTheme","watch","v","unref","onMounted","onUnmounted"],"mappings":";;;AAQA,MAAMA,wBAAS,IAAA;AAEX,OAAO,cACT,OAAO,WAAW,8BAA8B,EAAE,iBAAiB,UAAU,CAAC,MAAM;AAClF,EAAAC,EAAOC,EAAYF,EAAG,OAAA,GAAU,CAACG,MAAOA,EAAG,EAAE,UAAU,SAAS,OAAO,CAAC,CAAC;AAC3E,CAAC;AAGH,MAAMC,IACJ,OAAO,cAAc,OAAO,WAAW,8BAA8B,EAAE,UAAU,SAAS,SAEtFC,IAAeC,EAAWF,CAAI,GAC9BG,IAAaC,EAAuB,OAAO;AAE1C,SAASC,EAASC,GAAgB;AACvC,QAAMC,IAAQC,EAAgB,MACrBL,EAAW,QAAQA,EAAW,QAAQF,EAAa,KAC3D,GAEKF,IAAK,CAACQ,MAAiB;AAC3B,IAAAN,EAAa,QAAQM,GACrBD,KAAA,QAAAA,EAAMC;AAAAA,EACR;AAEA,WAASE,IAAc;AACrB,IAAAN,EAAW,QACTI,EAAM,UAAU,UAAU,UAASA,EAAM,UAAU,QAAS;AAAA,EAChE;AAEA,SAAAG,EAAMH,GAAO,CAACI,MAAM;AAClB,IAAAL,KAAA,QAAAA,EAAMM,EAAMD,CAAC;AAAA,EACf,CAAC,GAEDE,EAAU,MAAM;AACd,IAAAjB,EAAG,IAAIG,CAAE;AAAA,EACX,CAAC,GAEDe,EAAY,MAAM;AAChB,IAAAlB,EAAG,OAAOG,CAAE;AAAA,EACd,CAAC,GAEM,CAACQ,GAAOE,CAAW;AAC5B;"}
+{"version":3,"file":"useTheme.js","names":[],"sources":["../../src/composition/useTheme.ts"],"sourcesContent":["import { computed, onMounted, onUnmounted, ref, unref, watch } from \"vue\";\nimport { mapIterable, toList } from \"../helpers/iterators\";\nimport { useLocalStorage } from \"./useLocalStorage\";\n\ntype Theme = \"light\" | \"dark\";\n\ntype Callback = (mode: Theme) => void;\n\nconst cm = new Set<Callback>();\n\nif (window.matchMedia) {\n  window.matchMedia(\"(prefers-color-scheme: dark)\").addEventListener(\"change\", (e) => {\n    toList(mapIterable(cm.values(), (cb) => cb(e.matches ? \"dark\" : \"light\")));\n  });\n}\n\nconst init =\n  window.matchMedia && window.matchMedia(\"(prefers-color-scheme: dark)\").matches ? \"dark\" : \"light\";\n\nconst browserTheme = ref<Theme>(init);\nconst savedTheme = useLocalStorage<Theme>(\"theme\");\n\nexport function useTheme(_cb?: Callback) {\n  const theme = computed<Theme>(() => {\n    return savedTheme.value ? savedTheme.value : browserTheme.value;\n  });\n\n  const cb = (theme: Theme) => {\n    browserTheme.value = theme;\n    _cb?.(theme);\n  };\n\n  function toggleTheme() {\n    savedTheme.value =\n      theme.value === \"light\" ? \"dark\" : theme.value === \"dark\" ? \"light\" : \"light\";\n  }\n\n  watch(theme, (v) => {\n    _cb?.(unref(v));\n  });\n\n  onMounted(() => {\n    cm.add(cb);\n  });\n\n  onUnmounted(() => {\n    cm.delete(cb);\n  });\n\n  return [theme, toggleTheme] as const;\n}\n"],"mappings":";;;AAQA,IAAM,oBAAK,IAAI,KAAe;AAE1B,OAAO,cACT,OAAO,WAAW,+BAA+B,CAAC,iBAAiB,WAAW,MAAM;AAClF,GAAO,EAAY,EAAG,QAAQ,GAAG,MAAO,EAAG,EAAE,UAAU,SAAS,QAAQ,CAAC,CAAC;EAC1E;AAMJ,IAAM,IAAe,EAFnB,OAAO,cAAc,OAAO,WAAW,+BAA+B,CAAC,UAAU,SAAS,QAEvD,EAC/B,IAAa,EAAuB,QAAQ;AAElD,SAAgB,EAAS,GAAgB;CACvC,IAAM,IAAQ,QACL,EAAW,QAAQ,EAAW,QAAQ,EAAa,MAC1D,EAEI,KAAM,MAAiB;AAE3B,EADA,EAAa,QAAQ,GACrB,IAAM,EAAM;;CAGd,SAAS,IAAc;AACrB,IAAW,QACT,EAAM,UAAU,UAAU,UAAS,EAAM,OAAmB;;AAehE,QAZA,EAAM,IAAQ,MAAM;AAClB,MAAM,EAAM,EAAE,CAAC;GACf,EAEF,QAAgB;AACd,IAAG,IAAI,EAAG;GACV,EAEF,QAAkB;AAChB,IAAG,OAAO,EAAG;GACb,EAEK,CAAC,GAAO,EAAY"}

package/dist/composition/useTransformedModel.js

@@ -1,28 +1,58 @@
-import { ref as c, computed as d, reactive as i } from "vue";
-function h(a, l) {
-  const r = c(), t = c(), { parse: u, update: s } = l, n = () => {
-    r.value = void 0, t.value = void 0;
-  }, v = d({
-    get() {
-      return r.value !== void 0 ? r.value : a.value;
-    },
-    set(o) {
-      n();
-      try {
-        const e = u ? u(o) : o;
-        (s ? s(e) : !0) ? a.value = e : r.value = e;
-      } catch (e) {
-        r.value = o, t.value = e instanceof Error ? e.message : String(e);
-      }
-    }
-  });
-  return i({
-    value: v,
-    error: t,
-    reset: n
-  });
+import { computed as e, reactive as t, ref as n } from "vue";
+/**
+* Creates a reactive local model with optional transformation and validation logic.
+*
+* @template T The type of the model's value.
+*
+* @param model - A `Ref` representing the underlying value.
+* @param options - Optional configuration for validation and parsing.
+* @param options.update - A function that takes the transformed value and returns `true` if it should be applied to the model, or `false` to keep it in a cached state.
+* @param options.parse - A function that takes the input value and returns a transformed value of type `T`. If omitted, the value is used as-is.
+*
+* @returns A reactive object with the following properties:
+* - `value`: A computed property for getting and setting the model value.
+* - `error`: A `Ref<string | undefined>` containing the last error message, if any.
+* - `reset`: A method to clear the cached value and error state.
+*
+* ### Example
+* ```ts
+* import { ref } from 'vue';
+* import { useTransformedModel } from './useTransformedModel';
+*
+* const model = ref<number>(42);
+*
+* const transformedModel = useTransformedModel(model, {
+*   parse: (value) => {
+*     const parsed = Number(value);
+*     if (!Number.isFinite(parsed)) throw new Error('Invalid number');
+*     return parsed;
+*   },
+*   update: (value) => value >= 0, // Only allow non-negative numbers
+* });
+*/
+function r(r, i) {
+	let a = n(), o = n(), { parse: s, update: c } = i, l = () => {
+		a.value = void 0, o.value = void 0;
+	};
+	return t({
+		value: e({
+			get() {
+				return a.value === void 0 ? r.value : a.value;
+			},
+			set(e) {
+				l();
+				try {
+					let t = s ? s(e) : e;
+					!c || c(t) ? r.value = t : a.value = t;
+				} catch (t) {
+					a.value = e, o.value = t instanceof Error ? t.message : String(t);
+				}
+			}
+		}),
+		error: o,
+		reset: l
+	});
 }
-export {
-  h as useTransformedModel
-};
-//# sourceMappingURL=useTransformedModel.js.map
+export { r as useTransformedModel };
+
+//# sourceMappingURL=useTransformedModel.js.map

package/dist/composition/useTransformedModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTransformedModel.js","sources":["../../src/composition/useTransformedModel.ts"],"sourcesContent":["import type { Ref, UnwrapNestedRefs } from \"vue\";\nimport { reactive, computed, ref } from \"vue\";\n\n/**\n * Creates a reactive local model with optional transformation and validation logic.\n *\n * @template T The type of the model's value.\n *\n * @param model - A `Ref` representing the underlying value.\n * @param options - Optional configuration for validation and parsing.\n * @param options.update - A function that takes the transformed value and returns `true` if it should be applied to the model, or `false` to keep it in a cached state.\n * @param options.parse - A function that takes the input value and returns a transformed value of type `T`. If omitted, the value is used as-is.\n *\n * @returns A reactive object with the following properties:\n * - `value`: A computed property for getting and setting the model value.\n * - `error`: A `Ref<string | undefined>` containing the last error message, if any.\n * - `reset`: A method to clear the cached value and error state.\n *\n * ### Example\n * ```ts\n * import { ref } from 'vue';\n * import { useTransformedModel } from './useTransformedModel';\n *\n * const model = ref<number>(42);\n *\n * const transformedModel = useTransformedModel(model, {\n *   parse: (value) => {\n *     const parsed = Number(value);\n *     if (!Number.isFinite(parsed)) throw new Error('Invalid number');\n *     return parsed;\n *   },\n *   update: (value) => value >= 0, // Only allow non-negative numbers\n * });\n */\n\nexport function useTransformedModel<T>(\n  model: Ref<T>,\n  options: { update?: (v: T) => boolean; parse?: (v: unknown) => T },\n) {\n  const cached = ref<T | undefined>();\n  const error = ref<string>();\n\n  const { parse, update } = options;\n\n  const reset = () => {\n    cached.value = undefined;\n    error.value = undefined;\n  };\n\n  const value = computed<T>({\n    get() {\n      if (cached.value !== undefined) {\n        return cached.value;\n      }\n\n      return model.value;\n    },\n    set(value) {\n      reset();\n\n      try {\n        const newValue = parse ? parse(value) : value;\n\n        const shouldUpdate = update ? update(newValue) : true;\n\n        if (shouldUpdate) {\n          model.value = newValue;\n        } else {\n          cached.value = newValue;\n        }\n      } catch (err) {\n        cached.value = value;\n        error.value = err instanceof Error ? err.message : String(err);\n      }\n    },\n  });\n\n  return reactive({\n    value,\n    error,\n    reset,\n  }) as UnwrapNestedRefs<{ value: T; error?: string; reset: () => void }>;\n}\n"],"names":["useTransformedModel","model","options","cached","ref","error","parse","update","reset","value","computed","newValue","err","reactive"],"mappings":";AAmCO,SAASA,EACdC,GACAC,GACA;AACA,QAAMC,IAASC,EAAA,GACTC,IAAQD,EAAA,GAER,EAAE,OAAAE,GAAO,QAAAC,EAAA,IAAWL,GAEpBM,IAAQ,MAAM;AAClB,IAAAL,EAAO,QAAQ,QACfE,EAAM,QAAQ;AAAA,EAChB,GAEMI,IAAQC,EAAY;AAAA,IACxB,MAAM;AACJ,aAAIP,EAAO,UAAU,SACZA,EAAO,QAGTF,EAAM;AAAA,IACf;AAAA,IACA,IAAIQ,GAAO;AACT,MAAAD,EAAA;AAEA,UAAI;AACF,cAAMG,IAAWL,IAAQA,EAAMG,CAAK,IAAIA;AAIxC,SAFqBF,IAASA,EAAOI,CAAQ,IAAI,MAG/CV,EAAM,QAAQU,IAEdR,EAAO,QAAQQ;AAAA,MAEnB,SAASC,GAAK;AACZ,QAAAT,EAAO,QAAQM,GACfJ,EAAM,QAAQO,aAAe,QAAQA,EAAI,UAAU,OAAOA,CAAG;AAAA,MAC/D;AAAA,IACF;AAAA,EAAA,CACD;AAED,SAAOC,EAAS;AAAA,IACd,OAAAJ;AAAA,IACA,OAAAJ;AAAA,IACA,OAAAG;AAAA,EAAA,CACD;AACH;"}
+{"version":3,"file":"useTransformedModel.js","names":[],"sources":["../../src/composition/useTransformedModel.ts"],"sourcesContent":["import type { Ref, UnwrapNestedRefs } from \"vue\";\nimport { reactive, computed, ref } from \"vue\";\n\n/**\n * Creates a reactive local model with optional transformation and validation logic.\n *\n * @template T The type of the model's value.\n *\n * @param model - A `Ref` representing the underlying value.\n * @param options - Optional configuration for validation and parsing.\n * @param options.update - A function that takes the transformed value and returns `true` if it should be applied to the model, or `false` to keep it in a cached state.\n * @param options.parse - A function that takes the input value and returns a transformed value of type `T`. If omitted, the value is used as-is.\n *\n * @returns A reactive object with the following properties:\n * - `value`: A computed property for getting and setting the model value.\n * - `error`: A `Ref<string | undefined>` containing the last error message, if any.\n * - `reset`: A method to clear the cached value and error state.\n *\n * ### Example\n * ```ts\n * import { ref } from 'vue';\n * import { useTransformedModel } from './useTransformedModel';\n *\n * const model = ref<number>(42);\n *\n * const transformedModel = useTransformedModel(model, {\n *   parse: (value) => {\n *     const parsed = Number(value);\n *     if (!Number.isFinite(parsed)) throw new Error('Invalid number');\n *     return parsed;\n *   },\n *   update: (value) => value >= 0, // Only allow non-negative numbers\n * });\n */\n\nexport function useTransformedModel<T>(\n  model: Ref<T>,\n  options: { update?: (v: T) => boolean; parse?: (v: unknown) => T },\n) {\n  const cached = ref<T | undefined>();\n  const error = ref<string>();\n\n  const { parse, update } = options;\n\n  const reset = () => {\n    cached.value = undefined;\n    error.value = undefined;\n  };\n\n  const value = computed<T>({\n    get() {\n      if (cached.value !== undefined) {\n        return cached.value;\n      }\n\n      return model.value;\n    },\n    set(value) {\n      reset();\n\n      try {\n        const newValue = parse ? parse(value) : value;\n\n        const shouldUpdate = update ? update(newValue) : true;\n\n        if (shouldUpdate) {\n          model.value = newValue;\n        } else {\n          cached.value = newValue;\n        }\n      } catch (err) {\n        cached.value = value;\n        error.value = err instanceof Error ? err.message : String(err);\n      }\n    },\n  });\n\n  return reactive({\n    value,\n    error,\n    reset,\n  }) as UnwrapNestedRefs<{ value: T; error?: string; reset: () => void }>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,EACd,GACA,GACA;CACA,IAAM,IAAS,GAAoB,EAC7B,IAAQ,GAAa,EAErB,EAAE,UAAO,cAAW,GAEpB,UAAc;AAElB,EADA,EAAO,QAAQ,KAAA,GACf,EAAM,QAAQ,KAAA;;AA+BhB,QAAO,EAAS;EACd,OA7BY,EAAY;GACxB,MAAM;AAKJ,WAJI,EAAO,UAAU,KAAA,IAId,EAAM,QAHJ,EAAO;;GAKlB,IAAI,GAAO;AACT,OAAO;AAEP,QAAI;KACF,IAAM,IAAW,IAAQ,EAAM,EAAM,GAAG;AAIxC,KAFqB,MAAS,EAAO,EAAS,GAG5C,EAAM,QAAQ,IAEd,EAAO,QAAQ;aAEV,GAAK;AAEZ,KADA,EAAO,QAAQ,GACf,EAAM,QAAQ,aAAe,QAAQ,EAAI,UAAU,OAAO,EAAI;;;GAGnE,CAAC;EAIA;EACA;EACD,CAAC"}

package/dist/composition/useWatchFetch.js

@@ -1,27 +1,45 @@
-import { ref as d, reactive as f, computed as h, unref as i, watch as m } from "vue";
-import { exclusiveRequest as p, delay as y } from "@milaboratories/helpers";
-function n(c, l, e) {
-  const r = d(0), a = f({
-    loading: h(() => r.value > 0),
-    loadingRef: r,
-    value: void 0,
-    error: void 0
-  }), v = p(async (o) => (e != null && e.debounce && await y(i(e.debounce)), l(o)));
-  return m(
-    c,
-    async (o) => {
-      e != null && e.filterWatchResult && !e.filterWatchResult(o) || (a.error = void 0, r.value++, v(o).then((u) => {
-        u.ok && (a.value = u.value);
-      }).catch((u) => {
-        a.value = void 0, a.error = u;
-      }).finally(() => {
-        r.value--;
-      }));
-    },
-    Object.assign({ immediate: !0, deep: !0 }, (e == null ? void 0 : e.watchOptions) ?? {})
-  ), a;
+import { computed as e, reactive as t, ref as n, unref as r, watch as i } from "vue";
+import { delay as a, exclusiveRequest as o } from "@milaboratories/helpers";
+/**
+* Watch any reactive source and perform an asynchronous operation
+*
+* @example
+* ```ts
+* const v = useWatchFetch(
+*   watchSource,
+*   async (sourceValue) => {
+*     return await fetchDataFromApi(sourceValue);
+*   }
+* );
+*
+* // Usage in a template
+* <template>
+*   <div v-if="v.loading">Loading...</div>
+*   <div v-else-if="v.error">Error: {{ v.error.message }}</div>
+*   <div v-else>Data: {{ v.value }}</div>
+* </template>
+* ```
+*/
+function s(s, c, l) {
+	let u = n(0), d = t({
+		loading: e(() => u.value > 0),
+		loadingRef: u,
+		value: void 0,
+		error: void 0
+	}), f = o(async (e) => (l?.debounce && await a(r(l.debounce)), c(e)));
+	return i(s, async (e) => {
+		l?.filterWatchResult && !l.filterWatchResult(e) || (d.error = void 0, u.value++, f(e).then((e) => {
+			e.ok && (d.value = e.value);
+		}).catch((e) => {
+			d.value = void 0, d.error = e;
+		}).finally(() => {
+			u.value--;
+		}));
+	}, Object.assign({
+		immediate: !0,
+		deep: !0
+	}, l?.watchOptions ?? {})), d;
 }
-export {
-  n as useWatchFetch
-};
-//# sourceMappingURL=useWatchFetch.js.map
+export { s as useWatchFetch };
+
+//# sourceMappingURL=useWatchFetch.js.map

package/dist/composition/useWatchFetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"useWatchFetch.js","sources":["../../src/composition/useWatchFetch.ts"],"sourcesContent":["import type { WatchSource, WatchOptions, MaybeRef } from \"vue\";\nimport { reactive, watch, ref, computed, unref } from \"vue\";\nimport { delay, exclusiveRequest } from \"@milaboratories/helpers\";\n\nexport type FetchResult<V, E = unknown> = {\n  loading: boolean;\n  value: V | undefined;\n  error: E;\n};\n\n// TODO Should we keep the old value while fetching the new value?\n\n/**\n * Watch any reactive source and perform an asynchronous operation\n *\n * @example\n * ```ts\n * const v = useWatchFetch(\n *   watchSource,\n *   async (sourceValue) => {\n *     return await fetchDataFromApi(sourceValue);\n *   }\n * );\n *\n * // Usage in a template\n * <template>\n *   <div v-if=\"v.loading\">Loading...</div>\n *   <div v-else-if=\"v.error\">Error: {{ v.error.message }}</div>\n *   <div v-else>Data: {{ v.value }}</div>\n * </template>\n * ```\n */\nexport function useWatchFetch<S, V>(\n  watchSource: WatchSource<S>,\n  doFetch: (s: S) => Promise<V>,\n  settings?: {\n    watchOptions?: WatchOptions;\n    debounce?: MaybeRef<number>; // debounce time in ms\n    filterWatchResult?: (s: S) => boolean; // prevents fetching if false\n  },\n): FetchResult<V> {\n  const loadingRef = ref(0);\n\n  const data = reactive({\n    loading: computed(() => loadingRef.value > 0),\n    loadingRef,\n    value: undefined as V,\n    error: undefined,\n  }) as FetchResult<V>;\n\n  const exclusive = exclusiveRequest(async (s: S) => {\n    if (settings?.debounce) {\n      await delay(unref(settings.debounce));\n    }\n    return doFetch(s);\n  });\n\n  watch(\n    watchSource,\n    async (s) => {\n      if (settings?.filterWatchResult && !settings.filterWatchResult(s)) {\n        return;\n      }\n\n      data.error = undefined;\n      loadingRef.value++;\n      exclusive(s)\n        .then((res) => {\n          if (res.ok) {\n            data.value = res.value;\n          }\n        })\n        .catch((err) => {\n          data.value = undefined;\n          data.error = err;\n        })\n        .finally(() => {\n          loadingRef.value--;\n        });\n    },\n    Object.assign({ immediate: true, deep: true }, settings?.watchOptions ?? {}),\n  );\n\n  return data;\n}\n"],"names":["useWatchFetch","watchSource","doFetch","settings","loadingRef","ref","data","reactive","computed","exclusive","exclusiveRequest","s","delay","unref","watch","res","err"],"mappings":";;AAgCO,SAASA,EACdC,GACAC,GACAC,GAKgB;AAChB,QAAMC,IAAaC,EAAI,CAAC,GAElBC,IAAOC,EAAS;AAAA,IACpB,SAASC,EAAS,MAAMJ,EAAW,QAAQ,CAAC;AAAA,IAC5C,YAAAA;AAAA,IACA,OAAO;AAAA,IACP,OAAO;AAAA,EAAA,CACR,GAEKK,IAAYC,EAAiB,OAAOC,OACpCR,KAAA,QAAAA,EAAU,YACZ,MAAMS,EAAMC,EAAMV,EAAS,QAAQ,CAAC,GAE/BD,EAAQS,CAAC,EACjB;AAED,SAAAG;AAAA,IACEb;AAAA,IACA,OAAOU,MAAM;AACX,MAAIR,KAAA,QAAAA,EAAU,qBAAqB,CAACA,EAAS,kBAAkBQ,CAAC,MAIhEL,EAAK,QAAQ,QACbF,EAAW,SACXK,EAAUE,CAAC,EACR,KAAK,CAACI,MAAQ;AACb,QAAIA,EAAI,OACNT,EAAK,QAAQS,EAAI;AAAA,MAErB,CAAC,EACA,MAAM,CAACC,MAAQ;AACd,QAAAV,EAAK,QAAQ,QACbA,EAAK,QAAQU;AAAA,MACf,CAAC,EACA,QAAQ,MAAM;AACb,QAAAZ,EAAW;AAAA,MACb,CAAC;AAAA,IACL;AAAA,IACA,OAAO,OAAO,EAAE,WAAW,IAAM,MAAM,GAAA,IAAQD,KAAA,gBAAAA,EAAU,iBAAgB,CAAA,CAAE;AAAA,EAAA,GAGtEG;AACT;"}
+{"version":3,"file":"useWatchFetch.js","names":[],"sources":["../../src/composition/useWatchFetch.ts"],"sourcesContent":["import type { WatchSource, WatchOptions, MaybeRef } from \"vue\";\nimport { reactive, watch, ref, computed, unref } from \"vue\";\nimport { delay, exclusiveRequest } from \"@milaboratories/helpers\";\n\nexport type FetchResult<V, E = unknown> = {\n  loading: boolean;\n  value: V | undefined;\n  error: E;\n};\n\n// TODO Should we keep the old value while fetching the new value?\n\n/**\n * Watch any reactive source and perform an asynchronous operation\n *\n * @example\n * ```ts\n * const v = useWatchFetch(\n *   watchSource,\n *   async (sourceValue) => {\n *     return await fetchDataFromApi(sourceValue);\n *   }\n * );\n *\n * // Usage in a template\n * <template>\n *   <div v-if=\"v.loading\">Loading...</div>\n *   <div v-else-if=\"v.error\">Error: {{ v.error.message }}</div>\n *   <div v-else>Data: {{ v.value }}</div>\n * </template>\n * ```\n */\nexport function useWatchFetch<S, V>(\n  watchSource: WatchSource<S>,\n  doFetch: (s: S) => Promise<V>,\n  settings?: {\n    watchOptions?: WatchOptions;\n    debounce?: MaybeRef<number>; // debounce time in ms\n    filterWatchResult?: (s: S) => boolean; // prevents fetching if false\n  },\n): FetchResult<V> {\n  const loadingRef = ref(0);\n\n  const data = reactive({\n    loading: computed(() => loadingRef.value > 0),\n    loadingRef,\n    value: undefined as V,\n    error: undefined,\n  }) as FetchResult<V>;\n\n  const exclusive = exclusiveRequest(async (s: S) => {\n    if (settings?.debounce) {\n      await delay(unref(settings.debounce));\n    }\n    return doFetch(s);\n  });\n\n  watch(\n    watchSource,\n    async (s) => {\n      if (settings?.filterWatchResult && !settings.filterWatchResult(s)) {\n        return;\n      }\n\n      data.error = undefined;\n      loadingRef.value++;\n      exclusive(s)\n        .then((res) => {\n          if (res.ok) {\n            data.value = res.value;\n          }\n        })\n        .catch((err) => {\n          data.value = undefined;\n          data.error = err;\n        })\n        .finally(() => {\n          loadingRef.value--;\n        });\n    },\n    Object.assign({ immediate: true, deep: true }, settings?.watchOptions ?? {}),\n  );\n\n  return data;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,EACd,GACA,GACA,GAKgB;CAChB,IAAM,IAAa,EAAI,EAAE,EAEnB,IAAO,EAAS;EACpB,SAAS,QAAe,EAAW,QAAQ,EAAE;EAC7C;EACA,OAAO,KAAA;EACP,OAAO,KAAA;EACR,CAAC,EAEI,IAAY,EAAiB,OAAO,OACpC,GAAU,YACZ,MAAM,EAAM,EAAM,EAAS,SAAS,CAAC,EAEhC,EAAQ,EAAE,EACjB;AA4BF,QA1BA,EACE,GACA,OAAO,MAAM;AACP,KAAU,qBAAqB,CAAC,EAAS,kBAAkB,EAAE,KAIjE,EAAK,QAAQ,KAAA,GACb,EAAW,SACX,EAAU,EAAE,CACT,MAAM,MAAQ;AACb,GAAI,EAAI,OACN,EAAK,QAAQ,EAAI;IAEnB,CACD,OAAO,MAAQ;AAEd,GADA,EAAK,QAAQ,KAAA,GACb,EAAK,QAAQ;IACb,CACD,cAAc;AACb,KAAW;IACX;IAEN,OAAO,OAAO;EAAE,WAAW;EAAM,MAAM;EAAM,EAAE,GAAU,gBAAgB,EAAE,CAAC,CAC7E,EAEM"}

package/dist/composition/utils.js

@@ -1,8 +1,7 @@
-import { onMounted as o, onUpdated as t } from "vue";
-function e(n) {
-  o(n), t(n);
+import { onMounted as e, onUpdated as t } from "vue";
+function n(n) {
+	e(n), t(n);
 }
-export {
-  e as onChanged
-};
-//# sourceMappingURL=utils.js.map
+export { n as onChanged };
+
+//# sourceMappingURL=utils.js.map

package/dist/composition/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../src/composition/utils.ts"],"sourcesContent":["import { onMounted, onUpdated } from \"vue\";\n\nexport function onChanged(hook: () => unknown) {\n  onMounted(hook);\n  onUpdated(hook);\n}\n"],"names":["onChanged","hook","onMounted","onUpdated"],"mappings":";AAEO,SAASA,EAAUC,GAAqB;AAC7C,EAAAC,EAAUD,CAAI,GACdE,EAAUF,CAAI;AAChB;"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/composition/utils.ts"],"sourcesContent":["import { onMounted, onUpdated } from \"vue\";\n\nexport function onChanged(hook: () => unknown) {\n  onMounted(hook);\n  onUpdated(hook);\n}\n"],"mappings":";AAEA,SAAgB,EAAU,GAAqB;AAE7C,CADA,EAAU,EAAK,EACf,EAAU,EAAK"}

package/dist/composition/watchCached.js

@@ -1,31 +1,18 @@
-import { isJsonEqual as c, deepClone as i } from "@milaboratories/helpers";
-import { ref as l, watch as t } from "vue";
-function n(m, d, e) {
-  const a = l(), u = t(
-    m,
-    (r) => {
-      c(r, a.value) || (a.value = i(r));
-    },
-    {
-      deep: !0,
-      immediate: !0
-      // always initialize cachedValue
-    }
-  );
-  return t(
-    () => a.value,
-    // `as T` is safe as we always initialize cachedValue
-    d,
-    // separate watch so that `onWatcherCleanup` would only be triggerred here
-    {
-      // standard vue `WatchOptions` conform to `WatchCachedOptions` interface,
-      // so construct new options to remove unsupported entries
-      deep: !0,
-      immediate: e == null ? void 0 : e.immediate
-    }
-  ), u;
+import { ref as e, watch as t } from "vue";
+import { deepClone as n, isJsonEqual as r } from "@milaboratories/helpers";
+/** Alternative to `watch`, but triggering only on actual data changes */
+function i(i, a, o) {
+	let s = e(), c = t(i, (e) => {
+		r(e, s.value) || (s.value = n(e));
+	}, {
+		deep: !0,
+		immediate: !0
+	});
+	return t(() => s.value, a, {
+		deep: !0,
+		immediate: o?.immediate
+	}), c;
 }
-export {
-  n as watchCached
-};
-//# sourceMappingURL=watchCached.js.map
+export { i as watchCached };
+
+//# sourceMappingURL=watchCached.js.map

package/dist/composition/watchCached.js.map

@@ -1 +1 @@
-{"version":3,"file":"watchCached.js","sources":["../../src/composition/watchCached.ts"],"sourcesContent":["import { deepClone, isJsonEqual } from \"@milaboratories/helpers\";\nimport { ref, watch, type WatchCallback, type WatchHandle, type WatchSource } from \"vue\";\n\ntype MaybeUndefined<T, I> = I extends true ? T | undefined : T;\nexport interface WatchCachedOptions<Immediate = boolean> {\n  immediate?: Immediate;\n  // deep: true; - caching is useless when you are using the source as a `shallowRef`\n  // once: false; - caching is useless when you need a single shot, use plain watch instead\n}\n/** Alternative to `watch`, but triggering only on actual data changes */\nexport function watchCached<T, Immediate extends Readonly<boolean> = false>(\n  source: WatchSource<T>,\n  cb: WatchCallback<T, MaybeUndefined<T, Immediate>>,\n  options?: WatchCachedOptions<Immediate>,\n): WatchHandle {\n  const cachedValue = ref<T>();\n  const handle = watch(\n    source,\n    (newValue) => {\n      if (!isJsonEqual(newValue, cachedValue.value)) {\n        // `deepClone` is needed because in case some fields are patched the deep would be triggered,\n        // but objects would be equal as the saved value was also patched\n        cachedValue.value = deepClone(newValue);\n      }\n    },\n    {\n      deep: true,\n      immediate: true, // always initialize cachedValue\n    },\n  );\n  watch<T, Immediate>(\n    () => cachedValue.value as T, // `as T` is safe as we always initialize cachedValue\n    cb, // separate watch so that `onWatcherCleanup` would only be triggerred here\n    {\n      // standard vue `WatchOptions` conform to `WatchCachedOptions` interface,\n      // so construct new options to remove unsupported entries\n      deep: true,\n      immediate: options?.immediate,\n    },\n  );\n  return handle; // stopping first handle would effectively stop the second one\n}\n"],"names":["watchCached","source","cb","options","cachedValue","ref","handle","watch","newValue","isJsonEqual","deepClone"],"mappings":";;AAUO,SAASA,EACdC,GACAC,GACAC,GACa;AACb,QAAMC,IAAcC,EAAA,GACdC,IAASC;AAAA,IACbN;AAAA,IACA,CAACO,MAAa;AACZ,MAAKC,EAAYD,GAAUJ,EAAY,KAAK,MAG1CA,EAAY,QAAQM,EAAUF,CAAQ;AAAA,IAE1C;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,WAAW;AAAA;AAAA,IAAA;AAAA,EACb;AAEF,SAAAD;AAAA,IACE,MAAMH,EAAY;AAAA;AAAA,IAClBF;AAAA;AAAA,IACA;AAAA;AAAA;AAAA,MAGE,MAAM;AAAA,MACN,WAAWC,KAAA,gBAAAA,EAAS;AAAA,IAAA;AAAA,EACtB,GAEKG;AACT;"}
+{"version":3,"file":"watchCached.js","names":[],"sources":["../../src/composition/watchCached.ts"],"sourcesContent":["import { deepClone, isJsonEqual } from \"@milaboratories/helpers\";\nimport { ref, watch, type WatchCallback, type WatchHandle, type WatchSource } from \"vue\";\n\ntype MaybeUndefined<T, I> = I extends true ? T | undefined : T;\nexport interface WatchCachedOptions<Immediate = boolean> {\n  immediate?: Immediate;\n  // deep: true; - caching is useless when you are using the source as a `shallowRef`\n  // once: false; - caching is useless when you need a single shot, use plain watch instead\n}\n/** Alternative to `watch`, but triggering only on actual data changes */\nexport function watchCached<T, Immediate extends Readonly<boolean> = false>(\n  source: WatchSource<T>,\n  cb: WatchCallback<T, MaybeUndefined<T, Immediate>>,\n  options?: WatchCachedOptions<Immediate>,\n): WatchHandle {\n  const cachedValue = ref<T>();\n  const handle = watch(\n    source,\n    (newValue) => {\n      if (!isJsonEqual(newValue, cachedValue.value)) {\n        // `deepClone` is needed because in case some fields are patched the deep would be triggered,\n        // but objects would be equal as the saved value was also patched\n        cachedValue.value = deepClone(newValue);\n      }\n    },\n    {\n      deep: true,\n      immediate: true, // always initialize cachedValue\n    },\n  );\n  watch<T, Immediate>(\n    () => cachedValue.value as T, // `as T` is safe as we always initialize cachedValue\n    cb, // separate watch so that `onWatcherCleanup` would only be triggerred here\n    {\n      // standard vue `WatchOptions` conform to `WatchCachedOptions` interface,\n      // so construct new options to remove unsupported entries\n      deep: true,\n      immediate: options?.immediate,\n    },\n  );\n  return handle; // stopping first handle would effectively stop the second one\n}\n"],"mappings":";;;AAUA,SAAgB,EACd,GACA,GACA,GACa;CACb,IAAM,IAAc,GAAQ,EACtB,IAAS,EACb,IACC,MAAa;AACZ,EAAK,EAAY,GAAU,EAAY,MAAM,KAG3C,EAAY,QAAQ,EAAU,EAAS;IAG3C;EACE,MAAM;EACN,WAAW;EACZ,CACF;AAWD,QAVA,QACQ,EAAY,OAClB,GACA;EAGE,MAAM;EACN,WAAW,GAAS;EACrB,CACF,EACM"}