@enigmax/primitives 0.24.0 → 0.26.0

package/dist/{color-OPV3BJV6.js → color-T63FLJNH.js}

@@ -1,7 +1,7 @@
 import { parseColor, rgbToHsv, colorEquals, hsvToRgb, formatColor, toHex } from './chunk-S2FPN5ID.js';
-import { writeValue } from './chunk-S7EE57YB.js';
+import { writeValue, ColorSwatch } from './chunk-KVLSOQTI.js';
 import { useLayoutEffect, useRef, useState, useMemo, useEffect, useCallback } from 'react';
-import { jsxs, jsx } from 'react/jsx-runtime';
+import { jsx, jsxs } from 'react/jsx-runtime';
 
 // src/react/input/color-styles.ts
 var COLOR_STYLES = `
@@ -133,6 +133,26 @@ var COLOR_STYLES = `
 [data-enigma-color-eyedropper]:hover { color: var(--enigma-color-text); }
 [data-enigma-color-eyedropper]:focus-visible { outline: 2px solid var(--enigma-color-focus); outline-offset: 2px; }
 
+/* The value as text, with the notation beside it. Monospace on purpose: a hex whose digits
+   shift width as you drag is a value nobody can read at a glance. */
+[data-enigma-color-value] { display: flex; align-items: center; gap: 0.375rem; }
+[data-enigma-color-format] {
+    flex: none; padding: 0.3125rem 0.375rem;
+    font: inherit; font-size: 0.625rem; line-height: 1; letter-spacing: 0.06em;
+    color: var(--enigma-color-muted); background: none;
+    border: 1px solid var(--enigma-color-border); border-radius: 0.25rem; cursor: pointer;
+}
+[data-enigma-color-format]:hover { color: var(--enigma-color-text); }
+[data-enigma-color-input] {
+    flex: 1; min-width: 0; padding: 0.25rem 0.375rem;
+    font: inherit; font-family: var(--enigma-color-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
+    font-size: 0.75rem; line-height: 1.4;
+    color: var(--enigma-color-text); background: none;
+    border: 1px solid var(--enigma-color-border); border-radius: 0.25rem;
+}
+[data-enigma-color-format]:focus-visible,
+[data-enigma-color-input]:focus-visible { outline: 2px solid var(--enigma-color-focus); outline-offset: 1px; }
+
 [data-enigma-color-swatches] { display: flex; flex-wrap: wrap; gap: 0.25rem; }
 [data-enigma-color-preset] {
     width: 1.125rem; height: 1.125rem; padding: 0;
@@ -144,6 +164,8 @@ var COLOR_STYLES = `
 var INITIAL = { h: 0, s: 0, v: 0, a: 1 };
 var STEP = { fine: 0.01, coarse: 0.1, hue: 1, hueCoarse: 10 };
 var MARGIN = 12;
+var FORMATS = ["hex", "rgb", "hsl"];
+var FORMAT_LABELS = { hex: "HEX", rgb: "RGB", hsl: "HSL" };
 var injected = false;
 function injectStyles() {
   if (injected || typeof document === "undefined") return;
@@ -167,6 +189,7 @@ function ColorExtras({
   placement = "auto",
   styles = true,
   locked = false,
+  openOnMount = false,
   labels
 }) {
   useLayoutEffect(() => {
@@ -176,7 +199,7 @@ function ColorExtras({
   const panelRef = useRef(null);
   const swatchRef = useRef(null);
   const areaRef = useRef(null);
-  const [open, setOpen] = useState(false);
+  const [open, setOpen] = useState(openOnMount && !locked);
   const [side, setSide] = useState(placement === "top" ? "top" : "bottom");
   const parsed = useMemo(() => parseColor(value), [value]);
   const [hsv, setHsv] = useState(() => parsed ? rgbToHsv(parsed) : INITIAL);
@@ -305,138 +328,178 @@ function ColorExtras({
     } catch {
     }
   }, [commit, hsv]);
+  const [shown, setShown] = useState(format);
+  useEffect(() => setShown(format), [format]);
+  const [draft, setDraft] = useState(null);
+  const readout = useMemo(() => formatColor(rgb, shown, { alpha }), [rgb, shown, alpha]);
+  const nextFormat = FORMATS[(FORMATS.indexOf(shown) + 1) % FORMATS.length];
+  const typed = useCallback((next) => {
+    setDraft(next);
+    const colour = parseColor(next);
+    if (colour) commit(rgbToHsv(alpha ? colour : { ...colour, a: 1 }, hsv.h));
+  }, [commit, alpha, hsv.h]);
   const css = useMemo(() => formatColor(rgb, "hex", { alpha: true }), [rgb]);
   const opaque = useMemo(() => toHex({ ...rgb, a: 1 }), [rgb]);
   const text = labels ?? {};
   const valueText = `${text.color ?? "Colour"} ${css}`;
   const panelStyle = { "--enigma-color-hue": Math.round(hsv.h), "--enigma-color-opaque": opaque };
-  return /* @__PURE__ */ jsxs("span", { ref: anchorRef, "data-enigma-color": "", "data-open": open ? "" : void 0, children: [
-    /* @__PURE__ */ jsx(
-      "button",
-      {
-        ref: swatchRef,
-        type: "button",
-        "data-enigma-color-swatch": "",
-        "data-enigma-color-checkers": "",
-        "data-invalid": parsed ? void 0 : "",
-        "aria-haspopup": "dialog",
-        "aria-expanded": open,
-        "aria-label": text.open ?? "Pick a colour",
-        title: text.open ?? "Pick a colour",
-        disabled: locked,
-        onClick: () => open ? close(true) : setOpenState(true),
-        children: /* @__PURE__ */ jsx("span", { "data-enigma-color-fill": "", style: { background: parsed ? css : void 0 } })
-      }
-    ),
-    open && !locked && /* @__PURE__ */ jsxs(
-      "div",
-      {
-        ref: panelRef,
-        "data-enigma-color-panel": "",
-        "data-side": side,
-        role: "dialog",
-        "aria-label": text.panel ?? "Colour picker",
-        style: panelStyle,
-        onKeyDown: (event) => {
-          if (event.key !== "Escape") return;
-          event.stopPropagation();
-          close(true);
-        },
-        children: [
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              ref: areaRef,
-              "data-enigma-color-area": "",
-              role: "slider",
-              tabIndex: 0,
-              "aria-label": text.area ?? "Saturation and brightness",
-              "aria-valuemin": 0,
-              "aria-valuemax": 100,
-              "aria-valuenow": Math.round(hsv.s * 100),
-              "aria-valuetext": `${Math.round(hsv.s * 100)}% saturation, ${Math.round(hsv.v * 100)}% brightness, ${valueText}`,
-              onKeyDown: areaKeys,
-              onPointerDown: (event) => track(event, (x, y) => commit({ ...hsv, s: x, v: 1 - y })),
-              children: /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.s * 100}%`, top: `${(1 - hsv.v) * 100}%` } })
-            }
-          ),
-          /* @__PURE__ */ jsxs("div", { "data-enigma-color-controls": "", children: [
-            /* @__PURE__ */ jsx("span", { "data-enigma-color-preview": "", "data-enigma-color-checkers": "", children: /* @__PURE__ */ jsx("span", { "data-enigma-color-fill": "", style: { background: css } }) }),
-            dropper && /* @__PURE__ */ jsx(
-              "button",
+  return /* @__PURE__ */ jsx(
+    ColorSwatch,
+    {
+      anchorRef,
+      buttonRef: swatchRef,
+      value: css,
+      invalid: !parsed,
+      open,
+      locked,
+      label: text.open ?? "Pick a colour",
+      onPress: () => open ? close(true) : setOpenState(true),
+      children: open && !locked && /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref: panelRef,
+          "data-enigma-color-panel": "",
+          "data-side": side,
+          role: "dialog",
+          "aria-label": text.panel ?? "Colour picker",
+          style: panelStyle,
+          onKeyDown: (event) => {
+            if (event.key !== "Escape") return;
+            event.stopPropagation();
+            close(true);
+          },
+          children: [
+            /* @__PURE__ */ jsx(
+              "div",
               {
-                type: "button",
-                "data-enigma-color-eyedropper": "",
-                "aria-label": text.eyedropper ?? "Pick a colour from the screen",
-                title: text.eyedropper ?? "Pick a colour from the screen",
-                onClick: () => {
-                  void pick();
-                },
-                children: /* @__PURE__ */ jsx(EyedropperIcon, {})
+                ref: areaRef,
+                "data-enigma-color-area": "",
+                role: "slider",
+                tabIndex: 0,
+                "aria-label": text.area ?? "Saturation and brightness",
+                "aria-valuemin": 0,
+                "aria-valuemax": 100,
+                "aria-valuenow": Math.round(hsv.s * 100),
+                "aria-valuetext": `${Math.round(hsv.s * 100)}% saturation, ${Math.round(hsv.v * 100)}% brightness, ${valueText}`,
+                onKeyDown: areaKeys,
+                onPointerDown: (event) => track(event, (x, y) => commit({ ...hsv, s: x, v: 1 - y })),
+                children: /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.s * 100}%`, top: `${(1 - hsv.v) * 100}%` } })
               }
             ),
-            /* @__PURE__ */ jsxs("div", { "data-enigma-color-rails": "", children: [
+            /* @__PURE__ */ jsxs("div", { "data-enigma-color-controls": "", children: [
+              /* @__PURE__ */ jsx("span", { "data-enigma-color-preview": "", "data-enigma-color-checkers": "", children: /* @__PURE__ */ jsx("span", { "data-enigma-color-fill": "", style: { background: css } }) }),
+              dropper && /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  "data-enigma-color-eyedropper": "",
+                  "aria-label": text.eyedropper ?? "Pick a colour from the screen",
+                  title: text.eyedropper ?? "Pick a colour from the screen",
+                  onClick: () => {
+                    void pick();
+                  },
+                  children: /* @__PURE__ */ jsx(EyedropperIcon, {})
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { "data-enigma-color-rails": "", children: [
+                /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    "data-enigma-color-rail": "hue",
+                    role: "slider",
+                    tabIndex: 0,
+                    "aria-label": text.hue ?? "Hue",
+                    "aria-valuemin": 0,
+                    "aria-valuemax": 360,
+                    "aria-valuenow": Math.round(hsv.h),
+                    "aria-valuetext": `${Math.round(hsv.h)} degrees`,
+                    onKeyDown: (event) => railKeys(event, "hue"),
+                    onPointerDown: (event) => track(event, (x) => commit({ ...hsv, h: x * 360 })),
+                    children: /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.h / 360 * 100}%` } })
+                  }
+                ),
+                alpha && /* @__PURE__ */ jsxs(
+                  "div",
+                  {
+                    "data-enigma-color-rail": "alpha",
+                    "data-enigma-color-checkers": "",
+                    role: "slider",
+                    tabIndex: 0,
+                    "aria-label": text.alpha ?? "Opacity",
+                    "aria-valuemin": 0,
+                    "aria-valuemax": 100,
+                    "aria-valuenow": Math.round(hsv.a * 100),
+                    "aria-valuetext": `${Math.round(hsv.a * 100)}% opacity`,
+                    onKeyDown: (event) => railKeys(event, "alpha"),
+                    onPointerDown: (event) => track(event, (x) => commit({ ...hsv, a: x })),
+                    children: [
+                      /* @__PURE__ */ jsx("span", { "data-enigma-color-gradient": "" }),
+                      /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.a * 100}%` } })
+                    ]
+                  }
+                )
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { "data-enigma-color-value": "", children: [
               /* @__PURE__ */ jsx(
-                "div",
+                "button",
                 {
-                  "data-enigma-color-rail": "hue",
-                  role: "slider",
-                  tabIndex: 0,
-                  "aria-label": text.hue ?? "Hue",
-                  "aria-valuemin": 0,
-                  "aria-valuemax": 360,
-                  "aria-valuenow": Math.round(hsv.h),
-                  "aria-valuetext": `${Math.round(hsv.h)} degrees`,
-                  onKeyDown: (event) => railKeys(event, "hue"),
-                  onPointerDown: (event) => track(event, (x) => commit({ ...hsv, h: x * 360 })),
-                  children: /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.h / 360 * 100}%` } })
+                  type: "button",
+                  "data-enigma-color-format": "",
+                  "aria-label": `${text.formatAs ?? "Show as"} ${FORMAT_LABELS[nextFormat]}`,
+                  title: `${text.formatAs ?? "Show as"} ${FORMAT_LABELS[nextFormat]}`,
+                  onClick: () => {
+                    setShown(nextFormat);
+                    setDraft(null);
+                  },
+                  children: FORMAT_LABELS[shown]
                 }
               ),
