@foldkit/ui 0.112.0

package/dist/dialog/index.js

@@ -0,0 +1,211 @@
+import { Effect, Match as M, Option, Schema as S } from 'effect';
+import * as Command from 'foldkit/command';
+import * as Dom from 'foldkit/dom';
+import { childAttributes, html, } from 'foldkit/html';
+import { m } from 'foldkit/message';
+import { evo } from 'foldkit/struct';
+import { defineView } from 'foldkit/submodel';
+// NOTE: Animation imports are split across schema + update to avoid a circular
+// dependency: animation → html → runtime → devtools → dialog → animation.
+// The barrel (../animation) imports from html, which starts the cycle.
+import { Hid as AnimationHid, Message as AnimationMessage, Model as AnimationModel, Showed as AnimationShowed, init as animationInit, } from '../animation/schema.js';
+import { defaultLeaveCommand as animationDefaultLeaveCommand, update as animationUpdate, } from '../animation/update.js';
+// MODEL
+/** Schema for the dialog component's state, tracking its unique ID, open/closed status, animation support, and animation lifecycle phase. */
+export const Model = S.Struct({
+    id: S.String,
+    isOpen: S.Boolean,
+    isAnimated: S.Boolean,
+    animation: AnimationModel,
+    maybeFocusSelector: S.Option(S.String),
+});
+// MESSAGE
+/** Sent when the dialog should open. Triggers the ShowDialog command. */
+export const RequestedOpen = m('RequestedOpen');
+/** Sent when the dialog should close (Escape key, backdrop click, or programmatic). */
+export const RequestedClose = m('RequestedClose');
+/** Sent when the show-dialog command completes. */
+export const CompletedShowDialog = m('CompletedShowDialog');
+/** Sent when the close-dialog command completes. */
+export const CompletedCloseDialog = m('CompletedCloseDialog');
+/** Wraps an Animation submodel message for delegation. */
+export const GotAnimationMessage = m('GotAnimationMessage', {
+    message: AnimationMessage,
+});
+/** Union of all messages the dialog component can produce. */
+export const Message = S.Union([
+    RequestedOpen,
+    RequestedClose,
+    CompletedShowDialog,
+    CompletedCloseDialog,
+    GotAnimationMessage,
+]);
+// OUT MESSAGE
+/** Sent once the dialog has transitioned to open. Fires after `update`
+ *  has processed `RequestedOpen` and `isOpen` reflects the new state.
+ *  Programmatic `Dialog.open` on an already-open model is a no-op that
+ *  does not re-emit. */
+export const Opened = m('Opened');
+/** Sent once the dialog has transitioned to closed. Programmatic
+ *  `Dialog.close` on an already-closed model is a no-op that does not
+ *  re-emit; calling close while a leave animation is in progress is
+ *  also a no-op. */
+export const Closed = m('Closed');
+/** Union of out-messages the dialog component can produce. */
+export const OutMessage = S.Union([Opened, Closed]);
+/** Creates an initial dialog model from a config. Defaults to closed and non-animated. */
+export const init = (config) => ({
+    id: config.id,
+    isOpen: config.isOpen ?? false,
+    isAnimated: config.isAnimated ?? false,
+    animation: animationInit({
+        id: `${config.id}-panel`,
+        ...(config.isOpen !== undefined ? { isShowing: config.isOpen } : {}),
+    }),
+    maybeFocusSelector: Option.fromNullishOr(config.focusSelector),
+});
+// UPDATE
+const dialogSelector = (id) => `#${id}`;
+const withUpdateReturn = M.withReturnType();
+/** Locks page scroll and opens the native dialog element with `show()`. */
+export const ShowDialog = Command.define('ShowDialog', { id: S.String, maybeFocusSelector: S.Option(S.String) }, CompletedShowDialog)(({ id, maybeFocusSelector }) => Dom.lockScroll.pipe(Effect.andThen(() => Dom.showModal(dialogSelector(id), Option.match(maybeFocusSelector, {
+    onNone: () => undefined,
+    onSome: focusSelector => ({ focusSelector }),
+}))), Effect.ignore, Effect.as(CompletedShowDialog())));
+/** Calls `close()` on the native dialog element and unlocks page scroll. */
+export const CloseDialog = Command.define('CloseDialog', { id: S.String }, CompletedCloseDialog)(({ id }) => Dom.closeModal(dialogSelector(id)).pipe(Effect.andThen(() => Dom.unlockScroll), Effect.ignore, Effect.as(CompletedCloseDialog())));
+const wrapAnimationMessage = (message) => GotAnimationMessage({ message });
+const delegateToAnimation = (model, animationMessage) => {
+    const [nextAnimation, animationCommands, maybeOutMessage] = animationUpdate(model.animation, animationMessage);
+    const mappedCommands = Command.mapMessages(animationCommands, wrapAnimationMessage);
+    const additionalCommands = Option.match(maybeOutMessage, {
+        onNone: () => [],
+        onSome: M.type().pipe(M.tagsExhaustive({
+            StartedLeaveAnimating: () => [
+                Command.mapMessage(animationDefaultLeaveCommand(nextAnimation), wrapAnimationMessage),
+            ],
+            TransitionedOut: () => [CloseDialog({ id: model.id })],
+        })),
+    });
+    return [
+        evo(model, { animation: () => nextAnimation }),
+        [...mappedCommands, ...additionalCommands],
+        Option.none(),
+    ];
+};
+/** Processes a dialog message and returns the next model and commands. */
+export const update = (model, message) => M.value(message).pipe(withUpdateReturn, M.tagsExhaustive({
+    RequestedOpen: () => {
+        const wasClosed = !model.isOpen;
+        const maybeShow = Option.liftPredicate(ShowDialog({
+            id: model.id,
+            maybeFocusSelector: model.maybeFocusSelector,
+        }), () => wasClosed);
+        const maybeOutMessage = wasClosed
+            ? Option.some(Opened())
+            : Option.none();
+        if (model.isAnimated) {
+            const [nextModel, animationCommands] = delegateToAnimation(model, AnimationShowed());
+            return [
+                evo(nextModel, { isOpen: () => true }),
+                [...Option.toArray(maybeShow), ...animationCommands],
+                maybeOutMessage,
+            ];
+        }
+        return [
+            evo(model, { isOpen: () => true }),
+            Option.toArray(maybeShow),
+            maybeOutMessage,
+        ];
+    },
+    RequestedClose: () => {
+        const { transitionState } = model.animation;
+        const isLeaving = transitionState === 'LeaveStart' ||
+            transitionState === 'LeaveAnimating';
+        if (isLeaving) {
+            return [model, [], Option.none()];
+        }
+        const wasOpen = model.isOpen;
+        const maybeOutMessage = wasOpen ? Option.some(Closed()) : Option.none();
+        if (model.isAnimated) {
+            const [nextModel, animationCommands] = delegateToAnimation(evo(model, { isOpen: () => false }), AnimationHid());
+            return [nextModel, animationCommands, maybeOutMessage];
+        }
+        const maybeClose = Option.liftPredicate(CloseDialog({ id: model.id }), () => wasOpen);
+        return [
+            evo(model, { isOpen: () => false }),
+            Option.toArray(maybeClose),
+            maybeOutMessage,
+        ];
+    },
+    GotAnimationMessage: ({ message: animationMessage }) => delegateToAnimation(model, animationMessage),
+    CompletedShowDialog: () => [model, [], Option.none()],
+    CompletedCloseDialog: () => [model, [], Option.none()],
+}));
+/** Programmatically opens the dialog. */
+export const open = (model) => update(model, RequestedOpen());
+/** Programmatically closes the dialog. */
+export const close = (model) => update(model, RequestedClose());
+// VIEW
+/** Returns the ID used for `aria-labelledby` on the dialog. Apply this to your title element. */
+export const titleId = (model) => `${model.id}-title`;
+/** Returns the ID used for `aria-describedby` on the dialog. Apply this to your description element. */
+export const descriptionId = (model) => `${model.id}-description`;
+/** Renders a headless dialog component backed by the native `<dialog>`
+ *  element opened with `show()`. */
+export const view = defineView((model, viewInputs) => {
+    const h = html();
+    const { id, isOpen, animation: { transitionState }, } = model;
+    const { toView } = viewInputs;
+    const isLeaving = transitionState === 'LeaveStart' || transitionState === 'LeaveAnimating';
+    const isVisible = isOpen || isLeaving;
+    const animationAttributes = M.value(transitionState).pipe(M.when('EnterStart', () => [
+        h.DataAttribute('closed', ''),
+        h.DataAttribute('enter', ''),
+        h.DataAttribute('transition', ''),
+    ]), M.when('EnterAnimating', () => [
+        h.DataAttribute('enter', ''),
+        h.DataAttribute('transition', ''),
+    ]), M.when('LeaveStart', () => [
+        h.DataAttribute('leave', ''),
+        h.DataAttribute('transition', ''),
+    ]), M.when('LeaveAnimating', () => [
+        h.DataAttribute('closed', ''),
+        h.DataAttribute('leave', ''),
+        h.DataAttribute('transition', ''),
+    ]), M.orElse(() => []));
+    const dialogAttributes = [
+        h.Id(id),
+        h.AriaLabelledBy(`${id}-title`),
+        h.AriaDescribedBy(`${id}-description`),
+        h.OnCancel(RequestedClose()),
+        h.Open(isVisible),
+        h.Style({
+            width: '100%',
+            height: '100%',
+            maxWidth: '100%',
+            maxHeight: '100%',
+            padding: '0',
+            border: 'none',
+            background: 'transparent',
+            ...(isVisible
+                ? { position: 'fixed', inset: '0', zIndex: '2147483600' }
+                : {}),
+        }),
+        ...(isVisible ? [h.DataAttribute('open', '')] : []),
+    ];
+    const backdropAttributes = [
+        h.Style({ minHeight: '100vh' }),
+        ...animationAttributes,
+        ...(isLeaving ? [] : [h.OnClick(RequestedClose())]),
+    ];
+    const panelAttributes = [h.Id(`${id}-panel`), ...animationAttributes];
+    const closeButtonAttributes = isLeaving ? [] : [h.OnClick(RequestedClose())];
+    return toView({
+        dialog: childAttributes(dialogAttributes),
+        backdrop: childAttributes(backdropAttributes),
+        panel: childAttributes(panelAttributes),
+        closeButton: childAttributes(closeButtonAttributes),
+        isVisible,
+    });
+});

