@devmotion/cli 0.7.0 → 0.8.0

package/studio/server/chunks/tooltip-provider-D6ZF3H34.js

@@ -0,0 +1,30 @@
+import './async-lVJA8xJZ.js';
+import { T as TooltipProviderState } from './tooltip.svelte-DRe72lD-.js';
+import { b as boxWith } from './input-C1z0Nn4U.js';
+
+function Tooltip_provider($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      children,
+      delayDuration = 700,
+      disableCloseOnTriggerClick = false,
+      disableHoverableContent = false,
+      disabled = false,
+      ignoreNonKeyboardFocus = false,
+      skipDelayDuration = 300
+    } = $$props;
+    TooltipProviderState.create({
+      delayDuration: boxWith(() => delayDuration),
+      disableCloseOnTriggerClick: boxWith(() => disableCloseOnTriggerClick),
+      disableHoverableContent: boxWith(() => disableHoverableContent),
+      disabled: boxWith(() => disabled),
+      ignoreNonKeyboardFocus: boxWith(() => ignoreNonKeyboardFocus),
+      skipDelayDuration: boxWith(() => skipDelayDuration)
+    });
+    children?.($$renderer2);
+    $$renderer2.push(`<!---->`);
+  });
+}
+
+export { Tooltip_provider as T };
+//# sourceMappingURL=tooltip-provider-D6ZF3H34.js.map

package/studio/server/chunks/tooltip-provider-D6ZF3H34.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-provider-D6ZF3H34.js","sources":["../../../.svelte-kit/adapter-node/chunks/tooltip-provider.js"],"sourcesContent":["import \"./async.js\";\nimport \"clsx\";\nimport { T as TooltipProviderState } from \"./tooltip.svelte.js\";\nimport { b as boxWith } from \"./input.js\";\nfunction Tooltip_provider($$renderer, $$props) {\n  $$renderer.component(($$renderer2) => {\n    let {\n      children,\n      delayDuration = 700,\n      disableCloseOnTriggerClick = false,\n      disableHoverableContent = false,\n      disabled = false,\n      ignoreNonKeyboardFocus = false,\n      skipDelayDuration = 300\n    } = $$props;\n    TooltipProviderState.create({\n      delayDuration: boxWith(() => delayDuration),\n      disableCloseOnTriggerClick: boxWith(() => disableCloseOnTriggerClick),\n      disableHoverableContent: boxWith(() => disableHoverableContent),\n      disabled: boxWith(() => disabled),\n      ignoreNonKeyboardFocus: boxWith(() => ignoreNonKeyboardFocus),\n      skipDelayDuration: boxWith(() => skipDelayDuration)\n    });\n    children?.($$renderer2);\n    $$renderer2.push(`<!---->`);\n  });\n}\nexport {\n  Tooltip_provider as T\n};\n"],"names":[],"mappings":";;;;AAIA,SAAS,gBAAgB,CAAC,UAAU,EAAE,OAAO,EAAE;AAC/C,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,WAAW,KAAK;AACxC,IAAI,IAAI;AACR,MAAM,QAAQ;AACd,MAAM,aAAa,GAAG,GAAG;AACzB,MAAM,0BAA0B,GAAG,KAAK;AACxC,MAAM,uBAAuB,GAAG,KAAK;AACrC,MAAM,QAAQ,GAAG,KAAK;AACtB,MAAM,sBAAsB,GAAG,KAAK;AACpC,MAAM,iBAAiB,GAAG;AAC1B,KAAK,GAAG,OAAO;AACf,IAAI,oBAAoB,CAAC,MAAM,CAAC;AAChC,MAAM,aAAa,EAAE,OAAO,CAAC,MAAM,aAAa,CAAC;AACjD,MAAM,0BAA0B,EAAE,OAAO,CAAC,MAAM,0BAA0B,CAAC;AAC3E,MAAM,uBAAuB,EAAE,OAAO,CAAC,MAAM,uBAAuB,CAAC;AACrE,MAAM,QAAQ,EAAE,OAAO,CAAC,MAAM,QAAQ,CAAC;AACvC,MAAM,sBAAsB,EAAE,OAAO,CAAC,MAAM,sBAAsB,CAAC;AACnE,MAAM,iBAAiB,EAAE,OAAO,CAAC,MAAM,iBAAiB;AACxD,KAAK,CAAC;AACN,IAAI,QAAQ,GAAG,WAAW,CAAC;AAC3B,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;AAC/B,EAAE,CAAC,CAAC;AACJ;;;;"}

