@typed/ui 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/Checkbox.d.ts

@@ -0,0 +1,168 @@
+/**
+ * A native checkbox synchronized with boolean or mixed state.
+ * The checked and indeterminate properties are separate; mixed is not a submitted third value.
+ *
+ * Read the [Checkbox guide](/explore/ui-checkbox) for a complete example.
+ *
+ * [APG interaction reference](https://www.w3.org/WAI/ARIA/apg/patterns/checkbox/).
+ * @since 1.0.0
+ * @category Overview
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { EventHandler } from "@typed/template";
+import * as Dom from "./Dom.js";
+import type { HostResult } from "./Dom/Types.js";
+/**
+ */
+export type Checked = boolean | "mixed";
+/**
+ * Current renderer-independent checkbox state.
+ * @remarks
+ * State can be updated and tested through RefSubject before any input mounts.
+ * The value is plain data; the hydrated RefSubject returned by `makeState`
+ * owns observation for its Effect Scope.
+ * @since 1.0.0
+ * @category State models
+ */
+export interface State {
+    /**
+     */
+    readonly checked: Checked;
+}
+/**
+ */
+export interface InitialState {
+    /**
+     */
+    readonly checked?: Checked;
+}
+/**
+ */
+export declare const StateSchema: Schema.Struct<{
+    readonly checked: Schema.Literals<readonly [true, false, "mixed"]>;
+}>;
+/**
+ * Creates hydrated, renderer-independent checkbox state.
+ * @remarks
+ * State transitions remain testable without rendering and can be consumed by
+ * any UI producer.
+ * The caller's Effect Scope owns the hydrated RefSubject and its subscriptions.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Checkbox.makeState({ checked: "mixed" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State construction
+ */
+export declare function makeState(initial?: InitialState): Effect.Effect<RefSubject.HydratedRefSubject<{
+    readonly checked: "mixed" | boolean;
+}, Schema.SchemaError, never, never>, never, import("effect/Scope").Scope>;
+/**
+ * Sets the checkbox state to a boolean or mixed value.
+ * @remarks
+ * A single atomic RefSubject update keeps DOM properties and ARIA state aligned.
+ * The Effect uses the existing subject lifetime and acquires no new resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState()
+ *   yield* Checkbox.setChecked(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State transitions
+ */
+export declare function setChecked<E, R>(state: RefSubject.RefSubject<State, E, R>, checked: Checked): Effect.Effect<State, E, R>;
+/**
+ * Toggles checked state, treating the mixed state as unchecked.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState({ checked: "mixed" })
+ *   yield* Checkbox.toggle(state)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State transitions
+ */
+export declare function toggle<E, R>(state: RefSubject.RefSubject<State, E, R>): Effect.Effect<State, E, R>;
+/**
+ */
+export interface InputOptions extends Dom.HostOptions<HTMLInputElement> {
+    /**
+     * Hydrated state synchronized with the input.
+     * @since 1.0.0
+     * @category State connection
+     */
+    readonly state: RefSubject.HydratedRefSubject<State, Schema.SchemaError>;
+}
+declare function internalProps<const Options extends InputOptions>(options: Options): ({ property }: Dom.InternalPropsHelpers<Options>) => {
+    type: string;
+    "aria-checked": RefSubject.Computed<Checked, Schema.SchemaError, never>;
+    "?checked": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    ".checked": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    "?disabled": false | Exclude<Dom.Property<Options, "disabled">, Dom.Nullish>;
+    "?required": false | Exclude<Dom.Property<Options, "required">, Dom.Nullish>;
+    ".indeterminate": RefSubject.Computed<boolean, Schema.SchemaError, never>;
+    onchange: EventHandler.EventHandler<Event, Schema.SchemaError, never>;
+    ref: RefSubject.HydratedRefSubject<State, Schema.SchemaError, never, never>;
+};
+type InputInternalProps<Options extends InputOptions> = ReturnType<ReturnType<typeof internalProps<Options>>>;
+/**
+ * Renders a native checkbox input synchronized with hydrated state.
+ * @remarks
+ * Native keyboard, form, disabled, required, and accessibility behavior remain
+ * available while state is exposed through RefSubject.
+ * Running the Fx installs native listeners and state subscriptions in its
+ * Scope. A custom host must apply `type`, checked, indeterminate, ARIA, and ref
+ * props; only one hydration owner may be composed for the element.
+ * @example
+ * ```ts
+ * import { RefSubject } from "@typed/fx";
+ * import { html } from "@typed/template";
+ * import * as Checkbox from "@typed/ui/Checkbox";
+ * import { component } from "@typed/template";
+ *
+ * export const UpdatePreference = component(function* () {
+ *   const state = yield* Checkbox.makeState({ checked: false });
+ *   const message = RefSubject.map(state, ({ checked }) =>
+ *     checked === true ? "Product updates enabled" : "Product updates disabled",
+ *   );
+ *   return html`<div class="preference">
+ *     <label>
+ *       ${Checkbox.Input({ state, props: { name: "updates", value: "yes" } })}
+ *       Receive product updates
+ *     </label>
+ *     <p>${message}</p>
+ *   </div>`;
+ * });
+ * ```
+ * @since 1.0.0
+ * @category Native controls
+ */
+export declare function Input<const Options extends InputOptions, const Host extends HostResult = never>(options: Options, host?: Dom.HostOverride<Dom.RenderHostProps<Options, InputInternalProps<Options>>, "", Host>): import("./Dom/Types.js").HostComponent<Host | Options>;
+/**
+ * Canonical component alias for `Input`.
+ * @remarks
+ * The alias provides the widget name while retaining the explicit input API.
+ * It has exactly the same Scope and native-element ownership as `Input`.
+ * @since 1.0.0
+ * @category Native controls
+ */
+export declare const Checkbox: typeof Input;
+export {};
+//# sourceMappingURL=Checkbox.d.ts.map

