@k8slens/drop-down-menu-contracts 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { getDropDownMenuKind } from "./src/drop-down-menu-kind";
+export { type DropDownMenuKindDeclaration, type DropDownMenuKindDeclarationFactory, type DropDownMenuKindInjectableParams, dropDownMenuKindInjectionToken, getDropDownMenuKindInjectableBunch, } from "./src/drop-down-menu-kind-injection-token";
+export type { DropDownMenuData, DropDownMenuKind } from "./src/drop-down-menu-kind";
+export { dropDownMenuItemInjectionToken, getDropDownMenuItemInjectableBunch, } from "./src/drop-down-menu-item";
+export type { DropDownMenuItem, DropDownMenuItemBunchParams, DropDownMenuItemFactory, DropDownMenuItemTokenFor, } from "./src/drop-down-menu-item";
+export { dropDownMenu } from "./src/drop-down-menu-spec";
+export type { DropDownMenuGap, DropDownMenuOpenOn, DropDownMenuOptions, DropDownMenuPosition, DropDownMenuSpec, } from "./src/drop-down-menu-spec";
+export { DefaultDropDownMenuContainer, dropDownMenuContainerComponentInjectionToken, } from "./src/drop-down-menu-container-component";
+export type { DropDownMenuContainerComponent, DropDownMenuContainerProps, DropDownMenuContainerTokenFor, } from "./src/drop-down-menu-container-component";
+export { DropDownMenu } from "./src/drop-down-menu-component";
+export type { DropDownMenuProps } from "./src/drop-down-menu-component";
+export { closeAllDropDownMenusInjectionToken, closeDropDownMenuInjectionToken, } from "./src/close-drop-down-menu";
+export type { CloseAllDropDownMenus, CloseDropDownMenu } from "./src/close-drop-down-menu";
+export { contextForClosingDropDownMenu, useCloseDropDownMenu } from "./src/close-drop-down-menu-context";
+/**
+ * The authoring model of the context menu and the anchored menu, which draw their own rows.
+ * Drop-down menus proper have no such model — their items are arbitrary components.
+ */
+export type { ActionMenuItem, ComponentLabelable, ComponentMenuItem, GroupOfMenuItems, LabelPropsFor, MenuItem, ReactLabelable, SubMenuItem, TextLabelable, } from "./src/context-menu-items";
+export { menuItemActivatedContext } from "./src/menu-item-activated-context";
+//# 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,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,kCAAkC,EACvC,KAAK,gCAAgC,EACrC,8BAA8B,EAC9B,kCAAkC,GACnC,MAAM,2CAA2C,CAAC;AACnD,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EACL,8BAA8B,EAC9B,kCAAkC,GACnC,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,gBAAgB,EAChB,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,4BAA4B,EAC5B,4CAA4C,GAC7C,MAAM,0CAA0C,CAAC;AAClD,YAAY,EACV,8BAA8B,EAC9B,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,YAAY,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EACL,mCAAmC,EACnC,+BAA+B,GAChC,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,EAAE,6BAA6B,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAEzG;;;GAGG;AACH,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,cAAc,EACd,WAAW,EACX,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/index.js

