@mittwald/flow-react-components 0.1.0-alpha.43 → 0.1.0-alpha.430

package/dist/js/context-BlNV7smK.js

@@ -0,0 +1,8 @@
+"use client"
+/* */
+import { createContext as t } from "react";
+const o = t({}), r = o.Provider;
+export {
+  r as L,
+  o as l
+};

package/dist/js/context-JScptH87.js

@@ -0,0 +1,62 @@
+"use client"
+/* */
+var a = Object.defineProperty;
+var r = (s, e, n) => e in s ? a(s, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : s[e] = n;
+var t = (s, e, n) => r(s, typeof e != "symbol" ? e + "" : e, n);
+import { makeObservable as i, observable as u, action as O } from "mobx";
+import { u as d, a as o } from "./useStatic-FXPyFF3K.js";
+import { createContext as h, useContext as c } from "react";
+class l {
+  constructor(e) {
+    t(this, "isOpen");
+    t(this, "onOpenHandlers", /* @__PURE__ */ new Set());
+    t(this, "onCloseHandlers", /* @__PURE__ */ new Set());
+    i(this, {
+      isOpen: u,
+      open: O.bound,
+      close: O.bound,
+      toggle: O.bound,
+      setOpen: O.bound
+    }), this.isOpen = (e == null ? void 0 : e.isDefaultOpen) ?? !1, e != null && e.onOpen && this.onOpenHandlers.add(e.onOpen), e != null && e.onClose && this.onCloseHandlers.add(e.onClose);
+  }
+  static useNew(e) {
+    return d(() => new l(e));
+  }
+  addOnOpen(e) {
+    return this.onOpenHandlers.add(e), () => {
+      this.onOpenHandlers.delete(e);
+    };
+  }
+  addOnClose(e) {
+    return this.onCloseHandlers.add(e), () => {
+      this.onCloseHandlers.delete(e);
+    };
+  }
+  executeOnClose() {
+    this.onCloseHandlers.forEach((e) => e());
+  }
+  executeOnOpen() {
+    this.onOpenHandlers.forEach((e) => e());
+  }
+  open() {
+    this.isOpen = !0, this.executeOnOpen();
+  }
+  close() {
+    this.isOpen = !1, this.executeOnClose();
+  }
+  toggle() {
+    this.isOpen = !this.isOpen, this.isOpen ? this.executeOnOpen() : this.executeOnClose();
+  }
+  setOpen(e) {
+    this.isOpen = e, e ? this.executeOnOpen() : this.executeOnClose();
+  }
+  useIsOpen() {
+    return o(() => this.isOpen);
+  }
+}
+const p = h({}), b = () => c(p);
+export {
+  l as O,
+  p as o,
+  b as u
+};

package/dist/js/controller.js

@@ -0,0 +1,8 @@
+"use client"
+/* */
+import { O as e } from "./context-JScptH87.js";
+import { u as a } from "./useOverlayController-ZXQCcFC-.js";
+export {
+  e as OverlayController,
+  a as useOverlayController
+};

package/dist/js/dynamic-ClpUSmEt.js

@@ -0,0 +1,8 @@
+"use client"
+/* */
+const c = (a) => ({
+  __dynamicProp: a
+});
+export {
+  c as d
+};

package/dist/js/flowComponent-B1r5sCmz.js

@@ -0,0 +1,144 @@
+"use client"
+/* */
+import s, { isValidElement as x, createContext as f, useContext as P, forwardRef as y, cloneElement as g } from "react";
+import { u as h } from "./propsContext-DzAKlmhS.js";
+import { mergeProps as T } from "@react-aria/utils";
+import { pickBy as v, omitBy as S } from "remeda";
+import "dot-prop";
+import { PropsContextProvider as b } from "./PropsContextProvider.js";
+import { TunnelEntry as B } from "@mittwald/react-tunnel";
+const E = {
+  Action: !0,
+  ActionGroup: !0,
+  Avatar: !0,
+  Alert: !0,
+  AlertBadge: !0,
+  AlertIcon: !0,
+  Align: !0,
+  Badge: !0,
+  Button: !0,
+  Checkbox: !0,
+  CheckboxButton: !0,
+  CheckboxGroup: !0,
+  ComboBox: !0,
+  Content: !0,
+  ContextMenu: !0,
+  ContextMenuSection: !0,
+  ContextMenuTrigger: !0,
+  ContextualHelp: !0,
+  ContextualHelpTrigger: !0,
+  CopyButton: !0,
+  CounterBadge: !0,
+  CountryOptions: !0,
+  DatePicker: !0,
+  DateRangePicker: !0,
+  FieldDescription: !0,
+  FieldError: !0,
+  FileCard: !0,
+  FileField: !0,
+  Header: !0,
+  Heading: !0,
+  Icon: !0,
+  Image: !0,
+  Initials: !0,
+  Label: !0,
+  LayoutCard: !0,
+  LightBox: !0,
+  Link: !0,
+  List: !0,
+  ListSummary: !0,
+  MenuItem: !0,
+  Modal: !0,
+  ModalTrigger: !0,
+  NumberField: !0,
+  Radio: !0,
+  Option: !0,
+  Popover: !0,
+  PopoverTrigger: !0,
+  RadioButton: !0,
+  RadioGroup: !0,
+  SearchField: !0,
+  Section: !0,
+  Segment: !0,
+  SegmentedControl: !0,
+  Select: !0,
+  Slider: !0,
+  Switch: !0,
+  Tabs: !0,
+  TabTitle: !0,
+  TestComponent: !0,
+  Text: !0,
+  TextArea: !0,
+  TextField: !0,
+  TimeField: !0
+}, l = Object.keys(
+  E
+);
+function a(t) {
+  return !!t && typeof t == "object" && "__dynamicProp" in t;
+}
+function d(t) {
+  return typeof t == "string" && l.includes(t);
+}
+function F(t) {
+  return !d(t);
+}
+const k = (t, o) => {
+  const r = {};
+  for (const e in t)
+    if (F(e)) {
+      const n = t[e];
+      a(n) && (r[e] = n.__dynamicProp(o));
+    }
+  return r;
+};
+function A(t) {
+  return !!t && typeof t == "object" && "children" in t && !!t.children;
+}
+const w = (t) => v(t, (o, r) => d(r)), I = (t, o) => {
+  if (!A(o))
+    return {};
+  const r = o.children;
+  if (!Array.isArray(r) && !x(r))
+    return {};
+  const e = w(t);
+  return Object.keys(e).length === 0 ? {} : {
+    children: /* @__PURE__ */ s.createElement(b, { props: e, mergeInParentContext: !0 }, r)
+  };
+}, M = (t, o) => {
+  const e = h()[t], n = e ? k(e, o) : void 0, i = e ? I(e, o) : void 0;
+  return T(
+    e && S(
+      e,
+      (c, p) => l.includes(
+        p
+      ) || a(c)
+    ),
+    o,
+    n,
+    i
+  );
+}, m = f({}), R = () => P(m), D = (t) => {
+  const { slot: o, component: r, children: e } = t, i = {
+    ...R(),
+    [r]: o
+  };
+  return /* @__PURE__ */ s.createElement(m.Provider, { value: i }, e);
+};
+function G(t, o) {
+  return y((r, e) => {
+    const { tunnelId: n, wrapWith: i, ...c } = M(
+      t,
+      r
+    ), C = {
+      refProp: e,
+      ...c
+    };
+    let u = /* @__PURE__ */ s.createElement(o, { ...C });
+    return "slot" in r && r.slot && (u = /* @__PURE__ */ s.createElement(D, { slot: r.slot, component: t }, u)), i && (u = g(i, void 0, u)), n && (u = /* @__PURE__ */ s.createElement(B, { id: n }, u)), u;
+  });
+}
+export {
+  G as f,
+  R as u
+};

package/dist/js/getActionGroupSlot-ByIakli9.js

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

package/dist/js/hooks.js

@@ -0,0 +1,17 @@
+"use client"
+/* */
+import "mobx";
+import { useState as o, useEffect as r } from "react";
+import { u as m } from "./useOverlayController-ZXQCcFC-.js";
+import { u as l } from "./useOnChange-C1Quwyuz.js";
+const n = () => {
+  const [e, t] = o(!1);
+  return r(() => {
+    t(!0);
+  }, []), e;
+};
+export {
+  n as useIsMounted,
+  l as useOnChange,
+  m as useOverlayController
+};

package/dist/js/nextjs.js

@@ -0,0 +1,23 @@
+"use client"
+/* */
+import r, { forwardRef as m } from "react";
+import c from "next/link";
+import { L as f } from "./context-BlNV7smK.js";
+const s = m(
+  function(t, n) {
+    const { href: i, isDisabled: o, ...a } = t;
+    return /* @__PURE__ */ r.createElement(
+      c,
+      {
+        href: i ?? "#",
+        "aria-disabled": o,
+        ...a,
+        ref: n
+      }
+    );
+  }
+), L = (e) => /* @__PURE__ */ r.createElement(f, { value: { linkComponent: s } }, e.children);
+export {
+  s as Link,
+  L as LinkProvider
+};

package/dist/js/propsContext-DzAKlmhS.js

@@ -0,0 +1,10 @@
+"use client"
+/* */
+import { createContext as o, useContext as e } from "react";
+const t = o({});
+t.Provider;
+const s = () => e(t);
+export {
+  t as p,
+  s as u
+};

package/dist/js/react-hook-form.js

@@ -0,0 +1,129 @@
+"use client"
+/* */
+import n, { createContext as v, useContext as x, useEffect as S, useRef as k } from "react";
+import { Controller as g, useFormState as h } from "react-hook-form";
+import "./propsContext-DzAKlmhS.js";
+import { PropsContextProvider as b } from "./PropsContextProvider.js";
+import "@react-aria/utils";
+import "remeda";
+import { d as F } from "./dynamic-ClpUSmEt.js";
+import { F as A } from "./FieldError-C-_2QNam.js";
+import { a as P, A as y } from "./Action-DdTtAlW3.js";
+const C = v({}), V = C.Provider, f = () => x(C);
+function D(t) {
+  var i;
+  const { children: r, control: o, ...s } = t, l = (i = f().form) == null ? void 0 : i.control;
+  return /* @__PURE__ */ n.createElement(
+    g,
+    {
+      ...s,
+      control: o ?? l,
+      render: (a) => {
+        var p;
+        const {
+          field: c,
+          fieldState: { error: u, invalid: m }
+        } = a, e = {
+          ...c,
+          isRequired: !!((p = s.rules) != null && p.required),
+          isInvalid: m,
+          validationBehavior: "aria",
+          children: F((E) => /* @__PURE__ */ n.createElement(n.Fragment, null, E.children, /* @__PURE__ */ n.createElement(A, null, u == null ? void 0 : u.message))),
+          ref: void 0,
+          refProp: c.ref
+        }, d = {
+          Checkbox: e,
+          CheckboxGroup: e,
+          CheckboxButton: e,
+          FileField: e,
+          NumberField: e,
+          RadioGroup: e,
+          Switch: {
+            ...e,
+            isSelected: e.value
+          },
+          TextArea: e,
+          TextField: e,
+          Select: {
+            ...e,
+            selectedKey: e.value
+          },
+          Slider: e,
+          DatePicker: e,
+          DateRangePicker: e,
+          TimeField: e,
+          SegmentedControl: e
+        };
+        return /* @__PURE__ */ n.createElement(
+          b,
+          {
+            props: d,
+            dependencies: [a]
+          },
+          r
+        );
+      }
+    }
+  );
+}
+const _ = (t) => D, I = (t) => {
+  const { isStarted: r, hasFailedWithError: o, hasSucceeded: s, children: l } = t, i = P.useNew({});
+  return S(() => {
+    s ? i.state.onSucceeded() : o ? i.state.onFailed(o) : r && i.state.onAsyncStart();
+  }, [r, o, s]), /* @__PURE__ */ n.createElement(y, { actionModel: i }, l);
+}, R = (t) => {
+  const { children: r, isAsyncSubmit: o } = t, s = f().form, { isSubmitted: l, isSubmitting: i, isSubmitSuccessful: a, errors: c } = h(s), u = l && c && Object.entries(c).length > 0 ? c : void 0, m = l && a;
+  return /* @__PURE__ */ n.createElement(
+    I,
+    {
+      isStarted: i && o.current,
+      hasFailedWithError: u,
+      hasSucceeded: m
+    },
+    r
+  );
+}, T = (t) => {
+  const { children: r, isAsyncSubmit: o } = t, s = {
+    ActionGroup: {
+      children: F((l) => /* @__PURE__ */ n.createElement(R, { isAsyncSubmit: o }, l.children))
+    }
+  };
+  return /* @__PURE__ */ n.createElement(b, { props: s, mergeInParentContext: !0 }, r);
+}, B = () => {
+  const t = f().form, { isValid: r, isSubmitted: o } = h(t);
+  return S(() => {
+    o && r && t && t.reset(void 0, {
+      keepIsSubmitted: !1,
+      keepIsSubmitSuccessful: !1,
+      keepDefaultValues: !0,
+      keepValues: !0,
+      keepDirtyValues: !0,
+      keepIsValid: !0,
+      keepDirty: !0,
+      keepErrors: !0,
+      keepTouched: !0,
+      keepIsValidating: !0,
+      keepSubmitCount: !0
+    });
+  }, [o, r, t]), null;
+};
+function z(t) {
+  const { form: r, children: o, onSubmit: s, ...l } = t, i = k(!1), a = (c) => {
+    const { isSubmitting: u, isValidating: m } = r.control._formState;
+    if (c.stopPropagation(), u || m) {
+      c.preventDefault();
+      return;
+    }
+    r.handleSubmit((e) => {
+      const d = s(e, c);
+      return i.current = d instanceof Promise, d;
+    })(c);
+  };
+  return /* @__PURE__ */ n.createElement(V, { value: { form: r } }, /* @__PURE__ */ n.createElement(T, { isAsyncSubmit: i }, /* @__PURE__ */ n.createElement("form", { ...l, onSubmit: a }, o), /* @__PURE__ */ n.createElement(B, null)));
+}
+export {
+  D as Field,
+  z as Form,
+  _ as typedField,
+  f as useFormContext
+};

package/dist/js/types/components/Accordion/Accordion.d.ts

@@ -0,0 +1,9 @@
+import { ComponentProps, FC, PropsWithChildren } from 'react';
+export interface AccordionProps extends PropsWithChildren<ComponentProps<"div">> {
+    /** Whether the accordion should be initially expanded. */
+    defaultExpanded?: boolean;
+    /** The visual variant of the accordion. @default "default" */
+    variant?: "default" | "outline";
+}
+export declare const Accordion: FC<AccordionProps>;
+export default Accordion;

package/dist/js/types/components/Accordion/index.d.ts

@@ -0,0 +1,3 @@
+import { Accordion } from './Accordion';
+export { Accordion, type AccordionProps } from './Accordion';
+export default Accordion;

package/dist/js/types/components/Accordion/stories/Default.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Accordion } from '..';
+declare const meta: Meta<typeof Accordion>;
+export default meta;
+type Story = StoryObj<typeof Accordion>;
+export declare const Default: Story;
+export declare const DefaultExpanded: Story;
+export declare const OutlineVariant: Story;
+export declare const WithLabel: Story;

