@bquery/bquery 1.5.0 → 1.7.0

package/dist/index.es.mjs

@@ -1,145 +1,240 @@
-import { a, c as e, i as t, n as i, o as r, r as o, s as n, t as c } from "./sanitize-jyJ2ryE2.js";
-import { A as u, C as p, D as l, E as f, F as g, I as d, L as C, M as S, N as y, O as b, P as h, R as k, S as P, T as O, _ as A, a as E, b as T, c as v, d as w, f as x, g as B, h as I, i as R, j as D, k as Q, l as q, m as F, n as H, o as N, p as j, r as z, s as L, t as M, u as $, v as _, w as G, x as J, y as K } from "./core-CK2Mfpf4.js";
-import { a as V, i as W, n as X, o as Y, r as Z, t as ss } from "./object-qGpWr6-J.js";
-import { n as es, r as ts, t as is } from "./core-DPdbItcq.js";
-import { a as os, c as ns, d as cs, f as ms, i as us, l as ps, n as ls, o as fs, p as gs, r as ds, s as Cs, t as Ss, u as ys } from "./reactive-BDya-ia8.js";
-import { n as hs, t as ks } from "./config-DRmZZno3.js";
-import { a as Os, i as As, n as Es, r as Ts, t as vs } from "./component-CY5MVoYN.js";
-import { C as xs, S as Bs, _ as Is, a as Rs, b as Ds, c as Qs, d as qs, f as Fs, g as Hs, h as Ns, i as js, l as zs, m as Ls, n as Ms, o as $s, p as _s, r as Gs, s as Js, t as Ks, u as Us, v as Vs, w as Ws, x as Xs, y as Ys } from "./motion-C5DRdPnO.js";
-import { a as sa, i as aa, n as ea, o as ta, r as ia, s as ra, t as oa } from "./platform-B7JhGBc7.js";
-import { a as ca, c as ma, i as ua, l as pa, n as la, o as fa, r as ga, s as da, t as Ca, u as Sa } from "./router-CijiICxt.js";
-import { a as ba, c as ha, d as ka, i as Pa, l as Oa, n as Aa, o as Ea, r as Ta, s as va, t as wa, u as xa } from "./store-CPK9E62U.js";
-import { n as Ia, r as Ra, t as Da } from "./view-Cdi0g-qo.js";
+import { a, c as e, d as t, i as r, n as o, o as i, r as n, s as m, t as l } from "./sanitize-B1V4JswB.js";
+import { C as u, D as p, E as g, O as f, S as d, T as S, _ as b, a as C, b as y, c as h, d as k, f as v, g as E, h as T, i as D, l as P, m as O, n as A, o as w, p as x, r as B, s as I, t as R, u as F, v as L, w as q, x as Q, y as z } from "./core-Cjl7GUu8.js";
+import { a as N, n as H, o as $, r as j, s as G, t as _ } from "./object-BCk-1c8T.js";
+import { a as K, c as U, i as V, l as W, n as X, o as Y, r as Z, s as ss, t as as, u as es } from "./type-guards-Do9DWgNp.js";
+import { n as rs, r as os, t as is } from "./core-DnlyjbF2.js";
+import { a as ms, c as ls, i as cs, l as us, n as ps, o as gs, r as fs, s as ds, t as Ss, u as bs } from "./reactive-Cfv0RK6x.js";
+import { n as ys, t as hs } from "./config-BW35FKuA.js";
+import { n as vs, r as Es, t as Ts } from "./untrack-DJVQQ2WM.js";
+import { a as Ps, c as Os, i as As, l as ws, n as xs, o as Bs, r as Is, s as Rs, t as Fs } from "./component-CuuTijA6.js";
+import { C as qs, D as Qs, E as zs, O as Ms, S as Ns, T as Hs, _ as $s, a as js, b as Gs, c as _s, d as Js, f as Ks, g as Us, h as Vs, i as Ws, l as Xs, m as Ys, n as Zs, o as sa, p as aa, r as ea, s as ta, t as ra, u as oa, v as ia, w as na, x as ma, y as la } from "./motion-qPj_TYGv.js";
+import { a as ua, i as pa, n as ga, o as fa, r as da, s as Sa, t as ba } from "./platform-CPbCprb6.js";
+import { a as ya, c as ha, d as ka, f as va, i as Ea, l as Ta, n as Da, o as Pa, p as Oa, r as Aa, s as wa, t as xa, u as Ba } from "./router-BrthaP_z.js";
+import { i as Ra, n as Fa, t as La } from "./registry-CWf368tT.js";
+import { a as Qa, c as za, i as Ma, n as Na, o as Ha, r as $a, s as ja, t as Ga } from "./store-DWpyH6p5.js";
+import { n as Ja, r as Ka, t as Ua } from "./mount-SM07RUa6.js";
+import "./view.es.mjs";
+import { a as Xa, c as Ya, d as Za, i as se, l as ae, n as ee, o as te, r as re, s as oe, t as ie, u as ne } from "./forms-C3yovgH9.js";
+import { n as le, r as ce, t as ue } from "./i18n-BnnhTFOS.js";
+import { a as ge, d as fe, i as de, l as Se, n as be, o as Ce, r as ye, s as he, t as ke, u as ve } from "./a11y-C5QOVvRn.js";
+import { n as Te, r as De, t as Pe } from "./dnd-B8EgyzaI.js";
+import { a as Ae, c as we, i as xe, l as Be, n as Ie, o as Re, r as Fe, s as Le, t as qe } from "./media-Di2Ta22s.js";
+import { a as ze, i as Me, n as Ne, o as He, r as $e, t as je } from "./plugin-cPoOHFLY.js";
+import { a as _e, c as Je, d as Ke, f as Ue, g as Ve, h as We, i as Xe, l as Ye, m as Ze, n as st, o as at, p as et, r as tt, s as rt, t as ot, u as it } from "./devtools-D2fQLhDN.js";
+import { a as mt, i as lt, n as ct, o as ut, r as pt, t as gt } from "./testing-CsqjNUyy.js";
+import { a as dt, i as St, n as bt, o as Ct, r as yt, t as ht } from "./ssr-B2qd_WBB.js";
 export {
-  g as $,
-  d as $$,
-  C as BQueryCollection,
-  k as BQueryElement,
-  cs as Computed,
+  S as $,
+  g as $$,
+  p as BQueryCollection,
+  f as BQueryElement,
+  ha as BqLinkElement,
+  vs as Computed,
   is as Signal,
-  xs as animate,
-  da as back,
-  gs as batch,
-  ra as buckets,
-  ta as cache,
-  x as capitalize,
-  zs as capturePosition,
-  u as chunk,
-  _ as clamp,
-  Ra as clearExpressionCache,
-  ss as clone,
-  D as compact,
-  As as component,
-  ms as computed,
-  Aa as createPersistedStore,
-  Ca as createRouter,
-  va as createStore,
-  Da as createTemplate,
-  t as createTrustedHtml,
-  Cs as createUseFetch,
-  Sa as currentRoute,
-  f as debounce,
-  ks as defineBqueryConfig,
-  Os as defineComponent,
-  ea as definePageMeta,
-  Ea as defineStore,
-  ha as destroyStore,
-  _s as easeInCubic,
-  Ls as easeInOutCubic,
-  Ns as easeInOutQuad,
-  Hs as easeInQuad,
-  Is as easeOutBack,
-  Vs as easeOutCubic,
-  Ys as easeOutExpo,
-  Ds as easeOutQuad,
-  Xs as easingPresets,
-  ts as effect,
-  S as ensureArray,
-  c as escapeHtml,
-  j as escapeRegExp,
-  y as flatten,
-  Us as flip,
-  qs as flipElements,
-  Fs as flipList,
-  ma as forward,
-  n as generateNonce,
-  hs as getBqueryConfig,
-  Oa as getStore,
+  zs as animate,
+  ve as announceToScreenReader,
+  Se as auditA11y,
+  Ba as back,
+  bs as batch,
+  xs as bool,
+  we as breakpoints,
+  Sa as buckets,
+  fa as cache,
+  A as capitalize,
+  Ks as capturePosition,
+  y as chunk,
+  h as clamp,
+  fe as clearAnnouncements,
+  Ka as clearExpressionCache,
+  ot as clearTimeline,
+  qe as clipboard,
+  _ as clone,
+  Q as compact,
+  Ps as component,
+  Es as computed,
+  Za as createForm,
+  ue as createI18n,
+  Na as createPersistedStore,
+  Da as createRouter,
+  ja as createStore,
+  Ua as createTemplate,
+  r as createTrustedHtml,
+  ds as createUseFetch,
+  Oa as currentRoute,
+  ie as custom,
+  ee as customAsync,
+  E as debounce,
+  hs as defineBqueryConfig,
+  Bs as defineComponent,
+  ga as definePageMeta,
+  Ha as defineStore,
+  bt as deserializeStoreState,
+  La as destroyStore,
+  De as draggable,
+  Te as droppable,
+  Us as easeInCubic,
+  $s as easeInOutCubic,
+  ia as easeInOutQuad,
+  la as easeInQuad,
+  Gs as easeOutBack,
+  ma as easeOutCubic,
+  Ns as easeOutExpo,
+  qs as easeOutQuad,
+  na as easingPresets,
+  os as effect,
+  re as email,
+  st as enableDevtools,
+  d as ensureArray,
+  l as escapeHtml,
+  B as escapeRegExp,
+  gt as fireEvent,
+  u as flatten,
+  aa as flip,
+  Ys as flipElements,
+  Vs as flipList,
+  ct as flushEffects,
+  le as formatDate,
+  ce as formatNumber,
+  ka as forward,
+  m as generateNonce,
+  tt as generateSignalLabel,
+  ys as getBqueryConfig,
+  je as getCustomDirective,
+  Ne as getCustomDirectives,
+  Xe as getDevtoolsState,
+  ke as getFocusableElements,
+  $e as getInstalledPlugins,
+  Fa as getStore,
+  _e as getTimeline,
   a as getTrustedTypesPolicy,
   e as hasCSPDirective,
-  X as hasOwn,
-  Es as html,
-  K as inRange,
-  ca as interceptLinks,
-  la as isActive,
-  ga as isActiveSignal,
-  H as isArray,
-  z as isBoolean,
-  R as isCollection,
-  ls as isComputed,
-  E as isDate,
-  N as isElement,
-  P as isEmpty,
-  L as isFunction,
-  v as isNumber,
-  q as isObject,
-  Z as isPlainObject,
-  $ as isPromise,
-  ds as isSignal,
-  w as isString,
-  r as isTrustedTypesSupported,
-  Qs as keyframePresets,
-  Bs as linear,
-  fa as link,
-  fs as linkedSignal,
-  xa as listStores,
-  Ta as mapActions,
-  Pa as mapGetters,
-  ba as mapState,
-  W as merge,
-  Ia as mount,
-  pa as navigate,
-  l as noop,
-  aa as notifications,
-  V as omit,
-  b as once,
-  p as parseJson,
-  os as persistedSignal,
-  Y as pick,
-  Ws as prefersReducedMotion,
-  T as randomInt,
-  us as readonly,
-  vs as registerDefaultComponents,
-  ka as registerPlugin,
-  ua as resolve,
-  Ts as safeHtml,
-  i as sanitize,
-  i as sanitizeHtml,
-  Js as scrollAnimate,
-  Ms as sequence,
-  es as signal,
-  G as sleep,
-  F as slugify,
-  Rs as spring,
-  $s as springPresets,
+  H as hasOwn,
+  Is as html,
+  Ct as hydrateMount,
+  yt as hydrateStore,
+  St as hydrateStores,
+  P as inRange,
+  at as inspectComponents,
+  rt as inspectSignals,
+  Je as inspectStores,
+  Pa as interceptLinks,
+  Aa as isActive,
+  Ea as isActiveSignal,
+  as as isArray,
+  X as isBoolean,
+  Z as isCollection,
+  ps as isComputed,
+  V as isDate,
+  Ye as isDevtoolsEnabled,
+  K as isElement,
+  v as isEmpty,
+  Y as isFunction,
+  Me as isInstalled,
+  ss as isNumber,
+  U as isObject,
+  j as isPlainObject,
+  W as isPromise,
+  fs as isSignal,
+  es as isString,
+  i as isTrustedTypesSupported,
+  Js as keyframePresets,
+  Hs as linear,
+  wa as link,
+  gs as linkedSignal,
+  Ra as listStores,
+  it as logComponents,
+  Ke as logSignals,
+  Ue as logStores,
+  et as logTimeline,
+  $a as mapActions,
+  Ma as mapGetters,
+  Qa as mapState,
+  se as max,
+  Xa as maxLength,
+  Be as mediaQuery,
+  N as merge,
+  te as min,
+  oe as minLength,
+  pt as mockRouter,
+  lt as mockSignal,
+  oa as morphElement,
+  Ja as mount,
+  va as navigate,
+  b as noop,
+  pa as notifications,
+  $ as omit,
+  L as once,
+  Xs as parallax,
+  x as parseJson,
+  Ya as pattern,
+  ms as persistedSignal,
+  G as pick,
+  Ce as prefersColorScheme,
+  he as prefersContrast,
+  Qs as prefersReducedMotion,
+  F as randomInt,
+  cs as readonly,
+  Ze as recordEvent,
+  Ta as registerBqLink,
+  Fs as registerDefaultComponents,
+  za as registerPlugin,
+  be as releaseFocus,
+  mt as renderComponent,
+  ht as renderToString,
+  ae as required,
+  ze as resetPlugins,
+  ya as resolve,
+  ge as rovingTabIndex,
+  As as safeHtml,
+  o as sanitize,
+  o as sanitizeHtml,
+  _s as scrollAnimate,
+  ea as sequence,
+  dt as serializeStoreState,
+  Ms as setReducedMotion,
+  rs as signal,
+  de as skipLink,
+  O as sleep,
+  D as slugify,
+  Pe as sortable,
+  sa as spring,
+  ta as springPresets,
   js as stagger,
-  oa as storage,
-  o as stripTags,
-  Q as throttle,
-  Gs as timeline,
-  I as toCamelCase,
-  B as toKebabCase,
-  J as toNumber,
-  Ks as transition,
-  A as truncate,
-  O as uid,
-  h as unique,
-  ys as untrack,
-  ia as useAnnouncer,
-  ns as useAsyncData,
-  sa as useCookie,
-  ps as useFetch,
-  M as utils,
+  ba as storage,
+  n as stripTags,
+  z as throttle,
+  Ws as timeline,
+  C as toCamelCase,
+  w as toKebabCase,
+  k as toNumber,
+  We as trackSignal,
+  Zs as transition,
+  ye as trapFocus,
+  I as truncate,
+  t as trusted,
+  ra as typewriter,
+  T as uid,
+  q as unique,
+  Ts as untrack,
+  Ve as untrackSignal,
+  ne as url,
+  He as use,
+  da as useAnnouncer,
+  ls as useAsyncData,
+  Ae as useBattery,
+  Rs as useComputed,
+  ua as useCookie,
+  Ie as useDeviceMotion,
+  Fe as useDeviceOrientation,
+  Os as useEffect,
+  us as useFetch,
+  xe as useGeolocation,
+  Re as useNetworkStatus,
+  xa as useRoute,
+  ws as useSignal,
+  Le as useViewport,
+  R as utils,
+  ut as waitFor,
   Ss as watch,
-  wa as watchStore
+  Ga as watchStore
 };

