@dreamtree-org/twreact-ui 1.2.1 → 1.3.1

package/dist/esm/store/store.js

@@ -0,0 +1,107 @@
+import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { createListenerMiddleware, combineReducers, configureStore, isAnyOf } from '@reduxjs/toolkit';
+import { EmitterClass } from '../utils/emitter.js';
+import { createMigrate, persistReducer, FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER, persistStore } from 'redux-persist';
+import storage from 'redux-persist/lib/storage';
+import getStore, { promiseMap } from './storeSlice.js';
+
+var listenerMiddleware = createListenerMiddleware();
+// Persist config
+var PERSIST_VERSION = 1;
+var persistConfig = {
+  key: "root",
+  version: PERSIST_VERSION,
+  storage: storage,
+  whitelist: ["storeSlice"],
+  // only persist these reducers
+  migrate: createMigrate({
+    // Example migration for future schema changes
+    1: function _(state) {
+      return state;
+    } // current
+  }, {
+    debug: false
+  })
+};
+function setupStore() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var emitter = EmitterClass.getInstance();
+  var context = {
+    emitter: emitter,
+    changes: []
+  };
+  var storeData = getStore(initialState, context);
+  var storeSlice = storeData.reducer;
+  var actions = storeData.actions;
+  var rootReducer = combineReducers({
+    storeSlice: storeSlice
+  });
+  var persistedReducer = persistReducer(persistConfig, rootReducer);
+  var store = configureStore({
+    reducer: persistedReducer,
+    middleware: function middleware(getDefault) {
+      return getDefault({
+        serializableCheck: {
+          // Ignore redux-persist action types and setStore action
+          ignoredActions: [FLUSH, REHYDRATE, PAUSE, PERSIST, PURGE, REGISTER, 'store/setStore']
+        }
+      }).concat(listenerMiddleware.middleware);
+    },
+    devTools: process.env.NODE_ENV !== "production"
+  });
+  var persistor = persistStore(store);
+  listenerMiddleware.startListening({
+    matcher: isAnyOf(actions.setStore),
+    effect: function () {
+      var _effect = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(action, _api) {
+        var changeEvent, uniqueId, value, promise;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              try {
+                // Get state for future use if needed
+                // const state = _api.getState();
+                changeEvent = action.payload; // do things after state is reduced
+                uniqueId = changeEvent.uniqueId, value = changeEvent.value; // Resolve promise from module-level map if it exists
+                if (promiseMap && promiseMap.has(uniqueId)) {
+                  promise = promiseMap.get(uniqueId);
+                  if (promise && typeof promise.resolve === 'function') {
+                    promise.resolve(value);
+                  }
+                  // Clean up fulfilled promises
+                  if (promise && promise.isFulfilled()) {
+                    promiseMap["delete"](uniqueId);
+                  }
+                }
+                // Clean up changes array - remove fulfilled promises
+                context.changes = context.changes.filter(function (change) {
+                  // Check if promise still exists in promiseMap
+                  if (promiseMap && promiseMap.has(change.uniqueId)) {
+                    var _promise = promiseMap.get(change.uniqueId);
+                    return _promise && !_promise.isFulfilled();
+                  }
+                  return false;
+                });
+              } catch (error) {
+                console.error('Error in setStore listener middleware:', error);
+                // Don't throw - let the action complete even if promise resolution fails
+              }
+            case 1:
+              return _context.a(2);
+          }
+        }, _callee);
+      }));
+      function effect(_x, _x2) {
+        return _effect.apply(this, arguments);
+      }
+      return effect;
+    }()
+  });
+  return {
+    store: store,
+    persistor: persistor,
+    actions: actions
+  };
+}
+
+export { setupStore as default, listenerMiddleware, setupStore };

package/dist/esm/store/storeSlice.js

