@studiometa/js-toolkit 3.9.0-beta.2 → 4.0.0-alpha.0

package/dist/events.js

@@ -0,0 +1,19 @@
+//#region src/events.ts
+const component = Object.freeze({
+	mounted: "js-toolkit:component:mounted",
+	unmounted: "js-toolkit:component:unmounted"
+});
+const dom = Object.freeze({ update: "js-toolkit:dom:update" });
+/**
+* Public framework event names.
+* @link https://js-toolkit-v4.studiometa.dev/api/diagnostics/EVENTS.html
+*/
+const EVENTS = Object.freeze({
+	component,
+	dom,
+	diagnostic: "js-toolkit:diagnostic"
+});
+//#endregion
+export { EVENTS };
+
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../src/events.ts"],"sourcesContent":["const component = Object.freeze({\n  mounted: 'js-toolkit:component:mounted',\n  unmounted: 'js-toolkit:component:unmounted',\n} as const);\n\nconst dom = Object.freeze({\n  update: 'js-toolkit:dom:update',\n} as const);\n\n/**\n * Public framework event names.\n * @link https://js-toolkit-v4.studiometa.dev/api/diagnostics/EVENTS.html\n */\nexport const EVENTS = Object.freeze({\n  component,\n  dom,\n  diagnostic: 'js-toolkit:diagnostic',\n} as const);\n"],"mappings":";AAAA,MAAM,YAAY,OAAO,OAAO;CAC9B,SAAS;CACT,WAAW;AACb,CAAU;AAEV,MAAM,MAAM,OAAO,OAAO,EACxB,QAAQ,wBACV,CAAU;;;;;AAMV,MAAa,SAAS,OAAO,OAAO;CAClC;CACA;CACA,YAAY;AACd,CAAU"}

package/dist/group.d.ts

@@ -0,0 +1,55 @@
+import { Signal } from "./context.js";
+//#region src/group.d.ts
+/**
+ * What a group needs of a member: the element that decides its rank.
+ *
+ * Structural on purpose — this module never imports `Base`, so a group orders
+ * anything anchored to the DOM and costs a consumer no component graph.
+ */
+interface GroupMember {
+  readonly $el: Element;
+}
+/**
+ * A set of peers that know about each other, published as one reactive value.
+ *
+ * The membership _is_ the state. v3's `withGroup` handed out a bare `Set` with no
+ * value cell, so a coordinator could read its peers but never learn that one
+ * arrived, and every consumer built a change channel beside it. Here a peer
+ * joining or leaving is an observable write, which is what makes an invariant
+ * over the whole set — one open at a time, one selected item — enforceable
+ * when v4 mounts on DOM insertion with no ordering guarantee.
+ *
+ * A group is not a registry: nothing joins implicitly, and the coordinator
+ * that created the group decides who can reach it — usually by providing it as
+ * a context value, so membership is scoped by the DOM, nearest provider first.
+ */
+interface Group<T extends GroupMember = GroupMember> {
+  /**
+   * The members in document order, replaced by a new array on every change so
+   * subscribers observe changes by identity and never share a mutable set.
+   */
+  readonly members: Signal<readonly T[]>;
+  /**
+   * Join, and get the leave function back.
+   *
+   * Returning the teardown is what makes membership survive an unknown mount
+   * order: a member hands this straight back from a `subscribeContext()`
+   * callback, so it joins the nearest group whenever that group appears, and
+   * leaves again before a nearer one takes over.
+   *
+   * Membership is a set — joining twice changes nothing, and either leave
+   * function removes the member once.
+   */
+  join(member: T): () => void;
+}
+/**
+ * Create an empty group.
+ *
+ * A member leaves through the function `join()` returned; nothing sweeps
+ * disconnected elements, because v4 unmounts a component when its element
+ * leaves the DOM and the member's own teardown is what removes it.
+ * @link https://js-toolkit-v4.studiometa.dev/api/context/createGroup.html
+ */
+declare function createGroup<T extends GroupMember = GroupMember>(): Group<T>;
+//#endregion
+export { Group, GroupMember, createGroup };

package/dist/group.js

@@ -0,0 +1,34 @@
+import { signal } from "./context.js";
+import { compareDocumentOrder } from "./document-order.js";
+//#region src/group.ts
+/**
+* Create an empty group.
+*
+* A member leaves through the function `join()` returned; nothing sweeps
+* disconnected elements, because v4 unmounts a component when its element
+* leaves the DOM and the member's own teardown is what removes it.
+* @link https://js-toolkit-v4.studiometa.dev/api/context/createGroup.html
+*/
+function createGroup() {
+	const joined = /* @__PURE__ */ new Set();
+	const members = signal([]);
+	const publish = () => {
+		members.value = [...joined].sort((a, b) => compareDocumentOrder(a.$el, b.$el));
+	};
+	return {
+		members,
+		join(member) {
+			if (!joined.has(member)) {
+				joined.add(member);
+				publish();
+			}
+			return () => {
+				if (joined.delete(member)) publish();
+			};
+		}
+	};
+}
+//#endregion
+export { createGroup };
+
+//# sourceMappingURL=group.js.map

