@wirekyt/dom 0.0.1 → 0.0.2

package/dist/index-BdeZuSX6.d.ts

@@ -0,0 +1 @@
+import "./index-CFoN0L3C.js";

package/dist/index-C2865AJq.d.cts

@@ -0,0 +1,25 @@
+//#region src/common/interact-outside/index.d.ts
+interface InteractOutsideHandlers {
+  onPointerDownOutside?: ((event: PointerDownOutsideEvent) => void) | undefined;
+  onFocusOutside?: ((event: FocusOutsideEvent) => void) | undefined;
+  onInteractOutside?: ((event: InteractOutsideEvent) => void) | undefined;
+}
+interface InteractOutsideOptions extends InteractOutsideHandlers {
+  exclude?: ((target: HTMLElement) => boolean) | undefined;
+  defer?: boolean | undefined;
+  followControlledElements?: boolean | undefined;
+}
+interface EventDetails<T> {
+  originalEvent: T;
+  contextmenu: boolean;
+  focusable: boolean;
+  target: EventTarget;
+}
+type PointerDownOutsideEvent = CustomEvent<EventDetails<PointerEvent>>;
+type FocusOutsideEvent = CustomEvent<EventDetails<FocusEvent>>;
+type InteractOutsideEvent = PointerDownOutsideEvent | FocusOutsideEvent;
+type MaybeElement = HTMLElement | null | undefined;
+type NodeOrFn = MaybeElement | (() => MaybeElement);
+declare function trackInteractOutside(nodeOrFn: NodeOrFn, options: InteractOutsideOptions): () => void;
+//#endregion
+export { InteractOutsideOptions as a, PointerDownOutsideEvent as c, InteractOutsideHandlers as i, trackInteractOutside as l, FocusOutsideEvent as n, MaybeElement as o, InteractOutsideEvent as r, NodeOrFn as s, EventDetails as t };

package/dist/index-C2865AJq.d.ts

@@ -0,0 +1,25 @@
+//#region src/common/interact-outside/index.d.ts
+interface InteractOutsideHandlers {
+  onPointerDownOutside?: ((event: PointerDownOutsideEvent) => void) | undefined;
+  onFocusOutside?: ((event: FocusOutsideEvent) => void) | undefined;
+  onInteractOutside?: ((event: InteractOutsideEvent) => void) | undefined;
+}
+interface InteractOutsideOptions extends InteractOutsideHandlers {
+  exclude?: ((target: HTMLElement) => boolean) | undefined;
+  defer?: boolean | undefined;
+  followControlledElements?: boolean | undefined;
+}
+interface EventDetails<T> {
+  originalEvent: T;
+  contextmenu: boolean;
+  focusable: boolean;
+  target: EventTarget;
+}
+type PointerDownOutsideEvent = CustomEvent<EventDetails<PointerEvent>>;
+type FocusOutsideEvent = CustomEvent<EventDetails<FocusEvent>>;
+type InteractOutsideEvent = PointerDownOutsideEvent | FocusOutsideEvent;
+type MaybeElement = HTMLElement | null | undefined;
+type NodeOrFn = MaybeElement | (() => MaybeElement);
+declare function trackInteractOutside(nodeOrFn: NodeOrFn, options: InteractOutsideOptions): () => void;
+//#endregion
+export { InteractOutsideOptions as a, PointerDownOutsideEvent as c, InteractOutsideHandlers as i, trackInteractOutside as l, FocusOutsideEvent as n, MaybeElement as o, InteractOutsideEvent as r, NodeOrFn as s, EventDetails as t };

package/dist/index-CFoN0L3C.d.ts