package/dist/media/battery.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reactive battery status.
+ *
+ * Provides a reactive signal tracking the device's battery status
+ * via the Battery Status API.
+ *
+ * @module bquery/media
+ */
+import type { BatterySignal } from './types';
+/**
+ * Returns a reactive signal tracking the device's battery status.
+ *
+ * Uses the Battery Status API (`navigator.getBattery()`) where available.
+ * Falls back gracefully to a default state with `supported: false` when
+ * the API is not available.
+ *
+ * @returns A readonly reactive signal with battery state and a `destroy()` method
+ * to remove Battery Status API listeners
+ *
+ * @example
+ * ```ts
+ * import { useBattery } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const battery = useBattery();
+ * effect(() => {
+ *   if (battery.value.supported) {
+ *     console.log(`Battery: ${(battery.value.level * 100).toFixed(0)}%`);
+ *     console.log(`Charging: ${battery.value.charging}`);
+ *   }
+ * });
+ * ```
+ */
+export declare const useBattery: () => BatterySignal;
+//# sourceMappingURL=battery.d.ts.map

package/dist/media/battery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"battery.d.ts","sourceRoot":"","sources":["../../src/media/battery.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,SAAS,CAAC;AAsB3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,QAAO,aA2D7B,CAAC"}

package/dist/media/breakpoints.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Named breakpoint signals.
+ *
+ * Defines named breakpoints that return reactive boolean signals,
+ * making it easy to respond to viewport size changes.
+ *
+ * @module bquery/media
+ */
+import type { BreakpointMap, MediaSignalHandle } from './types';
+type BreakpointSignals<T extends BreakpointMap> = {
+    [K in keyof T]: MediaSignalHandle<boolean>;
+} & {
+    destroyAll(): void;
+} & ('destroy' extends keyof T ? Record<never, never> : {
+    destroy(): void;
+});
+/**
+ * Defines named breakpoints and returns reactive boolean signals for each.
+ *
+ * Each breakpoint is a minimum-width media query. The returned object maps
+ * each breakpoint name to a `ReadonlySignal<boolean>` that is `true` when
+ * the viewport width is at or above the breakpoint value.
+ *
+ * @param bp - An object mapping breakpoint names to minimum widths in pixels
+ * @returns An object with the same keys, each a reactive boolean signal with
+ * `destroy()`, plus a top-level `destroyAll()` method to clean up all listeners.
+ * When no breakpoint is named `destroy`, a `destroy()` alias is also provided.
+ *
+ * @example
+ * ```ts
+ * import { breakpoints } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const bp = breakpoints({ sm: 640, md: 768, lg: 1024, xl: 1280 });
+ *
+ * effect(() => {
+ *   if (bp.xl.value) {
+ *     console.log('Extra large viewport');
+ *   } else if (bp.lg.value) {
+ *     console.log('Large viewport');
+ *   } else if (bp.md.value) {
+ *     console.log('Medium viewport');
+ *   } else {
+ *     console.log('Small viewport');
+ *   }
+ * });
+ * ```
+ */
+export declare const breakpoints: <T extends BreakpointMap>(bp: T) => BreakpointSignals<T>;
+export {};
+//# sourceMappingURL=breakpoints.d.ts.map

