@mercury-fx/effector 2.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonnify <mercury@jonnify.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @mercury-fx/effector
+
+Effector-backed state adapters for
+[`@mercury-fx/ui`](https://www.npmjs.com/package/@mercury-fx/ui): a theme store,
+a toast model + `<Toaster/>`, a `createForm` field factory, password strength,
+and a cooldown timer. State lives **outside** React, so the components stay
+presentational.
+
+## Install
+
+```bash
+npm i @mercury-fx/effector
+npm i @mercury-fx/ui react effector effector-react   # peer dependencies
+```
+
+## Use
+
+```tsx
+import "@mercury-fx/ui/styles.css";
+import { Toaster, toast, useTheme, toggleTheme } from "@mercury-fx/effector";
+
+function App() {
+  const theme = useTheme();               // "light" | "dark"
+  return (
+    <>
+      <button onClick={() => toggleTheme()}>{theme}</button>
+      <button onClick={() => toast.success("Saved")}>Save</button>
+      <Toaster />
+    </>
+  );
+}
+```
+
+## License
+
+MIT

package/dist/bridge.d.ts

@@ -0,0 +1,31 @@
+/**
+ * bridgeChannel — lift a host bridge into the `ChannelLike` contract.
+ *
+ * A LiveView-style host hands an embedded island a bridge — outbound
+ * `pushEvent(event, payload)` plus an `onServerEvent(cb)` fan-out of named
+ * server frames — rather than a raw Phoenix channel. Both transports terminate
+ * the same server-side PubSub, so this adapter maps the bridge onto
+ * `ChannelLike` and `createChannel().bind(...)` (and every model built over
+ * it) runs unchanged on either transport.
+ *
+ * Semantics, stated honestly:
+ * - `join()` resolves "ok" synchronously with `joinReply` — the host delivered
+ *   the initial state before the island mounted (the moral twin of a Phoenix
+ *   join reply), so there is nothing to wait for and no way to fail.
+ * - `push()` forwards to `bridge.pushEvent` and acks "ok" immediately —
+ *   fire-and-forget; a host reply path, where one exists, is a bridge-surface
+ *   extension, not this adapter's invention.
+ * - `onClose`/`onError` are no-ops: the host socket owns lifecycle and
+ *   reconnection; the bridge never surfaces them.
+ */
+import type { ChannelLike } from "./channel";
+/** The host-bridge shape an embedding page hands its island. */
+export interface HostBridge {
+    pushEvent(event: string, payload: unknown): void;
+    onServerEvent(cb: (name: string, payload: unknown) => void): () => void;
+}
+export interface BridgeChannelOptions {
+    /** Delivered as the join "ok" reply (the host's initial state). */
+    joinReply?: unknown;
+}
+export declare function bridgeChannel(bridge: HostBridge, opts?: BridgeChannelOptions): ChannelLike;

package/dist/channel.d.ts

@@ -0,0 +1,56 @@
+/**
+ * createChannel — an Effector plug for a Phoenix channel.
+ *
+ * The state lives outside React, matching the other Mercury plugs: a channel's
+ * lifecycle (joining/joined/errored/closed), its inbound messages, and its
+ * outbound pushes are Effector units. The plug is structurally typed against a
+ * Phoenix channel (`ChannelLike`), so this package takes no `@echo/phoenix`
+ * dependency — any object with the channel shape plugs in.
+ *
+ * "Hot plug": `bind(channel, inbound)` wires a live channel into the model at
+ * runtime (join + the inbound listeners) and returns an unbind that removes the
+ * listeners and detaches. Bind a fresh channel when the room changes; unbind on
+ * teardown. A React status hook is provided for convenience; components stay
+ * presentational.
+ */
+import { type Store } from "effector";
+/** The receive-chain a Phoenix push returns. */
+export interface PushLike {
+    receive(status: string, callback: (response?: unknown) => void): PushLike;
+}
+/** The subset of a Phoenix channel this plug uses. A real `@echo/phoenix`
+ *  `Channel` satisfies it structurally. */
+export interface ChannelLike {
+    join(timeout?: number): PushLike;
+    on(event: string, callback: (payload?: unknown) => void): number;
+    off(event: string, ref?: number): void;
+    push(event: string, payload: object, timeout?: number): PushLike;
+    onClose(callback: (payload?: unknown) => void): void;
+    onError(callback: (reason?: unknown) => void): number;
+    leave(timeout?: number): PushLike;
+}
+export type ChannelStatus = "idle" | "joining" | "joined" | "errored" | "closed";
+/** A single inbound frame: the event name and its payload. */
+export interface ChannelMessage {
+    event: string;
+    payload: unknown;
+}
+export interface ChannelModel {
+    /** Reactive lifecycle status. */
+    $status: Store<ChannelStatus>;
+    /** The last join/close/error reason, or null. */
+    $error: Store<unknown | null>;
+    /** Fires with the join reply payload once the channel joins. */
+    joined: import("effector").Event<unknown>;
+    /** Every inbound frame for a bound event name. */
+    message: import("effector").Event<ChannelMessage>;
+    /** Fire-and-forget outbound push (routed to the bound channel). */
+    push: (event: string, payload?: object) => void;
+    /** Awaitable outbound push; resolves on "ok", rejects on "error"/"timeout". */
+    pushAsync: (event: string, payload?: object) => Promise<unknown>;
+    /** Plug a live channel in: join + listen. Returns an unbind. */
+    bind: (channel: ChannelLike, inbound: readonly string[]) => () => void;
+    /** React hook for the status store. */
+    useStatus: () => ChannelStatus;
+}
+export declare function createChannel(): ChannelModel;

package/dist/cooldown.d.ts

@@ -0,0 +1,11 @@
+/**
+ * createCooldown — a countdown timer as Effector state, for "resend in 30s"
+ * style rate-limit affordances. The interval lives outside React; components
+ * read `useCooldown()` and call `start(seconds)`.
+ */
+export declare function createCooldown(): {
+    $remaining: import("effector").StoreWritable<number>;
+    start: (seconds: number) => void;
+    stop: () => void;
+    useCooldown: () => number;
+};

package/dist/disclosure.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @mercury-fx/effector — the overlay disclosure bridge (mx.7.4 §E).
+ *
+ * The optional driver for the presentational overlays (`Dialog`/`AlertDialog`/
+ * `Popover`). It PRODUCES their controlled state and manages the cross-overlay
+ * concern a single component cannot — a global body-scroll-lock — exactly as
+ * `theme`/`toast` drive their components from the outside. `@mercury-fx/ui` gains
+ * NO dependency on this: the arrow is effector -> ui only (INV-EFFECTOR).
+ */
+/**
+ * createDisclosure — a controlled open/close model for one overlay instance, as
+ * Effector state (the `createCooldown` factory idiom). Each call returns an
+ * INDEPENDENT model; a consumer wires `useOpen()` into an overlay's `open` prop
+ * and `close`/`open`/`toggle` into its `onClose`/`onOpenChange`. The overlay
+ * stays the source of truth for its DOM; the model is the source of truth for
+ * whether it is open.
+ */
+export declare function createDisclosure(opts?: {
+    defaultOpen?: boolean;
+}): {
+    $open: import("effector").StoreWritable<boolean>;
+    open: import("effector").EventCallable<void>;
+    close: import("effector").EventCallable<void>;
+    toggle: import("effector").EventCallable<void>;
+    useOpen: () => boolean;
+};
+/** The id of one open overlay in the global stack. */
+export type OverlayId = string;
+/** Register an overlay's id when it opens (modal consumers only). */
+export declare const pushOverlay: import("effector").EventCallable<string>;
+/** Unregister an overlay's id when it closes. */
+export declare const popOverlay: import("effector").EventCallable<string>;
+/**
+ * $openOverlays — the LIFO stack of open overlay ids. Push appends (the last
+ * opened is topmost, for `Escape`-topmost + z-ordering); pop removes the most
+ * recent occurrence of the id (defensive against a doubled push).
+ */
+export declare const $openOverlays: import("effector").StoreWritable<string[]>;
+/** True while any overlay is open. */
+export declare const $anyOverlayOpen: import("effector").Store<boolean>;
+/** The topmost (most-recently opened) overlay id, or null when none is open. */
+export declare const $topOverlay: import("effector").Store<string | null>;
+/** Reactive "is any overlay open" for components. */
+export declare const useAnyOverlayOpen: () => boolean;
+/**
+ * Call once at app start to lock body scroll while any overlay is open, padding-
+ * compensated so the layout does not shift. Idempotent (the `initTheme` idiom);
+ * SSR-guarded. Opt-in: the singleton does NOT auto-fire from `createDisclosure` —
+ * a MODAL consumer calls `pushOverlay`/`popOverlay`; a non-modal `Popover` does
+ * not, so modals lock scroll and popovers do not.
+ */
+export declare function initOverlayLock(): void;

package/dist/form.d.ts

@@ -0,0 +1,50 @@
+export type FormErrors<V> = Partial<Record<keyof V, string>>;
+export interface FormConfig<V> {
+    initialValues: V;
+    /** Pure validator: return a map of field → message for invalid fields. */
+    validate?: (values: V) => FormErrors<V>;
+    /**
+     * Optional async submit handler. Runs only when the form is valid; while it
+     * is pending `$submitting` (and `useForm().submitting`) is true.
+     */
+    onSubmit?: (values: V) => void | Promise<void>;
+}
+export interface FieldBinding<T> {
+    value: T;
+    error: string | undefined;
+    onChange: (value: T) => void;
+    onBlur: () => void;
+}
+/**
+ * createForm — an Effector-backed form model + React hooks.
+ * Components stay presentational; the stores live outside React.
+ */
+export declare function createForm<V extends Record<string, unknown>>(config: FormConfig<V>): {
+    $values: import("effector").StoreWritable<V>;
+    $errors: import("effector").Store<Partial<Record<keyof V, string>>>;
+    $touched: import("effector").StoreWritable<Partial<Record<keyof V, boolean>>>;
+    $isValid: import("effector").Store<boolean>;
+    $submitting: import("effector").StoreWritable<boolean>;
+    changed: import("effector").EventCallable<{
+        name: keyof V;
+        value: V[keyof V];
+    }>;
+    blurred: import("effector").EventCallable<keyof V>;
+    submitted: import("effector").EventCallable<void>;
+    reset: import("effector").EventCallable<void>;
+    submit: () => Promise<boolean>;
+    useField: <K extends keyof V>(name: K) => FieldBinding<V[K]>;
+    useForm: () => {
+        values: V;
+        errors: Partial<Record<keyof V, string>>;
+        touched: Partial<Record<keyof V, boolean>>;
+        isValid: boolean;
+        submitting: boolean;
+        setField: <K extends keyof V>(name: K, value: V[K]) => {
+            name: keyof V;
+            value: V[keyof V];
+        };
+        submit: () => Promise<boolean>;
+        reset: () => void;
+    };
+};

package/dist/formatter.d.ts

@@ -0,0 +1,39 @@
+import { type EventCallable, type Store } from "effector";
+import { type Formatter, type MonthFormat, type YearFormat } from "@mercury-fx/ui";
+/**
+ * createFormatterModel — an Effector-backed wrapper around `@mercury-fx/ui`'s
+ * `createFormatter`. The locale and month/year styles live in stores; the
+ * formatter reads them live, so changing any of them re-renders every component
+ * that called `useFormatter()`. Components stay presentational; this wires state.
+ */
+export interface FormatterModelOptions {
+    /** Initial BCP-47 locale. Defaults to the browser locale, else `"en-US"`. */
+    locale?: string;
+    /** Initial month rendering for `fullMonthAndYear`. Defaults to `"long"`. */
+    monthFormat?: MonthFormat;
+    /** Initial year rendering for `fullMonthAndYear`. Defaults to `"numeric"`. */
+    yearFormat?: YearFormat;
+}
+export interface FormatterModel {
+    /** Active locale store. */
+    $locale: Store<string>;
+    /** Active month-format store. */
+    $monthFormat: Store<MonthFormat>;
+    /** Active year-format store. */
+    $yearFormat: Store<YearFormat>;
+    /** Set the active locale. */
+    setLocale: EventCallable<string>;
+    /** Set how months render in `fullMonthAndYear`. */
+    setMonthFormat: EventCallable<MonthFormat>;
+    /** Set how years render in `fullMonthAndYear`. */
+    setYearFormat: EventCallable<YearFormat>;
+    /**
+     * The formatter instance. Stable across renders — its methods read the stores
+     * live. Use directly outside React; inside React prefer {@link FormatterModel.useFormatter}
+     * so the component re-renders when inputs change.
+     */
+    formatter: Formatter;
+    /** React hook: subscribes to the stores and returns the (stable) formatter. */
+    useFormatter: () => Formatter;
+}
+export declare function createFormatterModel(opts?: FormatterModelOptions): FormatterModel;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @mercury-fx/effector — pluggable Effector state for Mercury.
+ * Theme store, toast model + <Toaster/>, and a createForm factory.
+ * Mercury UI components stay presentational; this wires the state.
+ */
+export * from "./theme";
+export * from "./toast";
+export * from "./form";
+export * from "./resource";
+export * from "./strength";
+export * from "./cooldown";
+export * from "./formatter";
+export * from "./channel";
+export * from "./bridge";
+export * from "./disclosure";

package/dist/mercury-effector.js

@@ -0,0 +1,314 @@
+import { createEvent as r, createStore as m, createEffect as D, sample as M } from "effector";
+import { useUnit as b } from "effector-react";
+import { jsx as R } from "react/jsx-runtime";
+import { Alert as X, createFormatter as H } from "@mercury-fx/ui";
+const Y = "mercury-theme";
+function J() {
+  if (typeof localStorage < "u") {
+    const e = localStorage.getItem(Y);
+    if (e === "light" || e === "dark") return e;
+  }
+  return "light";
+}
+const N = r(), Q = r(), _ = m(J()).on(N, (e, t) => t).on(Q, (e) => e === "dark" ? "light" : "dark");
+function L(e) {
+  if (typeof document < "u") {
+    const t = document.documentElement;
+    t.classList.remove("light-theme", "dark-theme"), t.classList.add(e === "dark" ? "dark-theme" : "light-theme");
+  }
+  if (typeof localStorage < "u")
+    try {
+      localStorage.setItem(Y, e);
+    } catch {
+    }
+}
+let P = !1;
+function fe() {
+  P || (P = !0, L(_.getState()), _.watch(L));
+}
+const me = () => b(_);
+let ee = 0;
+const k = r(), A = r(), te = r(), Z = k.map((e) => {
+  const t = typeof e == "string" ? { message: e } : e;
+  return {
+    id: ++ee,
+    tone: t.tone ?? "info",
+    title: t.title,
+    message: t.message,
+    duration: t.duration ?? 4e3
+  };
+}), ne = m([]).on(Z, (e, t) => [...e, t]).on(A, (e, t) => e.filter((n) => n.id !== t)).reset(te), q = D(
+  (e) => new Promise((t) => setTimeout(() => t(e.id), e.duration))
+);
+M({ clock: Z.filter({ fn: (e) => e.duration > 0 }), target: q });
+M({ clock: q.doneData, target: A });
+const ge = {
+  show: (e) => k(e),
+  info: (e, t = {}) => k({ ...t, tone: "info", message: e }),
+  success: (e, t = {}) => k({ ...t, tone: "success", message: e }),
+  warning: (e, t = {}) => k({ ...t, tone: "warning", message: e }),
+  error: (e, t = {}) => k({ ...t, tone: "danger", message: e })
+}, oe = () => b(ne), re = {
+  "top-end": { top: 16, right: 16, alignItems: "flex-end" },
+  "bottom-end": { bottom: 16, right: 16, alignItems: "flex-end" },
+  "bottom-center": { bottom: 16, left: "50%", transform: "translateX(-50%)", alignItems: "center" }
+};
+function he({ position: e = "bottom-end" }) {
+  const t = oe();
+  return /* @__PURE__ */ R(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        zIndex: 200,
+        display: "flex",
+        flexDirection: "column",
+        gap: 10,
+        pointerEvents: "none",
+        ...re[e]
+      },
+      children: t.map((n) => /* @__PURE__ */ R("div", { style: { pointerEvents: "auto", width: 360, maxWidth: "calc(100vw - 32px)", boxShadow: "var(--shadow-300)", borderRadius: "var(--radius-12)" }, children: /* @__PURE__ */ R(X, { tone: n.tone, title: n.title, dismissible: !0, onDismiss: () => A(n.id), children: n.message }) }, n.id))
+    }
+  );
+}
+function pe(e) {
+  const { initialValues: t, validate: n, onSubmit: s } = e, o = Object.keys(t), i = r(), l = r(), g = r(), p = r(), u = r(), d = r(), v = m(t).on(i, (a, { name: S, value: F }) => ({ ...a, [S]: F })).reset(d), y = m({}).on(l, (a, S) => ({ ...a, [S]: !0 })).on(g, () => Object.fromEntries(o.map((a) => [a, !0]))).reset(d), w = v.map((a) => n ? n(a) : {}), x = w.map((a) => Object.keys(a).length === 0), c = m(!1).on(p, () => !0).on(u, () => !1).reset(d);
+  async function f() {
+    if (g(), !(!n || Object.keys(n(v.getState())).length === 0)) return !1;
+    if (s) {
+      p();
+      try {
+        await s(v.getState());
+      } finally {
+        u();
+      }
+    }
+    return !0;
+  }
+  function $(a) {
+    const [S, F, O] = b([v, w, y]);
+    return {
+      value: S[a],
+      error: O[a] ? F[a] : void 0,
+      onChange: (j) => i({ name: a, value: j }),
+      onBlur: () => l(a)
+    };
+  }
+  function h() {
+    const [a, S, F, O, j] = b([v, w, y, x, c]);
+    return {
+      values: a,
+      errors: S,
+      touched: F,
+      isValid: O,
+      submitting: j,
+      setField: (G, K) => i({ name: G, value: K }),
+      submit: f,
+      reset: () => d()
+    };
+  }
+  return { $values: v, $errors: w, $touched: y, $isValid: x, $submitting: c, changed: i, blurred: l, submitted: g, reset: d, submit: f, useField: $, useForm: h };
+}
+function ve(e, t = {}) {
+  const n = D(() => e()), s = r(), o = m(t.initialData ?? null).on(n.doneData, (v, y) => y).reset(s), i = m(null).on(n.failData, (v, y) => y instanceof Error ? y : new Error(String(y))).reset(n).reset(s), l = n.pending, g = m("idle").on(n, () => "loading").on(n.done, () => "success").on(n.fail, () => "error").reset(s), p = () => n(), u = () => n();
+  function d() {
+    const [v, y, w, x] = b([o, i, l, g]);
+    return { data: v, error: y, loading: w, status: x, load: p, refresh: u, reset: () => s() };
+  }
+  return { $data: o, $error: i, $loading: l, $status: g, load: p, refresh: u, reset: s, useResource: d };
+}
+function ye(e) {
+  const t = {
+    length: e.length >= 8,
+    mixedCase: /[a-z]/.test(e) && /[A-Z]/.test(e),
+    number: /[0-9]/.test(e),
+    symbol: /[^a-zA-Z0-9]/.test(e)
+  };
+  let n = 0;
+  t.length && (n += 34), t.mixedCase && (n += 33), (t.number || t.symbol) && (n += 33), n = Math.min(100, n);
+  const s = e.length === 0 ? "" : n < 40 ? "Weak" : n < 75 ? "Fair" : "Strong", o = n < 40 ? "negative" : n < 75 ? "caution" : "positive";
+  return { score: n, label: s, variant: o, rules: t };
+}
+function be() {
+  const e = r(), t = r(), n = r(), s = m(0).on(e, (u, d) => Math.max(0, Math.floor(d))).on(t, (u) => Math.max(0, u - 1)).on(n, () => 0);
+  let o = null;
+  function i() {
+    o !== null && (clearInterval(o), o = null);
+  }
+  function l(u) {
+    i(), e(u), o = setInterval(() => {
+      t(), s.getState() <= 0 && i();
+    }, 1e3);
+  }
+  function g() {
+    i(), n();
+  }
+  return { $remaining: s, start: l, stop: g, useCooldown: () => b(s) };
+}
+function se() {
+  return typeof navigator < "u" && navigator.language ? navigator.language : "en-US";
+}
+function T(e) {
+  return {
+    get current() {
+      return e.getState();
+    }
+  };
+}
+function Se(e = {}) {
+  const t = r(), n = r(), s = r(), o = m(e.locale ?? se()).on(t, (u, d) => d), i = m(e.monthFormat ?? "long").on(
+    n,
+    (u, d) => d
+  ), l = m(e.yearFormat ?? "numeric").on(
+    s,
+    (u, d) => d
+  ), g = H({
+    locale: T(o),
+    monthFormat: T(i),
+    yearFormat: T(l)
+  });
+  function p() {
+    return b([o, i, l]), g;
+  }
+  return {
+    $locale: o,
+    $monthFormat: i,
+    $yearFormat: l,
+    setLocale: t,
+    setMonthFormat: n,
+    setYearFormat: s,
+    formatter: g,
+    useFormatter: p
+  };
+}
+function we() {
+  const e = r(), t = r(), n = r(), s = r(), o = r(), i = r(), l = r(), g = r(), p = m(null).on(e, (c, f) => f).reset(t), u = m("idle").on(n, () => "joining").on(s, () => "joined").on(o, () => "errored").on(i, () => "closed").reset(t), d = m(null).on(o, (c, f) => f).reset([n, t]), v = D(
+    ({ channel: c, event: f, payload: $ }) => new Promise((h, a) => {
+      c.push(f, $).receive("ok", h).receive("error", a).receive("timeout", () => a(new Error("push timeout")));
+    })
+  );
+  M({
+    clock: g,
+    source: p,
+    filter: (c) => c !== null,
+    fn: (c, f) => ({ channel: c, event: f.event, payload: f.payload }),
+    target: v
+  });
+  function y(c, f) {
+    e(c), n();
+    const $ = f.map((h) => {
+      const a = c.on(h, (S) => l({ event: h, payload: S }));
+      return [h, a];
+    });
+    return c.onClose(() => i()), c.onError((h) => o(h)), c.join().receive("ok", (h) => s(h)).receive("error", (h) => o(h)).receive("timeout", () => o(new Error("join timeout"))), () => {
+      for (const [h, a] of $) c.off(h, a);
+      t();
+    };
+  }
+  function w(c, f = {}) {
+    g({ event: c, payload: f });
+  }
+  function x(c, f = {}) {
+    const $ = p.getState();
+    return $ === null ? Promise.reject(new Error("no channel bound")) : v({ channel: $, event: c, payload: f });
+  }
+  return {
+    $status: u,
+    $error: d,
+    joined: s,
+    message: l,
+    push: w,
+    pushAsync: x,
+    bind: y,
+    useStatus: () => b(u)
+  };
+}
+function C(e) {
+  const t = {
+    receive(n, s) {
+      return n === "ok" && s(e), t;
+    }
+  };
+  return t;
+}
+function $e(e, t = {}) {
+  const n = /* @__PURE__ */ new Map();
+  let s = 1;
+  return {
+    join: () => C(t.joinReply),
+    on(o, i) {
+      const l = s++, g = e.onServerEvent((p, u) => {
+        p === o && i(u);
+      });
+      return n.set(l, g), l;
+    },
+    off(o, i) {
+      i !== void 0 && (n.get(i)?.(), n.delete(i));
+    },
+    push(o, i) {
+      return e.pushEvent(o, i), C();
+    },
+    onClose() {
+    },
+    onError() {
+      return 0;
+    },
+    leave() {
+      for (const o of n.values()) o();
+      return n.clear(), C();
+    }
+  };
+}
+function xe(e) {
+  const t = r(), n = r(), s = r(), o = m(e?.defaultOpen ?? !1).on(t, () => !0).on(n, () => !1).on(s, (l) => !l);
+  return { $open: o, open: t, close: n, toggle: s, useOpen: () => b(o) };
+}
+const ie = r(), ae = r(), B = m([]).on(ie, (e, t) => [...e, t]).on(ae, (e, t) => {
+  const n = e.lastIndexOf(t);
+  return n === -1 ? e : [...e.slice(0, n), ...e.slice(n + 1)];
+}), I = B.map((e) => e.length > 0), ke = B.map((e) => e.at(-1) ?? null), Fe = () => b(I);
+let W = !1, E = !1, z = "", V = "";
+function U(e) {
+  if (typeof document > "u") return;
+  const t = document.body;
+  if (e && !E) {
+    E = !0, z = t.style.overflow, V = t.style.paddingRight;
+    const n = window.innerWidth - document.documentElement.clientWidth;
+    if (t.style.overflow = "hidden", n > 0) {
+      const s = parseFloat(getComputedStyle(t).paddingRight) || 0;
+      t.style.paddingRight = `${s + n}px`;
+    }
+  } else !e && E && (E = !1, t.style.overflow = z, t.style.paddingRight = V);
+}
+function Ee() {
+  W || (W = !0, !(typeof document > "u") && (U(I.getState()), I.watch(U)));
+}
+export {
+  I as $anyOverlayOpen,
+  B as $openOverlays,
+  _ as $theme,
+  ne as $toasts,
+  ke as $topOverlay,
+  he as Toaster,
+  $e as bridgeChannel,
+  te as clearToasts,
+  we as createChannel,
+  be as createCooldown,
+  xe as createDisclosure,
+  pe as createForm,
+  Se as createFormatterModel,
+  ve as createResource,
+  A as dismissToast,
+  Ee as initOverlayLock,
+  fe as initTheme,
+  ye as passwordStrength,
+  ae as popOverlay,
+  ie as pushOverlay,
+  N as setTheme,
+  k as showToast,
+  ge as toast,
+  Q as toggleTheme,
+  Fe as useAnyOverlayOpen,
+  me as useTheme,
+  oe as useToasts
+};