@@ -0,0 +1,45 @@
+import { createSlice } from '@reduxjs/toolkit';
+import helperInstance from '../utils/helpers.js';
+
+// src/store/storeSlice.ts
+var storeInstance = {
+  actions: {}
+};
+var promiseMap = new Map();
+function getStore() {
+  var initialState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var storeSlice = createSlice({
+    name: "store",
+    initialState: initialState,
+    reducers: {
+      setStore: function setStore(state, _ref) {
+        var payload = _ref.payload;
+        // Extract only serializable data
+        var name = payload.name,
+          value = payload.value,
+          uniqueId = payload.uniqueId;
+        // Store change event for listener middleware (without promise)
+        // Note: We no longer store resolve/reject functions here - they're in promiseMap
+        if (context.changes) {
+          var changeEvent = {
+            name: name,
+            value: value,
+            uniqueId: uniqueId
+          };
+          context.changes.push(changeEvent);
+        }
+        var newState = helperInstance.setNested(state, name, value);
+        return newState;
+      }
+    }
+  });
+  var setStore = storeSlice.actions.setStore;
+  storeInstance.reducer = storeSlice.reducer;
+  storeInstance.actions = {
+    setStore: setStore
+  };
+  return storeInstance;
+}
+
+export { getStore as default, getStore, promiseMap, storeInstance };

package/dist/esm/utils/cn.js

@@ -0,0 +1,11 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+function cn() {
+  for (var _len = arguments.length, inputs = new Array(_len), _key = 0; _key < _len; _key++) {
+    inputs[_key] = arguments[_key];
+  }
+  return twMerge(clsx(inputs));
+}
+
+export { cn };

package/dist/esm/utils/emitter.js

@@ -0,0 +1,169 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+var EmitterClass = /*#__PURE__*/function () {
+  function EmitterClass() {
+    _classCallCheck(this, EmitterClass);
+    this.events = {};
+    this.testCallback = null;
+  }
+  return _createClass(EmitterClass, [{
+    key: "onCheck",
+    value: function onCheck(callback) {
+      this.testCallback = callback;
+    }
+  }, {
+    key: "on",
+    value: function on(event, listener) {
+      if (!this.events[event]) {
+        this.events[event] = [];
+      }
+      this.events[event].push({
+        listener: listener,
+        once: false
+      });
+    }
+  }, {
+    key: "onOnce",
+    value: function onOnce(event, listener) {
+      if (!this.events[event]) {
+        this.events[event] = [];
+      }
+      this.events[event].push({
+        listener: listener,
+        once: true
+      });
+    }
+  }, {
+    key: "offAll",
+    value: function offAll(event) {
+      if (!this.events[event]) {
+        return;
+      }
+      this.events[event] = [];
+    }
+  }, {
+    key: "onSchedule",
+    value: function onSchedule(event, listener, schedule) {
+      if (!this.events[event]) {
+        this.events[event] = [];
+      }
+      this.events[event].push({
+        listener: listener,
+        schedule: schedule
+      });
+    }
+  }, {
+    key: "emit",
+    value: function emit(event) {
+      var _this = this;
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      return new Promise(function (resolve, reject) {
+        _this.executeEvent.apply(_this, [event, {
+          resolve: resolve,
+          reject: reject
+        }].concat(args));
+      });
+    }
+  }, {
+    key: "executeEvent",
+    value: function executeEvent(event) {
+      var _this2 = this;
+      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+        args[_key2 - 2] = arguments[_key2];
+      }
+      try {
+        if (this.testCallback) {
+          this.testCallback({
+            event: event,
+            args: args
+          });
+        }
+        if (!this.events[event]) {
+          if (typeof config.resolve === "function") {
+            config.resolve(undefined);
+          }
+          return;
+        }
+        this.events[event].forEach(function (payload) {
+          var listener = payload.listener,
+            once = payload.once,
+            schedule = payload.schedule;
+          var resolveListener = function resolveListener() {
+            var result = listener.apply(void 0, args);
+            config.resolve(result);
+          };
+          if (schedule) {
+            var now = new Date();
+            var nextRun;
+            var delay = -1;
+            if (schedule instanceof Date) {
+              nextRun = schedule;
+              delay = nextRun.getTime() - now.getTime();
+            } else if (typeof schedule === "number") {
+              delay = schedule;
+            } else if (typeof schedule === "string") {
+              nextRun = new Date(schedule);
+              delay = nextRun.getTime() - now.getTime();
+            }
+            if (delay > 0) {
+              setTimeout(function () {
+                resolveListener();
+              }, delay);
+            } else {
+              resolveListener();
+            }
+          } else {
+            resolveListener();
+          }
+          if (once) {
+            _this2.off(event, listener);
+          }
+        });
+      } catch (error) {
+        config.reject(error);
+      }
+    }
+  }, {
+    key: "off",
+    value: function off(event, listener) {
+      if (!this.events[event]) {
+        return;
+      }
+      this.events[event] = this.events[event].filter(function (payload) {
+        var payloadListener = payload.listener;
+        return payloadListener !== listener;
+      });
+    }
+  }], [{
+    key: "getInstance",
+    value: function getInstance() {
+      return new EmitterClass();
+    }
+  }]);
+}();
+var Emitter = /*#__PURE__*/function () {
+  function Emitter() {
+    _classCallCheck(this, Emitter);
+    if (Emitter.instanceMap.has(this)) {
+      return Emitter.instanceMap.get(this);
+    }
+    Emitter.instanceMap.set(this, new EmitterClass());
+  }
+  return _createClass(Emitter, null, [{
+    key: "getInstance",
+    value: function getInstance() {
+      var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
+      if (this.instanceMap.has(name)) {
+        return this.instanceMap.get(name);
+      }
+      this.instanceMap.set(name, new EmitterClass());
+      return this.instanceMap.get(name);
+    }
+  }]);
+}();
+Emitter.instanceMap = new Map();
+
+export { Emitter, EmitterClass, Emitter as default };