package/dist/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","names":[],"sources":["../src/group.ts"],"sourcesContent":["import { signal, type Signal } from './context.js';\nimport { compareDocumentOrder } from './document-order.js';\n\n/**\n * What a group needs of a member: the element that decides its rank.\n *\n * Structural on purpose — this module never imports `Base`, so a group orders\n * anything anchored to the DOM and costs a consumer no component graph.\n */\nexport interface GroupMember {\n  readonly $el: Element;\n}\n\n/**\n * A set of peers that know about each other, published as one reactive value.\n *\n * The membership _is_ the state. v3's `withGroup` handed out a bare `Set` with no\n * value cell, so a coordinator could read its peers but never learn that one\n * arrived, and every consumer built a change channel beside it. Here a peer\n * joining or leaving is an observable write, which is what makes an invariant\n * over the whole set — one open at a time, one selected item — enforceable\n * when v4 mounts on DOM insertion with no ordering guarantee.\n *\n * A group is not a registry: nothing joins implicitly, and the coordinator\n * that created the group decides who can reach it — usually by providing it as\n * a context value, so membership is scoped by the DOM, nearest provider first.\n */\nexport interface Group<T extends GroupMember = GroupMember> {\n  /**\n   * The members in document order, replaced by a new array on every change so\n   * subscribers observe changes by identity and never share a mutable set.\n   */\n  readonly members: Signal<readonly T[]>;\n  /**\n   * Join, and get the leave function back.\n   *\n   * Returning the teardown is what makes membership survive an unknown mount\n   * order: a member hands this straight back from a `subscribeContext()`\n   * callback, so it joins the nearest group whenever that group appears, and\n   * leaves again before a nearer one takes over.\n   *\n   * Membership is a set — joining twice changes nothing, and either leave\n   * function removes the member once.\n   */\n  join(member: T): () => void;\n}\n\n/**\n * Create an empty group.\n *\n * A member leaves through the function `join()` returned; nothing sweeps\n * disconnected elements, because v4 unmounts a component when its element\n * leaves the DOM and the member's own teardown is what removes it.\n * @link https://js-toolkit-v4.studiometa.dev/api/context/createGroup.html\n */\nexport function createGroup<T extends GroupMember = GroupMember>(): Group<T> {\n  const joined = new Set<T>();\n  const members = signal<readonly T[]>([]);\n\n  // Sorting on write keeps the published value ready to read and makes the\n  // new array identity the notification.\n  const publish = () => {\n    members.value = [...joined].sort((a, b) => compareDocumentOrder(a.$el, b.$el));\n  };\n\n  return {\n    members,\n    join(member: T): () => void {\n      if (!joined.has(member)) {\n        joined.add(member);\n        publish();\n      }\n      return () => {\n        if (joined.delete(member)) {\n          publish();\n        }\n      };\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;AAuDA,SAAgB,cAA6D;CAC3E,MAAM,yBAAS,IAAI,IAAO;CAC1B,MAAM,UAAU,OAAqB,CAAC,CAAC;CAIvC,MAAM,gBAAgB;EACpB,QAAQ,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,qBAAqB,EAAE,KAAK,EAAE,GAAG,CAAC;CAC/E;CAEA,OAAO;EACL;EACA,KAAK,QAAuB;GAC1B,IAAI,CAAC,OAAO,IAAI,MAAM,GAAG;IACvB,OAAO,IAAI,MAAM;IACjB,QAAQ;GACV;GACA,aAAa;IACX,IAAI,OAAO,OAAO,MAAM,GACtB,QAAQ;GAEZ;EACF;CACF;AACF"}

package/dist/index.d.ts

@@ -1,7 +1,40 @@
-export { version } from './version.js';
-export { Base, getInstances, type BaseAsyncConstructor, type BaseChildren, type BaseConfig, type BaseConfigComponents, type BaseConstructor, type BaseEl, type BaseOptions, type BaseProps, type BaseRefs, type Managers, } from './Base/index.js';
-export { type BaseDecorator, type BaseEventHookParams, type BaseInterface } from './Base/types.js';
-export { getScopedGroups, withBreakpointManager, withBreakpointObserver, withDrag, withExtraConfig, withFreezedOptions, withGroup, withIntersectionObserver, withMountOnMediaQuery, withMountWhenInView, withMountWhenPrefersMotion, withMutation, withName, withRelativePointer, withResponsiveOptions, withScrolledInView, type DragDecoratorOptions, type MutationDecoratorOptions, type NormalizedOffset, type OffsetValue, type RelativePointerDecoratorOptions, type RelativePointerInterface, type ScrollInViewProps, type WithBreakpointObserverInterface, type WithBreakpointObserverProps, type WithDragInterface, type WithFreezedOptionsInterface, type WithGroupInterface, type WithGroupOptions, type WithGroupProps, type WithIntersectionObserverInterface, type WithIntersectionObserverProps, type WithMountWhenInViewInterface, type WithMountWhenInViewProps, type WithMutationInterface, type WithScrolledInViewInterface, type WithScrolledInViewOptions, type WithScrolledInViewProps, type withMountOnMediaQueryInterface, type withMountOnMediaQueryProps, } from './decorators/index.js';
-export { closestComponent, createApp, defineFeatures, getClosestParent, getDirectChildren, getInstanceFromElement, importOnInteraction, importOnMediaQuery, importWhenIdle, importWhenPrefersMotion, importWhenVisible, isDirectChild, logTree, queryComponent, queryComponentAll, registerComponent, registerComponents, type CreateAppOptions, type QueryOptions, } from './helpers/index.js';
-export { AbstractService, DragService, KeyService, LoadService, MutationService, PointerService, RafService, ResizeService, ScrollService, useDrag, useKey, useLoad, useMutation, usePointer, useRaf, useResize, useScroll, type DragServiceInterface, type DragServiceOptions, type DragServiceProps, type KeyServiceInterface, type KeyServiceProps, type LoadServiceInterface, type LoadServiceProps, type MutationServiceInterface, type MutationServiceOptions, type MutationServiceProps, type PointerServiceInterface, type PointerServiceProps, type RafServiceInterface, type RafServiceProps, type ResizeServiceInterface, type ResizeServiceProps, type ScrollServiceInterface, type ScrollServiceProps, type ServiceConfig, type ServiceInterface, } from './services/index.js';
-export { ComponentLoader, DEFAULT_DIAGNOSTIC_PREFIX, VISIBLE_ROOT_MARGIN, IDLE_TIMEOUT, autoload, composeManifests, registerManifest, registerManifests, readEagerTokens, defineManifest, fromMetaGlob, fromWebpackContext, type ComponentLoadStrategy, type ComponentManifestEntry, type ComponentManifest, type LoaderDependencies, type ComponentLoaderOptions, type ComponentLoaderStartOptions, type AutoloadOptions, type AutoloadHandle, type AutoloadRuntime, type RegisterManifestOptions, type ModuleRecord, type ComponentOverride, type DefineManifestOptions, type WebpackContextLike, } from './autoload/index.js';
+import { ContextKey, Signal, createContext, injectContext, injectContextSync, provideContext, provideRootContext, signal } from "./context.js";
+import { DIAGNOSTICS, ToolkitConsumerDiagnosticCode, ToolkitCoreDiagnosticCode, ToolkitDiagnosticCode, ToolkitDiagnosticDetail, ToolkitDiagnosticSeverity } from "./diagnostic-contract.js";
+import { ScheduledTask, SchedulerPhase, TickCallback, TickProps, defaultScheduler, nextFrame } from "./scheduler.js";
+import { MountStrategy } from "./mount-strategies.js";
+import { Base, BaseConfig, BaseConstructor, BaseProps, ChildrenCollection, ComponentImporter, DelegatedEvent, EmitMap, GlobalEvent, LifecycleEventDetail, MountedReturn, OptionChange, OptionChangedReturn, OptionDefinition, OptionType, OptionTypes, RefEvent, WatchChildrenCallbacks } from "./Base.js";
+import { AttributeNamespaceBinder, AttributeNamespaceDeclaration, AttributeNamespaceOptions, watchAttributeNamespace } from "./attribute-namespaces.js";
+import { MOUNT_ATTRIBUTE, namespaceQualifier } from "./attributes.js";
+import { ContextCallback, subscribeContext } from "./context-subscription.js";
+import { children, component, inject, on, provide, read, write } from "./decorators.js";
+import { reportDiagnostic, warn } from "./diagnostics.js";
+import { AttributeChange, AttributeWatcher, watchAttributes, whenDOMSettled } from "./dom-mutations.js";
+import { EVENTS } from "./events.js";
+import { Group, GroupMember, createGroup } from "./group.js";
+import { getInstance, getInstances, getMountedInstances, getUnmountedInstances } from "./instances.js";
+import { ComponentManifest, ComponentManifestEntry, registerComponent, registerComponents, registerManifest } from "./registry.js";
+import { DefineManifestOptions, ModuleRecord, WebpackContextLike, defineManifest, fromMetaGlob, fromWebpackContext } from "./manifest.js";
+import { DomMutation, DomUpdateDetail, DomUpdateRunner, DomUpdateTransitioner, ExtendableDetail, ExtendableTransitioner, Extension, domUpdate, emitExtendable } from "./negotiated-events.js";
+import { MutableProps, Service, ServiceCallback, ServiceDefinition, SubscribeOptions, Unsubscribe, createService, perTarget } from "./services/service.js";
+import { BREAKPOINTS, BreakpointProps, getBreakpoints, setBreakpoints, useBreakpoint } from "./services/breakpoint.js";
+import { Toggle, toggle } from "./services/toggle.js";
+import { MixedClass, ServiceHandles, ServiceMixin, ServiceMixinDefinition, ServiceMixinOptions, createServiceMixin } from "./services/mixin.js";
+import { DRAG_MODES, DragHook, DragMixinOptions, DragMode, DragOptions, DragProps, DragTarget, useDrag, withDrag } from "./services/drag.js";
+import { InViewHook, InViewMixinOptions, InViewProps, useInView, withInView } from "./services/in-view.js";
+import { KeyFlags, KeyHook, KeyMixinOptions, KeyName, KeyProps, KeyTarget, useKey, withKey } from "./services/key.js";
+import { MediaQueryProps, useMediaQuery, usePrefersReducedMotion } from "./services/media.js";
+import { MutationHook, MutationMixinOptions, MutationProps, useMutation, withMutation } from "./services/mutation.js";
+import { ElementPointerProps, PointerHook, PointerMixinOptions, PointerProps, usePointer, withPointer } from "./services/pointer.js";
+import { RafHook, RafMixinOptions, RafProps, RafRender, RafService, useRaf, withRaf } from "./services/raf.js";
+import { ResizeHook, ResizeMixinOptions, ResizeOrientation, ResizeProps, useResize, useWindowSize, withResize } from "./services/resize.js";
+import { ScrollProgressHook, ScrollProgressMixinOptions, ScrollProgressOptions, ScrollProgressProps, ScrollProgressRender, useScrollProgress, withScrollProgress } from "./services/scroll-progress.js";
+import { ScrollDirection, ScrollHook, ScrollMixinOptions, ScrollProps, ScrollTarget, useScroll, useWindowScroll, withScroll } from "./services/scroll.js";
+import { until } from "./services/until.js";
+import { StorageInstance, StorageOptions, StorageProvider, StorageSerializer, StorageSubscribeOptions, UrlProviderOptions } from "./storage/types.js";
+import { createStorage } from "./storage/createStorage.js";
+import { createFallbackProvider, createMemoryStorageProvider, createUrlSearchParamsInHashProvider, createUrlSearchParamsProvider, localStorageProvider, memoryStorageProvider, sessionStorageProvider, urlSearchParamsInHashProvider, urlSearchParamsProvider } from "./storage/providers.js";
+import { jsonSerializer } from "./storage/serializers.js";
+import { createLocalStorage, createSessionStorage, createUrlSearchParamsInHashStorage, createUrlSearchParamsStorage } from "./storage/index.js";
+import { SWAP_MODES, SwapContent, SwapMode, SwapOptions, SwapWrap, swap } from "./swap.js";
+import { ViewTransitionUpdate, viewTransition } from "./viewTransition.js";
+export { type AttributeChange, type AttributeNamespaceBinder, type AttributeNamespaceDeclaration, type AttributeNamespaceOptions, type AttributeWatcher, BREAKPOINTS, Base, type BaseConfig, type BaseConstructor, type BaseProps, type BreakpointProps, type ChildrenCollection, type ComponentImporter, type ComponentManifest, type ComponentManifestEntry, type ContextCallback, type ContextKey, DIAGNOSTICS, DRAG_MODES, type DefineManifestOptions, type DelegatedEvent, type DomMutation, type DomUpdateDetail, type DomUpdateRunner, type DomUpdateTransitioner, type DragHook, type DragMixinOptions, type DragMode, type DragOptions, type DragProps, type DragTarget, EVENTS, type ElementPointerProps, type EmitMap, type ExtendableDetail, type ExtendableTransitioner, type Extension, type GlobalEvent, type Group, type GroupMember, type InViewHook, type InViewMixinOptions, type InViewProps, type KeyFlags, type KeyHook, type KeyMixinOptions, type KeyName, type KeyProps, type KeyTarget, type LifecycleEventDetail, MOUNT_ATTRIBUTE, type MediaQueryProps, type MixedClass, type ModuleRecord, type MountStrategy, type MountedReturn, type MutableProps, type MutationHook, type MutationMixinOptions, type MutationProps, type OptionChange, type OptionChangedReturn, type OptionDefinition, type OptionType, type OptionTypes, type PointerHook, type PointerMixinOptions, type PointerProps, type RafHook, type RafMixinOptions, type RafProps, type RafRender, type RafService, type RefEvent, type ResizeHook, type ResizeMixinOptions, type ResizeOrientation, type ResizeProps, SWAP_MODES, type ScheduledTask, type SchedulerPhase, type ScrollDirection, type ScrollHook, type ScrollMixinOptions, type ScrollProgressHook, type ScrollProgressMixinOptions, type ScrollProgressOptions, type ScrollProgressProps, type ScrollProgressRender, type ScrollProps, type ScrollTarget, type Service, type ServiceCallback, type ServiceDefinition, type ServiceHandles, type ServiceMixin, type ServiceMixinDefinition, type ServiceMixinOptions, type Signal, type StorageInstance, type StorageOptions, type StorageProvider, type StorageSerializer, type StorageSubscribeOptions, type SubscribeOptions, type SwapContent, type SwapMode, type SwapOptions, type SwapWrap, type TickCallback, type TickProps, type Toggle, type ToolkitConsumerDiagnosticCode, type ToolkitCoreDiagnosticCode, type ToolkitDiagnosticCode, type ToolkitDiagnosticDetail, type ToolkitDiagnosticSeverity, type Unsubscribe, type UrlProviderOptions, type ViewTransitionUpdate, type WatchChildrenCallbacks, type WebpackContextLike, children, component, createContext, createFallbackProvider, createGroup, createLocalStorage, createMemoryStorageProvider, createService, createServiceMixin, createSessionStorage, createStorage, createUrlSearchParamsInHashProvider, createUrlSearchParamsInHashStorage, createUrlSearchParamsProvider, createUrlSearchParamsStorage, defaultScheduler, defineManifest, domUpdate, emitExtendable, fromMetaGlob, fromWebpackContext, getBreakpoints, getInstance, getInstances, getMountedInstances, getUnmountedInstances, inject, injectContext, injectContextSync, jsonSerializer, localStorageProvider, memoryStorageProvider, namespaceQualifier, nextFrame, on, perTarget, provide, provideContext, provideRootContext, read, registerComponent, registerComponents, registerManifest, reportDiagnostic, sessionStorageProvider, setBreakpoints, signal, subscribeContext, swap, toggle, until, urlSearchParamsInHashProvider, urlSearchParamsProvider, useBreakpoint, useDrag, useInView, useKey, useMediaQuery, useMutation, usePointer, usePrefersReducedMotion, useRaf, useResize, useScroll, useScrollProgress, useWindowScroll, useWindowSize, viewTransition, warn, watchAttributeNamespace, watchAttributes, whenDOMSettled, withDrag, withInView, withKey, withMutation, withPointer, withRaf, withResize, withScroll, withScrollProgress, write };

package/dist/index.js

@@ -1,143 +1,38 @@
-import { version } from "./version.js";
-import {
-  Base,
-  getInstances
-} from "./Base/index.js";
-import {
-  getScopedGroups,
-  withBreakpointManager,
-  withBreakpointObserver,
-  withDrag,
-  withExtraConfig,
-  withFreezedOptions,
-  withGroup,
-  withIntersectionObserver,
-  withMountOnMediaQuery,
-  withMountWhenInView,
-  withMountWhenPrefersMotion,
-  withMutation,
-  withName,
-  withRelativePointer,
-  withResponsiveOptions,
-  withScrolledInView
-} from "./decorators/index.js";
-import {
-  closestComponent,
-  createApp,
-  defineFeatures,
-  getClosestParent,
-  getDirectChildren,
-  getInstanceFromElement,
-  importOnInteraction,
-  importOnMediaQuery,
-  importWhenIdle,
-  importWhenPrefersMotion,
-  importWhenVisible,
-  isDirectChild,
-  logTree,
-  queryComponent,
-  queryComponentAll,
-  registerComponent,
-  registerComponents
-} from "./helpers/index.js";
-import {
-  AbstractService,
-  DragService,
-  KeyService,
-  LoadService,
-  MutationService,
-  PointerService,
-  RafService,
-  ResizeService,
-  ScrollService,
-  useDrag,
-  useKey,
-  useLoad,
-  useMutation,
-  usePointer,
-  useRaf,
-  useResize,
-  useScroll
-} from "./services/index.js";
-import {
-  ComponentLoader,
-  DEFAULT_DIAGNOSTIC_PREFIX,
-  VISIBLE_ROOT_MARGIN,
-  IDLE_TIMEOUT,
-  autoload,
-  composeManifests,
-  registerManifest,
-  registerManifests,
-  readEagerTokens,
-  defineManifest,
-  fromMetaGlob,
-  fromWebpackContext
-} from "./autoload/index.js";
-export {
-  AbstractService,
-  Base,
-  ComponentLoader,
-  DEFAULT_DIAGNOSTIC_PREFIX,
-  DragService,
-  IDLE_TIMEOUT,
-  KeyService,
-  LoadService,
-  MutationService,
-  PointerService,
-  RafService,
-  ResizeService,
-  ScrollService,
-  VISIBLE_ROOT_MARGIN,
-  autoload,
-  closestComponent,
-  composeManifests,
-  createApp,
-  defineFeatures,
-  defineManifest,
-  fromMetaGlob,
-  fromWebpackContext,
-  getClosestParent,
-  getDirectChildren,
-  getInstanceFromElement,
-  getInstances,
-  getScopedGroups,
-  importOnInteraction,
-  importOnMediaQuery,
-  importWhenIdle,
-  importWhenPrefersMotion,
-  importWhenVisible,
-  isDirectChild,
-  logTree,
-  queryComponent,
-  queryComponentAll,
-  readEagerTokens,
-  registerComponent,
-  registerComponents,
-  registerManifest,
-  registerManifests,
-  useDrag,
-  useKey,
-  useLoad,
-  useMutation,
-  usePointer,
-  useRaf,
-  useResize,
-  useScroll,
-  version,
-  withBreakpointManager,
-  withBreakpointObserver,
-  withDrag,
-  withExtraConfig,
-  withFreezedOptions,
-  withGroup,
-  withIntersectionObserver,
-  withMountOnMediaQuery,
-  withMountWhenInView,
-  withMountWhenPrefersMotion,
-  withMutation,
-  withName,
-  withRelativePointer,
-  withResponsiveOptions,
-  withScrolledInView
-};
-//# sourceMappingURL=index.js.map
+import { MOUNT_ATTRIBUTE, namespaceQualifier } from "./attributes.js";
+import { reportDiagnostic, warn } from "./diagnostics.js";
+import { defaultScheduler, nextFrame } from "./scheduler.js";
+import { watchAttributes, whenDOMSettled } from "./dom-mutations.js";
+import { createService, perTarget } from "./services/service.js";
+import { BREAKPOINTS, getBreakpoints, setBreakpoints, useBreakpoint } from "./services/breakpoint.js";
+import { EVENTS } from "./events.js";
+import { createContext, injectContext, injectContextSync, provideContext, provideRootContext, signal } from "./context.js";
+import { Base } from "./Base.js";
+import { watchAttributeNamespace } from "./attribute-namespaces.js";
+import { subscribeContext } from "./context-subscription.js";
+import { registerComponent, registerComponents, registerManifest } from "./registry.js";
+import { children, component, inject, on, provide, read, write } from "./decorators.js";
+import { DIAGNOSTICS } from "./diagnostic-contract.js";
+import { createGroup } from "./group.js";
+import { getInstance, getInstances, getMountedInstances, getUnmountedInstances } from "./instances.js";
+import { defineManifest, fromMetaGlob, fromWebpackContext } from "./manifest.js";
+import { domUpdate, emitExtendable } from "./negotiated-events.js";
+import { toggle } from "./services/toggle.js";
+import { createServiceMixin } from "./services/mixin.js";
+import { DRAG_MODES, useDrag, withDrag } from "./services/drag.js";
+import { useInView, withInView } from "./services/in-view.js";
+import { useKey, withKey } from "./services/key.js";
+import { useMediaQuery, usePrefersReducedMotion } from "./services/media.js";
+import { useMutation, withMutation } from "./services/mutation.js";
+import { usePointer, withPointer } from "./services/pointer.js";
+import { useRaf, withRaf } from "./services/raf.js";
+import { useResize, useWindowSize, withResize } from "./services/resize.js";
+import { useScroll, useWindowScroll, withScroll } from "./services/scroll.js";
+import { useScrollProgress, withScrollProgress } from "./services/scroll-progress.js";
+import { until } from "./services/until.js";
+import { createFallbackProvider, createMemoryStorageProvider, createUrlSearchParamsInHashProvider, createUrlSearchParamsProvider, localStorageProvider, memoryStorageProvider, sessionStorageProvider, urlSearchParamsInHashProvider, urlSearchParamsProvider } from "./storage/providers.js";
+import { jsonSerializer } from "./storage/serializers.js";
+import { createStorage } from "./storage/createStorage.js";
+import { createLocalStorage, createSessionStorage, createUrlSearchParamsInHashStorage, createUrlSearchParamsStorage } from "./storage/index.js";
+import { SWAP_MODES, swap } from "./swap.js";
+import { viewTransition } from "./viewTransition.js";
+export { BREAKPOINTS, Base, DIAGNOSTICS, DRAG_MODES, EVENTS, MOUNT_ATTRIBUTE, SWAP_MODES, children, component, createContext, createFallbackProvider, createGroup, createLocalStorage, createMemoryStorageProvider, createService, createServiceMixin, createSessionStorage, createStorage, createUrlSearchParamsInHashProvider, createUrlSearchParamsInHashStorage, createUrlSearchParamsProvider, createUrlSearchParamsStorage, defaultScheduler, defineManifest, domUpdate, emitExtendable, fromMetaGlob, fromWebpackContext, getBreakpoints, getInstance, getInstances, getMountedInstances, getUnmountedInstances, inject, injectContext, injectContextSync, jsonSerializer, localStorageProvider, memoryStorageProvider, namespaceQualifier, nextFrame, on, perTarget, provide, provideContext, provideRootContext, read, registerComponent, registerComponents, registerManifest, reportDiagnostic, sessionStorageProvider, setBreakpoints, signal, subscribeContext, swap, toggle, until, urlSearchParamsInHashProvider, urlSearchParamsProvider, useBreakpoint, useDrag, useInView, useKey, useMediaQuery, useMutation, usePointer, usePrefersReducedMotion, useRaf, useResize, useScroll, useScrollProgress, useWindowScroll, useWindowSize, viewTransition, warn, watchAttributeNamespace, watchAttributes, whenDOMSettled, withDrag, withInView, withKey, withMutation, withPointer, withRaf, withResize, withScroll, withScrollProgress, write };

package/dist/instances.d.ts

@@ -0,0 +1,86 @@
+import { Base } from "./Base.js";
+//#region src/instances.d.ts
+/**
+ * Every instance built for a component name, in DOM order, mounted or not.
+ *
+ * The search covers the descendants of `root` and never `root` itself, since
+ * it is a `querySelectorAll`. A **detached** element is therefore unreachable
+ * by this form even though it still carries its instance — pass the element
+ * to the overload below, or pass its detached root as `root`.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/getInstances.html
+ */
+declare function getInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];
+/**
+ * Every instance on one element, in mount order, mounted or not.
+ *
+ * The element form is the reason this overload exists rather than a second
+ * export: both answer "which instances are there", and the argument picks the
+ * scope. It also keeps the `INSTANCES` read in one place, which matters more
+ * now that the key is a symbol and no longer spellable as `el.__base__`.
+ *
+ * Unlike the string form it does not consult the DOM, so it answers for a
+ * detached element as readily as for a connected one.
+ */
+declare function getInstances<T extends Base = Base>(el: Element): T[];
+/**
+ * The live instances of a component name, in DOM order.
+ *
+ * This is the safe list to call a method on: every instance in it has run
+ * `mounted()` and has not yet run `unmounted()`. Prefer it over
+ * {@link getInstances} whenever the result is going to be *used* rather than
+ * counted or inspected.
+ *
+ * Scoping and the detached-element blind spot are {@link getInstances}'.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/getMountedInstances.html
+ */
+declare function getMountedInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];
+/** The live instances on one element, in mount order. Works when detached. */
+declare function getMountedInstances<T extends Base = Base>(el: Element): T[];
+/**
+ * The instances of a component name that were built and are not mounted, in
+ * DOM order.
+ *
+ * This population is small and specific. It is what a **reversible** mount
+ * strategy leaves behind: `in-view` and `media:` unmount their instance when
+ * the condition stops holding and keep it for the crossing back, so the
+ * instance stays in the element's map with `$isMounted === false`. A
+ * constructor that succeeded before a failing `mounted()` lands here too.
+ *
+ * What is *not* here: a declaration whose class never arrived, and a
+ * declaration withdrawn by a breakpoint. Neither has an instance at all.
+ *
+ * Scoping and the detached-element blind spot are {@link getInstances}'.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/getUnmountedInstances.html
+ */
+declare function getUnmountedInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];
+/** The built-but-unmounted instances on one element, in mount order. */
+declare function getUnmountedInstances<T extends Base = Base>(el: Element): T[];
+/**
+ * The instance of `name` on `el`, mounted or not.
+ *
+ * One map read and no scan, which is why it is a function of its own rather
+ * than a filter over {@link getInstances}: the caller already holds the
+ * element and the name, so there is nothing left to search. It is also the
+ * answer to "is this element's instance there yet", which every plural form
+ * loses by returning a list.
+ *
+ * `el` accepts `null` so that a `querySelector()` result can be passed
+ * straight through. The two ways of having no instance — no element, and an
+ * element without one — are the same answer to the caller, and `undefined`
+ * says it for both. Narrowing the parameter to `Element` would buy nothing
+ * back: the body reads an optional map either way, so the only thing a
+ * stricter type produces is a `!` at every call site that asserts something
+ * the function never needed.
+ *
+ * The *return* stays `T | undefined`, and that asymmetry is deliberate. An
+ * absent element is a fact the caller may reasonably not know; an absent
+ * instance is a fact the caller must handle.
+ *
+ * There is deliberately no `getMountedInstance`. The result is one object, so
+ * a caller who needs the live one reads `.$isMounted` on it — a second export
+ * would only hide that check behind a `undefined` that means two things.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/getInstance.html
+ */
+declare function getInstance<T extends Base = Base>(el: Element | null, name: string): T | undefined;
+//#endregion
+export { getInstance, getInstances, getMountedInstances, getUnmountedInstances };

