@celestia-island/hikari 0.55.113 → 0.55.115

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.113",
+  "version": "0.55.115",
   "private": false,
   "type": "module",
   "description": "Hikari Vue 3 component library — production-grade UI components based on shittim-chest design system",

package/src/components/HkBadge.scss

@@ -27,6 +27,11 @@
   color: var(--hk-badge-text);
   line-height: 1.4;
   white-space: nowrap;
+  /* Tags are labels, not prose: dragging across a row of pills must never
+     start a text selection (the workspace tag contract makes HkCopyBadge
+     the copy path instead). */
+  user-select: none;
+  -webkit-user-select: none;
 }
 
 /* ---------- size ---------- */

package/src/components/HkCopyBadge.scss

@@ -0,0 +1,20 @@
+/*
+ * HkCopyBadge — the interactive tag face. The badge itself stays pure;
+ * this sheet only adds the interactivity contract: pointer cursor and a
+ * pressed/keyboard-focus affordance that keeps the HkBadge geometry.
+ * (Text selection is banned on every badge at the `.hk-badge` base —
+ * tags are labels, not prose.)
+ */
+
+.hk-badge.hk-copy-badge {
+  cursor: pointer;
+
+  &:active {
+    filter: brightness(0.92);
+  }
+
+  &:focus-visible {
+    outline: 2px solid rgb(var(--color-primary) / 60%);
+    outline-offset: 1px;
+  }
+}

package/src/components/HkCopyBadge.test.tsx

