@mittwald/flow-react-components 1.6.0-next.37 → 1.6.0-next.39

package/dist/js/packages/components-base/src/overlay/OverlayState.mjs

@@ -0,0 +1,178 @@
+"use client"
+/* */
+import { action, computed, makeObservable, observable, runInAction } from "mobx";
+//#region ../components-base/src/overlay/OverlayState.ts
+/**
+* Whether an overlay is open, and whether closing it has to be confirmed first.
+* Each binding adds its subscription and its lifecycle: React's
+* `OverlayController` subclasses it, Vue's adapter wraps it in refs.
+*
+* `TCloseOptions` lets a binding pass more on a close than the state reads —
+* React's `overlay`, resolved by `Action` before the close arrives here.
+*/
+var OverlayState = class {
+	isOpen = false;
+	isContentSuspended = false;
+	onOpenHandlers = /* @__PURE__ */ new Set();
+	onCloseHandlers = /* @__PURE__ */ new Set();
+	onOpenChangeHandlers = /* @__PURE__ */ new Set();
+	showConfirmationModal = false;
+	closeIsConfirmed = false;
+	confirmOnCloseFromOptions;
+	/**
+	* Every mounted component that has an opinion on close confirmation
+	* contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
+	* and a `Form` tracking its dirty state. Combining them instead of assigning
+	* a single flag keeps them from overwriting each other.
+	*/
+	confirmOnCloseSources = observable.map();
+	/**
+	* Active grants that allow closing without a confirmation. Each entry is
+	* scoped to an ongoing operation that legitimately closes the overlay – e.g.
+	* a `Form` submit – and is dropped again when that operation has finished, so
+	* an operation that does _not_ close the overlay leaves the confirmation
+	* armed.
+	*/
+	closeWithoutConfirmationGrants = /* @__PURE__ */ new Set();
+	/**
+	* The open state a `setOpen` call is currently applying. Handlers run before
+	* `isOpen` is assigned, so a handler that calls `setOpen` again would not be
+	* caught by the equality check at the top and would recurse.
+	*/
+	openStateInFlight;
+	constructor(options = {}) {
+		makeObservable(this, {
+			isOpen: observable,
+			isContentSuspended: observable,
+			showConfirmationModal: observable,
+			confirmOnCloseEnabled: computed,
+			open: action.bound,
+			close: action.bound,
+			toggle: action.bound,
+			setOpen: action.bound,
+			syncOpen: action.bound,
+			setIsContentSuspended: action.bound,
+			confirmClose: action.bound,
+			cancelConfirmation: action.bound
+		});
+		const { isDefaultOpen = false, confirmOnClose = false } = options;
+		this.isOpen = isDefaultOpen;
+		this.confirmOnCloseFromOptions = confirmOnClose;
+	}
+	/** Whether closing this overlay currently requires a confirmation. */
+	get confirmOnCloseEnabled() {
+		if (this.confirmOnCloseSources.size === 0) return this.confirmOnCloseFromOptions;
+		return Array.from(this.confirmOnCloseSources.values()).some(Boolean);
+	}
+	/**
+	* Sets the opinion of one source – any object the caller keeps – on close
+	* confirmation. Remove the source again when its owner goes away.
+	*
+	* @internal Bindings call it from their lifecycle.
+	*/
+	setConfirmOnCloseSource(source, confirmOnClose) {
+		runInAction(() => this.confirmOnCloseSources.set(source, confirmOnClose));
+	}
+	/** @internal Bindings call it from their lifecycle. */
+	removeConfirmOnCloseSource(source) {
+		runInAction(() => this.confirmOnCloseSources.delete(source));
+	}
+	addOpenStateHandler(handler, handlersSet) {
+		handlersSet.add(handler);
+		return () => {
+			handlersSet.delete(handler);
+		};
+	}
+	executeHandlers(isOpen, handlers) {
+		return Array.from(handlers).map((handler) => handler(isOpen)).some((result) => result === false);
+	}
+	executeOnClose() {
+		return this.executeHandlers(false, this.onCloseHandlers);
+	}
+	executeOnOpen() {
+		return this.executeHandlers(true, this.onOpenHandlers);
+	}
+	executeOnOpenChange(isOpen) {
+		return this.executeHandlers(isOpen, this.onOpenChangeHandlers);
+	}
+	addOnClose(handler) {
+		return this.addOpenStateHandler(handler, this.onCloseHandlers);
+	}
+	addOnOpen(handler) {
+		return this.addOpenStateHandler(handler, this.onOpenHandlers);
+	}
+	addOnOpenChange(handler) {
+		return this.addOpenStateHandler(handler, this.onOpenChangeHandlers);
+	}
+	open() {
+		this.setOpen(true);
+	}
+	close(options) {
+		this.setOpen(false, options);
+	}
+	toggle() {
+		this.setOpen(!this.isOpen);
+	}
+	setOpen(toOpen, options) {
+		if (this.isOpen === toOpen || this.openStateInFlight === toOpen) return;
+		this.openStateInFlight = toOpen;
+		try {
+			this.applyOpenState(toOpen, options);
+		} finally {
+			this.openStateInFlight = void 0;
+		}
+	}
+	/**
+	* Sets the open state without running any handler. Use it to mirror a
+	* controlled `isOpen` prop, whose change comes from the consumer – notifying
+	* them of their own state would echo it back.
+	*/
+	syncOpen(toOpen) {
+		this.isOpen = toOpen;
+	}
+	applyOpenState(toOpen, options) {
+		const { bypassConfirmation = false } = options ?? {};
+		if (toOpen === false) {
+			const closeIsConfirmed = this.closeIsConfirmed;
+			this.closeIsConfirmed = false;
+			if (this.confirmOnCloseEnabled && !closeIsConfirmed && this.closeWithoutConfirmationGrants.size === 0 && !bypassConfirmation) {
+				this.showConfirmationModal = true;
+				return;
+			}
+		}
+		let aborted;
+		if (toOpen) aborted = this.executeOnOpen();
+		else aborted = this.executeOnClose();
+		if (!aborted) aborted = this.executeOnOpenChange(toOpen);
+		if (!aborted) this.isOpen = toOpen;
+	}
+	setIsContentSuspended(to) {
+		this.isContentSuspended = to;
+	}
+	/**
+	* Allows closing this overlay without a confirmation until the returned
+	* disposer is called. Use it around an operation that may legitimately close
+	* the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
+	* prompt would be nonsense – and dispose it as soon as that operation has
+	* finished. An operation that ends without closing the overlay therefore
+	* leaves the confirmation armed (#2775).
+	*/
+	grantCloseWithoutConfirmation() {
+		const grant = {};
+		this.closeWithoutConfirmationGrants.add(grant);
+		return () => {
+			this.closeWithoutConfirmationGrants.delete(grant);
+		};
+	}
+	confirmClose() {
+		this.closeIsConfirmed = true;
+		this.showConfirmationModal = false;
+	}
+	cancelConfirmation() {
+		this.showConfirmationModal = false;
+	}
+};
+//#endregion
+export { OverlayState };
+
+//# sourceMappingURL=OverlayState.mjs.map

