@k8slens/hotbar-contracts 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export type { HotbarItemId } from "./src/hotbar-item-id";
+export { getHotbarItemKind, getHotbarItemKindId, type HotbarItemKind, type HotbarItemKindId, type HotbarItemPersistedData, parseHotbarItemKindId, } from "./src/hotbar-item-kind";
+export type { HotbarItem } from "./src/hotbar-item";
+export { getHotbarItemKindInjectableBunch, type HotbarItemKindBunchParams, type HotbarItemProps, } from "./src/get-hotbar-item-kind-injectable-bunch";
+export { addToHotbarInjectionToken, type AddToHotbar, type AddToHotbarTokenFor, type AddToHotbarTokenForKind, } from "./src/add-to-hotbar";
+export { removeFromHotbarInjectionToken, type RemoveFromHotbar, type RemoveFromHotbarTokenFor, type RemoveFromHotbarTokenForKind, } from "./src/remove-from-hotbar";
+export { isInHotbarInjectionToken, isInHotbarReactiveInjectionToken, type IsInHotbar, type IsInHotbarReactive, type IsInHotbarReactiveTokenFor, type IsInHotbarReactiveTokenForKind, type IsInHotbarTokenFor, type IsInHotbarTokenForKind, } from "./src/is-in-hotbar";
+export { hotbarItemContextMenuItemInjectionToken, type HotbarItemContextMenuItemFor, type HotbarItemContextMenuItemTokenFor, type HotbarItemContextMenuItemTokenForKind, } from "./src/hotbar-item-context-menu-item";
+/**
+ * The hotbar's side of the contract: implemented by the hotbar, built on by
+ * `getHotbarItemKindInjectableBunch`. A kind has no reason to touch these directly.
+ */
+export { hotbarItemComponentInjectionToken, type HotbarItemComponent, type HotbarItemComponentFactory, type HotbarItemComponentProps, type HotbarItemComponentTokenFor, type HotbarItemComponentTokenForKind, } from "./src/hotbar-item-component";
+export { HotbarItemFrame, type HotbarItemFrameProps } from "./src/hotbar-item-frame";
+export { hotbarItemPersistedDataInjectionToken, type HotbarItemPersistedDataEntry, type HotbarItemPersistedDataStore, type HotbarItemPersistedDataStoreFor, } from "./src/hotbar-item-persisted-data";
+export { insertHotbarItemInjectionToken, type InsertHotbarItem } from "./src/insert-hotbar-item";
+export { ejectHotbarItemInjectionToken, type EjectHotbarItem } from "./src/eject-hotbar-item";
+export { hasHotbarItemInjectionToken, hasHotbarItemReactiveInjectionToken, type HasHotbarItem, type HasHotbarItemReactive, } from "./src/has-hotbar-item";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EACL,gCAAgC,EAChC,KAAK,yBAAyB,EAC9B,KAAK,eAAe,GACrB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EACL,yBAAyB,EACzB,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,GAC7B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,8BAA8B,EAC9B,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,GAClC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,wBAAwB,EACxB,gCAAgC,EAChC,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,8BAA8B,EACnC,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,uCAAuC,EACvC,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EACtC,KAAK,qCAAqC,GAC3C,MAAM,qCAAqC,CAAC;AAE7C;;;GAGG;AACH,OAAO,EACL,iCAAiC,EACjC,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,GACrC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EACL,qCAAqC,EACrC,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,GACrC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,8BAA8B,EAAE,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjG,OAAO,EAAE,6BAA6B,EAAE,KAAK,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC9F,OAAO,EACL,2BAA2B,EAC3B,mCAAmC,EACnC,KAAK,aAAa,EAClB,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,308 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  HotbarItemFrame: () => HotbarItemFrame,
+  addToHotbarInjectionToken: () => addToHotbarInjectionToken,
+  ejectHotbarItemInjectionToken: () => ejectHotbarItemInjectionToken,
+  getHotbarItemKind: () => getHotbarItemKind,
+  getHotbarItemKindId: () => getHotbarItemKindId,
+  getHotbarItemKindInjectableBunch: () => getHotbarItemKindInjectableBunch,
+  hasHotbarItemInjectionToken: () => hasHotbarItemInjectionToken,
+  hasHotbarItemReactiveInjectionToken: () => hasHotbarItemReactiveInjectionToken,
+  hotbarItemComponentInjectionToken: () => hotbarItemComponentInjectionToken,
+  hotbarItemContextMenuItemInjectionToken: () => hotbarItemContextMenuItemInjectionToken,
+  hotbarItemPersistedDataInjectionToken: () => hotbarItemPersistedDataInjectionToken,
+  insertHotbarItemInjectionToken: () => insertHotbarItemInjectionToken,
+  isInHotbarInjectionToken: () => isInHotbarInjectionToken,
+  isInHotbarReactiveInjectionToken: () => isInHotbarReactiveInjectionToken,
+  parseHotbarItemKindId: () => parseHotbarItemKindId,
+  removeFromHotbarInjectionToken: () => removeFromHotbarInjectionToken
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/hotbar-item-kind.ts
+var import_injectable = require("@k8slens/injectable");
+var getHotbarItemKindId = (kind, scopeIds) => [...scopeIds, kind].join(":");
+var parseHotbarItemKindId = (kindId) => {
+  const segments = String(kindId).split(":");
+  return {
+    kind: segments[segments.length - 1],
+    scopeIds: segments.slice(0, -1)
+  };
+};
+var getHotbarItemKind = () => (specifier) => {
+  if (specifier.includes(":")) {
+    throw new Error(
+      `Tried to create hotbar item kind "${specifier}", but ":" is reserved for scoping the kind to its registration.`
+    );
+  }
+  return (0, import_injectable.getTypedSpecifier)()(specifier);
+};
+
+// src/get-hotbar-item-kind-injectable-bunch.tsx
+var import_injectable10 = require("@k8slens/injectable");
+var import_injectable_react2 = require("@k8slens/injectable-react");
+var import_mobx_react = require("mobx-react");
+var import_react = require("react");
+
+// src/add-to-hotbar.ts
+var import_injectable2 = require("@k8slens/injectable");
+var addToHotbarTokenForKind = (kind) => (0, import_injectable2.getInjectionToken2)({
+  id: `add-to-hotbar-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-many"
+})(
+  (scopeIds) => (0, import_injectable2.getInjectionToken2)({
+    id: `add-to-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,
+    speciality: getHotbarItemKindId(kind, scopeIds),
+    cardinality: "one"
+  })()
+);
+var addToHotbarInjectionToken = (0, import_injectable2.getInjectionToken2)({
+  id: "add-to-hotbar",
+  cardinality: "zero-or-many"
+})(addToHotbarTokenForKind);
+
+// src/eject-hotbar-item.ts
+var import_injectable3 = require("@k8slens/injectable");
+var ejectHotbarItemInjectionToken = (0, import_injectable3.getInjectionToken2)({
+  id: "eject-hotbar-item",
+  cardinality: "one"
+})();
+
+// src/has-hotbar-item.ts
+var import_injectable4 = require("@k8slens/injectable");
+var hasHotbarItemInjectionToken = (0, import_injectable4.getInjectionToken2)({
+  id: "has-hotbar-item",
+  cardinality: "one"
+})();
+var hasHotbarItemReactiveInjectionToken = (0, import_injectable4.getInjectionToken2)({
+  id: "has-hotbar-item-reactive",
+  cardinality: "one"
+})();
+
+// src/hotbar-item-component.ts
+var import_injectable5 = require("@k8slens/injectable");
+var hotbarItemComponentTokenForKind = (kind) => (0, import_injectable5.getInjectionToken2)({
+  id: `hotbar-item-component-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-many"
+})(
+  (scopeIds) => (0, import_injectable5.getInjectionToken2)({
+    id: `hotbar-item-component-${getHotbarItemKindId(kind, scopeIds)}`,
+    speciality: getHotbarItemKindId(kind, scopeIds),
+    cardinality: "zero-or-one"
+  })()
+);
+var hotbarItemComponentInjectionToken = (0, import_injectable5.getInjectionToken2)({
+  id: "hotbar-item-component",
+  cardinality: "zero-or-many"
+})(hotbarItemComponentTokenForKind);
+
+// src/hotbar-item-frame.ts
+var import_injectable_react = require("@k8slens/injectable-react");
+var HotbarItemFrame = (0, import_injectable_react.getInjectionTokenComponent2)({
+  id: "hotbar-item-frame"
+})();
+
+// src/hotbar-item-persisted-data.ts
+var import_injectable6 = require("@k8slens/injectable");
+var hotbarItemPersistedDataInjectionToken = (0, import_injectable6.getInjectionToken2)({
+  id: "hotbar-item-persisted-data",
+  cardinality: "one"
+})();
+
+// src/insert-hotbar-item.ts
+var import_injectable7 = require("@k8slens/injectable");
+var insertHotbarItemInjectionToken = (0, import_injectable7.getInjectionToken2)({
+  id: "insert-hotbar-item",
+  cardinality: "one"
+})();
+
+// src/is-in-hotbar.ts
+var import_injectable8 = require("@k8slens/injectable");
+var isInHotbarTokenForKind = (kind) => (0, import_injectable8.getInjectionToken2)({
+  id: `is-in-hotbar-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-many"
+})(
+  (scopeIds) => (0, import_injectable8.getInjectionToken2)({
+    id: `is-in-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,
+    speciality: getHotbarItemKindId(kind, scopeIds),
+    cardinality: "one"
+  })()
+);
+var isInHotbarInjectionToken = (0, import_injectable8.getInjectionToken2)({
+  id: "is-in-hotbar",
+  cardinality: "zero-or-many"
+})(isInHotbarTokenForKind);
+var isInHotbarReactiveTokenForKind = (kind) => (0, import_injectable8.getInjectionToken2)({
+  id: `is-in-hotbar-reactive-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-many"
+})(
+  (scopeIds) => (0, import_injectable8.getInjectionToken2)({
+    id: `is-in-hotbar-reactive-${getHotbarItemKindId(kind, scopeIds)}`,
+    speciality: getHotbarItemKindId(kind, scopeIds),
+    cardinality: "one"
+  })()
+);
+var isInHotbarReactiveInjectionToken = (0, import_injectable8.getInjectionToken2)({
+  id: "is-in-hotbar-reactive",
+  cardinality: "zero-or-many"
+})(isInHotbarReactiveTokenForKind);
+
+// src/remove-from-hotbar.ts
+var import_injectable9 = require("@k8slens/injectable");
+var removeFromHotbarTokenForKind = (kind) => (0, import_injectable9.getInjectionToken2)({
+  id: `remove-from-hotbar-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-many"
+})(
+  (scopeIds) => (0, import_injectable9.getInjectionToken2)({
+    id: `remove-from-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,
+    speciality: getHotbarItemKindId(kind, scopeIds),
+    cardinality: "one"
+  })()
+);
+var removeFromHotbarInjectionToken = (0, import_injectable9.getInjectionToken2)({
+  id: "remove-from-hotbar",
+  cardinality: "zero-or-many"
+})(removeFromHotbarTokenForKind);
+
+// src/get-hotbar-item-kind-injectable-bunch.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var getHotbarItemKindInjectableBunch = ({
+  kind,
+  Component
+}) => {
+  const HotbarItemOfKind = (0, import_mobx_react.observer)(({ item }) => {
+    const di = (0, import_injectable_react2.useDi)();
+    const persistedData = (0, import_react.useMemo)(() => di.inject(hotbarItemPersistedDataInjectionToken, item.kind), [di, item.kind]);
+    const entry = persistedData.get(item.id).get();
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HotbarItemFrame, { item, children: entry ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Component, { id: item.id, persistedData: entry.persistedData }) : null });
+  });
+  return (0, import_injectable10.getInjectableBunch)({
+    component: (0, import_injectable_react2.getInjectableComponent2)({
+      id: `hotbar-item-component-${kind}`,
+      Component: HotbarItemOfKind,
+      injectionToken: ({ scopeIds }) => hotbarItemComponentInjectionToken.for(kind).for(scopeIds)
+    }),
+    addToHotbar: (0, import_injectable10.getInjectable2)({
+      id: `add-to-hotbar-${kind}`,
+      consumptions: [
+        hotbarItemPersistedDataInjectionToken,
+        insertHotbarItemInjectionToken,
+        hasHotbarItemInjectionToken
+      ],
+      instantiate: (di) => {
+        const kindId = getHotbarItemKindId(kind, di.scopeIds);
+        const persistedData = di.inject(hotbarItemPersistedDataInjectionToken)(kindId);
+        const insertHotbarItem = di.inject(insertHotbarItemInjectionToken)();
+        const hasHotbarItem = di.inject(hasHotbarItemInjectionToken)();
+        const addToHotbar = async ({ id, persistedData: data }) => {
+          if (await hasHotbarItem({ id, kind: kindId })) {
+            throw new Error(`Tried to add hotbar item "${id}" of kind "${kindId}", but it is already in the hotbar.`);
+          }
+          await persistedData.set(id, data);
+          await insertHotbarItem({ id, kind: kindId });
+        };
+        return () => addToHotbar;
+      },
+      injectionToken: ({ scopeIds }) => addToHotbarInjectionToken.for(kind).for(scopeIds)
+    }),
+    // The hotbar answers for every kind at once, given the whole { id, kind }; these bind the
+    // kind, so a consumer addresses items by kind first and id second, never by id alone.
+    isInHotbar: (0, import_injectable10.getInjectable2)({
+      id: `is-in-hotbar-${kind}`,
+      consumptions: [hasHotbarItemInjectionToken],
+      instantiate: (di) => {
+        const kindId = getHotbarItemKindId(kind, di.scopeIds);
+        const hasHotbarItem = di.inject(hasHotbarItemInjectionToken)();
+        const isInHotbar = (id) => hasHotbarItem({ id, kind: kindId });
+        return () => isInHotbar;
+      },
+      injectionToken: ({ scopeIds }) => isInHotbarInjectionToken.for(kind).for(scopeIds)
+    }),
+    isInHotbarReactive: (0, import_injectable10.getInjectable2)({
+      id: `is-in-hotbar-reactive-${kind}`,
+      consumptions: [hasHotbarItemReactiveInjectionToken],
+      instantiate: (di) => {
+        const kindId = getHotbarItemKindId(kind, di.scopeIds);
+        const hasHotbarItemReactive = di.inject(hasHotbarItemReactiveInjectionToken);
+        const isInHotbarReactive = (id) => hasHotbarItemReactive({ id, kind: kindId });
+        return isInHotbarReactive;
+      },
+      injectionToken: ({ scopeIds }) => isInHotbarReactiveInjectionToken.for(kind).for(scopeIds)
+    }),
+    removeFromHotbar: (0, import_injectable10.getInjectable2)({
+      id: `remove-from-hotbar-${kind}`,
+      consumptions: [ejectHotbarItemInjectionToken],
+      instantiate: (di) => {
+        const kindId = getHotbarItemKindId(kind, di.scopeIds);
+        const ejectHotbarItem = di.inject(ejectHotbarItemInjectionToken)();
+        const removeFromHotbar = (id) => ejectHotbarItem({ id, kind: kindId });
+        return () => removeFromHotbar;
+      },
+      injectionToken: ({ scopeIds }) => removeFromHotbarInjectionToken.for(kind).for(scopeIds)
+    })
+  });
+};
+
+// src/hotbar-item-context-menu-item.ts
+var import_injectable11 = require("@k8slens/injectable");
+var hotbarItemContextMenuItemInjectionToken = (0, import_injectable11.getInjectionToken2)({
+  id: "hotbar-item-context-menu-item",
+  cardinality: "zero-or-many"
+})(
+  (kind) => (0, import_injectable11.getInjectionToken2)({
+    id: `hotbar-item-context-menu-item-${kind}`,
+    speciality: kind,
+    cardinality: "zero-or-many"
+  })(
+    (scopeIds) => (0, import_injectable11.getInjectionToken2)({
+      id: `hotbar-item-context-menu-item-${getHotbarItemKindId(kind, scopeIds)}`,
+      speciality: getHotbarItemKindId(kind, scopeIds),
+      cardinality: "zero-or-many"
+    })()
+  )
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HotbarItemFrame,
+  addToHotbarInjectionToken,
+  ejectHotbarItemInjectionToken,
+  getHotbarItemKind,
+  getHotbarItemKindId,
+  getHotbarItemKindInjectableBunch,
+  hasHotbarItemInjectionToken,
+  hasHotbarItemReactiveInjectionToken,
+  hotbarItemComponentInjectionToken,
+  hotbarItemContextMenuItemInjectionToken,
+  hotbarItemPersistedDataInjectionToken,
+  insertHotbarItemInjectionToken,
+  isInHotbarInjectionToken,
+  isInHotbarReactiveInjectionToken,
+  parseHotbarItemKindId,
+  removeFromHotbarInjectionToken
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.ts", "../src/hotbar-item-kind.ts", "../src/get-hotbar-item-kind-injectable-bunch.tsx", "../src/add-to-hotbar.ts", "../src/eject-hotbar-item.ts", "../src/has-hotbar-item.ts", "../src/hotbar-item-component.ts", "../src/hotbar-item-frame.ts", "../src/hotbar-item-persisted-data.ts", "../src/insert-hotbar-item.ts", "../src/is-in-hotbar.ts", "../src/remove-from-hotbar.ts", "../src/hotbar-item-context-menu-item.ts"],
  "sourcesContent": ["export type { HotbarItemId } from \"./src/hotbar-item-id\";\nexport {\n  getHotbarItemKind,\n  getHotbarItemKindId,\n  type HotbarItemKind,\n  type HotbarItemKindId,\n  type HotbarItemPersistedData,\n  parseHotbarItemKindId,\n} from \"./src/hotbar-item-kind\";\nexport type { HotbarItem } from \"./src/hotbar-item\";\n\nexport {\n  getHotbarItemKindInjectableBunch,\n  type HotbarItemKindBunchParams,\n  type HotbarItemProps,\n} from \"./src/get-hotbar-item-kind-injectable-bunch\";\nexport {\n  addToHotbarInjectionToken,\n  type AddToHotbar,\n  type AddToHotbarTokenFor,\n  type AddToHotbarTokenForKind,\n} from \"./src/add-to-hotbar\";\nexport {\n  removeFromHotbarInjectionToken,\n  type RemoveFromHotbar,\n  type RemoveFromHotbarTokenFor,\n  type RemoveFromHotbarTokenForKind,\n} from \"./src/remove-from-hotbar\";\nexport {\n  isInHotbarInjectionToken,\n  isInHotbarReactiveInjectionToken,\n  type IsInHotbar,\n  type IsInHotbarReactive,\n  type IsInHotbarReactiveTokenFor,\n  type IsInHotbarReactiveTokenForKind,\n  type IsInHotbarTokenFor,\n  type IsInHotbarTokenForKind,\n} from \"./src/is-in-hotbar\";\nexport {\n  hotbarItemContextMenuItemInjectionToken,\n  type HotbarItemContextMenuItemFor,\n  type HotbarItemContextMenuItemTokenFor,\n  type HotbarItemContextMenuItemTokenForKind,\n} from \"./src/hotbar-item-context-menu-item\";\n\n/**\n * The hotbar's side of the contract: implemented by the hotbar, built on by\n * `getHotbarItemKindInjectableBunch`. A kind has no reason to touch these directly.\n */\nexport {\n  hotbarItemComponentInjectionToken,\n  type HotbarItemComponent,\n  type HotbarItemComponentFactory,\n  type HotbarItemComponentProps,\n  type HotbarItemComponentTokenFor,\n  type HotbarItemComponentTokenForKind,\n} from \"./src/hotbar-item-component\";\nexport { HotbarItemFrame, type HotbarItemFrameProps } from \"./src/hotbar-item-frame\";\nexport {\n  hotbarItemPersistedDataInjectionToken,\n  type HotbarItemPersistedDataEntry,\n  type HotbarItemPersistedDataStore,\n  type HotbarItemPersistedDataStoreFor,\n} from \"./src/hotbar-item-persisted-data\";\nexport { insertHotbarItemInjectionToken, type InsertHotbarItem } from \"./src/insert-hotbar-item\";\nexport { ejectHotbarItemInjectionToken, type EjectHotbarItem } from \"./src/eject-hotbar-item\";\nexport {\n  hasHotbarItemInjectionToken,\n  hasHotbarItemReactiveInjectionToken,\n  type HasHotbarItem,\n  type HasHotbarItemReactive,\n} from \"./src/has-hotbar-item\";\n", "import { getTypedSpecifier, type TypedSpecifier, type TypedSpecifierType } from \"@k8slens/injectable\";\n\n/**\n * Identifies one kind of hotbar item: what an item is, as opposed to which item it is.\n * Every item in the hotbar is persisted as `{ id, kind }`, and the kind decides how the\n * item renders.\n *\n * `PersistedData` is what the hotbar persists next to the item's id when the item is\n * added, and hands back to the kind's component whenever the item renders. A kind\n * created without `PersistedData` persists nothing beyond the id.\n *\n * At runtime a kind is a branded string, so it is usable as a `.for()` key.\n */\nexport type HotbarItemKind<PersistedData = unknown> = TypedSpecifier<string, { persistedData: PersistedData }>;\n\n/**\n * Recovers the persisted data type bound to a {@link HotbarItemKind} or a {@link HotbarItemKindId}.\n */\nexport type HotbarItemPersistedData<K extends HotbarItemKind<any> | HotbarItemKindId<any>> = TypedSpecifierType<\n  \"persistedData\",\n  K\n>;\n\n/**\n * What the hotbar knows a kind by: the kind's specifier, scoped to whoever registered it, as\n * one string. It is what the hotbar persists as an item's `kind` and what keys the kind's\n * persisted data. Two extensions declaring a kind with the same specifier get two ids, because\n * their scopes differ; the specifier alone is never an identity.\n *\n * The tokens take the two parts separately, `token.for(kind).for(scopeIds)`; the id is the\n * hotbar's side of the same identity. Made by {@link getHotbarItemKindId}, taken apart by\n * {@link parseHotbarItemKindId}. Typed by the kind's persisted data, like the kind itself.\n */\nexport type HotbarItemKindId<PersistedData = unknown> = TypedSpecifier<\n  string,\n  { persistedData: PersistedData; scopedHotbarItemKind: true }\n>;\n\n/**\n * The id of a kind as registered under the given scopes: the scope ids, then the specifier,\n * joined with \":\", which is why a specifier may not contain one. The same kind under the same\n * scopes always yields the same id. The hotbar computes it from an item's kind and scopes;\n * a kind's own code has no need for it, the tokens take the parts.\n */\nexport const getHotbarItemKindId = <K extends HotbarItemKind<any>>(\n  kind: K,\n  scopeIds: readonly string[],\n): HotbarItemKindId<HotbarItemPersistedData<K>> =>\n  [...scopeIds, kind].join(\":\") as HotbarItemKindId<HotbarItemPersistedData<K>>;\n\n/**\n * The two parts of a kind id: the scopes the kind was registered under and the kind itself,\n * as the tokens take them: `token.for(kind).for(scopeIds)`. The inverse of\n * {@link getHotbarItemKindId}. A kind registered at container level, or persisted before kinds\n * were scoped, parses to no scopes.\n */\nexport const parseHotbarItemKindId = <Data>(\n  kindId: HotbarItemKindId<Data>,\n): { readonly kind: HotbarItemKind<Data>; readonly scopeIds: readonly string[] } => {\n  const segments = String(kindId).split(\":\");\n\n  return {\n    kind: segments[segments.length - 1] as HotbarItemKind<Data>,\n    scopeIds: segments.slice(0, -1),\n  };\n};\n\n/**\n * Curried creator for a {@link HotbarItemKind}. The first call binds the persisted data\n * type; the second the globally unique specifier string. Register the kind with\n * `getHotbarItemKindInjectableBunch`, then add items of it with\n * `addToHotbarInjectionToken.for(kind)`.\n *\n * @example\n * ```ts\n * // A kind whose items carry a URL:\n * export const bookmarkHotbarItemKind = getHotbarItemKind<{ url: string }>()(\"my-extension-bookmark\");\n *\n * // A kind whose items need nothing beyond their id:\n * export const dashboardHotbarItemKind = getHotbarItemKind()(\"my-extension-dashboard\");\n * ```\n */\nexport const getHotbarItemKind =\n  <PersistedData = void>() =>\n  <S extends string>(specifier: S) => {\n    if (specifier.includes(\":\")) {\n      throw new Error(\n        `Tried to create hotbar item kind \"${specifier}\", but \":\" is reserved for scoping the kind to its registration.`,\n      );\n    }\n\n    return getTypedSpecifier<{ persistedData: PersistedData }>()(specifier);\n  };\n", "import { getInjectable2, getInjectableBunch } from \"@k8slens/injectable\";\nimport { getInjectableComponent2, useDi } from \"@k8slens/injectable-react\";\nimport { observer } from \"mobx-react\";\nimport type React from \"react\";\nimport { useMemo } from \"react\";\nimport { type AddToHotbar, addToHotbarInjectionToken } from \"./add-to-hotbar\";\nimport { ejectHotbarItemInjectionToken } from \"./eject-hotbar-item\";\nimport { hasHotbarItemInjectionToken, hasHotbarItemReactiveInjectionToken } from \"./has-hotbar-item\";\nimport { type HotbarItemComponentProps, hotbarItemComponentInjectionToken } from \"./hotbar-item-component\";\nimport { HotbarItemFrame } from \"./hotbar-item-frame\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport { getHotbarItemKindId, type HotbarItemKind, type HotbarItemPersistedData } from \"./hotbar-item-kind\";\nimport { hotbarItemPersistedDataInjectionToken } from \"./hotbar-item-persisted-data\";\nimport { insertHotbarItemInjectionToken } from \"./insert-hotbar-item\";\nimport {\n  type IsInHotbar,\n  type IsInHotbarReactive,\n  isInHotbarInjectionToken,\n  isInHotbarReactiveInjectionToken,\n} from \"./is-in-hotbar\";\nimport { type RemoveFromHotbar, removeFromHotbarInjectionToken } from \"./remove-from-hotbar\";\n\n/**\n * What a kind's component receives: which item it renders, and the data that was\n * persisted when the item was added. Typed by the kind.\n */\nexport interface HotbarItemProps<K extends HotbarItemKind<any>> {\n  readonly id: HotbarItemId;\n  readonly persistedData: HotbarItemPersistedData<K>;\n}\n\nexport interface HotbarItemKindBunchParams<K extends HotbarItemKind<any>> {\n  /** The kind being registered, from `getHotbarItemKind`. */\n  readonly kind: K;\n  /**\n   * Renders an item of the kind, inside the slot's frame. Receives the item's id and its\n   * persisted data, and decides everything else: what the item looks like, and what\n   * clicking it does. Must be defined at module scope.\n   */\n  readonly Component: React.ComponentType<HotbarItemProps<K>>;\n}\n\n/**\n * Register a kind of hotbar item. One call declares how items of the kind render, wires\n * their persisted data, and gives the kind its typed adder, `addToHotbarInjectionToken.for(kind).for(scopeIds)`,\n * along with its own membership queries and remover, `isInHotbarInjectionToken.for(kind).for(scopeIds)`,\n * `isInHotbarReactiveInjectionToken.for(kind).for(scopeIds)` and `removeFromHotbarInjectionToken.for(kind).for(scopeIds)`.\n *\n * The last `.for()` is the scope of the registration: every token here is registered under\n * the scopes of whoever registers the bunch, so two extensions declaring a kind with the same\n * specifier never meet. Items are identified by their kind, its scopes, and then their own\n * id, never by the id alone.\n *\n * The hotbar frames each item, persists its `{ id, kind }` and data, pages and drags it,\n * and gives its right-click menu a way to remove it. The component owns the rest.\n *\n * @example\n * ```tsx\n * export const bookmarkHotbarItemKind = getHotbarItemKind<{ url: string }>()(\"my-extension-bookmark\");\n *\n * const Bookmark = ({ persistedData }: HotbarItemProps<typeof bookmarkHotbarItemKind>) => (\n *   <Button onClick={() => open(persistedData.url)}>{new URL(persistedData.url).host}</Button>\n * );\n *\n * export default getHotbarItemKindInjectableBunch({\n *   kind: bookmarkHotbarItemKind,\n *   Component: Bookmark,\n * });\n * ```\n */\nexport const getHotbarItemKindInjectableBunch = <K extends HotbarItemKind<any>>({\n  kind,\n  Component,\n}: HotbarItemKindBunchParams<K>) => {\n  // Built once per kind so the component reference is stable across injections; a fresh\n  // reference on each injection would remount the item and lose its state.\n  const HotbarItemOfKind = observer(({ item }: HotbarItemComponentProps) => {\n    const di = useDi();\n    // Resolved straight from the container: the store is a singleton per kind, and a\n    // suspending hook has no place around an item that is already on screen. The item carries\n    // the kind's id, which is what the store is keyed by.\n    const persistedData = useMemo(() => di.inject(hotbarItemPersistedDataInjectionToken, item.kind), [di, item.kind]);\n    const entry = persistedData.get(item.id).get();\n\n    return (\n      <HotbarItemFrame item={item}>\n        {entry ? <Component id={item.id} persistedData={entry.persistedData as HotbarItemPersistedData<K>} /> : null}\n      </HotbarItemFrame>\n    );\n  });\n\n  // The tokens are keyed by the scopes of whoever registers this bunch (the `injectionToken`\n  // functions), and the instances compute the hotbar's id of the kind from their own\n  // `di.scopeIds`, so the two always agree.\n  return getInjectableBunch({\n    component: getInjectableComponent2({\n      id: `hotbar-item-component-${kind}`,\n      Component: HotbarItemOfKind,\n      injectionToken: ({ scopeIds }) => hotbarItemComponentInjectionToken.for(kind).for(scopeIds),\n    }),\n\n    addToHotbar: getInjectable2({\n      id: `add-to-hotbar-${kind}`,\n      consumptions: [\n        hotbarItemPersistedDataInjectionToken,\n        insertHotbarItemInjectionToken,\n        hasHotbarItemInjectionToken,\n      ],\n\n      instantiate: (di) => {\n        const kindId = getHotbarItemKindId(kind, di.scopeIds);\n        const persistedData = di.inject(hotbarItemPersistedDataInjectionToken)(kindId);\n        const insertHotbarItem = di.inject(insertHotbarItemInjectionToken)();\n        const hasHotbarItem = di.inject(hasHotbarItemInjectionToken)();\n\n        const addToHotbar: AddToHotbar<HotbarItemPersistedData<K>> = async ({ id, persistedData: data }) => {\n          // Checked before persisting, so a rejected add leaves the item's data as it was.\n          if (await hasHotbarItem({ id, kind: kindId })) {\n            throw new Error(`Tried to add hotbar item \"${id}\" of kind \"${kindId}\", but it is already in the hotbar.`);\n          }\n\n          await persistedData.set(id, data);\n          await insertHotbarItem({ id, kind: kindId });\n        };\n\n        return () => addToHotbar;\n      },\n\n      injectionToken: ({ scopeIds }) => addToHotbarInjectionToken.for(kind).for(scopeIds),\n    }),\n\n    // The hotbar answers for every kind at once, given the whole { id, kind }; these bind the\n    // kind, so a consumer addresses items by kind first and id second, never by id alone.\n    isInHotbar: getInjectable2({\n      id: `is-in-hotbar-${kind}`,\n      consumptions: [hasHotbarItemInjectionToken],\n\n      instantiate: (di) => {\n        const kindId = getHotbarItemKindId(kind, di.scopeIds);\n        const hasHotbarItem = di.inject(hasHotbarItemInjectionToken)();\n        const isInHotbar: IsInHotbar = (id) => hasHotbarItem({ id, kind: kindId });\n\n        return () => isInHotbar;\n      },\n\n      injectionToken: ({ scopeIds }) => isInHotbarInjectionToken.for(kind).for(scopeIds),\n    }),\n\n    isInHotbarReactive: getInjectable2({\n      id: `is-in-hotbar-reactive-${kind}`,\n      consumptions: [hasHotbarItemReactiveInjectionToken],\n\n      instantiate: (di) => {\n        const kindId = getHotbarItemKindId(kind, di.scopeIds);\n        const hasHotbarItemReactive = di.inject(hasHotbarItemReactiveInjectionToken);\n        const isInHotbarReactive: IsInHotbarReactive = (id) => hasHotbarItemReactive({ id, kind: kindId });\n\n        return isInHotbarReactive;\n      },\n\n      injectionToken: ({ scopeIds }) => isInHotbarReactiveInjectionToken.for(kind).for(scopeIds),\n    }),\n\n    removeFromHotbar: getInjectable2({\n      id: `remove-from-hotbar-${kind}`,\n      consumptions: [ejectHotbarItemInjectionToken],\n\n      instantiate: (di) => {\n        const kindId = getHotbarItemKindId(kind, di.scopeIds);\n        const ejectHotbarItem = di.inject(ejectHotbarItemInjectionToken)();\n        const removeFromHotbar: RemoveFromHotbar = (id) => ejectHotbarItem({ id, kind: kindId });\n\n        return () => removeFromHotbar;\n      },\n\n      injectionToken: ({ scopeIds }) => removeFromHotbarInjectionToken.for(kind).for(scopeIds),\n    }),\n  });\n};\n", "import { getInjectionToken2, type ManyFactory, type SpecificInjectionToken2 } from \"@k8slens/injectable\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport type { HotbarItemKind, HotbarItemPersistedData } from \"./hotbar-item-kind\";\nimport { getHotbarItemKindId } from \"./hotbar-item-kind\";\nimport type { isInHotbarInjectionToken } from \"./is-in-hotbar\";\n\n/**\n * Adds an item of one kind to the hotbar: persists its data under its id, then puts it\n * into the first free slot of the current page. Tells the user when there is no free slot.\n *\n * An item is identified by its kind and then its id, so the id needs to be unique only among\n * items of the kind. Throws when an item of the kind with the id is already on the current\n * page, leaving the hotbar and the item's persisted data as they were. A toggle asks\n * {@link isInHotbarInjectionToken} first.\n */\nexport type AddToHotbar<PersistedData> = (item: {\n  readonly id: HotbarItemId;\n  readonly persistedData: PersistedData;\n}) => Promise<void>;\n\n/** What `.for(kind).for(scopeIds)` yields: exactly one adder per kind per scope, typed by its persisted data. */\nexport type AddToHotbarTokenFor<PersistedData> = SpecificInjectionToken2<{\n  singleFactory: () => AddToHotbar<PersistedData>;\n  specificTokenFactory: undefined;\n  cardinality: \"one\";\n}>;\n\n/** What `.for(kind)` yields: the kind's adders, one per scope, reached with `.for(scopeIds)`. */\nexport type AddToHotbarTokenForKind<PersistedData> = SpecificInjectionToken2<{\n  singleFactory: () => AddToHotbar<PersistedData>;\n  manyFactory: ManyFactory<() => AddToHotbar<PersistedData>>;\n  specificTokenFactory: (scopeIds: readonly string[]) => AddToHotbarTokenFor<PersistedData>;\n  cardinality: \"zero-or-many\";\n}>;\n\n/**\n * The `.for()` factories, annotated so a kind's own persisted data type survives both levels.\n * Inference from the value alone cannot reconstruct a return type that mentions the\n * specifier's own type parameter.\n */\nconst addToHotbarTokenForKind = <K extends HotbarItemKind<any>>(\n  kind: K,\n): AddToHotbarTokenForKind<HotbarItemPersistedData<K>> =>\n  getInjectionToken2<{\n    singleFactory: () => AddToHotbar<HotbarItemPersistedData<K>>;\n    manyFactory: ManyFactory<() => AddToHotbar<HotbarItemPersistedData<K>>>;\n  }>({\n    id: `add-to-hotbar-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-many\",\n  })(\n    (scopeIds: readonly string[]): AddToHotbarTokenFor<HotbarItemPersistedData<K>> =>\n      getInjectionToken2<{ singleFactory: () => AddToHotbar<HotbarItemPersistedData<K>> }>({\n        id: `add-to-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,\n        speciality: getHotbarItemKindId(kind, scopeIds),\n        cardinality: \"one\",\n      })(),\n  );\n\n/**\n * Add an item to the hotbar, typed by its kind: `.for(kind)` narrows to the kind, whose\n * `persistedData` is what the kind was created for, and `.for(scopeIds)` to the registration\n * of it, with the `di.scopeIds` of the injectable asking. Registered by\n * `getHotbarItemKindInjectableBunch`, so every registered kind has one.\n *\n * @example\n * ```ts\n * const addBookmarkToHotbar = di.inject(addToHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();\n *\n * await addBookmarkToHotbar({ id: `bookmark(${url})`, persistedData: { url } });\n * ```\n */\nexport const addToHotbarInjectionToken = getInjectionToken2<{\n  singleFactory: () => AddToHotbar<any>;\n  manyFactory: ManyFactory<() => AddToHotbar<any>>;\n}>({\n  id: \"add-to-hotbar\",\n  cardinality: \"zero-or-many\",\n})(addToHotbarTokenForKind);\n", "import { getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { HotbarItem } from \"./hotbar-item\";\n\n/**\n * Takes the item, as `{ id, kind }`, out of the current hotbar page. Throws when no such item\n * is there.\n */\nexport type EjectHotbarItem = (item: HotbarItem) => Promise<void>;\n\n/**\n * The hotbar's own removal, the counterpart of `insertHotbarItemInjectionToken`: one\n * implementation for every kind, given the whole `{ id, kind }`.\n * `getHotbarItemKindInjectableBunch` builds `removeFromHotbarInjectionToken.for(kind)` on it,\n * so reach for that one instead.\n *\n * Implemented by the hotbar.\n */\nexport const ejectHotbarItemInjectionToken = getInjectionToken2<{ singleFactory: () => EjectHotbarItem }>({\n  id: \"eject-hotbar-item\",\n  cardinality: \"one\",\n})();\n", "import { getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { IComputedValue } from \"mobx\";\nimport type { HotbarItem } from \"./hotbar-item\";\n\n/** Whether the item, as `{ id, kind }`, is on the current hotbar page, as of now. */\nexport type HasHotbarItem = (item: HotbarItem) => Promise<boolean>;\n\n/**\n * The hotbar's own membership query: one implementation for every kind, asked with the whole\n * `{ id, kind }`. `getHotbarItemKindInjectableBunch` builds `isInHotbarInjectionToken.for(kind)`\n * on it, so reach for that one instead.\n *\n * Implemented by the hotbar.\n */\nexport const hasHotbarItemInjectionToken = getInjectionToken2<{ singleFactory: () => HasHotbarItem }>({\n  id: \"has-hotbar-item\",\n  cardinality: \"one\",\n})();\n\n/** Whether the item, as `{ id, kind }`, is on the current hotbar page, reactively. */\nexport type HasHotbarItemReactive = (item: HotbarItem) => IComputedValue<boolean>;\n\n/**\n * The hotbar's own reactive membership query, asked with the whole `{ id, kind }`.\n * `getHotbarItemKindInjectableBunch` builds `isInHotbarReactiveInjectionToken.for(kind)` on it,\n * so reach for that one instead.\n *\n * Implemented by the hotbar.\n */\nexport const hasHotbarItemReactiveInjectionToken = getInjectionToken2<{ singleFactory: HasHotbarItemReactive }>({\n  id: \"has-hotbar-item-reactive\",\n  cardinality: \"one\",\n})();\n", "import {\n  getInjectionToken2,\n  type ManyFactory,\n  type MaybeResultFactory,\n  type SpecificInjectionToken2,\n} from \"@k8slens/injectable\";\nimport type React from \"react\";\nimport type { HotbarItem } from \"./hotbar-item\";\nimport { getHotbarItemKindId, type HotbarItemKind } from \"./hotbar-item-kind\";\n\n/** What the hotbar hands a kind's component: the item, as `{ id, kind }`. */\nexport type HotbarItemComponentProps = { item: HotbarItem };\n\n/**\n * Renders one item of a kind inside its hotbar slot. The hotbar hands it the item only;\n * the component resolves whatever else it needs from the item's id and kind.\n */\nexport type HotbarItemComponent = React.ComponentType<HotbarItemComponentProps>;\n\n/** How the component is registered: a v2 token models a factory, so a component is wrapped in one. */\nexport type HotbarItemComponentFactory = () => HotbarItemComponent;\n\n/** What `.for(kind).for(scopeIds)` yields: at most one component per kind per scope. */\nexport type HotbarItemComponentTokenFor = SpecificInjectionToken2<{\n  singleFactory: HotbarItemComponentFactory;\n  maybeFactory: MaybeResultFactory<HotbarItemComponentFactory>;\n  specificTokenFactory: undefined;\n  cardinality: \"zero-or-one\";\n}>;\n\n/** What `.for(kind)` yields: the kind's components, one per scope, reached with `.for(scopeIds)`. */\nexport type HotbarItemComponentTokenForKind = SpecificInjectionToken2<{\n  singleFactory: HotbarItemComponentFactory;\n  manyFactory: ManyFactory<HotbarItemComponentFactory>;\n  specificTokenFactory: (scopeIds: readonly string[]) => HotbarItemComponentTokenFor;\n  cardinality: \"zero-or-many\";\n}>;\n\nconst hotbarItemComponentTokenForKind = (kind: HotbarItemKind<any>): HotbarItemComponentTokenForKind =>\n  getInjectionToken2<{\n    singleFactory: HotbarItemComponentFactory;\n    manyFactory: ManyFactory<HotbarItemComponentFactory>;\n  }>({\n    id: `hotbar-item-component-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-many\",\n  })(\n    (scopeIds: readonly string[]): HotbarItemComponentTokenFor =>\n      getInjectionToken2<{\n        singleFactory: HotbarItemComponentFactory;\n        maybeFactory: MaybeResultFactory<HotbarItemComponentFactory>;\n      }>({\n        id: `hotbar-item-component-${getHotbarItemKindId(kind, scopeIds)}`,\n        speciality: getHotbarItemKindId(kind, scopeIds),\n        cardinality: \"zero-or-one\",\n      })(),\n  );\n\n/**\n * How the hotbar renders an item: the component registered for the item's kind, via\n * `.for(kind).for(scopeIds)`. A kind with no component is unknown to the hotbar, and its items\n * render as unavailable.\n *\n * `getHotbarItemKindInjectableBunch` registers this for a kind; prefer it over binding\n * to the token by hand, since it also wires the persisted data and the adder.\n */\nexport const hotbarItemComponentInjectionToken = getInjectionToken2<{\n  singleFactory: HotbarItemComponentFactory;\n  manyFactory: ManyFactory<HotbarItemComponentFactory>;\n}>({\n  id: \"hotbar-item-component\",\n  cardinality: \"zero-or-many\",\n})(hotbarItemComponentTokenForKind);\n", "import { getInjectionTokenComponent2 } from \"@k8slens/injectable-react\";\nimport type React from \"react\";\nimport type { HotbarItem } from \"./hotbar-item\";\n\nexport interface HotbarItemFrameProps {\n  readonly item: HotbarItem;\n  readonly children?: React.ReactNode;\n}\n\n/**\n * What every hotbar item sits in: the slot's chrome, plus the item's right-click menu,\n * which is where the hotbar offers to remove the item. Whatever is rendered inside decides\n * what clicking the item does.\n *\n * Implemented by the hotbar. `getHotbarItemKindInjectableBunch` wraps a kind's component\n * in it, so a kind needs to render only its own content.\n */\nexport const HotbarItemFrame = getInjectionTokenComponent2<React.ComponentType<HotbarItemFrameProps>>({\n  id: \"hotbar-item-frame\",\n})();\n", "import { getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { IComputedValue } from \"mobx\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport type { HotbarItemKindId } from \"./hotbar-item-kind\";\n\n/**\n * The persisted data of one item, wrapped so that \"no data persisted\" and \"persisted\n * `undefined`\" (a kind without data) stay distinguishable.\n */\nexport interface HotbarItemPersistedDataEntry<PersistedData = unknown> {\n  readonly persistedData: PersistedData;\n}\n\n/**\n * The persisted data of every item of one kind, keyed by item id.\n */\nexport interface HotbarItemPersistedDataStore<PersistedData = unknown> {\n  /** The item's entry, `undefined` until the store has loaded and while the item has none. */\n  readonly get: (id: HotbarItemId) => IComputedValue<HotbarItemPersistedDataEntry<PersistedData> | undefined>;\n  /** Persists the item's data, resolving once the store has loaded and taken it. */\n  readonly set: (id: HotbarItemId, persistedData: PersistedData) => Promise<void>;\n}\n\n/** What {@link hotbarItemPersistedDataInjectionToken} yields: the store of one kind, by the kind's id. */\nexport type HotbarItemPersistedDataStoreFor = (kindId: HotbarItemKindId<any>) => HotbarItemPersistedDataStore;\n\n/**\n * Where the hotbar keeps the persisted data of items, one store per kind. The data is\n * typed by the kind, which is why the store itself is untyped: `getHotbarItemKindInjectableBunch`\n * binds the type on both the way in (the adder) and the way out (the component), so a kind\n * never touches this directly.\n *\n * Implemented by the hotbar.\n */\nexport const hotbarItemPersistedDataInjectionToken = getInjectionToken2<{\n  singleFactory: HotbarItemPersistedDataStoreFor;\n}>({\n  id: \"hotbar-item-persisted-data\",\n  cardinality: \"one\",\n})();\n", "import { getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { HotbarItem } from \"./hotbar-item\";\n\n/**\n * Puts an item into the first free slot of the current hotbar page. Tells the user when\n * there is none, or when the item's kind is unknown, instead of throwing.\n */\nexport type InsertHotbarItem = (item: HotbarItem) => Promise<void>;\n\n/**\n * The hotbar's own insertion: id and kind only, no persisted data. The typed adder a kind\n * gets from `addToHotbarInjectionToken.for(kind)` persists the data first and then comes\n * here, so reach for that one instead.\n *\n * Implemented by the hotbar.\n */\nexport const insertHotbarItemInjectionToken = getInjectionToken2<{ singleFactory: () => InsertHotbarItem }>({\n  id: \"insert-hotbar-item\",\n  cardinality: \"one\",\n})();\n", "import { getInjectionToken2, type ManyFactory, type SpecificInjectionToken2 } from \"@k8slens/injectable\";\nimport type { IComputedValue } from \"mobx\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport { getHotbarItemKindId, type HotbarItemKind } from \"./hotbar-item-kind\";\n\n/** Whether the item of the kind with the id is on the current hotbar page, as of now. */\nexport type IsInHotbar = (id: HotbarItemId) => Promise<boolean>;\n\n/** What `.for(kind).for(scopeIds)` yields: exactly one membership query per kind per scope. */\nexport type IsInHotbarTokenFor = SpecificInjectionToken2<{\n  singleFactory: () => IsInHotbar;\n  specificTokenFactory: undefined;\n  cardinality: \"one\";\n}>;\n\n/** What `.for(kind)` yields: the kind's membership queries, one per scope, reached with `.for(scopeIds)`. */\nexport type IsInHotbarTokenForKind = SpecificInjectionToken2<{\n  singleFactory: () => IsInHotbar;\n  manyFactory: ManyFactory<() => IsInHotbar>;\n  specificTokenFactory: (scopeIds: readonly string[]) => IsInHotbarTokenFor;\n  cardinality: \"zero-or-many\";\n}>;\n\nconst isInHotbarTokenForKind = (kind: HotbarItemKind<any>): IsInHotbarTokenForKind =>\n  getInjectionToken2<{ singleFactory: () => IsInHotbar; manyFactory: ManyFactory<() => IsInHotbar> }>({\n    id: `is-in-hotbar-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-many\",\n  })(\n    (scopeIds: readonly string[]): IsInHotbarTokenFor =>\n      getInjectionToken2<{ singleFactory: () => IsInHotbar }>({\n        id: `is-in-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,\n        speciality: getHotbarItemKindId(kind, scopeIds),\n        cardinality: \"one\",\n      })(),\n  );\n\n/**\n * Whether an item is in the hotbar, asked once: `.for(kind).for(scopeIds)` yields the query\n * of that kind as registered under those scopes, which takes the id. An item is identified by\n * its kind and then its id, never by the id alone, so two kinds using the same id never answer\n * for each other; the scopes come from the `di.scopeIds` of the injectable asking. For\n * deciding in a handler, say whether a click should add the item or remove it.\n *\n * A promise rather than a boolean because the hotbar loads what it persisted lazily: asked\n * before that, a boolean could only be a guess. For following the answer as it changes, see\n * {@link isInHotbarReactiveInjectionToken}.\n *\n * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one.\n *\n * @example\n * ```ts\n * const isBookmarkInHotbar = di.inject(isInHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();\n *\n * if (await isBookmarkInHotbar(id)) {\n *   await removeBookmarkFromHotbar(id);\n * } else {\n *   await addBookmarkToHotbar({ id, persistedData: { url } });\n * }\n * ```\n */\nexport const isInHotbarInjectionToken = getInjectionToken2<{\n  singleFactory: () => IsInHotbar;\n  manyFactory: ManyFactory<() => IsInHotbar>;\n}>({\n  id: \"is-in-hotbar\",\n  cardinality: \"zero-or-many\",\n})(isInHotbarTokenForKind);\n\n/** Whether the item of the kind with the id is on the current hotbar page, reactively. */\nexport type IsInHotbarReactive = (id: HotbarItemId) => IComputedValue<boolean>;\n\n/** What `.for(kind).for(scopeIds)` yields: exactly one reactive membership query per kind per scope. */\nexport type IsInHotbarReactiveTokenFor = SpecificInjectionToken2<{\n  singleFactory: IsInHotbarReactive;\n  specificTokenFactory: undefined;\n  cardinality: \"one\";\n}>;\n\n/** What `.for(kind)` yields: the kind's reactive membership queries, one per scope, reached with `.for(scopeIds)`. */\nexport type IsInHotbarReactiveTokenForKind = SpecificInjectionToken2<{\n  singleFactory: IsInHotbarReactive;\n  manyFactory: ManyFactory<IsInHotbarReactive>;\n  specificTokenFactory: (scopeIds: readonly string[]) => IsInHotbarReactiveTokenFor;\n  cardinality: \"zero-or-many\";\n}>;\n\nconst isInHotbarReactiveTokenForKind = (kind: HotbarItemKind<any>): IsInHotbarReactiveTokenForKind =>\n  getInjectionToken2<{ singleFactory: IsInHotbarReactive; manyFactory: ManyFactory<IsInHotbarReactive> }>({\n    id: `is-in-hotbar-reactive-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-many\",\n  })(\n    (scopeIds: readonly string[]): IsInHotbarReactiveTokenFor =>\n      getInjectionToken2<{ singleFactory: IsInHotbarReactive }>({\n        id: `is-in-hotbar-reactive-${getHotbarItemKindId(kind, scopeIds)}`,\n        speciality: getHotbarItemKindId(kind, scopeIds),\n        cardinality: \"one\",\n      })(),\n  );\n\n/**\n * Whether an item is in the hotbar, as a MobX computed: `.for(kind).for(scopeIds)` yields the\n * query of that kind as registered under those scopes, which takes the id. Read it under an\n * observer (or a reaction) to follow the user pinning and unpinning. `false` until the hotbar\n * has loaded what it persisted. For a one-off answer, see {@link isInHotbarInjectionToken}.\n *\n * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one. A\n * component has no scope of its own, so it takes the query from an injectable that reached it\n * with its `di.scopeIds`.\n *\n * @example\n * ```tsx\n * const PinState = observer(({ url }: { url: string }) => {\n *   const isInHotbar = useInject(isBookmarkInHotbarReactiveInjectable)(idOf(url)).get();\n *\n *   return <span>{isInHotbar ? \"Pinned\" : \"Not pinned\"}</span>;\n * });\n * ```\n */\nexport const isInHotbarReactiveInjectionToken = getInjectionToken2<{\n  singleFactory: IsInHotbarReactive;\n  manyFactory: ManyFactory<IsInHotbarReactive>;\n}>({\n  id: \"is-in-hotbar-reactive\",\n  cardinality: \"zero-or-many\",\n})(isInHotbarReactiveTokenForKind);\n", "import { getInjectionToken2, type ManyFactory, type SpecificInjectionToken2 } from \"@k8slens/injectable\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport { getHotbarItemKindId, type HotbarItemKind } from \"./hotbar-item-kind\";\nimport type { isInHotbarInjectionToken } from \"./is-in-hotbar\";\n\n/**\n * Removes the item of the kind with the id from the current hotbar page. Throws when no\n * such item is there.\n */\nexport type RemoveFromHotbar = (id: HotbarItemId) => Promise<void>;\n\n/** What `.for(kind).for(scopeIds)` yields: exactly one remover per kind per scope. */\nexport type RemoveFromHotbarTokenFor = SpecificInjectionToken2<{\n  singleFactory: () => RemoveFromHotbar;\n  specificTokenFactory: undefined;\n  cardinality: \"one\";\n}>;\n\n/** What `.for(kind)` yields: the kind's removers, one per scope, reached with `.for(scopeIds)`. */\nexport type RemoveFromHotbarTokenForKind = SpecificInjectionToken2<{\n  singleFactory: () => RemoveFromHotbar;\n  manyFactory: ManyFactory<() => RemoveFromHotbar>;\n  specificTokenFactory: (scopeIds: readonly string[]) => RemoveFromHotbarTokenFor;\n  cardinality: \"zero-or-many\";\n}>;\n\nconst removeFromHotbarTokenForKind = (kind: HotbarItemKind<any>): RemoveFromHotbarTokenForKind =>\n  getInjectionToken2<{ singleFactory: () => RemoveFromHotbar; manyFactory: ManyFactory<() => RemoveFromHotbar> }>({\n    id: `remove-from-hotbar-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-many\",\n  })(\n    (scopeIds: readonly string[]): RemoveFromHotbarTokenFor =>\n      getInjectionToken2<{ singleFactory: () => RemoveFromHotbar }>({\n        id: `remove-from-hotbar-${getHotbarItemKindId(kind, scopeIds)}`,\n        speciality: getHotbarItemKindId(kind, scopeIds),\n        cardinality: \"one\",\n      })(),\n  );\n\n/**\n * Remove an item from the hotbar: `.for(kind).for(scopeIds)` yields the remover of that kind\n * as registered under those scopes, which takes the id. An item is identified by its kind and\n * then its id, so removing one kind's item leaves another kind's item with the same id alone.\n * The persisted data of the item is left in place, so adding the same id back finds it again.\n * The scopes come from the `di.scopeIds` of the injectable asking.\n *\n * Throws when no item of the kind with the id is on the current page: removing is something\n * done to an item known to be there, so a toggle asks {@link isInHotbarInjectionToken} first.\n *\n * Registered by `getHotbarItemKindInjectableBunch`, so every registered kind has one.\n *\n * @example\n * ```ts\n * const removeBookmarkFromHotbar = di.inject(removeFromHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();\n *\n * await removeBookmarkFromHotbar(`my-extension-bookmark(${url})`);\n * ```\n */\nexport const removeFromHotbarInjectionToken = getInjectionToken2<{\n  singleFactory: () => RemoveFromHotbar;\n  manyFactory: ManyFactory<() => RemoveFromHotbar>;\n}>({\n  id: \"remove-from-hotbar\",\n  cardinality: \"zero-or-many\",\n})(removeFromHotbarTokenForKind);\n", "import { getInjectionToken2, type ManyFactory, type SpecificInjectionToken2 } from \"@k8slens/injectable\";\nimport type { MenuItem } from \"@k8slens/drop-down-menu-contracts\";\nimport type { MaybePromise } from \"@k8slens/public-utilities\";\nimport type { HotbarItemId } from \"./hotbar-item-id\";\nimport { getHotbarItemKindId, type HotbarItemKind } from \"./hotbar-item-kind\";\n\n/** Produces the menu item for one hotbar item, possibly later. */\nexport type HotbarItemContextMenuItemFor = (id: HotbarItemId) => MaybePromise<MenuItem>;\n\n/** What `.for(kind).for(scopeIds)` yields: the menu items contributed to one kind as registered under those scopes. */\nexport type HotbarItemContextMenuItemTokenFor = SpecificInjectionToken2<{\n  singleFactory: HotbarItemContextMenuItemFor;\n  manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;\n  specificTokenFactory: undefined;\n  cardinality: \"zero-or-many\";\n}>;\n\n/** What `.for(kind)` yields: the kind's menu items, per scope, reached with `.for(scopeIds)`. */\nexport type HotbarItemContextMenuItemTokenForKind = SpecificInjectionToken2<{\n  singleFactory: HotbarItemContextMenuItemFor;\n  manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;\n  specificTokenFactory: (scopeIds: readonly string[]) => HotbarItemContextMenuItemTokenFor;\n  cardinality: \"zero-or-many\";\n}>;\n\n/**\n * The right-click menu of a hotbar item: one entry per contribution, registered against the\n * item's kind via `.for(kind).for(scopeIds)`. The scopes are those of the registration, so the\n * `injectionToken` is given as a function of them. The hotbar contributes the way to remove\n * the item to every kind itself.\n *\n * @example\n * ```ts\n * export const openBookmarkInBrowserInjectable = getInjectable2({\n *   id: \"open-bookmark-in-browser\",\n *   instantiate: () => (id): MenuItem => ({\n *     id: \"open-in-browser\",\n *     kind: \"action\",\n *     labelText: \"Open in browser\",\n *     onClick: () => openInBrowser(urlOf(id)),\n *     orderNumber: 10,\n *     parentId: undefined,\n *   }),\n *   injectionToken: ({ scopeIds }) => hotbarItemContextMenuItemInjectionToken.for(bookmarkHotbarItemKind).for(scopeIds),\n * });\n * ```\n */\nexport const hotbarItemContextMenuItemInjectionToken = getInjectionToken2<{\n  singleFactory: HotbarItemContextMenuItemFor;\n  manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;\n}>({\n  id: \"hotbar-item-context-menu-item\",\n  cardinality: \"zero-or-many\",\n})(\n  (kind: HotbarItemKind<any>): HotbarItemContextMenuItemTokenForKind =>\n    getInjectionToken2<{\n      singleFactory: HotbarItemContextMenuItemFor;\n      manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;\n    }>({\n      id: `hotbar-item-context-menu-item-${kind}`,\n      speciality: kind,\n      cardinality: \"zero-or-many\",\n    })(\n      (scopeIds: readonly string[]): HotbarItemContextMenuItemTokenFor =>\n        getInjectionToken2<{\n          singleFactory: HotbarItemContextMenuItemFor;\n          manyFactory: ManyFactory<HotbarItemContextMenuItemFor>;\n        }>({\n          id: `hotbar-item-context-menu-item-${getHotbarItemKindId(kind, scopeIds)}`,\n          speciality: getHotbarItemKindId(kind, scopeIds),\n          cardinality: \"zero-or-many\",\n        })(),\n    ),\n);\n"],
  "mappings": "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",
  "names": ["import_injectable", "import_injectable_react", "import_injectable", "import_injectable", "import_injectable", "import_injectable", "import_injectable", "import_injectable", "import_injectable", "import_injectable", "import_injectable"]
}