@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createApp, h, defineComponent } from "vue";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import HkCopyBadge from "./HkCopyBadge";
+import { useToast } from "../runtime/useToast";
+
+const mounts: Array<{ app: ReturnType<typeof createApp>; container: HTMLElement }> = [];
+
+function mount(renderNode: () => ReturnType<typeof h>) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const app = createApp({ render: renderNode });
+  app.mount(container);
+  mounts.push({ app, container });
+  return container;
+}
+
+afterEach(() => {
+  for (const { app, container } of mounts.splice(0)) {
+    app.unmount();
+    container.remove();
+  }
+  useToast().toasts.splice(0);
+});
+
+// `navigator.clipboard` does not exist under happy-dom — install a
+// controllable stub and restore whatever was there before.
+let writeText: ReturnType<typeof vi.fn>;
+const originalClipboard = navigator.clipboard;
+
+beforeEach(() => {
+  writeText = vi.fn().mockResolvedValue(undefined);
+  Object.defineProperty(navigator, "clipboard", {
+    value: { writeText },
+    configurable: true,
+  });
+});
+
+afterEach(() => {
+  Object.defineProperty(navigator, "clipboard", {
+    value: originalClipboard,
+    configurable: true,
+  });
+});
+
+describe("HkCopyBadge", () => {
+  it("renders a HkBadge inside the tooltip wrapper with button semantics", () => {
+    const c = mount(() => h(HkCopyBadge, { variant: "muted", mono: true }, () => "#d.132"));
+    // The badge keeps its HkBadge identity (variant class, mono flag)…
+    const badge = c.querySelector(".hk-badge");
+    expect(badge).not.toBeNull();
+    expect(badge!.classList.contains("hk-badge-muted")).toBe(true);
+    expect(badge!.hasAttribute("data-mono")).toBe(true);
+    expect(badge!.textContent).toBe("#d.132");
+    // …wrapped by the house tooltip, with button semantics on the badge.
+    expect(c.querySelector(".hk-tooltip-wrapper")).not.toBeNull();
+    expect(badge!.getAttribute("role")).toBe("button");
+    expect(badge!.getAttribute("tabindex")).toBe("0");
+    expect(badge!.classList.contains("hk-copy-badge")).toBe(true);
+  });
+
+  it("copies the rendered text on click and toasts the localized default", async () => {
+    const c = mount(() => h(HkCopyBadge, null, () => "#demiurge.132"));
+    (c.querySelector(".hk-badge") as HTMLElement).click();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(writeText).toHaveBeenCalledWith("#demiurge.132");
+    const success = useToast().toasts.find((t) => t.type === "success");
+    expect(success?.messages.some((m) => m.text === "Copied")).toBe(true);
+  });
+
+  it("prefers the value prop over the rendered label as the copy payload", async () => {
+    const c = mount(() =>
+      h(HkCopyBadge, { value: "demiurge.132" }, () => "#d.132"),
+    );
+    (c.querySelector(".hk-badge") as HTMLElement).click();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(writeText).toHaveBeenCalledWith("demiurge.132");
+    expect(writeText).not.toHaveBeenCalledWith("#d.132");
+  });
+
+  it("stops the click from reaching clickable ancestors", async () => {
+    const rowClick = vi.fn();
+    const Row = defineComponent({
+      setup() {
+        return () =>
+          h("div", { onClick: rowClick }, h(HkCopyBadge, null, () => "#d.132"));
+      },
+    });
+    const c = mount(() => h(Row));
+    (c.querySelector(".hk-badge") as HTMLElement).click();
+    await Promise.resolve();
+
+    expect(writeText).toHaveBeenCalled();
+    expect(rowClick).not.toHaveBeenCalled();
+  });
+
+  it("activates on Enter and Space but not other keys", async () => {
+    const c = mount(() => h(HkCopyBadge, null, () => "x"));
+    const badge = c.querySelector(".hk-badge") as HTMLElement;
+
+    badge.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+    await Promise.resolve();
+    badge.dispatchEvent(new KeyboardEvent("keydown", { key: " ", bubbles: true }));
+    await Promise.resolve();
+    expect(writeText).toHaveBeenCalledTimes(2);
+
+    badge.dispatchEvent(new KeyboardEvent("keydown", { key: "a", bubbles: true }));
+    await Promise.resolve();
+    expect(writeText).toHaveBeenCalledTimes(2);
+  });
+
+  it("swaps the click behavior when `action` is set", async () => {
+    const action = vi.fn();
+    const c = mount(() => h(HkCopyBadge, { action, tooltip: "Open details" }, () => "#d.132"));
+    (c.querySelector(".hk-badge") as HTMLElement).click();
+    await Promise.resolve();
+
+    expect(action).toHaveBeenCalledTimes(1);
+    expect(writeText).not.toHaveBeenCalled();
+  });
+
+  it("renders the custom tooltip text", () => {
+    const c = mount(() => h(HkCopyBadge, { tooltip: "Open details" }, () => "#d.132"));
+    const content = c.parentElement!.querySelector(".hk-tooltip-popup .hk-tooltip-content");
+    expect(content?.textContent).toBe("Open details");
+  });
+
+  it("shows the localized click-to-copy tooltip by default", () => {
+    const c = mount(() => h(HkCopyBadge, null, () => "#d.132"));
+    const content = c.parentElement!.querySelector(".hk-tooltip-popup .hk-tooltip-content");
+    expect(content?.textContent).toBe("Click to copy");
+  });
+
+  it("renders the inert badge face when disabled", () => {
+    const c = mount(() => h(HkCopyBadge, { disabled: true }, () => "#d.132"));
+    const badge = c.querySelector(".hk-badge")!;
+    expect(badge.getAttribute("role")).toBeNull();
+    expect(badge.getAttribute("tabindex")).toBeNull();
+    expect(badge.classList.contains("hk-copy-badge")).toBe(false);
+    // No tooltip wrapper at all.
+    expect(c.querySelector(".hk-tooltip-wrapper")).toBeNull();
+  });
+
+  it("keeps the workspace tag contract: no badge text selection, ever", () => {
+    // Source contract on the HkBadge base sheet — every tag in every host
+    // inherits the no-selection rule, copyable or not.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const scss = readFileSync(join(here, "HkBadge.scss"), "utf-8");
+    expect(scss).toMatch(/user-select:\s*none/);
+  });
+
+  it("lands consumer class on the badge element, not the tooltip wrapper", () => {
+    const c = mount(() => h(HkCopyBadge, { class: "s-kanban-card-tag" }, () => "#tag"));
+    const badge = c.querySelector(".hk-badge")!;
+    expect(badge.classList.contains("s-kanban-card-tag")).toBe(true);
+    expect(badge.classList.contains("hk-copy-badge")).toBe(true);
+    const wrapper = c.querySelector(".hk-tooltip-wrapper")!;
+    expect(wrapper.classList.contains("s-kanban-card-tag")).toBe(false);
+  });
+
+  it("keeps consumer class when disabled", () => {
+    const c = mount(() => h(HkCopyBadge, { disabled: true, class: "x-pill" }, () => "#tag"));
+    expect(c.querySelector(".hk-badge")!.classList.contains("x-pill")).toBe(true);
+  });
+});