@@ -0,0 +1,149 @@
+"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, {
+  DefaultDropDownMenuContainer: () => DefaultDropDownMenuContainer,
+  DropDownMenu: () => DropDownMenu,
+  closeAllDropDownMenusInjectionToken: () => closeAllDropDownMenusInjectionToken,
+  closeDropDownMenuInjectionToken: () => closeDropDownMenuInjectionToken,
+  contextForClosingDropDownMenu: () => contextForClosingDropDownMenu,
+  dropDownMenu: () => dropDownMenu,
+  dropDownMenuContainerComponentInjectionToken: () => dropDownMenuContainerComponentInjectionToken,
+  dropDownMenuItemInjectionToken: () => dropDownMenuItemInjectionToken,
+  dropDownMenuKindInjectionToken: () => dropDownMenuKindInjectionToken,
+  getDropDownMenuItemInjectableBunch: () => getDropDownMenuItemInjectableBunch,
+  getDropDownMenuKind: () => getDropDownMenuKind,
+  getDropDownMenuKindInjectableBunch: () => getDropDownMenuKindInjectableBunch,
+  menuItemActivatedContext: () => menuItemActivatedContext,
+  useCloseDropDownMenu: () => useCloseDropDownMenu
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/drop-down-menu-kind.ts
+var import_injectable = require("@k8slens/injectable");
+var getDropDownMenuKind = () => (specifier) => (0, import_injectable.getTypedSpecifier)()(specifier);
+
+// src/drop-down-menu-kind-injection-token.ts
+var import_injectable2 = require("@k8slens/injectable");
+var dropDownMenuKindInjectionToken = (0, import_injectable2.getInjectionToken2)({
+  id: "drop-down-menu-kind",
+  cardinality: "zero-or-many"
+})();
+var getDropDownMenuKindInjectableBunch = (params) => (0, import_injectable2.getInjectableBunch)({
+  dropDownMenuKind: (0, import_injectable2.getInjectable2)({
+    id: params.id,
+    instantiate: () => () => ({
+      kind: params.kind,
+      description: params.description
+    }),
+    injectionToken: dropDownMenuKindInjectionToken
+  })
+});
+
+// src/drop-down-menu-item.ts
+var import_injectable3 = require("@k8slens/injectable");
+var dropDownMenuItemTokenFor = (kind) => (0, import_injectable3.getInjectionToken2)({
+  id: `drop-down-menu-item-${kind}`,
+  speciality: kind,
+  cardinality: "one-or-many"
+})();
+var dropDownMenuItemInjectionToken = (0, import_injectable3.getInjectionToken2)({
+  id: "drop-down-menu-item",
+  cardinality: "zero-or-many"
+})(dropDownMenuItemTokenFor);
+var getDropDownMenuItemInjectableBunch = (params) => (0, import_injectable3.getInjectableBunch)({
+  dropDownMenuItem: (0, import_injectable3.getInjectable2)({
+    id: params.id,
+    instantiate: () => () => ({
+      id: params.id,
+      orderNumber: params.orderNumber,
+      isVisible: params.isVisible,
+      Component: params.Component
+    }),
+    injectionToken: dropDownMenuItemInjectionToken.for(params.kind)
+  })
+});
+
+// src/drop-down-menu-spec.ts
+function dropDownMenu(kind, options) {
+  return { kind, ...options };
+}
+
+// src/drop-down-menu-container-component.ts
+var import_injectable4 = require("@k8slens/injectable");
+var import_injectable_react = require("@k8slens/injectable-react");
+var DefaultDropDownMenuContainer = (0, import_injectable_react.getInjectionTokenComponent2)({
+  id: "default-drop-down-menu-container"
+})();
+var dropDownMenuContainerComponentTokenFor = (kind) => (0, import_injectable4.getInjectionToken2)({
+  id: `drop-down-menu-container-component-${kind}`,
+  speciality: kind,
+  cardinality: "zero-or-one"
+})();
+var dropDownMenuContainerComponentInjectionToken = (0, import_injectable4.getInjectionToken2)({
+  id: "drop-down-menu-container-component",
+  cardinality: "zero-or-one"
+})(dropDownMenuContainerComponentTokenFor);
+
+// src/drop-down-menu-component.ts
+var import_injectable_react2 = require("@k8slens/injectable-react");
+var DropDownMenu = (0, import_injectable_react2.getInjectionTokenComponent2)({
+  id: "drop-down-menu"
+})();
+
+// src/close-drop-down-menu.ts
+var import_injectable5 = require("@k8slens/injectable");
+var closeDropDownMenuInjectionToken = (0, import_injectable5.getInjectionToken2)({
+  id: "close-drop-down-menu",
+  cardinality: "one"
+})();
+var closeAllDropDownMenusInjectionToken = (0, import_injectable5.getInjectionToken2)({
+  id: "close-all-drop-down-menus",
+  cardinality: "one"
+})();
+
+// src/close-drop-down-menu-context.ts
+var import_public_utilities = require("@k8slens/public-utilities");
+var import_react = require("react");
+var contextForClosingDropDownMenu = (0, import_react.createContext)(void 0);
+var useCloseDropDownMenu = () => (0, import_public_utilities.expectDefined)((0, import_react.useContext)(contextForClosingDropDownMenu), "Tried to close a drop-down menu while not inside one.");
+
+// src/menu-item-activated-context.ts
+var import_react2 = require("react");
+var menuItemActivatedContext = (0, import_react2.createContext)(void 0);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultDropDownMenuContainer,
+  DropDownMenu,
+  closeAllDropDownMenusInjectionToken,
+  closeDropDownMenuInjectionToken,
+  contextForClosingDropDownMenu,
+  dropDownMenu,
+  dropDownMenuContainerComponentInjectionToken,
+  dropDownMenuItemInjectionToken,
+  dropDownMenuKindInjectionToken,
+  getDropDownMenuItemInjectableBunch,
+  getDropDownMenuKind,
+  getDropDownMenuKindInjectableBunch,
+  menuItemActivatedContext,
+  useCloseDropDownMenu
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../index.ts", "../src/drop-down-menu-kind.ts", "../src/drop-down-menu-kind-injection-token.ts", "../src/drop-down-menu-item.ts", "../src/drop-down-menu-spec.ts", "../src/drop-down-menu-container-component.ts", "../src/drop-down-menu-component.ts", "../src/close-drop-down-menu.ts", "../src/close-drop-down-menu-context.ts", "../src/menu-item-activated-context.ts"],
  "sourcesContent": ["export { getDropDownMenuKind } from \"./src/drop-down-menu-kind\";\nexport {\n  type DropDownMenuKindDeclaration,\n  type DropDownMenuKindDeclarationFactory,\n  type DropDownMenuKindInjectableParams,\n  dropDownMenuKindInjectionToken,\n  getDropDownMenuKindInjectableBunch,\n} from \"./src/drop-down-menu-kind-injection-token\";\nexport type { DropDownMenuData, DropDownMenuKind } from \"./src/drop-down-menu-kind\";\nexport {\n  dropDownMenuItemInjectionToken,\n  getDropDownMenuItemInjectableBunch,\n} from \"./src/drop-down-menu-item\";\nexport type {\n  DropDownMenuItem,\n  DropDownMenuItemBunchParams,\n  DropDownMenuItemFactory,\n  DropDownMenuItemTokenFor,\n} from \"./src/drop-down-menu-item\";\nexport { dropDownMenu } from \"./src/drop-down-menu-spec\";\nexport type {\n  DropDownMenuGap,\n  DropDownMenuOpenOn,\n  DropDownMenuOptions,\n  DropDownMenuPosition,\n  DropDownMenuSpec,\n} from \"./src/drop-down-menu-spec\";\nexport {\n  DefaultDropDownMenuContainer,\n  dropDownMenuContainerComponentInjectionToken,\n} from \"./src/drop-down-menu-container-component\";\nexport type {\n  DropDownMenuContainerComponent,\n  DropDownMenuContainerProps,\n  DropDownMenuContainerTokenFor,\n} from \"./src/drop-down-menu-container-component\";\nexport { DropDownMenu } from \"./src/drop-down-menu-component\";\nexport type { DropDownMenuProps } from \"./src/drop-down-menu-component\";\nexport {\n  closeAllDropDownMenusInjectionToken,\n  closeDropDownMenuInjectionToken,\n} from \"./src/close-drop-down-menu\";\nexport type { CloseAllDropDownMenus, CloseDropDownMenu } from \"./src/close-drop-down-menu\";\nexport { contextForClosingDropDownMenu, useCloseDropDownMenu } from \"./src/close-drop-down-menu-context\";\n\n/**\n * The authoring model of the context menu and the anchored menu, which draw their own rows.\n * Drop-down menus proper have no such model \u2014 their items are arbitrary components.\n */\nexport type {\n  ActionMenuItem,\n  ComponentLabelable,\n  ComponentMenuItem,\n  GroupOfMenuItems,\n  LabelPropsFor,\n  MenuItem,\n  ReactLabelable,\n  SubMenuItem,\n  TextLabelable,\n} from \"./src/context-menu-items\";\nexport { menuItemActivatedContext } from \"./src/menu-item-activated-context\";\n", "import { getTypedSpecifier, type TypedSpecifier, type TypedSpecifierType } from \"@k8slens/injectable\";\n\n/**\n * Identifies one family of drop-down menu items. Items are contributed against\n * a kind via `dropDownMenuItemInjectionToken.for(kind)`, and a host element\n * opens the menu of a kind with `$dropDownMenu={dropDownMenu(kind)}`.\n *\n * `TData` is the data the host element supplies when opening the menu; item\n * factories of the kind receive it. A kind created without `TData` needs no\n * data.\n *\n * At runtime a kind is a branded string, so it is usable as a `.for()` key.\n */\nexport type DropDownMenuKind<TData = void> = TypedSpecifier<string, { dropDownMenuData: TData }>;\n\n/**\n * Recovers the data type bound to a {@link DropDownMenuKind}.\n */\nexport type DropDownMenuData<K extends DropDownMenuKind<any>> = TypedSpecifierType<\"dropDownMenuData\", K>;\n\n/**\n * Curried creator for a {@link DropDownMenuKind}. The first call binds the data\n * type; the second the globally unique specifier string.\n *\n * @example\n * ```ts\n * // A menu whose items need no data:\n * export const aiToolsMenuKind = getDropDownMenuKind()(\"ai-tools-menu\");\n *\n * // A menu whose items derive from the host element's data:\n * export const podActionsMenuKind = getDropDownMenuKind<{ podName: string }>()(\"pod-actions-menu\");\n * ```\n */\nexport const getDropDownMenuKind =\n  <TData = void>() =>\n  <S extends string>(specifier: S) =>\n    getTypedSpecifier<{ dropDownMenuData: TData }>()(specifier);\n", "import { getInjectable2, getInjectableBunch, getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { DropDownMenuKind } from \"./drop-down-menu-kind\";\n\n/**\n * One drop-down menu that exists, announced so it can be discovered rather\n * than found by reading the source.\n */\nexport interface DropDownMenuKindDeclaration {\n  /** The kind itself, as `dropDownMenuItemInjectionToken.for(kind)` takes it. */\n  readonly kind: DropDownMenuKind<any>;\n  /** One line on what the menu is, for a reader deciding whether to contribute. */\n  readonly description: string;\n}\n\n/** Produces one declaration, possibly later. */\nexport type DropDownMenuKindDeclarationFactory = () => DropDownMenuKindDeclaration;\n\n/**\n * Every drop-down menu kind the running build knows about.\n *\n * Injecting many of these is how a surface enumerates the menus that exist \u2014\n * the extension-development instructions render their list from it, so a new\n * menu becomes documented by registering here rather than by someone\n * remembering to edit prose.\n */\nexport const dropDownMenuKindInjectionToken = getInjectionToken2<{\n  singleFactory: DropDownMenuKindDeclarationFactory;\n}>({\n  id: \"drop-down-menu-kind\",\n  cardinality: \"zero-or-many\",\n})();\n\nexport interface DropDownMenuKindInjectableParams {\n  /** Unique id for the registered injectable. */\n  readonly id: string;\n  /** The kind being announced. */\n  readonly kind: DropDownMenuKind<any>;\n  /** One line on what the menu is. */\n  readonly description: string;\n}\n\n/**\n * Announce a drop-down menu kind, so anything enumerating the menus finds it.\n *\n * Register this wherever the menu's own surface is registered \u2014 a contracts\n * package exports the kind, but not the registration.\n *\n * @example\n * ```ts\n * export default getDropDownMenuKindInjectableBunch({\n *   id: \"ai-tool-top-bar-menu-kind\",\n *   kind: aiToolTopBarMenuKind,\n *   description: \"The menu of the AI tool button in the top bar.\",\n * });\n * ```\n */\nexport const getDropDownMenuKindInjectableBunch = (params: DropDownMenuKindInjectableParams) =>\n  getInjectableBunch({\n    dropDownMenuKind: getInjectable2({\n      id: params.id,\n\n      instantiate: () => (): DropDownMenuKindDeclaration => ({\n        kind: params.kind,\n        description: params.description,\n      }),\n\n      injectionToken: dropDownMenuKindInjectionToken,\n    }),\n  });\n", "import {\n  getInjectable2,\n  getInjectableBunch,\n  getInjectionToken2,\n  type ManyFactory,\n  type NonEmptyManyFactory,\n  type SpecificInjectionToken2,\n} from \"@k8slens/injectable\";\nimport type {\n  Identifiable,\n  MaybeComputed,\n  MaybeComputedShowable,\n  Orderable,\n} from \"@k8slens/composable-responsibilities\";\nimport type { MaybePromise } from \"@k8slens/public-utilities\";\nimport type React from \"react\";\nimport type { DropDownMenuData, DropDownMenuKind } from \"./drop-down-menu-kind\";\n\n/**\n * One item of a drop-down menu: a component, where it sits among the others, and whether it is\n * shown at all. What the item looks like and what it does are its own business \u2014 a menu neither\n * draws it nor decides anything about it.\n *\n * The component is given the data the host element opened the menu with, and must be defined at\n * module scope; capturing data in a closure would create a new component reference on every\n * invocation and break React reconciliation.\n */\nexport interface DropDownMenuItem<TData = void> extends Identifiable, Orderable, MaybeComputedShowable {\n  readonly Component: React.ComponentType<{ readonly data: TData }>;\n}\n\n/** Produces one item, possibly later. */\nexport type DropDownMenuItemFactory<TData = any> = () => MaybePromise<DropDownMenuItem<TData>>;\n\n/**\n * The specific token `.for(kind)` yields: the items contributed to one menu kind. At least one of\n * them, so that a kind nobody contributes to is a composition error rather than a menu that never\n * opens.\n */\nexport type DropDownMenuItemTokenFor<TData> = SpecificInjectionToken2<{\n  singleFactory: DropDownMenuItemFactory<TData>;\n  manyFactory: NonEmptyManyFactory<DropDownMenuItemFactory<TData>>;\n  specificTokenFactory: undefined;\n  cardinality: \"one-or-many\";\n}>;\n\n/**\n * The `.for()` factory, annotated so a kind's own data type survives into the specific token. The\n * annotation carries what the retired third type parameter used to: inference from the value alone\n * cannot reconstruct a return type that mentions the specifier's own type parameter.\n */\nconst dropDownMenuItemTokenFor = <K extends DropDownMenuKind<any>>(\n  kind: K,\n): DropDownMenuItemTokenFor<DropDownMenuData<K>> =>\n  getInjectionToken2<{\n    singleFactory: DropDownMenuItemFactory<DropDownMenuData<K>>;\n    manyFactory: NonEmptyManyFactory<DropDownMenuItemFactory<DropDownMenuData<K>>>;\n  }>({\n    id: `drop-down-menu-item-${kind}`,\n    speciality: kind,\n    cardinality: \"one-or-many\",\n  })();\n\n/**\n * The contribution surface of drop-down menus: one item per contribution, registered against a\n * {@link DropDownMenuKind} via `.for(kind)`. Prefer {@link getDropDownMenuItemInjectableBunch}\n * over registering by hand.\n */\nexport const dropDownMenuItemInjectionToken = getInjectionToken2<{\n  singleFactory: DropDownMenuItemFactory<any>;\n  manyFactory: ManyFactory<DropDownMenuItemFactory<any>>;\n}>({\n  id: \"drop-down-menu-item\",\n  cardinality: \"zero-or-many\",\n})(dropDownMenuItemTokenFor);\n\nexport interface DropDownMenuItemBunchParams<K extends DropDownMenuKind<any>> {\n  /** Unique id for the registered injectable; doubles as the item's id. */\n  readonly id: string;\n  /** The menu kind the item belongs to. */\n  readonly kind: K;\n  /** Lower comes first among the kind's items. */\n  readonly orderNumber: number;\n  /** Whether the item is shown at all; the menu reacts to this while open. */\n  readonly isVisible?: MaybeComputed<boolean>;\n  /** Renders the item. Receives the data the menu was opened with. */\n  readonly Component: React.ComponentType<{ readonly data: DropDownMenuData<K> }>;\n}\n\n/**\n * Contribute one item to a drop-down menu kind.\n *\n * @example\n * ```tsx\n * const RestartPod = ({ data }: { data: { podName: string } }) => (\n *   <ClickableLi $onClick={() => restart(data.podName)}>Restart {data.podName}</ClickableLi>\n * );\n *\n * export const restartPodBunch = getDropDownMenuItemInjectableBunch({\n *   id: \"restart-pod\",\n *   kind: podActionsMenuKind,\n *   orderNumber: 10,\n *   isVisible: computed(() => canRestart.get()),\n *   Component: RestartPod,\n * });\n * ```\n */\nexport const getDropDownMenuItemInjectableBunch = <K extends DropDownMenuKind<any>>(\n  params: DropDownMenuItemBunchParams<K>,\n) =>\n  getInjectableBunch({\n    dropDownMenuItem: getInjectable2({\n      id: params.id,\n\n      instantiate: () => (): DropDownMenuItem<DropDownMenuData<K>> => ({\n        id: params.id,\n        orderNumber: params.orderNumber,\n        isVisible: params.isVisible,\n        Component: params.Component,\n      }),\n\n      injectionToken: dropDownMenuItemInjectionToken.for(params.kind),\n    }),\n  });\n", "import type { DropDownMenuData, DropDownMenuKind } from \"./drop-down-menu-kind\";\n\n/**\n * How the menu opens from its host element.\n *\n * - `\"click\"` (the default): clicking the element toggles the menu.\n * - `\"hover\"`: the menu opens while the pointer is over the element or the menu.\n * - `\"right-click\"`: right-clicking the element toggles the menu. The menu stays anchored to the\n *   element; cursor-anchored right-click menus are the concern of `@lensapp/context-menu`.\n */\nexport type DropDownMenuOpenOn = \"click\" | \"hover\" | \"right-click\";\n\n/**\n * Where the menu sits relative to its host element: a side of the host, optionally refined with how\n * the menu extends along that side. A bare side centers the menu on it; `span-<direction>` aligns\n * their edges and lets the menu extend toward that direction.\n *\n * Defaults to `\"bottom span-right\"`. When the menu would not fit the viewport, it falls back to the\n * mirrored positions.\n *\n * Note: kept identical to `AnchorPosition` of `@k8slens/element-components`, which cannot be\n * imported here \u2014 it depends on this package.\n */\nexport type DropDownMenuPosition =\n  | \"top\"\n  | \"bottom\"\n  | \"left\"\n  | \"right\"\n  | \"top span-left\"\n  | \"top span-right\"\n  | \"bottom span-left\"\n  | \"bottom span-right\"\n  | \"left span-top\"\n  | \"left span-bottom\"\n  | \"right span-top\"\n  | \"right span-bottom\";\n\n/**\n * How far from its host the menu sits, on the shared t-shirt scale. Defaults to `\"xs\"`.\n *\n * Note: kept identical to `TShirtSize` of `@k8slens/element-components`, which cannot be imported\n * here \u2014 it depends on this package.\n */\nexport type DropDownMenuGap =\n  | \"zero\"\n  | \"4xs\"\n  | \"3xs\"\n  | \"xxs\"\n  | \"xs\"\n  | \"s\"\n  | \"m\"\n  | \"l\"\n  | \"xl\"\n  | \"xxl\"\n  | \"3xl\"\n  | \"4xl\"\n  | \"5xl\"\n  | \"6xl\"\n  | \"7xl\"\n  | \"8xl\"\n  | \"9xl\"\n  | \"10xl\"\n  | \"11xl\";\n\n/**\n * The value of the `$dropDownMenu` element prop: which menu kind to open, the data its item\n * factories receive, how the menu opens and where it sits. Create with {@link dropDownMenu} so the\n * data is typed by the kind.\n */\nexport type DropDownMenuSpec = {\n  readonly kind: DropDownMenuKind<any>;\n  readonly data?: unknown;\n  readonly openOn?: DropDownMenuOpenOn;\n  readonly position?: DropDownMenuPosition;\n  readonly gap?: DropDownMenuGap;\n};\n\nexport type DropDownMenuOptions = {\n  readonly openOn?: DropDownMenuOpenOn;\n  readonly position?: DropDownMenuPosition;\n  readonly gap?: DropDownMenuGap;\n};\n\n/**\n * Typed constructor for a {@link DropDownMenuSpec}: a kind created for a data type makes `data`\n * required and typed; a kind without data forbids it.\n *\n * @example\n * ```tsx\n * <Button $dropDownMenu={dropDownMenu(aiToolsMenuKind)}>Open</Button>\n * <Button $dropDownMenu={dropDownMenu(podActionsMenuKind, { data: { podName } })}>Pod</Button>\n * <Button $dropDownMenu={dropDownMenu(rowActionsMenuKind, { position: \"bottom span-left\" })}>\u22EE</Button>\n * ```\n */\nexport function dropDownMenu<K extends DropDownMenuKind<void>>(\n  kind: K,\n  options?: DropDownMenuOptions,\n): DropDownMenuSpec;\nexport function dropDownMenu<K extends DropDownMenuKind<any>>(\n  kind: K,\n  options: DropDownMenuOptions & { readonly data: DropDownMenuData<K> },\n): DropDownMenuSpec;\nexport function dropDownMenu(\n  kind: DropDownMenuKind<any>,\n  options?: DropDownMenuOptions & { readonly data?: unknown },\n): DropDownMenuSpec {\n  return { kind, ...options };\n}\n", "import { getInjectionToken2, type MaybeResultFactory, type SpecificInjectionToken2 } from \"@k8slens/injectable\";\nimport { getInjectionTokenComponent2 } from \"@k8slens/injectable-react\";\nimport type React from \"react\";\nimport type { DropDownMenuData, DropDownMenuKind } from \"./drop-down-menu-kind\";\nimport type { DropDownMenuItem } from \"./drop-down-menu-item\";\n\n/**\n * The props the menu hands its container. They position the container, put it above everything\n * else, and let a menu opened by hovering know the pointer is on it \u2014 so the container must spread\n * them onto whichever element it renders.\n */\nexport type DropDownMenuContainerProps<TData = void> = {\n  readonly children: React.ReactNode;\n\n  /**\n   * The items of the menu, as its kind declares them, for a container that lays them out itself\n   * rather than rendering what the menu gave it as children.\n   */\n  readonly items?: readonly DropDownMenuItem<TData>[];\n} & Record<string, unknown>;\n\nexport type DropDownMenuContainerComponent<TData = void> = () => React.ComponentType<DropDownMenuContainerProps<TData>>;\n\n/**\n * The container a menu renders as when its kind contributes none of its own. Implemented by\n * `@lensapp/drop-down-menu`; override it to change what every menu is made of.\n */\nexport const DefaultDropDownMenuContainer = getInjectionTokenComponent2<\n  React.ComponentType<DropDownMenuContainerProps>\n>({\n  id: \"default-drop-down-menu-container\",\n})();\n\n/** The specific token `.for(kind)` yields: at most one container for a menu kind, typed by it. */\nexport type DropDownMenuContainerTokenFor<TData> = SpecificInjectionToken2<{\n  singleFactory: DropDownMenuContainerComponent<TData>;\n  maybeFactory: MaybeResultFactory<DropDownMenuContainerComponent<TData>>;\n  specificTokenFactory: undefined;\n  cardinality: \"zero-or-one\";\n}>;\n\n/**\n * The `.for()` factory, annotated so a kind's own data type survives into the specific token. The\n * annotation carries what the retired third type parameter used to: inference from the value alone\n * cannot reconstruct a return type that mentions the specifier's own type parameter.\n */\nconst dropDownMenuContainerComponentTokenFor = <K extends DropDownMenuKind<any>>(\n  kind: K,\n): DropDownMenuContainerTokenFor<DropDownMenuData<K>> =>\n  getInjectionToken2<{\n    singleFactory: DropDownMenuContainerComponent<DropDownMenuData<K>>;\n    maybeFactory: MaybeResultFactory<DropDownMenuContainerComponent<DropDownMenuData<K>>>;\n  }>({\n    id: `drop-down-menu-container-component-${kind}`,\n    speciality: kind,\n    cardinality: \"zero-or-one\",\n  })();\n\n/**\n * The element a menu of some kind renders as. Without one, a menu is a list \u2014 which is what a menu\n * of ordinary items should be. Contribute one when the items are not a list: a grid of icons, say,\n * or a panel that happens to open like a menu.\n *\n * @example\n * ```tsx\n * // Items typed by the kind, for a container that lays them out itself.\n * const IconGrid = ({ items = [], ...menuProps }: DropDownMenuContainerProps) => (\n *   <Div {...menuProps} $grid={{ columns: 3 }}>\n *     {items.map((item) => (\n *       <item.Component key={item.id} data={undefined} />\n *     ))}\n *   </Div>\n * );\n *\n * export const iconGridContainerInjectable = getInjectable2({\n *   id: \"icon-grid-container\",\n *   instantiate: () => () => IconGrid,\n *   injectionToken: dropDownMenuContainerComponentInjectionToken.for(iconsMenuKind),\n * });\n * ```\n */\nexport const dropDownMenuContainerComponentInjectionToken = getInjectionToken2<{\n  singleFactory: DropDownMenuContainerComponent<any>;\n  maybeFactory: MaybeResultFactory<DropDownMenuContainerComponent<any>>;\n}>({\n  id: \"drop-down-menu-container-component\",\n  cardinality: \"zero-or-one\",\n})(dropDownMenuContainerComponentTokenFor);\n", "import { getInjectionTokenComponent2 } from \"@k8slens/injectable-react\";\nimport type React from \"react\";\nimport type { DropDownMenuSpec } from \"./drop-down-menu-spec\";\n\nexport interface DropDownMenuProps {\n  /** Which menu to show: the kind, its data, how it opens and where it sits. */\n  readonly spec: DropDownMenuSpec;\n\n  /**\n   * Viewport point to sit at, instead of the host element \u2014 how a menu opened by right-clicking\n   * ends up at the cursor.\n   */\n  readonly anchorPoint?: { readonly x: number; readonly y: number };\n\n  /** Called when the menu closes itself (item activation, outside click, Escape, no items). */\n  readonly onClose: VoidFunction;\n\n  /** Reports pointer presence over the menu surface; hover-opened hosts stay open while true. */\n  readonly onMenuHoverChange?: (isHovered: boolean) => void;\n}\n\n/**\n * The menu component the `$dropDownMenu` element prop renders while open. It renders inside the\n * host element and anchors itself to it, so the host needs no ref and the menu needs no portal.\n *\n * Implemented by `@lensapp/drop-down-menu`, whose feature must be registered for the prop to work;\n * resolved through this token so element-components needs no dependency on the implementation.\n */\nexport const DropDownMenu = getInjectionTokenComponent2<React.ComponentType<DropDownMenuProps>>({\n  id: \"drop-down-menu\",\n})();\n", "import { getInjectionToken2 } from \"@k8slens/injectable\";\nimport type { DropDownMenuKind } from \"./drop-down-menu-kind\";\n\n/** Closes the open drop-down menu of the given kind. */\nexport type CloseDropDownMenu = (kind: DropDownMenuKind<any>) => void;\n\n/**\n * Programmatically close the open drop-down menu of one kind. Menus of other kinds stay open.\n *\n * @example\n * ```ts\n * const closeDropDownMenu = di.inject(closeDropDownMenuInjectionToken)();\n *\n * closeDropDownMenu(podActionsMenuKind);\n * ```\n */\nexport const closeDropDownMenuInjectionToken = getInjectionToken2<{ singleFactory: () => CloseDropDownMenu }>({\n  id: \"close-drop-down-menu\",\n  cardinality: \"one\",\n})();\n\n/** Closes every open drop-down menu. */\nexport type CloseAllDropDownMenus = VoidFunction;\n\n/**\n * Programmatically close all open drop-down menus, regardless of kind.\n *\n * @example\n * ```ts\n * const closeAllDropDownMenus = di.inject(closeAllDropDownMenusInjectionToken)();\n *\n * closeAllDropDownMenus();\n * ```\n */\nexport const closeAllDropDownMenusInjectionToken = getInjectionToken2<{ singleFactory: () => CloseAllDropDownMenus }>({\n  id: \"close-all-drop-down-menus\",\n  cardinality: \"one\",\n})();\n", "import { expectDefined } from \"@k8slens/public-utilities\";\nimport { createContext, useContext } from \"react\";\n\n/**\n * Carries the close function of the drop-down menu a component is rendered in. Provided by the\n * menu implementation around its items; consume through {@link useCloseDropDownMenu}.\n */\nexport const contextForClosingDropDownMenu = createContext<VoidFunction | undefined>(undefined);\n\n/**\n * Inside menu content: returns a function closing the menu this component is rendered in \u2014 only\n * that menu, not its ancestors. Throws when used outside a drop-down menu.\n *\n * @example\n * ```tsx\n * const CustomRow = () => {\n *   const closeDropDownMenu = useCloseDropDownMenu();\n *\n *   return <ClickableDiv $onClick={closeDropDownMenu}>Done</ClickableDiv>;\n * };\n * ```\n */\nexport const useCloseDropDownMenu = () =>\n  expectDefined(useContext(contextForClosingDropDownMenu), \"Tried to close a drop-down menu while not inside one.\");\n", "import { createContext } from \"react\";\n\n/**\n * Told by an item when it is activated, so the menu it belongs to \u2014 and the menus it was opened\n * from \u2014 can close. Items themselves know nothing of menus.\n */\nexport const menuItemActivatedContext = createContext<VoidFunction | undefined>(undefined);\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,wBAAgF;AAiCzE,IAAM,sBACX,MACA,CAAmB,kBACjB,qCAA+C,EAAE,SAAS;;;ACpC9D,IAAAA,qBAAuE;AAyBhE,IAAM,qCAAiC,uCAE3C;AAAA,EACD,IAAI;AAAA,EACJ,aAAa;AACf,CAAC,EAAE;AA0BI,IAAM,qCAAqC,CAAC,eACjD,uCAAmB;AAAA,EACjB,sBAAkB,mCAAe;AAAA,IAC/B,IAAI,OAAO;AAAA,IAEX,aAAa,MAAM,OAAoC;AAAA,MACrD,MAAM,OAAO;AAAA,MACb,aAAa,OAAO;AAAA,IACtB;AAAA,IAEA,gBAAgB;AAAA,EAClB,CAAC;AACH,CAAC;;;ACpEH,IAAAC,qBAOO;AA4CP,IAAM,2BAA2B,CAC/B,aAEA,uCAGG;AAAA,EACD,IAAI,uBAAuB,IAAI;AAAA,EAC/B,YAAY;AAAA,EACZ,aAAa;AACf,CAAC,EAAE;AAOE,IAAM,qCAAiC,uCAG3C;AAAA,EACD,IAAI;AAAA,EACJ,aAAa;AACf,CAAC,EAAE,wBAAwB;AAiCpB,IAAM,qCAAqC,CAChD,eAEA,uCAAmB;AAAA,EACjB,sBAAkB,mCAAe;AAAA,IAC/B,IAAI,OAAO;AAAA,IAEX,aAAa,MAAM,OAA8C;AAAA,MAC/D,IAAI,OAAO;AAAA,MACX,aAAa,OAAO;AAAA,MACpB,WAAW,OAAO;AAAA,MAClB,WAAW,OAAO;AAAA,IACpB;AAAA,IAEA,gBAAgB,+BAA+B,IAAI,OAAO,IAAI;AAAA,EAChE,CAAC;AACH,CAAC;;;ACrBI,SAAS,aACd,MACA,SACkB;AAClB,SAAO,EAAE,MAAM,GAAG,QAAQ;AAC5B;;;AC3GA,IAAAC,qBAA0F;AAC1F,8BAA4C;AA0BrC,IAAM,mCAA+B,qDAE1C;AAAA,EACA,IAAI;AACN,CAAC,EAAE;AAeH,IAAM,yCAAyC,CAC7C,aAEA,uCAGG;AAAA,EACD,IAAI,sCAAsC,IAAI;AAAA,EAC9C,YAAY;AAAA,EACZ,aAAa;AACf,CAAC,EAAE;AAyBE,IAAM,mDAA+C,uCAGzD;AAAA,EACD,IAAI;AAAA,EACJ,aAAa;AACf,CAAC,EAAE,sCAAsC;;;ACvFzC,IAAAC,2BAA4C;AA4BrC,IAAM,mBAAe,sDAAoE;AAAA,EAC9F,IAAI;AACN,CAAC,EAAE;;;AC9BH,IAAAC,qBAAmC;AAgB5B,IAAM,sCAAkC,uCAA+D;AAAA,EAC5G,IAAI;AAAA,EACJ,aAAa;AACf,CAAC,EAAE;AAeI,IAAM,0CAAsC,uCAAmE;AAAA,EACpH,IAAI;AAAA,EACJ,aAAa;AACf,CAAC,EAAE;;;ACrCH,8BAA8B;AAC9B,mBAA0C;AAMnC,IAAM,oCAAgC,4BAAwC,MAAS;AAevF,IAAM,uBAAuB,UAClC,2CAAc,yBAAW,6BAA6B,GAAG,uDAAuD;;;ACvBlH,IAAAC,gBAA8B;AAMvB,IAAM,+BAA2B,6BAAwC,MAAS;",
  "names": ["import_injectable", "import_injectable", "import_injectable", "import_injectable_react", "import_injectable", "import_react"]
}