package/dist/Checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.d.ts","sourceRoot":"","sources":["../src/Checkbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,YAAY,EAAQ,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;GACG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAExC;;;;;;;;GAQG;AACH,MAAM,WAAW,KAAK;IACpB;OACG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;GACG;AACH,MAAM,WAAW,YAAY;IAC3B;OACG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;GACG;AACH,eAAO,MAAM,WAAW;;EAEtB,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,YAAiB;;2EAEnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,EACzC,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAE5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,GACxC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAK5B;AAED;GACG;AACH,MAAM,WAAW,YAAa,SAAQ,GAAG,CAAC,WAAW,CAAC,gBAAgB,CAAC;IACrE;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;CAC1E;AAED,iBAAS,aAAa,CAAC,KAAK,CAAC,OAAO,SAAS,YAAY,EAAE,OAAO,EAAE,OAAO,kBASnD,GAAG,CAAC,oBAAoB,CAAC,OAAO,CAAC;IACrD,IAAI;IACJ,cAAc;IACd,UAAU;IACV,UAAU;IACV,WAAW;IACX,WAAW;IACX,gBAAgB;IAChB,QAAQ;IACR,GAAG;EAEN;AAED,KAAK,kBAAkB,CAAC,OAAO,SAAS,YAAY,IAAI,UAAU,CAChE,UAAU,CAAC,OAAO,aAAa,CAAC,OAAO,CAAC,CAAC,CAC1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,KAAK,CAAC,KAAK,CAAC,OAAO,SAAS,YAAY,EAAE,KAAK,CAAC,IAAI,SAAS,UAAU,GAAG,KAAK,EAC7F,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,0DAW7F;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,cAAQ,CAAC"}

package/dist/Checkbox.js