package/dist/instances.js

@@ -0,0 +1,71 @@
+import { INSTANCES } from "./protocol-symbols.js";
+import { selectorFor } from "./utils/selectors.js";
+//#region src/instances.ts
+/**
+* The one traversal behind the three plural lookups.
+*
+* Written once rather than three times, because the traversal is the part
+* with the invariants — DOM order for a name, mount order for an element, the
+* instance-map read in between — and the three exports differ only in which
+* instances they keep. `accept` is that difference and nothing else.
+*
+* The string form narrows twice before `accept` ever runs.
+* {@link selectorFor} over-matches on purpose: it lists the responsive
+* spellings of `data-component` as well as the plain one, so an element that
+* declares a name only above a breakpoint is still a candidate. The
+* `INSTANCES` read is what removes it, because a declaration that is not
+* currently active has no instance — the registry destroys a
+* breakpoint-withdrawn one *and* deletes it from the map. So the map read,
+* not `accept`, is what keeps an inactive declaration out of every result.
+*/
+function collect(target, root, accept) {
+	if (typeof target !== "string") return [...target[INSTANCES]?.values() ?? []].filter(accept);
+	const instances = [];
+	for (const el of root.querySelectorAll(selectorFor(target))) {
+		const instance = el[INSTANCES]?.get(target);
+		if (instance && accept(instance)) instances.push(instance);
+	}
+	return instances;
+}
+function getInstances(target, root = document) {
+	return collect(target, root, () => true);
+}
+function getMountedInstances(target, root = document) {
+	return collect(target, root, (instance) => instance.$isMounted);
+}
+function getUnmountedInstances(target, root = document) {
+	return collect(target, root, (instance) => !instance.$isMounted);
+}
+/**
+* The instance of `name` on `el`, mounted or not.
+*
+* One map read and no scan, which is why it is a function of its own rather
+* than a filter over {@link getInstances}: the caller already holds the
+* element and the name, so there is nothing left to search. It is also the
+* answer to "is this element's instance there yet", which every plural form
+* loses by returning a list.
+*
+* `el` accepts `null` so that a `querySelector()` result can be passed
+* straight through. The two ways of having no instance — no element, and an
+* element without one — are the same answer to the caller, and `undefined`
+* says it for both. Narrowing the parameter to `Element` would buy nothing
+* back: the body reads an optional map either way, so the only thing a
+* stricter type produces is a `!` at every call site that asserts something
+* the function never needed.
+*
+* The *return* stays `T | undefined`, and that asymmetry is deliberate. An
+* absent element is a fact the caller may reasonably not know; an absent
+* instance is a fact the caller must handle.
+*
+* There is deliberately no `getMountedInstance`. The result is one object, so
+* a caller who needs the live one reads `.$isMounted` on it — a second export
+* would only hide that check behind a `undefined` that means two things.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/getInstance.html
+*/
+function getInstance(el, name) {
+	return el?.[INSTANCES]?.get(name);
+}
+//#endregion
+export { getInstance, getInstances, getMountedInstances, getUnmountedInstances };
+
+//# sourceMappingURL=instances.js.map