package/src/components/HkCopyBadge.tsx

@@ -0,0 +1,140 @@
+import { computed, defineComponent, ref, type PropType } from "vue";
+
+import HBadge, { type BadgeVariant } from "./HkBadge";
+import HTooltip from "./HkTooltip";
+import { useI18n } from "../i18n/context";
+import { useClipboardWithToast } from "../runtime/useClipboard";
+import { useToast } from "../runtime/useToast";
+import "./HkCopyBadge.scss";
+
+/**
+ * HkCopyBadge — the house standard for interactive TAGS: a HkBadge that
+ * never selects text and instead copies on click.
+ *
+ * The workspace-wide tag contract (user direction 2026-10-05) is that a
+ * label pill is not prose: text selection is always off (that half lives
+ * on `.hk-badge` itself), hover shows a "click to copy" tooltip, and a
+ * click runs the shared clipboard-with-toast path so every host confirms
+ * with the same localized toast. Rendered content is the default copy
+ * payload; pass `value` when the meaningful string differs from the
+ * label (a `#short` display id backed by a longer id, say).
+ *
+ * `action` swaps the click behavior outright (open a panel, jump …).
+ * That is only legitimate when the tooltip no longer claims "copy" —
+ * pass `tooltip` alongside, or the component warns in dev. `disabled`
+ * drops the interactivity entirely (no tooltip, no pointer cursor, no
+ * button semantics) and renders the plain badge face.
+ *
+ * A11y: the tag is a real button (role, tab order, Enter/Space), and the
+ * click is stopped from reaching clickable ancestors — a tag inside a
+ * selectable row copies without selecting the row. Consumer attrs
+ * (class/style/data-*) land on the badge element itself, so a call site
+ * skinning the pill keeps working; the tooltip wrapper stays clean.
+ */
+export default defineComponent({
+  name: "HkCopyBadge",
+  inheritAttrs: false,
+  props: {
+    /** What a click copies. Default: the rendered text content. */
+    value: { type: String, default: undefined },
+    /** Tooltip text. Default: the localized "click to copy". */
+    tooltip: { type: String, default: undefined },
+    /** Swap the click behavior (must come with a custom `tooltip`). */
+    action: { type: Function as PropType<() => void>, default: undefined },
+    /** Render the inert badge face: no tooltip, no click, no cursor. */
+    disabled: { type: Boolean, default: false },
+    // ── HkBadge passthrough ──────────────────────────────────────────
+    variant: { type: String as PropType<BadgeVariant>, default: "default" },
+    dot: { type: Boolean, default: false },
+    size: { type: String as PropType<"sm" | "md">, default: "md" },
+    mono: { type: Boolean, default: false },
+    uppercase: { type: Boolean, default: false },
+    pill: { type: Boolean, default: true },
+    color: { type: String, default: undefined },
+    bgColor: { type: String, default: undefined },
+    borderColor: { type: String, default: undefined },
+  },
+  setup(props, { slots, attrs }) {
+    const { t } = useI18n();
+    const clipboard = useClipboardWithToast(useToast());
+
+    // The badge root: HkBadge renders a single span, so the instance's
+    // $el carries the rendered label — the default copy payload.
+    const badgeRef = ref<InstanceType<typeof HBadge> | null>(null);
+
+    const tooltipText = computed(() =>
+      props.tooltip ?? t("hikari::clipboard.clickToCopy", "Click to copy"),
+    );
+
+    if (import.meta.env?.DEV && props.action && !props.tooltip) {
+      console.warn(
+        "[HkCopyBadge] `action` replaces the copy behavior — pass `tooltip` " +
+        "so the hover hint stops claiming click-to-copy.",
+      );
+    }
+
+    function copyPayload(): string {
+      if (props.value !== undefined) return props.value;
+      const el = badgeRef.value?.$el as HTMLElement | undefined;
+      return el?.textContent?.trim() ?? "";
+    }
+
+    function activate() {
+      if (props.disabled) return;
+      if (props.action) {
+        props.action();
+        return;
+      }
+      const text = copyPayload();
+      if (!text) return;
+      void clipboard.copy(text);
+    }
+
+    return () => {
+      // Everything the call site put on HkCopyBadge belongs to the pill
+      // itself; only the interactive contract below is ours to add.
+      const { class: attrClass, style: attrStyle, ...restAttrs } = attrs;
+
+      const badge = (
+        <HBadge
+          ref={badgeRef}
+          {...restAttrs}
+          class={props.disabled ? attrClass : ["hk-copy-badge", attrClass]}
+          style={attrStyle}
+          variant={props.variant}
+          dot={props.dot}
+          size={props.size}
+          mono={props.mono}
+          uppercase={props.uppercase}
+          pill={props.pill}
+          color={props.color}
+          bgColor={props.bgColor}
+          borderColor={props.borderColor}
+          {...(props.disabled
+            ? {}
+            : {
+                role: "button",
+                tabindex: 0,
+                onClick: (e: MouseEvent) => {
+                  // A tag inside a clickable row/card copies itself
+                  // without triggering the row.
+                  e.stopPropagation();
+                  activate();
+                },
+                onKeydown: (e: KeyboardEvent) => {
+                  if (e.key !== "Enter" && e.key !== " ") return;
+                  e.preventDefault();
+                  e.stopPropagation();
+                  activate();
+                },
+              })}
+        >
+          {slots.default?.()}
+        </HBadge>
+      );
+
+      if (props.disabled) return badge;
+      return <HTooltip text={tooltipText.value}>{badge}</HTooltip>;
+    };
+  },
+});