package/dist/dialog/public.d.ts

@@ -0,0 +1,3 @@
+export { init, update, open, close, view, titleId, descriptionId, Model, Message, OutMessage, Opened, Closed, RequestedOpen, RequestedClose, CompletedShowDialog, CompletedCloseDialog, GotAnimationMessage, ShowDialog, CloseDialog, } from './index.js';
+export type { InitConfig, ViewInputs, RenderInfo } from './index.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/dialog/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/dialog/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,OAAO,EACP,aAAa,EACb,KAAK,EACL,OAAO,EACP,UAAU,EACV,MAAM,EACN,MAAM,EACN,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,UAAU,EACV,WAAW,GACZ,MAAM,YAAY,CAAA;AAEnB,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA"}

package/dist/dialog/public.js

@@ -0,0 +1 @@
+export { init, update, open, close, view, titleId, descriptionId, Model, Message, OutMessage, Opened, Closed, RequestedOpen, RequestedClose, CompletedShowDialog, CompletedCloseDialog, GotAnimationMessage, ShowDialog, CloseDialog, } from './index.js';

package/dist/disclosure/index.d.ts

@@ -0,0 +1,110 @@
+import { Effect, Option, Schema as S } from 'effect';
+import * as Command from 'foldkit/command';
+import { type ChildAttribute, type Html } from 'foldkit/html';
+import { type Reflect } from 'foldkit/submodel';
+/** Schema for the disclosure component's state, tracking its unique ID and open/closed status. */
+export declare const Model: S.Struct<{
+    readonly id: S.String;
+    readonly isOpen: S.Boolean;
+}>;
+export type Model = typeof Model.Type;
+/** Sent when the disclosure button is clicked. Toggles the open/closed state. */
+export declare const Toggled: import("foldkit/schema").CallableTaggedStruct<"Toggled", {}>;
+/** Sent to explicitly close the disclosure, regardless of its current state. */
+export declare const Closed: import("foldkit/schema").CallableTaggedStruct<"Closed", {}>;
+/** Sent when the focus-button command completes after closing. */
+export declare const CompletedFocusButton: import("foldkit/schema").CallableTaggedStruct<"CompletedFocusButton", {}>;
+/** Union of all messages the disclosure component can produce. */
+export declare const Message: S.Union<[
+    typeof Toggled,
+    typeof Closed,
+    typeof CompletedFocusButton
+]>;
+export type Toggled = typeof Toggled.Type;
+export type Closed = typeof Closed.Type;
+export type CompletedFocusButton = typeof CompletedFocusButton.Type;
+export type Message = typeof Message.Type;
+/** Sent to the parent each time the disclosure toggles. The new open state is available on the next model snapshot; this OutMessage signals only that the transition happened. Consumers typically use this for analytics, lazy content loading, or saving open/closed state to a store. */
+export declare const ToggledOpenState: import("foldkit/schema").CallableTaggedStruct<"ToggledOpenState", {
+    isOpen: S.Boolean;
+}>;
+export declare const OutMessage: S.Union<readonly [import("foldkit/schema").CallableTaggedStruct<"ToggledOpenState", {
+    isOpen: S.Boolean;
+}>]>;
+export type OutMessage = typeof OutMessage.Type;
+export type ToggledOpenState = typeof ToggledOpenState.Type;
+/** Configuration for creating a disclosure model with `init`. */
+export type InitConfig = Readonly<{
+    id: string;
+    isOpen?: boolean;
+}>;
+/** Creates an initial disclosure model from a config. Defaults to closed. */
+export declare const init: (config: InitConfig) => Model;
+/** Moves focus to the disclosure's toggle button. */
+export declare const FocusButton: Command.CommandDefinitionWithArgs<"FocusButton", {
+    id: S.String;
+}, Effect.Effect<{
+    readonly _tag: "CompletedFocusButton";
+}, never, never>>;
+type UpdateReturn = readonly [
+    Model,
+    ReadonlyArray<Command.Command<Message>>,
+    Option.Option<OutMessage>
+];
+/** Processes a disclosure message and returns the next model, commands, and optional OutMessage. */
+export declare const update: (model: Model, message: Message) => UpdateReturn;
+/** Programmatically toggles the disclosure, updating the model and returning
+ *  focus commands plus a `ToggledOpenState` OutMessage. */
+export declare const toggle: (model: Model) => UpdateReturn;
+/** Programmatically closes the disclosure, updating the model and returning
+ *  focus commands plus a `ToggledOpenState` OutMessage when it was open. */
+export declare const close: (model: Model) => UpdateReturn;
+/** Reflects an externally-sourced open state onto the model without
+ *  emitting an OutMessage or running the focus command. Use this to mirror
+ *  external truth (restored storage, a deep link) onto the disclosure.
+ *  Contrast with `toggle`/`close`, which represent user or programmatic
+ *  *choices* and emit `ToggledOpenState`. Returns the model directly
+ *  because it produces no commands and no OutMessage. */
+export declare const reflectOpenState: Reflect<Model, boolean>;
+/** Attribute groups the disclosure component provides to the consumer's
+ *  `toView` callback. The consumer composes the button + panel layout
+ *  themselves using these bundles. */
+export type DisclosureAttributes = Readonly<{
+    button: ReadonlyArray<ChildAttribute>;
+    panel: ReadonlyArray<ChildAttribute>;
+}>;
+/** Per-render view inputs passed to `view` via `h.submodel`'s `viewInputs` field.
+ *
+ *  - `toView`: receives the disclosure's `button` and `panel` attribute
+ *    bundles and returns the composed layout. The consumer reads
+ *    `isOpen` from their parent model when they need to render
+ *    conditionally on it.
+ *  - `isDisabled`: when true, the button is not clickable, gets
+ *    `aria-disabled` and a `data-disabled` attribute. */
+export type ViewInputs = Readonly<{
+    toView: (attributes: DisclosureAttributes) => Html;
+    isDisabled?: boolean;
+}>;
+/** Renders a headless disclosure component with accessible ARIA
+ *  attributes and keyboard support. The consumer composes the layout
+ *  through the `toView` slot, spreading the published `button` and
+ *  `panel` attribute bundles onto their own elements.
+ *
+ *  Designed to be embedded via `h.submodel`. The consumer reacts to
+ *  toggle events by pattern-matching the `ToggledOpenState` OutMessage
+ *  from the third element of `update`'s return tuple. */
+export declare const view: import("foldkit/submodel").View<{
+    readonly id: string;
+    readonly isOpen: boolean;
+}, {
+    readonly _tag: "CompletedFocusButton";
+} | {
+    readonly _tag: "Closed";
+} | {
+    readonly _tag: "Toggled";
+}, Readonly<{
+    toView: (attributes: DisclosureAttributes) => Html;
+    isDisabled?: boolean;
+}>>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/disclosure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/disclosure/index.ts"],"names":[],"mappings":"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"}

