@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/toolbar-xbh5bhtr.js

@@ -0,0 +1,194 @@
+// ../ui/src/behaviors/toolbar.ts
+var TOOLBAR = "jx-toolbar";
+var FOCUSABLE = "button, input, select, textarea, a[href], [contenteditable=''], [contenteditable='true']";
+var COMPOSITE = "jx-action-group, jx-tabs, jx-tree, jx-swatch-group, jx-listbox, jx-menu";
+var OWN_ARROWS = "select, input[type='range'], input[type='number'], [role='spinbutton'], [role='slider'], [role='combobox']";
+var TEXT_TYPES = new Set(["", "text", "search", "url", "tel", "password", "email"]);
+function barOf(event) {
+  const target = event.currentTarget;
+  return target instanceof HTMLElement && target.localName === TOOLBAR ? target : null;
+}
+function ownsNode(bar, node) {
+  return node instanceof Element && node.closest(TOOLBAR) === bar;
+}
+function itemFor(bar, node) {
+  let item = node;
+  for (let el = node.parentElement;el && el !== bar; el = el.parentElement) {
+    if (el.localName.includes("-")) {
+      item = el;
+    }
+  }
+  return item;
+}
+function controlOf(item) {
+  if (item.matches(FOCUSABLE)) {
+    return item;
+  }
+  const named = [...item.querySelectorAll('[part="control"], [part="input"]')].find((node) => node.matches(FOCUSABLE));
+  return named ?? item.querySelector(FOCUSABLE) ?? item;
+}
+function itemsOf(bar) {
+  const items = [];
+  for (const node of bar.querySelectorAll(FOCUSABLE)) {
+    if (node.closest(TOOLBAR) !== bar) {
+      continue;
+    }
+    const composite = node.closest(COMPOSITE);
+    if (composite && bar.contains(composite)) {
+      continue;
+    }
+    const item = itemFor(bar, node);
+    if (!items.includes(item) && !controlOf(item).matches(OWN_ARROWS)) {
+      items.push(item);
+    }
+  }
+  return items;
+}
+function isOut(item) {
+  if (item.hidden) {
+    return true;
+  }
+  return item.disabled === undefined ? item.hasAttribute("disabled") : item.disabled === true;
+}
+function caretOf(item) {
+  return "tabindex" in item ? String(item.tabindex ?? "") : item.getAttribute("tabindex") ?? "";
+}
+function setCaret(item, value) {
+  if ("tabindex" in item) {
+    item.tabindex = value;
+  } else if (item.matches(FOCUSABLE)) {
+    item.tabIndex = Number(value);
+  }
+}
+function writeRoving(items, caret) {
+  for (const item of items) {
+    setCaret(item, item === caret ? "0" : "-1");
+  }
+}
+function caretFor(items) {
+  const live = items.filter((item) => !isOut(item));
+  return live.find((item) => caretOf(item) === "0") ?? live[0] ?? null;
+}
+function focusItem(bar, index) {
+  const items = itemsOf(bar);
+  const live = items.filter((item) => !isOut(item));
+  if (live.length === 0) {
+    return null;
+  }
+  const at = (index % live.length + live.length) % live.length;
+  const caret = live[at];
+  writeRoving(items, caret);
+  controlOf(caret).focus();
+  return caret;
+}
+function atEdge(node, forward) {
+  let start = null;
+  let end = null;
+  try {
+    start = node.selectionStart;
+    end = node.selectionEnd;
+  } catch {
+    return true;
+  }
+  if (start === null || end === null) {
+    return true;
+  }
+  if (start !== end) {
+    return false;
+  }
+  return forward ? start >= String(node.value ?? "").length : start <= 0;
+}
+function isTextEntry(node) {
+  if (node.localName === "textarea") {
+    return true;
+  }
+  return node.localName === "input" && TEXT_TYPES.has((node.getAttribute("type") ?? "").toLowerCase());
+}
+function cedesKey(node, key, forward) {
+  if (!(node instanceof HTMLElement) || !isTextEntry(node)) {
+    return false;
+  }
+  if (key === "Home" || key === "End") {
+    return true;
+  }
+  return !atEdge(node, key === forward);
+}
+function syncRoving(bar) {
+  const items = itemsOf(bar);
+  writeRoving(items, caretFor(items));
+}
+function isSettled(bar) {
+  const items = itemsOf(bar);
+  const caret = caretFor(items);
+  return items.every((item) => caretOf(item) === (item === caret ? "0" : "-1"));
+}
+var watched = new WeakSet;
+function watchRoving(bar) {
+  if (watched.has(bar)) {
+    return;
+  }
+  watched.add(bar);
+  const observer = new MutationObserver(() => {
+    if (!isSettled(bar)) {
+      syncRoving(bar);
+    }
+  });
+  observer.observe(bar, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeFilter: ["disabled", "hidden"]
+  });
+}
+function onToolbarKeydown(state, event) {
+  const bar = barOf(event);
+  if (!bar || !ownsNode(bar, event.target)) {
+    return;
+  }
+  const vertical = state.orientation === "vertical";
+  const forward = vertical ? "ArrowDown" : "ArrowRight";
+  const back = vertical ? "ArrowUp" : "ArrowLeft";
+  if (event.key !== forward && event.key !== back && event.key !== "Home" && event.key !== "End") {
+    return;
+  }
+  if (cedesKey(event.target, event.key, forward)) {
+    return;
+  }
+  const live = itemsOf(bar).filter((item) => !isOut(item));
+  if (live.length === 0) {
+    return;
+  }
+  const active = live.findIndex((item) => item === event.target || event.target instanceof Node && item.contains(event.target));
+  let index;
+  if (event.key === forward) {
+    index = active + 1;
+  } else if (event.key === back) {
+    index = active === -1 ? -1 : active - 1;
+  } else if (event.key === "Home") {
+    index = 0;
+  } else {
+    index = -1;
+  }
+  focusItem(bar, index);
+  event.preventDefault();
+  event.stopPropagation();
+}
+function onToolbarReady(_state, event) {
+  const bar = barOf(event);
+  if (bar) {
+    syncRoving(bar);
+    watchRoving(bar);
+  }
+}
+export {
+  cedesKey,
+  controlOf,
+  focusItem,
+  itemsOf,
+  onToolbarKeydown,
+  onToolbarReady,
+  syncRoving
+};
+
+//# debugId=62ADF7BBE6AF01B264756E2164756E21
+//# sourceMappingURL=toolbar-xbh5bhtr.js.map

