@lumx/vue 4.20.0-next.4 → 4.20.0

package/package.json

@@ -30,11 +30,11 @@
         }
     },
     "sideEffects": false,
-    "version": "4.20.0-next.4",
+    "version": "4.20.0",
     "dependencies": {
         "@floating-ui/vue": "^1.1.10",
-        "@lumx/core": "^4.20.0-next.4",
-        "@lumx/icons": "^4.20.0-next.4",
+        "@lumx/core": "^4.20.0",
+        "@lumx/icons": "^4.20.0",
         "@vueuse/core": "^14.1.0"
     },
     "peerDependencies": {
@@ -63,9 +63,8 @@
         "vite-plugin-dts": "^4.5.4",
         "vite-plugin-static-copy": "^3.1.4",
         "vite-tsconfig-paths": "^5.1.4",
-        "vitest": "^4.0.18",
+        "vitest": "^4.1.10",
         "vue": "^3.5.27",
         "vue-tsc": "^3.2.4"
-    },
-    "stableVersion": "4.19.0"
+    }
 }

package/utils/IdsRegistryContext/IdsRegistryContext.d.ts

@@ -0,0 +1,14 @@
+import { InjectionKey } from 'vue';
+import { IdsRegistry } from '@lumx/core/js/utils/idsRegistry/createIdsRegistry';
+/**
+ * Internal "ids registry" injection key.
+ *
+ * Not exported from the package barrel - lets a container expose ids registered by its descendants
+ * under well-known names, without either side knowing about the other upfront (e.g. to wire up
+ * `aria-labelledby`/`aria-describedby` between components that don't know about each other).
+ *
+ * `undefined` outside of any provider - `useRegisterId`/`useRegisteredId` are no-ops in that case.
+ *
+ * See `IdsRegistry` in `@lumx/core` for the shared contract.
+ */
+export declare const IDS_REGISTRY_KEY: InjectionKey<IdsRegistry>;

package/utils/IdsRegistryContext/IdsRegistryContext.test.d.ts

@@ -0,0 +1 @@
+export {};

package/utils/IdsRegistryContext/IdsRegistryProvider.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Provides a fresh ids registry to its subtree (via the default slot). The registry instance lives
+ * for the lifetime of the provider, so registering/reading an id never re-renders the whole subtree
+ * - only the components subscribed (via `useRegisteredId`) to the name that changed.
+ */
+export declare const IdsRegistryProvider: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/utils/IdsRegistryContext/index.d.ts

@@ -0,0 +1,3 @@
+export { IdsRegistryProvider } from './IdsRegistryProvider';
+export { useRegisterId } from './useRegisterId';
+export { useRegisteredId } from './useRegisteredId';

package/utils/IdsRegistryContext/useRegisterId.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Register the id returned by `getId` under `key` in the enclosing ids registry, keeping it up to
+ * date reactively, and clear it on unmount. Last registered wins; if another registrant is still
+ * mounted under the same key, clearing this one falls back to it instead of leaving the key empty.
+ *
+ * Call from a descendant's `setup`.
+ *
+ * @param key   Registry key to store the id under.
+ * @param getId Getter returning the id of the element to register.
+ */
+export declare function useRegisterId(key: string, getId: () => string | undefined): void;

package/utils/IdsRegistryContext/useRegisteredId.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+/**
+ * Subscribe to the id currently registered under `key` in the enclosing ids registry. The returned
+ * ref updates (and only re-renders the reading component) when that key's id changes.
+ *
+ * Call from a descendant's `setup`.
+ *
+ * @param  key Registry key to read.
+ * @return A ref holding the registered id (`undefined` when none / outside any provider).
+ */
+export declare function useRegisteredId(key: string): Ref<string | undefined>;