@unleash/proxy-client-react/dist/unleash-react.js

React interface for working with unleash

import { InMemoryStorageProvider as e, LocalStorageProvider as t, UnleashClient as n, UnleashClient as r } from "unleash-proxy-client";
import i, { useCallback as a, useContext as o, useEffect as s, useMemo as c, useState as l } from "react";
import { useSyncExternalStore as u } from "use-sync-external-store/shim";
import { useSyncExternalStoreWithSelector as d } from "use-sync-external-store/shim/with-selector";
//#region src/FlagContext.ts
var f = i.createContext(null), p = {
	bootstrap: [],
	disableRefresh: !0,
	disableMetrics: !0,
	url: "http://localhost",
	appName: "offline",
	clientKey: "not-used"
}, m = i.startTransition || ((e) => e()), h = ({ config: e, children: t, unleashClient: n, startClient: a = !0, stopClient: o = !0, startTransition: u = m }) => {
	let d = e || p, h = i.useRef(n || new r(d)), [g, _] = i.useState(!!(n ? e?.bootstrap && e?.bootstrapOverride !== !1 || n.isReady?.() : d.bootstrap && d.bootstrapOverride !== !1)), [v, y] = l(h.current.getError?.() || null);
	s(() => {
		!d && !n && console.error("You must provide either a config or an unleash client to the flag provider.\n        If you are initializing the client in useEffect, you can avoid this warning\n        by checking if the client exists before rendering.");
		let e = (e) => {
			u(() => {
				y((t) => t || e);
			});
		}, t = (e) => {
			u(() => {
				y(null);
			});
		}, r = null, i = () => {
			r = setTimeout(() => {
				u(() => {
					_(!0);
				});
			}, 0);
		};
		return h.current.on("ready", i), h.current.on("error", e), h.current.on("recovered", t), a && (h.current.stop(), h.current.start()), function() {
			h.current && (h.current.off("error", e), h.current.off("ready", i), h.current.off("recovered", t), o && h.current.stop()), r && clearTimeout(r);
		};
	}, []);
	let b = c(() => ({
		on: (...e) => h.current.on(...e),
		off: (...e) => h.current.off(...e),
		isEnabled: (...e) => h.current.isEnabled(...e),
		updateContext: async (...e) => await h.current.updateContext(...e),
		getVariant: (...e) => h.current.getVariant(...e),
		client: h.current,
		flagsReady: g,
		flagsError: v,
		setFlagsReady: _,
		setFlagsError: y
	}), [g, v]);
	return /* @__PURE__ */ i.createElement(f.Provider, { value: b }, t);
}, g = {
	on: (e, t, n) => (console.error("on() must be used within a FlagProvider"), _),
	off: (e, t) => (console.error("off() must be used within a FlagProvider"), _),
	updateContext: async () => {
		console.error("updateContext() must be used within a FlagProvider");
	},
	isEnabled: () => (console.error("isEnabled() must be used within a FlagProvider"), !1),
	getVariant: () => (console.error("getVariant() must be used within a FlagProvider"), {
		name: "disabled",
		enabled: !1
	})
}, _ = {
	...g,
	toggles: [],
	impressionDataAll: {},
	context: {},
	storage: {},
	start: () => {},
	stop: () => {},
	isReady: () => !1,
	getError: () => null,
	getAllToggles: () => []
}, v = {
	...g,
	client: _,
	flagsReady: !1,
	setFlagsReady: () => {
		console.error("setFlagsReady() must be used within a FlagProvider");
	},
	flagsError: null,
	setFlagsError: () => {
		console.error("setFlagsError() must be used within a FlagProvider");
	}
};
function y() {
	return o(f) || (console.error("useFlagContext() must be used within a FlagProvider"), v);
}
//#endregion
//#region src/useUnleashClientSubscription.ts
var b = (e) => a((t) => e ? (e.on("update", t), e.on("ready", t), () => {
	e.off("update", t), e.off("ready", t);
}) : () => {}, [e]), x = (e) => {
	let { isEnabled: t, client: n } = y(), r = b(n), i = () => t(e);
	return u(r, i, i);
}, S = (e, t) => e?.name === t?.name && e?.enabled === t?.enabled && e?.feature_enabled === t?.feature_enabled && e?.payload?.type === t?.payload?.type && e?.payload?.value === t?.payload?.value, C = (e, t) => e.length === t.length && e.every((e, n) => {
	let r = t[n];
	return !!r && e.name === r.name && e.enabled === r.enabled && S(e.variant, r.variant);
}), w = (e) => e, T = () => {
	let { client: e } = y(), t = b(e), n = a(() => e?.getAllToggles() ?? [], [e]);
	return d(t, n, n, w, C);
}, E = () => {
	let { flagsReady: e, flagsError: t } = y();
	return {
		flagsReady: e,
		flagsError: t
	};
}, D = (e) => e, O = (e) => {
	let { getVariant: t, client: n } = y(), r = b(n), i = a(() => t(e), [t, e]);
	return d(r, i, i, D, S) || {};
}, k = () => {
	let { updateContext: e } = y();
	return e;
}, A = () => {
	let { client: e } = y();
	return e;
}, j = h;
//#endregion
export { f as FlagContext, h as FlagProvider, e as InMemoryStorageProvider, t as LocalStorageProvider, n as UnleashClient, j as default, x as useFlag, T as useFlags, E as useFlagsStatus, A as useUnleashClient, k as useUnleashContext, O as useVariant };

//# sourceMappingURL=unleash-react.js.map