@@ -0,0 +1,285 @@
+import { B as isActiveElement } from "./index-vPrqYDHu.js";
+//#region src/common/core/merge-props.d.ts
+interface Props {
+  [key: string | symbol]: any;
+}
+type TupleTypes<T extends any[]> = T[number];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+declare function mergeProps<T extends Props>(...args: Array<T | undefined>): UnionToIntersection<TupleTypes<T[]>>;
+//#endregion
+//#region src/common/core/memo.d.ts
+type NoInfer<T> = [T][T extends any ? 0 : never];
+declare function memo<TDeps extends any[], TDepArgs, TResult>(getDeps: (depArgs: TDepArgs) => [...TDeps], fn: (args: NoInfer<[...TDeps]>, deps: TDepArgs) => TResult, opts?: {
+  onChange?: ((result: TResult) => void) | undefined;
+}): (depArgs: TDepArgs) => TResult;
+//#endregion
+//#region src/common/core/types.d.ts
+type Dict = Record<string, any>;
+interface ComputedParams<T extends Dict> {
+  context: BindableContext<T>;
+  event: EventType<T["event"]>;
+  prop: PropFn<T>;
+  refs: BindableRefs<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+}
+interface ContextParams<T extends Dict> {
+  prop: PropFn<T>;
+  bindable: BindableFn;
+  scope: Scope;
+  getContext: () => BindableContext<T>;
+  getComputed: () => ComputedFn<T>;
+  getRefs: () => BindableRefs<T>;
+  getEvent: () => EventType<T["event"]>;
+  flush: (fn: VoidFunction) => void;
+}
+interface PropFn<T extends Dict> {
+  <K extends keyof T["props"]>(key: K): T["props"][K];
+}
+interface ComputedFn<T extends Dict> {
+  <K extends keyof T["computed"]>(key: K): T["computed"][K];
+}
+type AnyFunction = () => string | number | boolean | null | undefined;
+type TrackFn = (deps: AnyFunction[], fn: VoidFunction) => void;
+interface BindableParams<T> {
+  defaultValue?: T | undefined;
+  value?: T | undefined;
+  hash?: ((a: T) => string) | undefined;
+  isEqual?: ((a: T, b: T | undefined) => boolean) | undefined;
+  onChange?: ((value: T, prev: T | undefined) => void) | undefined;
+  debug?: string | undefined;
+  sync?: boolean | undefined;
+}
+type ValueOrFn<T> = T | ((prev: T) => T);
+interface Bindable<T> {
+  initial: T | undefined;
+  ref: any;
+  get: () => T;
+  set(value: ValueOrFn<T>): void;
+  invoke(nextValue: T, prevValue: T): void;
+  hash(value: T): string;
+}
+interface BindableRefs<T extends Dict> {
+  set<K extends keyof T["refs"]>(key: K, value: T["refs"][K]): void;
+  get<K extends keyof T["refs"]>(key: K): T["refs"][K];
+}
+interface BindableContext<T extends Dict> {
+  set<K extends keyof T["context"]>(key: K, value: ValueOrFn<T["context"][K]>): void;
+  get<K extends keyof T["context"]>(key: K): T["context"][K];
+  initial<K extends keyof T["context"]>(key: K): T["context"][K];
+  hash<K extends keyof T["context"]>(key: K): string;
+}
+interface BindableRef<T> {
+  get: () => T;
+  set: (next: T) => void;
+}
+interface BindableFn {
+  <K>(params: () => BindableParams<K>): Bindable<K>;
+  cleanup: (fn: VoidFunction) => void;
+  ref: <T>(defaultValue: T) => BindableRef<T>;
+}
+interface Scope {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode: () => ShadowRoot | Document | Element;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: (elem: HTMLElement | null) => boolean;
+  getDoc: () => typeof document;
+  getWin: () => typeof window;
+}
+type EventType<T = any> = T & {
+  previousEvent?: (T & {
+    [key: string]: any;
+  }) | undefined;
+  src?: string | undefined;
+  [key: string]: any;
+};
+type EventObject = EventType<{
+  type: string;
+}>;
+interface Params<T extends Dict> {
+  prop: PropFn<T>;
+  action: (action: T["action"][]) => void;
+  context: BindableContext<T>;
+  refs: BindableRefs<T>;
+  track: TrackFn;
+  flush: (fn: VoidFunction) => void;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+  send: (event: EventType<T["event"]>) => void;
+  computed: ComputedFn<T>;
+  scope: Scope;
+  state: Bindable<T["state"]> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  choose: ChooseFn<T>;
+  guard: (key: T["guard"] | GuardFn<T>) => boolean | undefined;
+}
+type GuardFn<T extends Dict> = (params: Params<T>) => boolean;
+type TopLevelState<S extends string> = S extends `${infer Top}.${string}` ? Top : S;
+type ChildStateKey<S extends string, Parent extends string> = S extends `${Parent}.${infer Rest}` ? Rest extends `${infer Child}.${string}` ? Child : Rest : never;
+type ParentPath<S extends string> = S extends `${infer Parent}.${string}` ? Parent : never;
+type AncestorPaths<S extends string> = S | (ParentPath<S> extends never ? never : AncestorPaths<ParentPath<S>>);
+type StateIdTarget = `#${string}`;
+type SiblingStateTarget<S extends string, Source extends string> = TopLevelState<S> | ChildStateKey<S, Exclude<AncestorPaths<Source>, Source>>;
+type ChildStateTarget<S extends string, Source extends string> = `.${ChildStateKey<S, Source>}`;
+interface Transition<T extends Dict, Source extends string | undefined = string | undefined> {
+  target?: T["state"] | StateIdTarget | (Source extends string ? SiblingStateTarget<T["state"], Source> : never) | (Source extends string ? ChildStateTarget<T["state"], Source> : never) | undefined;
+  actions?: T["action"][] | undefined;
+  guard?: T["guard"] | GuardFn<T> | undefined;
+  reenter?: boolean | undefined;
+}
+type TransitionSet<T extends Dict> = Transition<T> | Transition<T>[] | undefined;
+type TransitionMap<T extends Dict> = Record<string, TransitionSet<T>>;
+type TransitionMatch<T extends Dict> = {
+  transitions: TransitionSet<T>;
+  source: string | undefined;
+};
+type MaybeArray<T> = T | T[];
+type ChooseFn<T extends Dict> = (transitions: MaybeArray<Omit<Transition<T, string>, "target">> | null | undefined) => Transition<T> | undefined;
+interface PropsParams<T extends Dict> {
+  props: Partial<T["props"]>;
+  scope: Scope;
+}
+interface RefsParams<T extends Dict> {
+  prop: PropFn<T>;
+  context: BindableContext<T>;
+}
+type ActionsOrFn<T extends Dict> = T["action"][] | ((params: Params<T>) => T["action"][] | undefined);
+type EffectsOrFn<T extends Dict> = T["effect"][] | ((params: Params<T>) => T["effect"][] | undefined);
+interface MachineState<T extends Dict, Parent extends string = string> {
+  id?: string | undefined;
+  tags?: T["tag"][] | undefined;
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  initial?: ChildStateKey<T["state"], Parent> | undefined;
+  states?: { [K in ChildStateKey<T["state"], Parent>]?: MachineState<T, `${Parent}.${K}`>; } | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T, Parent> | Array<Transition<T, Parent>>; } | undefined;
+}
+interface Machine<T extends Dict> {
+  debug?: boolean | undefined;
+  props?: ((params: PropsParams<T>) => T["props"]) | undefined;
+  context?: ((params: ContextParams<T>) => { [K in keyof T["context"]]: Bindable<T["context"][K]>; }) | undefined;
+  computed?: { [K in keyof T["computed"]]: (params: ComputedParams<T>) => T["computed"][K]; } | undefined;
+  initialState: (params: {
+    prop: PropFn<T>;
+  }) => T["state"];
+  entry?: ActionsOrFn<T> | undefined;
+  exit?: ActionsOrFn<T> | undefined;
+  effects?: EffectsOrFn<T> | undefined;
+  refs?: ((params: RefsParams<T>) => T["refs"]) | undefined;
+  watch?: ((params: Params<T>) => void) | undefined;
+  on?: { [E in T["event"]["type"]]?: Transition<T, undefined> | Array<Transition<T, undefined>>; } | undefined;
+  states: { [K in TopLevelState<T["state"]>]: MachineState<T, K>; };
+  implementations?: {
+    guards?: { [K in T["guard"]]: (params: Params<T>) => boolean; } | undefined;
+    actions?: { [K in T["action"]]: (params: Params<T>) => void; } | undefined;
+    effects?: { [K in T["effect"]]: (params: Params<T>) => void | VoidFunction; } | undefined;
+  } | undefined;
+}
+interface MachineBaseProps {
+  id?: string | undefined;
+  ids?: Record<string, any> | undefined;
+  getRootNode?: (() => ShadowRoot | Document | Node) | undefined;
+  [key: string]: any;
+}
+interface MachineSchema {
+  props?: MachineBaseProps | undefined;
+  context?: Record<string, any> | undefined;
+  refs?: Record<string, any> | undefined;
+  computed?: Record<string, any> | undefined;
+  state?: string | undefined;
+  tag?: string | undefined;
+  guard?: string | undefined;
+  action?: string | undefined;
+  effect?: string | undefined;
+  event?: ({
+    type: string;
+  } & Dict) | undefined;
+}
+type State<T extends MachineSchema> = Bindable<T["state"]> & {
+  hasTag: (tag: T["tag"]) => boolean;
+  matches: (...values: T["state"][]) => boolean;
+};
+type Service<T extends MachineSchema> = {
+  getStatus: () => MachineStatus;
+  state: State<T> & {
+    matches: (...values: T["state"][]) => boolean;
+    hasTag: (tag: T["tag"]) => boolean;
+  };
+  context: BindableContext<T>;
+  send: (event: EventType<T["event"]>) => void;
+  prop: PropFn<T>;
+  scope: Scope;
+  computed: ComputedFn<T>;
+  refs: BindableRefs<T>;
+  event: EventType<T["event"]> & {
+    current: () => EventType<T["event"]>;
+    previous: () => EventType<T["event"]>;
+  };
+};
+declare enum MachineStatus {
+  NotStarted = "Not Started",
+  Started = "Started",
+  Stopped = "Stopped"
+}
+declare const INIT_STATE = "__init__";
+//#endregion
+//#region src/common/core/create-machine.d.ts
+declare function createGuards<T extends MachineSchema>(): {
+  and: (...guards: Array<GuardFn<T> | T["guard"]>) => (params: any) => boolean;
+  or: (...guards: Array<GuardFn<T> | T["guard"]>) => (params: any) => boolean;
+  not: (guard: GuardFn<T> | T["guard"]) => (params: any) => boolean;
+};
+declare function createMachine<T extends MachineSchema>(config: Machine<T>): Machine<T>;
+declare function setup<T extends MachineSchema>(): {
+  guards: {
+    and: (...guards: (GuardFn<T> | T["guard"])[]) => (params: any) => boolean;
+    or: (...guards: (GuardFn<T> | T["guard"])[]) => (params: any) => boolean;
+    not: (guard: GuardFn<T> | T["guard"]) => (params: any) => boolean;
+  };
+  createMachine: (config: Machine<T>) => Machine<T>;
+  choose: (transitions: Transition<T> | Transition<T>[]) => ({ choose }: Params<T>) => T["action"][] | undefined;
+};
+//#endregion
+//#region src/common/core/state.d.ts
+declare function ensureStateIndex<T extends MachineSchema>(machine: Machine<T>): Map<string, MachineState<T, string>>;
+type StateChain<T extends MachineSchema> = Array<{
+  path: string;
+  state: MachineState<T>;
+}>;
+declare function getStateChain<T extends MachineSchema>(machine: Machine<T>, state: T["state"] | undefined): StateChain<T>;
+declare function resolveStateValue<T extends MachineSchema>(machine: Machine<T>, value: T["state"] | string, source?: string): T["state"];
+declare function getStateDefinition<T extends MachineSchema>(machine: Machine<T>, state: T["state"]): MachineState<T, string>;
+declare function findTransition<T extends MachineSchema>(machine: Machine<T>, state: T["state"], eventType: string): TransitionMatch<T>;
+declare function getExitEnterStates<T extends MachineSchema>(machine: Machine<T>, prevState: T["state"] | undefined, nextState: T["state"], reenter?: boolean): {
+  exiting: {
+    path: string;
+    state: MachineState<T, string>;
+  }[];
+  entering: {
+    path: string;
+    state: MachineState<T, string>;
+  }[];
+};
+declare function matchesState(current: string | undefined, value: string): boolean;
+declare function hasTag<T extends MachineSchema>(machine: Machine<T>, state: T["state"], tag: T["tag"]): boolean;
+//#endregion
+//#region src/common/core/scope.d.ts
+declare function createScope(props: Pick<Scope, "id" | "ids" | "getRootNode">): {
+  getRootNode: () => Document | ShadowRoot;
+  getDoc: () => Document;
+  getWin: () => Window & typeof globalThis;
+  getActiveElement: () => HTMLElement | null;
+  isActiveElement: typeof isActiveElement;
+  getById: <T extends Element = HTMLElement>(id: string) => T | null;
+  id?: string | undefined | undefined;
+  ids?: Record<string, any> | undefined;
+};
+//#endregion
+export { PropFn as A, GuardFn as C, MachineState as D, MachineSchema as E, TransitionMatch as F, TransitionSet as I, ValueOrFn as L, Service as M, Transition as N, MachineStatus as O, TransitionMap as P, memo as R, EventObject as S, Machine as T, BindableParams as _, getStateChain as a, ComputedFn as b, matchesState as c, createMachine as d, setup as f, BindableFn as g, BindableContext as h, getExitEnterStates as i, Scope as j, Params as k, resolveStateValue as l, Bindable as m, ensureStateIndex as n, getStateDefinition as o, ActionsOrFn as p, findTransition as r, hasTag as s, createScope as t, createGuards as u, BindableRefs as v, INIT_STATE as w, EffectsOrFn as x, ChooseFn as y, mergeProps as z };