package/dist/media/breakpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpoints.d.ts","sourceRoot":"","sources":["../../src/media/breakpoints.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEhE,KAAK,iBAAiB,CAAC,CAAC,SAAS,aAAa,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,iBAAiB,CAAC,OAAO,CAAC;CAAE,GAAG;IACjG,UAAU,IAAI,IAAI,CAAC;CACpB,GAAG,CAAC,SAAS,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG;IAAE,OAAO,IAAI,IAAI,CAAA;CAAE,CAAC,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EACjD,IAAI,CAAC,KACJ,iBAAiB,CAAC,CAAC,CAgFrB,CAAC"}

package/dist/media/clipboard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Async clipboard API wrappers.
+ *
+ * Provides simple read/write access to the system clipboard
+ * via the Async Clipboard API.
+ *
+ * @module bquery/media
+ */
+import type { ClipboardAPI } from './types';
+/**
+ * Clipboard API wrapper providing simple async read/write access.
+ *
+ * Uses the modern Async Clipboard API (`navigator.clipboard`) under the hood.
+ * Both methods are `Promise`-based and will reject if the API is unavailable
+ * or permission is denied.
+ *
+ * @example
+ * ```ts
+ * import { clipboard } from '@bquery/bquery/media';
+ *
+ * // Write text to clipboard
+ * await clipboard.write('Hello, world!');
+ *
+ * // Read text from clipboard
+ * const text = await clipboard.read();
+ * console.log(text); // "Hello, world!"
+ * ```
+ */
+export declare const clipboard: ClipboardAPI;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/media/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../src/media/clipboard.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAK5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS,EAAE,YA8CvB,CAAC"}