package/dist/js/packages/components-base/src/overlay/OverlayState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OverlayState.mjs","names":[],"sources":["../../../../../../../components-base/src/overlay/OverlayState.ts"],"sourcesContent":["import {\n  action,\n  computed,\n  makeObservable,\n  observable,\n  runInAction,\n} from \"mobx\";\n\nexport type OverlayOpenHandler = () => unknown;\nexport type OverlayCloseHandler = () => unknown;\nexport type OverlayOpenStateHandler = (isOpen: boolean) => unknown;\nexport type AnyOverlayOpenStateHandler =\n  OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler;\n\nexport type DisposerFn = () => void;\n\nexport interface OverlayCloseOptions {\n  /** Close without asking, even when the overlay requires confirmation. */\n  bypassConfirmation?: boolean;\n}\n\nexport interface OverlayStateOptions {\n  isDefaultOpen?: boolean;\n  /**\n   * Whether closing the overlay must be confirmed while no source has an\n   * opinion (`setConfirmOnCloseSource`).\n   */\n  confirmOnClose?: boolean;\n}\n\n/**\n * Whether an overlay is open, and whether closing it has to be confirmed first.\n * Each binding adds its subscription and its lifecycle: React's\n * `OverlayController` subclasses it, Vue's adapter wraps it in refs.\n *\n * `TCloseOptions` lets a binding pass more on a close than the state reads —\n * React's `overlay`, resolved by `Action` before the close arrives here.\n */\nexport class OverlayState<\n  TCloseOptions extends OverlayCloseOptions = OverlayCloseOptions,\n> {\n  public isOpen = false;\n  public isContentSuspended = false;\n  private onOpenHandlers = new Set<OverlayOpenHandler>();\n  private onCloseHandlers = new Set<OverlayCloseHandler>();\n  private onOpenChangeHandlers = new Set<OverlayOpenStateHandler>();\n\n  public showConfirmationModal = false;\n  public closeIsConfirmed = false;\n  private readonly confirmOnCloseFromOptions: boolean;\n  /**\n   * Every mounted component that has an opinion on close confirmation\n   * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop\n   * and a `Form` tracking its dirty state. Combining them instead of assigning\n   * a single flag keeps them from overwriting each other.\n   */\n  private confirmOnCloseSources = observable.map<object, boolean>();\n  /**\n   * Active grants that allow closing without a confirmation. Each entry is\n   * scoped to an ongoing operation that legitimately closes the overlay – e.g.\n   * a `Form` submit – and is dropped again when that operation has finished, so\n   * an operation that does _not_ close the overlay leaves the confirmation\n   * armed.\n   */\n  private closeWithoutConfirmationGrants = new Set<object>();\n  /**\n   * The open state a `setOpen` call is currently applying. Handlers run before\n   * `isOpen` is assigned, so a handler that calls `setOpen` again would not be\n   * caught by the equality check at the top and would recurse.\n   */\n  private openStateInFlight: boolean | undefined;\n\n  public constructor(options: OverlayStateOptions = {}) {\n    makeObservable(this, {\n      isOpen: observable,\n      isContentSuspended: observable,\n      showConfirmationModal: observable,\n      confirmOnCloseEnabled: computed,\n      open: action.bound,\n      close: action.bound,\n      toggle: action.bound,\n      setOpen: action.bound,\n      syncOpen: action.bound,\n      setIsContentSuspended: action.bound,\n      confirmClose: action.bound,\n      cancelConfirmation: action.bound,\n    });\n    const { isDefaultOpen = false, confirmOnClose = false } = options;\n    this.isOpen = isDefaultOpen;\n    this.confirmOnCloseFromOptions = confirmOnClose;\n  }\n\n  /** Whether closing this overlay currently requires a confirmation. */\n  public get confirmOnCloseEnabled(): boolean {\n    if (this.confirmOnCloseSources.size === 0) {\n      return this.confirmOnCloseFromOptions;\n    }\n    return Array.from(this.confirmOnCloseSources.values()).some(Boolean);\n  }\n\n  /**\n   * Sets the opinion of one source – any object the caller keeps – on close\n   * confirmation. Remove the source again when its owner goes away.\n   *\n   * @internal Bindings call it from their lifecycle.\n   */\n  public setConfirmOnCloseSource(source: object, confirmOnClose: boolean) {\n    runInAction(() => this.confirmOnCloseSources.set(source, confirmOnClose));\n  }\n\n  /** @internal Bindings call it from their lifecycle. */\n  public removeConfirmOnCloseSource(source: object) {\n    runInAction(() => this.confirmOnCloseSources.delete(source));\n  }\n\n  private addOpenStateHandler<T extends AnyOverlayOpenStateHandler>(\n    handler: T,\n    handlersSet: Set<T>,\n  ): DisposerFn {\n    handlersSet.add(handler);\n    return () => {\n      handlersSet.delete(handler);\n    };\n  }\n\n  private executeHandlers(\n    isOpen: boolean,\n    handlers: Set<\n      OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler\n    >,\n  ): boolean {\n    const handlerResult = Array.from(handlers).map((handler) =>\n      handler(isOpen),\n    );\n    return handlerResult.some((result) => result === false);\n  }\n\n  private executeOnClose(): boolean {\n    return this.executeHandlers(false, this.onCloseHandlers);\n  }\n\n  private executeOnOpen(): boolean {\n    return this.executeHandlers(true, this.onOpenHandlers);\n  }\n\n  private executeOnOpenChange(isOpen: boolean): boolean {\n    return this.executeHandlers(isOpen, this.onOpenChangeHandlers);\n  }\n\n  public addOnClose(handler: OverlayCloseHandler) {\n    return this.addOpenStateHandler(handler, this.onCloseHandlers);\n  }\n\n  public addOnOpen(handler: OverlayOpenHandler) {\n    return this.addOpenStateHandler(handler, this.onOpenHandlers);\n  }\n\n  public addOnOpenChange(handler: OverlayOpenStateHandler) {\n    return this.addOpenStateHandler(handler, this.onOpenChangeHandlers);\n  }\n\n  public open(): void {\n    this.setOpen(true);\n  }\n\n  public close(options?: TCloseOptions): void {\n    this.setOpen(false, options);\n  }\n\n  public toggle(): void {\n    this.setOpen(!this.isOpen);\n  }\n\n  public setOpen(toOpen: boolean, options?: TCloseOptions): void {\n    if (this.isOpen === toOpen || this.openStateInFlight === toOpen) {\n      return;\n    }\n\n    this.openStateInFlight = toOpen;\n    try {\n      this.applyOpenState(toOpen, options);\n    } finally {\n      this.openStateInFlight = undefined;\n    }\n  }\n\n  /**\n   * Sets the open state without running any handler. Use it to mirror a\n   * controlled `isOpen` prop, whose change comes from the consumer – notifying\n   * them of their own state would echo it back.\n   */\n  public syncOpen(toOpen: boolean): void {\n    this.isOpen = toOpen;\n  }\n\n  private applyOpenState(toOpen: boolean, options?: TCloseOptions): void {\n    const { bypassConfirmation = false } = options ?? {};\n\n    if (toOpen === false) {\n      // The confirmation is a one-shot permission for exactly this close\n      // attempt – consume it here instead of only when a close succeeds, so it\n      // cannot survive an aborted close and disarm later attempts.\n      const closeIsConfirmed = this.closeIsConfirmed;\n      this.closeIsConfirmed = false;\n\n      if (\n        this.confirmOnCloseEnabled &&\n        !closeIsConfirmed &&\n        this.closeWithoutConfirmationGrants.size === 0 &&\n        !bypassConfirmation\n      ) {\n        this.showConfirmationModal = true;\n        return;\n      }\n    }\n\n    let aborted: boolean;\n    if (toOpen) {\n      aborted = this.executeOnOpen();\n    } else {\n      aborted = this.executeOnClose();\n    }\n    if (!aborted) {\n      aborted = this.executeOnOpenChange(toOpen);\n    }\n\n    if (!aborted) {\n      this.isOpen = toOpen;\n    }\n  }\n\n  public setIsContentSuspended(to: boolean): void {\n    this.isContentSuspended = to;\n  }\n\n  /**\n   * Allows closing this overlay without a confirmation until the returned\n   * disposer is called. Use it around an operation that may legitimately close\n   * the overlay – e.g. a `Form` submit, where a \"discard unsaved changes?\"\n   * prompt would be nonsense – and dispose it as soon as that operation has\n   * finished. An operation that ends without closing the overlay therefore\n   * leaves the confirmation armed (#2775).\n   */\n  public grantCloseWithoutConfirmation(): DisposerFn {\n    const grant = {};\n    this.closeWithoutConfirmationGrants.add(grant);\n    return () => {\n      this.closeWithoutConfirmationGrants.delete(grant);\n    };\n  }\n\n  public confirmClose(): void {\n    this.closeIsConfirmed = true;\n    this.showConfirmationModal = false;\n  }\n\n  public cancelConfirmation(): void {\n    this.showConfirmationModal = false;\n  }\n}\n"],"mappings":"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"}

