@runtypelabs/persona 4.14.0 → 4.16.0

package/src/components/launcher-surface.test.ts

@@ -0,0 +1,403 @@
+// @vitest-environment jsdom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createLauncherSurface } from "./launcher";
+import type {
+  AgentWidgetConfig,
+  AgentWidgetLauncherTeaserConfig,
+} from "../types";
+
+/**
+ * Every case uses its own `keyPrefix`: the consumed-teaser set is module-level
+ * (it is the page-load memory), so a shared key would leak between tests.
+ */
+let keyCounter = 0;
+const nextPrefix = () => `teaser-test-${++keyCounter}-`;
+
+const configWith = (
+  prefix: string,
+  teaser: AgentWidgetLauncherTeaserConfig
+): AgentWidgetConfig => ({
+  persistState: { keyPrefix: prefix },
+  launcher: { teaser },
+});
+
+describe("createLauncherSurface", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    window.localStorage.clear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    document.body.replaceChildren();
+  });
+
+  it("stays a display:contents passthrough when no teaser is configured", () => {
+    const surface = createLauncherSurface({ launcher: {} }, () => {});
+    document.body.appendChild(surface.element);
+
+    expect(surface.teaser).toBeNull();
+    expect(surface.element.getAttribute("data-teaser")).toBeNull();
+    expect(surface.element.className).toBe("persona-launcher-surface");
+    expect(surface.element.firstElementChild).toBe(surface.launcher.element);
+    expect(surface.launcher.element.style.position).toBe("");
+    surface.destroy();
+  });
+
+  it("renders the teaser as a sibling of the launcher with its own dismiss button", () => {
+    const prefix = nextPrefix();
+    const surface = createLauncherSurface(
+      configWith(prefix, { text: "Need a hand?" }),
+      () => {}
+    );
+    document.body.appendChild(surface.element);
+    vi.advanceTimersByTime(0);
+
+    const teaser = surface.teaser;
+    expect(teaser).not.toBeNull();
+    expect(teaser?.element.parentElement).toBe(surface.element);
+    expect(teaser?.element.getAttribute("aria-live")).toBe("polite");
+    expect(teaser?.element.hidden).toBe(false);
+
+    const buttons = teaser?.element.querySelectorAll("button") ?? [];
+    expect(buttons.length).toBe(2);
+    // Nested interactive elements are invalid HTML: both controls are siblings.
+    expect(buttons[1].closest("button")).toBe(buttons[1]);
+    expect(buttons[0].textContent).toBe("Need a hand?");
+
+    expect(surface.element.getAttribute("data-teaser")).toBe("bottom-right");
+    expect(surface.launcher.element.style.position).toBe("static");
+    surface.destroy();
+  });
+
+  it("honors delayMs before showing", () => {
+    const prefix = nextPrefix();
+    const surface = createLauncherSurface(
+      configWith(prefix, { text: "Hi there", delayMs: 3000 }),
+      () => {}
+    );
+    expect(surface.teaser?.element.hidden).toBe(true);
+    vi.advanceTimersByTime(2999);
+    expect(surface.teaser?.element.hidden).toBe(true);
+    vi.advanceTimersByTime(1);
+    expect(surface.teaser?.element.hidden).toBe(false);
+    surface.destroy();
+  });
+
+  it("hides the dismiss affordance when dismissible is false", () => {
+    const prefix = nextPrefix();
+    const surface = createLauncherSurface(
+      configWith(prefix, { text: "Hi there", dismissible: false }),
+      () => {}
+    );
+    const dismiss = surface.teaser?.element.querySelectorAll("button")[1];
+    expect(dismiss?.hidden).toBe(true);
+    surface.destroy();
+  });
+
+  describe("consumption rules", () => {
+    it("click-through opens the panel and persists under the default frequency", () => {
+      const prefix = nextPrefix();
+      const onToggle = vi.fn();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        onToggle
+      );
+      vi.advanceTimersByTime(0);
+
+      surface.teaser?.element.querySelector("button")?.click();
+
+      expect(onToggle).toHaveBeenCalledTimes(1);
+      expect(surface.teaser?.element.hidden).toBe(true);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBe("1");
+      surface.destroy();
+    });
+
+    it("dismissal persists without opening the panel", () => {
+      const prefix = nextPrefix();
+      const onToggle = vi.fn();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        onToggle
+      );
+      vi.advanceTimersByTime(0);
+
+      const buttons = surface.teaser?.element.querySelectorAll("button");
+      buttons?.[1].click();
+
+      expect(onToggle).not.toHaveBeenCalled();
+      expect(surface.teaser?.element.hidden).toBe(true);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBe("1");
+      surface.destroy();
+    });
+
+    it("a launcher click consumes the visible teaser too", () => {
+      const prefix = nextPrefix();
+      const onToggle = vi.fn();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        onToggle
+      );
+      vi.advanceTimersByTime(0);
+
+      surface.launcher.element.click();
+
+      expect(onToggle).toHaveBeenCalledTimes(1);
+      expect(surface.teaser?.element.hidden).toBe(true);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBe("1");
+      surface.destroy();
+    });
+
+    it("does not persist a teaser the user never saw", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there", delayMs: 5000 }),
+        () => {}
+      );
+
+      surface.launcher.element.click();
+      vi.advanceTimersByTime(10000);
+
+      expect(surface.teaser?.element.hidden).toBe(true);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBeNull();
+      surface.destroy();
+    });
+
+    it("suppresses the teaser while the panel is open and never resurrects it", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there", delayMs: 100 }),
+        () => {}
+      );
+
+      surface.setPanelOpen(true);
+      vi.advanceTimersByTime(1000);
+      expect(surface.teaser?.element.hidden).toBe(true);
+
+      surface.setPanelOpen(false);
+      surface.update(configWith(prefix, { text: "Hi there", delayMs: 100 }));
+      vi.advanceTimersByTime(1000);
+      expect(surface.teaser?.element.hidden).toBe(true);
+      surface.destroy();
+    });
+
+    it("does not persist the flag when an automatic open consumes the teaser", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+      expect(surface.teaser?.element.hidden).toBe(false);
+
+      surface.setPanelOpen(true, "auto");
+
+      expect(surface.teaser?.element.hidden).toBe(true);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBeNull();
+      surface.destroy();
+    });
+
+    it("appears at most once per page load under frequency always", () => {
+      const prefix = nextPrefix();
+      const config = configWith(prefix, { text: "Hi there", frequency: "always" });
+
+      const first = createLauncherSurface(config, () => {});
+      vi.advanceTimersByTime(0);
+      first.teaser?.dismiss(false);
+      expect(window.localStorage.getItem(`${prefix}teaser-dismissed`)).toBeNull();
+      first.destroy();
+
+      // Same page load, same key: the in-memory consumption still applies.
+      const second = createLauncherSurface(config, () => {});
+      vi.advanceTimersByTime(0);
+      expect(second.teaser?.element.hidden).toBe(true);
+      second.destroy();
+    });
+
+    it("skips the teaser when the persisted flag is already set", () => {
+      const prefix = nextPrefix();
+      window.localStorage.setItem(`${prefix}teaser-dismissed`, "1");
+
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+      expect(surface.teaser?.element.hidden).toBe(true);
+      surface.destroy();
+    });
+
+    it("ignores a stale persisted flag under frequency always", () => {
+      const prefix = nextPrefix();
+      window.localStorage.setItem(`${prefix}teaser-dismissed`, "1");
+
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there", frequency: "always" }),
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+      expect(surface.teaser?.element.hidden).toBe(false);
+      surface.destroy();
+    });
+
+    it("keeps dismissal in memory when persistState is false", () => {
+      const surface = createLauncherSurface(
+        { persistState: false, launcher: { teaser: { text: "Hi there" } } },
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+      surface.teaser?.dismiss(true);
+
+      expect(window.localStorage.getItem("persona-teaser-dismissed")).toBeNull();
+      expect(surface.teaser?.element.hidden).toBe(true);
+      surface.destroy();
+    });
+  });
+
+  it("falls back to memory when localStorage throws", () => {
+    const prefix = nextPrefix();
+    const getItem = vi
+      .spyOn(Storage.prototype, "getItem")
+      .mockImplementation(() => {
+        throw new Error("blocked");
+      });
+    const setItem = vi
+      .spyOn(Storage.prototype, "setItem")
+      .mockImplementation(() => {
+        throw new Error("blocked");
+      });
+
+    const config = configWith(prefix, { text: "Hi there" });
+    const first = createLauncherSurface(config, () => {});
+    vi.advanceTimersByTime(0);
+    expect(first.teaser?.element.hidden).toBe(false);
+
+    first.teaser?.dismiss(true);
+    expect(first.teaser?.element.hidden).toBe(true);
+    first.destroy();
+
+    const second = createLauncherSurface(config, () => {});
+    vi.advanceTimersByTime(0);
+    expect(second.teaser?.element.hidden).toBe(true);
+    second.destroy();
+
+    expect(getItem).toHaveBeenCalled();
+    expect(setItem).toHaveBeenCalled();
+  });
+
+  describe("live updates", () => {
+    it("adds a teaser configured by a later update()", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface({ launcher: {} }, () => {});
+      expect(surface.teaser).toBeNull();
+
+      surface.update(configWith(prefix, { text: "Added later" }));
+      vi.advanceTimersByTime(0);
+
+      expect(surface.teaser?.element.hidden).toBe(false);
+      expect(surface.teaser?.element.textContent).toContain("Added later");
+      expect(surface.element.getAttribute("data-teaser")).toBe("bottom-right");
+      surface.destroy();
+    });
+
+    it("swaps teaser text in place", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "First" }),
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+      const element = surface.teaser?.element;
+
+      surface.update(configWith(prefix, { text: "Second" }));
+
+      expect(surface.teaser?.element).toBe(element);
+      expect(element?.querySelector("button")?.textContent).toBe("Second");
+      surface.destroy();
+    });
+
+    it("toggles the dismiss affordance", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        () => {}
+      );
+      const dismiss = () =>
+        surface.teaser?.element.querySelectorAll("button")[1];
+      expect(dismiss()?.hidden).toBe(false);
+
+      surface.update(
+        configWith(prefix, { text: "Hi there", dismissible: false })
+      );
+      expect(dismiss()?.hidden).toBe(true);
+
+      surface.update(configWith(prefix, { text: "Hi there", dismissible: true }));
+      expect(dismiss()?.hidden).toBe(false);
+      surface.destroy();
+    });
+
+    it("removes the teaser and restores passthrough placement", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        configWith(prefix, { text: "Hi there" }),
+        () => {}
+      );
+      vi.advanceTimersByTime(0);
+
+      surface.update({ persistState: { keyPrefix: prefix }, launcher: {} });
+
+      expect(surface.teaser).toBeNull();
+      expect(surface.element.getAttribute("data-teaser")).toBeNull();
+      expect(surface.launcher.element.style.position).toBe("");
+      surface.destroy();
+    });
+
+    it("follows launcher.position onto the wrapper", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        {
+          persistState: { keyPrefix: prefix },
+          launcher: { teaser: { text: "Hi there" }, position: "top-left" },
+        },
+        () => {}
+      );
+      expect(surface.element.getAttribute("data-teaser")).toBe("top-left");
+      expect(surface.element.className).toContain("persona-top-6");
+      expect(surface.element.className).toContain("persona-left-6");
+      surface.destroy();
+    });
+
+    it("drops the teaser in docked mount mode", () => {
+      const prefix = nextPrefix();
+      const surface = createLauncherSurface(
+        {
+          persistState: { keyPrefix: prefix },
+          launcher: { teaser: { text: "Hi there" }, mountMode: "docked" },
+        },
+        () => {}
+      );
+      expect(surface.teaser).toBeNull();
+      surface.destroy();
+    });
+  });
+
+  it("clears the pending timer and removes the wrapper on destroy", () => {
+    const prefix = nextPrefix();
+    const surface = createLauncherSurface(
+      configWith(prefix, { text: "Hi there", delayMs: 5000 }),
+      () => {}
+    );
+    document.body.appendChild(surface.element);
+    const teaserElement = surface.teaser?.element;
+
+    surface.destroy();
+    vi.advanceTimersByTime(10000);
+
+    expect(vi.getTimerCount()).toBe(0);
+    expect(teaserElement?.hidden).toBe(true);
+    expect(surface.element.parentElement).toBeNull();
+    expect(document.body.children.length).toBe(0);
+  });
+});