@@ -0,0 +1,146 @@
+/**
+ * A native checkbox synchronized with boolean or mixed state.
+ * The checked and indeterminate properties are separate; mixed is not a submitted third value.
+ *
+ * Read the [Checkbox guide](/explore/ui-checkbox) for a complete example.
+ *
+ * [APG interaction reference](https://www.w3.org/WAI/ARIA/apg/patterns/checkbox/).
+ * @since 1.0.0
+ * @category Overview
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { RefSubject } from "@typed/fx";
+import { EventHandler, html } from "@typed/template";
+import * as Dom from "./Dom.js";
+/**
+ */
+export const StateSchema = Schema.Struct({
+    checked: Schema.Literals([true, false, "mixed"]),
+});
+/**
+ * Creates hydrated, renderer-independent checkbox state.
+ * @remarks
+ * State transitions remain testable without rendering and can be consumed by
+ * any UI producer.
+ * The caller's Effect Scope owns the hydrated RefSubject and its subscriptions.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   return yield* Checkbox.makeState({ checked: "mixed" })
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State construction
+ */
+export function makeState(initial = {}) {
+    return RefSubject.hydrate(StateSchema, { checked: initial.checked ?? false });
+}
+/**
+ * Sets the checkbox state to a boolean or mixed value.
+ * @remarks
+ * A single atomic RefSubject update keeps DOM properties and ARIA state aligned.
+ * The Effect uses the existing subject lifetime and acquires no new resource.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState()
+ *   yield* Checkbox.setChecked(state, true)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State transitions
+ */
+export function setChecked(state, checked) {
+    return RefSubject.update(state, (current) => ({ ...current, checked }));
+}
+/**
+ * Toggles checked state, treating the mixed state as unchecked.
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import * as Checkbox from "@typed/ui/Checkbox"
+ *
+ * const program = Effect.gen(function* () {
+ *   const state = yield* Checkbox.makeState({ checked: "mixed" })
+ *   yield* Checkbox.toggle(state)
+ * })
+ * ```
+ * @since 1.0.0
+ * @category State transitions
+ */
+export function toggle(state) {
+    return RefSubject.update(state, (current) => ({
+        ...current,
+        checked: current.checked === true ? false : true,
+    }));
+}
+function internalProps(options) {
+    const checked = RefSubject.map(options.state, (state) => state.checked === true);
+    const indeterminate = RefSubject.map(options.state, (state) => state.checked === "mixed");
+    const onChange = EventHandler.make(Effect.fn((event) => setChecked(options.state, Dom.currentTarget(event).checked)));
+    return ({ property }) => ({
+        type: "checkbox",
+        "aria-checked": RefSubject.map(options.state, (state) => state.checked),
+        "?checked": checked,
+        ".checked": checked,
+        "?disabled": property("disabled", false),
+        "?required": property("required", false),
+        ".indeterminate": indeterminate,
+        onchange: onChange,
+        ref: options.state,
+    });
+}
+/**
+ * Renders a native checkbox input synchronized with hydrated state.
+ * @remarks
+ * Native keyboard, form, disabled, required, and accessibility behavior remain
+ * available while state is exposed through RefSubject.
+ * Running the Fx installs native listeners and state subscriptions in its
+ * Scope. A custom host must apply `type`, checked, indeterminate, ARIA, and ref
+ * props; only one hydration owner may be composed for the element.
+ * @example
+ * ```ts
+ * import { RefSubject } from "@typed/fx";
+ * import { html } from "@typed/template";
+ * import * as Checkbox from "@typed/ui/Checkbox";
+ * import { component } from "@typed/template";
+ *
+ * export const UpdatePreference = component(function* () {
+ *   const state = yield* Checkbox.makeState({ checked: false });
+ *   const message = RefSubject.map(state, ({ checked }) =>
+ *     checked === true ? "Product updates enabled" : "Product updates disabled",
+ *   );
+ *   return html`<div class="preference">
+ *     <label>
+ *       ${Checkbox.Input({ state, props: { name: "updates", value: "yes" } })}
+ *       Receive product updates
+ *     </label>
+ *     <p>${message}</p>
+ *   </div>`;
+ * });
+ * ```
+ * @since 1.0.0
+ * @category Native controls
+ */
+export function Input(options, host) {
+    return Dom.renderHost()(options, host, internalProps(options), "", (i) => {
+        return html `<input ...${i} />`;
+    });
+}
+/**
+ * Canonical component alias for `Input`.
+ * @remarks
+ * The alias provides the widget name while retaining the explicit input API.
+ * It has exactly the same Scope and native-element ownership as `Input`.
+ * @since 1.0.0
+ * @category Native controls
+ */
+export const Checkbox = Input;

package/dist/Collection.d.ts