package/dist/instances.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instances.js","names":[],"sources":["../src/instances.ts"],"sourcesContent":["import { INSTANCES } from './protocol-symbols.js';\nimport { selectorFor } from './utils/selectors.js';\nimport type { Base } from './Base.js';\n\n/**\n * The one traversal behind the three plural lookups.\n *\n * Written once rather than three times, because the traversal is the part\n * with the invariants — DOM order for a name, mount order for an element, the\n * instance-map read in between — and the three exports differ only in which\n * instances they keep. `accept` is that difference and nothing else.\n *\n * The string form narrows twice before `accept` ever runs.\n * {@link selectorFor} over-matches on purpose: it lists the responsive\n * spellings of `data-component` as well as the plain one, so an element that\n * declares a name only above a breakpoint is still a candidate. The\n * `INSTANCES` read is what removes it, because a declaration that is not\n * currently active has no instance — the registry destroys a\n * breakpoint-withdrawn one *and* deletes it from the map. So the map read,\n * not `accept`, is what keeps an inactive declaration out of every result.\n */\nfunction collect<T extends Base>(\n  target: string | Element,\n  root: ParentNode,\n  accept: (instance: Base) => boolean,\n): T[] {\n  if (typeof target !== 'string') {\n    return [...(target[INSTANCES]?.values() ?? [])].filter(accept) as T[];\n  }\n\n  const instances: T[] = [];\n  for (const el of root.querySelectorAll(selectorFor(target))) {\n    const instance = el[INSTANCES]?.get(target);\n    if (instance && accept(instance)) {\n      instances.push(instance as T);\n    }\n  }\n  return instances;\n}\n\n/**\n * Every instance built for a component name, in DOM order, mounted or not.\n *\n * The search covers the descendants of `root` and never `root` itself, since\n * it is a `querySelectorAll`. A **detached** element is therefore unreachable\n * by this form even though it still carries its instance — pass the element\n * to the overload below, or pass its detached root as `root`.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/getInstances.html\n */\nexport function getInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];\n/**\n * Every instance on one element, in mount order, mounted or not.\n *\n * The element form is the reason this overload exists rather than a second\n * export: both answer \"which instances are there\", and the argument picks the\n * scope. It also keeps the `INSTANCES` read in one place, which matters more\n * now that the key is a symbol and no longer spellable as `el.__base__`.\n *\n * Unlike the string form it does not consult the DOM, so it answers for a\n * detached element as readily as for a connected one.\n */\nexport function getInstances<T extends Base = Base>(el: Element): T[];\nexport function getInstances<T extends Base = Base>(\n  target: string | Element,\n  root: ParentNode = document,\n): T[] {\n  return collect<T>(target, root, () => true);\n}\n\n/**\n * The live instances of a component name, in DOM order.\n *\n * This is the safe list to call a method on: every instance in it has run\n * `mounted()` and has not yet run `unmounted()`. Prefer it over\n * {@link getInstances} whenever the result is going to be *used* rather than\n * counted or inspected.\n *\n * Scoping and the detached-element blind spot are {@link getInstances}'.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/getMountedInstances.html\n */\nexport function getMountedInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];\n/** The live instances on one element, in mount order. Works when detached. */\nexport function getMountedInstances<T extends Base = Base>(el: Element): T[];\nexport function getMountedInstances<T extends Base = Base>(\n  target: string | Element,\n  root: ParentNode = document,\n): T[] {\n  return collect<T>(target, root, (instance) => instance.$isMounted);\n}\n\n/**\n * The instances of a component name that were built and are not mounted, in\n * DOM order.\n *\n * This population is small and specific. It is what a **reversible** mount\n * strategy leaves behind: `in-view` and `media:` unmount their instance when\n * the condition stops holding and keep it for the crossing back, so the\n * instance stays in the element's map with `$isMounted === false`. A\n * constructor that succeeded before a failing `mounted()` lands here too.\n *\n * What is *not* here: a declaration whose class never arrived, and a\n * declaration withdrawn by a breakpoint. Neither has an instance at all.\n *\n * Scoping and the detached-element blind spot are {@link getInstances}'.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/getUnmountedInstances.html\n */\nexport function getUnmountedInstances<T extends Base = Base>(name: string, root?: ParentNode): T[];\n/** The built-but-unmounted instances on one element, in mount order. */\nexport function getUnmountedInstances<T extends Base = Base>(el: Element): T[];\nexport function getUnmountedInstances<T extends Base = Base>(\n  target: string | Element,\n  root: ParentNode = document,\n): T[] {\n  return collect<T>(target, root, (instance) => !instance.$isMounted);\n}\n\n/**\n * The instance of `name` on `el`, mounted or not.\n *\n * One map read and no scan, which is why it is a function of its own rather\n * than a filter over {@link getInstances}: the caller already holds the\n * element and the name, so there is nothing left to search. It is also the\n * answer to \"is this element's instance there yet\", which every plural form\n * loses by returning a list.\n *\n * `el` accepts `null` so that a `querySelector()` result can be passed\n * straight through. The two ways of having no instance — no element, and an\n * element without one — are the same answer to the caller, and `undefined`\n * says it for both. Narrowing the parameter to `Element` would buy nothing\n * back: the body reads an optional map either way, so the only thing a\n * stricter type produces is a `!` at every call site that asserts something\n * the function never needed.\n *\n * The *return* stays `T | undefined`, and that asymmetry is deliberate. An\n * absent element is a fact the caller may reasonably not know; an absent\n * instance is a fact the caller must handle.\n *\n * There is deliberately no `getMountedInstance`. The result is one object, so\n * a caller who needs the live one reads `.$isMounted` on it — a second export\n * would only hide that check behind a `undefined` that means two things.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/getInstance.html\n */\nexport function getInstance<T extends Base = Base>(\n  el: Element | null,\n  name: string,\n): T | undefined {\n  return el?.[INSTANCES]?.get(name) as T | undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,SAAS,QACP,QACA,MACA,QACK;CACL,IAAI,OAAO,WAAW,UACpB,OAAO,CAAC,GAAI,OAAO,UAAU,EAAE,OAAO,KAAK,CAAC,CAAE,CAAC,CAAC,OAAO,MAAM;CAG/D,MAAM,YAAiB,CAAC;CACxB,KAAK,MAAM,MAAM,KAAK,iBAAiB,YAAY,MAAM,CAAC,GAAG;EAC3D,MAAM,WAAW,GAAG,UAAU,EAAE,IAAI,MAAM;EAC1C,IAAI,YAAY,OAAO,QAAQ,GAC7B,UAAU,KAAK,QAAa;CAEhC;CACA,OAAO;AACT;AAwBA,SAAgB,aACd,QACA,OAAmB,UACd;CACL,OAAO,QAAW,QAAQ,YAAY,IAAI;AAC5C;AAgBA,SAAgB,oBACd,QACA,OAAmB,UACd;CACL,OAAO,QAAW,QAAQ,OAAO,aAAa,SAAS,UAAU;AACnE;AAqBA,SAAgB,sBACd,QACA,OAAmB,UACd;CACL,OAAO,QAAW,QAAQ,OAAO,aAAa,CAAC,SAAS,UAAU;AACpE;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,YACd,IACA,MACe;CACf,OAAO,KAAK,UAAU,EAAE,IAAI,IAAI;AAClC"}

package/dist/manifest.d.ts

@@ -0,0 +1,36 @@
+import { MountStrategy } from "./mount-strategies.js";
+import { ComponentImporter } from "./Base.js";
+import { ComponentManifest } from "./registry.js";
+//#region src/manifest.d.ts
+/** Lazy module importers keyed by the paths a bundler matched. */
+type ModuleRecord = Record<string, ComponentImporter>;
+/** Options accepted by {@link defineManifest}. */
+interface DefineManifestOptions {
+  /** Lazy module importers keyed by their matched paths. */
+  modules: ModuleRecord;
+  /** One mount strategy for every generated entry. Defaults to `eager`. */
+  mountStrategy?: MountStrategy;
+}
+/** The structural shape of a webpack context, with no webpack dependency. */
+interface WebpackContextLike {
+  keys(): string[];
+  (id: string): unknown;
+}
+/**
+ * Build a lazy component manifest from bundler module importers without importing or registering
+ * anything. The registry resolves direct classes, named exports and default exports when needed.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/defineManifest.html
+ */
+declare function defineManifest({ modules, mountStrategy }: DefineManifestOptions): ComponentManifest;
+/**
+ * Return a lazy Vite glob unchanged, and reject eager glob values immediately.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/fromMetaGlob.html
+ */
+declare function fromMetaGlob(glob: Record<string, unknown>): ModuleRecord;
+/**
+ * Convert a webpack context to lazy importers without loading any matched module.
+ * @link https://js-toolkit-v4.studiometa.dev/api/registry/fromWebpackContext.html
+ */
+declare function fromWebpackContext(context: WebpackContextLike): ModuleRecord;
+//#endregion
+export { DefineManifestOptions, ModuleRecord, WebpackContextLike, defineManifest, fromMetaGlob, fromWebpackContext };

package/dist/manifest.js

@@ -0,0 +1,49 @@
+import { warnOnce } from "./diagnostics.js";
+//#region src/manifest.ts
+function deriveToken(path) {
+	const segments = path.split("/").filter((segment) => segment && segment !== ".");
+	const base = (segments.at(-1) ?? "").replace(/\.[^.]+$/, "");
+	return base === "index" && segments.length >= 2 ? segments.at(-2) : base;
+}
+/**
+* Build a lazy component manifest from bundler module importers without importing or registering
+* anything. The registry resolves direct classes, named exports and default exports when needed.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/defineManifest.html
+*/
+function defineManifest({ modules, mountStrategy }) {
+	const manifest = {};
+	const paths = /* @__PURE__ */ new Map();
+	for (const [path, importer] of Object.entries(modules)) {
+		const token = deriveToken(path);
+		const firstPath = paths.get(token);
+		if (firstPath !== void 0) {
+			warnOnce(modules, `${token}\0${firstPath}\0${path}`, "manifest.duplicate-token", `"${token}" is already derived from "${firstPath}"; ignoring "${path}".`);
+			continue;
+		}
+		paths.set(token, path);
+		manifest[token] = mountStrategy === void 0 || mountStrategy === "eager" ? importer : {
+			load: importer,
+			mountStrategy
+		};
+	}
+	return manifest;
+}
+/**
+* Return a lazy Vite glob unchanged, and reject eager glob values immediately.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/fromMetaGlob.html
+*/
+function fromMetaGlob(glob) {
+	for (const [path, importer] of Object.entries(glob)) if (typeof importer !== "function") throw new TypeError(`[manifest] fromMetaGlob() expects a lazy glob; "${path}" is not an importer function. Remove the { eager: true } option.`);
+	return glob;
+}
+/**
+* Convert a webpack context to lazy importers without loading any matched module.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/fromWebpackContext.html
+*/
+function fromWebpackContext(context) {
+	return Object.fromEntries(context.keys().map((key) => [key, () => Promise.resolve(context(key))]));
+}
+//#endregion
+export { defineManifest, fromMetaGlob, fromWebpackContext };
+
+//# sourceMappingURL=manifest.js.map