@startlibs/core 1.0.6 → 1.1.0

package/lib/hooks/useCallState.mjs

@@ -0,0 +1,21 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { useState, useMemo } from 'react';
+import '@startlibs/utils';
+
+const useCallState = (defaultValue, setCallback) => {
+  const _useState = useState(defaultValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    val = _useState2[0],
+    setValue = _useState2[1];
+  return useMemo(() => {
+    const get = () => val;
+    return {
+      get,
+      val,
+      set: setValue
+    };
+  }, [val]);
+};
+
+export { useCallState };
+//# sourceMappingURL=useCallState.mjs.map

package/lib/hooks/useCallState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCallState.mjs","sources":["../../src/hooks/useCallState.js"],"sourcesContent":["import React, {useMemo, useState} from 'react'\nimport {_s} from '@startlibs/utils'\n\nconst isPath = (path) => typeof path === 'string' || typeof path === 'number' || Array.isArray(path)\n\nconst getter = (value) => path => isPath(path) ? _s.get(path, value) : value\n\nexport const useCallState = (defaultValue, setCallback) => {\n  const [val, setValue] = useState(defaultValue)\n\n  return useMemo(() => {\n    const get = () => val\n    return {get, val, set: setValue}\n  }, [val])\n}\n"],"names":["useCallState","defaultValue","setCallback","_useState","useState","_useState2","_slicedToArray","val","setValue","useMemo","get","set"],"mappings":";;;;MAOaA,YAAY,GAAGA,CAACC,YAAY,EAAEC,WAAW,KAAK;AACzD,EAAA,MAAAC,SAAA,GAAwBC,QAAQ,CAACH,YAAY,CAAC;IAAAI,UAAA,GAAAC,cAAA,CAAAH,SAAA,EAAA,CAAA,CAAA;AAAvCI,IAAAA,GAAG,GAAAF,UAAA,CAAA,CAAA,CAAA;AAAEG,IAAAA,QAAQ,GAAAH,UAAA,CAAA,CAAA,CAAA,CAAA;EAEpB,OAAOI,OAAO,CAAC,MAAM;AACnB,IAAA,MAAMC,GAAG,GAAGA,MAAMH,GAAG,CAAA;IACrB,OAAO;MAACG,GAAG;MAAEH,GAAG;AAAEI,MAAAA,GAAG,EAAEH,QAAAA;KAAS,CAAA;AAClC,GAAC,EAAE,CAACD,GAAG,CAAC,CAAC,CAAA;AACX;;;;"}

package/lib/hooks/useCallbackStable.mjs

@@ -0,0 +1,17 @@
+import React, { useInsertionEffect } from 'react';
+
+const useCallbackStable = fn => {
+  const ref = React.useRef([fn, function () {
+    return ref[0](...arguments);
+  }]).current;
+  // Per Dan Abramov: useInsertionEffect executes marginally closer to the
+  // correct timing for ref synchronization than useLayoutEffect on React 18.
+  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
+  useInsertionEffect(() => {
+    ref[0] = fn;
+  });
+  return ref[1];
+};
+
+export { useCallbackStable };
+//# sourceMappingURL=useCallbackStable.mjs.map

package/lib/hooks/useCallbackStable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCallbackStable.mjs","sources":["../../src/hooks/useCallbackStable.jsx"],"sourcesContent":["import React, {useInsertionEffect} from 'react'\n\nexport const useCallbackStable = (fn) => {\n  const ref = React.useRef([fn, (...args) => ref[0](...args)]).current;\n  // Per Dan Abramov: useInsertionEffect executes marginally closer to the\n  // correct timing for ref synchronization than useLayoutEffect on React 18.\n  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360\n  useInsertionEffect(() => {\n    ref[0] = fn;\n  });\n  return ref[1];\n}"],"names":["useCallbackStable","fn","ref","React","useRef","arguments","current","useInsertionEffect"],"mappings":";;AAEaA,MAAAA,iBAAiB,GAAIC,EAAE,IAAK;EACvC,MAAMC,GAAG,GAAGC,KAAK,CAACC,MAAM,CAAC,CAACH,EAAE,EAAE,YAAA;AAAA,IAAA,OAAaC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAAG,SAAO,CAAC,CAAA;GAAC,CAAA,CAAC,CAACC,OAAO,CAAA;AACpE;AACA;AACA;AACAC,EAAAA,kBAAkB,CAAC,MAAM;AACvBL,IAAAA,GAAG,CAAC,CAAC,CAAC,GAAGD,EAAE,CAAA;AACb,GAAC,CAAC,CAAA;EACF,OAAOC,GAAG,CAAC,CAAC,CAAC,CAAA;AACf;;;;"}

package/lib/hooks/useConstant.mjs

@@ -0,0 +1,21 @@
+import { useRef } from 'react';
+import { callIfFunction } from '@startlibs/utils';
+
+const not_defined = {};
+const useConstant = value => {
+  const ref = useRef(not_defined);
+  if (ref.current === not_defined) {
+    ref.current = value;
+  }
+  return ref.current;
+};
+const useLazyConstant = value => {
+  const ref = useRef(not_defined);
+  if (ref.current === not_defined) {
+    ref.current = callIfFunction(value);
+  }
+  return ref.current;
+};
+
+export { useConstant, useLazyConstant };
+//# sourceMappingURL=useConstant.mjs.map

package/lib/hooks/useConstant.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConstant.mjs","sources":["../../src/hooks/useConstant.js"],"sourcesContent":["import React, {useRef} from 'react'\nimport {callIfFunction} from '@startlibs/utils'\n\nconst not_defined = {}\n\nexport const useConstant = (value) => {\n  const ref = useRef(not_defined)\n  if (ref.current === not_defined) {\n    ref.current = value\n  }\n  return ref.current\n}\n\nexport const useLazyConstant= (value) => {\n  const ref = useRef(not_defined)\n  if (ref.current === not_defined) {\n    ref.current = callIfFunction(value)\n  }\n  return ref.current\n}\n"],"names":["not_defined","useConstant","value","ref","useRef","current","useLazyConstant","callIfFunction"],"mappings":";;;AAGA,MAAMA,WAAW,GAAG,EAAE,CAAA;AAETC,MAAAA,WAAW,GAAIC,KAAK,IAAK;AACpC,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACJ,WAAW,CAAC,CAAA;AAC/B,EAAA,IAAIG,GAAG,CAACE,OAAO,KAAKL,WAAW,EAAE;IAC/BG,GAAG,CAACE,OAAO,GAAGH,KAAK,CAAA;AACrB,GAAA;EACA,OAAOC,GAAG,CAACE,OAAO,CAAA;AACpB,EAAC;AAEYC,MAAAA,eAAe,GAAGJ,KAAK,IAAK;AACvC,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACJ,WAAW,CAAC,CAAA;AAC/B,EAAA,IAAIG,GAAG,CAACE,OAAO,KAAKL,WAAW,EAAE;AAC/BG,IAAAA,GAAG,CAACE,OAAO,GAAGE,cAAc,CAACL,KAAK,CAAC,CAAA;AACrC,GAAA;EACA,OAAOC,GAAG,CAACE,OAAO,CAAA;AACpB;;;;"}

package/lib/hooks/useConsumerCatalog.mjs

@@ -0,0 +1,25 @@
+import { useMemo, useEffect } from 'react';
+import { callMany } from '@startlibs/utils';
+import { useRefState } from './useRefState.mjs';
+
+const useConsumerCatalog = (mountCallback, unmountCallback) => {
+  const elements = useRefState([]);
+  const register = callMany(element => elements.set(elements => elements.concat([element])), mountCallback);
+  const unregister = callMany(element => elements.set(elements => elements.filter(_ => _ !== element)), unmountCallback);
+  const manager = useMemo(() => ({
+    register,
+    unregister
+  }), []);
+  return [elements.get, manager];
+};
+const useCatalogManager = (_ref, ref) => {
+  let register = _ref.register,
+    unregister = _ref.unregister;
+  useEffect(() => {
+    register(ref);
+    return () => unregister(ref);
+  }, [ref]);
+};
+
+export { useCatalogManager, useConsumerCatalog };
+//# sourceMappingURL=useConsumerCatalog.mjs.map

package/lib/hooks/useConsumerCatalog.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConsumerCatalog.mjs","sources":["../../src/hooks/useConsumerCatalog.jsx"],"sourcesContent":["import React, {useEffect, useMemo} from 'react'\nimport {callMany} from '@startlibs/utils'\nimport {useRefState} from './useRefState'\n\nexport const useConsumerCatalog = (mountCallback,unmountCallback) => {\n  const elements = useRefState([])\n\n  const register = callMany((element) => elements.set((elements) => elements.concat([element])), mountCallback)\n  const unregister = callMany((element) =>  elements.set((elements) => elements.filter(_ => _ !== element)), unmountCallback)\n\n  const manager = useMemo(()=> ({register,unregister}), [])\n\n  return [elements.get,manager]\n}\n\nexport const useCatalogManager = ({register,unregister},ref) => {\n  useEffect(() => {\n    register(ref)\n    return () => unregister(ref)\n  },[ref])\n}"],"names":["useConsumerCatalog","mountCallback","unmountCallback","elements","useRefState","register","callMany","element","set","concat","unregister","filter","_","manager","useMemo","get","useCatalogManager","_ref","ref","useEffect"],"mappings":";;;;MAIaA,kBAAkB,GAAGA,CAACC,aAAa,EAACC,eAAe,KAAK;AACnE,EAAA,MAAMC,QAAQ,GAAGC,WAAW,CAAC,EAAE,CAAC,CAAA;EAEhC,MAAMC,QAAQ,GAAGC,QAAQ,CAAEC,OAAO,IAAKJ,QAAQ,CAACK,GAAG,CAAEL,QAAQ,IAAKA,QAAQ,CAACM,MAAM,CAAC,CAACF,OAAO,CAAC,CAAC,CAAC,EAAEN,aAAa,CAAC,CAAA;EAC7G,MAAMS,UAAU,GAAGJ,QAAQ,CAAEC,OAAO,IAAMJ,QAAQ,CAACK,GAAG,CAAEL,QAAQ,IAAKA,QAAQ,CAACQ,MAAM,CAACC,CAAC,IAAIA,CAAC,KAAKL,OAAO,CAAC,CAAC,EAAEL,eAAe,CAAC,CAAA;AAE3H,EAAA,MAAMW,OAAO,GAAGC,OAAO,CAAC,OAAM;IAACT,QAAQ;AAACK,IAAAA,UAAAA;GAAW,CAAC,EAAE,EAAE,CAAC,CAAA;AAEzD,EAAA,OAAO,CAACP,QAAQ,CAACY,GAAG,EAACF,OAAO,CAAC,CAAA;AAC/B,EAAC;MAEYG,iBAAiB,GAAGA,CAAAC,IAAA,EAAuBC,GAAG,KAAK;AAAA,EAAA,IAA7Bb,QAAQ,GAAAY,IAAA,CAARZ,QAAQ;IAACK,UAAU,GAAAO,IAAA,CAAVP,UAAU,CAAA;AACpDS,EAAAA,SAAS,CAAC,MAAM;IACdd,QAAQ,CAACa,GAAG,CAAC,CAAA;AACb,IAAA,OAAO,MAAMR,UAAU,CAACQ,GAAG,CAAC,CAAA;AAC9B,GAAC,EAAC,CAACA,GAAG,CAAC,CAAC,CAAA;AACV;;;;"}

package/lib/hooks/useEnsureRef.mjs

@@ -0,0 +1,9 @@
+import { useRef } from 'react';
+
+const useEnsureRef = forwardedRef => {
+  const ref = useRef();
+  return forwardedRef || ref;
+};
+
+export { useEnsureRef };
+//# sourceMappingURL=useEnsureRef.mjs.map

package/lib/hooks/useEnsureRef.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnsureRef.mjs","sources":["../../src/hooks/useEnsureRef.js"],"sourcesContent":["import React, {useRef} from 'react'\n\nexport const useEnsureRef = (forwardedRef) => {\n  const ref = useRef()\n  return forwardedRef || ref\n}\n"],"names":["useEnsureRef","forwardedRef","ref","useRef"],"mappings":";;AAEaA,MAAAA,YAAY,GAAIC,YAAY,IAAK;AAC5C,EAAA,MAAMC,GAAG,GAAGC,MAAM,EAAE,CAAA;EACpB,OAAOF,YAAY,IAAIC,GAAG,CAAA;AAC5B;;;;"}

package/lib/hooks/useForceUpdate.mjs

@@ -0,0 +1,28 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import { useState } from 'react';
+import { willUseSharedState } from './willUseSharedState.mjs';
+
+const useForceUpdate = () => {
+  const _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2);
+    _useState2[0];
+    const setValue = _useState2[1]; // integer state
+  return () => setValue(value => value + 1); // update the state to force render
+};
+const willUseForceUpdate = () => {
+  const _willUseSharedState = willUseSharedState(),
+    _willUseSharedState2 = _slicedToArray(_willUseSharedState, 3),
+    useValue = _willUseSharedState2[0],
+    set = _willUseSharedState2[2];
+  const useForceUpdate = () => {
+    const _useValue = useValue(0),
+      _useValue2 = _slicedToArray(_useValue, 2);
+      _useValue2[0];
+      const setV = _useValue2[1];
+    return () => setV(value => value + 1);
+  };
+  return [useForceUpdate, () => set(value => value + 1)];
+};
+
+export { useForceUpdate, willUseForceUpdate };
+//# sourceMappingURL=useForceUpdate.mjs.map

package/lib/hooks/useForceUpdate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForceUpdate.mjs","sources":["../../src/hooks/useForceUpdate.jsx"],"sourcesContent":["import {useState} from 'react'\nimport {willUseSharedState} from './willUseSharedState'\n\nexport const useForceUpdate = () => {\n  const [value, setValue] = useState(0); // integer state\n  return () => setValue(value => value + 1); // update the state to force render\n}\n\nexport const willUseForceUpdate = () => {\n  const [useValue,,set] = willUseSharedState()\n  const useForceUpdate = () => {\n    const [v,setV] = useValue(0)\n    return () => setV(value => value + 1)\n  }\n  return [useForceUpdate,() => set(value => value + 1)]\n}"],"names":["useForceUpdate","_useState","useState","_useState2","_slicedToArray","value","setValue","willUseForceUpdate","_willUseSharedState","willUseSharedState","_willUseSharedState2","useValue","set","_useValue","_useValue2","v","setV"],"mappings":";;;;AAGaA,MAAAA,cAAc,GAAGA,MAAM;AAClC,EAAA,MAAAC,SAAA,GAA0BC,QAAQ,CAAC,CAAC,CAAC,CAAA;IAAAC,UAAA,GAAAC,cAAA,CAAAH,SAAA,EAAA,CAAA,CAAA,CAAA;AAA9BI,IAAKF,UAAA,CAAA,CAAA,CAAA,CAAA;UAAEG,QAAQ,GAAAH,UAAA,CAAA,CAAA,EAAgB;EACtC,OAAO,MAAMG,QAAQ,CAACD,KAAK,IAAIA,KAAK,GAAG,CAAC,CAAC,CAAC;AAC5C,EAAC;AAEYE,MAAAA,kBAAkB,GAAGA,MAAM;AACtC,EAAA,MAAAC,mBAAA,GAAwBC,kBAAkB,EAAE;IAAAC,oBAAA,GAAAN,cAAA,CAAAI,mBAAA,EAAA,CAAA,CAAA;AAArCG,IAAAA,QAAQ,GAAAD,oBAAA,CAAA,CAAA,CAAA;AAAEE,IAAAA,GAAG,GAAAF,oBAAA,CAAA,CAAA,CAAA,CAAA;EACpB,MAAMV,cAAc,GAAGA,MAAM;AAC3B,IAAA,MAAAa,SAAA,GAAiBF,QAAQ,CAAC,CAAC,CAAC,CAAA;MAAAG,UAAA,GAAAV,cAAA,CAAAS,SAAA,EAAA,CAAA,CAAA,CAAA;AAArBE,MAACD,UAAA,CAAA,CAAA,CAAA,CAAA;AAACE,YAAAA,IAAI,GAAAF,UAAA,CAAA,CAAA,EAAA;IACb,OAAO,MAAME,IAAI,CAACX,KAAK,IAAIA,KAAK,GAAG,CAAC,CAAC,CAAA;GACtC,CAAA;AACD,EAAA,OAAO,CAACL,cAAc,EAAC,MAAMY,GAAG,CAACP,KAAK,IAAIA,KAAK,GAAG,CAAC,CAAC,CAAC,CAAA;AACvD;;;;"}

package/lib/hooks/useIsUnmounted.mjs

@@ -0,0 +1,15 @@
+import { useRef, useEffect } from 'react';
+
+const useIsUnmounted = () => {
+  const unmounted = useRef(false);
+  useEffect(() => {
+    unmounted.current = false;
+    return () => {
+      unmounted.current = true;
+    };
+  }, []);
+  return () => unmounted.current;
+};
+
+export { useIsUnmounted };
+//# sourceMappingURL=useIsUnmounted.mjs.map

package/lib/hooks/useIsUnmounted.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsUnmounted.mjs","sources":["../../src/hooks/useIsUnmounted.jsx"],"sourcesContent":["import {useEffect, useRef} from 'react'\n\nexport const useIsUnmounted = () => {\n  const unmounted = useRef(false)\n\n  useEffect(() => {\n    unmounted.current = false\n    return () => { unmounted.current = true }\n  }, [])\n\n  return () => unmounted.current\n}"],"names":["useIsUnmounted","unmounted","useRef","useEffect","current"],"mappings":";;AAEaA,MAAAA,cAAc,GAAGA,MAAM;AAClC,EAAA,MAAMC,SAAS,GAAGC,MAAM,CAAC,KAAK,CAAC,CAAA;AAE/BC,EAAAA,SAAS,CAAC,MAAM;IACdF,SAAS,CAACG,OAAO,GAAG,KAAK,CAAA;AACzB,IAAA,OAAO,MAAM;MAAEH,SAAS,CAACG,OAAO,GAAG,IAAI,CAAA;KAAE,CAAA;GAC1C,EAAE,EAAE,CAAC,CAAA;EAEN,OAAO,MAAMH,SAAS,CAACG,OAAO,CAAA;AAChC;;;;"}

package/lib/hooks/usePopupToggle.mjs

@@ -0,0 +1,33 @@
+import 'react';
+import { useToggle } from './useToggle.mjs';
+import { callIfFunction } from '@startlibs/utils';
+
+let prevOpenToggleClose = () => {};
+let sameTick = false;
+const clearPopups = () => {
+  if (!sameTick) {
+    prevOpenToggleClose();
+    prevOpenToggleClose = () => {};
+  }
+};
+const usePopupToggle = (startWith, callback) => {
+  const toggle = useToggle(startWith, (v, prev) => {
+    const result = callIfFunction(callback, v, prev);
+    if (result === false) {
+      return false;
+    }
+    if (v !== false && prevOpenToggleClose !== toggle.close) {
+      prevOpenToggleClose();
+      prevOpenToggleClose = toggle.close;
+      sameTick = true;
+      window.setTimeout(() => sameTick = false, 1);
+    }
+    if (v === false) {
+      prevOpenToggleClose = () => {};
+    }
+  });
+  return toggle;
+};
+
+export { clearPopups, usePopupToggle };
+//# sourceMappingURL=usePopupToggle.mjs.map

package/lib/hooks/usePopupToggle.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePopupToggle.mjs","sources":["../../src/hooks/usePopupToggle.js"],"sourcesContent":["import React from 'react'\nimport {useToggle} from './useToggle'\nimport {callIfFunction} from '@startlibs/utils'\n\nlet prevOpenToggleClose = () => {}\nlet sameTick = false\n\nexport const clearPopups = () => {\n  if (!sameTick) {\n    prevOpenToggleClose()\n    prevOpenToggleClose = () => {}\n  }\n}\n\nexport const usePopupToggle = (startWith,callback) => {\n  const toggle = useToggle(startWith,(v,prev) => {\n    const result = callIfFunction(callback,v,prev)\n    if (result === false) { return false}\n    if (v !== false && prevOpenToggleClose !== toggle.close) {\n      prevOpenToggleClose()\n      prevOpenToggleClose = toggle.close\n      sameTick = true\n      window.setTimeout(()=>sameTick = false, 1)\n    }\n    if (v === false) {\n      prevOpenToggleClose = () => {}\n    }\n  })\n  return toggle\n}"],"names":["prevOpenToggleClose","sameTick","clearPopups","usePopupToggle","startWith","callback","toggle","useToggle","v","prev","result","callIfFunction","close","window","setTimeout"],"mappings":";;;;AAIA,IAAIA,mBAAmB,GAAGA,MAAM,EAAE,CAAA;AAClC,IAAIC,QAAQ,GAAG,KAAK,CAAA;AAEPC,MAAAA,WAAW,GAAGA,MAAM;EAC/B,IAAI,CAACD,QAAQ,EAAE;AACbD,IAAAA,mBAAmB,EAAE,CAAA;AACrBA,IAAAA,mBAAmB,GAAGA,MAAM,EAAE,CAAA;AAChC,GAAA;AACF,EAAC;MAEYG,cAAc,GAAGA,CAACC,SAAS,EAACC,QAAQ,KAAK;EACpD,MAAMC,MAAM,GAAGC,SAAS,CAACH,SAAS,EAAC,CAACI,CAAC,EAACC,IAAI,KAAK;IAC7C,MAAMC,MAAM,GAAGC,cAAc,CAACN,QAAQ,EAACG,CAAC,EAACC,IAAI,CAAC,CAAA;IAC9C,IAAIC,MAAM,KAAK,KAAK,EAAE;AAAE,MAAA,OAAO,KAAK,CAAA;AAAA,KAAA;IACpC,IAAIF,CAAC,KAAK,KAAK,IAAIR,mBAAmB,KAAKM,MAAM,CAACM,KAAK,EAAE;AACvDZ,MAAAA,mBAAmB,EAAE,CAAA;MACrBA,mBAAmB,GAAGM,MAAM,CAACM,KAAK,CAAA;AAClCX,MAAAA,QAAQ,GAAG,IAAI,CAAA;MACfY,MAAM,CAACC,UAAU,CAAC,MAAIb,QAAQ,GAAG,KAAK,EAAE,CAAC,CAAC,CAAA;AAC5C,KAAA;IACA,IAAIO,CAAC,KAAK,KAAK,EAAE;AACfR,MAAAA,mBAAmB,GAAGA,MAAM,EAAE,CAAA;AAChC,KAAA;AACF,GAAC,CAAC,CAAA;AACF,EAAA,OAAOM,MAAM,CAAA;AACf;;;;"}

package/lib/hooks/usePrevious.mjs

@@ -0,0 +1,28 @@
+import { useRef, useEffect } from 'react';
+
+function usePrevious(value, initialValue) {
+  const ref = useRef(initialValue);
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+function usePreviousUnique(value, initialValue) {
+  const ref = useRef(initialValue);
+  useEffect(() => {
+    if (value !== ref.current) {
+      ref.current = value;
+    }
+  });
+  return ref.current;
+}
+function usePreviousForEffect(value, initialValue) {
+  const ref = useRef(initialValue);
+  useEffect(() => () => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+export { usePrevious, usePreviousForEffect, usePreviousUnique };
+//# sourceMappingURL=usePrevious.mjs.map

package/lib/hooks/usePrevious.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrevious.mjs","sources":["../../src/hooks/usePrevious.jsx"],"sourcesContent":["import {useEffect, useRef} from 'react'\n\nexport function usePrevious(value,initialValue) {\n  const ref = useRef(initialValue);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}\n\nexport function usePreviousUnique(value,initialValue) {\n  const ref = useRef(initialValue);\n  useEffect(() => {\n    if (value !== ref.current) {\n      ref.current = value;\n    }\n  });\n  return ref.current;\n}\n\nexport function usePreviousForEffect(value,initialValue) {\n  const ref = useRef(initialValue);\n  useEffect(() => () => {\n    ref.current = value;\n  },[value]);\n  return ref.current;\n}"],"names":["usePrevious","value","initialValue","ref","useRef","useEffect","current","usePreviousUnique","usePreviousForEffect"],"mappings":";;AAEO,SAASA,WAAWA,CAACC,KAAK,EAACC,YAAY,EAAE;AAC9C,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACF,YAAY,CAAC,CAAA;AAChCG,EAAAA,SAAS,CAAC,MAAM;IACdF,GAAG,CAACG,OAAO,GAAGL,KAAK,CAAA;AACrB,GAAC,CAAC,CAAA;EACF,OAAOE,GAAG,CAACG,OAAO,CAAA;AACpB,CAAA;AAEO,SAASC,iBAAiBA,CAACN,KAAK,EAACC,YAAY,EAAE;AACpD,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACF,YAAY,CAAC,CAAA;AAChCG,EAAAA,SAAS,CAAC,MAAM;AACd,IAAA,IAAIJ,KAAK,KAAKE,GAAG,CAACG,OAAO,EAAE;MACzBH,GAAG,CAACG,OAAO,GAAGL,KAAK,CAAA;AACrB,KAAA;AACF,GAAC,CAAC,CAAA;EACF,OAAOE,GAAG,CAACG,OAAO,CAAA;AACpB,CAAA;AAEO,SAASE,oBAAoBA,CAACP,KAAK,EAACC,YAAY,EAAE;AACvD,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACF,YAAY,CAAC,CAAA;EAChCG,SAAS,CAAC,MAAM,MAAM;IACpBF,GAAG,CAACG,OAAO,GAAGL,KAAK,CAAA;AACrB,GAAC,EAAC,CAACA,KAAK,CAAC,CAAC,CAAA;EACV,OAAOE,GAAG,CAACG,OAAO,CAAA;AACpB;;;;"}

package/lib/hooks/useRecycleFocus.mjs

@@ -0,0 +1,36 @@
+import React from 'react';
+import styled from 'styled-components';
+
+const TabFocus = /*#__PURE__*/styled.div.withConfig({
+  displayName: "useRecycleFocus__TabFocus",
+  componentId: "kxnccs-0"
+})(["width:0;height:0;position:absolute;"]);
+const useRecycleFocus = function (ref) {
+  let enabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let lastIndex = arguments.length > 2 ? arguments[2] : undefined;
+  const recycle = i => e => {
+    if (!enabled || !ref.current) {
+      return;
+    }
+    const nextTab = ref.current.querySelectorAll('[tabindex]');
+    if (nextTab) {
+      if (i < 0) {
+        console.log(nextTab[1]);
+        nextTab[1].focus();
+      } else {
+        console.log(nextTab[nextTab.length - 2]);
+        nextTab[nextTab.length - 2].focus();
+      }
+    }
+  };
+  return [/*#__PURE__*/React.createElement(TabFocus, {
+    tabIndex: 1,
+    onFocus: recycle(0)
+  }), /*#__PURE__*/React.createElement(TabFocus, {
+    tabIndex: lastIndex || 1,
+    onFocus: recycle(-1)
+  })];
+};
+
+export { useRecycleFocus };
+//# sourceMappingURL=useRecycleFocus.mjs.map

package/lib/hooks/useRecycleFocus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRecycleFocus.mjs","sources":["../../src/hooks/useRecycleFocus.jsx"],"sourcesContent":["import React from 'react'\nimport styled from 'styled-components'\n\nstyled\n\nconst TabFocus = styled.div`width:0;height:0;position:absolute;`\nexport const useRecycleFocus = (ref, enabled = true,lastIndex) => {\n\n  const recycle = i => (e) => {\n    if (!enabled || !ref.current) {\n      return\n    }\n    const nextTab = ref.current.querySelectorAll('[tabindex]')\n    if (nextTab) {\n      if (i<0) {\n        console.log(nextTab[1])\n        nextTab[1].focus()\n      } else {\n        console.log(nextTab[nextTab.length - 2])\n        nextTab[nextTab.length - 2].focus()\n      }\n    }\n  }\n\n  return [<TabFocus tabIndex={1} onFocus={recycle(0)}></TabFocus>,<TabFocus tabIndex={lastIndex || 1} onFocus={recycle(-1)}></TabFocus>]\n}"],"names":["TabFocus","styled","div","withConfig","displayName","componentId","useRecycleFocus","ref","enabled","arguments","length","undefined","lastIndex","recycle","i","e","current","nextTab","querySelectorAll","console","log","focus","React","createElement","tabIndex","onFocus"],"mappings":";;;AAKA,MAAMA,QAAQ,gBAAGC,MAAM,CAACC,GAAG,CAAAC,UAAA,CAAA;EAAAC,WAAA,EAAA,2BAAA;EAAAC,WAAA,EAAA,UAAA;AAAA,CAAqC,CAAA,CAAA,CAAA,qCAAA,CAAA,CAAA,CAAA;MACnDC,eAAe,GAAG,UAACC,GAAG,EAA+B;AAAA,EAAA,IAA7BC,OAAO,GAAAC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAG,IAAI,CAAA;EAAA,IAACG,SAAS,GAAAH,SAAA,CAAAC,MAAA,GAAAD,CAAAA,GAAAA,SAAA,MAAAE,SAAA,CAAA;AAE3D,EAAA,MAAME,OAAO,GAAGC,CAAC,IAAKC,CAAC,IAAK;AAC1B,IAAA,IAAI,CAACP,OAAO,IAAI,CAACD,GAAG,CAACS,OAAO,EAAE;AAC5B,MAAA,OAAA;AACF,KAAA;IACA,MAAMC,OAAO,GAAGV,GAAG,CAACS,OAAO,CAACE,gBAAgB,CAAC,YAAY,CAAC,CAAA;AAC1D,IAAA,IAAID,OAAO,EAAE;MACX,IAAIH,CAAC,GAAC,CAAC,EAAE;AACPK,QAAAA,OAAO,CAACC,GAAG,CAACH,OAAO,CAAC,CAAC,CAAC,CAAC,CAAA;AACvBA,QAAAA,OAAO,CAAC,CAAC,CAAC,CAACI,KAAK,EAAE,CAAA;AACpB,OAAC,MAAM;QACLF,OAAO,CAACC,GAAG,CAACH,OAAO,CAACA,OAAO,CAACP,MAAM,GAAG,CAAC,CAAC,CAAC,CAAA;QACxCO,OAAO,CAACA,OAAO,CAACP,MAAM,GAAG,CAAC,CAAC,CAACW,KAAK,EAAE,CAAA;AACrC,OAAA;AACF,KAAA;GACD,CAAA;AAED,EAAA,OAAO,cAACC,KAAA,CAAAC,aAAA,CAACvB,QAAQ,EAAA;AAACwB,IAAAA,QAAQ,EAAE,CAAE;IAACC,OAAO,EAAEZ,OAAO,CAAC,CAAC,CAAA;AAAE,GAAW,CAAC,eAACS,KAAA,CAAAC,aAAA,CAACvB,QAAQ,EAAA;IAACwB,QAAQ,EAAEZ,SAAS,IAAI,CAAE;AAACa,IAAAA,OAAO,EAAEZ,OAAO,CAAC,CAAC,CAAC,CAAA;AAAE,GAAW,CAAC,CAAC,CAAA;AACxI;;;;"}

package/lib/hooks/useRefMemo.mjs

@@ -0,0 +1,13 @@
+import { useRef } from 'react';
+import { callIfFunction } from '@startlibs/utils';
+
+const useRefMemo = value => {
+  const ref = useRef(value);
+  if (ref.current !== value) {
+    ref.current = callIfFunction(value);
+  }
+  return ref;
+};
+
+export { useRefMemo };
+//# sourceMappingURL=useRefMemo.mjs.map

package/lib/hooks/useRefMemo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRefMemo.mjs","sources":["../../src/hooks/useRefMemo.jsx"],"sourcesContent":["import React, {useRef} from 'react'\nimport  {callIfFunction} from '@startlibs/utils'\n\nexport const useRefMemo = (value) => {\n  const ref = useRef(value)\n  if (ref.current !== value) {\n    ref.current = callIfFunction(value)\n  }\n  return ref\n}"],"names":["useRefMemo","value","ref","useRef","current","callIfFunction"],"mappings":";;;AAGaA,MAAAA,UAAU,GAAIC,KAAK,IAAK;AACnC,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACF,KAAK,CAAC,CAAA;AACzB,EAAA,IAAIC,GAAG,CAACE,OAAO,KAAKH,KAAK,EAAE;AACzBC,IAAAA,GAAG,CAACE,OAAO,GAAGC,cAAc,CAACJ,KAAK,CAAC,CAAA;AACrC,GAAA;AACA,EAAA,OAAOC,GAAG,CAAA;AACZ;;;;"}

package/lib/hooks/useRefState.mjs

@@ -0,0 +1,29 @@
+import { useRef, useMemo } from 'react';
+import { callIfFunction, callIfFunctions, _s } from '@startlibs/utils';
+
+const isPath = path => typeof path === 'string' || typeof path === 'number' || Array.isArray(path);
+const getter = value => path => path !== "" && isPath(path) ? _s.get(path, value) : value;
+const uninitialized = {};
+const useRefState = (defaultValue, setCallback) => {
+  const ref = useRef(uninitialized);
+  if (ref.current === uninitialized) {
+    ref.current = callIfFunction(defaultValue);
+  }
+  return useMemo(() => {
+    const get = path => getter(ref.current)(path);
+    const set = (v, config) => {
+      const prev = ref.current;
+      ref.current = callIfFunctions(v, () => get());
+      if (prev !== ref.current && (!config || !config.ignoreCallback)) {
+        callIfFunction(setCallback, prev, ref.current);
+      }
+    };
+    return {
+      get,
+      set
+    };
+  }, []);
+};
+
+export { useRefState };
+//# sourceMappingURL=useRefState.mjs.map

package/lib/hooks/useRefState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRefState.mjs","sources":["../../src/hooks/useRefState.js"],"sourcesContent":["import React, {useMemo, useRef} from 'react'\nimport {_s, callIfFunction, callIfFunctions} from '@startlibs/utils'\n\nconst isPath = (path) => typeof path === 'string' || typeof path === 'number' || Array.isArray(path)\n\nconst getter = (value) => path => path !== \"\" && isPath(path) ? _s.get(path,value) : value\n\nconst uninitialized = {}\n\nexport const useRefState = (defaultValue, setCallback) => {\n  const ref = useRef(uninitialized)\n  if (ref.current === uninitialized) {\n    ref.current = callIfFunction(defaultValue)\n  }\n  return useMemo(() => {\n    const get = (path) => getter(ref.current)(path)\n    const set = (v, config) => {\n      const prev = ref.current\n      ref.current = callIfFunctions(v, () => get())\n      if (prev !== ref.current && (!config || !config.ignoreCallback)) {\n        callIfFunction(setCallback, prev, ref.current)\n      }\n    }\n    return {get, set}\n  }, [])\n}\n"],"names":["isPath","path","Array","isArray","getter","value","_s","get","uninitialized","useRefState","defaultValue","setCallback","ref","useRef","current","callIfFunction","useMemo","set","v","config","prev","callIfFunctions","ignoreCallback"],"mappings":";;;AAGA,MAAMA,MAAM,GAAIC,IAAI,IAAK,OAAOA,IAAI,KAAK,QAAQ,IAAI,OAAOA,IAAI,KAAK,QAAQ,IAAIC,KAAK,CAACC,OAAO,CAACF,IAAI,CAAC,CAAA;AAEpG,MAAMG,MAAM,GAAIC,KAAK,IAAKJ,IAAI,IAAIA,IAAI,KAAK,EAAE,IAAID,MAAM,CAACC,IAAI,CAAC,GAAGK,EAAE,CAACC,GAAG,CAACN,IAAI,EAACI,KAAK,CAAC,GAAGA,KAAK,CAAA;AAE1F,MAAMG,aAAa,GAAG,EAAE,CAAA;MAEXC,WAAW,GAAGA,CAACC,YAAY,EAAEC,WAAW,KAAK;AACxD,EAAA,MAAMC,GAAG,GAAGC,MAAM,CAACL,aAAa,CAAC,CAAA;AACjC,EAAA,IAAII,GAAG,CAACE,OAAO,KAAKN,aAAa,EAAE;AACjCI,IAAAA,GAAG,CAACE,OAAO,GAAGC,cAAc,CAACL,YAAY,CAAC,CAAA;AAC5C,GAAA;EACA,OAAOM,OAAO,CAAC,MAAM;AACnB,IAAA,MAAMT,GAAG,GAAIN,IAAI,IAAKG,MAAM,CAACQ,GAAG,CAACE,OAAO,CAAC,CAACb,IAAI,CAAC,CAAA;AAC/C,IAAA,MAAMgB,GAAG,GAAGA,CAACC,CAAC,EAAEC,MAAM,KAAK;AACzB,MAAA,MAAMC,IAAI,GAAGR,GAAG,CAACE,OAAO,CAAA;MACxBF,GAAG,CAACE,OAAO,GAAGO,eAAe,CAACH,CAAC,EAAE,MAAMX,GAAG,EAAE,CAAC,CAAA;AAC7C,MAAA,IAAIa,IAAI,KAAKR,GAAG,CAACE,OAAO,KAAK,CAACK,MAAM,IAAI,CAACA,MAAM,CAACG,cAAc,CAAC,EAAE;QAC/DP,cAAc,CAACJ,WAAW,EAAES,IAAI,EAAER,GAAG,CAACE,OAAO,CAAC,CAAA;AAChD,OAAA;KACD,CAAA;IACD,OAAO;MAACP,GAAG;AAAEU,MAAAA,GAAAA;KAAI,CAAA;GAClB,EAAE,EAAE,CAAC,CAAA;AACR;;;;"}

package/lib/hooks/useSignal.mjs

@@ -0,0 +1,271 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _isPlainObject from 'lodash/fp/isPlainObject';
+import _update from 'lodash/fp/update';
+import _identity from 'lodash/fp/identity';
+import _isArray from 'lodash/fp/isArray';
+import React, { useRef, useEffect, startTransition, useContext, useState, use, useCallback, useMemo } from 'react';
+import { useLazyConstant, useConstant } from './useConstant.mjs';
+import { useForceUpdate } from './useForceUpdate.mjs';
+import { _s, callIfFunction } from '@startlibs/utils';
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const IS_ARRAY_ITEMS_EQUALS = (a, b) => a.length === b.length && !a.some((x, i) => !Object.is(x, b[i]));
+const IS_DEPS_EQUALS = function () {
+  let a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return Object.is(a, b) || IS_ARRAY_ITEMS_EQUALS(a, b);
+};
+const SHALLOW_IS_EQUAL = (a, b) => Object.is(a, b) || _isArray(a) && _isArray(b) && IS_ARRAY_ITEMS_EQUALS(a, b);
+const EMPTY_DEPS = [];
+const EMPTY_VALUE = {
+  "EMPTY": true
+};
+const useUpdateSignal = initialValue => {
+  const value = useRef(initialValue);
+  value.current = initialValue;
+  return useLazyConstant(() => {
+    let registered = [];
+    const register = function () {
+      let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity;
+      let isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
+      let withTransition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      const selectorRef = useRef();
+      selectorRef.current = selector;
+      const update = useForceUpdate();
+      const lastValueRef = useRef(_s.select(selectorRef.current, value.current));
+      useEffect(() => {
+        const item = [update, selectorRef, isEqual, lastValueRef, withTransition];
+        registered = [...registered, item];
+        return () => {
+          registered = registered.filter(v => v !== item);
+        };
+      }, []);
+      if (value.current === EMPTY_VALUE) {
+        return EMPTY_VALUE;
+      }
+      return lastValueRef.current;
+    };
+    const call = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return registered.forEach(_ref => {
+        let _ref2 = _slicedToArray(_ref, 5),
+          fn = _ref2[0],
+          selectorRef = _ref2[1],
+          isEqual = _ref2[2],
+          lastValueRef = _ref2[3],
+          withTransition = _ref2[4];
+        const nextValue = _s.select(selectorRef.current, ...args);
+        if (!callIfFunction(isEqual, nextValue, lastValueRef.current)) {
+          lastValueRef.current = nextValue;
+          if (withTransition) {
+            (withTransition === true ? startTransition : withTransition)(() => fn(nextValue));
+          } else {
+            fn(nextValue);
+          }
+        }
+      });
+    };
+    return [register, call];
+  });
+};
+const useSelectorSignal = value => {
+  const prevValue = useRef(value);
+  const _useUpdateSignal = useUpdateSignal(value),
+    _useUpdateSignal2 = _slicedToArray(_useUpdateSignal, 2),
+    _register = _useUpdateSignal2[0],
+    call = _useUpdateSignal2[1];
+  const register = useCallback((selector, deps, isEqual, withTransition) => {
+    const prevDeps = useRef(EMPTY_DEPS);
+    if (prevDeps.current !== EMPTY_DEPS && !IS_DEPS_EQUALS(deps, prevDeps.current)) {
+      call(prevValue.current);
+    }
+    prevDeps.current = deps;
+    return _register(selector, isEqual, withTransition);
+  }, []);
+  useEffect(() => {
+    if (prevValue.current !== value) {
+      prevValue.current = value;
+      call(value);
+    }
+  }, [value]);
+  return register;
+};
+const updateStateFn = (path, update) => state => path ? _update(path, v => callIfFunction(update, v), state) : callIfFunction(update, state);
+const createStatefulContext = (v, defaultIsEqual) => {
+  const Ctx = /*#__PURE__*/React.createContext(v);
+  const Provider = _ref3 => {
+    let value = _ref3.value,
+      setValue = _ref3.setValue,
+      utils = _ref3.utils,
+      children = _ref3.children;
+    const register = useSelectorSignal(value);
+    const v = useLazyConstant(() => [register, setValue, utils]);
+    return /*#__PURE__*/React.createElement(Ctx.Provider, {
+      value: v
+    }, children);
+  };
+  const useCtx = () => useContext(Ctx);
+  const useSelectValue = (selector, deps, defaultIsEqual, withTransition) => {
+    const _useCtx = useCtx(),
+      _useCtx2 = _slicedToArray(_useCtx, 1),
+      useRegister = _useCtx2[0];
+    if (deps === true) {
+      return useRegister(selector, [], undefined, startTransition);
+    } else if (_isPlainObject(deps)) {
+      return useRegister(selector, deps.deps, deps.isEqual, deps.withTransition);
+    } else {
+      return useRegister(selector, _isArray(deps) ? deps : deps === null || deps === void 0 ? void 0 : deps.deps, defaultIsEqual, withTransition);
+    }
+  };
+  const useSetValue = path => {
+    const _useCtx3 = useCtx(),
+      _useCtx4 = _slicedToArray(_useCtx3, 2);
+      _useCtx4[0];
+      const set = _useCtx4[1];
+    return useConstant(update => set(updateStateFn(path, update)));
+  };
+  const useUtils = (path, deps) => {
+    const _useCtx5 = useCtx(),
+      _useCtx6 = _slicedToArray(_useCtx5, 3);
+      _useCtx6[0];
+      _useCtx6[1];
+      const utils = _useCtx6[2];
+    return utils;
+  };
+  return [Provider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+const createSelfStatefulContext = (v, defaultIsEqual) => {
+  const _createStatefulContex = createStatefulContext(v),
+    _createStatefulContex2 = _slicedToArray(_createStatefulContex, 2),
+    Provider = _createStatefulContex2[0],
+    _createStatefulContex3 = _slicedToArray(_createStatefulContex2[1], 4),
+    useSelectValue = _createStatefulContex3[0],
+    useSetValue = _createStatefulContex3[1],
+    useUtils = _createStatefulContex3[2],
+    useCtx = _createStatefulContex3[3];
+  const StateFullProvider = _ref4 => {
+    let _ref4$init = _ref4.init,
+      init = _ref4$init === void 0 ? {} : _ref4$init,
+      utils = _ref4.utils,
+      children = _ref4.children;
+    const _useState = useState(init),
+      _useState2 = _slicedToArray(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+    return /*#__PURE__*/React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: utils
+    }, children);
+  };
+  return [StateFullProvider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+const createLazyStatefulContext = (toPromise, defaultIsEqual) => {
+  const _createStatefulContex4 = createStatefulContext(EMPTY_VALUE),
+    _createStatefulContex5 = _slicedToArray(_createStatefulContex4, 2),
+    Provider = _createStatefulContex5[0],
+    _createStatefulContex6 = _slicedToArray(_createStatefulContex5[1], 4),
+    useSelectValue = _createStatefulContex6[0];
+    _createStatefulContex6[1];
+    const useUtils = _createStatefulContex6[2],
+    useCtx = _createStatefulContex6[3];
+  const useSelectLazyValue = function (selector, deps) {
+    let isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultIsEqual;
+    let withTransition = arguments.length > 3 ? arguments[3] : undefined;
+    const value = useSelectValue(selector, deps, isEqual, withTransition);
+    const utils = useUtils();
+    if (value === EMPTY_VALUE) {
+      const loadedValue = use(utils._lazyValue());
+      return _s.select(selector, loadedValue);
+    }
+    return value;
+  };
+  const useSetLazyValue = path => {
+    const _useCtx7 = useCtx(),
+      _useCtx8 = _slicedToArray(_useCtx7, 3),
+      setValue = _useCtx8[1],
+      utils = _useCtx8[2];
+    return useConstant(update => {
+      return setValue(value => value === EMPTY_VALUE ? updateStateFn(path, update)(utils.loadedValue()) : updateStateFn(path, update)(value));
+    });
+  };
+  const useValuePromise = (selector, deps, isEqual, withTransition) => {
+    const value = useSelectValue(selector, deps, isEqual, withTransition);
+    const utils = useUtils();
+    return useCallback(() => {
+      if (value === EMPTY_VALUE) {
+        return utils._lazyValue().then(v => console.log(v, _s.select(selector, v), selector) || _s.select(selector, v));
+      }
+      return new Promise(value);
+    }, [value, deps]);
+  };
+  const LazyStateFullProvider = _ref5 => {
+    let value = _ref5.value,
+      utils = _ref5.utils,
+      children = _ref5.children,
+      _ref5$fallback = _ref5.fallback,
+      fallback = _ref5$fallback === void 0 ? null : _ref5$fallback;
+    const _useState3 = useState(EMPTY_VALUE),
+      _useState4 = _slicedToArray(_useState3, 2),
+      state = _useState4[0],
+      setState = _useState4[1];
+    const promise = useRef();
+    const loadedValue = useRef();
+    const lazyUtils = useMemo(() => _objectSpread(_objectSpread({}, utils), {}, {
+      _lazyValue: () => {
+        var _promise$current;
+        (_promise$current = promise.current) !== null && _promise$current !== void 0 ? _promise$current : promise.current = callIfFunction(toPromise || _identity, value);
+        promise.current.then(value => {
+          loadedValue.current = value;
+        });
+        return promise.current;
+      },
+      loadedValue: () => loadedValue.current
+    }), [value, utils]);
+    return /*#__PURE__*/React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: lazyUtils
+    }, fallback === false ? children : /*#__PURE__*/React.createElement(React.Suspense, {
+      fallback: fallback
+    }, children));
+  };
+  return [LazyStateFullProvider, [useSelectLazyValue, useSetLazyValue, useValuePromise]];
+};
+const createSelectableContext = v => {
+  const _createStatefulContex7 = createStatefulContext(v),
+    _createStatefulContex8 = _slicedToArray(_createStatefulContex7, 2),
+    Provider = _createStatefulContex8[0],
+    _createStatefulContex9 = _slicedToArray(_createStatefulContex8[1], 1),
+    useSelectValue = _createStatefulContex9[0];
+  return [Provider, useSelectValue];
+};
+const createTriggerUpdateContext = v => {
+  const _createStatefulContex0 = createStatefulContext(v),
+    _createStatefulContex1 = _slicedToArray(_createStatefulContex0, 2),
+    Provider = _createStatefulContex1[0],
+    _createStatefulContex10 = _slicedToArray(_createStatefulContex1[1], 1),
+    useSelectValue = _createStatefulContex10[0];
+  const TriggerProvider = /*#__PURE__*/React.forwardRef((_ref6, ref) => {
+    let children = _ref6.children;
+    const _useState5 = useState(0),
+      _useState6 = _slicedToArray(_useState5, 2),
+      v = _useState6[0],
+      setV = _useState6[1];
+    const trigger = React.useMemo(() => () => setV(v => v + 1), [v]);
+    React.useImperativeHandle(ref, () => ({
+      trigger
+    }), []);
+    return /*#__PURE__*/React.createElement(Provider, {
+      value: trigger
+    }, children);
+  });
+  return [TriggerProvider, useSelectValue];
+};
+
+export { createLazyStatefulContext, createSelectableContext, createSelfStatefulContext, createStatefulContext, createTriggerUpdateContext, useUpdateSignal };
+//# sourceMappingURL=useSignal.mjs.map