package/dist/resource.d.ts

@@ -0,0 +1,28 @@
+export type ResourceStatus = "idle" | "loading" | "success" | "error";
+export interface ResourceConfig<T> {
+    /** Seed value shown before the first load. */
+    initialData?: T;
+}
+/**
+ * createResource — an Effector-backed async read model + a React hook (the read
+ * twin of createForm). One effect wraps the fetcher; the stores derive from it.
+ * State lives outside React; components stay presentational.
+ */
+export declare function createResource<T>(fetcher: () => Promise<T>, config?: ResourceConfig<T>): {
+    $data: import("effector").StoreWritable<T | null>;
+    $error: import("effector").StoreWritable<Error | null>;
+    $loading: import("effector").Store<boolean>;
+    $status: import("effector").StoreWritable<ResourceStatus>;
+    load: () => Promise<T>;
+    refresh: () => Promise<T>;
+    reset: import("effector").EventCallable<void>;
+    useResource: () => {
+        data: T | null;
+        error: Error | null;
+        loading: boolean;
+        status: ResourceStatus;
+        load: () => Promise<T>;
+        refresh: () => Promise<T>;
+        reset: () => void;
+    };
+};

package/dist/strength.d.ts

@@ -0,0 +1,21 @@
+/**
+ * passwordStrength — a pure scorer for password fields. Pairs with the
+ * <PasswordStrength /> meter and <Checklist /> in @mercury-fx/ui: feed `score` /
+ * `label` / `variant` to the meter and `rules` to the checklist.
+ */
+export type StrengthVariant = "negative" | "caution" | "positive";
+export interface PasswordRules {
+    length: boolean;
+    mixedCase: boolean;
+    number: boolean;
+    symbol: boolean;
+}
+export interface PasswordStrengthResult {
+    /** 0–100. */
+    score: number;
+    /** "" while empty, else Weak / Fair / Strong. */
+    label: "" | "Weak" | "Fair" | "Strong";
+    variant: StrengthVariant;
+    rules: PasswordRules;
+}
+export declare function passwordStrength(password: string): PasswordStrengthResult;

