@envive-ai/react-widgets 0.1.0-arthur-1

package/dist/index.cjs

@@ -0,0 +1,714 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let __envive_ai_react_hooks_atoms_globalSearch = require("@envive-ai/react-hooks/atoms/globalSearch");
+let __envive_ai_react_hooks_atoms_search = require("@envive-ai/react-hooks/atoms/search");
+let __envive_ai_react_hooks_hooks_NewOrgConfig = require("@envive-ai/react-hooks/hooks/NewOrgConfig");
+let classnames = require("classnames");
+classnames = __toESM(classnames);
+let __envive_ai_react_toolkit_SearchResultsContent = require("@envive-ai/react-toolkit/SearchResultsContent");
+let __envive_ai_react_toolkit_SearchResultsFilterModal = require("@envive-ai/react-toolkit/SearchResultsFilterModal");
+let __envive_ai_react_toolkit_SearchResultsToolbar = require("@envive-ai/react-toolkit/SearchResultsToolbar");
+let __envive_ai_react_toolkit_util = require("@envive-ai/react-toolkit/util");
+let __envive_ai_react_hooks_hooks_Search = require("@envive-ai/react-hooks/hooks/Search");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region ../../node_modules/jotai/esm/vanilla/internals.mjs
+function hasInitialValue(atom) {
+	return "init" in atom;
+}
+function isActuallyWritableAtom(atom) {
+	return !!atom.write;
+}
+function isAtomStateInitialized(atomState) {
+	return "v" in atomState || "e" in atomState;
+}
+function returnAtomValue(atomState) {
+	if ("e" in atomState) throw atomState.e;
+	if (({}.env ? {}.env.MODE : void 0) !== "production" && !("v" in atomState)) throw new Error("[Bug] atom state is not initialized");
+	return atomState.v;
+}
+const promiseStateMap = /* @__PURE__ */ new WeakMap();
+function isPendingPromise(value) {
+	var _a;
+	return isPromiseLike(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
+}
+function abortPromise(promise) {
+	const promiseState = promiseStateMap.get(promise);
+	if (promiseState == null ? void 0 : promiseState[0]) {
+		promiseState[0] = false;
+		promiseState[1].forEach((fn) => fn());
+	}
+}
+function registerAbortHandler(promise, abortHandler) {
+	let promiseState = promiseStateMap.get(promise);
+	if (!promiseState) {
+		promiseState = [true, /* @__PURE__ */ new Set()];
+		promiseStateMap.set(promise, promiseState);
+		const settle = () => {
+			promiseState[0] = false;
+		};
+		promise.then(settle, settle);
+	}
+	promiseState[1].add(abortHandler);
+}
+function isPromiseLike(p) {
+	return typeof (p == null ? void 0 : p.then) === "function";
+}
+function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
+	if (!dependencyAtomState.p.has(atom)) {
+		dependencyAtomState.p.add(atom);
+		const cleanup = () => dependencyAtomState.p.delete(atom);
+		promise.then(cleanup, cleanup);
+	}
+}
+function getMountedOrPendingDependents(atom, atomState, mountedMap) {
+	var _a;
+	const dependents = /* @__PURE__ */ new Set();
+	for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) if (mountedMap.has(a)) dependents.add(a);
+	for (const atomWithPendingPromise of atomState.p) dependents.add(atomWithPendingPromise);
+	return dependents;
+}
+const atomRead = (_store, atom, ...params) => atom.read(...params);
+const atomWrite = (_store, atom, ...params) => atom.write(...params);
+const atomOnInit = (store, atom) => {
+	var _a;
+	return (_a = atom.unstable_onInit) == null ? void 0 : _a.call(atom, store);
+};
+const atomOnMount = (_store, atom, setAtom) => {
+	var _a;
+	return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
+};
+const ensureAtomState = (store, atom) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const atomStateMap = buildingBlocks[0];
+	const atomOnInit2 = buildingBlocks[9];
+	if (({}.env ? {}.env.MODE : void 0) !== "production" && !atom) throw new Error("Atom is undefined or null");
+	let atomState = atomStateMap.get(atom);
+	if (!atomState) {
+		atomState = {
+			d: /* @__PURE__ */ new Map(),
+			p: /* @__PURE__ */ new Set(),
+			n: 0
+		};
+		atomStateMap.set(atom, atomState);
+		atomOnInit2?.(store, atom);
+	}
+	return atomState;
+};
+const flushCallbacks = (store) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const changedAtoms = buildingBlocks[3];
+	const mountCallbacks = buildingBlocks[4];
+	const unmountCallbacks = buildingBlocks[5];
+	const storeHooks = buildingBlocks[6];
+	const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+	const errors = [];
+	const call = (fn) => {
+		try {
+			fn();
+		} catch (e) {
+			errors.push(e);
+		}
+	};
+	do {
+		if (storeHooks.f) call(storeHooks.f);
+		const callbacks = /* @__PURE__ */ new Set();
+		const add = callbacks.add.bind(callbacks);
+		changedAtoms.forEach((atom) => {
+			var _a;
+			return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
+		});
+		changedAtoms.clear();
+		unmountCallbacks.forEach(add);
+		unmountCallbacks.clear();
+		mountCallbacks.forEach(add);
+		mountCallbacks.clear();
+		callbacks.forEach(call);
+		if (changedAtoms.size) recomputeInvalidatedAtoms2(store);
+	} while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+	if (errors.length) throw new AggregateError(errors);
+};
+const recomputeInvalidatedAtoms = (store) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const invalidatedAtoms = buildingBlocks[2];
+	const changedAtoms = buildingBlocks[3];
+	const ensureAtomState2 = buildingBlocks[11];
+	const readAtomState2 = buildingBlocks[14];
+	const mountDependencies2 = buildingBlocks[17];
+	const topSortedReversed = [];
+	const visiting = /* @__PURE__ */ new WeakSet();
+	const visited = /* @__PURE__ */ new WeakSet();
+	const stack = Array.from(changedAtoms);
+	while (stack.length) {
+		const a = stack[stack.length - 1];
+		const aState = ensureAtomState2(store, a);
+		if (visited.has(a)) {
+			stack.pop();
+			continue;
+		}
+		if (visiting.has(a)) {
+			if (invalidatedAtoms.get(a) === aState.n) topSortedReversed.push([a, aState]);
+			else if (({}.env ? {}.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) throw new Error("[Bug] invalidated atom exists");
+			visited.add(a);
+			stack.pop();
+			continue;
+		}
+		visiting.add(a);
+		for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) if (!visiting.has(d)) stack.push(d);
+	}
+	for (let i = topSortedReversed.length - 1; i >= 0; --i) {
+		const [a, aState] = topSortedReversed[i];
+		let hasChangedDeps = false;
+		for (const dep of aState.d.keys()) if (dep !== a && changedAtoms.has(dep)) {
+			hasChangedDeps = true;
+			break;
+		}
+		if (hasChangedDeps) {
+			readAtomState2(store, a);
+			mountDependencies2(store, a);
+		}
+		invalidatedAtoms.delete(a);
+	}
+};
+const readAtomState = (store, atom) => {
+	var _a, _b;
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const invalidatedAtoms = buildingBlocks[2];
+	const changedAtoms = buildingBlocks[3];
+	const storeHooks = buildingBlocks[6];
+	const atomRead2 = buildingBlocks[7];
+	const ensureAtomState2 = buildingBlocks[11];
+	const flushCallbacks2 = buildingBlocks[12];
+	const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+	const readAtomState2 = buildingBlocks[14];
+	const writeAtomState2 = buildingBlocks[16];
+	const mountDependencies2 = buildingBlocks[17];
+	const atomState = ensureAtomState2(store, atom);
+	if (isAtomStateInitialized(atomState)) {
+		if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) return atomState;
+		if (Array.from(atomState.d).every(([a, n]) => readAtomState2(store, a).n === n)) return atomState;
+	}
+	atomState.d.clear();
+	let isSync = true;
+	function mountDependenciesIfAsync() {
+		if (mountedMap.has(atom)) {
+			mountDependencies2(store, atom);
+			recomputeInvalidatedAtoms2(store);
+			flushCallbacks2(store);
+		}
+	}
+	function getter(a) {
+		var _a2;
+		if (a === atom) {
+			const aState2 = ensureAtomState2(store, a);
+			if (!isAtomStateInitialized(aState2)) if (hasInitialValue(a)) setAtomStateValueOrPromise(store, a, a.init);
+			else throw new Error("no atom init");
+			return returnAtomValue(aState2);
+		}
+		const aState = readAtomState2(store, a);
+		try {
+			return returnAtomValue(aState);
+		} finally {
+			atomState.d.set(a, aState.n);
+			if (isPendingPromise(atomState.v)) addPendingPromiseToDependency(atom, atomState.v, aState);
+			(_a2 = mountedMap.get(a)) == null || _a2.t.add(atom);
+			if (!isSync) mountDependenciesIfAsync();
+		}
+	}
+	let controller;
+	let setSelf;
+	const options = {
+		get signal() {
+			if (!controller) controller = new AbortController();
+			return controller.signal;
+		},
+		get setSelf() {
+			if (({}.env ? {}.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) console.warn("setSelf function cannot be used with read-only atom");
+			if (!setSelf && isActuallyWritableAtom(atom)) setSelf = (...args) => {
+				if (({}.env ? {}.env.MODE : void 0) !== "production" && isSync) console.warn("setSelf function cannot be called in sync");
+				if (!isSync) try {
+					return writeAtomState2(store, atom, ...args);
+				} finally {
+					recomputeInvalidatedAtoms2(store);
+					flushCallbacks2(store);
+				}
+			};
+			return setSelf;
+		}
+	};
+	const prevEpochNumber = atomState.n;
+	try {
+		const valueOrPromise = atomRead2(store, atom, getter, options);
+		setAtomStateValueOrPromise(store, atom, valueOrPromise);
+		if (isPromiseLike(valueOrPromise)) {
+			registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
+			valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
+		}
+		(_a = storeHooks.r) == null || _a.call(storeHooks, atom);
+		return atomState;
+	} catch (error) {
+		delete atomState.v;
+		atomState.e = error;
+		++atomState.n;
+		return atomState;
+	} finally {
+		isSync = false;
+		if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
+			invalidatedAtoms.set(atom, atomState.n);
+			changedAtoms.add(atom);
+			(_b = storeHooks.c) == null || _b.call(storeHooks, atom);
+		}
+	}
+};
+const invalidateDependents = (store, atom) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const invalidatedAtoms = buildingBlocks[2];
+	const ensureAtomState2 = buildingBlocks[11];
+	const stack = [atom];
+	while (stack.length) {
+		const a = stack.pop();
+		const aState = ensureAtomState2(store, a);
+		for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+			const dState = ensureAtomState2(store, d);
+			invalidatedAtoms.set(d, dState.n);
+			stack.push(d);
+		}
+	}
+};
+const writeAtomState = (store, atom, ...args) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const changedAtoms = buildingBlocks[3];
+	const storeHooks = buildingBlocks[6];
+	const atomWrite2 = buildingBlocks[8];
+	const ensureAtomState2 = buildingBlocks[11];
+	const flushCallbacks2 = buildingBlocks[12];
+	const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+	const readAtomState2 = buildingBlocks[14];
+	const invalidateDependents2 = buildingBlocks[15];
+	const mountDependencies2 = buildingBlocks[17];
+	let isSync = true;
+	const getter = (a) => returnAtomValue(readAtomState2(store, a));
+	const setter = (a, ...args2) => {
+		var _a;
+		const aState = ensureAtomState2(store, a);
+		try {
+			if (a === atom) {
+				if (!hasInitialValue(a)) throw new Error("atom not writable");
+				const prevEpochNumber = aState.n;
+				const v = args2[0];
+				setAtomStateValueOrPromise(store, a, v);
+				mountDependencies2(store, a);
+				if (prevEpochNumber !== aState.n) {
+					changedAtoms.add(a);
+					(_a = storeHooks.c) == null || _a.call(storeHooks, a);
+					invalidateDependents2(store, a);
+				}
+				return;
+			} else return writeAtomState(store, a, ...args2);
+		} finally {
+			if (!isSync) {
+				recomputeInvalidatedAtoms2(store);
+				flushCallbacks2(store);
+			}
+		}
+	};
+	try {
+		return atomWrite2(store, atom, getter, setter, ...args);
+	} finally {
+		isSync = false;
+	}
+};
+const mountDependencies = (store, atom) => {
+	var _a;
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const changedAtoms = buildingBlocks[3];
+	const storeHooks = buildingBlocks[6];
+	const ensureAtomState2 = buildingBlocks[11];
+	const invalidateDependents2 = buildingBlocks[15];
+	const mountAtom2 = buildingBlocks[18];
+	const unmountAtom2 = buildingBlocks[19];
+	const atomState = ensureAtomState2(store, atom);
+	const mounted = mountedMap.get(atom);
+	if (mounted && !isPendingPromise(atomState.v)) {
+		for (const [a, n] of atomState.d) if (!mounted.d.has(a)) {
+			const aState = ensureAtomState2(store, a);
+			mountAtom2(store, a).t.add(atom);
+			mounted.d.add(a);
+			if (n !== aState.n) {
+				changedAtoms.add(a);
+				(_a = storeHooks.c) == null || _a.call(storeHooks, a);
+				invalidateDependents2(store, a);
+			}
+		}
+		for (const a of mounted.d || []) if (!atomState.d.has(a)) {
+			mounted.d.delete(a);
+			unmountAtom2(store, a)?.t.delete(atom);
+		}
+	}
+};
+const mountAtom = (store, atom) => {
+	var _a;
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const mountCallbacks = buildingBlocks[4];
+	const storeHooks = buildingBlocks[6];
+	const atomOnMount2 = buildingBlocks[10];
+	const ensureAtomState2 = buildingBlocks[11];
+	const flushCallbacks2 = buildingBlocks[12];
+	const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+	const readAtomState2 = buildingBlocks[14];
+	const writeAtomState2 = buildingBlocks[16];
+	const atomState = ensureAtomState2(store, atom);
+	let mounted = mountedMap.get(atom);
+	if (!mounted) {
+		readAtomState2(store, atom);
+		for (const a of atomState.d.keys()) mountAtom(store, a).t.add(atom);
+		mounted = {
+			l: /* @__PURE__ */ new Set(),
+			d: new Set(atomState.d.keys()),
+			t: /* @__PURE__ */ new Set()
+		};
+		mountedMap.set(atom, mounted);
+		(_a = storeHooks.m) == null || _a.call(storeHooks, atom);
+		if (isActuallyWritableAtom(atom)) {
+			const processOnMount = () => {
+				let isSync = true;
+				const setAtom = (...args) => {
+					try {
+						return writeAtomState2(store, atom, ...args);
+					} finally {
+						if (!isSync) {
+							recomputeInvalidatedAtoms2(store);
+							flushCallbacks2(store);
+						}
+					}
+				};
+				try {
+					const onUnmount = atomOnMount2(store, atom, setAtom);
+					if (onUnmount) mounted.u = () => {
+						isSync = true;
+						try {
+							onUnmount();
+						} finally {
+							isSync = false;
+						}
+					};
+				} finally {
+					isSync = false;
+				}
+			};
+			mountCallbacks.add(processOnMount);
+		}
+	}
+	return mounted;
+};
+const unmountAtom = (store, atom) => {
+	var _a;
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const mountedMap = buildingBlocks[1];
+	const unmountCallbacks = buildingBlocks[5];
+	const storeHooks = buildingBlocks[6];
+	const ensureAtomState2 = buildingBlocks[11];
+	const unmountAtom2 = buildingBlocks[19];
+	const atomState = ensureAtomState2(store, atom);
+	let mounted = mountedMap.get(atom);
+	if (mounted && !mounted.l.size && !Array.from(mounted.t).some((a) => {
+		var _a2;
+		return (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.d.has(atom);
+	})) {
+		if (mounted.u) unmountCallbacks.add(mounted.u);
+		mounted = void 0;
+		mountedMap.delete(atom);
+		(_a = storeHooks.u) == null || _a.call(storeHooks, atom);
+		for (const a of atomState.d.keys()) unmountAtom2(store, a)?.t.delete(atom);
+		return;
+	}
+	return mounted;
+};
+const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+	const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
+	const atomState = ensureAtomState2(store, atom);
+	const hasPrevValue = "v" in atomState;
+	const prevValue = atomState.v;
+	if (isPromiseLike(valueOrPromise)) for (const a of atomState.d.keys()) addPendingPromiseToDependency(atom, valueOrPromise, ensureAtomState2(store, a));
+	atomState.v = valueOrPromise;
+	delete atomState.e;
+	if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+		++atomState.n;
+		if (isPromiseLike(prevValue)) abortPromise(prevValue);
+	}
+};
+const storeGet = (store, atom) => {
+	const readAtomState2 = getInternalBuildingBlocks(store)[14];
+	return returnAtomValue(readAtomState2(store, atom));
+};
+const storeSet = (store, atom, ...args) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const flushCallbacks2 = buildingBlocks[12];
+	const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+	const writeAtomState2 = buildingBlocks[16];
+	try {
+		return writeAtomState2(store, atom, ...args);
+	} finally {
+		recomputeInvalidatedAtoms2(store);
+		flushCallbacks2(store);
+	}
+};
+const storeSub = (store, atom, listener) => {
+	const buildingBlocks = getInternalBuildingBlocks(store);
+	const flushCallbacks2 = buildingBlocks[12];
+	const mountAtom2 = buildingBlocks[18];
+	const unmountAtom2 = buildingBlocks[19];
+	const listeners = mountAtom2(store, atom).l;
+	listeners.add(listener);
+	flushCallbacks2(store);
+	return () => {
+		listeners.delete(listener);
+		unmountAtom2(store, atom);
+		flushCallbacks2(store);
+	};
+};
+const buildingBlockMap = /* @__PURE__ */ new WeakMap();
+const getInternalBuildingBlocks = (store) => {
+	const buildingBlocks = buildingBlockMap.get(store);
+	if (({}.env ? {}.env.MODE : void 0) !== "production" && !buildingBlocks) throw new Error("Store must be created by buildStore to read its building blocks");
+	return buildingBlocks;
+};
+function buildStore(...buildArgs) {
+	const store = {
+		get(atom) {
+			const storeGet2 = getInternalBuildingBlocks(store)[21];
+			return storeGet2(store, atom);
+		},
+		set(atom, ...args) {
+			const storeSet2 = getInternalBuildingBlocks(store)[22];
+			return storeSet2(store, atom, ...args);
+		},
+		sub(atom, listener) {
+			const storeSub2 = getInternalBuildingBlocks(store)[23];
+			return storeSub2(store, atom, listener);
+		}
+	};
+	const buildingBlocks = [
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new WeakMap(),
+		/* @__PURE__ */ new Set(),
+		/* @__PURE__ */ new Set(),
+		/* @__PURE__ */ new Set(),
+		{},
+		atomRead,
+		atomWrite,
+		atomOnInit,
+		atomOnMount,
+		ensureAtomState,
+		flushCallbacks,
+		recomputeInvalidatedAtoms,
+		readAtomState,
+		invalidateDependents,
+		writeAtomState,
+		mountDependencies,
+		mountAtom,
+		unmountAtom,
+		setAtomStateValueOrPromise,
+		storeGet,
+		storeSet,
+		storeSub,
+		void 0
+	].map((fn, i) => buildArgs[i] || fn);
+	buildingBlockMap.set(store, Object.freeze(buildingBlocks));
+	return store;
+}
+
+//#endregion
+//#region ../../node_modules/jotai/esm/vanilla.mjs
+let overiddenCreateStore;
+function createStore() {
+	if (overiddenCreateStore) return overiddenCreateStore();
+	return buildStore();
+}
+let defaultStore;
+function getDefaultStore() {
+	if (!defaultStore) {
+		defaultStore = createStore();
+		if (({}.env ? {}.env.MODE : void 0) !== "production") {
+			globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
+			if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) console.warn("Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044");
+		}
+	}
+	return defaultStore;
+}
+
+//#endregion
+//#region ../../node_modules/jotai/esm/react.mjs
+const StoreContext = (0, react.createContext)(void 0);
+function useStore(options) {
+	const store = (0, react.useContext)(StoreContext);
+	return (options == null ? void 0 : options.store) || store || getDefaultStore();
+}
+const attachPromiseStatus = (promise) => {
+	if (!promise.status) {
+		promise.status = "pending";
+		promise.then((v) => {
+			promise.status = "fulfilled";
+			promise.value = v;
+		}, (e) => {
+			promise.status = "rejected";
+			promise.reason = e;
+		});
+	}
+};
+const use = react.default.use || ((promise) => {
+	if (promise.status === "pending") throw promise;
+	else if (promise.status === "fulfilled") return promise.value;
+	else if (promise.status === "rejected") throw promise.reason;
+	else {
+		attachPromiseStatus(promise);
+		throw promise;
+	}
+});
+function useSetAtom(atom, options) {
+	const store = useStore(options);
+	return (0, react.useCallback)((...args) => {
+		if (({}.env ? {}.env.MODE : void 0) !== "production" && !("write" in atom)) throw new Error("not writable atom");
+		return store.set(atom, ...args);
+	}, [store, atom]);
+}
+
+//#endregion
+//#region src/SearchResults/withSearchResults.tsx
+function withSearchResults(Component) {
+	return function SearchResultsHoc(props) {
+		const searchHookResult = (0, __envive_ai_react_hooks_hooks_Search.useSearch)();
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, {
+			...props,
+			...searchHookResult,
+			productList: searchHookResult.searchData?.products || []
+		});
+	};
+}
+
+//#endregion
+//#region src/SearchResults/SearchResults.tsx
+const SearchResultsComponent = ({ widgetConfig, productCardConfig, merchantShortName, productList, autocompleteResults, searchFilters, availableDynamicFilters, selectedFilterOptions, searchText, query, searchResultsState, isFilterOpen, shouldShowAutocomplete, focusedIndex, focusedOptionId, recommendedProducts, filterButtonText, onSearchInputChange, onSubmitSearch, onAutocompleteSelect, onKeyDown, onSearchInputFocus, onSearchInputBlur, onToggleDynamicFilter, onSelectFilterItem, onRemoveFilter, onClearAllFilters, setIsFilterOpen, searchResultsRef }) => {
+	const { searchInputVariant, searchFilterSidebarVariant, productGridVariant, searchBoxPlaceholder, noResultsFoundText, isSearchInputSticky = false } = widgetConfig;
+	const { toolbarRef: ref, isVisible, toolbarHeight: height } = (0, __envive_ai_react_toolkit_util.useStickyVisibility)();
+	const toolbarRef = isSearchInputSticky ? ref : null;
+	const finalIsVisible = isSearchInputSticky ? isVisible : true;
+	const toolbarHeight = isSearchInputSticky ? height : 0;
+	const stickyToolbarClasses = (0, classnames.default)("spiffy-tw-fixed", "spiffy-tw-top-0", "spiffy-tw-left-0", "spiffy-tw-right-0", "spiffy-tw-transition-transform", "spiffy-tw-duration-300", "spiffy-tw-py-[8px]");
+	const containerXPaddingClasses = (0, classnames.default)("spiffy-tw-px-[16px]", "sm:spiffy-tw-px-[46px]");
+	(0, react.useEffect)(() => {
+		window.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+	}, [productList]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+		/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__envive_ai_react_toolkit_SearchResultsFilterModal.SearchResultsFilterModal, {
+			isOpen: isFilterOpen,
+			setIsOpen: setIsFilterOpen,
+			searchFilters,
+			productCount: productList.length,
+			onSelectFilterItem,
+			onClearAllFilters,
+			searchFilterSidebarVariant,
+			filterButtonText
+		}),
+		/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__envive_ai_react_toolkit_SearchResultsToolbar.SearchResultsToolbar, {
+			className: isSearchInputSticky ? stickyToolbarClasses : "spiffy-tw-py-[8px]",
+			toolbarRef,
+			searchInputVariant,
+			searchBoxPlaceholder,
+			searchText,
+			focusedIndex,
+			focusedOptionId,
+			autocompleteResults,
+			filterButtonText,
+			onKeyDown,
+			onSearchInputChange,
+			onSubmitSearch,
+			onAutocompleteSelect,
+			onSearchInputFocus,
+			onSearchInputBlur,
+			shouldShowAutocomplete,
+			setIsFilterOpen,
+			containerXPaddingClasses,
+			isVisible: finalIsVisible
+		}),
+		/* @__PURE__ */ (0, react_jsx_runtime.jsx)(__envive_ai_react_toolkit_SearchResultsContent.SearchResultsContent, {
+			searchResultsState,
+			productList,
+			recommendedProducts,
+			productCardConfig,
+			merchantShortName,
+			searchFilterSidebarVariant,
+			noResultsFoundText,
+			productGridVariant,
+			containerXPaddingClasses,
+			selectedFilterOptions,
+			availableDynamicFilters,
+			onRemoveFilter,
+			onToggleDynamicFilter,
+			searchResultsRef,
+			toolbarHeight,
+			query
+		})
+	] });
+};
+const SearchResults = withSearchResults(SearchResultsComponent);
+
+//#endregion
+//#region src/SearchResults/SearchResultsWidget.tsx
+const SearchResultsWidget = () => {
+	const setIsSearchResultsOpen = useSetAtom(__envive_ai_react_hooks_atoms_globalSearch.isSearchResultsOpenAtom);
+	const setSearchSystem = useSetAtom(__envive_ai_react_hooks_atoms_search.searchSystemAtom);
+	const newConfig = (0, __envive_ai_react_hooks_hooks_NewOrgConfig.useNewOrgConfig)();
+	(0, react.useEffect)(() => {
+		setSearchSystem(true);
+		return () => setSearchSystem(false);
+	}, [setSearchSystem]);
+	(0, react.useEffect)(() => {
+		setIsSearchResultsOpen(true);
+		return () => {
+			setIsSearchResultsOpen(false);
+		};
+	}, [setIsSearchResultsOpen]);
+	const widgetConfig = (0, react.useMemo)(() => {
+		if (newConfig && newConfig.frontendConfig?.widgetConfigs) return { ...(newConfig.frontendConfig?.widgetConfigs).find((widget) => widget.key === "searchResultsEntryPoint").config };
+		return null;
+	}, [newConfig]);
+	if (!widgetConfig) return null;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SearchResults, { widgetConfig });
+};
+
+//#endregion
+exports.SearchResultsWidget = SearchResultsWidget;