package/dist/js/types/components/Accordion/stories/EdgeCases.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Accordion } from '..';
+declare const meta: Meta<typeof Accordion>;
+export default meta;
+type Story = StoryObj<typeof Accordion>;
+export declare const LongHeading: Story;

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

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Action: React.ForwardRefExoticComponent<import('./types').ActionProps & React.RefAttributes<never>>;

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

@@ -0,0 +1,8 @@
+import { FC, PropsWithChildren } from 'react';
+interface Props extends PropsWithChildren {
+    isStarted?: boolean;
+    hasSucceeded?: boolean;
+    hasFailedWithError?: unknown;
+}
+export declare const ActionStateContext: FC<Props>;
+export {};

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

@@ -0,0 +1,3 @@
+import { ActionModel } from './models/ActionModel';
+export declare const actionContext: import('react').Context<ActionModel | undefined>;
+export declare const ActionContextProvider: import('react').Provider<ActionModel | undefined>;

package/dist/js/types/components/Action/hooks/useActionButtonState.d.ts

@@ -0,0 +1,3 @@
+import { ButtonProps } from '../../Button';
+import { ActionStateValue } from '../models/ActionState';
+export declare const useActionButtonState: (props: ButtonProps) => ActionStateValue;

package/dist/js/types/components/Action/hooks/useConfirmationModalButtonSlot.d.ts