@@ -0,0 +1,254 @@
+/**
+ * Collection is the scoped registry shared by composite widgets. Registration order is not
+ * navigation order: byDomOrder reads the mounted nodes with compareDocumentPosition, and each
+ * register Effect removes its own item when that Effect's Scope closes.
+ *
+ * @remarks
+ * The module keeps policy, state transitions, and DOM rendering separable so applications can use
+ * the state and pure operations without mounting UI, or supply custom hosts without replacing native
+ * events and browser-owned focus.
+ *
+ * @since 1.0.0
+ * @category Architecture overview
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import { RefSubject } from "@typed/fx";
+/**
+ * Public Collection.Item behavioral model.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The public model lets custom composites reuse Collection's deterministic policy without copying
+ * an internal shape.
+ *
+ * ## Ownership and lifetime
+ *
+ * This declaration is data or schema metadata and acquires no resources.
+ *
+ * ## Example
+ *
+ * Import with `import type { Item } from "@typed/ui/Collection";` Extend the [Collection.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCollection%23makeState). A registered value can retain
+ * its real DOM identity:
+ * `const item: Item<string> = { id: "save", value: "save", element: document.createElement("button") }`.
+ * @since 1.0.0
+ * @category Item metadata
+ */
+export interface Item<Value = unknown, Element extends object = globalThis.Element> {
+    /**
+     * Stable id used for collection identity and ARIA relationships.
+     * @since 1.0.0
+     * @category Identity and relationships
+     */
+    readonly id: string;
+    /**
+     * Mounted element handle used for DOM ordering, focus, and scrolling.
+     * @since 1.0.0
+     * @category Item registration
+     */
+    readonly element?: Element;
+    /**
+     * Flag used by collection movement and widget handlers to skip activation by default.
+     * @since 1.0.0
+     * @category Availability
+     */
+    readonly disabled?: boolean;
+    /**
+     * Whether the item participates as a submenu entry.
+     * @since 1.0.0
+     * @category Nested menus
+     */
+    readonly submenu?: boolean;
+    /**
+     * Search text used by typeahead independently of rendered markup.
+     * @since 1.0.0
+     * @category Typeahead
+     */
+    readonly textValue?: string;
+    /**
+     * Current semantic value selected or edited by the widget.
+     * @since 1.0.0
+     * @category Item metadata
+     */
+    readonly value?: Value;
+}
+/**
+ * Complete renderer-independent state for Collection.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Applications can inspect, update, and test Collection behavior without mounting or coupling the
+ * state to a renderer.
+ *
+ * ## Ownership and lifetime
+ *
+ * This declaration is data or schema metadata and acquires no resources.
+ *
+ * ## Example
+ *
+ * Import with `import type { State } from "@typed/ui/Collection";` Extend the [Collection.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCollection%23makeState). Collection state is an
+ * immutable sequence: `const snapshot: State<string> = [{ id: "save", value: "save" }]`.
+ * @since 1.0.0
+ * @category Collection state
+ */
+export type State<Value = unknown, Element extends object = globalThis.Element> = readonly Item<Value, Element>[];
+/**
+ * Creates hydrated Collection state. The collection starts with the supplied immutable item array,
+ * or empty.
+ *
+ * @remarks
+ * ## Why
+ *
+ * State and collection ownership can be composed and tested independently from any renderer.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect creates the RefSubject when run. That state is renderer-independent;
+ * collection registrations belong to the separate Scope that runs register or ref, not to state
+ * creation.
+ *
+ * @example
+ * ```ts
+ * import * as Effect from "effect/Effect";
+ * import * as Collection from "@typed/ui/Collection";
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* () {
+ *     const collection = yield* Collection.makeState<string>();
+ *     return yield* collection;
+ *   }),
+ * );
+ * ```
+ * @since 1.0.0
+ * @category Collection state
+ */
+export declare function makeState<Value = unknown, Element extends object = globalThis.Element>(initial?: State<Value, Element>): Effect.Effect<RefSubject.RefSubject<State<Value, Element>>, never, Scope.Scope>;
+/**
+ * Upserts an item immediately and installs a finalizer in the Scope that runs this Effect; the
+ * finalizer removes only that exact registration.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Collection's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration is owned by the Scope in which the registration Effect runs. Closing that Scope
+ * removes the exact registered item; creating the collection or state does not own this cleanup.
+ *
+ * ## Example
+ *
+ * Import with `import { register } from "@typed/ui/Collection";` Extend the [Collection.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCollection%23makeState). Inside the linked Effect
+ * program invoke `yield* register(collection, { id: "save", value: "save" })`, then read the
+ * collection to observe the inserted item.
+ * @since 1.0.0
+ * @category Item registration
+ */
+export declare function register<Value, Element extends object, E, R>(collection: RefSubject.RefSubject<State<Value, Element>, E, R>, item: Item<Value, Element>): Effect.Effect<void, E, R | Scope.Scope>;
+/**
+ * Registers a mounted element and removes it automatically with the Scope in which the returned
+ * Effect is run.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Collection's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * Registration is owned by the Scope in which the registration Effect runs. Closing that Scope
+ * removes the exact registered item; creating the collection or state does not own this cleanup.
+ *
+ * ## Example
+ *
+ * Import with `import { ref } from "@typed/ui/Collection";` Extend the [Collection.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCollection%23makeState). Inside the linked Effect
+ * program create `const attach = ref(collection, { id: "save", value: "save" })`, then run `yield*
+ * attach(document.createElement("button"))` and read the collection before Scope close.
+ * @since 1.0.0
+ * @category Item registration
+ */
+export declare function ref<Value, Element extends object, E, R>(collection: RefSubject.RefSubject<State<Value, Element>, E, R>, item: Omit<Item<Value, Element>, "element">): (element: Element) => Effect.Effect<void, E, R | Scope.Scope>;
+/**
+ * Removes every registered item with the supplied id and retains the remaining order.
+ *
+ * @remarks
+ * ## Why
+ *
+ * The operation exposes Collection's transition directly so callers can compose it in Effect
+ * programs and native event handlers.
+ *
+ * ## Ownership and lifetime
+ *
+ * The returned Effect performs the update or DOM side effect only when run, preserves the declared
+ * error and service channels, and retains no resources after completion.
+ *
+ * ## Example
+ *
+ * Import with `import { unregister } from "@typed/ui/Collection";` Extend the [Collection.makeState
+ * runnable setup](/reference/%40typed%2Fui%2FCollection%23makeState). Inside the linked Effect
+ * program first register `"save"`, run `yield* unregister(collection, "save")`, then read the
+ * collection to observe that only the matching id was removed.
+ * @since 1.0.0
+ * @category Item registration
+ */
+export declare function unregister<Value, Element extends object, E, R>(collection: RefSubject.RefSubject<State<Value, Element>, E, R>, id: string): Effect.Effect<void, E, R>;
+/**
+ * Returns a new array excluding only items whose disabled flag is exactly true.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Separating this deterministic policy from event wiring lets applications test it directly and
+ * reuse it in custom composites.
+ *
+ * ## Ownership and lifetime
+ *
+ * This is a synchronous calculation. It acquires no resources and does not mutate the input array,
+ * state, event, or DOM.
+ *
+ * @example
+ * ```ts
+ * import * as Collection from "@typed/ui/Collection";
+ *
+ * const enabled = Collection.enabledItems([{ id: "a" }, { id: "b", disabled: true }]);
+ * ```
+ * @since 1.0.0
+ * @category Collection ordering
+ */
+export declare function enabledItems<ItemType extends Item<unknown, object>>(items: readonly ItemType[]): readonly ItemType[];
+/**
+ * Returns a sorted copy using compareDocumentPosition; items without comparable mounted elements
+ * retain an equivalent ordering position.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Separating this deterministic policy from event wiring lets applications test it directly and
+ * reuse it in custom composites.
+ *
+ * ## Ownership and lifetime
+ *
+ * This is a synchronous calculation. It acquires no resources and does not mutate the input array,
+ * state, event, or DOM.
+ *
+ * @example
+ * ```ts
+ * import * as Collection from "@typed/ui/Collection";
+ *
+ * const ordered = Collection.byDomOrder([{ id: "body", element: document.body }]);
+ * ```
+ * @since 1.0.0
+ * @category Collection ordering
+ */
+export declare function byDomOrder<ItemType extends Item<unknown, object>>(items: readonly ItemType[]): readonly ItemType[];
+//# sourceMappingURL=Collection.d.ts.map

package/dist/Collection.d.ts.map

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