package/dist/src/add-to-hotbar.d.ts

@@ -0,0 +1,54 @@
+import { type ManyFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type { HotbarItemId } from "./hotbar-item-id";
+import type { HotbarItemKind, HotbarItemPersistedData } from "./hotbar-item-kind";
+/**
+ * Adds an item of one kind to the hotbar: persists its data under its id, then puts it
+ * into the first free slot of the current page. Tells the user when there is no free slot.
+ *
+ * An item is identified by its kind and then its id, so the id needs to be unique only among
+ * items of the kind. Throws when an item of the kind with the id is already on the current
+ * page, leaving the hotbar and the item's persisted data as they were. A toggle asks
+ * {@link isInHotbarInjectionToken} first.
+ */
+export type AddToHotbar<PersistedData> = (item: {
+    readonly id: HotbarItemId;
+    readonly persistedData: PersistedData;
+}) => Promise<void>;
+/** What `.for(kind).for(scopeIds)` yields: exactly one adder per kind per scope, typed by its persisted data. */
+export type AddToHotbarTokenFor<PersistedData> = SpecificInjectionToken2<{
+    singleFactory: () => AddToHotbar<PersistedData>;
+    specificTokenFactory: undefined;
+    cardinality: "one";
+}>;
+/** What `.for(kind)` yields: the kind's adders, one per scope, reached with `.for(scopeIds)`. */
+export type AddToHotbarTokenForKind<PersistedData> = SpecificInjectionToken2<{
+    singleFactory: () => AddToHotbar<PersistedData>;
+    manyFactory: ManyFactory<() => AddToHotbar<PersistedData>>;
+    specificTokenFactory: (scopeIds: readonly string[]) => AddToHotbarTokenFor<PersistedData>;
+    cardinality: "zero-or-many";
+}>;
+/**
+ * The `.for()` factories, annotated so a kind's own persisted data type survives both levels.
+ * Inference from the value alone cannot reconstruct a return type that mentions the
+ * specifier's own type parameter.
+ */
+declare const addToHotbarTokenForKind: <K extends HotbarItemKind<any>>(kind: K) => AddToHotbarTokenForKind<HotbarItemPersistedData<K>>;
+/**
+ * Add an item to the hotbar, typed by its kind: `.for(kind)` narrows to the kind, whose
+ * `persistedData` is what the kind was created for, and `.for(scopeIds)` to the registration
+ * of it, with the `di.scopeIds` of the injectable asking. Registered by
+ * `getHotbarItemKindInjectableBunch`, so every registered kind has one.
+ *
+ * @example
+ * ```ts
+ * const addBookmarkToHotbar = di.inject(addToHotbarInjectionToken.for(bookmarkHotbarItemKind).for(di.scopeIds))();
+ *
+ * await addBookmarkToHotbar({ id: `bookmark(${url})`, persistedData: { url } });
+ * ```
+ */
+export declare const addToHotbarInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => AddToHotbar<any>, () => AddToHotbar<any>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<AddToHotbar<any>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<AddToHotbar<any>>[]> & {
+    readonly __abstract: true;
+    for: typeof addToHotbarTokenForKind;
+};
+export {};
+//# sourceMappingURL=add-to-hotbar.d.ts.map

package/dist/src/add-to-hotbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-to-hotbar.d.ts","sourceRoot":"","sources":["../../src/add-to-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,KAAK,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAIlF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,EAAE;IAC9C,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEpB,iHAAiH;AACjH,MAAM,MAAM,mBAAmB,CAAC,aAAa,IAAI,uBAAuB,CAAC;IACvE,aAAa,EAAE,MAAM,WAAW,CAAC,aAAa,CAAC,CAAC;IAChD,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC;CACpB,CAAC,CAAC;AAEH,iGAAiG;AACjG,MAAM,MAAM,uBAAuB,CAAC,aAAa,IAAI,uBAAuB,CAAC;IAC3E,aAAa,EAAE,MAAM,WAAW,CAAC,aAAa,CAAC,CAAC;IAChD,WAAW,EAAE,WAAW,CAAC,MAAM,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC;IAC3D,oBAAoB,EAAE,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,KAAK,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAC1F,WAAW,EAAE,cAAc,CAAC;CAC7B,CAAC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,GAAI,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC,QACtD,CAAC,KACN,uBAAuB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAelD,CAAC;AAEJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,0DACf,WAAW,CAAC,GAAG,CAAC;;;CAKZ,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { HotbarItem } from "./hotbar-item";
+/**
+ * Takes the item, as `{ id, kind }`, out of the current hotbar page. Throws when no such item
+ * is there.
+ */
+export type EjectHotbarItem = (item: HotbarItem) => Promise<void>;
+/**
+ * The hotbar's own removal, the counterpart of `insertHotbarItemInjectionToken`: one
+ * implementation for every kind, given the whole `{ id, kind }`.
+ * `getHotbarItemKindInjectableBunch` builds `removeFromHotbarInjectionToken.for(kind)` on it,
+ * so reach for that one instead.
+ *
+ * Implemented by the hotbar.
+ */
+export declare const ejectHotbarItemInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => EjectHotbarItem, () => EjectHotbarItem[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<EjectHotbarItem>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<EjectHotbarItem>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=eject-hotbar-item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eject-hotbar-item.d.ts","sourceRoot":"","sources":["../../src/eject-hotbar-item.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,0DAA6C,eAAe;;CAGlG,CAAC"}

package/dist/src/get-hotbar-item-kind-injectable-bunch.d.ts

@@ -0,0 +1,60 @@
+import type React from "react";
+import { type AddToHotbar } from "./add-to-hotbar";
+import type { HotbarItemId } from "./hotbar-item-id";
+import { type HotbarItemKind, type HotbarItemPersistedData } from "./hotbar-item-kind";
+import { type IsInHotbar, type IsInHotbarReactive } from "./is-in-hotbar";
+import { type RemoveFromHotbar } from "./remove-from-hotbar";
+/**
+ * What a kind's component receives: which item it renders, and the data that was
+ * persisted when the item was added. Typed by the kind.
+ */
+export interface HotbarItemProps<K extends HotbarItemKind<any>> {
+    readonly id: HotbarItemId;
+    readonly persistedData: HotbarItemPersistedData<K>;
+}
+export interface HotbarItemKindBunchParams<K extends HotbarItemKind<any>> {
+    /** The kind being registered, from `getHotbarItemKind`. */
+    readonly kind: K;
+    /**
+     * Renders an item of the kind, inside the slot's frame. Receives the item's id and its
+     * persisted data, and decides everything else: what the item looks like, and what
+     * clicking it does. Must be defined at module scope.
+     */
+    readonly Component: React.ComponentType<HotbarItemProps<K>>;
+}
+/**
+ * Register a kind of hotbar item. One call declares how items of the kind render, wires
+ * their persisted data, and gives the kind its typed adder, `addToHotbarInjectionToken.for(kind).for(scopeIds)`,
+ * along with its own membership queries and remover, `isInHotbarInjectionToken.for(kind).for(scopeIds)`,
+ * `isInHotbarReactiveInjectionToken.for(kind).for(scopeIds)` and `removeFromHotbarInjectionToken.for(kind).for(scopeIds)`.
+ *
+ * The last `.for()` is the scope of the registration: every token here is registered under
+ * the scopes of whoever registers the bunch, so two extensions declaring a kind with the same
+ * specifier never meet. Items are identified by their kind, its scopes, and then their own
+ * id, never by the id alone.
+ *
+ * The hotbar frames each item, persists its `{ id, kind }` and data, pages and drags it,
+ * and gives its right-click menu a way to remove it. The component owns the rest.
+ *
+ * @example
+ * ```tsx
+ * export const bookmarkHotbarItemKind = getHotbarItemKind<{ url: string }>()("my-extension-bookmark");
+ *
+ * const Bookmark = ({ persistedData }: HotbarItemProps<typeof bookmarkHotbarItemKind>) => (
+ *   <Button onClick={() => open(persistedData.url)}>{new URL(persistedData.url).host}</Button>
+ * );
+ *
+ * export default getHotbarItemKindInjectableBunch({
+ *   kind: bookmarkHotbarItemKind,
+ *   Component: Bookmark,
+ * });
+ * ```
+ */
+export declare const getHotbarItemKindInjectableBunch: <K extends HotbarItemKind<any>>({ kind, Component, }: HotbarItemKindBunchParams<K>) => {
+    component: import("@k8slens/injectable-react").InjectableComponent2<import("./hotbar-item-component").HotbarItemComponent>;
+    addToHotbar: import("@k8slens/injectable").Injectable2<() => AddToHotbar<HotbarItemPersistedData<K>>>;
+    isInHotbar: import("@k8slens/injectable").Injectable2<() => IsInHotbar>;
+    isInHotbarReactive: import("@k8slens/injectable").Injectable2<IsInHotbarReactive>;
+    removeFromHotbar: import("@k8slens/injectable").Injectable2<() => RemoveFromHotbar>;
+};
+//# sourceMappingURL=get-hotbar-item-kind-injectable-bunch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-hotbar-item-kind-injectable-bunch.d.ts","sourceRoot":"","sources":["../../src/get-hotbar-item-kind-injectable-bunch.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,KAAK,WAAW,EAA6B,MAAM,iBAAiB,CAAC;AAK9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAuB,KAAK,cAAc,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAG5G,OAAO,EACL,KAAK,UAAU,EACf,KAAK,kBAAkB,EAGxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,gBAAgB,EAAkC,MAAM,sBAAsB,CAAC;AAE7F;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC;IAC5D,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,yBAAyB,CAAC,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC;IACtE,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gCAAgC,GAAI,CAAC,SAAS,cAAc,CAAC,GAAG,CAAC,wBAG3E,yBAAyB,CAAC,CAAC,CAAC;;;;;;CAyG9B,CAAC"}