-              alpha && /* @__PURE__ */ jsxs(
-                "div",
+              /* @__PURE__ */ jsx(
+                "input",
                 {
-                  "data-enigma-color-rail": "alpha",
-                  "data-enigma-color-checkers": "",
-                  role: "slider",
-                  tabIndex: 0,
-                  "aria-label": text.alpha ?? "Opacity",
-                  "aria-valuemin": 0,
-                  "aria-valuemax": 100,
-                  "aria-valuenow": Math.round(hsv.a * 100),
-                  "aria-valuetext": `${Math.round(hsv.a * 100)}% opacity`,
-                  onKeyDown: (event) => railKeys(event, "alpha"),
-                  onPointerDown: (event) => track(event, (x) => commit({ ...hsv, a: x })),
-                  children: [
-                    /* @__PURE__ */ jsx("span", { "data-enigma-color-gradient": "" }),
-                    /* @__PURE__ */ jsx("span", { "data-enigma-color-thumb": "", style: { left: `${hsv.a * 100}%` } })
-                  ]
+                  type: "text",
+                  "data-enigma-color-input": "",
+                  value: draft ?? readout,
+                  "aria-label": text.value ?? "Colour value",
+                  spellCheck: false,
+                  autoComplete: "off",
+                  autoCorrect: "off",
+                  autoCapitalize: "off",
+                  onChange: (event) => typed(event.target.value),
+                  onBlur: () => setDraft(null),
+                  onKeyDown: (event) => {
+                    if (event.key !== "Enter") return;
+                    event.preventDefault();
+                    setDraft(null);
+                  }
                 }
               )
-            ] })
-          ] }),
-          swatches && swatches.length > 0 && /* @__PURE__ */ jsx("div", { "data-enigma-color-swatches": "", role: "group", "aria-label": text.swatches ?? "Preset colours", children: swatches.map((preset) => {
-            const colour = parseColor(preset);
-            return /* @__PURE__ */ jsx(
-              "button",
-              {
-                type: "button",
-                "data-enigma-color-preset": "",
-                "data-enigma-color-checkers": "",
-                style: { background: preset },
-                "aria-label": preset,
-                title: preset,
-                "aria-pressed": colourEqualsPreset(colour, css),
-                onClick: () => {
-                  if (colour) commit(rgbToHsv(alpha ? colour : { ...colour, a: 1 }, hsv.h));
-                }
-              },
-              preset
-            );
-          }) })
-        ]
-      }
-    )
-  ] });
+            ] }),
+            swatches && swatches.length > 0 && /* @__PURE__ */ jsx("div", { "data-enigma-color-swatches": "", role: "group", "aria-label": text.swatches ?? "Preset colours", children: swatches.map((preset) => {
+              const colour = parseColor(preset);
+              return /* @__PURE__ */ jsx(
+                "button",
+                {
+                  type: "button",
+                  "data-enigma-color-preset": "",
+                  "data-enigma-color-checkers": "",
+                  style: { background: preset },
+                  "aria-label": preset,
+                  title: preset,
+                  "aria-pressed": colourEqualsPreset(colour, css),
+                  onClick: () => {
+                    if (colour) commit(rgbToHsv(alpha ? colour : { ...colour, a: 1 }, hsv.h));
+                  }
+                },
+                preset
+              );
+            }) })
+          ]
+        }
+      )
+    }
+  );
 }
 function colourEqualsPreset(preset, current) {
   return colorEquals(preset, parseColor(current));

package/dist/context-BfjYGPnH.d.ts

@@ -0,0 +1,54 @@
+import { ReactNode, RefObject } from 'react';
+import { a as ContextMenuAction, b as ContextMenuEntry, c as ContextMenuInstance, j as ContextMenuState, h as ContextMenuPoint } from './context-menu-D3FtTn7v.js';
+
+/**
+ * One row, as React draws it. The core carries `icon` as `unknown` because it cannot know
+ * what a node is; here it is one.
+ */
+interface ContextMenuItem extends Omit<ContextMenuAction, "icon" | "items"> {
+    icon?: ReactNode;
+    items?: readonly ContextMenuNode[];
+}
+/** Anything that can appear in a menu, with React's icon type. */
+type ContextMenuNode = ContextMenuItem | Exclude<ContextMenuEntry, ContextMenuAction>;
+interface ContextMenuContextValue {
+    instance: ContextMenuInstance;
+    state: ContextMenuState;
+    /**
+     * Open at a point, over what the press landed on. False when there was nothing to show,
+     * so the press is left alone.
+     *
+     * `target` is what the clipboard rows are built from - the field or the selection under
+     * the pointer - and a caller that leaves it out gets a menu with none of them, which is
+     * the right answer for a menu opened from somewhere that is not a press.
+     */
+    open: (point: ContextMenuPoint, target?: EventTarget | null) => boolean;
+    close: () => void;
+    /** ids the parts need to point at each other. */
+    ids: {
+        trigger: string;
+    };
+    panelId: (level: number) => string;
+    itemId: (level: number, index: number) => string;
+    triggerRef: RefObject<HTMLElement | null>;
+    /** Which panel the keyboard is in. Always the deepest open one. */
+    onMenuKeyDown: (event: React.KeyboardEvent) => void;
+    /** How long the pointer must rest on a row before its submenu opens, and before one closes. */
+    delays: {
+        open: number;
+        close: number;
+    };
+    /** Drop the pending close, wherever it was scheduled. Called wherever the pointer lands. */
+    cancelClose: () => void;
+    /** Close everything below `level`, after the beat - replacing any close already waiting. */
+    scheduleClose: (level: number) => void;
+    /** Draw a row instead of the default icon / label / shortcut. */
+    renderItem?: (item: ContextMenuItem, level: number, index: number) => ReactNode;
+    /** Shown while a fetched submenu has not answered. */
+    loadingLabel: ReactNode;
+    /** Shown when a filter matched nothing, or a fetched submenu came back with nothing. */
+    emptyLabel: ReactNode;
+}
+declare function useContextMenuContext(part: string): ContextMenuContextValue;
+
+export { type ContextMenuContextValue as C, type ContextMenuItem as a, type ContextMenuNode as b, useContextMenuContext as u };

package/dist/{clipboard-menu-B_ouitfS.d.ts → context-menu-D3FtTn7v.d.ts}

@@ -171,94 +171,4 @@ interface ContextMenuInstance {
 type ContextMenuMoveKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "PageDown" | "PageUp";
 declare function createContextMenu(options?: ContextMenuOptions): ContextMenuInstance;
 
-/**
- * The rows every context menu on a desktop already has: Copy, Cut and Paste.
- *
- * A menu opened over a selection or over a field is expected to offer them - the browser's own
- * does, and replacing that menu with a custom one takes them away without saying so. Which is
- * why they are ON by default here and turned off with a prop, rather than the other way round:
- * the defect is silent, so the default has to be the safe one.
- *
- * WHAT DECIDES THEY APPEAR is what was right-clicked, and it is read at the moment the menu
- * opens, not from React state - by then the selection is settled (a `contextmenu` event fires
- * after the press has adjusted it) and the caret is still where the visitor left it.
- *
- * - **Copy**, when there is selected text under the pointer.
- * - **Cut**, when that selection is also in something writable.
- * - **Paste**, in anything writable - and disabled when the clipboard is known to be empty.
- *
- * Not a React module: what a selection is, whether a field takes writes, and how text is put
- * back into one are DOM questions, so a menu drawn by anything else gets the same rows.
- */
-
-/** The ids these rows carry. Namespaced, so they can never collide with a caller's own. */
-declare const CLIPBOARD_PREFIX = "enigma:clipboard:";
-type ClipboardAction = "copy" | "cut" | "paste";
-/** What the menu was opened over, as far as the clipboard is concerned. */
-interface ClipboardTarget {
-    /** The field or contenteditable under the pointer, or null when it is neither. */
-    editable: HTMLElement | null;
-    /** Whether that element takes writes: not disabled, not read-only. */
-    writable: boolean;
-    /** The selected text, from the field's own selection or the document's. */
-    selection: string;
-    /**
-     * Whether that text may be put on the clipboard.
-     *
-     * False for a password field. The clipboard is shared with every other application on the
-     * machine and is not cleared, so a menu that copies a password out of a masked field
-     * leaks it somewhere the visitor cannot see - and the browser's own menu refuses too.
-     */
-    copyable: boolean;
-    /** Where the selection was, so it can be put back after the menu has taken focus. */
-    range: {
-        start: number;
-        end: number;
-    } | null;
-}
-interface ClipboardMenuLabels {
-    copy?: string;
-    cut?: string;
-    paste?: string;
-}
-interface ClipboardMenuOptions {
-    copy?: boolean;
-    cut?: boolean;
-    paste?: boolean;
-    labels?: ClipboardMenuLabels;
-    /** Whatever the renderer draws icons with. `unknown`, because a core cannot know. */
-    icons?: {
-        copy?: unknown;
-        cut?: unknown;
-        paste?: unknown;
-    };
-    /** The clipboard is known to be empty, so Paste is listed and greyed rather than missing. */
-    clipboardEmpty?: boolean;
-}
-/** What was right-clicked, read the moment the menu opens. */
-declare function inspectClipboardTarget(node: EventTarget | null): ClipboardTarget;
-/**
- * Whether the clipboard has text in it, or null when that cannot be known.
- *
- * Null is the common answer and not a failure: reading the clipboard needs permission, and
- * asking for it puts a browser prompt on screen just to decide whether to grey out a row -
- * which is a worse trade than showing an enabled Paste that turns out to do nothing. So the
- * permission is only READ, never requested, and the clipboard is only opened where it has
- * already been granted.
- */
-declare function clipboardHasText(): Promise<boolean | null>;
-/** The rows for this target, in the order every desktop menu puts them. */
-declare function clipboardEntries(target: ClipboardTarget, options?: ClipboardMenuOptions): ContextMenuEntry[];
-/** Which clipboard row an id belongs to, or null for anything that is not one of ours. */
-declare function clipboardAction(id: string): ClipboardAction | null;
-/**
- * Do what the row says.
- *
- * Called straight from the press that chose it, so the browser still counts it as a user
- * gesture - which is what the clipboard API requires and what makes a paste possible at all.
- * Returns whether the action happened: a refused permission and an empty clipboard are both
- * "no", and neither is worth an exception the caller has to catch.
- */
-declare function performClipboardAction(action: ClipboardAction, target: ClipboardTarget): Promise<boolean>;
-
-export { CLIPBOARD_PREFIX as C, CONTEXT_MENU_SEARCH_KEYS as a, type ClipboardAction as b, type ClipboardMenuLabels as c, type ClipboardMenuOptions as d, type ClipboardTarget as e, type ContextMenuAction as f, type ContextMenuEntry as g, type ContextMenuInstance as h, type ContextMenuLabel as i, type ContextMenuLevel as j, type ContextMenuMoveKey as k, type ContextMenuOptions as l, type ContextMenuPoint as m, type ContextMenuSeparator as n, type ContextMenuState as o, clipboardAction as p, clipboardEntries as q, clipboardHasText as r, createContextMenu as s, inspectClipboardTarget as t, isAction as u, performClipboardAction as v };
+export { CONTEXT_MENU_SEARCH_KEYS as C, type ContextMenuAction as a, type ContextMenuEntry as b, type ContextMenuInstance as c, type ContextMenuLabel as d, type ContextMenuLevel as e, type ContextMenuMoveKey as f, type ContextMenuOptions as g, type ContextMenuPoint as h, type ContextMenuSeparator as i, type ContextMenuState as j, createContextMenu as k, isAction as l };

package/dist/{index-ZPvlf9vs.d.ts → index-qXOkYQCU.d.ts}

@@ -145,6 +145,10 @@ interface ColorLabels {
     alpha?: string;
     eyedropper?: string;
     swatches?: string;
+    /** The editable readout under the rails. Default "Colour value". */
+    value?: string;
+    /** The button that cycles the readout between HEX, RGB and HSL. Default "Show as". */
+    formatAs?: string;
     /** The word before the colour in what a screen reader announces. Default "Colour". */
     color?: string;
 }