package/dist/media/device-sensors.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Reactive device motion and orientation sensors.
+ *
+ * Provides reactive signals for accelerometer, gyroscope, and
+ * compass data via the DeviceMotion and DeviceOrientation APIs.
+ *
+ * @module bquery/media
+ */
+import type { DeviceMotionSignal, DeviceOrientationSignal } from './types';
+/**
+ * Returns a reactive signal tracking device motion (accelerometer + gyroscope).
+ *
+ * Uses the `devicemotion` event to provide acceleration, acceleration
+ * including gravity, and rotation rate data.
+ *
+ * @returns A readonly reactive signal with motion sensor data and a `destroy()`
+ * method to remove the underlying event listener
+ *
+ * @example
+ * ```ts
+ * import { useDeviceMotion } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const motion = useDeviceMotion();
+ * effect(() => {
+ *   const { acceleration } = motion.value;
+ *   console.log(`Acceleration: x=${acceleration.x}, y=${acceleration.y}, z=${acceleration.z}`);
+ * });
+ * ```
+ */
+export declare const useDeviceMotion: () => DeviceMotionSignal;
+/**
+ * Returns a reactive signal tracking device orientation (compass/gyroscope).
+ *
+ * Uses the `deviceorientation` event to provide alpha (compass heading),
+ * beta (front-to-back tilt), and gamma (left-to-right tilt) data.
+ *
+ * @returns A readonly reactive signal with orientation data and a `destroy()`
+ * method to remove the underlying event listener
+ *
+ * @example
+ * ```ts
+ * import { useDeviceOrientation } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * const orientation = useDeviceOrientation();
+ * effect(() => {
+ *   console.log(`Compass heading: ${orientation.value.alpha}°`);
+ *   console.log(`Tilt: ${orientation.value.beta}° / ${orientation.value.gamma}°`);
+ * });
+ * ```
+ */
+export declare const useDeviceOrientation: () => DeviceOrientationSignal;
+//# sourceMappingURL=device-sensors.d.ts.map