package/dist/types/_bundled/flow-components-base/index.d.ts

@@ -23,3 +23,4 @@ export type { ListSortingShape, SortingDefaultMode, SortingFn, } from "./list/so
 export { ListViewMode } from "./list/viewMode/ListViewMode";
 export type { ListViewModeOptions, ListViewModeValue, } from "./list/viewMode/types";
 export { customPropertyPrefix, type CustomPropertyName, type PropertyName, type PropertyValue, type PropertyValueRenderMethod, } from "./list/types";
+export { OverlayState, type AnyOverlayOpenStateHandler, type DisposerFn, type OverlayCloseHandler, type OverlayCloseOptions, type OverlayOpenHandler, type OverlayOpenStateHandler, type OverlayStateOptions, } from "./overlay/OverlayState";

package/dist/types/_bundled/flow-components-base/overlay/OverlayState.d.ts

@@ -0,0 +1,90 @@
+export type OverlayOpenHandler = () => unknown;
+export type OverlayCloseHandler = () => unknown;
+export type OverlayOpenStateHandler = (isOpen: boolean) => unknown;
+export type AnyOverlayOpenStateHandler = OverlayOpenHandler | OverlayCloseHandler | OverlayOpenStateHandler;
+export type DisposerFn = () => void;
+export interface OverlayCloseOptions {
+    /** Close without asking, even when the overlay requires confirmation. */
+    bypassConfirmation?: boolean;
+}
+export interface OverlayStateOptions {
+    isDefaultOpen?: boolean;
+    /**
+     * Whether closing the overlay must be confirmed while no source has an
+     * opinion (`setConfirmOnCloseSource`).
+     */
+    confirmOnClose?: boolean;
+}
+/**
+ * Whether an overlay is open, and whether closing it has to be confirmed first.
+ * Each binding adds its subscription and its lifecycle: React's
+ * `OverlayController` subclasses it, Vue's adapter wraps it in refs.
+ *
+ * `TCloseOptions` lets a binding pass more on a close than the state reads —
+ * React's `overlay`, resolved by `Action` before the close arrives here.
+ */
+export declare class OverlayState<TCloseOptions extends OverlayCloseOptions = OverlayCloseOptions> {
+    isOpen: boolean;
+    isContentSuspended: boolean;
+    private onOpenHandlers;
+    private onCloseHandlers;
+    private onOpenChangeHandlers;
+    showConfirmationModal: boolean;
+    closeIsConfirmed: boolean;
+    private readonly confirmOnCloseFromOptions;
+    /**
+     * Every mounted component that has an opinion on close confirmation
+     * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
+     * and a `Form` tracking its dirty state. Combining them instead of assigning
+     * a single flag keeps them from overwriting each other.
+     */
+    private confirmOnCloseSources;
+    /**
+     * Active grants that allow closing without a confirmation. Each entry is
+     * scoped to an ongoing operation that legitimately closes the overlay – e.g.
+     * a `Form` submit – and is dropped again when that operation has finished, so
+     * an operation that does _not_ close the overlay leaves the confirmation
+     * armed.
+     */
+    private closeWithoutConfirmationGrants;
+    /**
+     * The open state a `setOpen` call is currently applying. Handlers run before
+     * `isOpen` is assigned, so a handler that calls `setOpen` again would not be
+     * caught by the equality check at the top and would recurse.
+     */
+    private openStateInFlight;
+    constructor(options?: OverlayStateOptions);
+    /** Whether closing this overlay currently requires a confirmation. */
+    get confirmOnCloseEnabled(): boolean;
+    private addOpenStateHandler;
+    private executeHandlers;
+    private executeOnClose;
+    private executeOnOpen;
+    private executeOnOpenChange;
+    addOnClose(handler: OverlayCloseHandler): DisposerFn;
+    addOnOpen(handler: OverlayOpenHandler): DisposerFn;
+    addOnOpenChange(handler: OverlayOpenStateHandler): DisposerFn;
+    open(): void;
+    close(options?: TCloseOptions): void;
+    toggle(): void;
+    setOpen(toOpen: boolean, options?: TCloseOptions): void;
+    /**
+     * Sets the open state without running any handler. Use it to mirror a
+     * controlled `isOpen` prop, whose change comes from the consumer – notifying
+     * them of their own state would echo it back.
+     */
+    syncOpen(toOpen: boolean): void;
+    private applyOpenState;
+    setIsContentSuspended(to: boolean): void;
+    /**
+     * Allows closing this overlay without a confirmation until the returned
+     * disposer is called. Use it around an operation that may legitimately close
+     * the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
+     * prompt would be nonsense – and dispose it as soon as that operation has
+     * finished. An operation that ends without closing the overlay therefore
+     * leaves the confirmation armed (#2775).
+     */
+    grantCloseWithoutConfirmation(): DisposerFn;
+    confirmClose(): void;
+    cancelConfirmation(): void;
+}

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

