@mittwald/flow-react-components 0.1.0-alpha.127 → 0.1.0-alpha.129

package/dist/Action-BPEu-X47.js

@@ -0,0 +1,322 @@
+"use client"
+/* */
+var F = Object.defineProperty;
+var P = (o, t, e) => t in o ? F(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var a = (o, t, e) => (P(o, typeof t != "symbol" ? t + "" : t, e), e);
+import r, { useRef as S, useContext as p } from "react";
+import { makeObservable as k, observable as O, action as I, computed as M } from "mobx";
+import { u as C } from "./useOverlayController-CGKumeGL.js";
+import D from "invariant";
+import { A as T, a as A, u as N, b as w, c as R } from "./ActionStateContext-B4ZIqu_K.js";
+import { u as y } from "./useSelector-DpU7_HMO.js";
+import "./propsContext-CauylOgH.js";
+import { P as h } from "./PropsContextProvider-ChpH8eF2.js";
+import "@react-aria/utils";
+import "remeda";
+import { W as v } from "./Wrap-DGT1h1o3.js";
+const x = (o) => new Promise((t) => setTimeout(t, o)), m = {
+  pending: 1e3,
+  succeeded: 1500,
+  failed: 2e3
+};
+class f {
+  constructor() {
+    a(this, "showFeedback");
+    a(this, "state", "isIdle");
+    a(this, "setPendingTimeout");
+    a(this, "error");
+    a(this, "isAsync", !1);
+    k(this, {
+      state: O,
+      updateState: I,
+      isBusy: M
+    });
+  }
+  static useNew() {
+    const t = S(new f()).current;
+    return T.useRegisterState(t), t;
+  }
+  updateState(t) {
+    this.state = t;
+  }
+  useValue() {
+    return y(() => this.state, [this]);
+  }
+  useIsBusy() {
+    return y(() => this.isBusy, [this]);
+  }
+  get isBusy() {
+    return this.state === "isExecuting" || this.state === "isPending";
+  }
+  onAsyncStart() {
+    this.isAsync = !0, this.updateState("isExecuting"), this.setPendingTimeout = window.setTimeout(
+      () => this.startPending(),
+      m.pending
+    );
+  }
+  async onSucceeded() {
+    await this.onDone();
+  }
+  async onFailed(t) {
+    this.error = t ?? new Error("Unknown error"), await this.onDone();
+  }
+  withFeedback(t) {
+    return this.showFeedback = t, this;
+  }
+  async startFailedFeedback() {
+    this.updateState("isFailed"), await x(m.failed), this.resetAfterDone();
+  }
+  async startSucceededFeedback() {
+    this.updateState("isSucceeded"), await x(m.succeeded), this.resetAfterDone();
+  }
+  resetAfterDone() {
+    this.updateState("isIdle"), this.isAsync = !1, this.error = void 0;
+  }
+  async onDone() {
+    this.setPendingTimeout && window.clearTimeout(this.setPendingTimeout), this.error ? await this.startFailedFeedback() : this.showFeedback !== !1 && (this.showFeedback || this.isAsync) ? await this.startSucceededFeedback() : this.resetAfterDone();
+  }
+  startPending() {
+    this.updateState("isPending");
+  }
+}
+const E = (o) => (...t) => {
+  const e = [...o], n = e.shift();
+  if (n) {
+    const s = n(...t), i = () => e.length === 0 ? s : E(e)(...t);
+    return s instanceof Promise ? s.then(i) : i();
+  }
+}, d = () => {
+}, G = (o, t = {}) => {
+  const {
+    onSync: e = d,
+    onAsync: n = d,
+    then: s = d,
+    catch: i = d,
+    finally: l = d
+  } = t;
+  try {
+    const c = o();
+    return c instanceof Promise ? (n(), c.then(s).catch(i).finally(l)) : (e(), s(c), l(), c);
+  } catch (c) {
+    e(), i(c), l();
+  }
+}, V = () => {
+};
+function $(o) {
+  if (o.needsConfirmation)
+    return o.confirmationModalController.open;
+  const t = o.getOverlayController(), {
+    action: e,
+    toggleOverlay: n,
+    closeOverlay: s,
+    openOverlay: i
+  } = o.actionProps;
+  return e || (i && t ? t.open : s && t || n && t ? t.close : V);
+}
+class b {
+  constructor(t) {
+    a(this, "actions", []);
+    a(this, "baseAction");
+    this.baseAction = t;
+  }
+  addAction(t) {
+    this.actions.push(t);
+  }
+  async executeBatch(t) {
+    if (this.actions.length === 0)
+      return;
+    const e = this.actions[this.actions.length - 1].actionProps.showFeedback, n = this.baseAction.state.withFeedback(
+      this.baseAction.needsConfirmation ? !1 : e
+    ), s = this.actions.map((c) => $(c)), i = E(s);
+    let l;
+    if (await G(() => i(...t), {
+      onAsync: () => n.onAsyncStart(),
+      then: () => n.onSucceeded(),
+      catch: (c) => {
+        n.onFailed(c), l = c;
+      }
+    }), l)
+      throw l;
+  }
+}
+class W {
+  constructor(t) {
+    a(this, "action");
+    a(this, "execute", (...t) => {
+      const e = this.getBatchedActions();
+      (async () => {
+        for (const s of e)
+          await s.executeBatch(t);
+      })().catch((s) => console.error(s));
+    });
+    a(this, "getBatchedActions", () => {
+      let t = this.action;
+      const e = [];
+      let n = new b(
+        this.action
+      ), s = 0;
+      for (; t; ) {
+        const { action: i, break: l, skip: c } = t.actionProps;
+        if (t.needsConfirmation) {
+          n.addAction(t);
+          break;
+        }
+        if (c) {
+          s = c === !0 ? 1 : c, t = t.parentAction;
+          continue;
+        }
+        if (s > 0) {
+          t = t.parentAction, s--;
+          continue;
+        }
+        if (l)
+          break;
+        i || (e.push(n), n = new b(this.action)), n.addAction(t), t = t.parentAction;
+      }
+      return e.push(n), e;
+    });
+    this.action = t;
+  }
+}
+class u {
+  constructor(t) {
+    a(this, "state");
+    a(this, "needsConfirmation");
+    a(this, "actionProps");
+    a(this, "parentAction");
+    a(this, "confirmationModalController");
+    a(this, "overlayController");
+    a(this, "execute", (...t) => {
+      new W(this).execute(...t);
+    });
+    const {
+      actionProps: e,
+      needsConfirmation: n,
+      parentAction: s,
+      overlayController: i,
+      confirmationModalController: l,
+      state: c
+    } = t;
+    this.actionProps = e, this.parentAction = s, this.confirmationModalController = l, this.needsConfirmation = n, this.overlayController = i, this.state = c;
+  }
+  static useNew(t, e = {}) {
+    const n = p(A), s = C(), i = C(), l = f.useNew();
+    return new u({
+      parentAction: n,
+      overlayController: s,
+      confirmationModalController: i,
+      needsConfirmation: !1,
+      actionProps: t,
+      state: l,
+      ...e
+    });
+  }
+  static use() {
+    const t = p(A);
+    return D(!!t, "Action context is not defined"), t;
+  }
+  static useConfirmationAction() {
+    const t = u.use();
+    return new u({
+      actionProps: t.actionProps,
+      confirmationModalController: t.confirmationModalController,
+      overlayController: t.overlayController,
+      state: t.state,
+      needsConfirmation: !1,
+      parentAction: u.useNew(
+        {
+          closeOverlay: !0
+        },
+        {
+          parentAction: t.parentAction
+        }
+      )
+    });
+  }
+  getOverlayController() {
+    const t = (e) => e === void 0 ? void 0 : e === !0 ? this.overlayController : e === !1 ? void 0 : e;
+    return t(this.actionProps.openOverlay) ?? t(this.actionProps.closeOverlay) ?? t(this.actionProps.toggleOverlay);
+  }
+}
+const B = (o, t) => {
+  const e = u.use(), n = e.state.useValue(), s = N().useIsBusy();
+  return e.confirmationModalController.useIsOpen() && e.needsConfirmation ? /* @__PURE__ */ r.createElement(o, { ...t, onPress: e.execute }) : /* @__PURE__ */ r.createElement(
+    o,
+    {
+      onPress: e.execute,
+      isPending: n === "isPending",
+      "aria-disabled": n === "isExecuting" || s,
+      isSucceeded: n === "isSucceeded",
+      isFailed: n === "isFailed",
+      ...t
+    }
+  );
+}, L = (o, t) => {
+  const e = u.use(), n = e.state.useValue();
+  return e.needsConfirmation ? /* @__PURE__ */ r.createElement(o, { ...t, onPress: e.execute }) : /* @__PURE__ */ r.createElement(
+    o,
+    {
+      ...t,
+      onPress: e.execute,
+      "aria-disabled": n !== "isIdle"
+    }
+  );
+}, U = (o, t) => {
+  const e = u.useConfirmationAction(), n = t.color === "secondary";
+  if (!(t.color === "primary" || t.color === "danger" || t.color === "accent") && !n)
+    return /* @__PURE__ */ r.createElement(o, { ...t });
+  const i = { Button: { render: B } };
+  return n ? /* @__PURE__ */ r.createElement(h, { props: i, mergeInParentContext: !0 }, /* @__PURE__ */ r.createElement(g, { break: !0 }, /* @__PURE__ */ r.createElement(g, { closeOverlay: !0 }, /* @__PURE__ */ r.createElement(o, { ...t })))) : /* @__PURE__ */ r.createElement(h, { props: i, mergeInParentContext: !0 }, /* @__PURE__ */ r.createElement(w, { value: e }, /* @__PURE__ */ r.createElement(o, { ...t })));
+}, j = (o, t) => {
+  const e = u.use();
+  e.needsConfirmation = t.slot === "actionConfirm";
+  const n = e.state.useIsBusy(), s = e.needsConfirmation ? e.confirmationModalController : e.getOverlayController(), i = n ? !1 : t.isDismissable;
+  return /* @__PURE__ */ r.createElement(
+    o,
+    {
+      ...t,
+      isDismissable: i,
+      controller: s ?? t.controller
+    },
+    /* @__PURE__ */ r.createElement(v, { if: e.needsConfirmation }, /* @__PURE__ */ r.createElement(
+      h,
+      {
+        props: {
+          ButtonGroup: {
+            Button: {
+              render: U
+            }
+          }
+        }
+      },
+      t.children
+    ))
+  );
+}, q = (o, t) => /* @__PURE__ */ r.createElement(o, { ...t }, /* @__PURE__ */ r.createElement(R, null, t.children)), g = (o) => {
+  const { children: t, ...e } = o, n = u.useNew(e), s = !n.parentAction, i = {
+    Modal: {
+      render: j
+    },
+    ButtonGroup: {
+      render: q
+    },
+    Button: {
+      render: B
+    },
+    Link: {
+      render: L
+    }
+  };
+  return /* @__PURE__ */ r.createElement(w, { value: n }, /* @__PURE__ */ r.createElement(v, { if: s }, /* @__PURE__ */ r.createElement(
+    h,
+    {
+      props: i,
+      dependencies: [n],
+      mergeInParentContext: !0
+    },
+    t
+  )));
+};
+export {
+  g as A
+};

package/dist/Action.js

@@ -1,6 +1,6 @@
 "use client"
 /* */
-import { A as t } from "./Action-BLnSsHE1.js";
+import { A as t } from "./Action-BPEu-X47.js";
 export {
   t as Action,
   t as default

package/dist/ActionStateContext-B4ZIqu_K.js

@@ -0,0 +1,55 @@
+"use client"
+/* */
+var i = Object.defineProperty;
+var u = (s, t, e) => t in s ? i(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var r = (s, t, e) => (u(s, typeof t != "symbol" ? t + "" : t, e), e);
+import d, { createContext as n, useRef as m, useEffect as v, useContext as S } from "react";
+import { makeObservable as f, observable as x, action as a, computed as l } from "mobx";
+import { u as h } from "./useSelector-DpU7_HMO.js";
+const C = n(void 0), A = C.Provider;
+class o {
+  constructor() {
+    r(this, "states", /* @__PURE__ */ new Set());
+    f(this, {
+      states: x,
+      addState: a,
+      removeState: a,
+      isBusy: l
+    });
+  }
+  static useNew() {
+    return m(new o()).current;
+  }
+  static useRegisterState(t) {
+    const e = b();
+    v(() => (e.addState(t), () => {
+      e.removeState(t);
+    }), [e, t]);
+  }
+  addState(t) {
+    this.states.add(t);
+  }
+  removeState(t) {
+    this.states.delete(t);
+  }
+  useIsBusy() {
+    return h(() => this.isBusy, [this]);
+  }
+  get isBusy() {
+    for (const t of this.states)
+      if (t.isBusy)
+        return !0;
+    return !1;
+  }
+}
+const c = n(new o()), P = (s) => {
+  const { children: t } = s, e = o.useNew();
+  return /* @__PURE__ */ d.createElement(c.Provider, { value: e }, t);
+}, b = () => S(c);
+export {
+  o as A,
+  C as a,
+  A as b,
+  P as c,
+  b as u
+};

package/dist/CopyButton.js

@@ -15,7 +15,7 @@ import "@react-aria/utils";
 import "remeda";
 import "dot-prop";
 import { f as C } from "./flowComponent-DHBRxUvd.js";
-import { A as E } from "./Action-BLnSsHE1.js";
+import { A as E } from "./Action-BPEu-X47.js";
 const B = {
   "de-DE": {
     "copyButton.copy": "Kopieren"

package/dist/Modal.js

@@ -11,7 +11,8 @@ import { f as u } from "./flowComponent-DHBRxUvd.js";
 import { O as w } from "./Overlay-BWA78Wvu.js";
 import "mobx";
 import "./useOverlayController-CGKumeGL.js";
-import "./context-D3hdrTHO.js";
+import "invariant";
+import "./ActionStateContext-B4ZIqu_K.js";
 const v = "flow--modal", z = "flow--modal--button-group", C = "flow--modal--content", b = "flow--modal--off-canvas", t = {
   modal: v,
   "modal-zoom": "flow--modal--modal-zoom",
@@ -23,12 +24,12 @@ const v = "flow--modal", z = "flow--modal--button-group", C = "flow--modal--cont
   offCanvas: b,
   "modal-slide-in": "flow--modal--modal-slide-in",
   "modal-slide-up": "flow--modal--modal-slide-up"
-}, F = u("Modal", (e) => {
+}, H = u("Modal", (e) => {
   const {
     size: l = "s",
     offCanvas: n,
-    controller: a,
-    children: m,
+    controller: m,
+    children: a,
     refProp: E,
     ...s
   } = e, r = d(
@@ -48,9 +49,9 @@ const v = "flow--modal", z = "flow--modal--button-group", C = "flow--modal--cont
       tunnelId: "buttons"
     }
   };
-  return /* @__PURE__ */ o.createElement(w, { className: r, controller: a, ...s }, /* @__PURE__ */ o.createElement(f, { props: i }, /* @__PURE__ */ o.createElement(p, null, /* @__PURE__ */ o.createElement("div", { className: t.content }, m), /* @__PURE__ */ o.createElement(c, { id: "buttons" }))));
+  return /* @__PURE__ */ o.createElement(w, { className: r, controller: m, ...s }, /* @__PURE__ */ o.createElement(f, { props: i }, /* @__PURE__ */ o.createElement(p, null, /* @__PURE__ */ o.createElement("div", { className: t.content }, a), /* @__PURE__ */ o.createElement(c, { id: "buttons" }))));
 });
 export {
-  F as Modal,
-  F as default
+  H as Modal,
+  H as default
 };

package/dist/OffCanvas.js

@@ -6,7 +6,7 @@ import { B as f } from "./Button-54Eoq_9o.js";
 import "@tabler/icons-react";
 import "./Icon-BwDd2GzD.js";
 import { I as m } from "./IconClose-D5lPIOIs.js";
-import { A as i } from "./Action-BLnSsHE1.js";
+import { A as i } from "./Action-BPEu-X47.js";
 import { O as p } from "./Overlay-BWA78Wvu.js";
 import "mobx";
 import "./useOverlayController-CGKumeGL.js";

package/dist/OverlayTrigger.js

@@ -1,22 +1,22 @@
 "use client"
 /* */
-import r from "react";
+import e from "react";
 import "mobx";
-import { u as l, a as m } from "./useOverlayController-CGKumeGL.js";
-import { A as p } from "./Action-BLnSsHE1.js";
+import { u as m, a as l } from "./useOverlayController-CGKumeGL.js";
+import { A as p } from "./Action-BPEu-X47.js";
 import "./propsContext-CauylOgH.js";
 import { P as i } from "./PropsContextProvider-ChpH8eF2.js";
 import "@react-aria/utils";
 import "remeda";
-const x = (t) => {
-  const e = l(), o = {
+const y = (t) => {
+  const r = m(), o = {
     Button: {
-      render: (a, n) => /* @__PURE__ */ r.createElement(p, { openOverlay: e }, /* @__PURE__ */ r.createElement(a, { ...n }))
+      render: (n, a) => /* @__PURE__ */ e.createElement(p, { openOverlay: r }, /* @__PURE__ */ e.createElement(n, { ...a }))
     }
   };
-  return /* @__PURE__ */ r.createElement(m, { value: e }, /* @__PURE__ */ r.createElement(i, { props: o }, t.children));
+  return /* @__PURE__ */ e.createElement(l, { value: r }, /* @__PURE__ */ e.createElement(i, { props: o, mergeInParentContext: !0 }, t.children));
 };
 export {
-  x as OverlayTrigger,
-  x as default
+  y as OverlayTrigger,
+  y as default
 };

package/dist/types/components/Action/components/ActionGroup.d.ts

@@ -0,0 +1,4 @@
+import { FlowRenderFn } from '../../../lib/types/props';
+import { ButtonGroupProps } from '../../ButtonGroup';
+
+export declare const ActionGroup: FlowRenderFn<ButtonGroupProps>;

package/dist/types/components/Action/components/{ConfirmationModal.d.ts → ActionModal.d.ts}

@@ -1,4 +1,4 @@
 import { FlowRenderFn } from '../../../lib/types/props';
 import { ModalProps } from '../../Modal';
 
-export declare const ConfirmationModal: FlowRenderFn<ModalProps>;
+export declare const ActionModal: FlowRenderFn<ModalProps>;

package/dist/types/components/Action/context.d.ts

@@ -1,15 +1,4 @@
-import { ActionProps } from './types';
-import { OverlayController } from '../../lib/controller';
-import { ActionState } from './lib/execution/ActionState';
+import { ActionModel } from './models/ActionModel';
 
-export interface ActionContextValue {
-    actionProps: ActionProps;
-    parentContext?: ActionContextValue;
-    confirmationModalController: OverlayController;
-    needsConfirmation: boolean;
-    overlayController: OverlayController;
-    state: ActionState;
-}
-export declare const ActionContextProvider: import('react').Provider<ActionContextValue>;
-export declare const useActionContext: () => ActionContextValue;
-export declare const useNewActionContext: (props: ActionProps) => ActionContextValue;
+export declare const actionContext: import('react').Context<ActionModel | undefined>;
+export declare const ActionContextProvider: import('react').Provider<ActionModel | undefined>;

package/dist/types/components/Action/lib/ariaLive.d.ts

@@ -1,4 +1,4 @@
-import { ActionStateValue } from './execution/ActionState';
+import { ActionStateValue } from '../models/ActionState';
 
 interface Options {
     isPendingText?: string;

package/dist/types/components/Action/models/ActionExecution.d.ts

@@ -0,0 +1,8 @@
+import { ActionModel } from './ActionModel';
+
+export declare class ActionExecution {
+    private readonly action;
+    constructor(action: ActionModel);
+    execute: (...args: unknown[]) => void;
+    private getBatchedActions;
+}

package/dist/types/components/Action/models/ActionExecutionBatch.d.ts

@@ -0,0 +1,9 @@
+import { ActionModel } from './ActionModel';
+
+export declare class ActionExecutionBatch {
+    private readonly actions;
+    readonly baseAction: ActionModel;
+    constructor(baseAction: ActionModel);
+    addAction(action: ActionModel): void;
+    executeBatch(args: unknown[]): Promise<void>;
+}

package/dist/types/components/Action/models/ActionModel.d.ts

@@ -0,0 +1,27 @@
+import { OverlayController } from '../../../lib/controller';
+import { ActionProps } from '../types';
+import { ActionState } from './ActionState';
+
+interface InitObject {
+    actionProps: ActionProps;
+    parentAction?: ActionModel;
+    confirmationModalController: OverlayController;
+    needsConfirmation: boolean;
+    overlayController: OverlayController;
+    state: ActionState;
+}
+export declare class ActionModel {
+    state: ActionState;
+    needsConfirmation: boolean;
+    readonly actionProps: ActionProps;
+    readonly parentAction?: ActionModel;
+    readonly confirmationModalController: OverlayController;
+    readonly overlayController: OverlayController;
+    private constructor();
+    static useNew(actionProps: ActionProps, init?: Partial<InitObject>): ActionModel;
+    static use(): ActionModel;
+    static useConfirmationAction(): ActionModel;
+    getOverlayController(): OverlayController | undefined;
+    execute: (...args: unknown[]) => void;
+}
+export {};

package/dist/types/components/Action/models/ActionState.d.ts

@@ -0,0 +1,23 @@
+export type ActionStateValue = "isIdle" | "isSucceeded" | "isPending" | "isExecuting" | "isFailed";
+export declare class ActionState {
+    private showFeedback?;
+    state: ActionStateValue;
+    private setPendingTimeout;
+    error: unknown;
+    private isAsync;
+    constructor();
+    static useNew(): ActionState;
+    updateState(newState: ActionStateValue): void;
+    useValue(): ActionStateValue;
+    useIsBusy(): boolean;
+    get isBusy(): boolean;
+    onAsyncStart(): void;
+    onSucceeded(): Promise<void>;
+    onFailed(error: unknown): Promise<void>;
+    withFeedback(feedback?: boolean): ActionState;
+    private startFailedFeedback;
+    private startSucceededFeedback;
+    private resetAfterDone;
+    private onDone;
+    private startPending;
+}

package/dist/types/components/Action/models/ActionStateContext.d.ts

@@ -0,0 +1,15 @@
+import { FC, PropsWithChildren } from 'react';
+import { ActionState } from './ActionState';
+
+export declare class ActionStateContext {
+    states: Set<ActionState>;
+    constructor();
+    static useNew(): ActionStateContext;
+    static useRegisterState(state: ActionState): void;
+    addState(state: ActionState): void;
+    removeState(state: ActionState): void;
+    useIsBusy(): boolean;
+    get isBusy(): boolean;
+}
+export declare const ActionStateContextProvider: FC<PropsWithChildren>;
+export declare const useActionStateContext: () => ActionStateContext;

package/dist/types/components/Action/models/getExecutionFunction.d.ts

@@ -0,0 +1,4 @@
+import { ActionModel } from './ActionModel';
+import { ActionFn } from '..';
+
+export declare function getExecutionFunction(action: ActionModel): ActionFn;

package/dist/types/components/Action/types.d.ts

@@ -8,5 +8,6 @@ export interface ActionProps extends PropsWithChildren {
     openOverlay?: boolean | OverlayController;
     toggleOverlay?: boolean | OverlayController;
     break?: boolean;
+    skip?: number | boolean;
     showFeedback?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/flow-react-components",
-  "version": "0.1.0-alpha.127",
+  "version": "0.1.0-alpha.129",
   "type": "module",
   "description": "A React implementation of Flow, mittwald’s design system",
   "homepage": "https://mittwald.github.io/flow",
@@ -259,7 +259,7 @@
   },
   "dependencies": {
     "@chakra-ui/live-region": "^2.1.0",
-    "@mittwald/react-tunnel": "^0.1.0-alpha.127",
+    "@mittwald/react-tunnel": "^0.1.0-alpha.129",
     "@mittwald/react-use-promise": "^2.3.13",
     "@react-aria/utils": "^3.24.1",
     "@react-types/shared": "^3.23.1",
@@ -283,7 +283,7 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
-    "@mittwald/flow-design-tokens": "^0.1.0-alpha.127",
+    "@mittwald/flow-design-tokens": "^0.1.0-alpha.129",
     "@mittwald/react-use-promise": "^2.3.13",
     "@nx/storybook": "^19.0.5",
     "@storybook/addon-a11y": "^8.1.2",
@@ -359,5 +359,5 @@
       "optional": true
     }
   },
-  "gitHead": "0344a25da2cf7f981180c9035758696649ae8236"
+  "gitHead": "62d13d6425d7321541323b3cea292d2c518ec9c6"
 }

package/dist/Action-BLnSsHE1.js

@@ -1,233 +0,0 @@
-"use client"
-/* */
-var $ = Object.defineProperty;
-var N = (t, e, n) => e in t ? $(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
-var l = (t, e, n) => (N(t, typeof e != "symbol" ? e + "" : e, n), n);
-import r, { useEffect as W } from "react";
-import { u as h, a as G, A as L } from "./context-D3hdrTHO.js";
-import "./propsContext-CauylOgH.js";
-import { P as M } from "./PropsContextProvider-ChpH8eF2.js";
-import "@react-aria/utils";
-import "remeda";
-import { W as U } from "./Wrap-DGT1h1o3.js";
-const u = () => {
-}, j = (t, e = {}) => {
-  const {
-    onSync: n = u,
-    onAsync: o = u,
-    then: s = u,
-    catch: i = u,
-    finally: c = u
-  } = e;
-  try {
-    const a = t();
-    return a instanceof Promise ? (o(), a.then(s).catch(i).finally(c)) : (n(), s(a), c(), a);
-  } catch (a) {
-    n(), i(a), c();
-  }
-}, P = (t) => new Promise((e) => setTimeout(e, t)), x = {
-  pending: 1e3,
-  succeeded: 1500,
-  failed: 2e3
-};
-class q {
-  constructor(e, n, o = {}) {
-    l(this, "options");
-    l(this, "state");
-    l(this, "args");
-    l(this, "isDone", !1);
-    l(this, "error");
-    const {
-      resetAfterDone: s = !0,
-      onFeedbackDone: i = () => {
-      },
-      showFeedback: c = !1,
-      resetDelayMs: a = 0
-    } = o;
-    this.state = e, this.args = n, this.options = {
-      resetAfterDone: s,
-      onFeedbackDone: i,
-      showFeedback: c,
-      resetDelayMs: a
-    };
-  }
-  onAsyncStart() {
-    this.options.showFeedback = !0, this.state.updateState("isExecuting"), setTimeout(() => this.startPending(), x.pending);
-  }
-  onSucceeded() {
-    return this.onDone();
-  }
-  async onFailed(e) {
-    this.error = e ?? new Error("Unknown error"), console.error(e), await this.onDone();
-  }
-  setResetDelay(e) {
-    this.options.resetDelayMs = e;
-  }
-  async startFailedFeedback() {
-    this.state.updateState("isFailed"), await P(x.failed), this.resetAfterDone();
-  }
-  async startSucceededFeedback() {
-    this.state.updateState("isSucceeded"), await P(x.succeeded), this.resetAfterDone();
-  }
-  resetAfterDone() {
-    setTimeout(() => {
-      this.options.resetAfterDone && this.state.updateState("isIdle"), this.error || this.options.onFeedbackDone(...this.args);
-    }, this.options.resetDelayMs);
-  }
-  async onDone() {
-    this.isDone = !0, this.options.showFeedback ? this.error ? await this.startFailedFeedback() : await this.startSucceededFeedback() : this.resetAfterDone();
-  }
-  startPending() {
-    this.isDone || this.state.updateState("isPending");
-  }
-}
-const v = (t) => (...e) => {
-  const n = [...t], o = n.shift();
-  if (o) {
-    const s = o(...e), i = () => n.length === 0 ? s : v(n)(...e);
-    return s instanceof Promise ? s.then(i) : i();
-  }
-}, z = () => {
-}, b = () => {
-  var n;
-  const t = h(), e = t.actionProps.confirm || t.actionProps.abort ? ((n = t.parentContext) == null ? void 0 : n.state) ?? t.state : t.state;
-  return {
-    state: e,
-    execute: async (...o) => {
-      var D;
-      const {
-        actionProps: s,
-        confirmationModalController: i,
-        needsConfirmation: c,
-        parentContext: a
-      } = t;
-      if (s.abort) {
-        (D = a == null ? void 0 : a.confirmationModalController) == null || D.close();
-        return;
-      }
-      if (c && !i.isOpen) {
-        i.open();
-        return;
-      }
-      const f = new q(e, o, s), A = [];
-      let d, p, m = t;
-      for (; m; ) {
-        const {
-          actionProps: C,
-          overlayController: B,
-          confirmationModalController: E,
-          needsConfirmation: R
-        } = m, {
-          action: S,
-          toggleOverlay: g,
-          openOverlay: F,
-          closeOverlay: w,
-          break: T
-        } = C;
-        if (T)
-          break;
-        if (R)
-          if (d) {
-            p = E;
-            break;
-          } else
-            d = E;
-        const y = (k) => typeof k == "boolean" ? B : k;
-        A.push(
-          S || (g ? y(g).toggle : F ? y(F).open : w ? y(w).close : z)
-        ), m = m.parentContext;
-      }
-      const O = v(A);
-      f.setResetDelay(
-        d ? 500 : 0
-      ), await j(() => O(o), {
-        onAsync: () => f.onAsyncStart(),
-        then: async () => {
-          await f.onSucceeded(), p && p.open(), d && d.close();
-        },
-        catch: (C) => f.onFailed(C)
-      });
-    }
-  };
-}, I = (t, e) => {
-  const { actionProps: n, needsConfirmation: o } = h(), s = b(), i = s.state.useState();
-  return o ? /* @__PURE__ */ r.createElement(t, { ...e, onPress: s.execute }) : n.abort ? /* @__PURE__ */ r.createElement(
-    t,
-    {
-      ...e,
-      onPress: s.execute,
-      "aria-disabled": i !== "isIdle"
-    }
-  ) : /* @__PURE__ */ r.createElement(
-    t,
-    {
-      ...e,
-      onPress: s.execute,
-      isPending: i === "isPending",
-      "aria-disabled": i === "isExecuting",
-      isSucceeded: i === "isSucceeded",
-      isFailed: i === "isFailed"
-    }
-  );
-}, H = (t, e) => {
-  const { needsConfirmation: n } = h(), o = b(), s = o.state.useState();
-  return n ? /* @__PURE__ */ r.createElement(t, { ...e, onPress: o.execute }) : /* @__PURE__ */ r.createElement(
-    t,
-    {
-      ...e,
-      onPress: o.execute,
-      "aria-disabled": s !== "isIdle"
-    }
-  );
-}, J = (t, e) => {
-  const n = e.color === "secondary", o = e.color === "primary" || e.color === "danger" || e.color === "accent";
-  if (!o && !n)
-    return /* @__PURE__ */ r.createElement(t, { ...e });
-  const s = { Button: { render: I } };
-  return /* @__PURE__ */ r.createElement(M, { props: s }, /* @__PURE__ */ r.createElement(Q, { abort: n, confirm: o }, /* @__PURE__ */ r.createElement(t, { ...e })));
-}, K = (t, e) => {
-  if (e.slot !== "actionConfirm")
-    return /* @__PURE__ */ r.createElement(t, { ...e });
-  const n = h(), o = b().state.useState();
-  W(() => (n.needsConfirmation = !0, () => {
-    n.needsConfirmation = !1;
-  }), [n]);
-  const s = o === "isIdle" ? e.isDismissable : !1;
-  return /* @__PURE__ */ r.createElement(
-    t,
-    {
-      ...e,
-      controller: n.confirmationModalController,
-      isDismissable: s
-    }
-  );
-}, Q = (t) => {
-  const { children: e, ...n } = t, o = G(n), s = !!o.parentContext && !!o.parentContext.parentContext, i = {
-    Modal: {
-      render: K,
-      ButtonGroup: {
-        Button: {
-          render: J
-        }
-      }
-    },
-    Button: {
-      render: I
-    },
-    Link: {
-      render: H
-    }
-  };
-  return /* @__PURE__ */ r.createElement(L, { value: o }, /* @__PURE__ */ r.createElement(U, { if: !s }, /* @__PURE__ */ r.createElement(
-    M,
-    {
-      props: i,
-      dependencies: [o],
-      mergeInParentContext: !0
-    },
-    e
-  )));
-};
-export {
-  Q as A
-};

package/dist/context-D3hdrTHO.js

@@ -1,58 +0,0 @@
-"use client"
-/* */
-var u = Object.defineProperty;
-var m = (e, t, o) => t in e ? u(e, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : e[t] = o;
-var a = (e, t, o) => (m(e, typeof t != "symbol" ? t + "" : t, o), o);
-import { useRef as C, createContext as f, useMemo as d, useContext as p } from "react";
-import { O as i, u as l } from "./useOverlayController-CGKumeGL.js";
-import { makeObservable as v, observable as x, action as w } from "mobx";
-import { u as b } from "./useSelector-DpU7_HMO.js";
-class r {
-  constructor() {
-    a(this, "state", "isIdle");
-    v(this, {
-      state: x,
-      updateState: w
-    });
-  }
-  static useNew() {
-    return C(new r()).current;
-  }
-  updateState(t) {
-    this.state = t;
-  }
-  useState() {
-    return b(() => this.state, [this]);
-  }
-}
-const c = f({
-  actionProps: {},
-  state: new r(),
-  overlayController: new i(),
-  confirmationModalController: new i(),
-  needsConfirmation: !1
-}), M = c.Provider, h = () => p(c), N = (e) => {
-  const t = h(), o = l(), n = r.useNew(), s = l();
-  return d(
-    () => ({
-      actionProps: e,
-      parentContext: t,
-      overlayController: o,
-      state: n,
-      confirmationModalController: s,
-      needsConfirmation: !1
-    }),
-    [
-      e,
-      t,
-      o,
-      n,
-      s
-    ]
-  );
-};
-export {
-  M as A,
-  N as a,
-  h as u
-};

package/dist/types/components/Action/lib/execution/ActionExecution.d.ts

@@ -1,26 +0,0 @@
-import { ActionState } from './ActionState';
-
-interface ActionExecutionOptions {
-    showFeedback?: boolean;
-    resetAfterDone?: boolean;
-    resetDelayMs?: number;
-    onFeedbackDone?: (...args: unknown[]) => void;
-}
-export declare class ActionExecution {
-    private readonly options;
-    private readonly state;
-    private readonly args;
-    private isDone;
-    error: unknown;
-    constructor(state: ActionState, args: unknown[], options?: ActionExecutionOptions);
-    onAsyncStart(): void;
-    onSucceeded(): Promise<void>;
-    onFailed(error: unknown): Promise<void>;
-    setResetDelay(ms: number): void;
-    private startFailedFeedback;
-    private startSucceededFeedback;
-    private resetAfterDone;
-    private onDone;
-    private startPending;
-}
-export {};

package/dist/types/components/Action/lib/execution/ActionState.d.ts

@@ -1,8 +0,0 @@
-export type ActionStateValue = "isIdle" | "isSucceeded" | "isPending" | "isExecuting" | "isFailed";
-export declare class ActionState {
-    state: ActionStateValue;
-    constructor();
-    static useNew(): ActionState;
-    updateState(newState: ActionStateValue): void;
-    useState(): ActionStateValue;
-}

package/dist/types/components/Action/lib/execution/context.d.ts

@@ -1,4 +0,0 @@
-import { ActionFn } from '../../types';
-
-export declare const useParentAction: () => ActionFn | undefined;
-export declare const ActionContextProvider: import('react').Provider<ActionFn | undefined>;

package/dist/types/components/Action/lib/execution/useActionController.d.ts

@@ -1,9 +0,0 @@
-import { ActionFn } from '../../types';
-import { ActionState } from './ActionState';
-
-interface UseActionController {
-    execute: ActionFn;
-    state: ActionState;
-}
-export declare const useActionController: () => UseActionController;
-export {};

package/dist/types/components/Action/lib/execution/useActionController.test.d.ts

@@ -1 +0,0 @@
-export {};