package/dist/media/device-sensors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-sensors.d.ts","sourceRoot":"","sources":["../../src/media/device-sensors.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAElB,uBAAuB,EAExB,MAAM,SAAS,CAAC;AAkBjB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,QAAO,kBA8ClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,QAAO,uBAkCvC,CAAC"}

package/dist/media/geolocation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reactive geolocation.
+ *
+ * Provides a reactive signal tracking the device's geographic position
+ * via the Geolocation API.
+ *
+ * @module bquery/media
+ */
+import type { GeolocationOptions, GeolocationSignal } from './types';
+/**
+ * Returns a reactive signal tracking the device's geographic position.
+ *
+ * Uses the Geolocation API (`navigator.geolocation`) where available.
+ * Can operate in one-shot mode (default) or continuous watch mode.
+ *
+ * @param options - Configuration for the geolocation request
+ * @returns A readonly reactive signal with position data and loading/error state,
+ * plus a `destroy()` method to stop an active watcher
+ *
+ * @example
+ * ```ts
+ * import { useGeolocation } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * // One-shot position
+ * const geo = useGeolocation();
+ * effect(() => {
+ *   if (geo.value.loading) return console.log('Getting position...');
+ *   if (geo.value.error) return console.error(geo.value.error);
+ *   console.log(`Lat: ${geo.value.latitude}, Lng: ${geo.value.longitude}`);
+ * });
+ *
+ * // Continuous watch with high accuracy
+ * const geoWatch = useGeolocation({ watch: true, enableHighAccuracy: true });
+ * ```
+ */
+export declare const useGeolocation: (options?: GeolocationOptions) => GeolocationSignal;
+//# sourceMappingURL=geolocation.d.ts.map