package/src/components/launcher.ts

@@ -1,5 +1,5 @@
-import { createElement } from "../utils/dom";
-import { AgentWidgetConfig } from "../types";
+import { createElement, createNode, cx } from "../utils/dom";
+import { AgentWidgetConfig, AgentWidgetLauncherTeaserConfig } from "../types";
 import { positionMap } from "../utils/positioning";
 import { isDockedMountMode } from "../utils/dock";
 import { renderLucideIcon } from "../utils/icons";
@@ -240,3 +240,298 @@ export const createLauncherButton = (
     destroy
   };
 };
+
+/** Teaser bubble handle. `dismiss(true)` also writes the persisted flag. */
+export interface LauncherTeaser {
+  element: HTMLElement;
+  show: () => void;
+  dismiss: (persist: boolean) => void;
+}
+
+/** "auto" covers restored/hook-driven opens: they never persist the teaser flag. */
+export type LauncherOpenOrigin = "user" | "auto";
+
+export interface LauncherSurface {
+  /** Positioned wrapper. Sibling teaser + launcher live inside it. */
+  element: HTMLElement;
+  launcher: LauncherButton;
+  /** Null when no teaser is configured for the current config. */
+  teaser: LauncherTeaser | null;
+  /** Opening the panel consumes the teaser; closing never resurrects it. */
+  setPanelOpen: (open: boolean, origin?: LauncherOpenOrigin) => void;
+  update: (config: AgentWidgetConfig) => void;
+  destroy: () => void;
+}
+
+const TEASER_KEY_SUFFIX = "teaser-dismissed";
+
+/** Consumed teaser keys for this page load; also the blocked-storage fallback. */
+const teaserMemoryDismissed = new Set<string>();
+
+const teaserStorageKey = (config?: AgentWidgetConfig): string => {
+  const persist = config?.persistState;
+  const prefix =
+    (typeof persist === "object" ? persist?.keyPrefix : undefined) ?? "persona-";
+  return `${prefix}${TEASER_KEY_SUFFIX}`;
+};
+
+// localStorage access throws (not just fails) in Safari private mode and
+// partitioned iframes, so every access falls back to the in-memory set.
+const readTeaserDismissed = (key: string, useStorage: boolean): boolean => {
+  if (teaserMemoryDismissed.has(key)) return true;
+  if (!useStorage) return false;
+  try {
+    return window.localStorage.getItem(key) === "1";
+  } catch {
+    return false;
+  }
+};
+
+const writeTeaserDismissed = (key: string, useStorage: boolean): void => {
+  teaserMemoryDismissed.add(key);
+  if (!useStorage) return;
+  try {
+    window.localStorage.setItem(key, "1");
+  } catch {
+    /* blocked storage: the in-memory flag above is the fallback */
+  }
+};
+
+const prefersReducedMotion = (): boolean =>
+  typeof window !== "undefined" &&
+  typeof window.matchMedia === "function" &&
+  window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+const resolveTeaserConfig = (
+  config: AgentWidgetConfig | undefined
+): AgentWidgetLauncherTeaserConfig | null => {
+  const teaser = config?.launcher?.teaser;
+  if (!teaser || !teaser.text) return null;
+  if (config?.launcher?.enabled === false) return null;
+  if (isDockedMountMode(config ?? {})) return null;
+  return teaser;
+};
+
+/**
+ * Launcher wrapper owning the collapsed button and its optional teaser bubble.
+ * Both the critical `launcher.global.js` bundle and the full widget build the
+ * launcher through this, so teaser behavior and cleanup are identical on the
+ * eager and deferred paths.
+ */
+export const createLauncherSurface = (
+  config: AgentWidgetConfig | undefined,
+  onToggle: () => void
+): LauncherSurface => {
+  const wrapper = createElement("div", "persona-launcher-surface");
+  wrapper.setAttribute("data-persona-launcher-surface", "true");
+
+  let currentConfig: AgentWidgetConfig = config ?? {};
+  let teaserConfig: AgentWidgetLauncherTeaserConfig | null = null;
+  let teaserElement: HTMLElement | null = null;
+  let dismissButton: HTMLButtonElement | null = null;
+  let teaserTextButton: HTMLButtonElement | null = null;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let visible = false;
+  let shown = false;
+  let consumed = false;
+  let panelOpen = false;
+
+  const usesStorage = (): boolean =>
+    (teaserConfig?.frequency ?? "once") === "once" &&
+    currentConfig.persistState !== false;
+
+  const clearTimer = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+
+  const hideBubble = () => {
+    if (!teaserElement || !visible) return;
+    visible = false;
+    teaserElement.hidden = true;
+  };
+
+  const dismiss = (persist: boolean) => {
+    clearTimer();
+    consumed = true;
+    hideBubble();
+    writeTeaserDismissed(teaserStorageKey(currentConfig), persist && usesStorage());
+  };
+
+  /**
+   * Click-through and launcher clicks consume; only a seen teaser persists.
+   * An automatic open is never user intent, so it consumes in memory only.
+   */
+  const consumeForOpen = (origin: LauncherOpenOrigin) => {
+    if (!teaserConfig || consumed) return;
+    dismiss(origin === "user" && visible);
+  };
+
+  const show = () => {
+    timer = null;
+    if (!teaserElement || consumed || panelOpen) return;
+    shown = true;
+    visible = true;
+    teaserElement.hidden = false;
+    if (prefersReducedMotion() || typeof teaserElement.animate !== "function") return;
+    teaserElement.animate(
+      [
+        { opacity: "0", transform: "translateY(6px)" },
+        { opacity: "1", transform: "none" },
+      ],
+      { duration: 220, easing: "ease-out", fill: "backwards" }
+    );
+  };
+
+  const schedule = () => {
+    if (!teaserConfig || !teaserElement) return;
+    if (consumed || shown || panelOpen) return;
+    if (readTeaserDismissed(teaserStorageKey(currentConfig), usesStorage())) return;
+    clearTimer();
+    timer = setTimeout(show, Math.max(0, teaserConfig.delayMs ?? 0));
+  };
+
+  const handleTeaserClick = () => {
+    dismiss(usesStorage());
+    onToggle();
+  };
+
+  const handleDismissClick = (event: MouseEvent) => {
+    event.stopPropagation();
+    dismiss(usesStorage());
+  };
+
+  const handleLauncherToggle = () => {
+    consumeForOpen("user");
+    onToggle();
+  };
+
+  const launcher = createLauncherButton(config, handleLauncherToggle);
+
+  const removeTeaserElement = () => {
+    clearTimer();
+    teaserTextButton?.removeEventListener("click", handleTeaserClick);
+    dismissButton?.removeEventListener("click", handleDismissClick);
+    teaserElement?.remove();
+    teaserElement = null;
+    teaserTextButton = null;
+    dismissButton = null;
+    visible = false;
+  };
+
+  const buildTeaserElement = () => {
+    teaserTextButton = createNode("button", {
+      className: "persona-launcher-teaser-text",
+      attrs: { type: "button" },
+    });
+    teaserTextButton.addEventListener("click", handleTeaserClick);
+
+    dismissButton = createNode("button", {
+      className: "persona-launcher-teaser-dismiss",
+      attrs: { type: "button" },
+      text: "\u00d7",
+    });
+    dismissButton.addEventListener("click", handleDismissClick);
+
+    teaserElement = createNode(
+      "div",
+      {
+        className: "persona-launcher-teaser",
+        attrs: {
+          "data-persona-launcher-teaser": "true",
+          role: "status",
+          "aria-live": "polite",
+          hidden: "",
+        },
+      },
+      teaserTextButton,
+      dismissButton
+    );
+    wrapper.insertBefore(teaserElement, launcher.element);
+  };
+
+  /**
+   * The wrapper is `display: contents` until a teaser exists, so the launcher
+   * keeps its own fixed placement; with a teaser the wrapper takes over the
+   * corner and the button becomes static inside it.
+   */
+  const applyPlacement = () => {
+    const position = currentConfig.launcher?.position ?? "bottom-right";
+    const positionClass = positionMap[position] ?? positionMap["bottom-right"];
+
+    if (!teaserElement) {
+      wrapper.className = "persona-launcher-surface";
+      wrapper.removeAttribute("data-teaser");
+      wrapper.style.zIndex = "";
+      launcher.element.style.position = "";
+      return;
+    }
+
+    wrapper.className = cx("persona-launcher-surface", positionClass);
+    wrapper.setAttribute("data-teaser", position);
+    wrapper.style.zIndex = String(
+      currentConfig.launcher?.zIndex ?? DEFAULT_OVERLAY_Z_INDEX
+    );
+    launcher.element.style.position = "static";
+  };
+
+  const syncTeaser = (nextConfig: AgentWidgetConfig) => {
+    const next = resolveTeaserConfig(nextConfig);
+    teaserConfig = next;
+
+    if (!next) {
+      removeTeaserElement();
+      return;
+    }
+
+    // `shown` is deliberately not reset here: at most one appearance per load.
+    if (!teaserElement) buildTeaserElement();
+
+    teaserTextButton!.textContent = next.text;
+    dismissButton!.hidden = next.dismissible === false;
+    dismissButton!.setAttribute(
+      "aria-label",
+      next.dismissLabel ?? "Dismiss message"
+    );
+    schedule();
+  };
+
+  const update = (nextConfig: AgentWidgetConfig) => {
+    currentConfig = nextConfig;
+    launcher.update(nextConfig);
+    syncTeaser(nextConfig);
+    applyPlacement();
+  };
+
+  const setPanelOpen = (open: boolean, origin: LauncherOpenOrigin = "user") => {
+    panelOpen = open;
+    if (!open) return;
+    consumeForOpen(origin);
+  };
+
+  const destroy = () => {
+    removeTeaserElement();
+    launcher.destroy();
+    wrapper.remove();
+  };
+
+  wrapper.appendChild(launcher.element);
+  if (config) {
+    syncTeaser(config);
+    applyPlacement();
+  }
+
+  return {
+    element: wrapper,
+    launcher,
+    get teaser(): LauncherTeaser | null {
+      if (!teaserElement) return null;
+      return { element: teaserElement, show, dismiss };
+    },
+    setPanelOpen,
+    update,
+    destroy,
+  };
+};