@dreamtree-org/twreact-ui 1.3.0 → 1.3.2

package/dist/esm/hooks/useMixins.js

@@ -0,0 +1,100 @@
+'use client';
+import { slicedToArray as _slicedToArray, objectSpread2 as _objectSpread2 } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { Emitter } from '../utils/emitter.js';
+import { promiseMap, storeInstance } from '../store/storeSlice.js';
+import helperInstance, { TrackingPromise } from '../utils/helpers.js';
+
+var setNested = helperInstance.setNested,
+  dotWalk = helperInstance.dotWalk;
+var inMemoryMap = new Proxy({}, {
+  get: function get(target, name) {
+    return target[name];
+  },
+  set: function set(target, name, value) {
+    target[name] = value;
+    return true;
+  }
+});
+var useMixins = function useMixins(name) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$emitterName = options.emitterName,
+    emitterName = _options$emitterName === void 0 ? "default" : _options$emitterName;
+  var emitterInstance = Emitter.getInstance(emitterName);
+  var dispatch = useDispatch();
+  var mixins = {};
+  var _useState = useState({
+      componentName: name,
+      inMemoryMap: inMemoryMap
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    mixinsState = _useState2[0],
+    setMixinsState = _useState2[1];
+  var setInMemory = function setInMemory(name, value) {
+    var newState = setNested(mixinsState.inMemoryMap, name, value);
+    setMixinsState(function (prev) {
+      return _objectSpread2(_objectSpread2({}, prev), {}, {
+        inMemoryMap: newState
+      });
+    });
+    return mixinsState.inMemoryMap;
+  };
+  var getInMemory = function getInMemory(name) {
+    return dotWalk(name, {
+      state: mixinsState.inMemoryMap
+    });
+  };
+  var setStore = function setStore(name, value) {
+    var timestamp = Date.now();
+    var uniqueId = timestamp;
+    // Create promise - the TrackingPromise has resolve/reject methods we can call
+    var promise = new TrackingPromise(function () {
+      // Callback is called but we don't need to store resolve/reject here
+      // We'll use promise.resolve() and promise.reject() methods directly
+    });
+    // Store promise in module-level map (not in action payload)
+    promiseMap.set(uniqueId, promise);
+    // Create a completely clean, serializable payload object
+    // Only include primitive/serializable values - no promises, no functions
+    var cleanPayload = {
+      name: name,
+      value: value,
+      uniqueId: uniqueId
+    };
+    // Dispatch using action creator if available, otherwise use action type directly
+    // This handles the case where the store hasn't been initialized yet
+    if (storeInstance.actions && 'setStore' in storeInstance.actions) {
+      dispatch(storeInstance.actions.setStore(cleanPayload));
+    } else {
+      // Fallback: create action manually using the action type
+      dispatch({
+        type: 'store/setStore',
+        payload: cleanPayload
+      });
+    }
+    return promise;
+  };
+  // getStore subscribes via useSelector, so it is a hook in disguise: call it
+  // unconditionally at the top level of a component, like any other hook.
+  // Renaming it would break the public API, hence the targeted disable.
+  var getStore = function getStore(name) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return useSelector(function (state) {
+      return dotWalk(name, {
+        state: state.storeSlice
+      });
+    });
+  };
+  return _objectSpread2(_objectSpread2({}, mixins), {}, {
+    emitter: emitterInstance,
+    mixinsState: mixinsState,
+    setStore: setStore,
+    getStore: getStore,
+    setInMemory: setInMemory,
+    getInMemory: getInMemory,
+    setMixinsState: setMixinsState
+  });
+};
+
+export { useMixins };

package/dist/esm/hooks/useScrollLock.js

@@ -0,0 +1,26 @@
+'use client';
+import { useEffect } from 'react';
+
+// Internal (not exported). Locks body scroll while any overlay is open. A
+// counter lets two overlays (e.g. a Drawer and a Tour) overlap without the
+// first one to close unlocking the page under the second.
+var lock = {
+  count: 0,
+  previous: ""
+};
+function useScrollLock(active) {
+  useEffect(function () {
+    if (!active || typeof document === "undefined") return undefined;
+    if (lock.count === 0) {
+      lock.previous = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+    }
+    lock.count += 1;
+    return function () {
+      lock.count -= 1;
+      if (lock.count === 0) document.body.style.overflow = lock.previous;
+    };
+  }, [active]);
+}
+
+export { useScrollLock };