package/dist/media/geolocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geolocation.d.ts","sourceRoot":"","sources":["../../src/media/geolocation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAoB,MAAM,SAAS,CAAC;AAiBvF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,cAAc,GAAI,UAAS,kBAAuB,KAAG,iBAgEjE,CAAC"}

package/dist/media/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * bQuery Media module — reactive browser and device API signals.
+ *
+ * Provides reactive wrappers around browser media queries, viewport,
+ * network status, battery, geolocation, device sensors, and clipboard.
+ *
+ * @module bquery/media
+ *
+ * @example
+ * ```ts
+ * import { mediaQuery, breakpoints, useViewport, useNetworkStatus, clipboard } from '@bquery/bquery/media';
+ * import { effect } from '@bquery/bquery/reactive';
+ *
+ * // Reactive media query
+ * const isDark = mediaQuery('(prefers-color-scheme: dark)');
+ *
+ * // Named breakpoints
+ * const bp = breakpoints({ sm: 640, md: 768, lg: 1024, xl: 1280 });
+ *
+ * // Viewport tracking
+ * const viewport = useViewport();
+ * effect(() => console.log(viewport.value.width));
+ *
+ * // Network status
+ * const net = useNetworkStatus();
+ * effect(() => console.log('Online:', net.value.online));
+ *
+ * // Clipboard
+ * await clipboard.write('Hello!');
+ * const text = await clipboard.read();
+ * ```
+ */
+export { mediaQuery } from './media-query';
+export { breakpoints } from './breakpoints';
+export { useViewport } from './viewport';
+export { useNetworkStatus } from './network';
+export { useBattery } from './battery';
+export { useGeolocation } from './geolocation';
+export { useDeviceMotion, useDeviceOrientation } from './device-sensors';
+export { clipboard } from './clipboard';
+export type { BatterySignal, BatteryState, BreakpointMap, ClipboardAPI, DeviceMotionSignal, DeviceMotionState, DeviceOrientationSignal, DeviceOrientationState, GeolocationOptions, GeolocationSignal, GeolocationState, MediaSignalHandle, NetworkSignal, NetworkState, ViewportSignal, ViewportState, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/media/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG7C,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAGvC,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGzE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,YAAY,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,uBAAuB,EACvB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,cAAc,EACd,aAAa,GACd,MAAM,SAAS,CAAC"}