@typed/ui 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/Disclosure.js

@@ -0,0 +1,128 @@
+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";
+import * as NativeDetails from "./NativeDetails.js";
+/** 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 Open state
+ */
+export const StateSchema = Schema.Struct({ 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 Open state
+ */
+export function makeState(initial = {}) {
+    return RefSubject.hydrate(StateSchema, { open: initial.open ?? false });
+}
+/** 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 Open state
+ */
+export function setOpen(state, open) {
+    return RefSubject.update(state, (current) => ({ ...current, open }));
+}
+function buttonInternalProps() {
+    return {};
+}
+/** 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 Summary activation
+ */
+export function Button(options, host) {
+    return Dom.renderHost()(options, host, buttonInternalProps, options.content, (props, content) => html `<summary ...${props}>${content}</summary>`);
+}
+function contentInternalProps(options) {
+    return () => ({
+        ontoggle: EventHandler.make(Effect.fn((event) => setOpen(options.state, Dom.currentTarget(event).open))),
+        ref: Dom.composeRefs(options.state, NativeDetails.ref(options.state)),
+    });
+}
+/** 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 Native content host
+ */
+export function Content(options, host) {
+    return Dom.renderHost()(options, host, contentInternalProps(options), options.content, (props, content) => {
+        return html `<details ...${props}>${content}</details>`;
+    });
+}
+/** 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 Native content host
+ */
+export const Disclosure = Content;

package/dist/Dom/Events.d.ts

@@ -0,0 +1,122 @@
+import { EventHandler } from "@typed/template";
+import type { EventHandlerInput, EventHandlerProperty } from "./Types.js";
+/**
+ * Combines a user handler with component-required behavior for one native event.
+ *
+ * @remarks
+ * ## Why
+ * Component hosts must combine user and required behavior without hiding the
+ * precise Effect boundary. User callback invocation constructs the user Effect
+ * first. Internal callback invocation may then construct an internal Effect;
+ * only execution of that returned Effect is sequenced after the user Effect.
+ *
+ * ## Ownership and lifetime
+ * The returned `EventHandler` owns no listener by itself. The rendering Scope
+ * installs it and removes it; `once` and AbortSignal state are honored for each
+ * input independently. Capture and passive options are conservatively merged.
+ *
+ * ## DOM behavior
+ * The user handler receives a retained `Proxy` around the browser event so a
+ * `preventDefault()` call made while its Effect runs can still cancel the
+ * internal step. The proxy is not identity-equal to the native event. Its
+ * properties—including `currentTarget`—are read from that native event, so
+ * `currentTarget` becomes null after browser dispatch exactly as it normally
+ * does. The internal handler receives the original native event, never the
+ * proxy.
+ *
+ * ## Invocation and Effect sequencing
+ * `userHandler.handler(proxy)` is called first to construct `userEffect`. If
+ * that invocation has already called `preventDefault()`—for example through an
+ * EventHandler option—the internal handler is not invoked. Otherwise,
+ * `internalHandler.handler(nativeEvent)` is called immediately to construct
+ * `internalEffect`, before `userEffect` runs. A void-returning internal callback
+ * therefore performs its callback body eagerly and cannot be undone by a later
+ * `preventDefault()` inside `userEffect`. The composed Effect runs `userEffect`,
+ * checks tracked default prevention again, and only then runs a returned
+ * `internalEffect` when it is still allowed.
+ *
+ * @example
+ * ```ts
+ * import { chainEvent } from "@typed/ui/Dom/Events"
+ * import { EventHandler } from "@typed/template"
+ * import { Effect } from "effect"
+ *
+ * const calls: Array<string> = []
+ * const handler = chainEvent(
+ *   EventHandler.make((event: MouseEvent) =>
+ *     Effect.sync(() => {
+ *       calls.push("user effect")
+ *       event.preventDefault()
+ *     })),
+ *   EventHandler.make(() => {
+ *     calls.push("internal callback") // runs while constructing the Effect
+ *     return Effect.sync(() => calls.push("internal effect"))
+ *   })
+ * )!
+ *
+ * const program = handler.handler(new MouseEvent("click", { cancelable: true }))
+ * // calls is now ["internal callback"]
+ * await Effect.runPromise(program)
+ * // calls is ["internal callback", "user effect"];
+ * // the returned internal Effect was gated by preventDefault.
+ * ```
+ *
+ * @since 1.0.0
+ * @category Event composition
+ */
+export declare function chainEvent<Ev extends Event, E1 = never, R1 = never, E2 = never, R2 = never>(user: EventHandlerInput<Ev, E1, R1>, internal: EventHandlerInput<Ev, E2, R2>): EventHandler.EventHandler<Ev, E1 | E2, R1 | R2> | undefined;
+/**
+ * Tests whether a prop name uses Typed's native event conventions.
+ *
+ * @remarks
+ * ## Why
+ * Host forwarding and merging treat `on*` and `@*` keys as handlers rather
+ * than ordinary attributes.
+ *
+ * ## Ownership and lifetime
+ * Pure predicate; it installs no listener and retains no key.
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export declare function isEventKey(key: string): key is EventHandlerProperty;
+/**
+ * Reads a native event's non-null current target during handler execution.
+ *
+ * @remarks
+ * ## Why
+ * The DOM types `currentTarget` as nullable because the browser clears it after
+ * dispatch. This helper makes the temporal constraint explicit and preserves a
+ * caller-selected target type.
+ *
+ * ## Ownership and lifetime
+ * The returned target is borrowed from the live dispatch. Do not treat it as a
+ * component-owned node; the helper throws after the handler window closes.
+ *
+ * @example
+ * ```ts
+ * import { currentTarget } from "@typed/ui/Dom/Events"
+ *
+ * const read = (event: Event) => currentTarget<HTMLInputElement>(event).value
+ * ```
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export declare function currentTarget<Target extends EventTarget>(event: Event): Target;
+/**
+ * Reads the standards-based `ToggleEvent.newState` value when present.
+ *
+ * @remarks
+ * ## Why
+ * Popover and details components can follow the browser's real toggle event
+ * while remaining usable with DOM libraries whose Event types lag the platform.
+ *
+ * ## Ownership and lifetime
+ * Pure read of the current event; no state or listener is retained.
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export declare function toggleState(event: Event): "open" | "closed" | undefined;
+//# sourceMappingURL=Events.d.ts.map

package/dist/Dom/Events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Events.d.ts","sourceRoot":"","sources":["../../src/Dom/Events.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAgB,UAAU,CAAC,EAAE,SAAS,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACzF,IAAI,EAAE,iBAAiB,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EACnC,QAAQ,EAAE,iBAAiB,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GACtC,YAAY,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CA0C7D;AA2BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,oBAAoB,CAEnE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,MAAM,SAAS,WAAW,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAO9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAGvE"}

package/dist/Dom/Events.js

@@ -0,0 +1,192 @@
+import * as Effect from "effect/Effect";
+import { EventHandler } from "@typed/template";
+/**
+ * Combines a user handler with component-required behavior for one native event.
+ *
+ * @remarks
+ * ## Why
+ * Component hosts must combine user and required behavior without hiding the
+ * precise Effect boundary. User callback invocation constructs the user Effect
+ * first. Internal callback invocation may then construct an internal Effect;
+ * only execution of that returned Effect is sequenced after the user Effect.
+ *
+ * ## Ownership and lifetime
+ * The returned `EventHandler` owns no listener by itself. The rendering Scope
+ * installs it and removes it; `once` and AbortSignal state are honored for each
+ * input independently. Capture and passive options are conservatively merged.
+ *
+ * ## DOM behavior
+ * The user handler receives a retained `Proxy` around the browser event so a
+ * `preventDefault()` call made while its Effect runs can still cancel the
+ * internal step. The proxy is not identity-equal to the native event. Its
+ * properties—including `currentTarget`—are read from that native event, so
+ * `currentTarget` becomes null after browser dispatch exactly as it normally
+ * does. The internal handler receives the original native event, never the
+ * proxy.
+ *
+ * ## Invocation and Effect sequencing
+ * `userHandler.handler(proxy)` is called first to construct `userEffect`. If
+ * that invocation has already called `preventDefault()`—for example through an
+ * EventHandler option—the internal handler is not invoked. Otherwise,
+ * `internalHandler.handler(nativeEvent)` is called immediately to construct
+ * `internalEffect`, before `userEffect` runs. A void-returning internal callback
+ * therefore performs its callback body eagerly and cannot be undone by a later
+ * `preventDefault()` inside `userEffect`. The composed Effect runs `userEffect`,
+ * checks tracked default prevention again, and only then runs a returned
+ * `internalEffect` when it is still allowed.
+ *
+ * @example
+ * ```ts
+ * import { chainEvent } from "@typed/ui/Dom/Events"
+ * import { EventHandler } from "@typed/template"
+ * import { Effect } from "effect"
+ *
+ * const calls: Array<string> = []
+ * const handler = chainEvent(
+ *   EventHandler.make((event: MouseEvent) =>
+ *     Effect.sync(() => {
+ *       calls.push("user effect")
+ *       event.preventDefault()
+ *     })),
+ *   EventHandler.make(() => {
+ *     calls.push("internal callback") // runs while constructing the Effect
+ *     return Effect.sync(() => calls.push("internal effect"))
+ *   })
+ * )!
+ *
+ * const program = handler.handler(new MouseEvent("click", { cancelable: true }))
+ * // calls is now ["internal callback"]
+ * await Effect.runPromise(program)
+ * // calls is ["internal callback", "user effect"];
+ * // the returned internal Effect was gated by preventDefault.
+ * ```
+ *
+ * @since 1.0.0
+ * @category Event composition
+ */
+export function chainEvent(user, internal) {
+    const userHandler = toEventHandler(user);
+    const internalHandler = toEventHandler(internal);
+    if (!userHandler)
+        return internalHandler;
+    if (!internalHandler)
+        return userHandler;
+    let userActive = true;
+    let internalActive = true;
+    const passive = userHandler.options?.preventDefault === true ||
+        internalHandler.options?.preventDefault === true ||
+        userHandler.options?.passive === false ||
+        internalHandler.options?.passive === false
+        ? false
+        : (userHandler.options?.passive ?? internalHandler.options?.passive);
+    const options = {
+        capture: userHandler.options?.capture ?? internalHandler.options?.capture,
+        passive,
+    };
+    return EventHandler.make((event) => {
+        const tracked = trackPreventDefault(event);
+        const userEffect = userActive && userHandler.options?.signal?.aborted !== true
+            ? userHandler.handler(tracked.event)
+            : Effect.void;
+        if (userActive && userHandler.options?.signal?.aborted !== true) {
+            if (userHandler.options?.once === true)
+                userActive = false;
+        }
+        if (tracked.defaultPrevented() ||
+            !internalActive ||
+            internalHandler.options?.signal?.aborted === true) {
+            return userEffect;
+        }
+        if (internalHandler.options?.once === true)
+            internalActive = false;
+        const internalEffect = internalHandler.handler(event);
+        return Effect.andThen(userEffect, () => tracked.defaultPrevented() ? Effect.void : internalEffect);
+    }, options);
+}
+function trackPreventDefault(event) {
+    let defaultPrevented = event.defaultPrevented;
+    return {
+        event: new Proxy(event, {
+            get(target, property) {
+                if (property === "defaultPrevented")
+                    return defaultPrevented;
+                if (property === "preventDefault") {
+                    return () => {
+                        defaultPrevented = true;
+                        event.preventDefault();
+                    };
+                }
+                const value = Reflect.get(target, property);
+                return typeof value === "function" ? value.bind(target) : value;
+            },
+        }),
+        defaultPrevented: () => defaultPrevented,
+    };
+}
+/**
+ * Tests whether a prop name uses Typed's native event conventions.
+ *
+ * @remarks
+ * ## Why
+ * Host forwarding and merging treat `on*` and `@*` keys as handlers rather
+ * than ordinary attributes.
+ *
+ * ## Ownership and lifetime
+ * Pure predicate; it installs no listener and retains no key.
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export function isEventKey(key) {
+    return key[0] === "@" || (key[0] === "o" && key[1] === "n");
+}
+/**
+ * Reads a native event's non-null current target during handler execution.
+ *
+ * @remarks
+ * ## Why
+ * The DOM types `currentTarget` as nullable because the browser clears it after
+ * dispatch. This helper makes the temporal constraint explicit and preserves a
+ * caller-selected target type.
+ *
+ * ## Ownership and lifetime
+ * The returned target is borrowed from the live dispatch. Do not treat it as a
+ * component-owned node; the helper throws after the handler window closes.
+ *
+ * @example
+ * ```ts
+ * import { currentTarget } from "@typed/ui/Dom/Events"
+ *
+ * const read = (event: Event) => currentTarget<HTMLInputElement>(event).value
+ * ```
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export function currentTarget(event) {
+    if (event.currentTarget === null) {
+        throw new TypeError("An event handler can only read its current target while handling an event");
+    }
+    return event.currentTarget;
+}
+/**
+ * Reads the standards-based `ToggleEvent.newState` value when present.
+ *
+ * @remarks
+ * ## Why
+ * Popover and details components can follow the browser's real toggle event
+ * while remaining usable with DOM libraries whose Event types lag the platform.
+ *
+ * ## Ownership and lifetime
+ * Pure read of the current event; no state or listener is retained.
+ *
+ * @since 1.0.0
+ * @category Event inspection
+ */
+export function toggleState(event) {
+    const value = Reflect.get(event, "newState");
+    return value === "open" || value === "closed" ? value : undefined;
+}
+function toEventHandler(handler) {
+    return handler == null ? undefined : EventHandler.fromEffectOrEventHandler(handler);
+}

package/dist/Dom/Props.d.ts

@@ -0,0 +1,161 @@
+import type { EventHandler, Renderable } from "@typed/template";
+import { type ComposedRef } from "./Refs.js";
+import type { EventHandlerProperty, EventOf, InternalPropsHelpers, Property } from "./Types.js";
+type ObjectValue<Value> = Value extends object ? Value : Record<never, never>;
+type PropsRef<Props> = Property<Props, "ref">;
+type MergedEventKeys<User, Internal> = Extract<keyof ObjectValue<User> | keyof ObjectValue<Internal>, EventHandlerProperty>;
+type MergedEvents<User, Internal> = {
+    readonly [Key in MergedEventKeys<User, Internal>]?: EventHandler.EventHandler<EventOf<Property<User, Key> | Property<Internal, Key>>, Renderable.Error<Property<User, Key> | Property<Internal, Key>>, Renderable.Services<Property<User, Key> | Property<Internal, Key>>>;
+};
+/**
+ * Type-level result of merging user and component-owned host props.
+ *
+ * @remarks
+ * ## Why
+ * Required internal values win, events compose, and refs compose while
+ * unrelated user props pass through unchanged.
+ *
+ * ## Ownership and lifetime
+ * The resulting event/ref work is owned by the host's rendering Scope.
+ *
+ * @since 1.0.0
+ * @category Prop composition
+ */
+export type MergedHostProps<User, Internal> = Omit<ObjectValue<User>, keyof ObjectValue<Internal> | EventHandlerProperty | "ref"> & Omit<ObjectValue<Internal>, EventHandlerProperty | "ref"> & MergedEvents<User, Internal> & {
+    readonly ref?: ComposedRef<PropsRef<Internal>, PropsRef<User>>;
+};
+/**
+ * Option keys forwarded directly to a component host.
+ *
+ * @remarks
+ * ## Why
+ * Top-level refs and events remain ergonomic while other DOM props stay under `props`.
+ *
+ * ## Ownership and lifetime
+ * Type-only; the rendered host owns listener/ref lifetime.
+ *
+ * @since 1.0.0
+ * @category Prop forwarding
+ */
+export type ForwardedHostKeys<Options> = Extract<keyof ObjectValue<Options>, EventHandlerProperty | "ref">;
+/**
+ * Top-level event and ref props selected from component options.
+ *
+ * @remarks
+ * ## Why
+ * Provides the exact forwarded subset used by `renderHost`.
+ *
+ * ## Ownership and lifetime
+ * Type-only; the rendered host owns listener/ref lifetime.
+ *
+ * @since 1.0.0
+ * @category Prop forwarding
+ */
+export type ForwardedHostProps<Options> = Pick<ObjectValue<Options>, ForwardedHostKeys<Options>>;
+/**
+ * User host props after combining nested `props` with top-level refs/events.
+ *
+ * @remarks
+ * ## Why
+ * Gives both supported authoring forms one deterministic merge model.
+ *
+ * ## Ownership and lifetime
+ * Type-only; runtime ownership begins when the host renders.
+ *
+ * @since 1.0.0
+ * @category Prop composition
+ */
+export type HostOptionProps<Options> = MergedHostProps<Property<Options, "props">, ForwardedHostProps<Options>>;
+/**
+ * Final props delivered to a default or custom host renderer.
+ *
+ * @remarks
+ * ## Why
+ * Custom hosts receive the same accessibility, event, disabled, and ref
+ * contract as Typed's default element.
+ *
+ * ## Ownership and lifetime
+ * The rendering Scope owns composed listeners and refs.
+ *
+ * @since 1.0.0
+ * @category Prop composition
+ */
+export type RenderHostProps<Options, Internal> = MergedHostProps<HostOptionProps<Options>, Internal>;
+/**
+ * Merges user host props with component-required internal props.
+ *
+ * @remarks
+ * ## Why
+ * Internal accessibility/state props must remain authoritative, but user
+ * events still run first and may cancel component behavior. Disabled hosts
+ * suppress user activation handlers. Refs compose instead of overwriting one
+ * another.
+ *
+ * ## Ownership and lifetime
+ * The function allocates only a merged object. Listener and ref effects are
+ * run by the eventual template Scope. `composeRefs` rejects two hydration
+ * owners because one element can restore only one hydration protocol.
+ *
+ * @example
+ * ```ts
+ * import { mergeProps } from "@typed/ui/Dom/Props"
+ * import { EventHandler } from "@typed/template"
+ * import { Effect } from "effect"
+ *
+ * const props = mergeProps(
+ *   {
+ *     class: "external",
+ *     onclick: EventHandler.make(() => Effect.log("user activation"))
+ *   },
+ *   { role: "button", "aria-disabled": false }
+ * )
+ * ```
+ *
+ * @since 1.0.0
+ * @category Prop composition
+ */
+export declare function mergeProps<const User extends object | undefined, const Internal extends object>(user: User, internal: Internal): MergedHostProps<User, Internal>;
+/**
+ * Reads a property from an unknown generic value without throwing on nullish input.
+ *
+ * @remarks
+ * ## Why
+ * Generic option construction needs runtime behavior matching the public `Property` type.
+ *
+ * ## Ownership and lifetime
+ * Pure read; no value is retained.
+ *
+ * @since 1.0.0
+ * @category Property inspection
+ */
+export declare function getProperty<const Value, const Key extends PropertyKey>(value: Value, key: Key): Property<Value, Key>;
+/**
+ * Builds typed fallback helpers for component-owned host props.
+ *
+ * @remarks
+ * ## Why
+ * Components can distinguish an absent option from valid falsy values.
+ *
+ * ## Ownership and lifetime
+ * The helper closes over `options` only during synchronous prop construction.
+ *
+ * @since 1.0.0
+ * @category Internal prop defaults
+ */
+export declare function makeInternalPropsHelpers<const Options>(options: Options): InternalPropsHelpers<Options>;
+/**
+ * Extracts top-level refs and event handlers from component options.
+ *
+ * @remarks
+ * ## Why
+ * Convenience event/ref options can enter the same deterministic host merge as `props`.
+ *
+ * ## Ownership and lifetime
+ * Returns a shallow object. The rendering Scope owns any contained listener/ref work.
+ *
+ * @since 1.0.0
+ * @category Prop forwarding
+ */
+export declare function forwardHostProps<const Options extends object>(options: Options): ForwardedHostProps<Options>;
+export {};
+//# sourceMappingURL=Props.d.ts.map

package/dist/Dom/Props.d.ts.map

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