@antadesign/anta 0.3.10 → 0.3.11

package/dist/components/Button.d.ts

@@ -55,7 +55,10 @@ export type ContentMode = {
     iconTrailing?: IconShape;
 };
 /** Submit axis — anchors (href) don't carry form-submission props; buttons
- *  don't carry anchor props. */
+ *  don't carry anchor props. A link (`href`) also can't be a copy control, so the
+ *  copy props live only on the non-link branch (via `CopyMode`) and are `never`
+ *  on the link branch — a `<ButtonCopy href=…>` or `<Button href=… copy=…>` is a
+ *  type error, not a silently-ignored attribute. */
 export type SubmitMode = {
     /** Renders as `<a role="button">` instead of `<a-button>`. */
     href: string;
@@ -69,7 +72,13 @@ export type SubmitMode = {
     ping?: string;
     type?: never;
     form?: never;
-} | {
+    copy?: never;
+    copyNode?: never;
+    copyUrl?: never;
+    copyWithUrl?: never;
+    onCopyRequest?: never;
+    onCopied?: never;
+} | ({
     href?: never;
     target?: never;
     rel?: never;
@@ -79,7 +88,7 @@ export type SubmitMode = {
     type?: 'button' | 'submit' | 'reset';
     /** Form id when the button isn't a descendant of its form. */
     form?: string;
-};
+} & CopyMode);
 /** Priority axis — `underline` only on `tertiary` / `quaternary`,
  *  `paddingless` only on `quaternary`. */
 export type PriorityMode = {
@@ -102,21 +111,29 @@ export type PriorityMode = {
 };
 /** Copy axis — turns the button into a copy control that writes to the clipboard
  *  on click and flashes a success / failure state (see `<a-button>`'s copy
- *  behavior). **Exactly one** of `copy`, `copyNode`, or `copyLazy` may be set;
+ *  behavior). **Exactly one** of `copy`, `copyNode`, or `copyUrl` may be set;
  *  the union makes the others `never` in each mode. For the batteries-included
  *  preset, use `ButtonCopy`. */
 export type CopyMode = {
     copy?: never;
     copyNode?: never;
-    copyLazy?: never;
+    copyUrl?: never;
+    copyWithUrl?: never;
     onCopied?: never;
     onCopyRequest?: never;
 } | {
     /** Text copied to the clipboard on click. */
     copy: string;
+    /** Prefix the copied text with `// URL: <current page URL>`. */
+    copyWithUrl?: boolean;
+    /** Compute the copy content lazily. Fires on **pointerdown**; update `copy`
+     *  (a state change) here and the click copies the latest value. The
+     *  pointerdown→click gap lets the update land even when this handler runs
+     *  off the UI thread (a worker-rendered app) — only the serializable `copy`
+     *  string crosses, via the normal re-render. */
+    onCopyRequest?: () => void;
     copyNode?: never;
-    copyLazy?: never;
-    onCopyRequest?: never;
+    copyUrl?: never;
     /** Fires after the copy attempt with whether it succeeded. */
     onCopied?: (ok: boolean) => void;
 } | {
@@ -126,24 +143,22 @@ export type CopyMode = {
      *  the copied output. */
     copyNode: boolean | string;
     copy?: never;
-    copyLazy?: never;
+    copyUrl?: never;
+    copyWithUrl?: never;
     onCopyRequest?: never;
     /** Fires after the copy attempt with whether it succeeded. */
     onCopied?: (ok: boolean) => void;
 } | {
-    /** Lazy copy: the content isn't computed or held in the DOM until the
-     *  click. The click fires `onCopyRequest(provide)`; call `provide(text)`
-     *  with the value — synchronously, or after an `await` (the browser's
-     *  transient-activation window still covers the write). */
-    copyLazy: true;
+    /** Copy the current page URL (`location.href`). */
+    copyUrl: true;
     copy?: never;
     copyNode?: never;
-    /** Supplies the lazily-computed content on click: call `provide(text)`. */
-    onCopyRequest: (provide: (text: string) => void) => void;
+    copyWithUrl?: never;
+    onCopyRequest?: never;
     /** Fires after the copy attempt with whether it succeeded. */
     onCopied?: (ok: boolean) => void;
 };
-export type ButtonProps = BaseButtonProps & PriorityMode & ContentMode & SubmitMode & CopyMode & BaseProps;
+export type ButtonProps = BaseButtonProps & PriorityMode & ContentMode & SubmitMode & BaseProps;
 /**
  * Action button.
  *
@@ -164,4 +179,4 @@ export type ButtonProps = BaseButtonProps & PriorityMode & ContentMode & SubmitM
  * <Button href="/docs" target="_blank" label="Read the docs" />
  * ```
  */
-export declare const Button: ({ priority, tone, underline, icon, iconTrailing, paddingless, label, size, loading, disabled, selected, round, href, type, form, copy, copyNode, copyLazy, onCopied, onCopyRequest, className, style, children, ...rest }: ButtonProps) => any;
+export declare const Button: ({ priority, tone, underline, icon, iconTrailing, paddingless, label, size, loading, disabled, selected, round, href, type, form, copy, copyNode, copyUrl, copyWithUrl, onCopied, onCopyRequest, className, style, children, ...rest }: ButtonProps) => any;

package/dist/components/Button.js

@@ -18,7 +18,8 @@ const Button = ({
   form,
   copy,
   copyNode,
-  copyLazy,
+  copyUrl,
+  copyWithUrl,
   onCopied,
   onCopyRequest,
   className,
@@ -26,7 +27,7 @@ const Button = ({
   children,
   ...rest
 }) => {
-  const isCopy = copy != null || copyNode != null || copyLazy === true;
+  const isCopy = copy != null || copyNode != null || copyUrl === true;
   const toneAttr = tone || void 0;
   const computedStyle = roundStyle(round, "--button-round", toneStyle(toneAttr, "--button-tone-source", style));
   const leadingIcon = icon ?? (isCopy ? "copy" : void 0);
@@ -67,14 +68,15 @@ const Button = ({
     // Copy behavior — the element reads these and performs the write itself.
     copy: copy != null ? copy : void 0,
     "copy-node": copyNode === true ? "" : typeof copyNode === "string" ? copyNode : void 0,
-    "copy-lazy": copyLazy ? "" : void 0,
+    "copy-url": copyUrl ? "" : void 0,
+    "copy-with-url": copyWithUrl ? "" : void 0,
     // Marks the control so `copy-node` serialization strips it from the copied
     // node (a copy button inside the copied region shouldn't paste itself).
     "data-copy-node-button": copyNode != null && copyNode !== false ? "" : void 0,
     oncopydone: onCopied ? (e) => onCopied(nativeStateChange(e).detail?.ok ?? false) : void 0,
-    // The element hands `provide` on the request event; forward it so the
-    // consumer supplies the lazily-computed content.
-    oncopyrequest: onCopyRequest ? (e) => onCopyRequest(nativeStateChange(e).detail.provide) : void 0,
+    // Fired on pointerdown for a lazy copy — the consumer updates `copy` here
+    // (a state change) and the click copies the latest value. No payload crosses.
+    oncopyrequest: onCopyRequest ? () => onCopyRequest() : void 0,
     class: className,
     style: computedStyle
   };

package/dist/components/ButtonCopy.d.ts

@@ -7,15 +7,16 @@ export type ButtonCopyProps = ButtonProps & ({
 } | {
     copyNode: boolean | string;
 } | {
-    copyLazy: true;
+    copyUrl: true;
 });
 /**
  * Copy button — a `Button` preset for copy-to-clipboard. Set `copy` for a literal
- * string, `copyNode` to copy a DOM region, or `copyLazy` + `onCopyRequest` to
- * compute the content on click. The `<a-button>` element performs the write and
- * reports the result; this wrapper flips the leading icon to a check (success) or
- * ✕ (failure) and retones to `success` / `critical` for ~2s — a JSX re-render, no
- * element state (see `useCopyFeedback`).
+ * string, `copyNode` to copy a DOM region, or `copyUrl` to copy the current page
+ * URL. For content computed on demand, keep `copy` reactive and refresh it in
+ * `onCopyRequest` (fired on pointerdown). The `<a-button>` element performs the
+ * write and reports the result; this wrapper flips the leading icon to a check
+ * (success) or ✕ (failure) and retones to `success` / `critical` for ~2s — a JSX
+ * re-render, no element state (see `useCopyFeedback`).
  *
  * With a `label` it's a labeled button; without one it's an icon-only copy button.
  * Everything else is a normal `Button` prop — `tone`, `priority`, `size`, `icon`
@@ -26,7 +27,12 @@ export type ButtonCopyProps = ButtonProps & ({
  * <ButtonCopy copy="npm i @antadesign/anta" label="Copy install" />
  * <ButtonCopy copy="https://anta.design" />          // icon-only
  * <ButtonCopy copyNode=".snippet" label="Copy block" priority="tertiary" />
- * <ButtonCopy copyLazy label="Copy report" onCopyRequest={(p) => p(buildReport())} />
+ * <ButtonCopy copyUrl label="Copy link" />           // copies location.href
+ * <ButtonCopy copy={code} copyWithUrl label="Copy snippet" />  // code + source URL
+ *
+ * // Lazy: compute on pointerdown, copied on the click that follows.
+ * const [report, setReport] = useState('')
+ * <ButtonCopy copy={report} onCopyRequest={() => setReport(buildReport())} label="Copy report" />
  * ```
  */
 export declare const ButtonCopy: ({ icon, tone, onCopied, ...rest }: ButtonCopyProps) => any;

package/dist/components/MenuItem.d.ts

@@ -86,7 +86,8 @@ export type MenuItemLinkMode = {
     indicator?: never;
     copy?: never;
     copyNode?: never;
-    copyLazy?: never;
+    copyUrl?: never;
+    copyWithUrl?: never;
     onCopied?: never;
     onCopyRequest?: never;
 };
@@ -141,4 +142,4 @@ export type MenuItemProps = MenuItemCommonProps & (MenuItemLinkMode | (MenuItemA
  * </MenuItem>
  * ```
  */
-export declare const MenuItem: ({ icon, label, hint, kbd, iconTrailing, disabled, selected, selectionIndicator, indeterminate, indicator, tone, toneSelected, submenu, value, onSelect, href, target, rel, download, ping, copy, copyNode, copyLazy, onCopied, onCopyRequest, role: roleOverride, className, style, children, ...rest }: MenuItemProps) => any;
+export declare const MenuItem: ({ icon, label, hint, kbd, iconTrailing, disabled, selected, selectionIndicator, indeterminate, indicator, tone, toneSelected, submenu, value, onSelect, href, target, rel, download, ping, copy, copyNode, copyUrl, copyWithUrl, onCopied, onCopyRequest, role: roleOverride, className, style, children, ...rest }: MenuItemProps) => any;

package/dist/components/MenuItem.js

@@ -23,7 +23,8 @@ const MenuItem = ({
   ping,
   copy,
   copyNode,
-  copyLazy,
+  copyUrl,
+  copyWithUrl,
   onCopied,
   onCopyRequest,
   role: roleOverride,
@@ -32,7 +33,7 @@ const MenuItem = ({
   children,
   ...rest
 }) => {
-  const isCopy = copy != null || copyNode != null || copyLazy === true;
+  const isCopy = copy != null || copyNode != null || copyUrl === true;
   const leadingIcon = icon ?? (isCopy ? "copy" : void 0);
   const checkable = selectionIndicator === "checkbox" || selectionIndicator === "radio" || selectionIndicator === "check";
   const role = selectionIndicator === "checkbox" ? "menuitemcheckbox" : selectionIndicator === "radio" || selectionIndicator === "check" ? "menuitemradio" : "menuitem";
@@ -85,10 +86,11 @@ const MenuItem = ({
       onmenuselect: onSelect ? (e) => onSelect(e, { value, label }) : void 0,
       copy: copy != null ? copy : void 0,
       "copy-node": copyNode === true ? "" : typeof copyNode === "string" ? copyNode : void 0,
-      "copy-lazy": copyLazy ? "" : void 0,
+      "copy-url": copyUrl ? "" : void 0,
+      "copy-with-url": copyWithUrl ? "" : void 0,
       "data-copy-node-button": copyNode != null && copyNode !== false ? "" : void 0,
       oncopydone: onCopied ? (e) => onCopied(nativeStateChange(e).detail?.ok ?? false) : void 0,
-      oncopyrequest: onCopyRequest ? (e) => onCopyRequest(nativeStateChange(e).detail.provide) : void 0,
+      oncopyrequest: onCopyRequest ? () => onCopyRequest() : void 0,
       class: className,
       ...rest,
       children: [

package/dist/components/MenuItemCopy.d.ts

@@ -8,12 +8,13 @@ export type MenuItemCopyProps = MenuItemCommonProps & MenuItemActionMode & CopyM
 } | {
     copyNode: boolean | string;
 } | {
-    copyLazy: true;
+    copyUrl: true;
 });
 /**
  * Copying menu item — a `MenuItem` preset for copy-to-clipboard rows inside a
  * `Menu`. Set `copy` for a literal string, `copyNode` to copy a DOM region, or
- * `copyLazy` + `onCopyRequest` to compute the content on select. The
+ * `copyUrl` to copy the current page URL. For content computed on demand, keep
+ * `copy` reactive and refresh it in `onCopyRequest` (fired on pointerdown). The
  * `<a-menu-item>` element performs the write when the row is chosen; this wrapper
  * flips the leading icon to a check / ✕ and retones for ~2s (see `useCopyFeedback`).
  *

package/dist/components/Select.d.ts

@@ -1,5 +1,6 @@
 import type { BaseProps } from '../general_types';
 import type { IconShape } from '../elements/a-icon.shapes';
+import { type MenuProps } from './Menu';
 /** One option in a `<Select>`. Pass a bare string as shorthand for
  *  `{ value: s, label: s }`. Carries an index signature so you can attach
  *  arbitrary fields (a `ranAt` date, a `status`, …) and read them back in
@@ -131,6 +132,13 @@ export interface SelectCommonProps extends Omit<BaseProps, 'children'> {
      *  logical pick (both rows toggle together; the trigger resolves to the last). Dev
      *  builds `console.warn` on a duplicate. */
     options: SelectItem[];
+    /** Preferred placement of the options menu relative to the trigger. The menu
+     *  auto-flips vertically and clamps horizontally when needed.
+     *  @defaultValue bottom-start */
+    placement?: MenuProps['placement'];
+    /** Gap in pixels between the trigger and the options menu.
+     *  @defaultValue 4 */
+    offset?: number;
     /** The per-row mark for **single**-select: `'none'` (a tint-only highlight),
      *  `'check'` (a trailing checkmark on the selected row, keeping the tint — the
      *  canonical Select look), or `'radio'` (a leading radio on every row).

package/dist/components/Select.js

@@ -37,6 +37,8 @@ function optionsWithSelection(options, values) {
 const Select = (props) => {
   const {
     options,
+    placement,
+    offset,
     selection,
     indicator,
     value,
@@ -274,6 +276,8 @@ const Select = (props) => {
     /* @__PURE__ */ jsxs(
       Menu,
       {
+        placement,
+        offset,
         onStateChange: (_e, { next }) => {
           setOpen(next);
           if (!next) {

package/dist/components/SelectFaceted.d.ts

@@ -1,6 +1,7 @@
 import type { BaseProps } from '../general_types';
 import type { IconShape } from '../elements/a-icon.shapes';
 import type { SelectItem, SelectOption } from './Select';
+import { type MenuProps } from './Menu';
 interface FacetBase {
     /** The facet's namespace — the key its value is stored under in the value
      *  record, and what `onValueChange`'s `attrs.facet` reports. Unique across
@@ -108,6 +109,13 @@ export interface SelectFacetedTriggerState {
 export interface SelectFacetedProps extends Omit<BaseProps, 'children'> {
     /** The facets (dimensions) to filter across, each with its own editor kind. */
     facets: SelectFacet[];
+    /** Preferred placement of the root filter menu relative to its trigger. The
+     *  menu auto-flips vertically and clamps horizontally when needed.
+     *  @defaultValue bottom-start */
+    placement?: MenuProps['placement'];
+    /** Gap in pixels between the trigger and the filter menu.
+     *  @defaultValue 4 */
+    offset?: number;
     /** Controlled value — the facet-keyed record. When provided, the consumer
      *  owns state: a pick only *requests* a change via `onValueChange` (reject by
      *  not updating). Leave undefined for uncontrolled. */

package/dist/components/SelectFaceted.js

@@ -27,6 +27,8 @@ const defaultMatch = (o, query) => matchesQuery(o, matchQueryRegex(query));
 const SelectFaceted = (props) => {
   const {
     facets,
+    placement,
+    offset,
     value,
     defaultValue,
     onValueChange,
@@ -284,6 +286,8 @@ const SelectFaceted = (props) => {
     /* @__PURE__ */ jsxs(
       Menu,
       {
+        placement,
+        offset,
         open,
         onStateChange: (_e, { next }) => {
           setOpen(next);

package/dist/elements/a-button.d.ts

@@ -64,8 +64,11 @@ declare global {
 export declare class AButtonElement extends HTMLElementBase {
     connectedCallback(): void;
     /** Perform a copy if this button is a copy control (`copy` / `copy-node` /
-     *  `copy-lazy`). Called from the delegated click handler on activation. The
+     *  `copy-url`). Called from the delegated click handler on activation. The
      *  outcome is announced via a `copydone` event the wrapper reflects. */
     performCopy(): boolean;
+    /** Ask a lazy consumer to refresh the `copy` value on pointerdown (fires a
+     *  `copyrequest` event); the click then copies whatever `copy` holds. */
+    requestCopy(): void;
 }
 export declare function register_a_button(): void;

package/dist/elements/a-button.js

@@ -1,9 +1,17 @@
 import { HTMLElementBase } from "../anta_helpers";
-import { runCopy } from "./copy-behavior";
+import { emitCopyRequest, runCopy } from "./copy-behavior";
+import { installKeyActivation } from "./key-activation";
 import "./a-button.css";
 function installDocumentHandlers(doc) {
   if (!doc || doc.hasKeyListenerForAButton) return;
-  doc.addEventListener("keydown", handleKeyDown, true);
+  installKeyActivation(doc, {
+    keys: ["Enter", " "],
+    resolve: (t) => t?.closest?.("a-button"),
+    blocked: (el) => el.hasAttribute("disabled") || el.hasAttribute("loading"),
+    preflight: (el) => el.requestCopy(),
+    activate: (el) => el.click()
+  });
+  doc.addEventListener("pointerdown", handlePointerDown, true);
   doc.addEventListener("click", handleClick, true);
   doc.hasKeyListenerForAButton = true;
 }
@@ -12,11 +20,16 @@ class AButtonElement extends HTMLElementBase {
     installDocumentHandlers(this.doc);
   }
   /** Perform a copy if this button is a copy control (`copy` / `copy-node` /
-   *  `copy-lazy`). Called from the delegated click handler on activation. The
+   *  `copy-url`). Called from the delegated click handler on activation. The
    *  outcome is announced via a `copydone` event the wrapper reflects. */
   performCopy() {
     return runCopy(this);
   }
+  /** Ask a lazy consumer to refresh the `copy` value on pointerdown (fires a
+   *  `copyrequest` event); the click then copies whatever `copy` holds. */
+  requestCopy() {
+    emitCopyRequest(this);
+  }
 }
 function findForm(el) {
   const formId = el.getAttribute("form");
@@ -25,16 +38,13 @@ function findForm(el) {
   }
   return el.closest("form");
 }
-function handleKeyDown(e) {
-  if (e.key !== "Enter" && e.key !== " ") return;
-  if (e.repeat) return;
+function handlePointerDown(e) {
   const el = e.target.closest(
     "a-button"
   );
   if (!el) return;
   if (el.hasAttribute("disabled") || el.hasAttribute("loading")) return;
-  e.preventDefault();
-  el.click();
+  el.requestCopy();
 }
 function handleClick(e) {
   const el = e.target.closest(

package/dist/elements/a-expander.js

@@ -1,6 +1,12 @@
 import { HTMLElementBase, parseOpenState } from "../anta_helpers";
 import "./a-expander.css";
 const ANIM_MS = 200;
+const INTERACTIVE_SELECTOR = 'a-button,a-checkbox,a-radio,a-radio-group,a-input,a-input-time,a-calendar,a-menu-item,a-tab,[data-anta][role="button"],button,a[href],input,select,textarea,label,[contenteditable=""],[contenteditable="true"]';
+const DISABLED_SELECTOR = ':disabled,[disabled],[aria-disabled="true"]';
+function ignoresToggle(el) {
+  if (el.matches("[data-expander-ignore]")) return true;
+  return el.matches(INTERACTIVE_SELECTOR) && !el.matches(DISABLED_SELECTOR);
+}
 const SUMMARY_TYPE_SCALE = {
   "1": [28, 32],
   "2": [24, 28],
@@ -266,11 +272,24 @@ class AExpanderElement extends HTMLElementBase {
     } catch {
     }
   }
+  /** Refuse to toggle when the click landed on a control inside the projected
+   *  title — walk the composed path up to (not including) the summary button and
+   *  test each element with `ignoresToggle` (enabled interactive control or the
+   *  opt-out marker). Synchronous and read here in the element, so it stands in
+   *  off-UI-thread runtimes. Suppressing before the dispatch also keeps a
+   *  *controlled* consumer from toggling (no `statechange` fires). */
+  #clickIgnoresToggle(e) {
+    const path = e.composedPath();
+    const end = path.indexOf(this.summary);
+    const scope = end === -1 ? path : path.slice(0, end);
+    return scope.some((n) => n instanceof Element && ignoresToggle(n));
+  }
   /** Compute the requested next state, announce it (cancelable, *before*
    *  applying), then — uncontrolled only, and only if not vetoed — apply it.
    *  Controlled: never self-apply; the consumer answers via the `state`
    *  attribute. See STATEFUL-COMPONENTS.md. */
-  onSummaryClick = () => {
+  onSummaryClick = (e) => {
+    if (this.#clickIgnoresToggle(e)) return;
     const prev = this.#current;
     const next = prev === "open" ? "closed" : "open";
     const ok = this.dispatchEvent(

package/dist/elements/a-menu-item.d.ts

@@ -67,6 +67,13 @@ export declare function isMenuItemEl(el: EventTarget | null | undefined): el is
 /** Install the one-per-document Enter/Space activation listener. Called from
  *  both `AMenuItemElement` and `AMenuElement` on connect, so a menu built only
  *  from link items (no `<a-menu-item>` ever upgrades) still gets keyboard
- *  activation. Idempotent per document. */
+ *  activation. Idempotent per document.
+ *
+ *  Shares `installKeyActivation` with `<a-button>`: activation is on keyup, with
+ *  a keydown pre-request (`emitCopyRequest`) so a lazy copy row can refresh its
+ *  `copy` during the hold. `.click()` on a link item navigates natively (honoring
+ *  download / target); on the custom element it routes through the menu's click
+ *  delegation — one path for both. (The combobox-filter Enter is a separate path
+ *  handled by `a-menu`, which uses the same keyup pre-request.) */
 export declare function ensureMenuItemKeyListener(doc: Document): void;
 export declare function register_a_menu_item(): void;

package/dist/elements/a-menu-item.js

@@ -1,5 +1,6 @@
 import { HTMLElementBase } from "../anta_helpers";
-import { runCopy } from "./copy-behavior";
+import { emitCopyRequest, runCopy } from "./copy-behavior";
+import { installKeyActivation } from "./key-activation";
 import "./a-menu-item.css";
 class AMenuItemElement extends HTMLElementBase {
   internals;
@@ -7,6 +8,7 @@ class AMenuItemElement extends HTMLElementBase {
     super();
     this.internals = this.attachInternals?.();
     this.addEventListener("menuselect", () => runCopy(this));
+    this.addEventListener("pointerdown", () => emitCopyRequest(this));
   }
   /** The active (combobox) cursor. `a-menu` sets this **property** (never an
    *  attribute — no DOM mutation, same rule as `a-radio.selected`) as ArrowUp/Down
@@ -30,17 +32,15 @@ function isMenuItemEl(el) {
 }
 function ensureMenuItemKeyListener(doc) {
   if (doc.hasKeyListenerForAMenuItem) return;
-  doc.addEventListener("keydown", handleKeyDown, true);
+  installKeyActivation(doc, {
+    keys: ["Enter", " "],
+    resolve: (t) => t?.closest?.(MENU_ITEM_SELECTOR),
+    blocked: (el) => el.hasAttribute("disabled"),
+    preflight: (el) => emitCopyRequest(el),
+    activate: (el) => el.click()
+  });
   doc.hasKeyListenerForAMenuItem = true;
 }
-function handleKeyDown(e) {
-  if (e.key !== "Enter" && e.key !== " ") return;
-  const el = e.target?.closest?.(MENU_ITEM_SELECTOR);
-  if (!el) return;
-  e.preventDefault();
-  if (el.hasAttribute("disabled")) return;
-  el.click();
-}
 function register_a_menu_item() {
   if (typeof customElements === "undefined") return;
   if (!customElements.get("a-menu-item")) {

package/dist/elements/a-menu.d.ts

@@ -122,6 +122,9 @@ export declare class AMenuElement extends HTMLElementBase {
      *  (line start/end); PageUp / PageDown jump the option list to first / last
      *  instead. Any other key falls through to the input (typing). */
     private handleComboKey;
+    /** Combobox keyup: activate the item a filter-field Enter armed. Paired with the
+     *  keydown pre-request in `handleComboKey` so lazy content resolves in the gap. */
+    handleKeyUp(e: KeyboardEvent): void;
     /** Public imperative API. Routes through the same intent path as the
      *  triggers, so it emits `statechange` and respects controlled mode. */
     open(opts?: {
@@ -212,8 +215,9 @@ export declare class AMenuElement extends HTMLElementBase {
     /** Close the whole open menu system from the root down. */
     private closeSystem;
     /** Called by the coordinator on the topmost open menu. Handles navigation;
-     *  Enter / Space activation is handled by a-menu-item's own global keydown
-     *  (which synthesizes a click → routed through onSurfaceClick). */
+     *  roving Enter / Space activation is `<a-menu-item>`'s own delegated keyup
+     *  (synthesizes a click → routed through onSurfaceClick). Combobox Enter (focus
+     *  in the filter field) is handled here via handleComboKey / handleKeyUp. */
     handleKey(e: KeyboardEvent): void;
     private submenuOf;
     private typeahead;

package/dist/elements/a-menu.js

@@ -1,5 +1,6 @@
 import { HTMLElementBase, anchorRect, setMenuPresence } from "../anta_helpers";
 import { AMenuItemElement, isMenuItemEl, ensureMenuItemKeyListener } from "./a-menu-item";
+import { emitCopyRequest } from "./copy-behavior";
 import "./a-menu.css";
 const MARGIN = 4;
 const MIN_HEIGHT = 96;
@@ -18,6 +19,7 @@ function bindDocListeners(doc, view) {
   if (docBound) return;
   doc.addEventListener("pointerdown", onDocPointerDown, true);
   doc.addEventListener("keydown", onDocKeyDown, true);
+  doc.addEventListener("keyup", onDocKeyUp, true);
   doc.addEventListener("contextmenu", onDocContextMenu, true);
   view.addEventListener("resize", onResize);
   boundDoc = doc;
@@ -28,6 +30,7 @@ function unbindDocListeners() {
   if (!docBound) return;
   boundDoc?.removeEventListener("pointerdown", onDocPointerDown, true);
   boundDoc?.removeEventListener("keydown", onDocKeyDown, true);
+  boundDoc?.removeEventListener("keyup", onDocKeyUp, true);
   boundDoc?.removeEventListener("contextmenu", onDocContextMenu, true);
   boundView?.removeEventListener("resize", onResize);
   removePosTracker?.();
@@ -66,6 +69,14 @@ function pathHitsMenus(e, primaryClick = false) {
   }
   return false;
 }
+function pathCrossesTopLayerBeforeAnchor(e, anchor) {
+  for (const node of e.composedPath()) {
+    if (node === anchor) return false;
+    if (node instanceof HTMLDialogElement && node.matches(":modal") || node instanceof HTMLElement && node.matches(":popover-open"))
+      return true;
+  }
+  return false;
+}
 function nodeHitsMenus(node) {
   for (const m of openStack) {
     if (m.contains(node) || m.surface.contains(node)) return true;
@@ -95,6 +106,11 @@ function onDocKeyDown(e) {
   if (!menu) return;
   menu.handleKey(e);
 }
+function onDocKeyUp(e) {
+  const menu = openStack[openStack.length - 1];
+  if (!menu) return;
+  menu.handleKeyUp(e);
+}
 function dismiss(originEvent) {
   openStack[0]?.requestClose(originEvent);
 }
@@ -535,13 +551,26 @@ class AMenuElement extends HTMLElementBase {
       case "Enter":
         if (this.activeItem) {
           e.preventDefault();
-          this.activeItem.click();
+          emitCopyRequest(this.activeItem);
+          this.#pendingComboActivate = this.activeItem;
         }
         return true;
       default:
         return false;
     }
   }
+  /** The combobox cursor armed by an Enter keydown in the filter field, consumed
+   *  on the matching keyup. Only the combobox path arms this — the roving Enter/
+   *  Space activation is `<a-menu-item>`'s (also keyup, via key-activation). */
+  #pendingComboActivate = null;
+  /** Combobox keyup: activate the item a filter-field Enter armed. Paired with the
+   *  keydown pre-request in `handleComboKey` so lazy content resolves in the gap. */
+  handleKeyUp(e) {
+    if (e.key !== "Enter") return;
+    const el = this.#pendingComboActivate;
+    this.#pendingComboActivate = null;
+    el?.click();
+  }
   /* ============================ open / close ============================ */
   /** Public imperative API. Routes through the same intent path as the
    *  triggers, so it emits `statechange` and respects controlled mode. */
@@ -863,8 +892,9 @@ class AMenuElement extends HTMLElementBase {
   }
   /* ============================ keyboard ============================ */
   /** Called by the coordinator on the topmost open menu. Handles navigation;
-   *  Enter / Space activation is handled by a-menu-item's own global keydown
-   *  (which synthesizes a click → routed through onSurfaceClick). */
+   *  roving Enter / Space activation is `<a-menu-item>`'s own delegated keyup
+   *  (synthesizes a click → routed through onSurfaceClick). Combobox Enter (focus
+   *  in the filter field) is handled here via handleComboKey / handleKeyUp. */
   handleKey(e) {
     const active = this.doc.activeElement;
     if (e.key === "Escape") {
@@ -998,6 +1028,7 @@ class AMenuElement extends HTMLElementBase {
       };
     } else if (this.#isContext) {
       const onContext = (e) => {
+        if (pathCrossesTopLayerBeforeAnchor(e, anchor)) return;
         e.preventDefault();
         this.requestOpen({ coord: [e.clientX, e.clientY], originEvent: e });
       };

package/dist/elements/copy-behavior.d.ts

@@ -11,23 +11,40 @@
  * nested copy row's `copydone` from flipping an ancestor copy row's feedback
  * (the same point-to-point rule Anta's `statechange` follows).
  *
- * Three modes, chosen by attribute:
+ * Modes, chosen by attribute:
  * - `copy="<text>"` — copy the literal string on activation.
+ * - `copy-url` — copy the current page URL (`location.href`); no `copy` needed.
+ * - `copy-with-url` — prefix the copied `copy` string with `// URL: <href>`.
  * - `copy-node` / `copy-node="<selector>"` — copy a DOM node as rich text
  *   (`text/html`) + plain text. Bare `copy-node` copies the nearest ancestor
  *   marked `[data-copy-source]`; a value is a selector resolved with `closest()`
  *   (an ancestor region). The copy control is stripped from the serialized
  *   output (`[data-copy-node-button]`).
- * - `copy-lazy` — the content isn't known until the click. Activation dispatches
- *   `copyrequest` whose `detail.provide(text)` the consumer calls with the value
- *   (synchronously, or after an `await` — the browser's transient-activation
- *   window still covers the write). Nothing lands in the DOM, and there's no
- *   attribute round-trip to reset. Takes precedence over any `copy` value.
+ *
+ * ## Lazy content (off-UI-thread safe)
+ *
+ * When the content isn't known ahead of time, the element emits a `copyrequest`
+ * event on **pointerdown** (`emitCopyRequest`, fired whenever a `copy` attribute
+ * is present). The consumer answers by setting the `copy` attribute to the
+ * freshly-computed value; the **click** then reads that value and writes it. The
+ * pointerdown→click gap absorbs the round-trip, so this works even when the
+ * consumer's handler runs off the UI thread (e.g. a worker-rendered app): only a
+ * serializable string crosses the boundary via the normal reconcile — no
+ * callback, and the write stays inside the click's transient activation. This is
+ * why there is no `provide`-function handoff and no `copy-lazy` marker.
  *
  * Precedence when several are set (the discriminated-union prop types make this
- * unreachable from the wrappers, but hand-authored markup can): node → lazy →
- * literal `copy`.
+ * unreachable from the wrappers, but hand-authored markup can): node → url →
+ * literal `copy` (with the optional URL prefix).
+ */
+/**
+ * Ask a lazy consumer to refresh the copy content, on pointerdown — dispatch a
+ * non-bubbling, payload-free `copyrequest`. The consumer answers by setting the
+ * `copy` attribute to the freshly-computed value before the click reads it (see
+ * the "Lazy content" note above). Fires only for string-copy controls; node/url
+ * modes resolve themselves at click time and need no request. No-op otherwise.
  */
+export declare function emitCopyRequest(el: HTMLElement): void;
 /**
  * Perform a copy on activation (click / Enter / Space / menu select). Returns
  * `true` if the element is a copy control (so the caller knows the copy path

package/dist/elements/copy-behavior.js

@@ -37,32 +37,34 @@ function run(el, work) {
     el.dispatchEvent(new CustomEvent("copydone", { bubbles: false, detail: { ok } }));
   });
 }
+function currentUrl() {
+  return typeof location !== "undefined" ? location.href : "";
+}
+function resolveText(el) {
+  if (el.hasAttribute("copy-url")) return currentUrl();
+  const base = el.getAttribute("copy") ?? "";
+  if (el.hasAttribute("copy-with-url")) return `// URL: ${currentUrl()}
+${base}`;
+  return base;
+}
+function isTextCopy(el) {
+  return el.hasAttribute("copy") || el.hasAttribute("copy-url");
+}
+function emitCopyRequest(el) {
+  if (!el.hasAttribute("copy")) return;
+  el.dispatchEvent(new CustomEvent("copyrequest", { bubbles: false }));
+}
 function runCopy(el) {
   if (el.hasAttribute("copy-node")) {
     const target = resolveNodeTarget(el);
     run(el, target ? writeNode(target) : Promise.resolve(false));
     return true;
   }
-  if (el.hasAttribute("copy-lazy")) {
-    let done = false;
-    el.dispatchEvent(
-      new CustomEvent("copyrequest", {
-        bubbles: false,
-        detail: {
-          provide(text) {
-            if (done) return;
-            done = true;
-            run(el, writeText(String(text ?? "")));
-          }
-        }
-      })
-    );
-    return true;
-  }
-  if (!el.hasAttribute("copy")) return false;
-  run(el, writeText(el.getAttribute("copy") ?? ""));
+  if (!isTextCopy(el)) return false;
+  run(el, writeText(resolveText(el)));
   return true;
 }
 export {
+  emitCopyRequest,
   runCopy
 };

package/dist/elements/key-activation.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared "activate on key release" for Enter / Space, used by `<a-button>` and
+ * `<a-menu-item>` (via one delegated keydown/keyup pair per document).
+ *
+ * Activation fires on **keyup**, not keydown. This matches the native `<button>`
+ * (Space already activates on release), makes activation **cancelable** (move
+ * focus between press and release → no fire), and — the reason it's uniform
+ * across Enter and Space here — opens a **keydown→keyup gap** so a lazy copy
+ * control can refresh its `copy` value between press and release before the write
+ * (the keyboard analog of the pointerdown→click gap; see copy-behavior's "Lazy
+ * content" note).
+ *
+ * keydown: `preventDefault()` (stop Space scrolling the page and a link's own
+ * native Enter→click), run `preflight(el)` — the copy pre-request — and arm the
+ * release. keyup: `activate(el)` only if the same element is still armed.
+ *
+ * Idempotency is the caller's job (each guards with its own per-document flag);
+ * this just wires one keydown/keyup pair.
+ */
+export interface KeyActivation {
+    /** Keys that activate — `['Enter', ' ']` for buttons/menu items. */
+    keys: readonly string[];
+    /** Resolve the activatable element from the event target (e.g. `closest`). */
+    resolve(target: EventTarget | null): HTMLElement | null;
+    /** Blocked (disabled / loading) — swallow the key without activating. */
+    blocked?(el: HTMLElement): boolean;
+    /** Runs on keydown, before the release: the lazy copy pre-request. */
+    preflight?(el: HTMLElement): void;
+    /** Runs on keyup: the actual activation (a synthesized `click()`). */
+    activate(el: HTMLElement): void;
+}
+export declare function installKeyActivation(doc: Document, config: KeyActivation): void;

package/dist/elements/key-activation.js

@@ -0,0 +1,33 @@
+function installKeyActivation(doc, config) {
+  let armed = null;
+  doc.addEventListener(
+    "keydown",
+    (e) => {
+      if (e.repeat || !config.keys.includes(e.key)) return;
+      const el = config.resolve(e.target);
+      if (!el) return;
+      e.preventDefault();
+      armed = config.blocked?.(el) ? null : el;
+      if (armed) config.preflight?.(armed);
+    },
+    true
+  );
+  doc.addEventListener(
+    "keyup",
+    (e) => {
+      if (!config.keys.includes(e.key)) return;
+      const el = config.resolve(e.target);
+      if (!el || el !== armed) {
+        armed = null;
+        return;
+      }
+      armed = null;
+      if (config.blocked?.(el)) return;
+      config.activate(el);
+    },
+    true
+  );
+}
+export {
+  installKeyActivation
+};

package/dist/general_types.d.ts

@@ -735,17 +735,19 @@ export interface AMenuItemAttributes extends BaseAttributes {
      *  is a CSS selector resolved with `closest()`. Presence-based for the boolean
      *  form. */
     'copy-node'?: boolean | string;
-    /** Lazy copy: with an empty `copy`, activation dispatches `copyrequest` and the
-     *  write completes once `copy` is set back (within the activation window).
+    /** Copy the current page URL (`location.href`) instead of a `copy` string.
      *  Presence-based. */
-    'copy-lazy'?: boolean | '';
+    'copy-url'?: boolean | '';
+    /** Prefix the copied `copy` string with `// URL: <href>`. Presence-based. */
+    'copy-with-url'?: boolean | '';
     /** Fired after a copy attempt (bubbling `copydone`, `detail: { ok }`).
      *  All-lowercase so it binds in React *and* Preact. */
     oncopydone?: (e: CustomEvent<{
         ok: boolean;
     }>) => void;
-    /** Fired on a lazy copy activation to request the content (bubbling
-     *  `copyrequest`). Answer by setting the `copy` attribute. All-lowercase. */
+    /** Fired on **pointerdown** for a string-copy row (`copyrequest`, non-bubbling).
+     *  Answer by setting the `copy` attribute to the freshly-computed value; the
+     *  chosen row copies it. All-lowercase. */
     oncopyrequest?: (e: CustomEvent) => void;
 }
 /**
@@ -798,22 +800,22 @@ export interface AButtonAttributes extends BaseAttributes {
      *  is a CSS selector resolved with `closest()` (an ancestor region). Presence-
      *  based for the boolean form. */
     'copy-node'?: boolean | string;
-    /** Lazy copy: activation dispatches `copyrequest`; the consumer calls
-     *  `detail.provide(text)` with the content, which stays out of the DOM until
-     *  then. Takes precedence over `copy`. Presence-based. */
-    'copy-lazy'?: boolean | '';
+    /** Copy the current page URL (`location.href`) instead of a `copy` string; no
+     *  `copy` needed. Presence-based. */
+    'copy-url'?: boolean | '';
+    /** Prefix the copied `copy` string with `// URL: <href>`. Presence-based. */
+    'copy-with-url'?: boolean | '';
     /** Fired after a copy attempt (`copydone`, `detail: { ok }`, non-bubbling so a
      *  nested copy row can't flip an ancestor's feedback). All-lowercase so it
      *  binds in React *and* Preact. */
     oncopydone?: (e: CustomEvent<{
         ok: boolean;
     }>) => void;
-    /** Fired on a lazy copy activation (`copyrequest`, non-bubbling). Supply the
-     *  content by calling `detail.provide(text)` — synchronously or within the
-     *  click's activation window. All-lowercase. */
-    oncopyrequest?: (e: CustomEvent<{
-        provide: (text: string) => void;
-    }>) => void;
+    /** Fired on **pointerdown** for a string-copy button (`copyrequest`,
+     *  non-bubbling). Answer by setting the `copy` attribute to the freshly-computed
+     *  value; the click then copies it. The pointerdown→click gap lets an
+     *  off-UI-thread handler set `copy` in time. All-lowercase. */
+    oncopyrequest?: (e: CustomEvent) => void;
     'aria-disabled'?: 'true' | 'false' | boolean;
     'aria-busy'?: 'true' | 'false' | boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antadesign/anta",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",