package/dist/esm/hooks/useSliderValues.js

@@ -0,0 +1,135 @@
+'use client';
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useCallback, useRef } from 'react';
+import { useControllableState } from './useControllableState.js';
+import { useLatestRef } from './useLatestRef.js';
+
+// Internal (not exported). Value math + pointer handling for Slider.
+var decimals = function decimals(step) {
+  return (String(step).split(".")[1] || "").length;
+};
+function snap(raw, _ref) {
+  var min = _ref.min,
+    max = _ref.max,
+    step = _ref.step;
+  var stepped = Math.round((raw - min) / step) * step + min;
+  return Math.min(max, Math.max(min, Number(stepped.toFixed(decimals(step)))));
+}
+var toPercent = function toPercent(v, min, max) {
+  return max === min ? 0 : (v - min) / (max - min) * 100;
+};
+/** New value for a keyboard press, or `null` when the key is not a slider key. */
+function keyToValue(key, current, _ref2) {
+  var min = _ref2.min,
+    max = _ref2.max,
+    step = _ref2.step,
+    largeStep = _ref2.largeStep;
+  switch (key) {
+    case "ArrowRight":
+    case "ArrowUp":
+      return current + step;
+    case "ArrowLeft":
+    case "ArrowDown":
+      return current - step;
+    case "PageUp":
+      return current + largeStep;
+    case "PageDown":
+      return current - largeStep;
+    case "Home":
+      return min;
+    case "End":
+      return max;
+    default:
+      return null;
+  }
+}
+/**
+ * Normalises single vs range values to an array, and exposes
+ * `setThumb(index, raw)` which snaps, keeps range thumbs from crossing, and
+ * emits a number (single) or `[low, high]` (range).
+ */
+function useSliderValues(_ref3) {
+  var value = _ref3.value,
+    defaultValue = _ref3.defaultValue,
+    onChange = _ref3.onChange,
+    onChangeEnd = _ref3.onChangeEnd,
+    bounds = _ref3.bounds;
+  var _useControllableState = useControllableState({
+      value: value,
+      defaultValue: defaultValue,
+      onChange: onChange
+    }),
+    _useControllableState2 = _slicedToArray(_useControllableState, 2),
+    current = _useControllableState2[0],
+    setCurrent = _useControllableState2[1];
+  var isRange = Array.isArray(current);
+  var values = isRange ? current : [current !== null && current !== void 0 ? current : bounds.min];
+  var latest = useLatestRef({
+    values: values,
+    isRange: isRange,
+    onChangeEnd: onChangeEnd
+  });
+  var setThumb = useCallback(function (index, raw) {
+    var commit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var _latest$current = latest.current,
+      vals = _latest$current.values,
+      range = _latest$current.isRange,
+      end = _latest$current.onChangeEnd;
+    var next = snap(raw, bounds);
+    if (range && index === 0) next = Math.min(next, vals[1]);
+    if (range && index === 1) next = Math.max(next, vals[0]);
+    var updated = vals.map(function (v, i) {
+      return i === index ? next : v;
+    });
+    var out = range ? updated : updated[0];
+    if (updated[index] !== vals[index]) setCurrent(out);
+    if (commit) end === null || end === void 0 || end(out);
+  }, [bounds, latest, setCurrent]);
+  return {
+    values: values,
+    isRange: isRange,
+    setThumb: setThumb
+  };
+}
+/** Pointer drag on the track: picks the nearest thumb and follows the pointer. */
+function useSliderPointer(_ref4) {
+  var trackRef = _ref4.trackRef,
+    values = _ref4.values,
+    setThumb = _ref4.setThumb,
+    bounds = _ref4.bounds,
+    disabled = _ref4.disabled;
+  var active = useRef(null);
+  var toValue = function toValue(clientX) {
+    var rect = trackRef.current.getBoundingClientRect();
+    var ratio = rect.width ? (clientX - rect.left) / rect.width : 0;
+    return bounds.min + Math.min(1, Math.max(0, ratio)) * (bounds.max - bounds.min);
+  };
+  var onPointerDown = function onPointerDown(e) {
+    var _e$currentTarget$setP, _e$currentTarget, _e$currentTarget$quer;
+    if (disabled || e.button > 0) return;
+    var raw = toValue(e.clientX);
+    var nearest = values.reduce(function (best, v, i) {
+      return Math.abs(v - raw) < Math.abs(values[best] - raw) || v === values[best] && raw > v ? i : best;
+    }, 0);
+    active.current = nearest;
+    (_e$currentTarget$setP = (_e$currentTarget = e.currentTarget).setPointerCapture) === null || _e$currentTarget$setP === void 0 || _e$currentTarget$setP.call(_e$currentTarget, e.pointerId);
+    setThumb(nearest, raw);
+    (_e$currentTarget$quer = e.currentTarget.querySelectorAll('[role="slider"]')[nearest]) === null || _e$currentTarget$quer === void 0 || _e$currentTarget$quer.focus();
+  };
+  var onPointerMove = function onPointerMove(e) {
+    if (active.current !== null) setThumb(active.current, toValue(e.clientX));
+  };
+  var onPointerUp = function onPointerUp(e) {
+    if (active.current === null) return;
+    setThumb(active.current, toValue(e.clientX), true);
+    active.current = null;
+  };
+  return {
+    onPointerDown: onPointerDown,
+    onPointerMove: onPointerMove,
+    onPointerUp: onPointerUp,
+    onPointerCancel: onPointerUp
+  };
+}
+
+export { keyToValue, snap, toPercent, useSliderPointer, useSliderValues };