package/dist/chunks/tooltip-eptb614w.js

@@ -0,0 +1,369 @@
+import {
+  supportsAnchorPositioning2,
+  openAt2,
+  close2
+} from "./iframe-entry-nbyxee1y.js";
+
+// ../ui/src/behaviors/tooltip.ts
+var TOOLTIP_HIDE_GRACE_MS = 150;
+var TOOLTIP_OFFSET = 6;
+var MARGIN = 4;
+var bindings = new WeakMap;
+var escapes = new WeakMap;
+function watchEscape(root, dismiss) {
+  let entry = escapes.get(root);
+  if (!entry) {
+    const set = new Set;
+    const listener = (event) => {
+      if (event.key !== "Escape") {
+        return;
+      }
+      for (const fn of set) {
+        fn();
+      }
+    };
+    root.addEventListener("keydown", listener, true);
+    entry = { dismiss: set, listener };
+    escapes.set(root, entry);
+  }
+  const { dismiss: set, listener } = entry;
+  set.add(dismiss);
+  return () => {
+    set.delete(dismiss);
+    if (set.size === 0 && escapes.get(root)?.listener === listener) {
+      root.removeEventListener("keydown", listener, true);
+      escapes.delete(root);
+    }
+  };
+}
+function popoverOpen(tip) {
+  try {
+    return tip.matches(":popover-open");
+  } catch {
+    return false;
+  }
+}
+function keyboardFocus(focused, pointerHeld) {
+  if (pointerHeld) {
+    return false;
+  }
+  if (!(focused instanceof Element)) {
+    return true;
+  }
+  try {
+    return focused.matches(":focus-visible");
+  } catch {
+    return true;
+  }
+}
+var watchers = new WeakMap;
+function supportsInterestInvokers() {
+  return typeof HTMLButtonElement === "function" && "interestForElement" in HTMLButtonElement.prototype;
+}
+function platformOwns(tip, trigger) {
+  return supportsInterestInvokers() && tip.id !== "" && trigger.getAttribute("interestfor") === tip.id;
+}
+function showTip(tip, source) {
+  openAt2(tip, source);
+}
+function hideTip(tip) {
+  close2(tip);
+}
+function bindTooltip(tip, trigger) {
+  if (platformOwns(tip, trigger)) {
+    return () => {};
+  }
+  const root = tip.getRootNode();
+  let showTimer = null;
+  let hideTimer = null;
+  let onTrigger = false;
+  let onTip = false;
+  let focused = false;
+  let pointerHeld = false;
+  let visible = false;
+  const cancel = () => {
+    if (showTimer !== null) {
+      clearTimeout(showTimer);
+      showTimer = null;
+    }
+    if (hideTimer !== null) {
+      clearTimeout(hideTimer);
+      hideTimer = null;
+    }
+  };
+  const show = () => {
+    cancel();
+    visible = true;
+    showTip(tip, trigger);
+  };
+  const hide = () => {
+    visible = false;
+    hideTip(tip);
+  };
+  const hideIfIdle = () => {
+    cancel();
+    if (onTrigger || onTip || focused) {
+      return;
+    }
+    hide();
+  };
+  const showLater = () => {
+    cancel();
+    const delay = Number(tip.delay) || 0;
+    showTimer = setTimeout(show, delay);
+  };
+  const hideLater = () => {
+    cancel();
+    hideTimer = setTimeout(hideIfIdle, TOOLTIP_HIDE_GRACE_MS);
+  };
+  const onPointerEnter = () => {
+    onTrigger = true;
+    showLater();
+  };
+  const onPointerLeave = () => {
+    onTrigger = false;
+    pointerHeld = false;
+    hideLater();
+  };
+  const onPointerDown = () => {
+    pointerHeld = true;
+  };
+  const onPointerUp = () => {
+    pointerHeld = false;
+  };
+  const onFocusIn = (event) => {
+    const keyboard = keyboardFocus(event.target, pointerHeld);
+    pointerHeld = false;
+    if (!keyboard) {
+      return;
+    }
+    focused = true;
+    show();
+  };
+  const onFocusOut = () => {
+    focused = false;
+    hideIfIdle();
+  };
+  const onTipEnter = () => {
+    onTip = true;
+    cancel();
+  };
+  const onTipLeave = () => {
+    onTip = false;
+    hideLater();
+  };
+  const onEscape = () => {
+    if (!visible && !popoverOpen(tip)) {
+      return;
+    }
+    cancel();
+    hide();
+  };
+  const listeners = [
+    [trigger, "pointerenter", onPointerEnter],
+    [trigger, "pointerleave", onPointerLeave],
+    [trigger, "pointerdown", onPointerDown],
+    [trigger, "pointerup", onPointerUp],
+    [trigger, "focusin", onFocusIn],
+    [trigger, "focusout", onFocusOut],
+    [tip, "pointerenter", onTipEnter],
+    [tip, "pointerleave", onTipLeave]
+  ];
+  for (const [target, type, listener] of listeners) {
+    target.addEventListener(type, listener, true);
+  }
+  const unwatch = watchEscape(root, onEscape);
+  return () => {
+    cancel();
+    unwatch();
+    for (const [target, type, listener] of listeners) {
+      target.removeEventListener(type, listener, true);
+    }
+  };
+}
+function triggerOf(state, tip) {
+  const root = tip.getRootNode();
+  const named = typeof state["for"] === "string" ? state["for"] : "";
+  const byFor = named === "" ? null : root.getElementById?.(named) ?? null;
+  if (byFor) {
+    return byFor;
+  }
+  const own = tip.id;
+  if (!/^[\w-]+$/.test(own)) {
+    return null;
+  }
+  return root.querySelector(`[interestfor="${own}"]`);
+}
+function anchorOf(state, tip) {
+  const wired = triggerOf(state, tip);
+  if (wired) {
+    return wired;
+  }
+  const root = tip.getRootNode();
+  const own = tip.id;
+  if (!/^[\w-]+$/.test(own)) {
+    return null;
+  }
+  return root.querySelector(`[aria-describedby~="${own}"]`);
+}
+function placeTooltip(state, tip) {
+  const anchor = anchorOf(state, tip);
+  if (!anchor) {
+    return;
+  }
+  const box = anchor.getBoundingClientRect();
+  if (box.width === 0 && box.height === 0) {
+    return;
+  }
+  state.x = Math.round(box.left);
+  state.y = Math.round(box.bottom + TOOLTIP_OFFSET);
+  state.flipped = false;
+  const measure = () => {
+    const own = tip.getBoundingClientRect();
+    if (own.width === 0 && own.height === 0) {
+      return;
+    }
+    if (own.right > window.innerWidth - MARGIN) {
+      state.x = Math.max(MARGIN, Math.round(window.innerWidth - own.width - MARGIN));
+    }
+    if (own.bottom > window.innerHeight - MARGIN) {
+      state.y = Math.max(MARGIN, Math.round(box.top - own.height - TOOLTIP_OFFSET));
+      state.flipped = true;
+    }
+  };
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(measure);
+  } else {
+    measure();
+  }
+}
+function measureAnchoredFlip(state, tip) {
+  watchers.get(state)?.();
+  const anchor = anchorOf(state, tip);
+  const measure = () => {
+    if (!anchor || state.anchored !== true) {
+      return;
+    }
+    const own = tip.getBoundingClientRect();
+    const box = anchor.getBoundingClientRect();
+    if (own.width === 0 && own.height === 0) {
+      return;
+    }
+    state.flipped = own.bottom <= box.top;
+  };
+  if (!anchor || typeof requestAnimationFrame !== "function") {
+    measure();
+    return () => {};
+  }
+  let frame = null;
+  const run = () => {
+    frame = null;
+    measure();
+  };
+  const schedule = () => {
+    if (frame === null) {
+      frame = requestAnimationFrame(run);
+    }
+  };
+  window.addEventListener("scroll", schedule, { capture: true, passive: true });
+  window.addEventListener("resize", schedule);
+  const observer = typeof ResizeObserver === "function" ? new ResizeObserver(schedule) : null;
+  if (observer) {
+    observer.observe(tip);
+    observer.observe(anchor);
+  }
+  const stop = () => {
+    if (frame !== null) {
+      cancelAnimationFrame(frame);
+      frame = null;
+    }
+    window.removeEventListener("scroll", schedule, { capture: true });
+    window.removeEventListener("resize", schedule);
+    observer?.disconnect();
+    if (watchers.get(state) === stop) {
+      watchers.delete(state);
+    }
+  };
+  watchers.set(state, stop);
+  schedule();
+  return stop;
+}
+function onTooltipBeforeToggle(state, event) {
+  const tip = event.currentTarget;
+  if (!(tip instanceof HTMLElement)) {
+    return;
+  }
+  const opening = event.newState === "open";
+  const { source } = event;
+  const from = source instanceof Element ? source : anchorOf(state, tip);
+  state.anchored = opening && from !== null;
+  if (!opening) {
+    state.flipped = false;
+  }
+}
+function onTooltipToggle(state, event) {
+  const tip = event.currentTarget;
+  if (!(tip instanceof HTMLElement)) {
+    return;
+  }
+  const opening = event.newState === "open";
+  state.open = opening;
+  if (!opening) {
+    watchers.get(state)?.();
+    return;
+  }
+  if (state.anchored === true && supportsAnchorPositioning2()) {
+    measureAnchoredFlip(state, tip);
+  } else {
+    placeTooltip(state, tip);
+  }
+}
+function onTooltipReady(state, event) {
+  const tip = event.currentTarget;
+  if (!(tip instanceof HTMLElement)) {
+    return;
+  }
+  const trigger = triggerOf(state, tip);
+  if (!trigger) {
+    return;
+  }
+  bindings.get(state)?.dispose();
+  bindings.set(state, { dispose: bindTooltip(tip, trigger), tip });
+}
+function onTooltipUnmount(state) {
+  watchers.get(state)?.();
+  const bound = bindings.get(state);
+  if (!bound) {
+    return;
+  }
+  queueMicrotask(() => {
+    if (bindings.get(state) !== bound) {
+      return;
+    }
+    if (bound.tip.isConnected) {
+      return;
+    }
+    bound.dispose();
+    bindings.delete(state);
+  });
+}
+var mintedHints = 0;
+function mintHintId(state, host) {
+  mintedHints += 1;
+  state["uid"] = `${host.localName}-${mintedHints}`;
+}
+export {
+  TOOLTIP_HIDE_GRACE_MS,
+  bindTooltip,
+  measureAnchoredFlip,
+  mintHintId,
+  onTooltipBeforeToggle,
+  onTooltipReady,
+  onTooltipToggle,
+  onTooltipUnmount,
+  placeTooltip,
+  supportsInterestInvokers
+};
+
+//# debugId=8F5E86EC32194E2D64756E2164756E21
+//# sourceMappingURL=tooltip-eptb614w.js.map