package/dist/disclosure/index.js

@@ -0,0 +1,111 @@
+import { Effect, Function, Match as M, Option, Schema as S } from 'effect';
+import * as Command from 'foldkit/command';
+import * as Dom from 'foldkit/dom';
+import { childAttributes, html, } from 'foldkit/html';
+import { m } from 'foldkit/message';
+import { evo } from 'foldkit/struct';
+import { defineView } from 'foldkit/submodel';
+// MODEL
+/** Schema for the disclosure component's state, tracking its unique ID and open/closed status. */
+export const Model = S.Struct({
+    id: S.String,
+    isOpen: S.Boolean,
+});
+// MESSAGE
+/** Sent when the disclosure button is clicked. Toggles the open/closed state. */
+export const Toggled = m('Toggled');
+/** Sent to explicitly close the disclosure, regardless of its current state. */
+export const Closed = m('Closed');
+/** Sent when the focus-button command completes after closing. */
+export const CompletedFocusButton = m('CompletedFocusButton');
+/** Union of all messages the disclosure component can produce. */
+export const Message = S.Union([Toggled, Closed, CompletedFocusButton]);
+// OUT MESSAGE
+/** Sent to the parent each time the disclosure toggles. The new open state is available on the next model snapshot; this OutMessage signals only that the transition happened. Consumers typically use this for analytics, lazy content loading, or saving open/closed state to a store. */
+export const ToggledOpenState = m('ToggledOpenState', { isOpen: S.Boolean });
+export const OutMessage = S.Union([ToggledOpenState]);
+/** Creates an initial disclosure model from a config. Defaults to closed. */
+export const init = (config) => ({
+    id: config.id,
+    isOpen: config.isOpen ?? false,
+});
+// UPDATE
+const buttonId = (id) => `${id}-button`;
+const buttonSelector = (id) => `#${CSS.escape(buttonId(id))}`;
+const panelId = (id) => `${id}-panel`;
+/** Moves focus to the disclosure's toggle button. */
+export const FocusButton = Command.define('FocusButton', { id: S.String }, CompletedFocusButton)(({ id }) => Dom.focus(buttonSelector(id)).pipe(Effect.ignore, Effect.as(CompletedFocusButton())));
+const withUpdateReturn = M.withReturnType();
+/** Processes a disclosure message and returns the next model, commands, and optional OutMessage. */
+export const update = (model, message) => M.value(message).pipe(withUpdateReturn, M.tagsExhaustive({
+    Toggled: () => {
+        const nextIsOpen = !model.isOpen;
+        const maybeFocus = Option.liftPredicate(FocusButton({ id: model.id }), () => model.isOpen);
+        return [
+            evo(model, { isOpen: () => nextIsOpen }),
+            Option.toArray(maybeFocus),
+            Option.some(ToggledOpenState({ isOpen: nextIsOpen })),
+        ];
+    },
+    Closed: () => {
+        if (!model.isOpen) {
+            return [model, [], Option.none()];
+        }
+        const maybeFocus = Option.liftPredicate(FocusButton({ id: model.id }), () => model.isOpen);
+        return [
+            evo(model, { isOpen: () => false }),
+            Option.toArray(maybeFocus),
+            Option.some(ToggledOpenState({ isOpen: false })),
+        ];
+    },
+    CompletedFocusButton: () => [model, [], Option.none()],
+}));
+/** Programmatically toggles the disclosure, updating the model and returning
+ *  focus commands plus a `ToggledOpenState` OutMessage. */
+export const toggle = (model) => update(model, Toggled());
+/** Programmatically closes the disclosure, updating the model and returning
+ *  focus commands plus a `ToggledOpenState` OutMessage when it was open. */
+export const close = (model) => update(model, Closed());
+/** Reflects an externally-sourced open state onto the model without
+ *  emitting an OutMessage or running the focus command. Use this to mirror
+ *  external truth (restored storage, a deep link) onto the disclosure.
+ *  Contrast with `toggle`/`close`, which represent user or programmatic
+ *  *choices* and emit `ToggledOpenState`. Returns the model directly
+ *  because it produces no commands and no OutMessage. */
+export const reflectOpenState = Function.dual(2, (model, isOpen) => evo(model, { isOpen: () => isOpen }));
+/** Renders a headless disclosure component with accessible ARIA
+ *  attributes and keyboard support. The consumer composes the layout
+ *  through the `toView` slot, spreading the published `button` and
+ *  `panel` attribute bundles onto their own elements.
+ *
+ *  Designed to be embedded via `h.submodel`. The consumer reacts to
+ *  toggle events by pattern-matching the `ToggledOpenState` OutMessage
+ *  from the third element of `update`'s return tuple. */
+export const view = defineView((model, viewInputs) => {
+    const h = html();
+    const { id, isOpen } = model;
+    const { toView, isDisabled = false } = viewInputs;
+    const handleKeyDown = (key) => M.value(key).pipe(M.whenOr('Enter', ' ', () => Option.some(Toggled())), M.orElse(() => Option.none()));
+    const disabledAttributes = isDisabled
+        ? [h.AriaDisabled(true), h.DataAttribute('disabled', '')]
+        : [];
+    const buttonAttributes = [
+        h.Id(buttonId(id)),
+        h.AriaExpanded(isOpen),
+        h.AriaControls(panelId(id)),
+        h.Tabindex(0),
+        ...(isOpen ? [h.DataAttribute('open', '')] : []),
+        ...disabledAttributes,
+        ...(isDisabled
+            ? []
+            : [h.OnClick(Toggled()), h.OnKeyDownPreventDefault(handleKeyDown)]),
+    ];
+    const panelAttributes = [
+        h.Id(panelId(id)),
+        ...(isOpen ? [h.DataAttribute('open', '')] : []),
+    ];
+    return toView({
+        button: childAttributes(buttonAttributes),
+        panel: childAttributes(panelAttributes),
+    });
+});

package/dist/disclosure/public.d.ts

@@ -0,0 +1,3 @@
+export { init, update, toggle, close, reflectOpenState, view, Model, Message, OutMessage, ToggledOpenState, Closed, CompletedFocusButton, FocusButton, } from './index.js';
+export type { InitConfig, ViewInputs, DisclosureAttributes, Toggled, } from './index.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/disclosure/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/disclosure/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,MAAM,EACN,MAAM,EACN,KAAK,EACL,gBAAgB,EAChB,IAAI,EACJ,KAAK,EACL,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,MAAM,EACN,oBAAoB,EACpB,WAAW,GACZ,MAAM,YAAY,CAAA;AAEnB,YAAY,EACV,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,OAAO,GACR,MAAM,YAAY,CAAA"}

package/dist/disclosure/public.js

@@ -0,0 +1 @@
+export { init, update, toggle, close, reflectOpenState, view, Model, Message, OutMessage, ToggledOpenState, Closed, CompletedFocusButton, FocusButton, } from './index.js';