package/dist/esm/hooks/useSortable.js

@@ -0,0 +1,188 @@
+'use client';
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { useLatestRef } from './useLatestRef.js';
+
+// Internal (not exported). Keyboard + pointer reordering for Sortable. Both
+// work on a draft list of keys while the user is moving an item and only call
+// `commit(fromIndex, toIndex)` when the item is dropped.
+function moveKey(keys, key, toIndex) {
+  var next = keys.filter(function (k) {
+    return k !== key;
+  });
+  next.splice(Math.max(0, Math.min(toIndex, next.length)), 0, key);
+  return next;
+}
+var DEFAULT_SORTABLE_MESSAGES = {
+  instructions: "Press Space or Enter to pick up an item. Use the arrow keys to move it, Space or Enter to drop it, Escape to cancel.",
+  grabbed: function grabbed(label, position, total) {
+    return "Picked up ".concat(label, ". Position ").concat(position, " of ").concat(total, ".");
+  },
+  moved: function moved(label, position, total) {
+    return "".concat(label, " moved to position ").concat(position, " of ").concat(total, ".");
+  },
+  dropped: function dropped(label, position, total) {
+    return "".concat(label, " dropped at position ").concat(position, " of ").concat(total, ".");
+  },
+  cancelled: function cancelled(label, position) {
+    return "Reorder cancelled. ".concat(label, " returned to position ").concat(position, ".");
+  }
+};
+var PREV_KEYS = {
+  vertical: ["ArrowUp"],
+  horizontal: ["ArrowLeft"]
+};
+var NEXT_KEYS = {
+  vertical: ["ArrowDown"],
+  horizontal: ["ArrowRight"]
+};
+function useSortableKeyboard(_ref) {
+  var keys = _ref.keys,
+    setDraft = _ref.setDraft,
+    commit = _ref.commit,
+    announce = _ref.announce,
+    labelFor = _ref.labelFor,
+    orientation = _ref.orientation;
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    grabbed = _useState2[0],
+    setGrabbed = _useState2[1];
+  var origin = useRef(-1);
+  var total = keys.length;
+  var keyDownFor = function keyDownFor(key) {
+    return function (e) {
+      if (e.target !== e.currentTarget || grabbed !== null && grabbed !== key) return;
+      var index = keys.indexOf(key);
+      if (e.key === " " || e.key === "Enter") {
+        e.preventDefault();
+        if (grabbed === null) {
+          origin.current = index;
+          setGrabbed(key);
+          setDraft(keys);
+          announce("grabbed", labelFor(key), index + 1, total);
+        } else {
+          setGrabbed(null);
+          commit(origin.current, index);
+          announce("dropped", labelFor(key), index + 1, total);
+        }
+      } else if (grabbed === key && e.key === "Escape") {
+        e.preventDefault();
+        setGrabbed(null);
+        setDraft(null);
+        announce("cancelled", labelFor(key), origin.current + 1, total);
+      } else if (grabbed === key) {
+        var delta = PREV_KEYS[orientation].includes(e.key) ? -1 : NEXT_KEYS[orientation].includes(e.key) ? 1 : 0;
+        if (!delta) return;
+        e.preventDefault();
+        var to = Math.max(0, Math.min(total - 1, index + delta));
+        if (to === index) return;
+        setDraft(moveKey(keys, key, to));
+        announce("moved", labelFor(key), to + 1, total);
+      }
+    };
+  };
+  var cancel = useCallback(function () {
+    setGrabbed(null);
+    setDraft(null);
+  }, [setDraft]);
+  return {
+    grabbed: grabbed,
+    keyDownFor: keyDownFor,
+    cancel: cancel
+  };
+}
+var DRAG_THRESHOLD = 4;
+function useSortablePointer(_ref2) {
+  var keys = _ref2.keys,
+    setDraft = _ref2.setDraft,
+    commit = _ref2.commit,
+    nodeFor = _ref2.nodeFor,
+    orientation = _ref2.orientation,
+    disabled = _ref2.disabled;
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    dragging = _useState4[0],
+    setDragging = _useState4[1];
+  var session = useRef(null);
+  var latest = useLatestRef({
+    keys: keys,
+    commit: commit,
+    nodeFor: nodeFor,
+    orientation: orientation
+  });
+  var end = useCallback(function () {
+    var _session$current;
+    (_session$current = session.current) === null || _session$current === void 0 || _session$current.detach();
+    session.current = null;
+  }, []);
+  useEffect(function () {
+    return end;
+  }, [end]);
+  var targetIndex = function targetIndex(point, key) {
+    var _latest$current = latest.current,
+      order = _latest$current.keys,
+      node = _latest$current.nodeFor,
+      axis = _latest$current.orientation;
+    var others = order.filter(function (k) {
+      return k !== key;
+    });
+    var index = others.findIndex(function (k) {
+      var _node;
+      var rect = (_node = node(k)) === null || _node === void 0 ? void 0 : _node.getBoundingClientRect();
+      if (!rect) return false;
+      return axis === "horizontal" ? point.x < rect.left + rect.width / 2 : point.y < rect.top + rect.height / 2;
+    });
+    return index === -1 ? others.length : index;
+  };
+  var startFor = function startFor(key) {
+    return function (e) {
+      if (disabled || e.button > 0) return;
+      var start = {
+        x: e.clientX,
+        y: e.clientY
+      };
+      var from = latest.current.keys.indexOf(key);
+      var active = false;
+      var onMove = function onMove(ev) {
+        var point = {
+          x: ev.clientX,
+          y: ev.clientY
+        };
+        if (!active && Math.hypot(point.x - start.x, point.y - start.y) < DRAG_THRESHOLD) return;
+        if (!active) {
+          active = true;
+          setDragging(key);
+        }
+        setDraft(moveKey(latest.current.keys, key, targetIndex(point, key)));
+      };
+      var onUp = function onUp() {
+        end();
+        if (!active) return;
+        setDragging(null);
+        latest.current.commit(from, latest.current.keys.indexOf(key));
+      };
+      var onCancel = function onCancel() {
+        end();
+        setDragging(null);
+        setDraft(null);
+      };
+      end();
+      window.addEventListener("pointermove", onMove);
+      window.addEventListener("pointerup", onUp);
+      window.addEventListener("pointercancel", onCancel);
+      session.current = {
+        detach: function detach() {
+          window.removeEventListener("pointermove", onMove);
+          window.removeEventListener("pointerup", onUp);
+          window.removeEventListener("pointercancel", onCancel);
+        }
+      };
+    };
+  };
+  return {
+    dragging: dragging,
+    startFor: startFor
+  };
+}
+
+export { DEFAULT_SORTABLE_MESSAGES, moveKey, useSortableKeyboard, useSortablePointer };

