@k8slens/hotbar-contracts 1.0.1

package/dist/src/has-hotbar-item.d.ts

@@ -0,0 +1,27 @@
+import type { IComputedValue } from "mobx";
+import type { HotbarItem } from "./hotbar-item";
+/** Whether the item, as `{ id, kind }`, is on the current hotbar page, as of now. */
+export type HasHotbarItem = (item: HotbarItem) => Promise<boolean>;
+/**
+ * The hotbar's own membership query: one implementation for every kind, asked with the whole
+ * `{ id, kind }`. `getHotbarItemKindInjectableBunch` builds `isInHotbarInjectionToken.for(kind)`
+ * on it, so reach for that one instead.
+ *
+ * Implemented by the hotbar.
+ */
+export declare const hasHotbarItemInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => HasHotbarItem, () => HasHotbarItem[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<HasHotbarItem>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<HasHotbarItem>[]> & {
+    readonly __abstract?: never;
+};
+/** Whether the item, as `{ id, kind }`, is on the current hotbar page, reactively. */
+export type HasHotbarItemReactive = (item: HotbarItem) => IComputedValue<boolean>;
+/**
+ * The hotbar's own reactive membership query, asked with the whole `{ id, kind }`.
+ * `getHotbarItemKindInjectableBunch` builds `isInHotbarReactiveInjectionToken.for(kind)` on it,
+ * so reach for that one instead.
+ *
+ * Implemented by the hotbar.
+ */
+export declare const hasHotbarItemReactiveInjectionToken: import("@k8slens/injectable").InjectionToken2Base<HasHotbarItemReactive, (item: HotbarItem) => IComputedValue<boolean>[], "one", (item: HotbarItem) => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<boolean>>, (item: HotbarItem) => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<boolean>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=has-hotbar-item.d.ts.map

package/dist/src/has-hotbar-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-hotbar-item.d.ts","sourceRoot":"","sources":["../../src/has-hotbar-item.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,qFAAqF;AACrF,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,0DAA6C,aAAa;;CAG9F,CAAC;AAEL,sFAAsF;AACtF,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,cAAc,CAAC,OAAO,CAAC,CAAC;AAElF;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;CAG5C,CAAC"}

package/dist/src/hotbar-item-component.d.ts

@@ -0,0 +1,44 @@
+import { type ManyFactory, type MaybeResultFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type React from "react";
+import type { HotbarItem } from "./hotbar-item";
+import { type HotbarItemKind } from "./hotbar-item-kind";
+/** What the hotbar hands a kind's component: the item, as `{ id, kind }`. */
+export type HotbarItemComponentProps = {
+    item: HotbarItem;
+};
+/**
+ * Renders one item of a kind inside its hotbar slot. The hotbar hands it the item only;
+ * the component resolves whatever else it needs from the item's id and kind.
+ */
+export type HotbarItemComponent = React.ComponentType<HotbarItemComponentProps>;
+/** How the component is registered: a v2 token models a factory, so a component is wrapped in one. */
+export type HotbarItemComponentFactory = () => HotbarItemComponent;
+/** What `.for(kind).for(scopeIds)` yields: at most one component per kind per scope. */
+export type HotbarItemComponentTokenFor = SpecificInjectionToken2<{
+    singleFactory: HotbarItemComponentFactory;
+    maybeFactory: MaybeResultFactory<HotbarItemComponentFactory>;
+    specificTokenFactory: undefined;
+    cardinality: "zero-or-one";
+}>;
+/** What `.for(kind)` yields: the kind's components, one per scope, reached with `.for(scopeIds)`. */
+export type HotbarItemComponentTokenForKind = SpecificInjectionToken2<{
+    singleFactory: HotbarItemComponentFactory;
+    manyFactory: ManyFactory<HotbarItemComponentFactory>;
+    specificTokenFactory: (scopeIds: readonly string[]) => HotbarItemComponentTokenFor;
+    cardinality: "zero-or-many";
+}>;
+declare const hotbarItemComponentTokenForKind: (kind: HotbarItemKind<any>) => HotbarItemComponentTokenForKind;
+/**
+ * How the hotbar renders an item: the component registered for the item's kind, via
+ * `.for(kind).for(scopeIds)`. A kind with no component is unknown to the hotbar, and its items
+ * render as unavailable.
+ *
+ * `getHotbarItemKindInjectableBunch` registers this for a kind; prefer it over binding
+ * to the token by hand, since it also wires the persisted data and the adder.
+ */
+export declare const hotbarItemComponentInjectionToken: import("@k8slens/injectable").InjectionToken2Base<HotbarItemComponentFactory, () => HotbarItemComponent[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<HotbarItemComponent>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<HotbarItemComponent>[]> & {
+    readonly __abstract: true;
+    for: typeof hotbarItemComponentTokenForKind;
+};
+export {};
+//# sourceMappingURL=hotbar-item-component.d.ts.map

package/dist/src/hotbar-item-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-component.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE9E,6EAA6E;AAC7E,MAAM,MAAM,wBAAwB,GAAG;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC;AAEhF,sGAAsG;AACtG,MAAM,MAAM,0BAA0B,GAAG,MAAM,mBAAmB,CAAC;AAEnE,wFAAwF;AACxF,MAAM,MAAM,2BAA2B,GAAG,uBAAuB,CAAC;IAChE,aAAa,EAAE,0BAA0B,CAAC;IAC1C,YAAY,EAAE,kBAAkB,CAAC,0BAA0B,CAAC,CAAC;IAC7D,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,aAAa,CAAC;CAC5B,CAAC,CAAC;AAEH,qGAAqG;AACrG,MAAM,MAAM,+BAA+B,GAAG,uBAAuB,CAAC;IACpE,aAAa,EAAE,0BAA0B,CAAC;IAC1C,WAAW,EAAE,WAAW,CAAC,0BAA0B,CAAC,CAAC;IACrD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,2BAA2B,CAAC;IACnF,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH,QAAA,MAAM,+BAA+B,SAAU,cAAc,CAAC,GAAG,CAAC,KAAG,+BAkBlE,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC;;;CAMX,CAAC"}

package/dist/src/hotbar-item-context-menu-item.d.ts

@@ -0,0 +1,48 @@
+import { type ManyFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type { MenuItem } from "@k8slens/drop-down-menu-contracts";
+import type { MaybePromise } from "@k8slens/public-utilities";
+import type { HotbarItemId } from "./hotbar-item-id";
+import { type HotbarItemKind } from "./hotbar-item-kind";
+/** Produces the menu item for one hotbar item, possibly later. */
+export type HotbarItemContextMenuItemFor = (id: HotbarItemId) => MaybePromise<MenuItem>;
+/** What `.for(kind).for(scopeIds)` yields: the menu items contributed to one kind as registered under those scopes. */
+export type HotbarItemContextMenuItemTokenFor = SpecificInjectionToken2<{
+    singleFactory: HotbarItemContextMenuItemFor;
+    manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;
+    specificTokenFactory: undefined;
+    cardinality: "zero-or-many";
+}>;
+/** What `.for(kind)` yields: the kind's menu items, per scope, reached with `.for(scopeIds)`. */
+export type HotbarItemContextMenuItemTokenForKind = SpecificInjectionToken2<{
+    singleFactory: HotbarItemContextMenuItemFor;
+    manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;
+    specificTokenFactory: (scopeIds: readonly string[]) => HotbarItemContextMenuItemTokenFor;
+    cardinality: "zero-or-many";
+}>;
+/**
+ * The right-click menu of a hotbar item: one entry per contribution, registered against the
+ * item's kind via `.for(kind).for(scopeIds)`. The scopes are those of the registration, so the
+ * `injectionToken` is given as a function of them. The hotbar contributes the way to remove
+ * the item to every kind itself.
+ *
+ * @example
+ * ```ts
+ * export const openBookmarkInBrowserInjectable = getInjectable2({
+ *   id: "open-bookmark-in-browser",
+ *   instantiate: () => (id): MenuItem => ({
+ *     id: "open-in-browser",
+ *     kind: "action",
+ *     labelText: "Open in browser",
+ *     onClick: () => openInBrowser(urlOf(id)),
+ *     orderNumber: 10,
+ *     parentId: undefined,
+ *   }),
+ *   injectionToken: ({ scopeIds }) => hotbarItemContextMenuItemInjectionToken.for(bookmarkHotbarItemKind).for(scopeIds),
+ * });
+ * ```
+ */
+export declare const hotbarItemContextMenuItemInjectionToken: import("@k8slens/injectable").InjectionToken2Base<HotbarItemContextMenuItemFor, (id: string) => MaybePromise<MenuItem>[], "zero-or-many", (id: string) => import("@k8slens/injectable").InjectionInstanceWithMeta<MaybePromise<MenuItem>>, (id: string) => import("@k8slens/injectable").InjectionInstanceWithMeta<MaybePromise<MenuItem>>[]> & {
+    readonly __abstract: true;
+    for: (kind: HotbarItemKind<any>) => HotbarItemContextMenuItemTokenForKind;
+};
+//# sourceMappingURL=hotbar-item-context-menu-item.d.ts.map

package/dist/src/hotbar-item-context-menu-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-context-menu-item.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-context-menu-item.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,WAAW,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACzG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE9E,kEAAkE;AAClE,MAAM,MAAM,4BAA4B,GAAG,CAAC,EAAE,EAAE,YAAY,KAAK,YAAY,CAAC,QAAQ,CAAC,CAAC;AAExF,uHAAuH;AACvH,MAAM,MAAM,iCAAiC,GAAG,uBAAuB,CAAC;IACtE,aAAa,EAAE,4BAA4B,CAAC;IAC5C,WAAW,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;IACvD,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH,iGAAiG;AACjG,MAAM,MAAM,qCAAqC,GAAG,uBAAuB,CAAC;IAC1E,aAAa,EAAE,4BAA4B,CAAC;IAC5C,WAAW,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;IACvD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,iCAAiC,CAAC;IACzF,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uCAAuC;;gBAO3C,cAAc,CAAC,GAAG,CAAC,KAAG,qCAAqC;CAmBnE,CAAC"}

package/dist/src/hotbar-item-frame.d.ts

@@ -0,0 +1,18 @@
+import type React from "react";
+import type { HotbarItem } from "./hotbar-item";
+export interface HotbarItemFrameProps {
+    readonly item: HotbarItem;
+    readonly children?: React.ReactNode;
+}
+/**
+ * What every hotbar item sits in: the slot's chrome, plus the item's right-click menu,
+ * which is where the hotbar offers to remove the item. Whatever is rendered inside decides
+ * what clicking the item does.
+ *
+ * Implemented by the hotbar. `getHotbarItemKindInjectableBunch` wraps a kind's component
+ * in it, so a kind needs to render only its own content.
+ */
+export declare const HotbarItemFrame: React.ComponentType<HotbarItemFrameProps> & import("@k8slens/injectable").InjectionToken2Base<() => React.ComponentType<HotbarItemFrameProps>, () => React.ComponentType<HotbarItemFrameProps>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<HotbarItemFrameProps>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<HotbarItemFrameProps>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=hotbar-item-frame.d.ts.map

package/dist/src/hotbar-item-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-frame.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-frame.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;CAExB,CAAC"}

package/dist/src/hotbar-item-id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Identifies one item in the hotbar. Ids are global across kinds, so a kind should
+ * namespace the ids it hands out (for example `my-extension-bookmark(<url>)`).
+ */
+export type HotbarItemId = string;
+//# sourceMappingURL=hotbar-item-id.d.ts.map

package/dist/src/hotbar-item-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-id.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC"}

package/dist/src/hotbar-item-kind.d.ts

@@ -0,0 +1,69 @@
+import { type TypedSpecifier, type TypedSpecifierType } from "@k8slens/injectable";
+/**
+ * Identifies one kind of hotbar item: what an item is, as opposed to which item it is.
+ * Every item in the hotbar is persisted as `{ id, kind }`, and the kind decides how the
+ * item renders.
+ *
+ * `PersistedData` is what the hotbar persists next to the item's id when the item is
+ * added, and hands back to the kind's component whenever the item renders. A kind
+ * created without `PersistedData` persists nothing beyond the id.
+ *
+ * At runtime a kind is a branded string, so it is usable as a `.for()` key.
+ */
+export type HotbarItemKind<PersistedData = unknown> = TypedSpecifier<string, {
+    persistedData: PersistedData;
+}>;
+/**
+ * Recovers the persisted data type bound to a {@link HotbarItemKind} or a {@link HotbarItemKindId}.
+ */
+export type HotbarItemPersistedData<K extends HotbarItemKind<any> | HotbarItemKindId<any>> = TypedSpecifierType<"persistedData", K>;
+/**
+ * What the hotbar knows a kind by: the kind's specifier, scoped to whoever registered it, as
+ * one string. It is what the hotbar persists as an item's `kind` and what keys the kind's
+ * persisted data. Two extensions declaring a kind with the same specifier get two ids, because
+ * their scopes differ; the specifier alone is never an identity.
+ *
+ * The tokens take the two parts separately, `token.for(kind).for(scopeIds)`; the id is the
+ * hotbar's side of the same identity. Made by {@link getHotbarItemKindId}, taken apart by
+ * {@link parseHotbarItemKindId}. Typed by the kind's persisted data, like the kind itself.
+ */
+export type HotbarItemKindId<PersistedData = unknown> = TypedSpecifier<string, {
+    persistedData: PersistedData;
+    scopedHotbarItemKind: true;
+}>;
+/**
+ * The id of a kind as registered under the given scopes: the scope ids, then the specifier,
+ * joined with ":", which is why a specifier may not contain one. The same kind under the same
+ * scopes always yields the same id. The hotbar computes it from an item's kind and scopes;
+ * a kind's own code has no need for it, the tokens take the parts.
+ */
+export declare const getHotbarItemKindId: <K extends HotbarItemKind<any>>(kind: K, scopeIds: readonly string[]) => HotbarItemKindId<HotbarItemPersistedData<K>>;
+/**
+ * The two parts of a kind id: the scopes the kind was registered under and the kind itself,
+ * as the tokens take them: `token.for(kind).for(scopeIds)`. The inverse of
+ * {@link getHotbarItemKindId}. A kind registered at container level, or persisted before kinds
+ * were scoped, parses to no scopes.
+ */
+export declare const parseHotbarItemKindId: <Data>(kindId: HotbarItemKindId<Data>) => {
+    readonly kind: HotbarItemKind<Data>;
+    readonly scopeIds: readonly string[];
+};
+/**
+ * Curried creator for a {@link HotbarItemKind}. The first call binds the persisted data
+ * type; the second the globally unique specifier string. Register the kind with
+ * `getHotbarItemKindInjectableBunch`, then add items of it with
+ * `addToHotbarInjectionToken.for(kind)`.
+ *
+ * @example
+ * ```ts
+ * // A kind whose items carry a URL:
+ * export const bookmarkHotbarItemKind = getHotbarItemKind<{ url: string }>()("my-extension-bookmark");
+ *
+ * // A kind whose items need nothing beyond their id:
+ * export const dashboardHotbarItemKind = getHotbarItemKind()("my-extension-dashboard");
+ * ```
+ */
+export declare const getHotbarItemKind: <PersistedData = void>() => <S extends string>(specifier: S) => TypedSpecifier<S, {
+    persistedData: PersistedData;
+}>;
+//# sourceMappingURL=hotbar-item-kind.d.ts.map

package/dist/src/hotbar-item-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-kind.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-kind.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEtG;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,CAAC,aAAa,GAAG,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAE/G;;GAEG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,kBAAkB,CAC7G,eAAe,EACf,CAAC,CACF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,CAAC,aAAa,GAAG,OAAO,IAAI,cAAc,CACpE,MAAM,EACN;IAAE,aAAa,EAAE,aAAa,CAAC;IAAC,oBAAoB,EAAE,IAAI,CAAA;CAAE,CAC7D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC,QACzD,CAAC,YACG,SAAS,MAAM,EAAE,KAC1B,gBAAgB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CACiC,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,GAAI,IAAI,UAChC,gBAAgB,CAAC,IAAI,CAAC,KAC7B;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAO7E,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC3B,aAAa,GAAG,IAAI,QACpB,CAAC,SAAS,MAAM,aAAa,CAAC;mBAOa,aAAa;EACxD,CAAC"}

package/dist/src/hotbar-item-persisted-data.d.ts

@@ -0,0 +1,33 @@
+import type { IComputedValue } from "mobx";
+import type { HotbarItemId } from "./hotbar-item-id";
+import type { HotbarItemKindId } from "./hotbar-item-kind";
+/**
+ * The persisted data of one item, wrapped so that "no data persisted" and "persisted
+ * `undefined`" (a kind without data) stay distinguishable.
+ */
+export interface HotbarItemPersistedDataEntry<PersistedData = unknown> {
+    readonly persistedData: PersistedData;
+}
+/**
+ * The persisted data of every item of one kind, keyed by item id.
+ */
+export interface HotbarItemPersistedDataStore<PersistedData = unknown> {
+    /** The item's entry, `undefined` until the store has loaded and while the item has none. */
+    readonly get: (id: HotbarItemId) => IComputedValue<HotbarItemPersistedDataEntry<PersistedData> | undefined>;
+    /** Persists the item's data, resolving once the store has loaded and taken it. */
+    readonly set: (id: HotbarItemId, persistedData: PersistedData) => Promise<void>;
+}
+/** What {@link hotbarItemPersistedDataInjectionToken} yields: the store of one kind, by the kind's id. */
+export type HotbarItemPersistedDataStoreFor = (kindId: HotbarItemKindId<any>) => HotbarItemPersistedDataStore;
+/**
+ * Where the hotbar keeps the persisted data of items, one store per kind. The data is
+ * typed by the kind, which is why the store itself is untyped: `getHotbarItemKindInjectableBunch`
+ * binds the type on both the way in (the adder) and the way out (the component), so a kind
+ * never touches this directly.
+ *
+ * Implemented by the hotbar.
+ */
+export declare const hotbarItemPersistedDataInjectionToken: import("@k8slens/injectable").InjectionToken2Base<HotbarItemPersistedDataStoreFor, (kindId: HotbarItemKindId<any>) => HotbarItemPersistedDataStore<unknown>[], "one", (kindId: HotbarItemKindId<any>) => import("@k8slens/injectable").InjectionInstanceWithMeta<HotbarItemPersistedDataStore<unknown>>, (kindId: HotbarItemKindId<any>) => import("@k8slens/injectable").InjectionInstanceWithMeta<HotbarItemPersistedDataStore<unknown>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=hotbar-item-persisted-data.d.ts.map

package/dist/src/hotbar-item-persisted-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item-persisted-data.d.ts","sourceRoot":"","sources":["../../src/hotbar-item-persisted-data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,4BAA4B,CAAC,aAAa,GAAG,OAAO;IACnE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B,CAAC,aAAa,GAAG,OAAO;IACnE,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,cAAc,CAAC,4BAA4B,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5G,kFAAkF;IAClF,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,aAAa,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjF;AAED,0GAA0G;AAC1G,MAAM,MAAM,+BAA+B,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,4BAA4B,CAAC;AAE9G;;;;;;;GAOG;AACH,eAAO,MAAM,qCAAqC;;CAK9C,CAAC"}

package/dist/src/hotbar-item.d.ts

@@ -0,0 +1,12 @@
+import type { HotbarItemId } from "./hotbar-item-id";
+import type { HotbarItemKindId } from "./hotbar-item-kind";
+/**
+ * One item in the hotbar, as the hotbar persists it: which item it is, and what kind of
+ * item it is, as the kind's id. Anything else an item needs travels as the kind's persisted
+ * data.
+ */
+export type HotbarItem = {
+    id: HotbarItemId;
+    kind: HotbarItemKindId;
+};
+//# sourceMappingURL=hotbar-item.d.ts.map

package/dist/src/hotbar-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotbar-item.d.ts","sourceRoot":"","sources":["../../src/hotbar-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAC;IACjB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC"}

package/dist/src/insert-hotbar-item.d.ts

@@ -0,0 +1,17 @@
+import type { HotbarItem } from "./hotbar-item";
+/**
+ * Puts an item into the first free slot of the current hotbar page. Tells the user when
+ * there is none, or when the item's kind is unknown, instead of throwing.
+ */
+export type InsertHotbarItem = (item: HotbarItem) => Promise<void>;
+/**
+ * The hotbar's own insertion: id and kind only, no persisted data. The typed adder a kind
+ * gets from `addToHotbarInjectionToken.for(kind)` persists the data first and then comes
+ * here, so reach for that one instead.
+ *
+ * Implemented by the hotbar.
+ */
+export declare const insertHotbarItemInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => InsertHotbarItem, () => InsertHotbarItem[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<InsertHotbarItem>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<InsertHotbarItem>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=insert-hotbar-item.d.ts.map

package/dist/src/insert-hotbar-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-hotbar-item.d.ts","sourceRoot":"","sources":["../../src/insert-hotbar-item.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,0DAA6C,gBAAgB;;CAGpG,CAAC"}

package/dist/src/is-in-hotbar.d.ts

@@ -0,0 +1,89 @@
+import { type ManyFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type { IComputedValue } from "mobx";
+import type { HotbarItemId } from "./hotbar-item-id";
+import { type HotbarItemKind } from "./hotbar-item-kind";
+/** Whether the item of the kind with the id is on the current hotbar page, as of now. */
+export type IsInHotbar = (id: HotbarItemId) => Promise<boolean>;
+/** What `.for(kind).for(scopeIds)` yields: exactly one membership query per kind per scope. */
+export type IsInHotbarTokenFor = SpecificInjectionToken2<{
+    singleFactory: () => IsInHotbar;
+    specificTokenFactory: undefined;
+    cardinality: "one";
+}>;
+/** What `.for(kind)` yields: the kind's membership queries, one per scope, reached with `.for(scopeIds)`. */
+export type IsInHotbarTokenForKind = SpecificInjectionToken2<{
+    singleFactory: () => IsInHotbar;
+    manyFactory: ManyFactory<() => IsInHotbar>;
+    specificTokenFactory: (scopeIds: readonly string[]) => IsInHotbarTokenFor;
+    cardinality: "zero-or-many";
+}>;
+declare const isInHotbarTokenForKind: (kind: HotbarItemKind<any>) => IsInHotbarTokenForKind;
+/**
+ * Whether an item is in the hotbar, asked once: `.for(kind).for(scopeIds)` yields the query
+ * of that kind as registered under those scopes, which takes the id. An item is identified by
+ * its kind and then its id, never by the id alone, so two kinds using the same id never answer
+ * for each other; the scopes come from the `di.scopeIds` of the injectable asking. For
+ * deciding in a handler, say whether a click should add the item or remove it.
+ *
+ * A promise rather than a boolean because the hotbar loads what it persisted lazily: asked
+ * before that, a boolean could only be a guess. For following the answer as it changes, see
+ * {@link isInHotbarReactiveInjectionToken}.
+ *
+ * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one.
+ *
+ * @example
+ * ```ts
+ * const isBookmarkInHotbar = di.inject(isInHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();
+ *
+ * if (await isBookmarkInHotbar(id)) {
+ *   await removeBookmarkFromHotbar(id);
+ * } else {
+ *   await addBookmarkToHotbar({ id, persistedData: { url } });
+ * }
+ * ```
+ */
+export declare const isInHotbarInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => IsInHotbar, () => IsInHotbar[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<IsInHotbar>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<IsInHotbar>[]> & {
+    readonly __abstract: true;
+    for: typeof isInHotbarTokenForKind;
+};
+/** Whether the item of the kind with the id is on the current hotbar page, reactively. */
+export type IsInHotbarReactive = (id: HotbarItemId) => IComputedValue<boolean>;
+/** What `.for(kind).for(scopeIds)` yields: exactly one reactive membership query per kind per scope. */
+export type IsInHotbarReactiveTokenFor = SpecificInjectionToken2<{
+    singleFactory: IsInHotbarReactive;
+    specificTokenFactory: undefined;
+    cardinality: "one";
+}>;
+/** What `.for(kind)` yields: the kind's reactive membership queries, one per scope, reached with `.for(scopeIds)`. */
+export type IsInHotbarReactiveTokenForKind = SpecificInjectionToken2<{
+    singleFactory: IsInHotbarReactive;
+    manyFactory: ManyFactory<IsInHotbarReactive>;
+    specificTokenFactory: (scopeIds: readonly string[]) => IsInHotbarReactiveTokenFor;
+    cardinality: "zero-or-many";
+}>;
+declare const isInHotbarReactiveTokenForKind: (kind: HotbarItemKind<any>) => IsInHotbarReactiveTokenForKind;
+/**
+ * Whether an item is in the hotbar, as a MobX computed: `.for(kind).for(scopeIds)` yields the
+ * query of that kind as registered under those scopes, which takes the id. Read it under an
+ * observer (or a reaction) to follow the user pinning and unpinning. `false` until the hotbar
+ * has loaded what it persisted. For a one-off answer, see {@link isInHotbarInjectionToken}.
+ *
+ * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one. A
+ * component has no scope of its own, so it takes the query from an injectable that reached it
+ * with its `di.scopeIds`.
+ *
+ * @example
+ * ```tsx
+ * const PinState = observer(({ url }: { url: string }) => {
+ *   const isInHotbar = useInject(isBookmarkInHotbarReactiveInjectable)(idOf(url)).get();
+ *
+ *   return <span>{isInHotbar ? "Pinned" : "Not pinned"}</span>;
+ * });
+ * ```
+ */
+export declare const isInHotbarReactiveInjectionToken: import("@k8slens/injectable").InjectionToken2Base<IsInHotbarReactive, (id: string) => IComputedValue<boolean>[], "zero-or-many", (id: string) => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<boolean>>, (id: string) => import("@k8slens/injectable").InjectionInstanceWithMeta<IComputedValue<boolean>>[]> & {
+    readonly __abstract: true;
+    for: typeof isInHotbarReactiveTokenForKind;
+};
+export {};
+//# sourceMappingURL=is-in-hotbar.d.ts.map

package/dist/src/is-in-hotbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-in-hotbar.d.ts","sourceRoot":"","sources":["../../src/is-in-hotbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,WAAW,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACzG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE9E,yFAAyF;AACzF,MAAM,MAAM,UAAU,GAAG,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhE,+FAA+F;AAC/F,MAAM,MAAM,kBAAkB,GAAG,uBAAuB,CAAC;IACvD,aAAa,EAAE,MAAM,UAAU,CAAC;IAChC,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC;CACpB,CAAC,CAAC;AAEH,6GAA6G;AAC7G,MAAM,MAAM,sBAAsB,GAAG,uBAAuB,CAAC;IAC3D,aAAa,EAAE,MAAM,UAAU,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC,MAAM,UAAU,CAAC,CAAC;IAC3C,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,kBAAkB,CAAC;IAC1E,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH,QAAA,MAAM,sBAAsB,SAAU,cAAc,CAAC,GAAG,CAAC,KAAG,sBAYzD,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB,0DACd,UAAU;;;CAKP,CAAC;AAE3B,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,CAAC,EAAE,EAAE,YAAY,KAAK,cAAc,CAAC,OAAO,CAAC,CAAC;AAE/E,wGAAwG;AACxG,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,CAAC;IAC/D,aAAa,EAAE,kBAAkB,CAAC;IAClC,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC;CACpB,CAAC,CAAC;AAEH,sHAAsH;AACtH,MAAM,MAAM,8BAA8B,GAAG,uBAAuB,CAAC;IACnE,aAAa,EAAE,kBAAkB,CAAC;IAClC,WAAW,EAAE,WAAW,CAAC,kBAAkB,CAAC,CAAC;IAC7C,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,0BAA0B,CAAC;IAClF,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH,QAAA,MAAM,8BAA8B,SAAU,cAAc,CAAC,GAAG,CAAC,KAAG,8BAYjE,CAAC;AAEJ;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gCAAgC;;;CAMX,CAAC"}

package/dist/src/remove-from-hotbar.d.ts

@@ -0,0 +1,47 @@
+import { type ManyFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type { HotbarItemId } from "./hotbar-item-id";
+import { type HotbarItemKind } from "./hotbar-item-kind";
+/**
+ * Removes the item of the kind with the id from the current hotbar page. Throws when no
+ * such item is there.
+ */
+export type RemoveFromHotbar = (id: HotbarItemId) => Promise<void>;
+/** What `.for(kind).for(scopeIds)` yields: exactly one remover per kind per scope. */
+export type RemoveFromHotbarTokenFor = SpecificInjectionToken2<{
+    singleFactory: () => RemoveFromHotbar;
+    specificTokenFactory: undefined;
+    cardinality: "one";
+}>;
+/** What `.for(kind)` yields: the kind's removers, one per scope, reached with `.for(scopeIds)`. */
+export type RemoveFromHotbarTokenForKind = SpecificInjectionToken2<{
+    singleFactory: () => RemoveFromHotbar;
+    manyFactory: ManyFactory<() => RemoveFromHotbar>;
+    specificTokenFactory: (scopeIds: readonly string[]) => RemoveFromHotbarTokenFor;
+    cardinality: "zero-or-many";
+}>;
+declare const removeFromHotbarTokenForKind: (kind: HotbarItemKind<any>) => RemoveFromHotbarTokenForKind;
+/**
+ * Remove an item from the hotbar: `.for(kind).for(scopeIds)` yields the remover of that kind
+ * as registered under those scopes, which takes the id. An item is identified by its kind and
+ * then its id, so removing one kind's item leaves another kind's item with the same id alone.
+ * The persisted data of the item is left in place, so adding the same id back finds it again.
+ * The scopes come from the `di.scopeIds` of the injectable asking.
+ *
+ * Throws when no item of the kind with the id is on the current page: removing is something
+ * done to an item known to be there, so a toggle asks {@link isInHotbarInjectionToken} first.
+ *
+ * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one.
+ *
+ * @example
+ * ```ts
+ * const removeBookmarkFromHotbar = di.inject(removeFromHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();
+ *
+ * await removeBookmarkFromHotbar(`my-extension-bookmark(${url})`);
+ * ```
+ */
+export declare const removeFromHotbarInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => RemoveFromHotbar, () => RemoveFromHotbar[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<RemoveFromHotbar>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<RemoveFromHotbar>[]> & {
+    readonly __abstract: true;
+    for: typeof removeFromHotbarTokenForKind;
+};
+export {};
+//# sourceMappingURL=remove-from-hotbar.d.ts.map

package/dist/src/remove-from-hotbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-from-hotbar.d.ts","sourceRoot":"","sources":["../../src/remove-from-hotbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,WAAW,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACzG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG9E;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE,sFAAsF;AACtF,MAAM,MAAM,wBAAwB,GAAG,uBAAuB,CAAC;IAC7D,aAAa,EAAE,MAAM,gBAAgB,CAAC;IACtC,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC;CACpB,CAAC,CAAC;AAEH,mGAAmG;AACnG,MAAM,MAAM,4BAA4B,GAAG,uBAAuB,CAAC;IACjE,aAAa,EAAE,MAAM,gBAAgB,CAAC;IACtC,WAAW,EAAE,WAAW,CAAC,MAAM,gBAAgB,CAAC,CAAC;IACjD,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,wBAAwB,CAAC;IAChF,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH,QAAA,MAAM,4BAA4B,SAAU,cAAc,CAAC,GAAG,CAAC,KAAG,4BAY/D,CAAC;AAEJ;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,8BAA8B,0DACpB,gBAAgB;;;CAKP,CAAC"}