This PR introduces the requested native composables and page utilities (createUseFetch, useFetch, useAsyncData, useCookie, definePageMeta, useAnnouncer, defineBqueryConfig), improves the view transition API, adds a default dependency-free component library for foundational UI primitives, and replaces the previous playground workflow with Storybook for component development. The changes stay within the project's existing modular architecture and browser-native design.

• Reactive data composables

  • Added useAsyncData() for signal-backed async state with data, error, status, pending, execute, refresh, clear, and dispose.
    • dispose() tears down reactive watch effects for short-lived consumers and makes later execute() / refresh() return the cached data value instead of re-running the handler.
    • Watch-triggered refreshes run under untrack() so only explicit watch sources retrigger executions, avoiding accidental dependency capture from synchronous signal reads inside handlers.
  • Added useFetch() as a native Fetch wrapper with:
    • query param support
    • body serialization
    • configurable response parsing
    • shared reactive async state shape, including dispose()
  • Added createUseFetch() for preconfigured fetch factories (e.g. base URL, headers).
    • Returned helpers remain generic per invocation, so one configured fetch instance can be reused across endpoints with different response types.
    • When factory defaults include a transform, derived helpers preserve that configured transformed data shape as their default AsyncDataState type while still allowing per-invocation response/data generics to be overridden.
  • Fetch behavior was further hardened so that:
    • relative baseUrl values resolve against the runtime base URL
    • Request inputs preserve their original headers unless explicitly overridden
    • query params are also applied consistently for Request inputs
    • requests with a body default to POST when no method is specified
    • explicit GET / HEAD requests with a body produce a clear reactive error state instead of attempting an invalid fetch
    • rebuilding Request inputs for query updates tolerates already-consumed bodies without throwing

• Platform utilities

  • Added useCookie() as a reactive cookie signal with typed defaults, serialization/deserialization, and write-through behavior.
    • Auto-deserialization is limited to JSON structures (objects, arrays, quoted strings) to preserve type safety; bare primitives (numbers, booleans, null) are returned as raw strings unless a custom deserialize option is provided.
    • Automatically enforces secure: true when sameSite is set to 'None' to comply with modern browser requirements.
    • Avoids rewriting an existing cookie during read-only initialization.
    • Cookie reads tolerate both ;- and ; -separated cookie strings and gracefully fall back to raw values when percent-decoding fails, so malformed cookie data cannot crash initialization.
  • Added definePageMeta() for document title, meta tags, link tags, and html/body attribute management with cleanup support.
  • Added useAnnouncer() for accessible ARIA live-region announcements with proper reactive effect disposal on destroy.
  • Added defineBqueryConfig() / getBqueryConfig() for global runtime defaults across fetch, cookies, announcer, transitions, page meta, and component prefixing.
    • Config snapshots clone transition arrays and Headers instances to prevent accidental mutation of global state through returned values.

• Motion / view transitions

  • Extended transition() to support:
    • async DOM updates (both function overload and options object accept Promise<void>)
    • transition classes on the root element
    • optional transition types where supported
    • reduced-motion-aware skipping
    • onReady / onFinish hooks
  • Ignores empty or whitespace-only transition class/type tokens to avoid DOMTokenList errors from misconfiguration.
  • Kept progressive enhancement behavior for browsers without the View Transitions API.

• Default component library

  • Added registerDefaultComponents() to register a small native baseline component set:
    • button
    • card
    • input
    • textarea
    • checkbox
  • Implemented on top of the existing Web Component system with no external dependencies.
  • Components emit native-friendly custom events and expose stable foundational styling.
  • String props are HTML-entity-escaped before template interpolation to prevent markup injection.
  • Input and textarea components use beforeUpdate to patch control values in-place, preserving focus and caret position during typing instead of triggering full shadow DOM re-renders.
  • Component lifecycle hook typings remain compatible with both this-based handlers and arrow functions that do not use this.
  • Added regression coverage so repeated default-component registration remains safe for repeat dev bootstraps such as Storybook initialization and HMR-style reloads.

• Component development workflow

  • Replaced the former Vite playground with Storybook as the dedicated component development environment.
  • Added a minimal Storybook setup based on storybook + @storybook/web-components-vite with docs support.
  • Added initial stories for the default component library so the new primitives can be developed and reviewed in isolation.
  • Updated project scripts, contributor docs, agent guidance, and repository metadata to point to Storybook instead of the removed playground workflow.

• Public API integration

  • Exported the new APIs through the existing reactive, platform, component, root, and full entrypoints so they remain tree-shakeable and consistent with current module boundaries.

Example usage:

import {
  createUseFetch,
  defineBqueryConfig,
  definePageMeta,
  registerDefaultComponents,
  transition,
  useAnnouncer,
  useCookie,
} from '@bquery/bquery';

defineBqueryConfig({
  fetch: { baseUrl: 'https://api.example.com' },
  components: { prefix: 'bq' },
});

definePageMeta({
  title: 'Dashboard',
  description: 'Overview of your account',
});

const theme = useCookie('theme', { defaultValue: 'light' });
const useApiFetch = createUseFetch({ headers: { 'x-client': 'bquery' } });
const profile = useApiFetch('/profile');

const announcer = useAnnouncer();
announcer.announce('Profile loaded');

registerDefaultComponents();

await transition({
  classes: ['is-transitioning'],
  update: () => {
    document.body.dataset.state = 'ready';
  },
});

Screenshot of the new Storybook-based component workflow:

🔒 GitHub Advanced Security automatically protects Copilot coding agent pull requests. You can protect all pull requests by enabling Advanced Security for your repositories. Learn more about Advanced Security.