package/dist/esm/hooks/useTheme.js

@@ -0,0 +1,53 @@
+'use client';
+import { slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { jsx } from 'react/jsx-runtime';
+import { useState, useEffect, useContext, createContext } from 'react';
+
+var ThemeContext = /*#__PURE__*/createContext(undefined);
+var useTheme = function useTheme() {
+  var context = useContext(ThemeContext);
+  if (!context) {
+    throw new Error('useTheme must be used within a ThemeProvider');
+  }
+  return context;
+};
+var ThemeProvider = function ThemeProvider(_ref) {
+  var children = _ref.children,
+    _ref$defaultTheme = _ref.defaultTheme,
+    defaultTheme = _ref$defaultTheme === void 0 ? 'light' : _ref$defaultTheme;
+  var _useState = useState(defaultTheme),
+    _useState2 = _slicedToArray(_useState, 2),
+    theme = _useState2[0],
+    setTheme = _useState2[1];
+  useEffect(function () {
+    var savedTheme = localStorage.getItem('dreamtree-theme');
+    if (savedTheme && (savedTheme === 'light' || savedTheme === 'dark')) {
+      // Read persisted theme after mount (not in a lazy initializer) so SSR
+      // markup and the first client render agree; a one-off sync is intended.
+      // eslint-disable-next-line react-hooks/set-state-in-effect
+      setTheme(savedTheme);
+    }
+  }, []);
+  useEffect(function () {
+    localStorage.setItem('dreamtree-theme', theme);
+    document.documentElement.setAttribute('data-theme', theme);
+  }, [theme]);
+  var toggleTheme = function toggleTheme() {
+    setTheme(function (prev) {
+      return prev === 'light' ? 'dark' : 'light';
+    });
+  };
+  var value = {
+    theme: theme,
+    setTheme: setTheme,
+    toggleTheme: toggleTheme,
+    isDark: theme === 'dark',
+    isLight: theme === 'light'
+  };
+  return jsx(ThemeContext.Provider, {
+    value: value,
+    children: children
+  });
+};
+
+export { ThemeProvider, useTheme };

package/dist/esm/hooks/useTourTarget.js

@@ -0,0 +1,92 @@
+'use client';
+import { slicedToArray as _slicedToArray, typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useEffect } from 'react';
+import { revealElement } from '../utils/position.js';
+import { useLatestRef } from './useLatestRef.js';
+
+// Internal (not exported). Finds a Tour step's target, scrolls it into view
+// and follows its box on scroll/resize. A target that never shows up within
+// `timeout` (still loading, hidden on this screen size) resolves to
+// `rect: null`, so the step degrades to a centred card instead of stalling.
+var POLL_MS = 100;
+function resolveTarget(target) {
+  if (!target || typeof document === "undefined") return null;
+  if (typeof target === "string") {
+    try {
+      return document.querySelector(target);
+    } catch (_unused) {
+      return null;
+    }
+  }
+  if (typeof target === "function") return target() || null;
+  if (_typeof(target) === "object" && "current" in target) return target.current || null;
+  return target.nodeType === 1 ? target : null;
+}
+var hasBox = function hasBox(el) {
+  var r = el.getBoundingClientRect();
+  return r.width > 0 || r.height > 0;
+};
+function useTourTarget(_ref) {
+  var active = _ref.active,
+    stepKey = _ref.stepKey,
+    target = _ref.target,
+    timeout = _ref.timeout;
+  var _useState = useState({
+      key: null,
+      rect: null,
+      ready: false
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  // Steps are often declared inline, so a function/ref target changes identity
+  // every render; read it through a ref and re-locate only when the step does.
+  var targetRef = useLatestRef(target);
+  useEffect(function () {
+    if (!active) return undefined;
+    var cancelled = false;
+    var timer = null;
+    var detach = null;
+    var startedAt = Date.now();
+    var settle = function settle(rect) {
+      return !cancelled && setState({
+        key: stepKey,
+        rect: rect,
+        ready: true
+      });
+    };
+    var _locate = function locate() {
+      if (cancelled) return;
+      var wanted = targetRef.current;
+      var el = wanted ? resolveTarget(wanted) : null;
+      if (!el || !hasBox(el)) {
+        if (!wanted || Date.now() - startedAt >= timeout) settle(null);else timer = setTimeout(_locate, POLL_MS);
+        return;
+      }
+      revealElement(el);
+      var update = function update() {
+        return settle(el.getBoundingClientRect());
+      };
+      update();
+      window.addEventListener("resize", update);
+      window.addEventListener("scroll", update, true);
+      detach = function detach() {
+        window.removeEventListener("resize", update);
+        window.removeEventListener("scroll", update, true);
+      };
+    };
+    timer = setTimeout(_locate, 0);
+    return function () {
+      var _detach;
+      cancelled = true;
+      clearTimeout(timer);
+      (_detach = detach) === null || _detach === void 0 || _detach();
+    };
+  }, [active, stepKey, targetRef, timeout]);
+  return state.key === stepKey ? state : {
+    rect: null,
+    ready: false
+  };
+}
+
+export { resolveTarget, useTourTarget };

package/dist/esm/index.js

@@ -0,0 +1,65 @@
+export { default as Input } from './components/core/Input.js';
+export { default as Button } from './components/core/Button.js';
+export { default as Select } from './components/core/Select.js';
+export { default as Table } from './components/core/Table/Table.js';
+import 'react/jsx-runtime';
+import 'react';
+import 'react-dom';
+export { cn } from './utils/cn.js';
+import 'lucide-react';
+import './components/core/Table/constants.js';
+export { default as Form } from './components/core/Form.js';
+export { default as Accordion } from './components/core/Accordion.js';
+export { default as Checkbox } from './components/core/Checkbox.js';
+export { default as ColorPicker } from './components/core/ColorPicker.js';
+export { default as DateRangePicker } from './components/core/DateRangePicker.js';
+export { default as Loader } from './components/core/Loader.js';
+export { default as PriceRangePicker } from './components/core/PriceRangePicker.js';
+export { default as ProgressBar } from './components/core/ProgressBar.js';
+export { default as Radio } from './components/core/Radio.js';
+export { default as Rate } from './components/core/Rate.js';
+export { default as RoundedTag } from './components/core/RoundedTag.js';
+export { default as Skeleton } from './components/core/Skeleton.js';
+export { default as Switch } from './components/core/Switch.js';
+export { default as Tabs } from './components/core/Tabs.js';
+export { default as ThreeDotPopover } from './components/core/ThreeDotPopover.js';
+export { default as Tooltip } from './components/core/Tooltip.js';
+export { default as DatePicker } from './components/core/DatePicker.js';
+export { default as LocationPicker } from './components/core/LocationPicker.js';
+export { default as SpeechToText } from './components/core/SpeechToText.js';
+export { default as TextToSpeech } from './components/core/TextToSpeech.js';
+export { default as Textarea } from './components/core/Textarea.js';
+export { default as Slider } from './components/core/Slider.js';
+export { default as Popover } from './components/core/Popover.js';
+export { default as Sidebar } from './components/navigation/Sidebar.js';
+export { Navbar } from './components/navigation/Navbar.js';
+export { default as FootNav } from './components/navigation/FootNav.js';
+export { default as Breadcrumbs } from './components/navigation/Breadcrumbs.js';
+export { default as Dialog } from './components/feedback/Dialog.js';
+export { Toast, ToastContainer, ToastProvider, useToast } from './components/feedback/Toast.js';
+export { default as Alert } from './components/feedback/Alert.js';
+export { default as Drawer } from './components/feedback/Drawer.js';
+export { default as Tour } from './components/feedback/Tour.js';
+export { default as Badge } from './components/utility/Badge.js';
+export { default as Avatar } from './components/utility/Avatar.js';
+export { default as Card } from './components/utility/Card.js';
+export { default as Pagination } from './components/utility/Pagination.js';
+export { default as Stepper } from './components/utility/Stepper.js';
+export { default as FileUpload } from './components/utility/FileUpload.js';
+export { Condition } from './components/utility/Condition.js';
+export { Carousel } from './components/utility/Carousel.js';
+export { default as Sortable } from './components/utility/Sortable.js';
+export { default as AppShell } from './components/blocks/AppShell.js';
+export { default as PageHeader } from './components/blocks/PageHeader.js';
+export { default as StatCard } from './components/blocks/StatCard.js';
+export { default as StatusPill } from './components/blocks/StatusPill.js';
+export { default as EmptyState } from './components/blocks/EmptyState.js';
+export { default as ErrorState } from './components/blocks/ErrorState.js';
+export { default as LoadingState } from './components/blocks/LoadingState.js';
+export { default as ConfirmDialog } from './components/blocks/ConfirmDialog.js';
+export { ThemeProvider, useTheme } from './hooks/useTheme.js';
+export { useMixins } from './hooks/useMixins.js';
+export { useApi } from './hooks/useApi.js';
+export { StoreProvider } from './store/index.js';
+export { Helpers } from './utils/helpers.js';
+export { EmitterClass as Emitter } from './utils/emitter.js';

package/dist/esm/rich-text/index.js

@@ -0,0 +1 @@
+export { default as RichTextEditor } from '../components/rich-text/RichTextEditor.js';