@@ -2,7 +2,7 @@ import { ComponentProps, ComponentType, CSSProperties, PropsWithChildren } from
 import { FlowComponentProps } from '../../lib/componentFactory/flowComponent';
 import { AlphaColor, PropsWithClassName } from '../../lib/types/props';
 import * as Aria from "react-aria-components";
-export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
+export interface LinkProps extends PropsWithChildren<Omit<Aria.LinkProps, "children" | "slot" | "className" | "aria-current">>, FlowComponentProps<HTMLAnchorElement>, PropsWithClassName {
     /** Whether the link should be styled for being displayed inside a text. */
     inline?: boolean;
     /** An alternative link component. */

package/dist/types/components/Table/components/TableCell/TableCell.d.ts

@@ -1,7 +1,10 @@
 import { FC, PropsWithChildren } from 'react';
 import * as Aria from "react-aria-components";
 export interface TableCellProps extends Omit<Aria.CellProps, "children" | "style" | "render">, PropsWithChildren {
-    /** Use cell as row header */
+    /**
+     * Styles the cell as a row header. Its semantics come from the column: the
+     * first column, or the one with `isRowHeader`.
+     */
     rowHeader?: boolean;
     /** Horizontal alignment of the cell content @default "start" */
     horizontalAlign?: "start" | "center" | "end";

package/dist/types/components/Table/components/TableHeader/context.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Whether a column is the first of its `TableHeader`. Undefined outside a
+ * header that can tell, e.g. with dynamic `columns`.
+ */
+export declare const IsFirstColumnContext: import('react').Context<boolean | undefined>;
+export declare const useIsFirstColumn: () => boolean | undefined;

package/dist/types/lib/controller/overlay/OverlayController.d.ts

@@ -1,16 +1,13 @@
+import { OverlayState, OverlayCloseHandler, OverlayCloseOptions, OverlayOpenHandler, OverlayOpenStateHandler } from '../../../_bundled/flow-components-base/index';
 import { DependencyList } from 'react';
 import { FlowComponentName } from '../../../components/propTypes';
-export type OverlayOpenHandler = () => unknown;
-export type OverlayCloseHandler = () => unknown;
-export type OverlayOpenStateHandler = (isOpen: boolean) => unknown;
-type DisposerFn = () => void;
-export interface CloseOverlayOptions {
+export type { OverlayCloseHandler, OverlayOpenHandler, OverlayOpenStateHandler, } from '../../../_bundled/flow-components-base/index';
+export interface CloseOverlayOptions extends OverlayCloseOptions {
     /**
      * The overlay to close. Omitted, the nearest enclosing overlay is closed –
      * the same thing `closeOverlay={true}` means.
      */
     overlay?: FlowComponentName | OverlayController;
-    bypassConfirmation?: boolean;
 }
 export interface OnOverlayClosedOptions {
     dependencies?: DependencyList;
@@ -35,48 +32,17 @@ export interface OverlayControllerOptions {
      */
     confirmOnClose?: boolean;
 }
-type ConstructorOptions = Pick<OverlayControllerOptions, "isDefaultOpen" | "confirmOnClose">;
-export declare class OverlayController {
-    isOpen: boolean;
-    isContentSuspended: boolean;
-    private onOpenHandlers;
-    private onCloseHandlers;
-    private onOpenChangeHandlers;
-    showConfirmationModal: boolean;
-    closeIsConfirmed: boolean;
-    private readonly confirmOnCloseFromOptions;
-    /**
-     * Every mounted component that has an opinion on close confirmation
-     * contributes one entry here – e.g. a `Modal` with a `confirmOnClose` prop
-     * and a `Form` tracking its dirty state. Combining them instead of assigning
-     * a single flag keeps them from overwriting each other.
-     */
-    private confirmOnCloseSources;
-    /**
-     * Active grants that allow closing without a confirmation. Each entry is
-     * scoped to an ongoing operation that legitimately closes the overlay – e.g.
-     * a `Form` submit – and is dropped again when that operation has finished, so
-     * an operation that does _not_ close the overlay leaves the confirmation
-     * armed.
-     */
-    private closeWithoutConfirmationGrants;
-    /**
-     * The open state a `setOpen` call is currently applying. Handlers run before
-     * `isOpen` is assigned, so a handler that calls `setOpen` again would not be
-     * caught by the equality check at the top and would recurse.
-     */
-    private openStateInFlight;
-    constructor(options?: ConstructorOptions);
-    /** Whether closing this overlay currently requires a confirmation. */
-    get confirmOnCloseEnabled(): boolean;
+/**
+ * The state is `OverlayState` from `@mittwald/flow-components-base`, shared
+ * with every remote binding; this adds the hooks.
+ */
+export declare class OverlayController extends OverlayState<CloseOptions> {
     useUpdateOptions(options?: OverlayControllerOptions): void;
     /**
      * Registers the calling component as a close confirmation source for as long
      * as it is mounted. `undefined` contributes nothing at all.
      */
     private useConfirmOnCloseSource;
-    private setConfirmOnCloseSource;
-    private removeConfirmOnCloseSource;
     /**
      * Can be used to execute a callback when the Overlay has unmounted – means
      * after any closing animation.
@@ -85,27 +51,7 @@ export declare class OverlayController {
      */
     useOnClosed(callback: () => unknown, options?: OnOverlayClosedOptions): void;
     static useNew(options?: OverlayControllerOptions): OverlayController;
-    private addOpenStateHandler;
     private useOnHandler;
-    private executeHandlers;
-    private executeOnClose;
-    private executeOnOpen;
-    private executeOnOpenChange;
-    addOnClose(handler: OverlayCloseHandler): DisposerFn;
-    addOnOpen(handler: OverlayOpenHandler): DisposerFn;
-    addOnOpenChange(handler: OverlayOpenStateHandler): DisposerFn;
-    open(): void;
-    close(options?: CloseOptions): void;
-    toggle(): void;
-    setOpen(toOpen: boolean, options?: CloseOptions): void;
-    /**
-     * Sets the open state without running any handler. Use it to mirror a
-     * controlled `isOpen` prop, whose change comes from the consumer – notifying
-     * them of their own state would echo it back.
-     */
-    syncOpen(toOpen: boolean): void;
-    private applyOpenState;
-    setIsContentSuspended(to: boolean): void;
     useIsOpen(): boolean;
     useIsContentSuspended(): boolean;
     useShowConfirmationModal(): boolean;
@@ -115,16 +61,4 @@ export declare class OverlayController {
         readonly cancel: () => void;
         readonly confirm: () => void;
     } | undefined;
-    /**
-     * Allows closing this overlay without a confirmation until the returned
-     * disposer is called. Use it around an operation that may legitimately close
-     * the overlay – e.g. a `Form` submit, where a "discard unsaved changes?"
-     * prompt would be nonsense – and dispose it as soon as that operation has
-     * finished. An operation that ends without closing the overlay therefore
-     * leaves the confirmation armed (#2775).
-     */
-    grantCloseWithoutConfirmation(): DisposerFn;
-    confirmClose(): void;
-    cancelConfirmation(): void;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/flow-react-components",
-  "version": "1.6.0-next.37",
+  "version": "1.6.0-next.39",
   "type": "module",
   "description": "A React implementation of Flow, mittwald’s design system",
   "homepage": "https://flow.mittwald.de",
@@ -84,9 +84,9 @@
     "@internationalized/string-compiler": "^3.4.1",
     "@lezer/common": "^1.5.2",
     "@lezer/highlight": "^1.2.3",
-    "@mittwald/flow-icons": "^1.6.0-next.37",
+    "@mittwald/flow-icons": "^1.6.0-next.39",
     "@mittwald/password-tools-js": "^3.0.0",
-    "@mittwald/react-tunnel": "^1.6.0-next.37",
+    "@mittwald/react-tunnel": "^1.6.0-next.39",
     "@mittwald/react-use-promise": "^4.2.2",
     "@react-aria/form": "^3.2.1",
     "@react-aria/i18n": "^3.13.1",
@@ -139,13 +139,13 @@
     "@internationalized/date": "^3.12.3",
     "@lezer/generator": "^1.8.0",
     "@lezer/lr": "^1.4.10",
-    "@mittwald/flow-components-base": "1.6.0-next.37",
-    "@mittwald/flow-core": "1.6.0-next.37",
-    "@mittwald/flow-design-tokens": "1.6.0-next.37",
-    "@mittwald/flow-icons-base": "1.6.0-next.37",
+    "@mittwald/flow-components-base": "1.6.0-next.39",
+    "@mittwald/flow-core": "1.6.0-next.39",
+    "@mittwald/flow-design-tokens": "1.6.0-next.39",
+    "@mittwald/flow-icons-base": "1.6.0-next.39",
     "@mittwald/react-use-promise": "^4.2.2",
     "@mittwald/remote-dom-react": "1.2.2-mittwald.10",
-    "@mittwald/typescript-config": "1.6.0-next.37",
+    "@mittwald/typescript-config": "1.6.0-next.39",
     "@nx/storybook": "^22.7.6",
     "@storybook/addon-a11y": "^10.5.10",
     "@storybook/addon-actions": "^9.0.8",
@@ -199,7 +199,7 @@
   },
   "peerDependencies": {
     "@internationalized/date": "^3.12.2",
-    "@mittwald/flow-icons-pro": "1.6.0-next.37",
+    "@mittwald/flow-icons-pro": "1.6.0-next.39",
     "@mittwald/react-use-promise": "^4.2.2",
     "next": "^16.2.3",
     "react": "^19.2.0",
@@ -223,5 +223,5 @@
   "browserslist": [
     "baseline widely available"
   ],
-  "gitHead": "e4ab7766ecff29bf82f1ea257438bb1f92b2b4ec"
+  "gitHead": "ff0590a0a5c672cef5cf8e08817b5c17da235d7e"
 }