package/dist/esm/utils/helpers.js

@@ -0,0 +1,161 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+var Helpers = /*#__PURE__*/function () {
+  function Helpers() {
+    _classCallCheck(this, Helpers);
+  }
+  /**
+   * Traverses an object by a dotted path and returns the nested value.
+   * If `options.prefix` is provided, starts from that subkey of state.
+   * @param path - Dot-separated path, e.g. "a.b.c"
+   * @param options - { state?: Object, prefix?: string }
+   * @returns Reference to the nested object or value
+   *
+   * Example:
+   *   let obj = { foo: { bar: { baz: 5 } } };
+   *   Helpers.dotWalk("bar.baz", { state: obj.foo }) // returns 5
+   */
+  return _createClass(Helpers, [{
+    key: "dotWalk",
+    value: function dotWalk(path) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // The state root is provided via options.state or this.state (if available)
+      var state = options.state || this.state;
+      if (!state || _typeof(state) !== "object") {
+        throw new Error("dotWalk requires a state object via options.state");
+      }
+      var arr = path.split(".");
+      var tmp = state;
+      // Use prefix if provided
+      var prefix = options.prefix || "";
+      if (prefix) {
+        tmp = tmp[prefix];
+      }
+      for (var i = 0; i < arr.length; i++) {
+        if (tmp == null) return undefined;
+        tmp = tmp[arr[i]];
+      }
+      return tmp;
+    }
+  }, {
+    key: "setNested",
+    value: function setNested(state, name, value) {
+      var payload = {
+        name: name,
+        value: value
+      };
+      var old = state;
+      var tmp = old;
+      var key = "";
+      var arr = payload.name.split(".");
+      if (arr.length > 1) {
+        arr.forEach(function (k) {
+          old = tmp;
+          tmp[k] = tmp[k] || {};
+          tmp = tmp[k];
+          key = k;
+        });
+        old[key] = payload.value;
+      } else {
+        key = payload.name;
+        old = state[key];
+        state[key] = payload.value;
+      }
+      return state;
+    }
+    /**
+     * Creates and returns a debounced version of the given callback.
+     * The debounced function delays invoking the callback until after delay ms have elapsed
+     * since the last time the debounced function was invoked.
+     * The debounce state (timeout) is stored per instance; if you need per-callback
+     * isolation, use a closure or bind a new Helpers() instance.
+     *
+     * @param delay - Delay in milliseconds
+     * @returns Debounced promise with clear method
+     */
+  }, {
+    key: "debounce",
+    value: function debounce() {
+      var delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1000;
+      var timeoutId = 0;
+      var promise = new Promise(function (resolve, reject) {
+        try {
+          timeoutId = setTimeout(function () {
+            resolve();
+          }, delay);
+        } catch (error) {
+          reject(error);
+        }
+      });
+      var _clear = function _clear() {
+        clearTimeout(timeoutId);
+        timeoutId = 0;
+      };
+      promise._clear = _clear; // Add the clear method to the promise
+      return promise;
+    }
+  }]);
+}();
+// A serializable-safe TrackingPromise that *does not* put the promise or any methods in the redux action payload.
+// This class is only intended to be used locally (not as part of redux/store payloads).
+// DO NOT EVER put an instance of TrackingPromise directly in redux actions.
+var TrackingPromise = /*#__PURE__*/function () {
+  function TrackingPromise(callback) {
+    var _this = this;
+    _classCallCheck(this, TrackingPromise);
+    this._state = "pending";
+    this._callback = callback;
+    this._promise = new Promise(function (resolve, reject) {
+      _this._resolve = function (value) {
+        _this._state = "fulfilled";
+        resolve(value);
+      };
+      _this._reject = function (reason) {
+        _this._state = "rejected";
+        reject(reason);
+      };
+      _this._callback(_this._resolve, _this._reject);
+    });
+  }
+  return _createClass(TrackingPromise, [{
+    key: "resolve",
+    value: function resolve(value) {
+      if (this._state !== "pending") return;
+      this._resolve(value);
+    }
+  }, {
+    key: "reject",
+    value: function reject(reason) {
+      if (this._state !== "pending") return;
+      this._reject(reason);
+    }
+  }, {
+    key: "isFulfilled",
+    value: function isFulfilled() {
+      return this._state === "fulfilled";
+    }
+  }, {
+    key: "isRejected",
+    value: function isRejected() {
+      return this._state === "rejected";
+    }
+  }, {
+    key: "isPending",
+    value: function isPending() {
+      return this._state === "pending";
+    }
+  }, {
+    key: "then",
+    value: function then(onFulfilled, onRejected) {
+      return this._promise.then(onFulfilled, onRejected);
+    }
+  }, {
+    key: "catch",
+    value: function _catch(onRejected) {
+      return this._promise["catch"](onRejected);
+    }
+  }]);
+}();
+var helperInstance = new Helpers();
+
+export { Helpers, TrackingPromise, helperInstance as default };