@@ -0,0 +1,2 @@
+import { ButtonProps } from '../../Button';
+export declare const useConfirmationModalButtonSlot: (props: ButtonProps) => string | undefined;

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

@@ -0,0 +1,4 @@
+import { Action } from './Action';
+export { Action } from './Action';
+export * from './types';
+export default Action;

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

@@ -0,0 +1,8 @@
+import { ActionStateValue } from '../models/ActionState';
+interface Options {
+    isPendingText?: string;
+    isSucceededText?: string;
+    isFailedText?: string;
+}
+export declare const useAriaAnnounceActionState: (actionState: ActionStateValue, options?: Options) => void;
+export {};

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

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

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

@@ -0,0 +1,8 @@
+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/js/types/components/Action/models/ActionModel.d.ts

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

package/dist/js/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/js/types/components/Action/models/ActionStateContext.d.ts

@@ -0,0 +1,14 @@
+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/js/types/components/Action/models/getExecutionFunction.d.ts

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

package/dist/js/types/components/Action/stories/Default.stories.d.ts

@@ -0,0 +1,13 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Action } from '..';
+declare const meta: Meta<typeof Action>;
+export default meta;
+type Story = StoryObj<typeof Action>;
+export declare const Default: Story;
+export declare const Async: Story;
+export declare const AsyncLong: Story;
+export declare const AsyncWithFeedback: Story;
+export declare const AsyncLongWithFeedback: Story;
+export declare const Nested: Story;
+export declare const NestedAsync: Story;
+export declare const WithConfirmationModal: Story;

package/dist/js/types/components/Action/stories/EdgeCases.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Action } from '..';
+declare const meta: Meta<typeof Action>;
+export default meta;
+type Story = StoryObj<typeof Action>;
+export declare const MixedAsyncSyncNested: Story;