@typed/ui 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/Dialog.js

@@ -0,0 +1,355 @@
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { EventHandler, html, } from "@typed/template";
+import * as Dom from "./Dom.js";
+import * as NativeDialog from "./NativeDialog.js";
+const dialogs = new WeakMap();
+/** Schema for dialog hydration state.
+ * @remarks
+ * ## Why
+ * Shared encoding keeps server and browser state compatible.
+ * ## Ownership and lifetime
+ * The immutable schema acquires no resources.
+ * @since 1.0.0
+ * @category schemas
+ */
+export const StateSchema = Schema.Struct({ open: Schema.Boolean });
+/** Creates hydrated dialog state independent of rendering.
+ * @remarks
+ * ## Why
+ * Application transitions can be composed and tested before a native dialog
+ * element exists.
+ * ## Ownership and lifetime
+ * The calling Effect Scope owns the returned RefSubject.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Dialog.makeState()
+ * })
+ * ```
+ * @since 1.0.0
+ * @category constructors
+ */
+export function makeState(initial = {}) {
+    return RefSubject.hydrate(StateSchema, { open: initial.open ?? false });
+}
+/** Sets desired dialog visibility.
+ * @remarks
+ * ## Why
+ * Explicit state transitions stay outside renderers and retain Effect typing.
+ * ## Ownership and lifetime
+ * The Effect uses the existing RefSubject lifetime and acquires no resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState()
+ *   yield* Dialog.setOpen(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category state
+ */
+export function setOpen(state, open) {
+    return RefSubject.update(state, (current) => ({ ...current, open }));
+}
+/** Marks dialog state closed without requesting native cancellation.
+ * @remarks
+ * ## Why
+ * Programmatic close is distinct from `requestClose`, which runs the browser's
+ * cancelable close-request lifecycle.
+ * ## Ownership and lifetime
+ * The Effect updates existing state and acquires no resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState({ open: true })
+ *   yield* Dialog.close(state)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category state
+ */
+export function close(state) {
+    return setOpen(state, false);
+}
+/**
+ * Requests the native dialog close lifecycle, including its cancel event.
+ * @remarks
+ * ## Why
+ * The browser's `requestClose()` is cancelable. The fallback dispatches a real
+ * cancelable `cancel` event and calls `close()` only when it is accepted, so
+ * user handlers retain the same veto point.
+ * ## Ownership and lifetime
+ * The Effect consults the dialog currently registered for the hydrated state;
+ * registration is removed when `Content`'s Scope closes. No dialog is retained
+ * after that finalizer.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState({ open: true })
+ *   yield* Dialog.requestClose(state)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category lifecycle
+ */
+export function requestClose(state, returnValue) {
+    return Effect.sync(() => {
+        const dialog = dialogs.get(state);
+        const requestClose = dialog === undefined ? undefined : Reflect.get(dialog, "requestClose");
+        if (typeof requestClose === "function") {
+            requestClose.call(dialog, returnValue);
+        }
+        else if (dialog !== undefined) {
+            const accepted = dialog.dispatchEvent(new Event("cancel", { cancelable: true }));
+            if (accepted)
+                dialog.close(returnValue);
+        }
+    });
+}
+function triggerInternalProps(options) {
+    const open = RefSubject.map(options.state, (state) => state.open);
+    const show = setOpen(options.state, true);
+    return ({ property }) => ({
+        type: "button",
+        "aria-haspopup": "dialog",
+        "aria-expanded": open,
+        "aria-controls": property("controls", undefined),
+        commandfor: property("controls", undefined),
+        command: options.controls === undefined ? undefined : "show-modal",
+        onclick: options.controls === undefined ? show : undefined,
+    });
+}
+/** Renders a native button that opens dialog content.
+ * @remarks
+ * ## Why
+ * It preserves button semantics, real events, and ARIA relationship state.
+ * Supplying `controls` selects native `commandfor` / `show-modal` behavior and
+ * disables the Fx click fallback, so that form requires browser command support.
+ * Omitting `controls` installs the portable state-driven click handler.
+ * ## Ownership and lifetime
+ * Running the Fx owns reactive props/listeners in its Scope. A custom host must
+ * preserve button type, ARIA, command, click props, and content.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState()
+ *   // Omitting controls selects the Fx state fallback.
+ *   return Dialog.Trigger({ state, content: "Open" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function Trigger(options, host) {
+    return Dom.renderHost()(options, host, triggerInternalProps(options), options.content, (props, content) => html `<button ...${props}>${content}</button>`);
+}
+function contentInternalProps(options) {
+    const synchronize = NativeDialog.ref(options.state, { modal: options.modal });
+    return ({ property }) => ({
+        id: property("id", undefined),
+        "aria-labelledby": property("labelledBy", undefined),
+        "aria-describedby": property("describedBy", undefined),
+        "aria-label": property("label", undefined),
+        oncancel: close(options.state),
+        onclose: close(options.state),
+        ontoggle: EventHandler.make(Effect.fn((event) => setOpen(options.state, Dom.currentTarget(event).open))),
+        ref: Dom.composeRefs(options.state, Dom.composeRefs(synchronize, dialogRef(options.state))),
+    });
+}
+function dialogRef(state) {
+    return Effect.fn(function* (dialog) {
+        dialogs.set(state, dialog);
+        const scope = yield* Effect.scope;
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+            if (dialogs.get(state) === dialog)
+                dialogs.delete(state);
+        }));
+    });
+}
+/**
+ * Renders native dialog content synchronized with hydrated state.
+ * @remarks
+ * ## Why
+ * `Content` uses a real `<dialog>` and its `show()`, `showModal()`, `close()`,
+ * `cancel`, `close`, and `toggle` lifecycle. The browser therefore owns focus,
+ * top-layer placement, modal inertness, and default Escape behavior.
+ * ## Ownership and lifetime
+ * Running the Fx owns native listeners, dialog registration, and the
+ * NativeDialog observer in its Effect Scope. Finalization removes registration
+ * only when it still points at this element. A custom host must preserve native
+ * dialog identity, naming props, lifecycle handlers, and exactly one hydration
+ * ref owner.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState()
+ *   return Dialog.Content({
+ *     state,
+ *     id: "confirm",
+ *     label: "Confirm",
+ *     content: "Continue?"
+ *   })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function Content(options, host) {
+    return Dom.renderHost()(options, host, contentInternalProps(options), options.content, (props, content) => {
+        return html `<dialog ...${props}>${content}</dialog>`;
+    });
+}
+/** Canonical widget alias for `Content`.
+ * @remarks
+ * ## Why
+ * The alias provides the widget name while `Content` identifies compound use.
+ * ## Ownership and lifetime
+ * It has exactly the same native element and Scope ownership as `Content`.
+ * @since 1.0.0
+ * @category aliases
+ */
+export const Dialog = Content;
+function closeInternalProps(options, requestCloseLifecycle) {
+    return ({ property }) => ({
+        type: "button",
+        commandfor: property("controls", undefined),
+        command: options.controls === undefined
+            ? undefined
+            : requestCloseLifecycle
+                ? "request-close"
+                : "close",
+        onclick: options.controls !== undefined
+            ? undefined
+            : requestCloseLifecycle
+                ? requestClose(options.state)
+                : close(options.state),
+    });
+}
+/** Renders a button that closes a dialog without a cancel request.
+ * @remarks
+ * ## Why
+ * Accepted actions need a direct close path distinct from cancelable dismissal.
+ * `controls` selects native `command="close"` and disables the Fx click
+ * fallback; omit it when native dialog commands are unavailable.
+ * ## Ownership and lifetime
+ * Running the Fx owns handlers/dynamic content by Scope. Custom hosts must
+ * preserve type, command or fallback click behavior, and content.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState({ open: true })
+ *   return Dialog.Close({ state, content: "Done" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function Close(options, host) {
+    return Dom.renderHost()(options, host, closeInternalProps(options, false), options.content, (props, content) => html `<button ...${props}>${content}</button>`);
+}
+/** Alias for direct `Close` behavior.
+ * @remarks
+ * ## Why
+ * The alias supports dismissal vocabulary without introducing another lifecycle.
+ * ## Ownership and lifetime
+ * It has exactly the same Scope and native button ownership as `Close`.
+ * @since 1.0.0
+ * @category aliases
+ */
+export const Dismiss = Close;
+/** Renders a button that starts the cancelable native close-request lifecycle.
+ * @remarks
+ * ## Why
+ * Consumers can intercept a real `cancel` event before the dialog closes.
+ * `controls` selects native `command="request-close"` and disables the Fx click
+ * fallback; omit it when native dialog commands are unavailable.
+ * ## Ownership and lifetime
+ * Running the Fx owns handlers by Scope; dialog registration remains owned by
+ * the corresponding `Content` Scope.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Dialog from "@typed/ui/Dialog"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Dialog.makeState({ open: true })
+ *   return Dialog.RequestClose({ state, content: "Cancel" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function RequestClose(options, host) {
+    return Dom.renderHost()(options, host, closeInternalProps(options, true), options.content, (props, content) => html `<button ...${props}>${content}</button>`);
+}
+function headingInternalProps() {
+    return ({ property }) => ({
+        id: property("id", undefined),
+        role: "heading",
+        "aria-level": property("level", 2),
+    });
+}
+/** Renders a dialog heading with explicit ARIA level semantics.
+ * @remarks
+ * ## Why
+ * The helper creates a reliable naming target and preserves heading hierarchy.
+ * ## Ownership and lifetime
+ * Running the Fx owns dynamic content by Scope. A custom host must preserve id,
+ * role, and `aria-level`.
+ * @example
+ * ```ts
+ * import { Heading } from "@typed/ui/Dialog"
+ *
+ * const title = Heading({ id: "confirm-title", content: "Confirm" })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function Heading(options, host) {
+    return Dom.renderHost()(options, host, headingInternalProps(), options.content, (props, content) => html `<h2 ...${props}>${content}</h2>`);
+}
+function descriptionInternalProps() {
+    return ({ property }) => ({ id: property("id", undefined) });
+}
+/** Renders descriptive dialog text with an optional relationship id.
+ * @remarks
+ * ## Why
+ * The helper keeps accessible description wiring explicit and platform-native.
+ * ## Ownership and lifetime
+ * Running the Fx owns dynamic content by Scope. A custom host must preserve id.
+ * @example
+ * ```ts
+ * import { Description } from "@typed/ui/Dialog"
+ *
+ * const detail = Description({ id: "confirm-detail", content: "This cannot be undone." })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export function Description(options, host) {
+    return Dom.renderHost()(options, host, descriptionInternalProps(), options.content, (props, content) => html `<p ...${props}>${content}</p>`);
+}

package/dist/Disclosure.d.ts

@@ -0,0 +1,219 @@
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import * as Schema from "effect/Schema";
+import type { Fx } from "@typed/fx/Fx";
+import { RefSubject } from "@typed/fx";
+import { EventHandler, type Renderable, type RenderEvent, type RenderTemplate } from "@typed/template";
+import * as Dom from "./Dom.js";
+import type { HostResult } from "./Dom/Types.js";
+/** Current renderer-independent disclosure state.
+ * @remarks
+ * ## Why
+ * Open state remains testable without mounting native details content.
+ * ## Ownership and lifetime
+ * Plain state retains no resources; RefSubject lifetime is Scope-owned.
+ * @since 1.0.0
+ * @category state
+ */
+export interface State {
+    /** Whether the details element is open.
+     * @remarks
+     * ## Why
+     * One field coordinates application state with native element state.
+     * ## Ownership and lifetime
+     * Plain data acquires no resources.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly open: boolean;
+}
+/** Optional initial disclosure state.
+ * @remarks
+ * ## Why
+ * Omission produces a deterministic closed SSR snapshot.
+ * ## Ownership and lifetime
+ * Configuration is inert.
+ * @since 1.0.0
+ * @category state
+ */
+export interface InitialState {
+    /** Initial open state, defaulting to false.
+     * @remarks
+     * ## Why
+     * The value seeds the hydration contract.
+     * ## Ownership and lifetime
+     * Plain data retains no resources.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly open?: boolean;
+}
+/** Schema for disclosure hydration state.
+ * @remarks
+ * ## Why
+ * Shared encoding keeps server and browser state compatible.
+ * ## Ownership and lifetime
+ * The immutable schema acquires no resources.
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const StateSchema: Schema.Struct<{
+    readonly open: Schema.Boolean;
+}>;
+/** Creates hydrated disclosure state.
+ * @remarks
+ * ## Why
+ * Applications can own and test open-state transitions independently of UI.
+ * ## Ownership and lifetime
+ * The calling Effect Scope owns the returned RefSubject.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Disclosure from "@typed/ui/Disclosure"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Disclosure.makeState({ open: true })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function makeState(initial?: InitialState): Effect.Effect<RefSubject.HydratedRefSubject<{
+    readonly open: boolean;
+}, Schema.SchemaError, never, never>, never, Scope.Scope>;
+/** Sets disclosure visibility.
+ * @remarks
+ * ## Why
+ * Explicit state transitions remain composable with Effect and outside renderers.
+ * ## Ownership and lifetime
+ * The Effect reuses the existing state lifetime and acquires no resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Disclosure from "@typed/ui/Disclosure"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Disclosure.makeState()
+ *   yield* Disclosure.setOpen(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category state
+ */
+export declare function setOpen<E, R>(state: RefSubject.RefSubject<State, E, R>, open: boolean): Effect.Effect<State, E, R>;
+/** Options for the native `<summary>` trigger.
+ * @remarks
+ * ## Why
+ * Summary preserves built-in pointer, keyboard, and disclosure behavior.
+ * ## Ownership and lifetime
+ * Options are inert; dynamic content follows the rendered Scope.
+ * @since 1.0.0
+ * @category models
+ */
+export interface ButtonOptions extends Dom.HostOptions<HTMLElement> {
+    /** Visible summary content and accessible name.
+     * @remarks
+     * ## Why
+     * Native summary content labels its containing details element.
+     * ## Ownership and lifetime
+     * Dynamic content follows the trigger Scope.
+     * @since 1.0.0
+     * @category content
+     */
+    readonly content: Renderable.Any;
+}
+declare function buttonInternalProps(): {};
+type ButtonInternalProps = ReturnType<typeof buttonInternalProps>;
+/** Renders a native `<summary>` disclosure trigger.
+ * @remarks
+ * ## Why
+ * The browser owns activation and toggling; Typed does not emulate them with
+ * click handlers or synthetic events.
+ * ## Ownership and lifetime
+ * Running the Fx owns dynamic content in its Scope. A custom host must remain a
+ * valid summary participant inside the associated details element.
+ * @example
+ * ```ts
+ * import { Button } from "@typed/ui/Disclosure"
+ *
+ * const summary = Button({ content: "Advanced settings" })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export declare function Button<const Options extends ButtonOptions, const Host extends HostResult = never>(options: Options, host?: Dom.HostOverride<Dom.RenderHostProps<Options, ButtonInternalProps>, Options["content"], Host>): Fx<RenderEvent, Renderable.Error<Options | Host>, Renderable.Services<Options | Host> | Scope.Scope | RenderTemplate>;
+/** Options for native `<details>` content.
+ * @remarks
+ * ## Why
+ * A shared state lets application code observe and control the browser-owned
+ * disclosure lifecycle.
+ * ## Ownership and lifetime
+ * Options are inert; rendering owns listeners and the NativeDetails observer.
+ * @since 1.0.0
+ * @category models
+ */
+export interface ContentOptions extends Dom.HostOptions<HTMLDetailsElement> {
+    /** Hydrated state synchronized with the details element.
+     * @remarks
+     * ## Why
+     * Native toggle events and application updates converge on one source.
+     * ## Ownership and lifetime
+     * The content borrows state; its originating Scope owns it.
+     * @since 1.0.0
+     * @category state
+     */
+    readonly state: RefSubject.HydratedRefSubject<State, Schema.SchemaError>;
+    /** Summary and disclosed body content.
+     * @remarks
+     * ## Why
+     * Keeping the subtree renderable preserves Typed error/service composition.
+     * ## Ownership and lifetime
+     * Dynamic content follows the details Scope.
+     * @since 1.0.0
+     * @category content
+     */
+    readonly content: Renderable.Any;
+}
+declare function contentInternalProps<const Options extends ContentOptions>(options: Options): () => {
+    readonly ontoggle: EventHandler.EventHandler<Event, Schema.SchemaError, never>;
+    readonly ref: import("./Dom/Refs.js").ComposedRef<RefSubject.HydratedRefSubject<State, Schema.SchemaError, never, never>, (element: HTMLDetailsElement) => Effect.Effect<void, Schema.SchemaError, Scope.Scope>> | undefined;
+};
+type ContentInternalProps<Options extends ContentOptions> = ReturnType<ReturnType<typeof contentInternalProps<Options>>>;
+/** Renders native details content synchronized with hydrated state.
+ * @remarks
+ * ## Why
+ * Native disclosure behavior, semantics, and `toggle` events stay intact while
+ * Effect state can control or observe visibility.
+ * ## Ownership and lifetime
+ * Running the Fx owns the native listener and scoped observer. A custom host
+ * must preserve the toggle handler and exactly one composed hydration ref.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Disclosure from "@typed/ui/Disclosure"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Disclosure.makeState()
+ *   return Disclosure.Content({
+ *     state,
+ *     content: Disclosure.Button({ content: "More" })
+ *   })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category components
+ */
+export declare function Content<const Options extends ContentOptions, const Host extends HostResult = never>(options: Options, host?: Dom.HostOverride<Dom.RenderHostProps<Options, ContentInternalProps<Options>>, Options["content"], Host>): Fx<RenderEvent, Renderable.Error<Options | Host>, Renderable.Services<Options | Host> | Scope.Scope | RenderTemplate>;
+/** Canonical alias for `Content`.
+ * @remarks
+ * ## Why
+ * The widget name remains convenient while `Content` identifies its role in
+ * compound composition.
+ * ## Ownership and lifetime
+ * It has exactly the same Scope and details-element ownership as `Content`.
+ * @since 1.0.0
+ * @category aliases
+ */
+export declare const Disclosure: typeof Content;
+export {};
+//# sourceMappingURL=Disclosure.d.ts.map

package/dist/Disclosure.d.ts.map

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