package/dist/index-vPrqYDHu.d.ts

@@ -0,0 +1,216 @@
+import { S as JSX, c as MaybeFn, u as Nullable } from "./index-BXfunVyD.js";
+//#region src/common/dom-query/types.d.ts
+type Booleanish = boolean | "true" | "false";
+interface Point {
+  x: number;
+  y: number;
+}
+interface EventKeyOptions {
+  dir?: "ltr" | "rtl" | undefined;
+  orientation?: "horizontal" | "vertical" | undefined;
+}
+type NativeEvent<E> = JSX.ChangeEvent<any> extends E ? InputEvent : E extends JSX.SyntheticEvent<any, infer T> ? T : never;
+type AnyPointerEvent = MouseEvent | TouchEvent | PointerEvent;
+type MaybeElement = Nullable<HTMLElement>;
+type MaybeElementOrFn = MaybeFn<MaybeElement>;
+type HTMLElementWithValue = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+//#endregion
+//#region src/common/dom-query/event.d.ts
+declare function getBeforeInputValue(event: Pick<InputEvent, "currentTarget">): string;
+declare function getEventTarget<T extends EventTarget>(event: Partial<Pick<UIEvent, "target" | "composedPath">>): T | null;
+declare function isOpeningInNewTab(event: Pick<MouseEvent, "currentTarget" | "metaKey" | "ctrlKey" | "button">): boolean;
+declare function isDownloadingEvent(event: Pick<MouseEvent, "altKey" | "currentTarget">): boolean;
+declare function isComposingEvent(event: any): boolean;
+declare function isKeyboardClick(e: Pick<MouseEvent, "detail" | "clientX" | "clientY">): boolean;
+declare function isCtrlOrMetaKey(e: Pick<KeyboardEvent, "ctrlKey" | "metaKey">): boolean;
+declare function isPrintableKey(e: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey">): boolean;
+declare function isVirtualPointerEvent(e: PointerEvent): boolean;
+declare function isVirtualClick(e: MouseEvent | PointerEvent): boolean;
+declare const isLeftClick: (e: Pick<MouseEvent, "button">) => boolean;
+declare const isContextMenuEvent: (e: Pick<MouseEvent, "button" | "ctrlKey" | "metaKey">) => boolean;
+declare const isModifierKey: (e: Pick<KeyboardEvent, "ctrlKey" | "metaKey" | "altKey">) => boolean;
+declare const isTouchEvent: (event: AnyPointerEvent) => event is TouchEvent;
+declare function getEventKey(event: Pick<KeyboardEvent, "key">, options?: EventKeyOptions): string;
+declare function getNativeEvent<E>(event: E): NativeEvent<E>;
+declare function getEventStep(event: Pick<KeyboardEvent, "key" | "shiftKey">): 1 | 10;
+interface EventStepOptions {
+  step: number;
+  largeStep: number;
+  smallStep?: number | undefined;
+}
+declare function getEventStepValue(event: Pick<KeyboardEvent, "key" | "shiftKey" | "altKey">, options: EventStepOptions): number;
+declare function getEventPoint(event: any, type?: "page" | "client"): {
+  x: number;
+  y: number;
+};
+interface DOMEventMap extends DocumentEventMap, WindowEventMap, HTMLElementEventMap {}
+declare const addDomEvent: <K extends keyof DOMEventMap>(target: MaybeFn<EventTarget | null>, eventName: K | (string & {}), handler: (event: DOMEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => () => void;
+declare const isSelfTarget: (event: Partial<Pick<UIEvent, "currentTarget" | "target" | "composedPath">>) => boolean;
+//#endregion
+//#region src/common/dom-query/form.d.ts
+declare function setElementValue(el: HTMLElementWithValue | null, value: string, property?: "value" | "checked"): void;
+declare function setElementChecked(el: HTMLInputElement | null, checked: boolean): void;
+interface InputValueEventOptions {
+  value: string | number;
+  bubbles?: boolean | undefined;
+}
+declare function dispatchInputValueEvent(el: HTMLElementWithValue | null, options: InputValueEventOptions): void;
+interface CheckedEventOptions {
+  checked: boolean;
+  bubbles?: boolean | undefined;
+}
+declare function dispatchInputCheckedEvent(el: HTMLInputElement | null, options: CheckedEventOptions): void;
+interface TrackFormControlOptions {
+  onFieldsetDisabledChange: (disabled: boolean) => void;
+  onFormReset: VoidFunction;
+}
+declare function trackFormControl(el: HTMLElement | null, options: TrackFormControlOptions): (() => void) | undefined;
+declare const INTERNAL_CHANGE_EVENT: unique symbol;
+type InternalChangeEventProps = {
+  [INTERNAL_CHANGE_EVENT]?: boolean;
+};
+declare function isInternalChangeEvent<T extends Event>(e: T): e is T & InternalChangeEventProps;
+declare function markAsInternalChangeEvent<T extends Event>(event: T): T & InternalChangeEventProps;
+//#endregion
+//#region src/common/dom-query/mutation-observer.d.ts
+interface ObserveAttributeOptions {
+  attributes: string[];
+  callback(record: MutationRecord): void;
+  defer?: boolean | undefined;
+}
+declare function observeAttributes(nodeOrFn: MaybeElementOrFn, options: ObserveAttributeOptions): () => void;
+interface ObserveChildrenOptions {
+  callback: MutationCallback;
+  defer?: boolean | undefined;
+}
+declare function observeChildren(nodeOrFn: MaybeElementOrFn, options: ObserveChildrenOptions): () => void;
+//#endregion
+//#region src/common/dom-query/node.d.ts
+declare const isElement: (el: any) => el is Element;
+declare const isHTMLElement: (el: any) => el is HTMLElement;
+declare const isDocument: (el: any) => el is Document;
+declare const isWindow: (el: any) => el is Window;
+declare const isVisualViewport: (el: any) => el is VisualViewport;
+declare const getNodeName: (node: Node | Window) => string;
+declare function isRootElement(node: Node): boolean;
+declare const isNode: (el: any) => el is Node;
+declare const isShadowRoot: (el: any) => el is ShadowRoot;
+declare const isInputElement: (el: any) => el is HTMLInputElement;
+declare const isAnchorElement: (el: HTMLElement | null | undefined) => el is HTMLAnchorElement;
+declare const isElementVisible: (el: Node) => boolean;
+declare function isActiveElement(element: Element | null | undefined): boolean;
+declare function isEditableElement(el: HTMLElement | EventTarget | null): boolean;
+type Target = HTMLElement | EventTarget | null | undefined;
+declare function getParentElement(node: Element): Element | null;
+declare function getAncestorElements(node: Element | null): Element[];
+declare function contains(parent: Target, child: Target): boolean;
+declare function getDocument(el: Element | Window | Node | Document | null | undefined): Document;
+declare function getDocumentElement(el: Element | Node | Window | Document | null | undefined): HTMLElement;
+declare function getWindow(el: Node | ShadowRoot | Document | null | undefined): Window & typeof globalThis;
+declare function getActiveElement(rootNode: Document | ShadowRoot): HTMLElement | null;
+declare function getParentNode(node: Node): Node;
+declare function getRootNode(node: Node): Document | ShadowRoot;
+//#endregion
+//#region src/common/dom-query/point.d.ts
+interface PercentValueOptions {
+  inverted?: boolean | {
+    x?: boolean | undefined;
+    y?: boolean | undefined;
+  } | undefined;
+  dir?: "ltr" | "rtl" | undefined;
+  orientation?: "vertical" | "horizontal" | undefined;
+}
+declare function getRelativePoint(point: Point, element: HTMLElement): {
+  offset: {
+    x: number;
+    y: number;
+  };
+  percent: {
+    x: number;
+    y: number;
+  };
+  getPercentValue: (options?: PercentValueOptions) => number;
+};
+//#endregion
+//#region src/common/dom-query/pointer-move.d.ts
+interface PointerMoveDetails {
+  point: Point;
+  event: PointerEvent;
+}
+interface PointerUpDetails {
+  point: Point;
+  event: PointerEvent;
+}
+interface PointerMoveHandlers {
+  onPointerUp: (details: PointerUpDetails) => void;
+  onPointerMove: (details: PointerMoveDetails) => void;
+}
+declare function trackPointerMove(doc: Document, handlers: PointerMoveHandlers): () => void;
+//#endregion
+//#region src/common/dom-query/press.d.ts
+interface PressDetails {
+  point: Point;
+  event: PointerEvent;
+}
+interface TrackPressOptions {
+  pointerNode: Element | null;
+  keyboardNode?: Element | null | undefined;
+  isValidKey?(event: KeyboardEvent): boolean;
+  onPress?(details: PressDetails): void;
+  onPressStart?(details: PressDetails): void;
+  onPressEnd?(details: PressDetails): void;
+}
+declare function trackPress(options: TrackPressOptions): () => void;
+//#endregion
+//#region src/common/dom-query/tabbable.d.ts
+type IncludeContainerType = boolean | "if-empty";
+type GetShadowRootOption = boolean | ((node: HTMLElement) => ShadowRoot | boolean | undefined) | undefined;
+interface TabbableOptions {
+  includeContainer?: IncludeContainerType;
+  getShadowRoot?: GetShadowRootOption;
+}
+interface NextTabbableOptions {
+  current?: HTMLElement | undefined | null;
+  getShadowRoot?: GetShadowRootOption;
+}
+declare const getFocusables: (container: Pick<HTMLElement, "querySelectorAll"> | null, options?: TabbableOptions) => HTMLElement[];
+declare function isFocusable(element: HTMLElement | EventTarget | null): element is HTMLElement;
+declare function getFirstFocusable(container: HTMLElement | null, options?: TabbableOptions): HTMLElement | null;
+declare function getTabbables(container: HTMLElement | null, options?: TabbableOptions): HTMLElement[];
+declare function isTabbable(el: HTMLElement | EventTarget | null): el is HTMLElement;
+declare function getFirstTabbable(container: HTMLElement | null, options?: TabbableOptions): HTMLElement | null;
+declare function getLastTabbable(container: HTMLElement | null, options?: TabbableOptions): HTMLElement | null;
+declare function getTabbableEdges(container: HTMLElement | null, options?: TabbableOptions): [HTMLElement, HTMLElement] | [null, null];
+declare function getNextTabbable(container: HTMLElement | null, options?: NextTabbableOptions): HTMLElement | null;
+declare function getTabIndex(node: HTMLElement | SVGElement): number;
+//#endregion
+//#region src/common/dom-query/proxy-tab-focus.d.ts
+interface ProxyTabFocusOptions<T = MaybeElement> {
+  triggerElement?: T | undefined;
+  onFocus?: ((elementToFocus: HTMLElement) => void) | undefined;
+  onFocusEnter?: VoidFunction | undefined;
+  defer?: boolean | undefined;
+  getShadowRoot?: GetShadowRootOption | undefined;
+}
+declare function proxyTabFocus(container: MaybeElementOrFn, options: ProxyTabFocusOptions<MaybeElementOrFn>): () => void;
+//#endregion
+//#region src/common/dom-query/scope.d.ts
+interface ScopeContext {
+  getRootNode?: (() => Document | ShadowRoot | Node) | undefined;
+}
+declare function createScope<T>(methods: T): {
+  getRootNode: (ctx: ScopeContext) => Document | ShadowRoot;
+  getDoc: (ctx: ScopeContext) => Document;
+  getWin: (ctx: ScopeContext) => Window & typeof globalThis;
+  getActiveElement: (ctx: ScopeContext) => HTMLElement | null;
+  isActiveElement: typeof isActiveElement;
+  getById: <T_1 extends Element = HTMLElement>(ctx: ScopeContext, id: string) => T_1 | null;
+  setValue: <T_1 extends HTMLElementWithValue>(elem: T_1 | null, value: string | number | null | undefined) => void;
+} & T;
+//#endregion
+//#region src/common/dom-query/shared.d.ts
+declare const MAX_Z_INDEX = 2147483647;
+declare const dataAttr: (guard: boolean | undefined) => Booleanish;
+declare const ariaAttr: (guard: boolean | undefined) => "true" | undefined;
+//#endregion
+export { ObserveAttributeOptions as $, contains as A, isSelfTarget as At, isActiveElement as B, trackPress as C, isCtrlOrMetaKey as Ct, trackPointerMove as D, isModifierKey as Dt, PointerUpDetails as E, isLeftClick as Et, getNodeName as F, isElementVisible as G, isDocument as H, getParentElement as I, isNode as J, isHTMLElement as K, getParentNode as L, getAncestorElements as M, isVirtualClick as Mt, getDocument as N, isVirtualPointerEvent as Nt, PercentValueOptions as O, isOpeningInNewTab as Ot, getDocumentElement as P, Booleanish as Pt, isWindow as Q, getRootNode as R, TrackPressOptions as S, isContextMenuEvent as St, PointerMoveHandlers as T, isKeyboardClick as Tt, isEditableElement as U, isAnchorElement as V, isElement as W, isShadowRoot as X, isRootElement as Y, isVisualViewport as Z, getTabbableEdges as _, getEventStep as _t, createScope as a, TrackFormControlOptions as at, isTabbable as b, getNativeEvent as bt, GetShadowRootOption as c, isInternalChangeEvent as ct, getFirstFocusable as d, setElementValue as dt, ObserveChildrenOptions as et, getFirstTabbable as f, trackFormControl as ft, getTabIndex as g, getEventPoint as gt, getNextTabbable as h, getEventKey as ht, ScopeContext as i, InputValueEventOptions as it, getActiveElement as j, isTouchEvent as jt, getRelativePoint as k, isPrintableKey as kt, NextTabbableOptions as l, markAsInternalChangeEvent as lt, getLastTabbable as m, getBeforeInputValue as mt, ariaAttr as n, observeChildren as nt, ProxyTabFocusOptions as o, dispatchInputCheckedEvent as ot, getFocusables as p, addDomEvent as pt, isInputElement as q, dataAttr as r, CheckedEventOptions as rt, proxyTabFocus as s, dispatchInputValueEvent as st, MAX_Z_INDEX as t, observeAttributes as tt, TabbableOptions as u, setElementChecked as ut, getTabbables as v, getEventStepValue as vt, PointerMoveDetails as w, isDownloadingEvent as wt, PressDetails as x, isComposingEvent as xt, isFocusable as y, getEventTarget as yt, getWindow as z };

package/dist/index.cjs

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_core = require("./core-BNMw-JId.cjs");
+const require_types = require("./types-HCvp3Bhv.cjs");
+exports.INIT_STATE = require_types.INIT_STATE;
+exports.MachineStatus = require_types.MachineStatus;
+exports.createGuards = require_core.createGuards;
+exports.createMachine = require_core.createMachine;
+exports.createScope = require_core.createScope;
+exports.ensureStateIndex = require_core.ensureStateIndex;
+exports.findTransition = require_core.findTransition;
+exports.getExitEnterStates = require_core.getExitEnterStates;
+exports.getStateChain = require_core.getStateChain;
+exports.getStateDefinition = require_core.getStateDefinition;
+exports.hasTag = require_core.hasTag;
+exports.matchesState = require_core.matchesState;
+exports.memo = require_core.memo;
+exports.mergeProps = require_core.mergeProps;
+exports.resolveStateValue = require_core.resolveStateValue;
+exports.setup = require_core.setup;

package/dist/index.d.cts

@@ -0,0 +1,3 @@
+import { A as PropFn, C as GuardFn, D as MachineState, E as MachineSchema, F as TransitionMatch, I as TransitionSet, L as ValueOrFn, M as Service, N as Transition, O as MachineStatus, P as TransitionMap, R as memo, S as EventObject, T as Machine, _ as BindableParams, a as getStateChain, b as ComputedFn, c as matchesState, d as createMachine, f as setup, g as BindableFn, h as BindableContext, i as getExitEnterStates, j as Scope, k as Params, l as resolveStateValue, m as Bindable, n as ensureStateIndex, o as getStateDefinition, p as ActionsOrFn, r as findTransition, s as hasTag, t as createScope, u as createGuards, v as BindableRefs, w as INIT_STATE, x as EffectsOrFn, y as ChooseFn, z as mergeProps } from "./index-BKgxIVbE.cjs";
+import "./index-BF6G2RiC.cjs";
+export { ActionsOrFn, Bindable, BindableContext, BindableFn, BindableParams, BindableRefs, ChooseFn, ComputedFn, EffectsOrFn, EventObject, GuardFn, INIT_STATE, Machine, MachineSchema, MachineState, MachineStatus, Params, PropFn, Scope, Service, Transition, TransitionMap, TransitionMatch, TransitionSet, ValueOrFn, createGuards, createMachine, createScope, ensureStateIndex, findTransition, getExitEnterStates, getStateChain, getStateDefinition, hasTag, matchesState, memo, mergeProps, resolveStateValue, setup };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { A as PropFn, C as GuardFn, D as MachineState, E as MachineSchema, F as TransitionMatch, I as TransitionSet, L as ValueOrFn, M as Service, N as Transition, O as MachineStatus, P as TransitionMap, R as memo, S as EventObject, T as Machine, _ as BindableParams, a as getStateChain, b as ComputedFn, c as matchesState, d as createMachine, f as setup, g as BindableFn, h as BindableContext, i as getExitEnterStates, j as Scope, k as Params, l as resolveStateValue, m as Bindable, n as ensureStateIndex, o as getStateDefinition, p as ActionsOrFn, r as findTransition, s as hasTag, t as createScope, u as createGuards, v as BindableRefs, w as INIT_STATE, x as EffectsOrFn, y as ChooseFn, z as mergeProps } from "./index-CFoN0L3C.js";
+import "./index-BdeZuSX6.js";
+export { ActionsOrFn, Bindable, BindableContext, BindableFn, BindableParams, BindableRefs, ChooseFn, ComputedFn, EffectsOrFn, EventObject, GuardFn, INIT_STATE, Machine, MachineSchema, MachineState, MachineStatus, Params, PropFn, Scope, Service, Transition, TransitionMap, TransitionMatch, TransitionSet, ValueOrFn, createGuards, createMachine, createScope, ensureStateIndex, findTransition, getExitEnterStates, getStateChain, getStateDefinition, hasTag, matchesState, memo, mergeProps, resolveStateValue, setup };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { a as ensureStateIndex, c as getStateChain, d as matchesState, f as resolveStateValue, i as setup, l as getStateDefinition, m as mergeProps, n as createGuards, o as findTransition, p as memo, r as createMachine, s as getExitEnterStates, t as createScope, u as hasTag } from "./core-CJ0MZr3D.js";
+import { n as MachineStatus, t as INIT_STATE } from "./types-BFuHIo7S.js";
+export { INIT_STATE, MachineStatus, createGuards, createMachine, createScope, ensureStateIndex, findTransition, getExitEnterStates, getStateChain, getStateDefinition, hasTag, matchesState, memo, mergeProps, resolveStateValue, setup };

package/dist/initial-focus-BQxRRFPa.cjs

@@ -0,0 +1,37 @@
+const require_dom_query = require("./dom-query-CQzY93XU.cjs");
+const require_tabbable = require("./tabbable-Bz1-1GAY.cjs");
+//#region src/common/dom-query/initial-focus.ts
+function getInitialFocus(options) {
+	const { root, getInitialEl, filter, enabled = true } = options;
+	if (!enabled) return;
+	let node = null;
+	node ||= typeof getInitialEl === "function" ? getInitialEl() : getInitialEl;
+	node ||= root?.querySelector("[data-autofocus],[autofocus]");
+	if (!node) {
+		const tabbables = require_tabbable.getTabbables(root);
+		node = filter ? tabbables.filter(filter)[0] : tabbables[0];
+	}
+	return node || root || void 0;
+}
+function isValidTabEvent(event) {
+	const container = event.currentTarget;
+	if (!container) return false;
+	const [firstTabbable, lastTabbable] = require_tabbable.getTabbableEdges(container);
+	if (require_dom_query.isActiveElement(firstTabbable) && event.shiftKey) return false;
+	if (require_dom_query.isActiveElement(lastTabbable) && !event.shiftKey) return false;
+	if (!firstTabbable && !lastTabbable) return false;
+	return true;
+}
+//#endregion
+Object.defineProperty(exports, "getInitialFocus", {
+	enumerable: true,
+	get: function() {
+		return getInitialFocus;
+	}
+});
+Object.defineProperty(exports, "isValidTabEvent", {
+	enumerable: true,
+	get: function() {
+		return isValidTabEvent;
+	}
+});

package/dist/initial-focus-BrN5tT2X.js

@@ -0,0 +1,26 @@
+import { C as isActiveElement } from "./dom-query-e7fh0TEH.js";
+import { c as getTabbables, s as getTabbableEdges } from "./tabbable-CDA1YMjZ.js";
+//#region src/common/dom-query/initial-focus.ts
+function getInitialFocus(options) {
+	const { root, getInitialEl, filter, enabled = true } = options;
+	if (!enabled) return;
+	let node = null;
+	node ||= typeof getInitialEl === "function" ? getInitialEl() : getInitialEl;
+	node ||= root?.querySelector("[data-autofocus],[autofocus]");
+	if (!node) {
+		const tabbables = getTabbables(root);
+		node = filter ? tabbables.filter(filter)[0] : tabbables[0];
+	}
+	return node || root || void 0;
+}
+function isValidTabEvent(event) {
+	const container = event.currentTarget;
+	if (!container) return false;
+	const [firstTabbable, lastTabbable] = getTabbableEdges(container);
+	if (isActiveElement(firstTabbable) && event.shiftKey) return false;
+	if (isActiveElement(lastTabbable) && !event.shiftKey) return false;
+	if (!firstTabbable && !lastTabbable) return false;
+	return true;
+}
+//#endregion
+export { isValidTabEvent as n, getInitialFocus as t };