package/src/components/HkModalBreadcrumb.test.tsx

@@ -640,7 +640,9 @@ describe("HkModalBreadcrumb overflow fold", () => {
     // The strip is teleported into the host's zoomed root: the header's
     // rect is VISUAL px while the inline top it writes is LOCAL px, so the
     // height is divided by the zoom. Forgetting the division drifts the
-    // strip (zoom − 1) · height / 2 down its window.
+    // strip (zoom − 1) · height / 2 down its window. The strip's OWN height
+    // rides the same conversion (clearance branch), so it is mocked here
+    // too: 88 visual px = 44 local at zoom 2.
     const app = document.createElement("div");
     app.id = "app";
     app.style.top = "10px";
@@ -665,21 +667,91 @@ describe("HkModalBreadcrumb overflow fold", () => {
     const rect = (height: number): DOMRect =>
       ({ x: 0, y: 0, width: 200, height, top: 0, left: 0, right: 200, bottom: height, toJSON: () => ({}) }) as DOMRect;
     vi.spyOn(HTMLElement.prototype, "getBoundingClientRect").mockImplementation(function (this: HTMLElement) {
-      return this === header ? rect(96) : rect(0);
+      if (this === header) return rect(96);
+      if (this.classList.contains("hk-modal-breadcrumb")) return rect(88);
+      return rect(0);
     });
     try {
       setViewport(1200);
       manager.register("modal", true, "第一层");
       manager.register("modal", true, "第二层");
       await mountStrip();
-      // 10 (app top, local) + (96 visual / 2 zoom) / 2
-      expect(strip()!.style.top).toBe("34px");
+      // 10 (app top, local) + the lower of: header centre (96 visual / 2
+      // zoom) / 2 = 24, and the clearance 12 + (88 visual / 2 zoom) / 2 =
+      // 34 — the clearance sits lower and wins.
+      expect(strip()!.style.top).toBe("44px");
     } finally {
       vi.restoreAllMocks();
       app.remove();
     }
   });
 
+  it("keeps daylight between the app's top edge and the strip", async () => {
+    // Centred on a standard short header, the strip's own upper half used
+    // to kiss the very top edge (2026-10-05 user report): a ~24px centre
+    // line is less than the strip's half height. The top is now the LOWER
+    // of "header centre" and the topGap clearance; the boxless test DOM
+    // exercises the rule on the two layout fallbacks (48px header, 43px
+    // strip). The app top is deliberately non-zero (5px) so NO expectation
+    // coincides with the pre-resync initial ref — each leg proves resyncTop
+    // actually wrote: 5 + max(48/2, gap + 43/2).
+    const app = document.createElement("div");
+    app.id = "app";
+    app.style.top = "5px";
+    document.body.appendChild(app);
+    const unmountAll = () => {
+      for (const a of mounts.splice(0)) a.unmount();
+    };
+    try {
+      setViewport(1200);
+      manager.register("modal", true, "第一层");
+      manager.register("modal", true, "第二层");
+      await mountStrip();
+      expect(strip()!.style.top).toBe("38.5px");
+      unmountAll();
+
+      // A host pinning the legacy, header-centred position passes 0:
+      // 5 + max(24, 0 + 21.5) — the centre branch wins again.
+      await mountStrip({ topGap: 0 });
+      expect(strip()!.style.top).toBe("29px");
+      unmountAll();
+
+      // And a host wanting more air simply raises the gap.
+      await mountStrip({ topGap: 40 });
+      expect(strip()!.style.top).toBe("66.5px");
+      unmountAll();
+
+      // A NaN gap is host junk: it falls back to the default instead of
+      // poisoning Math.max into `top: NaNpx` (which the browser drops).
+      await mountStrip({ topGap: Number.NaN });
+      expect(strip()!.style.top).toBe("38.5px");
+    } finally {
+      unmountAll();
+      app.remove();
+    }
+  });
+
+  it("paints the fallback position before any resync can run", async () => {
+    // A host whose app root id never resolves leaves resyncTop at its
+    // early-return, so the strip paints the INITIAL ref: that line must
+    // already encode the clearance rule on the two layout fallbacks
+    // (48px header, 43px strip), not a legacy literal. Every other
+    // style.top assertion lives in tests that create #app, where the
+    // pre-mount resync overwrites the init before the first render
+    // (mutation round M5: reverting the init to a bare 24 passed
+    // everything else green).
+    setViewport(1200);
+    manager.register("modal", true, "第一层");
+    manager.register("modal", true, "第二层");
+    await mountStrip({ appRootId: "no-such-root" });
+    expect(strip()!.style.top).toBe("33.5px");
+    for (const a of mounts.splice(0)) a.unmount();
+
+    // The init follows the prop the same way the resync does.
+    await mountStrip({ appRootId: "no-such-root", topGap: 0 });
+    expect(strip()!.style.top).toBe("21.5px");
+  });
+
   it("writes the viewport fence in the strip's own px", async () => {
     // A vw-authored cap would be scaled by a host root zoom at paint, so the
     // fence is re-derived from the live viewport (minus the shared gutter)

package/src/components/HkModalBreadcrumb.tsx

@@ -36,6 +36,13 @@ const GAP_PX = 8;
 const SIDE_PADDING_PX = 32;
 const BORDER_PX = 1;
 const MORE_PX = 24;
+/** The strip's own height for the moments no box can be measured (first
+ *  resync, unit DOM): the stylesheet declares 12px vertical padding, a
+ *  ~17px label line and a 1px border — 12·2 + 17 + 1·2 ≈ 43. Models the
+ *  UNFOLDED strip; a folded one is ~50px (the 24px trigger line) — the
+ *  fallback only serves boxless DOMs, a real browser measures the live
+ *  nav and the slow tick re-derives from it. */
+const STRIP_HEIGHT_PX = 43;
 
 interface Crumb {
   /** Popup-registry id this crumb can navigate back to. */
@@ -66,12 +73,33 @@ export default defineComponent({
      * hidden-layers menu.
      */
     maxLabelUnits: { type: Number, default: 10 },
+    /**
+     * Least daylight, in px, between the app's top edge and the strip's own
+     * top edge. The strip is centred on the app header, and on the standard
+     * short header that centre line sits ~24px from the top — less than the
+     * strip's half height, so its upper half used to kiss the very top edge
+     * (2026-10-05 user report). The top is now the lower of "centred on the
+     * header" and "this clearance"; a header whose centre already sits at
+     * least this far down keeps the strip centred on it. Authored in the
+     * strip's LOCAL px like every length here — a host root zoom scales it
+     * at paint, so it can only over-deliver daylight. Below 8 the entrance
+     * keyframe's own 8px slide transiently pokes back above the app top.
+     */
+    topGap: { type: Number, default: 12 },
   },
   setup(props) {
     const manager = usePopupManager();
     const { t } = useI18n();
     const { isMobile } = useBreakpoint();
 
+    /** Sanitized once: a host passing NaN would otherwise poison both the
+     *  pre-resync ref and every resync (Math.max(x, NaN) is NaN, and the
+     *  browser drops `top: NaNpx`, parking the strip at its static
+     *  position). A NEGATIVE gap stays the host's choice: it lowers the
+     *  clearance candidate below the centre line, which then wins — i.e.
+     *  "I don't care about daylight". */
+    const topGapPx = computed(() => (Number.isFinite(props.topGap) ? props.topGap : 12));
+
     /** Which entries the strip navigates. Windows (modal/drawer) always;
      *  dropdown-kind surfaces only while they BLOCK like a window — the
      *  mobile bottom sheet a menu/popover becomes when viewport space
@@ -375,7 +403,10 @@ export default defineComponent({
     });
     onBeforeUnmount(() => document.removeEventListener("keydown", onSurfaceKeydown));
 
-    const topPx = ref(24);
+    /** Pre-resync paint position: the clearance rule evaluated on the two
+     *  layout fallbacks (48px header, 43px strip). The first nextTick
+     *  resync replaces it with measured numbers. */
+    const topPx = ref(topGapPx.value + STRIP_HEIGHT_PX / 2);
     function resyncTop() {
       const app = document.getElementById(props.appRootId);
       if (!app) return;
@@ -397,7 +428,20 @@ export default defineComponent({
       const headerH = header
         ? header.getBoundingClientRect().height / z
         : props.headerFallbackHeight;
-      topPx.value = appTop + headerH / 2;
+      // The strip's own height comes back in the same VISUAL px the
+      // header's rect does (it teleports into the same zoomed subtree), so
+      // it divides by the zoom read at the strip itself. No box (first
+      // resync, unit DOM) falls back to the stylesheet-declared height.
+      let stripH = STRIP_HEIGHT_PX;
+      if (navRef.value) {
+        const navH = navRef.value.getBoundingClientRect().height;
+        if (navH > 0) stripH = navH / ancestorZoom(navRef.value);
+      }
+      // Centre on the header, but keep the promised daylight: whichever
+      // candidate parks the strip LOWER wins, so a centre line near the
+      // viewport top can no longer push the strip's upper half against
+      // (or past) the top edge.
+      topPx.value = appTop + Math.max(headerH / 2, topGapPx.value + stripH / 2);
     }
 
     /** Viewport fence, in the strip's OWN px. The stylesheet cap is
@@ -463,6 +507,9 @@ export default defineComponent({
           if (!handle) handle = scheduleEvery(onSlowTick, 1000);
           window.addEventListener("resize", onViewportChange);
           void nextTick(() => {
+            // The strip's own box exists only now: re-derive the top with
+            // a measured height (the pre-mount resync ran on fallbacks).
+            resyncBox();
             measureStrip();
             observeClone();
           });
@@ -495,7 +542,9 @@ export default defineComponent({
       if (!visible.value) return;
       // Synchronous first measure: the collapsed shape is committed in the
       // same task as the mount, so the strip never paints one frame wide
-      // enough to spill before folding.
+      // enough to spill before folding. The top is re-derived with the
+      // strip's now-measurable height for the same reason.
+      resyncBox();
       measureStrip();
       observeClone();
     });

package/src/i18n/locales/ar/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "نسخ",
     "hikari::protocol.copied": "تم النسخ",
     "hikari::clipboard.copied": "تم النسخ",
+    "hikari::clipboard.clickToCopy": "انقر للنسخ",
     "hikari::clipboard.copyFailed": "فشل النسخ",
     "hikari::about.title": "حول",
     "hikari::about.version": "الإصدار",

package/src/i18n/locales/de/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Kopieren",
     "hikari::protocol.copied": "Kopiert",
     "hikari::clipboard.copied": "Kopiert",
+    "hikari::clipboard.clickToCopy": "Klicken zum Kopieren",
     "hikari::clipboard.copyFailed": "Kopieren fehlgeschlagen",
     "hikari::about.title": "Über",
     "hikari::about.version": "Version",

package/src/i18n/locales/en/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Copy",
     "hikari::protocol.copied": "Copied",
     "hikari::clipboard.copied": "Copied",
+    "hikari::clipboard.clickToCopy": "Click to copy",
     "hikari::clipboard.copyFailed": "Copy failed",
     "hikari::about.title": "About",
     "hikari::about.version": "Version",

package/src/i18n/locales/es/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Copiar",
     "hikari::protocol.copied": "Copiado",
     "hikari::clipboard.copied": "Copiado",
+    "hikari::clipboard.clickToCopy": "Haz clic para copiar",
     "hikari::clipboard.copyFailed": "Error al copiar",
     "hikari::about.title": "Acerca de",
     "hikari::about.version": "Versión",

package/src/i18n/locales/fr/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Copier",
     "hikari::protocol.copied": "Copié",
     "hikari::clipboard.copied": "Copié",
+    "hikari::clipboard.clickToCopy": "Cliquez pour copier",
     "hikari::clipboard.copyFailed": "Échec de la copie",
     "hikari::about.title": "À propos",
     "hikari::about.version": "Version",

package/src/i18n/locales/ja/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "コピー",
     "hikari::protocol.copied": "コピーしました",
     "hikari::clipboard.copied": "コピーしました",
+    "hikari::clipboard.clickToCopy": "クリックでコピー",
     "hikari::clipboard.copyFailed": "コピーに失敗しました",
     "hikari::about.title": "このアプリについて",
     "hikari::about.version": "バージョン",

package/src/i18n/locales/ko/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "복사",
     "hikari::protocol.copied": "복사됨",
     "hikari::clipboard.copied": "복사됨",
+    "hikari::clipboard.clickToCopy": "클릭하여 복사",
     "hikari::clipboard.copyFailed": "복사 실패",
     "hikari::about.title": "정보",
     "hikari::about.version": "버전",

package/src/i18n/locales/pt/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Copiar",
     "hikari::protocol.copied": "Copiado",
     "hikari::clipboard.copied": "Copiado",
+    "hikari::clipboard.clickToCopy": "Clique para copiar",
     "hikari::clipboard.copyFailed": "Falha ao copiar",
     "hikari::about.title": "Sobre",
     "hikari::about.version": "Versão",

package/src/i18n/locales/ru/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "Копировать",
     "hikari::protocol.copied": "Скопировано",
     "hikari::clipboard.copied": "Скопировано",
+    "hikari::clipboard.clickToCopy": "Нажмите, чтобы скопировать",
     "hikari::clipboard.copyFailed": "Не удалось скопировать",
     "hikari::about.title": "О программе",
     "hikari::about.version": "Версия",

package/src/i18n/locales/zh-Hans/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "复制",
     "hikari::protocol.copied": "已复制",
     "hikari::clipboard.copied": "已复制",
+    "hikari::clipboard.clickToCopy": "点击复制",
     "hikari::clipboard.copyFailed": "复制失败",
     "hikari::about.title": "关于",
     "hikari::about.version": "版本",

package/src/i18n/locales/zh-Hant/platform.json

@@ -11,6 +11,7 @@
     "hikari::protocol.copy": "複製",
     "hikari::protocol.copied": "已複製",
     "hikari::clipboard.copied": "已複製",
+    "hikari::clipboard.clickToCopy": "點擊複製",
     "hikari::clipboard.copyFailed": "複製失敗",
     "hikari::about.title": "關於",
     "hikari::about.version": "版本",

package/src/index.ts

@@ -16,6 +16,7 @@ export { default as HColorPicker } from "./components/HkColorPicker";
 export { HColorSchemeDialog, type HCustomTheme } from "./components/HkColorSchemeDialog";
 export { HkColorSchemeEditor } from "./components/HkColorSchemeEditor";
 export { default as HConfirmDialog } from "./components/HkConfirmDialog";
+export { default as HCopyBadge } from "./components/HkCopyBadge";
 export { default as HCrossfade } from "./components/HkCrossfade";
 export { default as HDivider } from "./components/HkDivider";
 export {
@@ -684,6 +685,7 @@ export { default as HkButton } from "./components/HkButton";
 export { default as HkCard } from "./components/HkCard";
 export { default as HkCheckbox } from "./components/HkCheckbox";
 export { default as HkColorPicker } from "./components/HkColorPicker";
+export { default as HkCopyBadge } from "./components/HkCopyBadge";
 export { default as HkConfirmDialog } from "./components/HkConfirmDialog";
 export { default as HkCrossfade } from "./components/HkCrossfade";
 export { default as HkDivider } from "./components/HkDivider";