package/dist/theme.d.ts

@@ -0,0 +1,8 @@
+export type Theme = "light" | "dark";
+export declare const setTheme: import("effector").EventCallable<Theme>;
+export declare const toggleTheme: import("effector").EventCallable<void>;
+export declare const $theme: import("effector").StoreWritable<Theme>;
+/** Call once at app start to sync <html> with the store. Idempotent. */
+export declare function initTheme(): void;
+/** Reactive theme value for components. */
+export declare const useTheme: () => Theme;

package/dist/toast.d.ts

@@ -0,0 +1,33 @@
+import type { AlertTone } from "@mercury-fx/ui";
+export interface ToastOptions {
+    tone?: AlertTone;
+    title?: string;
+    message?: string;
+    /** Auto-dismiss after N ms. Default 4000. Pass 0 to keep open. */
+    duration?: number;
+}
+export interface ToastItem {
+    id: number;
+    tone: AlertTone;
+    title?: string;
+    message?: string;
+    duration: number;
+}
+export declare const showToast: import("effector").EventCallable<string | ToastOptions>;
+export declare const dismissToast: import("effector").EventCallable<number>;
+export declare const clearToasts: import("effector").EventCallable<void>;
+export declare const $toasts: import("effector").StoreWritable<ToastItem[]>;
+/** Imperative helper: `toast.success("Saved")`, `toast.error({ title, message })`. */
+export declare const toast: {
+    show: (o: ToastOptions | string) => string | ToastOptions;
+    info: (message: string, o?: Omit<ToastOptions, "tone" | "message">) => string | ToastOptions;
+    success: (message: string, o?: Omit<ToastOptions, "tone" | "message">) => string | ToastOptions;
+    warning: (message: string, o?: Omit<ToastOptions, "tone" | "message">) => string | ToastOptions;
+    error: (message: string, o?: Omit<ToastOptions, "tone" | "message">) => string | ToastOptions;
+};
+export declare const useToasts: () => ToastItem[];
+export type ToasterPosition = "top-end" | "bottom-end" | "bottom-center";
+/** Drop once near the app root. Renders live toasts as Mercury Alerts. */
+export declare function Toaster({ position }: {
+    position?: ToasterPosition;
+}): import("react").JSX.Element;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mercury-fx/effector",
+  "version": "2.4.0",
+  "description": "Effector adapter for Mercury — theme store, toast model + Toaster, and a form/field factory. Components stay presentational.",
+  "type": "module",
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jonny-novikov/mercury-fx.git",
+    "directory": "packages/mercury-effector"
+  },
+  "homepage": "https://github.com/jonny-novikov/mercury-fx/tree/master/packages/mercury-effector#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "imports": {
+    "#*": "./src/*"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/mercury-effector.js"
+    }
+  },
+  "peerDependencies": {
+    "effector": ">=23",
+    "effector-react": ">=23",
+    "react": ">=18",
+    "@mercury-fx/ui": "2.4.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19",
+    "@vitejs/plugin-react": "^4.3.3",
+    "effector": "^23.3.0",
+    "effector-react": "^23.3.0",
+    "react": "^19",
+    "typescript": "~5.9.3",
+    "vite": "^7",
+    "@mercury-fx/ui": "2.4.0",
+    "@mercury-fx/core": "2.4.0"
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "dev": "vite build --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}