package/studio/server/chunks/tooltip.svelte-DRe72lD-.js

@@ -0,0 +1,658 @@
+import { h as derived } from './index9-D9BBZH26.js';
+import { C as Context, w as watch, D as DOMContext } from './copy-gHAQZ-hc.js';
+import { P as PresenceManager, i as isElement$1, a as isFocusVisible, S as SafePolygon } from './editor.svelte-Bdv5LaOt.js';
+import { s as simpleBox, c as createBitsAttrs, b as boxWith, a as attachRef, d as boolToEmptyStrOrUndef } from './input-C1z0Nn4U.js';
+
+function onDestroyEffect(fn) {
+}
+class TimeoutFn {
+  #interval;
+  #cb;
+  #timer = null;
+  constructor(cb, interval) {
+    this.#cb = cb;
+    this.#interval = interval;
+    this.stop = this.stop.bind(this);
+    this.start = this.start.bind(this);
+    onDestroyEffect(this.stop);
+  }
+  #clear() {
+    if (this.#timer !== null) {
+      window.clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+  }
+  stop() {
+    this.#clear();
+  }
+  start(...args) {
+    this.#clear();
+    this.#timer = window.setTimeout(() => {
+      this.#timer = null;
+      this.#cb(...args);
+    }, this.#interval);
+  }
+}
+const tooltipAttrs = createBitsAttrs({ component: "tooltip", parts: ["content", "trigger"] });
+const TooltipProviderContext = new Context("Tooltip.Provider");
+const TooltipRootContext = new Context("Tooltip.Root");
+class TooltipTriggerRegistryState {
+  triggers = /* @__PURE__ */ new Map();
+  activeTriggerId = null;
+  #activeTriggerNode = derived(() => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return null;
+    return this.triggers.get(activeTriggerId)?.node ?? null;
+  });
+  get activeTriggerNode() {
+    return this.#activeTriggerNode();
+  }
+  set activeTriggerNode($$value) {
+    return this.#activeTriggerNode($$value);
+  }
+  #activePayload = derived(() => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return null;
+    return this.triggers.get(activeTriggerId)?.payload ?? null;
+  });
+  get activePayload() {
+    return this.#activePayload();
+  }
+  set activePayload($$value) {
+    return this.#activePayload($$value);
+  }
+  register = (record) => {
+    const next = new Map(this.triggers);
+    next.set(record.id, record);
+    this.triggers = next;
+    this.#coerceActiveTrigger();
+  };
+  update = (record) => {
+    const next = new Map(this.triggers);
+    next.set(record.id, record);
+    this.triggers = next;
+    this.#coerceActiveTrigger();
+  };
+  unregister = (id) => {
+    if (!this.triggers.has(id)) return;
+    const next = new Map(this.triggers);
+    next.delete(id);
+    this.triggers = next;
+    if (this.activeTriggerId === id) {
+      this.activeTriggerId = null;
+    }
+  };
+  setActiveTrigger = (id) => {
+    if (id === null) {
+      this.activeTriggerId = null;
+      return;
+    }
+    if (!this.triggers.has(id)) {
+      this.activeTriggerId = null;
+      return;
+    }
+    this.activeTriggerId = id;
+  };
+  get = (id) => {
+    return this.triggers.get(id);
+  };
+  has = (id) => {
+    return this.triggers.has(id);
+  };
+  getFirstTriggerId = () => {
+    const firstEntry = this.triggers.entries().next();
+    if (firstEntry.done) return null;
+    return firstEntry.value[0];
+  };
+  #coerceActiveTrigger = () => {
+    const activeTriggerId = this.activeTriggerId;
+    if (activeTriggerId === null) return;
+    if (!this.triggers.has(activeTriggerId)) {
+      this.activeTriggerId = null;
+    }
+  };
+}
+class TooltipProviderState {
+  static create(opts) {
+    return TooltipProviderContext.set(new TooltipProviderState(opts));
+  }
+  opts;
+  isOpenDelayed = true;
+  isPointerInTransit = simpleBox(false);
+  #timerFn;
+  #openTooltip = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.#timerFn = new TimeoutFn(
+      () => {
+        this.isOpenDelayed = true;
+      },
+      this.opts.skipDelayDuration.current
+    );
+  }
+  #startTimer = () => {
+    const skipDuration = this.opts.skipDelayDuration.current;
+    if (skipDuration === 0) {
+      this.isOpenDelayed = true;
+      return;
+    } else {
+      this.#timerFn.start();
+    }
+  };
+  #clearTimer = () => {
+    this.#timerFn.stop();
+  };
+  onOpen = (tooltip) => {
+    if (this.#openTooltip && this.#openTooltip !== tooltip) {
+      this.#openTooltip.handleClose();
+    }
+    this.#clearTimer();
+    this.isOpenDelayed = false;
+    this.#openTooltip = tooltip;
+  };
+  onClose = (tooltip) => {
+    if (this.#openTooltip === tooltip) {
+      this.#openTooltip = null;
+    }
+    this.#startTimer();
+  };
+  isTooltipOpen = (tooltip) => {
+    return this.#openTooltip === tooltip;
+  };
+}
+class TooltipRootState {
+  static create(opts) {
+    return TooltipRootContext.set(new TooltipRootState(opts, TooltipProviderContext.get()));
+  }
+  opts;
+  provider;
+  #delayDuration = derived(() => this.opts.delayDuration.current ?? this.provider.opts.delayDuration.current);
+  get delayDuration() {
+    return this.#delayDuration();
+  }
+  set delayDuration($$value) {
+    return this.#delayDuration($$value);
+  }
+  #disableHoverableContent = derived(() => this.opts.disableHoverableContent.current ?? this.provider.opts.disableHoverableContent.current);
+  get disableHoverableContent() {
+    return this.#disableHoverableContent();
+  }
+  set disableHoverableContent($$value) {
+    return this.#disableHoverableContent($$value);
+  }
+  #disableCloseOnTriggerClick = derived(() => this.opts.disableCloseOnTriggerClick.current ?? this.provider.opts.disableCloseOnTriggerClick.current);
+  get disableCloseOnTriggerClick() {
+    return this.#disableCloseOnTriggerClick();
+  }
+  set disableCloseOnTriggerClick($$value) {
+    return this.#disableCloseOnTriggerClick($$value);
+  }
+  #disabled = derived(() => this.opts.disabled.current ?? this.provider.opts.disabled.current);
+  get disabled() {
+    return this.#disabled();
+  }
+  set disabled($$value) {
+    return this.#disabled($$value);
+  }
+  #ignoreNonKeyboardFocus = derived(() => this.opts.ignoreNonKeyboardFocus.current ?? this.provider.opts.ignoreNonKeyboardFocus.current);
+  get ignoreNonKeyboardFocus() {
+    return this.#ignoreNonKeyboardFocus();
+  }
+  set ignoreNonKeyboardFocus($$value) {
+    return this.#ignoreNonKeyboardFocus($$value);
+  }
+  registry;
+  tether;
+  contentNode = null;
+  contentPresence;
+  #wasOpenDelayed = false;
+  #timerFn;
+  #stateAttr = derived(() => {
+    if (!this.opts.open.current) return "closed";
+    return this.#wasOpenDelayed ? "delayed-open" : "instant-open";
+  });
+  get stateAttr() {
+    return this.#stateAttr();
+  }
+  set stateAttr($$value) {
+    return this.#stateAttr($$value);
+  }
+  constructor(opts, provider) {
+    this.opts = opts;
+    this.provider = provider;
+    this.tether = opts.tether.current?.state ?? null;
+    this.registry = this.tether?.registry ?? new TooltipTriggerRegistryState();
+    this.#timerFn = new TimeoutFn(
+      () => {
+        this.#wasOpenDelayed = true;
+        this.opts.open.current = true;
+      },
+      this.delayDuration ?? 0
+    );
+    if (this.tether) {
+      this.tether.root = this;
+    }
+    this.contentPresence = new PresenceManager({
+      open: this.opts.open,
+      ref: boxWith(() => this.contentNode),
+      onComplete: () => {
+        this.opts.onOpenChangeComplete.current(this.opts.open.current);
+      }
+    });
+    watch(() => this.delayDuration, () => {
+      if (this.delayDuration === void 0) return;
+      this.#timerFn = new TimeoutFn(
+        () => {
+          this.#wasOpenDelayed = true;
+          this.opts.open.current = true;
+        },
+        this.delayDuration
+      );
+    });
+    watch(
+      () => this.opts.open.current,
+      (isOpen) => {
+        if (isOpen) {
+          this.ensureActiveTrigger();
+          this.provider.onOpen(this);
+        } else {
+          this.provider.onClose(this);
+        }
+      },
+      { lazy: true }
+    );
+    watch(() => this.opts.triggerId.current, (triggerId) => {
+      if (triggerId === this.registry.activeTriggerId) return;
+      this.registry.setActiveTrigger(triggerId);
+    });
+    watch(() => this.registry.activeTriggerId, (activeTriggerId) => {
+      if (this.opts.triggerId.current === activeTriggerId) return;
+      this.opts.triggerId.current = activeTriggerId;
+    });
+  }
+  handleOpen = () => {
+    this.#timerFn.stop();
+    this.#wasOpenDelayed = false;
+    this.ensureActiveTrigger();
+    this.opts.open.current = true;
+  };
+  handleClose = () => {
+    this.#timerFn.stop();
+    this.opts.open.current = false;
+  };
+  #handleDelayedOpen = () => {
+    this.#timerFn.stop();
+    const shouldSkipDelay = !this.provider.isOpenDelayed;
+    const delayDuration = this.delayDuration ?? 0;
+    if (shouldSkipDelay || delayDuration === 0) {
+      this.#wasOpenDelayed = false;
+      this.opts.open.current = true;
+    } else {
+      this.#timerFn.start();
+    }
+  };
+  onTriggerEnter = (triggerId) => {
+    this.setActiveTrigger(triggerId);
+    this.#handleDelayedOpen();
+  };
+  onTriggerLeave = () => {
+    if (this.disableHoverableContent) {
+      this.handleClose();
+    } else {
+      this.#timerFn.stop();
+    }
+  };
+  ensureActiveTrigger = () => {
+    if (this.registry.activeTriggerId !== null && this.registry.has(this.registry.activeTriggerId)) {
+      return;
+    }
+    if (this.opts.triggerId.current !== null && this.registry.has(this.opts.triggerId.current)) {
+      this.registry.setActiveTrigger(this.opts.triggerId.current);
+      return;
+    }
+    const firstTriggerId = this.registry.getFirstTriggerId();
+    this.registry.setActiveTrigger(firstTriggerId);
+  };
+  setActiveTrigger = (triggerId) => {
+    this.registry.setActiveTrigger(triggerId);
+  };
+  registerTrigger = (trigger) => {
+    this.registry.register(trigger);
+    if (trigger.disabled && this.registry.activeTriggerId === trigger.id && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  updateTrigger = (trigger) => {
+    this.registry.update(trigger);
+    if (trigger.disabled && this.registry.activeTriggerId === trigger.id && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  unregisterTrigger = (id) => {
+    const isActive = this.registry.activeTriggerId === id;
+    this.registry.unregister(id);
+    if (isActive && this.opts.open.current) {
+      this.handleClose();
+    }
+  };
+  isActiveTrigger = (triggerId) => {
+    return this.registry.activeTriggerId === triggerId;
+  };
+  get triggerNode() {
+    return this.registry.activeTriggerNode;
+  }
+  get activePayload() {
+    return this.registry.activePayload;
+  }
+  get activeTriggerId() {
+    return this.registry.activeTriggerId;
+  }
+}
+class TooltipTriggerState {
+  static create(opts) {
+    if (opts.tether.current) {
+      return new TooltipTriggerState(opts, null, opts.tether.current.state);
+    }
+    return new TooltipTriggerState(opts, TooltipRootContext.get(), null);
+  }
+  opts;
+  root;
+  tether;
+  attachment;
+  #isPointerDown = simpleBox(false);
+  #hasPointerMoveOpened = false;
+  domContext;
+  #transitCheckTimeout = null;
+  #mounted = false;
+  #lastRegisteredId = null;
+  constructor(opts, root, tether) {
+    this.opts = opts;
+    this.root = root;
+    this.tether = tether;
+    this.domContext = new DOMContext(opts.ref);
+    this.attachment = attachRef(this.opts.ref, (v) => this.#register(v));
+    watch(() => this.opts.id.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+    watch(() => this.opts.payload.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+    watch(() => this.opts.disabled.current, () => {
+      this.#register(this.opts.ref.current);
+    });
+  }
+  #getRoot = () => {
+    return this.tether?.root ?? this.root;
+  };
+  #isDisabled = () => {
+    const root = this.#getRoot();
+    return this.opts.disabled.current || Boolean(root?.disabled);
+  };
+  #register = (node) => {
+    if (!this.#mounted) return;
+    const id = this.opts.id.current;
+    const payload = this.opts.payload.current;
+    const disabled = this.opts.disabled.current;
+    if (this.#lastRegisteredId && this.#lastRegisteredId !== id) {
+      const root2 = this.#getRoot();
+      if (this.tether) {
+        this.tether.registry.unregister(this.#lastRegisteredId);
+      } else {
+        root2?.unregisterTrigger(this.#lastRegisteredId);
+      }
+    }
+    const triggerRecord = { id, node, payload, disabled };
+    const root = this.#getRoot();
+    if (this.tether) {
+      if (this.tether.registry.has(id)) {
+        this.tether.registry.update(triggerRecord);
+      } else {
+        this.tether.registry.register(triggerRecord);
+      }
+      if (disabled && this.tether.registry.activeTriggerId === id && root?.opts.open.current) {
+        root.handleClose();
+      }
+    } else {
+      if (root?.registry.has(id)) {
+        root.updateTrigger(triggerRecord);
+      } else {
+        root?.registerTrigger(triggerRecord);
+      }
+    }
+    this.#lastRegisteredId = id;
+  };
+  #clearTransitCheck = () => {
+    if (this.#transitCheckTimeout !== null) {
+      clearTimeout(this.#transitCheckTimeout);
+      this.#transitCheckTimeout = null;
+    }
+  };
+  handlePointerUp = () => {
+    this.#isPointerDown.current = false;
+  };
+  #onpointerup = () => {
+    if (this.#isDisabled()) return;
+    this.#isPointerDown.current = false;
+  };
+  #onpointerdown = () => {
+    if (this.#isDisabled()) return;
+    this.#isPointerDown.current = true;
+    this.domContext.getDocument().addEventListener(
+      "pointerup",
+      () => {
+        this.handlePointerUp();
+      },
+      { once: true }
+    );
+  };
+  #onpointerenter = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (e.pointerType === "touch") return;
+    if (root.provider.isPointerInTransit.current) {
+      this.#clearTransitCheck();
+      this.#transitCheckTimeout = window.setTimeout(
+        () => {
+          if (root.provider.isPointerInTransit.current) {
+            root.provider.isPointerInTransit.current = false;
+            root.onTriggerEnter(this.opts.id.current);
+            this.#hasPointerMoveOpened = true;
+          }
+        },
+        250
+      );
+      return;
+    }
+    root.onTriggerEnter(this.opts.id.current);
+    this.#hasPointerMoveOpened = true;
+  };
+  #onpointermove = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (e.pointerType === "touch") return;
+    if (this.#hasPointerMoveOpened) return;
+    this.#clearTransitCheck();
+    root.provider.isPointerInTransit.current = false;
+    root.onTriggerEnter(this.opts.id.current);
+    this.#hasPointerMoveOpened = true;
+  };
+  #onpointerleave = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isDisabled()) return;
+    this.#clearTransitCheck();
+    if (!root.isActiveTrigger(this.opts.id.current)) {
+      this.#hasPointerMoveOpened = false;
+      return;
+    }
+    const relatedTarget = e.relatedTarget;
+    if (isElement$1(relatedTarget)) {
+      for (const record of root.registry.triggers.values()) {
+        if (record.node !== relatedTarget) continue;
+        if (root.provider.opts.skipDelayDuration.current > 0) {
+          this.#hasPointerMoveOpened = false;
+          return;
+        }
+        root.handleClose();
+        this.#hasPointerMoveOpened = false;
+        return;
+      }
+    }
+    root.onTriggerLeave();
+    this.#hasPointerMoveOpened = false;
+  };
+  #onfocus = (e) => {
+    const root = this.#getRoot();
+    if (!root) return;
+    if (this.#isPointerDown.current) return;
+    if (this.#isDisabled()) {
+      if (root.opts.open.current) {
+        root.handleClose();
+      }
+      return;
+    }
+    if (root.ignoreNonKeyboardFocus && !isFocusVisible(e.currentTarget)) return;
+    root.setActiveTrigger(this.opts.id.current);
+    root.handleOpen();
+  };
+  #onblur = () => {
+    const root = this.#getRoot();
+    if (!root || this.#isDisabled()) return;
+    root.handleClose();
+  };
+  #onclick = () => {
+    const root = this.#getRoot();
+    if (!root || root.disableCloseOnTriggerClick || this.#isDisabled()) return;
+    root.handleClose();
+  };
+  #props = derived(() => {
+    const root = this.#getRoot();
+    const isOpenForTrigger = Boolean(root?.opts.open.current && root.isActiveTrigger(this.opts.id.current));
+    const isDisabled = this.#isDisabled();
+    return {
+      id: this.opts.id.current,
+      "aria-describedby": isOpenForTrigger ? root?.contentNode?.id : void 0,
+      "data-state": isOpenForTrigger ? root?.stateAttr : "closed",
+      "data-disabled": boolToEmptyStrOrUndef(isDisabled),
+      "data-delay-duration": `${root?.delayDuration ?? 0}`,
+      [tooltipAttrs.trigger]: "",
+      tabindex: isDisabled ? void 0 : this.opts.tabindex.current,
+      disabled: this.opts.disabled.current,
+      onpointerup: this.#onpointerup,
+      onpointerdown: this.#onpointerdown,
+      onpointerenter: this.#onpointerenter,
+      onpointermove: this.#onpointermove,
+      onpointerleave: this.#onpointerleave,
+      onfocus: this.#onfocus,
+      onblur: this.#onblur,
+      onclick: this.#onclick,
+      ...this.attachment
+    };
+  });
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+}
+class TooltipContentState {
+  static create(opts) {
+    return new TooltipContentState(opts, TooltipRootContext.get());
+  }
+  opts;
+  root;
+  attachment;
+  constructor(opts, root) {
+    this.opts = opts;
+    this.root = root;
+    this.attachment = attachRef(this.opts.ref, (v) => this.root.contentNode = v);
+    new SafePolygon({
+      triggerNode: () => this.root.triggerNode,
+      contentNode: () => this.root.contentNode,
+      enabled: () => this.root.opts.open.current && !this.root.disableHoverableContent,
+      transitIntentTimeout: 180,
+      ignoredTargets: () => {
+        if (this.root.provider.opts.skipDelayDuration.current === 0) return [];
+        const nodes = [];
+        const activeTriggerNode = this.root.triggerNode;
+        for (const record of this.root.registry.triggers.values()) {
+          if (record.node && record.node !== activeTriggerNode) {
+            nodes.push(record.node);
+          }
+        }
+        return nodes;
+      },
+      onPointerExit: () => {
+        if (this.root.provider.isTooltipOpen(this.root)) {
+          this.root.handleClose();
+        }
+      }
+    });
+  }
+  onInteractOutside = (e) => {
+    if (isElement$1(e.target) && this.root.triggerNode?.contains(e.target) && this.root.disableCloseOnTriggerClick) {
+      e.preventDefault();
+      return;
+    }
+    this.opts.onInteractOutside.current(e);
+    if (e.defaultPrevented) return;
+    this.root.handleClose();
+  };
+  onEscapeKeydown = (e) => {
+    this.opts.onEscapeKeydown.current?.(e);
+    if (e.defaultPrevented) return;
+    this.root.handleClose();
+  };
+  onOpenAutoFocus = (e) => {
+    e.preventDefault();
+  };
+  onCloseAutoFocus = (e) => {
+    e.preventDefault();
+  };
+  get shouldRender() {
+    return this.root.contentPresence.shouldRender;
+  }
+  #snippetProps = derived(() => ({ open: this.root.opts.open.current }));
+  get snippetProps() {
+    return this.#snippetProps();
+  }
+  set snippetProps($$value) {
+    return this.#snippetProps($$value);
+  }
+  #props = derived(() => ({
+    id: this.opts.id.current,
+    "data-state": this.root.stateAttr,
+    "data-disabled": boolToEmptyStrOrUndef(this.root.disabled),
+    style: { outline: "none" },
+    [tooltipAttrs.content]: "",
+    ...this.attachment
+  }));
+  get props() {
+    return this.#props();
+  }
+  set props($$value) {
+    return this.#props($$value);
+  }
+  popperProps = {
+    onInteractOutside: this.onInteractOutside,
+    onEscapeKeydown: this.onEscapeKeydown,
+    onOpenAutoFocus: this.onOpenAutoFocus,
+    onCloseAutoFocus: this.onCloseAutoFocus
+  };
+}
+
+export { TooltipProviderState as T, TooltipRootState as a, TooltipTriggerState as b, TooltipContentState as c };
+//# sourceMappingURL=tooltip.svelte-DRe72lD-.js.map