package/dist/esm/utils/position.js

@@ -0,0 +1,134 @@
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+// Internal (not exported). Viewport-space positioning shared by Popover and Tour.
+// All rects are getBoundingClientRect() values, so the result is for
+// `position: fixed`.
+var OPPOSITE = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function parsePlacement() {
+  var placement = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "bottom";
+  var _String$split = String(placement).split("-"),
+    _String$split2 = _slicedToArray(_String$split, 2),
+    _String$split2$ = _String$split2[0],
+    side = _String$split2$ === void 0 ? "bottom" : _String$split2$,
+    _String$split2$2 = _String$split2[1],
+    align = _String$split2$2 === void 0 ? "center" : _String$split2$2;
+  return {
+    side: OPPOSITE[side] ? side : "bottom",
+    align: align
+  };
+}
+function roomOn(side, anchor, viewport) {
+  if (side === "top") return anchor.top;
+  if (side === "bottom") return viewport.height - anchor.bottom;
+  if (side === "left") return anchor.left;
+  return viewport.width - anchor.right;
+}
+function chooseSide(side, anchor, size, offset, viewport) {
+  var needed = (side === "top" || side === "bottom" ? size.height : size.width) + offset;
+  if (roomOn(side, anchor, viewport) >= needed) return side;
+  var flipped = OPPOSITE[side];
+  return roomOn(flipped, anchor, viewport) > roomOn(side, anchor, viewport) ? flipped : side;
+}
+function alignAxis(align, start, length, size) {
+  if (align === "start") return start;
+  if (align === "end") return start + length - size;
+  return start + length / 2 - size / 2;
+}
+var clamp = function clamp(value, min, max) {
+  return Math.max(min, Math.min(value, Math.max(min, max)));
+};
+/**
+ * Places a floating box of `size` next to `anchor`. Flips to the opposite side
+ * when the requested side lacks room, then clamps into the viewport.
+ * Returns `{ top, left, side }`.
+ */
+function computePosition(anchor, size, _ref) {
+  var placement = _ref.placement,
+    _ref$offset = _ref.offset,
+    offset = _ref$offset === void 0 ? 8 : _ref$offset,
+    _ref$padding = _ref.padding,
+    padding = _ref$padding === void 0 ? 8 : _ref$padding,
+    viewport = _ref.viewport;
+  var vp = viewport || {
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+  var _parsePlacement = parsePlacement(placement),
+    wanted = _parsePlacement.side,
+    align = _parsePlacement.align;
+  var side = chooseSide(wanted, anchor, size, offset, vp);
+  var top;
+  var left;
+  if (side === "top" || side === "bottom") {
+    top = side === "top" ? anchor.top - size.height - offset : anchor.bottom + offset;
+    left = alignAxis(align, anchor.left, anchor.width, size.width);
+  } else {
+    left = side === "left" ? anchor.left - size.width - offset : anchor.right + offset;
+    top = alignAxis(align, anchor.top, anchor.height, size.height);
+  }
+  return {
+    top: Math.round(clamp(top, padding, vp.height - size.height - padding)),
+    left: Math.round(clamp(left, padding, vp.width - size.width - padding)),
+    side: side
+  };
+}
+/** `true` when the user asked the OS for reduced motion. */
+function prefersReducedMotion() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function nearestScroller(el) {
+  var node = el.parentElement;
+  while (node && node !== document.body && node !== document.documentElement) {
+    var _window$getComputedSt = window.getComputedStyle(node),
+      overflowY = _window$getComputedSt.overflowY;
+    if ((overflowY === "auto" || overflowY === "scroll") && node.scrollHeight > node.clientHeight) return node;
+    node = node.parentElement;
+  }
+  return null;
+}
+/**
+ * Scrolls `el` into view through its nearest real scroller only. Unlike
+ * `scrollIntoView`, this never scrolls `overflow: hidden` ancestors (an app
+ * shell's fixed-height root), which would leave the layout shifted afterwards.
+ */
+function revealElement(el) {
+  if (!el || typeof window === "undefined") return;
+  var behavior = prefersReducedMotion() ? "auto" : "smooth";
+  var rect = el.getBoundingClientRect();
+  var scroller = nearestScroller(el);
+  if (scroller && typeof scroller.scrollTo === "function") {
+    var box = scroller.getBoundingClientRect();
+    if (rect.top >= box.top && rect.bottom <= box.bottom) return;
+    var _top = scroller.scrollTop + (rect.top - box.top) - (box.height - rect.height) / 2;
+    scroller.scrollTo({
+      top: Math.max(0, _top),
+      behavior: behavior
+    });
+    return;
+  }
+  if (rect.top >= 0 && rect.bottom <= window.innerHeight) return;
+  if (typeof window.scrollTo !== "function") return;
+  var top = window.scrollY + rect.top - (window.innerHeight - rect.height) / 2;
+  window.scrollTo({
+    top: Math.max(0, top),
+    behavior: behavior
+  });
+}
+/** Assigns one DOM node to several refs (callback or object). */
+function setRefs(node) {
+  for (var _len = arguments.length, refs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    refs[_key - 1] = arguments[_key];
+  }
+  refs.forEach(function (ref) {
+    if (!ref) return;
+    if (typeof ref === "function") ref(node);else ref.current = node;
+  });
+}
+
+export { computePosition, parsePlacement, prefersReducedMotion, revealElement, setRefs };

package/dist/hooks/useApi.d.ts

@@ -2,7 +2,7 @@ import { AxiosInstance, AxiosResponse, Method } from "axios";
 interface UseApiProps {
     BASE_URL?: string | null;
     DEFAULT_HEADERS?: Record<string, string>;
-    apiMap?: Record<string, (data?: any) => ApiConfig>;
+    apiMap?: Record<string, (...args: any[]) => ApiConfig>;
     createRequestInstance?: (baseURL?: string | null, defaultHeaders?: Record<string, string>) => AxiosInstance;
     sendRequest?: (requestInstance: AxiosInstance, method: string, url: string, data?: any, headers?: Record<string, string>) => Promise<AxiosResponse>;
 }
@@ -22,6 +22,7 @@ interface UseApiReturn<T = any> {
     lastRequest: string | null;
     fetchData: (url: string, method: string, data?: any, headers?: Record<string, string>, options?: FetchOptions) => Promise<T>;
     fetchApi: (apiKey: string, data?: any, needLoading?: boolean) => Promise<T>;
+    fetchApiWith: (apiKey: string, args?: any[], options?: FetchOptions) => Promise<T>;
 }
 export declare const useApi: <T = any>(props?: UseApiProps) => UseApiReturn<T>;
 export {};

package/dist/hooks/useApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useApi.d.ts","sourceRoot":"","sources":["../../src/hooks/useApi.ts"],"names":[],"mappings":"AACA,OAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpE,UAAU,WAAW;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,SAAS,CAAC,CAAC;IACnD,qBAAqB,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,CAAC;IAC5G,WAAW,CAAC,EAAE,CACV,eAAe,EAAE,aAAa,EAC9B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/B,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/B;AAED,UAAU,SAAS;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACd;AAED,UAAU,YAAY;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,YAAY,CAAC,CAAC,GAAG,GAAG;IAC1B,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACf,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,CACP,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,CAAC,EAAE,YAAY,KACrB,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,GAAG,GAAG,EAAE,QAAO,WAAgB,KAAG,YAAY,CAAC,CAAC,CA0FvE,CAAC"}
+{"version":3,"file":"useApi.d.ts","sourceRoot":"","sources":["../../src/hooks/useApi.ts"],"names":[],"mappings":"AACA,OAAc,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAEpE,UAAU,WAAW;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,SAAS,CAAC,CAAC;IACvD,qBAAqB,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,CAAC;IAC5G,WAAW,CAAC,EAAE,CACV,eAAe,EAAE,aAAa,EAC9B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC/B,OAAO,CAAC,aAAa,CAAC,CAAC;CAC/B;AAED,UAAU,SAAS;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;CACd;AAED,UAAU,YAAY;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,YAAY,CAAC,CAAC,GAAG,GAAG;IAC1B,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACf,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,CACP,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,GAAG,EACV,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,CAAC,EAAE,YAAY,KACrB,OAAO,CAAC,CAAC,CAAC,CAAC;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5E,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;CACtF;AAED,eAAO,MAAM,MAAM,GAAI,CAAC,GAAG,GAAG,EAAE,QAAO,WAAgB,KAAG,YAAY,CAAC,CAAC,CAiHvE,CAAC"}

package/dist/hooks/useControllableState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Internal (not exported). Controlled/uncontrolled state in one place: when
+ * `value` is defined the component is controlled and `setValue` only notifies
+ * `onChange`; otherwise it also updates internal state.
+ */
+export function useControllableState({ value, defaultValue, onChange }: {
+    value: any;
+    defaultValue: any;
+    onChange: any;
+}): any[];
+//# sourceMappingURL=useControllableState.d.ts.map

package/dist/hooks/useControllableState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useControllableState.d.ts","sourceRoot":"","sources":["../../src/hooks/useControllableState.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;;;;UAcC"}

package/dist/hooks/useFocusTrap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Moves focus into `containerRef` while `active`, restores it to the previously
+ * focused element afterwards (unless the user moved focus elsewhere), routes
+ * Escape to `onEscape`, and — when `trap` — keeps Tab cycling inside.
+ */
+export function useFocusTrap(containerRef: any, { active, onEscape, trap, initialFocusRef, focusKey }: {
+    active: any;
+    onEscape: any;
+    trap?: boolean | undefined;
+    initialFocusRef: any;
+    focusKey: any;
+}): void;
+export const FOCUSABLE_SELECTOR: string;
+export function getFocusable(root: any): any[];
+//# sourceMappingURL=useFocusTrap.d.ts.map