package/dist/src/close-drop-down-menu-context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Carries the close function of the drop-down menu a component is rendered in. Provided by the
+ * menu implementation around its items; consume through {@link useCloseDropDownMenu}.
+ */
+export declare const contextForClosingDropDownMenu: import("react").Context<VoidFunction | undefined>;
+/**
+ * Inside menu content: returns a function closing the menu this component is rendered in — only
+ * that menu, not its ancestors. Throws when used outside a drop-down menu.
+ *
+ * @example
+ * ```tsx
+ * const CustomRow = () => {
+ *   const closeDropDownMenu = useCloseDropDownMenu();
+ *
+ *   return <ClickableDiv $onClick={closeDropDownMenu}>Done</ClickableDiv>;
+ * };
+ * ```
+ */
+export declare const useCloseDropDownMenu: () => VoidFunction;
+//# sourceMappingURL=close-drop-down-menu-context.d.ts.map

package/dist/src/close-drop-down-menu-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-drop-down-menu-context.d.ts","sourceRoot":"","sources":["../../src/close-drop-down-menu-context.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,6BAA6B,mDAAqD,CAAC;AAEhG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,oBACkF,CAAC"}

package/dist/src/close-drop-down-menu.d.ts

@@ -0,0 +1,32 @@
+import type { DropDownMenuKind } from "./drop-down-menu-kind";
+/** Closes the open drop-down menu of the given kind. */
+export type CloseDropDownMenu = (kind: DropDownMenuKind<any>) => void;
+/**
+ * Programmatically close the open drop-down menu of one kind. Menus of other kinds stay open.
+ *
+ * @example
+ * ```ts
+ * const closeDropDownMenu = di.inject(closeDropDownMenuInjectionToken)();
+ *
+ * closeDropDownMenu(podActionsMenuKind);
+ * ```
+ */
+export declare const closeDropDownMenuInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => CloseDropDownMenu, () => CloseDropDownMenu[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<CloseDropDownMenu>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<CloseDropDownMenu>[]> & {
+    readonly __abstract?: never;
+};
+/** Closes every open drop-down menu. */
+export type CloseAllDropDownMenus = VoidFunction;
+/**
+ * Programmatically close all open drop-down menus, regardless of kind.
+ *
+ * @example
+ * ```ts
+ * const closeAllDropDownMenus = di.inject(closeAllDropDownMenusInjectionToken)();
+ *
+ * closeAllDropDownMenus();
+ * ```
+ */
+export declare const closeAllDropDownMenusInjectionToken: import("@k8slens/injectable").InjectionToken2Base<() => CloseAllDropDownMenus, () => VoidFunction[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<VoidFunction>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<VoidFunction>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=close-drop-down-menu.d.ts.map

package/dist/src/close-drop-down-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-drop-down-menu.d.ts","sourceRoot":"","sources":["../../src/close-drop-down-menu.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,wDAAwD;AACxD,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC;AAEtE;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B,0DAA6C,iBAAiB;;CAGtG,CAAC;AAEL,wCAAwC;AACxC,MAAM,MAAM,qBAAqB,GAAG,YAAY,CAAC;AAEjD;;;;;;;;;GASG;AACH,eAAO,MAAM,mCAAmC,0DAA6C,qBAAqB;;CAG9G,CAAC"}

package/dist/src/context-menu-items.d.ts

@@ -0,0 +1,77 @@
+import type { Discriminable, Orderable, MaybeComputedShowable, MaybeComputedEnableable, Identifiable } from "@k8slens/composable-responsibilities";
+import type { MaybeAsyncVoidFunction, MaybePromise } from "@k8slens/public-utilities";
+import type React from "react";
+/**
+ * A label given as plain text.
+ */
+export type TextLabelable = {
+    readonly labelText: string;
+    readonly Label?: undefined;
+    readonly labelProps?: undefined;
+};
+/**
+ * When the label component requires props, providing them is mandatory; when all of its props are
+ * optional, so is providing them.
+ */
+export type LabelPropsFor<P extends object> = {} extends P ? {
+    readonly labelProps?: P;
+} : {
+    readonly labelProps: P;
+};
+/**
+ * A label given as a component type the menu renders where and when the label is shown. The
+ * component must be defined at module scope; any data it needs arrives as props through
+ * `labelProps`. Capturing data in a closure instead would create a new component reference on
+ * every invocation and break React reconciliation.
+ */
+export type ComponentLabelable<P extends object = any> = {
+    readonly labelText?: undefined;
+    readonly Label: React.ComponentType<P>;
+} & LabelPropsFor<P>;
+/**
+ * Exactly one of `labelText` and `Label` must be provided.
+ */
+export type ReactLabelable<P extends object = any> = TextLabelable | ComponentLabelable<P>;
+/**
+ * A clickable menu item. Visibility (`isVisible`/`isHidden`) and enablement (`isEnabled`) may be
+ * given as computeds, in which case the menu reacts to their changes while open.
+ */
+export type ActionMenuItem<P extends object = any> = Discriminable<"action"> & Identifiable & Orderable & ReactLabelable<P> & MaybeComputedShowable & MaybeComputedEnableable & {
+    /**
+     * This function will be called when the user clicks on this menu item
+     */
+    readonly onClick: MaybePromise<MaybeAsyncVoidFunction>;
+    readonly parentId: string | undefined;
+};
+/**
+ * A menu item that reveals nested items on hover.
+ */
+export type SubMenuItem<P extends object = any> = Discriminable<"sub-menu"> & Identifiable & Orderable & ReactLabelable<P> & MaybeComputedShowable & MaybeComputedEnableable & {
+    readonly parentId: string | undefined;
+    readonly onClick?: MaybePromise<MaybeAsyncVoidFunction>;
+};
+/**
+ * An item that renders itself entirely — the element it lives in included. The menu puts the
+ * component in its list and stays out of the way, so the item decides its own markup, whether it
+ * anchors anything, and whether it takes part in keyboard navigation.
+ *
+ * The component must be defined at module scope; capturing data in a closure would create a new
+ * component reference on every invocation and break React reconciliation.
+ */
+export interface ComponentMenuItem extends Discriminable<"component">, Identifiable, Orderable, MaybeComputedShowable {
+    readonly Component: React.ComponentType;
+    readonly parentId: string | undefined;
+}
+/**
+ * A group of items that should have separators before the first item (if applicable) and after the last item (if applicable)
+ */
+export interface GroupOfMenuItems extends Discriminable<"group">, MaybeComputedShowable, Identifiable, Orderable {
+    readonly parentId: string | undefined;
+}
+/**
+ * The authoring model of a menu item: a clickable action, a sub-menu, or a group. Items reference
+ * each other by `id`/`parentId`; siblings are ordered by `orderNumber`, and separators appear
+ * between adjacent groups.
+ */
+export type MenuItem = ActionMenuItem | SubMenuItem | ComponentMenuItem | GroupOfMenuItems;
+//# sourceMappingURL=context-menu-items.d.ts.map

package/dist/src/context-menu-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-items.d.ts","sourceRoot":"","sources":["../../src/context-menu-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,YAAY,EACb,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC;CACjC,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI,EAAE,SAAS,CAAC,GAAG;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAA;CAAE,CAAC;AAEtH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,IAAI;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;CACxC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAErB;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,IAAI,aAAa,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAE3F;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,IAAI,aAAa,CAAC,QAAQ,CAAC,GAC1E,YAAY,GACZ,SAAS,GACT,cAAc,CAAC,CAAC,CAAC,GACjB,qBAAqB,GACrB,uBAAuB,GAAG;IACxB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC,sBAAsB,CAAC,CAAC;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC,CAAC;AAEJ;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,IAAI,aAAa,CAAC,UAAU,CAAC,GACzE,YAAY,GACZ,SAAS,GACT,cAAc,CAAC,CAAC,CAAC,GACjB,qBAAqB,GACrB,uBAAuB,GAAG;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,sBAAsB,CAAC,CAAC;CACzD,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,WAAW,iBAAkB,SAAQ,aAAa,CAAC,WAAW,CAAC,EAAE,YAAY,EAAE,SAAS,EAAE,qBAAqB;IACnH,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,aAAa,CAAC,OAAO,CAAC,EAAE,qBAAqB,EAAE,YAAY,EAAE,SAAS;IAC9G,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,WAAW,GAAG,iBAAiB,GAAG,gBAAgB,CAAC"}

package/dist/src/drop-down-menu-component.d.ts

@@ -0,0 +1,29 @@
+import type React from "react";
+import type { DropDownMenuSpec } from "./drop-down-menu-spec";
+export interface DropDownMenuProps {
+    /** Which menu to show: the kind, its data, how it opens and where it sits. */
+    readonly spec: DropDownMenuSpec;
+    /**
+     * Viewport point to sit at, instead of the host element — how a menu opened by right-clicking
+     * ends up at the cursor.
+     */
+    readonly anchorPoint?: {
+        readonly x: number;
+        readonly y: number;
+    };
+    /** Called when the menu closes itself (item activation, outside click, Escape, no items). */
+    readonly onClose: VoidFunction;
+    /** Reports pointer presence over the menu surface; hover-opened hosts stay open while true. */
+    readonly onMenuHoverChange?: (isHovered: boolean) => void;
+}
+/**
+ * The menu component the `$dropDownMenu` element prop renders while open. It renders inside the
+ * host element and anchors itself to it, so the host needs no ref and the menu needs no portal.
+ *
+ * Implemented by `@lensapp/drop-down-menu`, whose feature must be registered for the prop to work;
+ * resolved through this token so element-components needs no dependency on the implementation.
+ */
+export declare const DropDownMenu: React.ComponentType<DropDownMenuProps> & import("@k8slens/injectable").InjectionToken2Base<() => React.ComponentType<DropDownMenuProps>, () => React.ComponentType<DropDownMenuProps>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuProps>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuProps>>[]> & {
+    readonly __abstract?: never;
+};
+//# sourceMappingURL=drop-down-menu-component.d.ts.map

package/dist/src/drop-down-menu-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-down-menu-component.d.ts","sourceRoot":"","sources":["../../src/drop-down-menu-component.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAEhC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE;QAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAElE,6FAA6F;IAC7F,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAE/B,+FAA+F;IAC/F,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;CAErB,CAAC"}

package/dist/src/drop-down-menu-container-component.d.ts

@@ -0,0 +1,67 @@
+import { type MaybeResultFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type React from "react";
+import type { DropDownMenuData, DropDownMenuKind } from "./drop-down-menu-kind";
+import type { DropDownMenuItem } from "./drop-down-menu-item";
+/**
+ * The props the menu hands its container. They position the container, put it above everything
+ * else, and let a menu opened by hovering know the pointer is on it — so the container must spread
+ * them onto whichever element it renders.
+ */
+export type DropDownMenuContainerProps<TData = void> = {
+    readonly children: React.ReactNode;
+    /**
+     * The items of the menu, as its kind declares them, for a container that lays them out itself
+     * rather than rendering what the menu gave it as children.
+     */
+    readonly items?: readonly DropDownMenuItem<TData>[];
+} & Record<string, unknown>;
+export type DropDownMenuContainerComponent<TData = void> = () => React.ComponentType<DropDownMenuContainerProps<TData>>;
+/**
+ * The container a menu renders as when its kind contributes none of its own. Implemented by
+ * `@lensapp/drop-down-menu`; override it to change what every menu is made of.
+ */
+export declare const DefaultDropDownMenuContainer: React.ComponentType<DropDownMenuContainerProps<void>> & import("@k8slens/injectable").InjectionToken2Base<() => React.ComponentType<DropDownMenuContainerProps<void>>, () => React.ComponentType<DropDownMenuContainerProps<void>>[], "one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuContainerProps<void>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuContainerProps<void>>>[]> & {
+    readonly __abstract?: never;
+};
+/** The specific token `.for(kind)` yields: at most one container for a menu kind, typed by it. */
+export type DropDownMenuContainerTokenFor<TData> = SpecificInjectionToken2<{
+    singleFactory: DropDownMenuContainerComponent<TData>;
+    maybeFactory: MaybeResultFactory<DropDownMenuContainerComponent<TData>>;
+    specificTokenFactory: undefined;
+    cardinality: "zero-or-one";
+}>;
+/**
+ * The `.for()` factory, annotated so a kind's own data type survives into the specific token. The
+ * annotation carries what the retired third type parameter used to: inference from the value alone
+ * cannot reconstruct a return type that mentions the specifier's own type parameter.
+ */
+declare const dropDownMenuContainerComponentTokenFor: <K extends DropDownMenuKind<any>>(kind: K) => DropDownMenuContainerTokenFor<DropDownMenuData<K>>;
+/**
+ * The element a menu of some kind renders as. Without one, a menu is a list — which is what a menu
+ * of ordinary items should be. Contribute one when the items are not a list: a grid of icons, say,
+ * or a panel that happens to open like a menu.
+ *
+ * @example
+ * ```tsx
+ * // Items typed by the kind, for a container that lays them out itself.
+ * const IconGrid = ({ items = [], ...menuProps }: DropDownMenuContainerProps) => (
+ *   <Div {...menuProps} $grid={{ columns: 3 }}>
+ *     {items.map((item) => (
+ *       <item.Component key={item.id} data={undefined} />
+ *     ))}
+ *   </Div>
+ * );
+ *
+ * export const iconGridContainerInjectable = getInjectable2({
+ *   id: "icon-grid-container",
+ *   instantiate: () => () => IconGrid,
+ *   injectionToken: dropDownMenuContainerComponentInjectionToken.for(iconsMenuKind),
+ * });
+ * ```
+ */
+export declare const dropDownMenuContainerComponentInjectionToken: import("@k8slens/injectable").InjectionToken2Base<DropDownMenuContainerComponent<any>, () => React.ComponentType<DropDownMenuContainerProps<any>> | undefined, "zero-or-one", () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuContainerProps<any>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<React.ComponentType<DropDownMenuContainerProps<any>>> | undefined> & {
+    readonly __abstract: true;
+    for: typeof dropDownMenuContainerComponentTokenFor;
+};
+export {};
+//# sourceMappingURL=drop-down-menu-container-component.d.ts.map

package/dist/src/drop-down-menu-container-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-down-menu-container-component.d.ts","sourceRoot":"","sources":["../../src/drop-down-menu-container-component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEhH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,CAAC,KAAK,GAAG,IAAI,IAAI;IACrD,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAEnC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;CACrD,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,MAAM,MAAM,8BAA8B,CAAC,KAAK,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC,aAAa,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC,CAAC;AAExH;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;CAIrC,CAAC;AAEL,kGAAkG;AAClG,MAAM,MAAM,6BAA6B,CAAC,KAAK,IAAI,uBAAuB,CAAC;IACzE,aAAa,EAAE,8BAA8B,CAAC,KAAK,CAAC,CAAC;IACrD,YAAY,EAAE,kBAAkB,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC,CAAC;IACxE,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,aAAa,CAAC;CAC5B,CAAC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,sCAAsC,GAAI,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,QACvE,CAAC,KACN,6BAA6B,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAQ9C,CAAC;AAEP;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,4CAA4C;;;CAMf,CAAC"}

package/dist/src/drop-down-menu-item.d.ts

@@ -0,0 +1,84 @@
+import { type NonEmptyManyFactory, type SpecificInjectionToken2 } from "@k8slens/injectable";
+import type { Identifiable, MaybeComputed, MaybeComputedShowable, Orderable } from "@k8slens/composable-responsibilities";
+import type { MaybePromise } from "@k8slens/public-utilities";
+import type React from "react";
+import type { DropDownMenuData, DropDownMenuKind } from "./drop-down-menu-kind";
+/**
+ * One item of a drop-down menu: a component, where it sits among the others, and whether it is
+ * shown at all. What the item looks like and what it does are its own business — a menu neither
+ * draws it nor decides anything about it.
+ *
+ * The component is given the data the host element opened the menu with, and must be defined at
+ * module scope; capturing data in a closure would create a new component reference on every
+ * invocation and break React reconciliation.
+ */
+export interface DropDownMenuItem<TData = void> extends Identifiable, Orderable, MaybeComputedShowable {
+    readonly Component: React.ComponentType<{
+        readonly data: TData;
+    }>;
+}
+/** Produces one item, possibly later. */
+export type DropDownMenuItemFactory<TData = any> = () => MaybePromise<DropDownMenuItem<TData>>;
+/**
+ * The specific token `.for(kind)` yields: the items contributed to one menu kind. At least one of
+ * them, so that a kind nobody contributes to is a composition error rather than a menu that never
+ * opens.
+ */
+export type DropDownMenuItemTokenFor<TData> = SpecificInjectionToken2<{
+    singleFactory: DropDownMenuItemFactory<TData>;
+    manyFactory: NonEmptyManyFactory<DropDownMenuItemFactory<TData>>;
+    specificTokenFactory: undefined;
+    cardinality: "one-or-many";
+}>;
+/**
+ * The `.for()` factory, annotated so a kind's own data type survives into the specific token. The
+ * annotation carries what the retired third type parameter used to: inference from the value alone
+ * cannot reconstruct a return type that mentions the specifier's own type parameter.
+ */
+declare const dropDownMenuItemTokenFor: <K extends DropDownMenuKind<any>>(kind: K) => DropDownMenuItemTokenFor<DropDownMenuData<K>>;
+/**
+ * The contribution surface of drop-down menus: one item per contribution, registered against a
+ * {@link DropDownMenuKind} via `.for(kind)`. Prefer {@link getDropDownMenuItemInjectableBunch}
+ * over registering by hand.
+ */
+export declare const dropDownMenuItemInjectionToken: import("@k8slens/injectable").InjectionToken2Base<DropDownMenuItemFactory<any>, () => MaybePromise<DropDownMenuItem<any>>[], "zero-or-many", () => import("@k8slens/injectable").InjectionInstanceWithMeta<MaybePromise<DropDownMenuItem<any>>>, () => import("@k8slens/injectable").InjectionInstanceWithMeta<MaybePromise<DropDownMenuItem<any>>>[]> & {
+    readonly __abstract: true;
+    for: typeof dropDownMenuItemTokenFor;
+};
+export interface DropDownMenuItemBunchParams<K extends DropDownMenuKind<any>> {
+    /** Unique id for the registered injectable; doubles as the item's id. */
+    readonly id: string;
+    /** The menu kind the item belongs to. */
+    readonly kind: K;
+    /** Lower comes first among the kind's items. */
+    readonly orderNumber: number;
+    /** Whether the item is shown at all; the menu reacts to this while open. */
+    readonly isVisible?: MaybeComputed<boolean>;
+    /** Renders the item. Receives the data the menu was opened with. */
+    readonly Component: React.ComponentType<{
+        readonly data: DropDownMenuData<K>;
+    }>;
+}
+/**
+ * Contribute one item to a drop-down menu kind.
+ *
+ * @example
+ * ```tsx
+ * const RestartPod = ({ data }: { data: { podName: string } }) => (
+ *   <ClickableLi $onClick={() => restart(data.podName)}>Restart {data.podName}</ClickableLi>
+ * );
+ *
+ * export const restartPodBunch = getDropDownMenuItemInjectableBunch({
+ *   id: "restart-pod",
+ *   kind: podActionsMenuKind,
+ *   orderNumber: 10,
+ *   isVisible: computed(() => canRestart.get()),
+ *   Component: RestartPod,
+ * });
+ * ```
+ */
+export declare const getDropDownMenuItemInjectableBunch: <K extends DropDownMenuKind<any>>(params: DropDownMenuItemBunchParams<K>) => {
+    dropDownMenuItem: import("@k8slens/injectable").Injectable2<() => DropDownMenuItem<DropDownMenuData<K>>>;
+};
+export {};
+//# sourceMappingURL=drop-down-menu-item.d.ts.map

package/dist/src/drop-down-menu-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-down-menu-item.d.ts","sourceRoot":"","sources":["../../src/drop-down-menu-item.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EACxB,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,SAAS,EACV,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEhF;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,IAAI,CAAE,SAAQ,YAAY,EAAE,SAAS,EAAE,qBAAqB;IACpG,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;KAAE,CAAC,CAAC;CACnE;AAED,yCAAyC;AACzC,MAAM,MAAM,uBAAuB,CAAC,KAAK,GAAG,GAAG,IAAI,MAAM,YAAY,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;AAE/F;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,CAAC,KAAK,IAAI,uBAAuB,CAAC;IACpE,aAAa,EAAE,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC9C,WAAW,EAAE,mBAAmB,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC;IACjE,oBAAoB,EAAE,SAAS,CAAC;IAChC,WAAW,EAAE,aAAa,CAAC;CAC5B,CAAC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,wBAAwB,GAAI,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,QACzD,CAAC,KACN,wBAAwB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAQzC,CAAC;AAEP;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;CAMf,CAAC;AAE7B,MAAM,WAAW,2BAA2B,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC;IAC1E,yEAAyE;IACzE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC5C,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC,CAAC;CACjF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kCAAkC,GAAI,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,UACxE,2BAA2B,CAAC,CAAC,CAAC;sEAMX,gBAAgB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;CAS9D,CAAC"}