Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

106 KB
Raw Blame
import {
  reparentInstance,
  wrapInstance,
  toggleInstanceShow,
  unwrapInstance,
  canUnwrapInstance,
  convertInstance,
} from "./mutation";
import { deleteSelectedInstance } from "./mutation";
import { enableMapSet } from "immer";
import { describe, test, expect, beforeEach } from "vitest";
import type { Project } from "@webstudio-is/project";
import { createDefaultPages } from "@webstudio-is/project-build";
import { builderRuntimeContext } from "@webstudio-is/project-build/runtime";
import {
  canConvertInstance,
  reparentInstanceMutable,
} from "@webstudio-is/project-build/runtime";
import {
  createTemplateComponentFixture,
  ws,
  expression,
  renderData,
} from "@webstudio-is/template";
import * as defaultMetas from "@webstudio-is/sdk-components-react/metas";
import * as radixMetas from "@webstudio-is/sdk-components-react-radix/metas";
import type {
  DataSource,
  Instance,
  Prop,
  Resource,
  StyleDecl,
  WebstudioData,
  WsComponentMeta,
} from "@webstudio-is/sdk";
import {
  coreMetas,
  getStyleDeclKey,
  elementComponent,
} from "@webstudio-is/sdk";
import { showAttribute } from "@webstudio-is/react-sdk";
import type { StyleProperty, StyleValue } from "@webstudio-is/css-engine";
import type { InstancePath } from "@webstudio-is/project-build/runtime";
import { $registeredComponentMetas } from "../nano-states";
import {
  $instances,
  $pages,
  $project,
  $props,
} from "~/shared/sync/data-stores";
import { registerContainers } from "../sync/sync-stores";
import { $selectedInstanceSelector } from "../nano-states";
import { selectInstance } from "../nano-states";
import { $selectedPageId } from "../nano-states/pages";
import {
  expectSlotTreeIntegrity,
  expectSlotsShareFragment,
  getSlotFragmentId,
} from "../slot-test-utils";
import type {
  DroppableTarget,
  InstanceSelector,
} from "@webstudio-is/project-build/runtime";

const Body = createTemplateComponentFixture("Body");
const Bold = createTemplateComponentFixture("Bold");
const Box = createTemplateComponentFixture("Box");
const Button = createTemplateComponentFixture("Button");
const Fragment = createTemplateComponentFixture("Fragment");
const Heading = createTemplateComponentFixture("Heading");
const Paragraph = createTemplateComponentFixture("Paragraph");
const Slot = createTemplateComponentFixture("Slot");
const Text = createTemplateComponentFixture("Text");
const Tooltip = createTemplateComponentFixture("Tooltip");
const TooltipContent = createTemplateComponentFixture("TooltipContent");
const TooltipTrigger = createTemplateComponentFixture("TooltipTrigger");

enableMapSet();
registerContainers();

$pages.set(createDefaultPages({ rootInstanceId: "" }));

const defaultMetasMap = new Map(
  Object.entries({ ...defaultMetas, ...coreMetas })
);
$registeredComponentMetas.set(defaultMetasMap);

const reparentTestInstanceMutable = (
  data: Omit<WebstudioData, "pages">,
  sourceInstanceSelector: InstanceSelector,
  dropTarget: DroppableTarget
) =>
  reparentInstanceMutable({
    data,
    sourceInstanceSelector,
    dropTarget,
    createId: builderRuntimeContext.createId,
  });

const createFakeComponentMetas = (
  itemMeta: Partial<WsComponentMeta>,
  anotherItemMeta?: Partial<WsComponentMeta>
): Map<string, WsComponentMeta> => {
  const base = {
    label: "",
    Icon: () => null,
  };
  const configs = {
    Item: { ...base, ...itemMeta },
    AnotherItem: { ...base, ...anotherItemMeta },
    Bold: base,
    Text: base,
    Form: base,
    Box: base,
    Div: base,
    Body: base,
  } as const;
  return new Map(Object.entries(configs)) as Map<string, WsComponentMeta>;
};

const createInstance = (
  id: Instance["id"],
  component: string,
  children: Instance["children"]
): Instance => {
  return { type: "instance", id, component, children };
};

const createStyleDecl = (
  styleSourceId: string,
  breakpointId: string,
  property: StyleProperty,
  value: StyleValue | string
): StyleDecl => ({
  styleSourceId,
  breakpointId,
  property,
  value: typeof value === "string" ? { type: "unparsed", value } : value,
});

describe("reparent instance", () => {
  beforeEach(() => {
    $project.set({ id: "projectId" } as Project);
  });

  test("between instances", () => {
    const data = renderData(
      <Body ws:id="body">
        <Box ws:id="box">
          <Text ws:id="text"></Text>
        </Box>
        <Button ws:id="button"></Button>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["text", "box", "body"], {
      parentSelector: ["body"],
      position: 1,
    });
    const newTextId = data.instances.get("body")?.children[1].value as string;
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Box ws:id="box"></Box>
          <Text ws:id={newTextId}></Text>
          <Button ws:id="button"></Button>
        </Body>
      ).instances
    );
  });

  test("to the end", () => {
    const data = renderData(
      <Body ws:id="body">
        <Box ws:id="box">
          <Text ws:id="text"></Text>
        </Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["text", "box", "body"], {
      parentSelector: ["body"],
      position: "end",
    });
    const newTextId = data.instances.get("body")?.children[1].value as string;
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Box ws:id="box"></Box>
          <Text ws:id={newTextId}></Text>
        </Body>
      ).instances
    );
  });

  test("reparentInstance wrapper updates stores and selection", () => {
    const data = renderData(
      <Body ws:id="body">
        <Box ws:id="source"></Box>
        <Box ws:id="target"></Box>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $pages.set(createDefaultPages({ rootInstanceId: "body" }));
    $instances.set(data.instances);
    $props.set(data.props);

    reparentInstance(["source", "body"], {
      parentSelector: ["target", "body"],
      position: "end",
    });

    expect($instances.get().get("body")?.children).toEqual([
      { type: "id", value: "target" },
    ]);
    expect($instances.get().get("target")?.children).toEqual([
      { type: "id", value: "source" },
    ]);
    expect($selectedInstanceSelector.get()).toEqual([
      "source",
      "target",
      "body",
    ]);
  });

  test("before itself", () => {
    const data = renderData(
      <Body ws:id="body">
        <Text ws:id="text"></Text>
        <Box ws:id="box"></Box>
        <Button ws:id="button"></Button>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["body"],
      position: 1,
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Text ws:id="text"></Text>
          <Box ws:id="box"></Box>
          <Button ws:id="button"></Button>
        </Body>
      ).instances
    );
  });

  test("after itself", () => {
    const data = renderData(
      <Body ws:id="body">
        <Text ws:id="text"></Text>
        <Box ws:id="box"></Box>
        <Button ws:id="button"></Button>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["body"],
      position: 2,
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Text ws:id="text"></Text>
          <Box ws:id="box"></Box>
          <Button ws:id="button"></Button>
        </Body>
      ).instances
    );
  });

  test("wrap with fragment when reparent into empty slot", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot"></Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot", "body"],
      position: "end",
    });
    const newFragmentId = data.instances.get("slot")?.children[0]
      .value as string;
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Slot ws:id="slot">
            <Fragment ws:id={newFragmentId}>
              <Box ws:id="box"></Box>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
  });

  test("reuse existing fragment when reparent into slot", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot">
          <Fragment ws:id="fragment"></Fragment>
        </Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot", "body"],
      position: "end",
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Slot ws:id="slot">
            <Fragment ws:id="fragment">
              <Box ws:id="box"></Box>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
  });

  test("reparent into legacy slot with direct children wraps content in fragment", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot">
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot", "body"],
      position: "end",
    });

    const fragmentId = data.instances.get("slot")?.children[0]?.value;
    expect(fragmentId).toEqual(expect.any(String));
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Slot ws:id="slot">
            <Fragment ws:id={fragmentId}>
              <Heading ws:id="heading"></Heading>
              <Box ws:id="box"></Box>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
  });

  test("reparent into legacy shared slot content normalizes all occurrences", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot1", "body"],
      position: "end",
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
  });

  test("reparent into empty legacy shared slot content normalizes all occurrences", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1"></Slot>
        <Slot ws:id="slot2"></Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot1", "body"],
      position: "end",
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
  });

  test("reparent into legacy shared slot content preserves text and expression children", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1"></Slot>
        <Slot ws:id="slot2"></Slot>
        <Box ws:id="box"></Box>
      </Body>
    );
    data.instances.set(
      "slot1",
      createInstance("slot1", "Slot", [
        { type: "text", value: "Text child" },
        { type: "expression", value: "expressionChild" },
        { type: "id", value: "heading" },
      ])
    );
    data.instances.set(
      "slot2",
      createInstance("slot2", "Slot", [
        { type: "text", value: "Text child" },
        { type: "expression", value: "expressionChild" },
        { type: "id", value: "heading" },
      ])
    );
    data.instances.set("heading", createInstance("heading", "Heading", []));
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot1", "body"],
      position: "end",
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    const textWrapperId = data.instances.get(fragmentId ?? "")?.children[0]
      ?.value;
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: textWrapperId },
      { type: "id", value: "box" },
    ]);
    expect(data.instances.get(textWrapperId ?? "")?.children).toEqual([
      { type: "text", value: "Text child" },
      { type: "expression", value: "expressionChild" },
      { type: "id", value: "heading" },
    ]);
  });

  test("reparent into legacy slot does not normalize unrelated overlapping slot", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          <Box ws:id="box"></Box>
        </Slot>
        <Text ws:id="text"></Text>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["text", "body"], {
      parentSelector: ["slot1", "body"],
      position: "end",
    });

    const fragmentId = getSlotFragmentId(data.instances, "slot1");
    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
      { type: "id", value: "text" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
  });

  test("sort legacy shared slot content through visible slot drop target", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box1"></Box>
          <Box ws:id="box2"></Box>
          <Box ws:id="box3"></Box>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box1"></Box>
          <Box ws:id="box2"></Box>
          <Box ws:id="box3"></Box>
        </Slot>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box1", "slot1", "body"], {
      parentSelector: ["slot2", "body"],
      position: 3,
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "box2" },
      { type: "id", value: "box3" },
      { type: "id", value: "box1" },
    ]);
  });

  test("reparent legacy shared slot child outside removes it from all slot occurrences", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "slot1", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    const bodyChildId = data.instances.get("body")?.children.at(-1)?.value;
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
    expect(bodyChildId).toBe("box");
  });

  test("reparent legacy shared slot child into another slot updates both shared slots", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="sourceSlot1">
          <Box ws:id="box"></Box>
          <Text ws:id="text"></Text>
        </Slot>
        <Slot ws:id="sourceSlot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Text ws:id="text"></Text>
        </Slot>
        <Slot ws:id="targetSlot1">
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="targetSlot2">
          {/* same ids */}
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "sourceSlot1", "body"], {
      parentSelector: ["targetSlot1", "body"],
      position: "end",
    });

    const sourceSlot1FragmentId =
      data.instances.get("sourceSlot1")?.children[0]?.value;
    const sourceSlot2FragmentId =
      data.instances.get("sourceSlot2")?.children[0]?.value;
    const targetFragmentId =
      data.instances.get("targetSlot1")?.children[0]?.value;
    const movedBoxId = data.instances.get(targetFragmentId ?? "")?.children[1]
      ?.value;
    expect(sourceSlot1FragmentId).toBe(sourceSlot2FragmentId);
    expect(data.instances.get(sourceSlot1FragmentId ?? "")?.children).toEqual([
      { type: "id", value: "text" },
    ]);
    expect(data.instances.get("targetSlot1")?.children).toEqual([
      { type: "id", value: targetFragmentId },
    ]);
    expect(data.instances.get("targetSlot2")?.children).toEqual([
      { type: "id", value: targetFragmentId },
    ]);
    expect(data.instances.get(targetFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
    expect(movedBoxId).toBe("box");
  });

  test("reparent slot child from one instance of this slot into another", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["box", "fragment", "slot1", "body"], {
      parentSelector: ["slot2", "body"],
      position: "end",
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Slot ws:id="slot1">
            <Fragment ws:id="fragment">
              <Box ws:id="box"></Box>
            </Fragment>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <Fragment ws:id="fragment">
              <Box ws:id="box"></Box>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
  });

  test("sort shared slot content through visible slot drop target", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box1"></Box>
            <Box ws:id="box2"></Box>
            <Box ws:id="box3"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box1"></Box>
            <Box ws:id="box2"></Box>
            <Box ws:id="box3"></Box>
          </Fragment>
        </Slot>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box1", "fragment", "slot1", "body"], {
      parentSelector: ["slot2", "body"],
      position: 3,
    });

    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "box2" },
      { type: "id", value: "box3" },
      { type: "id", value: "box1" },
    ]);
  });

  test("reparent shared slot child into sibling in shared slot content", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["heading", "fragment", "slot1", "body"],
      {
        parentSelector: ["div", "fragment", "slot1", "body"],
        position: "end",
      }
    );

    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect(data.instances.get("div")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
  });

  test("reparent nested shared slot child within shared slot content", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["heading", "div", "fragment", "slot1", "body"],
      {
        parentSelector: ["fragment", "slot1", "body"],
        position: "end",
      }
    );

    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
      { type: "id", value: "heading" },
    ]);
    expect(data.instances.get("div")?.children).toEqual([]);
  });

  test("reparent normal child into slot makes it shared slot content", () => {
    const data = renderData(
      <Body ws:id="body">
        <Box ws:id="box"></Box>
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["slot1", "body"],
      position: "end",
    });

    expect(data.instances.get("body")?.children).toEqual([
      { type: "id", value: "slot1" },
      { type: "id", value: "slot2" },
    ]);
    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
  });

  test("reparent normal child into nested shared slot container makes it shared", () => {
    const data = renderData(
      <Body ws:id="body">
        <Box ws:id="box"></Box>
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "body"], {
      parentSelector: ["div", "fragment", "slot1", "body"],
      position: "end",
    });

    expect(data.instances.get("body")?.children).toEqual([
      { type: "id", value: "slot1" },
      { type: "id", value: "slot2" },
    ]);
    expect(data.instances.get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect(data.instances.get("div")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
  });

  test("reparent child from one slot into another updates both shared slot contents", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="sourceSlot1">
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="sourceSlot2">
          {/* same ids */}
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot1">
          <Fragment ws:id="targetFragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot2">
          {/* same ids */}
          <Fragment ws:id="targetFragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["box", "sourceFragment", "sourceSlot1", "body"],
      {
        parentSelector: ["targetSlot1", "body"],
        position: "end",
      }
    );

    expect(data.instances.get("sourceSlot1")?.children).toEqual([
      { type: "id", value: "sourceFragment" },
    ]);
    expect(data.instances.get("sourceSlot2")?.children).toEqual([
      { type: "id", value: "sourceFragment" },
    ]);
    expect(data.instances.get("sourceFragment")?.children).toEqual([]);
    expect(data.instances.get("targetSlot1")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(data.instances.get("targetSlot2")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(data.instances.get("targetFragment")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
  });

  test("reparent child from one slot into nested container in another slot", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="sourceSlot1">
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="sourceSlot2">
          {/* same ids */}
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot1">
          <Fragment ws:id="targetFragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot2">
          {/* same ids */}
          <Fragment ws:id="targetFragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["box", "sourceFragment", "sourceSlot1", "body"],
      {
        parentSelector: ["div", "targetFragment", "targetSlot1", "body"],
        position: "end",
      }
    );

    const movedBoxId = data.instances.get("div")?.children[0]?.value;
    expect(data.instances.get("sourceSlot1")?.children).toEqual([
      { type: "id", value: "sourceFragment" },
    ]);
    expect(data.instances.get("sourceSlot2")?.children).toEqual([
      { type: "id", value: "sourceFragment" },
    ]);
    expect(data.instances.get("sourceFragment")?.children).toEqual([]);
    expect(data.instances.get("targetSlot1")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(data.instances.get("targetSlot2")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(movedBoxId).toBe("box");
    expect(data.instances.get("div")?.children).toEqual([
      { type: "id", value: movedBoxId },
    ]);
  });

  test("reparent child from one slot into another preserves source siblings", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="sourceSlot1">
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
            <Text ws:id="text"></Text>
          </Fragment>
        </Slot>
        <Slot ws:id="sourceSlot2">
          {/* same ids */}
          <Fragment ws:id="sourceFragment">
            <Box ws:id="box"></Box>
            <Text ws:id="text"></Text>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot1">
          <Fragment ws:id="targetFragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="targetSlot2">
          {/* same ids */}
          <Fragment ws:id="targetFragment">
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["box", "sourceFragment", "sourceSlot1", "body"],
      {
        parentSelector: ["targetSlot1", "body"],
        position: "end",
      }
    );

    const sourceSlot1FragmentId =
      data.instances.get("sourceSlot1")?.children[0]?.value;
    expect(sourceSlot1FragmentId).toBe("sourceFragment");
    expect(data.instances.get(sourceSlot1FragmentId ?? "")?.children).toEqual([
      { type: "id", value: "text" },
    ]);
    expect(data.instances.get("sourceSlot2")?.children).toEqual([
      { type: "id", value: "sourceFragment" },
    ]);
    expect(data.instances.get("sourceFragment")?.children).toEqual([
      { type: "id", value: "text" },
    ]);
    expect(data.instances.get("targetSlot1")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(data.instances.get("targetSlot2")?.children).toEqual([
      { type: "id", value: "targetFragment" },
    ]);
    expect(data.instances.get("targetFragment")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
  });

  test("reparent slot operation matrix preserves sharing and detach invariants", () => {
    const random = (() => {
      let seed = 1;
      return () => {
        seed = (seed * 16807) % 2147483647;
        return seed / 2147483647;
      };
    })();
    const operations: Array<
      () => {
        data: Omit<WebstudioData, "pages">;
        sourceSelector: InstanceSelector;
        dropTarget: DroppableTarget;
        assert: (data: Omit<WebstudioData, "pages">) => void;
      }
    > = [
      () => ({
        data: renderData(
          <Body ws:id="body">
            <Slot ws:id="slot1">
              <Fragment ws:id="fragment">
                <Box ws:id="box1"></Box>
                <Box ws:id="box2"></Box>
                <Box ws:id="box3"></Box>
              </Fragment>
            </Slot>
            <Slot ws:id="slot2">
              {/* same ids */}
              <Fragment ws:id="fragment">
                <Box ws:id="box1"></Box>
                <Box ws:id="box2"></Box>
                <Box ws:id="box3"></Box>
              </Fragment>
            </Slot>
          </Body>
        ),
        sourceSelector: ["box1", "fragment", "slot1", "body"],
        dropTarget: {
          parentSelector: ["slot2", "body"],
          position: 3,
        },
        assert: (data) => {
          const fragmentId = expectSlotsShareFragment(data.instances, [
            "slot1",
            "slot2",
          ]);
          expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
            { type: "id", value: "box2" },
            { type: "id", value: "box3" },
            { type: "id", value: "box1" },
          ]);
        },
      }),
      () => ({
        data: renderData(
          <Body ws:id="body">
            <Slot ws:id="slot1">
              <Box ws:id="box1"></Box>
              <Box ws:id="box2"></Box>
              <Box ws:id="box3"></Box>
            </Slot>
            <Slot ws:id="slot2">
              {/* same ids */}
              <Box ws:id="box1"></Box>
              <Box ws:id="box2"></Box>
              <Box ws:id="box3"></Box>
            </Slot>
          </Body>
        ),
        sourceSelector: ["box1", "slot1", "body"],
        dropTarget: {
          parentSelector: ["slot2", "body"],
          position: 3,
        },
        assert: (data) => {
          const fragmentId = expectSlotsShareFragment(data.instances, [
            "slot1",
            "slot2",
          ]);
          expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
            { type: "id", value: "box2" },
            { type: "id", value: "box3" },
            { type: "id", value: "box1" },
          ]);
        },
      }),
      () => ({
        data: renderData(
          <Body ws:id="body">
            <Box ws:id="box"></Box>
            <Slot ws:id="slot1">
              <Fragment ws:id="fragment">
                <ws.element ws:tag="div" ws:id="div"></ws.element>
              </Fragment>
            </Slot>
            <Slot ws:id="slot2">
              {/* same ids */}
              <Fragment ws:id="fragment">
                <ws.element ws:tag="div" ws:id="div"></ws.element>
              </Fragment>
            </Slot>
          </Body>
        ),
        sourceSelector: ["box", "body"],
        dropTarget: {
          parentSelector: ["div", "fragment", "slot1", "body"],
          position: "end",
        },
        assert: (data) => {
          expectSlotsShareFragment(data.instances, ["slot1", "slot2"]);
          expect(data.instances.get("div")?.children).toEqual([
            { type: "id", value: "box" },
          ]);
        },
      }),
      () => ({
        data: renderData(
          <Body ws:id="body">
            <Slot ws:id="slot1">
              <Fragment ws:id="fragment">
                <Box ws:id="box"></Box>
                <Heading ws:id="heading"></Heading>
              </Fragment>
            </Slot>
            <Slot ws:id="slot2">
              {/* same ids */}
              <Fragment ws:id="fragment">
                <Box ws:id="box"></Box>
                <Heading ws:id="heading"></Heading>
              </Fragment>
            </Slot>
          </Body>
        ),
        sourceSelector: ["box", "fragment", "slot1", "body"],
        dropTarget: {
          parentSelector: ["body"],
          position: "end",
        },
        assert: (data) => {
          const fragmentId = expectSlotsShareFragment(data.instances, [
            "slot1",
            "slot2",
          ]);
          const movedBoxId = data.instances.get("body")?.children.at(-1)?.value;
          expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
            { type: "id", value: "heading" },
          ]);
          expect(movedBoxId).toBe("box");
        },
      }),
    ];

    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    for (let index = 0; index < 20; index += 1) {
      const operation = operations[Math.floor(random() * operations.length)]();
      reparentTestInstanceMutable(
        operation.data,
        operation.sourceSelector,
        operation.dropTarget
      );
      operation.assert(operation.data);
      expectSlotTreeIntegrity(operation.data.instances);
    }
  });

  test("slot operation sequence preserves integrity after normalize, reparent out, and delete", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same visible content in legacy direct-child shape */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Box ws:id="outside"></Box>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["heading", "slot2", "body"], {
      parentSelector: ["slot2", "body"],
      position: 0,
    });

    const sharedFragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get(sharedFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
      { type: "id", value: "box" },
    ]);
    expectSlotTreeIntegrity(data.instances);

    const movedSelector = reparentTestInstanceMutable(
      data,
      ["box", "fragment", "slot2", "body"],
      {
        parentSelector: ["outside", "body"],
        position: "end",
      }
    );

    expect(movedSelector).toEqual(expect.any(Array));
    expectSlotTreeIntegrity(data.instances, {
      selectedInstanceSelector: movedSelector,
    });
    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);

    const movedId = data.instances.get("outside")?.children[0]?.value;
    expect(movedId).toBe(movedSelector?.[0]);
  });

  test("reparent nested shared slot child outside removes it from all slot occurrences", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(
      data,
      ["box", "div", "fragment", "slot1", "body"],
      {
        parentSelector: ["body"],
        position: "end",
      }
    );

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    const slot1DivId = data.instances.get(fragmentId ?? "")?.children[0]?.value;
    const bodyChildId = data.instances.get("body")?.children.at(-1)?.value;

    expect(fragmentId).toBe("fragment");
    expect(data.instances.get(slot1DivId ?? "")?.children).toEqual([]);
    expect(data.instances.get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect(data.instances.get("div")?.children).toEqual([]);
    expect(bodyChildId).toBe("box");
  });

  test("reparent shared slot child outside preserves moved scoped data and resources", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="card">
              <Box ws:id="label"></Box>
            </ws.element>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="card">
              <Box ws:id="label"></Box>
            </ws.element>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    data.dataSources.set("cardVariable", {
      id: "cardVariable",
      scopeInstanceId: "card",
      type: "variable",
      name: "Card Variable",
      value: { type: "string", value: "value" },
    });
    data.props.set("labelProp", {
      id: "labelProp",
      instanceId: "label",
      name: "children",
      type: "expression",
      value: "$ws$dataSource$cardVariable",
    });
    data.props.set("cardResourceProp", {
      id: "cardResourceProp",
      instanceId: "card",
      name: "resource",
      type: "resource",
      value: "cardResource",
    });
    data.resources.set("cardResource", {
      id: "cardResource",
      name: "Card Resource",
      method: "get",
      url: "$ws$dataSource$cardVariable",
      headers: [
        {
          name: "authorization",
          value: "$ws$dataSource$cardVariable",
        },
      ],
      searchParams: [
        {
          name: "query",
          value: "$ws$dataSource$cardVariable",
        },
      ],
    });
    const style = createStyleDecl("cardStyle", "base", "color", "red");
    data.breakpoints.set("base", { id: "base", label: "Base" });
    data.styleSources.set("cardStyle", { id: "cardStyle", type: "local" });
    data.styleSourceSelections.set("card", {
      instanceId: "card",
      values: ["cardStyle"],
    });
    data.styles.set(getStyleDeclKey(style), style);
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["card", "fragment", "slot1", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    const slotFragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    const movedCardId = data.instances.get("body")?.children.at(-1)?.value;
    const movedLabelId =
      movedCardId === undefined
        ? undefined
        : data.instances.get(movedCardId)?.children[0]?.value;
    const movedCardVariable = Array.from(data.dataSources.values()).find(
      (dataSource) => dataSource.scopeInstanceId === movedCardId
    );
    const movedCardResourceId = Array.from(data.props.values()).find(
      (prop) => prop.instanceId === movedCardId && prop.type === "resource"
    )?.value;
    const movedCardResource =
      typeof movedCardResourceId !== "string"
        ? undefined
        : data.resources.get(movedCardResourceId);
    expect(movedCardVariable).toBeDefined();
    const movedCardVariableExpression = "$ws$dataSource$cardVariable";
    expect(slotFragmentId).toBe("fragment");
    expect(data.instances.get(slotFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
    expect(movedCardId).toBe("card");
    expect(movedLabelId).toBe("label");
    expect(movedCardVariable?.id).toBe("cardVariable");
    expect(
      Array.from(data.props.values()).find(
        (prop) => prop.instanceId === movedLabelId && prop.type === "expression"
      )?.value
    ).toBe(movedCardVariableExpression);
    expect(movedCardResourceId).toBe("cardResource");
    expect(movedCardResource?.url).toBe(movedCardVariableExpression);
    expect(movedCardResource?.headers).toEqual([
      {
        name: "authorization",
        value: movedCardVariableExpression,
      },
    ]);
    expect(movedCardResource?.searchParams).toEqual([
      {
        name: "query",
        value: movedCardVariableExpression,
      },
    ]);
    expect(data.styleSourceSelections.get(movedCardId ?? "")?.values).toEqual([
      "cardStyle",
    ]);
    expect(data.styles.size).toBe(1);
  });

  test("reparent shared slot child outside removes it from all slots and preserves siblings", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["box", "fragment", "slot1", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    const slotFragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    const bodyChildId = data.instances.get("body")?.children.at(-1)?.value;

    expect(slotFragmentId).toBe("fragment");
    expect(data.instances.get(slotFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
    expect(bodyChildId).toBe("box");
  });

  test("reparent direct slot child outside updates all linked slot occurrences", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["div", "fragment", "slot1", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    const fragmentId = expectSlotsShareFragment(data.instances, [
      "slot1",
      "slot2",
    ]);
    expect(data.instances.get(fragmentId ?? "")?.children).toEqual([]);
    expect(data.instances.get("body")?.children.at(-1)?.type).toBe("id");
    expect(data.instances.get("body")?.children.at(-1)?.value).toBe("div");
  });

  test("prevent slot reparenting into own children to avoid infinite loop", () => {
    const data = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot">
          <Fragment ws:id="fragment"></Fragment>
        </Slot>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(data, ["slot", "body"], {
      parentSelector: ["fragment", "slot", "body"],
      position: "end",
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Slot ws:id="slot">
            <Fragment ws:id="fragment"></Fragment>
          </Slot>
        </Body>
      ).instances
    );
  });

  test("from collection item", () => {
    const data = renderData(
      <Body ws:id="body">
        <ws.collection ws:id="collection">
          <Box ws:id="box"></Box>
        </ws.collection>
      </Body>
    );
    $registeredComponentMetas.set(createFakeComponentMetas({}));
    reparentTestInstanceMutable(
      data,
      ["box", "collection[0]", "collection", "body"],
      { parentSelector: ["body"], position: "end" }
    );
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <ws.collection ws:id="collection"></ws.collection>
          <Box ws:id="box"></Box>
        </Body>
      ).instances
    );
  });

  test("unsets variables scoped outside of moved subtree", () => {
    const data = getWebstudioDataStub({
      instances: createParentChildInstances([
        { type: "expression", value: "$ws$dataSource$parentVariable" },
      ]),
      dataSources: new Map([["parentVariable", parentScopedVariable]]),
    });
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["child", "parent", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    expect(data.instances.get("child")?.children).toEqual([
      { type: "expression", value: "Parent$32$Variable" },
    ]);
  });

  test("remaps moved expression props, action props, and resource expressions", () => {
    const data = getWebstudioDataStub({
      instances: createParentChildInstances(),
      dataSources: new Map([
        ["parentVariable", parentScopedVariable],
      ] satisfies [DataSource["id"], DataSource][]),
      props: new Map([
        [
          "expressionProp",
          {
            id: "expressionProp",
            instanceId: "child",
            name: "state",
            type: "expression",
            value: "$ws$dataSource$parentVariable",
          },
        ],
        [
          "actionProp",
          {
            id: "actionProp",
            instanceId: "child",
            name: "onClick",
            type: "action",
            value: [
              {
                type: "execute",
                args: [],
                code: "$ws$dataSource$parentVariable = 'next'",
              },
            ],
          },
        ],
        [
          "resourceProp",
          {
            id: "resourceProp",
            instanceId: "child",
            name: "resource",
            type: "resource",
            value: "resource",
          },
        ],
      ] satisfies [Prop["id"], Prop][]),
      resources: new Map([
        [
          "resource",
          {
            id: "resource",
            name: "Resource",
            method: "post",
            url: "$ws$dataSource$parentVariable",
            headers: [
              {
                name: "authorization",
                value: "$ws$dataSource$parentVariable",
              },
            ],
            searchParams: [
              {
                name: "query",
                value: "$ws$dataSource$parentVariable",
              },
            ],
            body: "$ws$dataSource$parentVariable",
          },
        ],
      ] satisfies [Resource["id"], Resource][]),
    });
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["child", "parent", "body"], {
      parentSelector: ["body"],
      position: "end",
    });

    expect(data.props.get("expressionProp")).toEqual({
      id: "expressionProp",
      instanceId: "child",
      name: "state",
      type: "expression",
      value: "Parent$32$Variable",
    });
    expect(data.props.get("actionProp")).toEqual({
      id: "actionProp",
      instanceId: "child",
      name: "onClick",
      type: "action",
      value: [
        {
          type: "execute",
          args: [],
          code: "Parent$32$Variable = 'next'",
        },
      ],
    });
    expect(data.resources.get("resource")).toEqual({
      id: "resource",
      name: "Resource",
      method: "post",
      url: "Parent$32$Variable",
      headers: [{ name: "authorization", value: "Parent$32$Variable" }],
      searchParams: [{ name: "query", value: "Parent$32$Variable" }],
      body: "Parent$32$Variable",
    });
  });

  test("restores moved expressions to same-name variables in new scope", () => {
    const data = getWebstudioDataStub({
      instances: new Map([
        [
          "body",
          {
            type: "instance",
            id: "body",
            component: "Body",
            children: [
              { type: "id", value: "source" },
              { type: "id", value: "target" },
            ],
          },
        ],
        [
          "source",
          {
            type: "instance",
            id: "source",
            component: "Box",
            children: [{ type: "id", value: "child" }],
          },
        ],
        [
          "target",
          {
            type: "instance",
            id: "target",
            component: "Box",
            children: [],
          },
        ],
        [
          "child",
          {
            type: "instance",
            id: "child",
            component: "Box",
            children: [
              { type: "expression", value: "$ws$dataSource$sourceVariable" },
            ],
          },
        ],
      ]),
      dataSources: new Map([
        [
          "sourceVariable",
          {
            id: "sourceVariable",
            scopeInstanceId: "source",
            type: "variable",
            name: "Shared Name",
            value: { type: "string", value: "source" },
          },
        ],
        [
          "targetVariable",
          {
            id: "targetVariable",
            scopeInstanceId: "target",
            type: "variable",
            name: "Shared Name",
            value: { type: "string", value: "target" },
          },
        ],
      ] satisfies [DataSource["id"], DataSource][]),
    });
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(createFakeComponentMetas({}));

    reparentTestInstanceMutable(data, ["child", "source", "body"], {
      parentSelector: ["target", "body"],
      position: "end",
    });

    expect(data.instances.get("child")?.children).toEqual([
      { type: "expression", value: "$ws$dataSource$targetVariable" },
    ]);
  });

  test("move required child within same instance", () => {
    const data = renderData(
      <Body ws:id="body">
        <Tooltip ws:id="tooltip">
          <TooltipTrigger ws:id="trigger"></TooltipTrigger>
          <TooltipContent ws:id="content"></TooltipContent>
        </Tooltip>
      </Body>
    );
    $registeredComponentMetas.set(
      new Map(Object.entries({ ...defaultMetas, ...radixMetas }))
    );
    reparentTestInstanceMutable(data, ["trigger", "tooltip", "body"], {
      parentSelector: ["tooltip", "body"],
      position: "end",
    });
    expect(data.instances).toEqual(
      renderData(
        <Body ws:id="body">
          <Tooltip ws:id="tooltip">
            <TooltipContent ws:id="content"></TooltipContent>
            <TooltipTrigger ws:id={expect.any(String)}></TooltipTrigger>
          </Tooltip>
        </Body>
      ).instances
    );
  });
});

const getWebstudioDataStub = (
  data?: Partial<WebstudioData>
): WebstudioData => ({
  pages: createDefaultPages({ rootInstanceId: "" }),
  assets: new Map(),
  dataSources: new Map(),
  resources: new Map(),
  instances: new Map(),
  props: new Map(),
  breakpoints: new Map(),
  styleSourceSelections: new Map(),
  styleSources: new Map(),
  styles: new Map(),
  ...data,
});

const createParentChildInstances = (childChildren: Instance["children"] = []) =>
  new Map<Instance["id"], Instance>([
    [
      "body",
      {
        type: "instance",
        id: "body",
        component: "Body",
        children: [{ type: "id", value: "parent" }],
      },
    ],
    [
      "parent",
      {
        type: "instance",
        id: "parent",
        component: "Box",
        children: [{ type: "id", value: "child" }],
      },
    ],
    [
      "child",
      {
        type: "instance",
        id: "child",
        component: "Box",
        children: childChildren,
      },
    ],
  ]);

const parentScopedVariable: DataSource = {
  id: "parentVariable",
  scopeInstanceId: "parent",
  type: "variable",
  name: "Parent Variable",
  value: { type: "string", value: "value" },
};

describe("wrap in", () => {
  test("wrap instance in link", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="div" ws:id="divId"></ws.element>
        </ws.element>
      ).instances
    );
    selectInstance(["divId", "bodyId"]);
    wrapInstance(elementComponent, "a");
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="a" ws:id={expect.any(String)}>
            <ws.element ws:tag="div" ws:id="divId"></ws.element>
          </ws.element>
        </ws.element>
      ).instances
    );
  });

  test("wrap image in element", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="img" ws:id="imageId"></ws.element>
        </ws.element>
      ).instances
    );
    selectInstance(["imageId", "bodyId"]);
    wrapInstance(elementComponent);
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="div" ws:id={expect.any(String)}>
            <ws.element ws:tag="img" ws:id="imageId"></ws.element>
          </ws.element>
        </ws.element>
      ).instances
    );
  });

  test("wrap shared slot child in shared slot content", () => {
    $registeredComponentMetas.set(defaultMetasMap);
    $instances.set(
      renderData(
        <Body ws:id="bodyId">
          <Slot ws:id="slot1">
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div"></ws.element>
            </Fragment>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div"></ws.element>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
    selectInstance(["div", "fragment", "slot1", "bodyId"]);

    wrapInstance(elementComponent, "div");

    const wrapperId = $instances.get().get("fragment")?.children[0]?.value;
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: wrapperId },
    ]);
    expect($instances.get().get(wrapperId ?? "")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
  });

  test("wrap legacy shared slot child in shared slot content", () => {
    $registeredComponentMetas.set(defaultMetasMap);
    $instances.set(
      renderData(
        <Body ws:id="bodyId">
          <Slot ws:id="slot1">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
            <Heading ws:id="heading"></Heading>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <ws.element ws:tag="div" ws:id="div"></ws.element>
            <Heading ws:id="heading"></Heading>
          </Slot>
        </Body>
      ).instances
    );
    selectInstance(["div", "slot1", "bodyId"]);

    wrapInstance(elementComponent, "div");

    const fragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    const wrapperId = $instances.get().get(fragmentId ?? "")
      ?.children[0]?.value;
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect($instances.get().get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: wrapperId },
      { type: "id", value: "heading" },
    ]);
    expect($instances.get().get(wrapperId ?? "")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
  });

  test("wrap shared slot child preserves shared siblings", () => {
    $registeredComponentMetas.set(defaultMetasMap);
    $instances.set(
      renderData(
        <Body ws:id="bodyId">
          <Slot ws:id="slot1">
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div"></ws.element>
              <Heading ws:id="heading"></Heading>
            </Fragment>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div"></ws.element>
              <Heading ws:id="heading"></Heading>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
    selectInstance(["div", "fragment", "slot1", "bodyId"]);

    wrapInstance(elementComponent, "div");

    const wrapperId = $instances.get().get("fragment")?.children[0]?.value;
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: wrapperId },
      { type: "id", value: "heading" },
    ]);
    expect($instances.get().get(wrapperId ?? "")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
  });

  test.each([
    {
      selectedId: "box",
      expectedSiblingIds: [expect.any(String), "heading"],
    },
    {
      selectedId: "heading",
      expectedSiblingIds: ["box", expect.any(String)],
    },
  ])(
    "wrap direct shared slot child in $selectedId position preserves sibling order",
    ({ selectedId, expectedSiblingIds }) => {
      $registeredComponentMetas.set(defaultMetasMap);
      $instances.set(
        renderData(
          <Body ws:id="bodyId">
            <Slot ws:id="slot1">
              <Fragment ws:id="fragment">
                <Box ws:id="box"></Box>
                <Heading ws:id="heading"></Heading>
              </Fragment>
            </Slot>
            <Slot ws:id="slot2">
              {/* same ids */}
              <Fragment ws:id="fragment">
                <Box ws:id="box"></Box>
                <Heading ws:id="heading"></Heading>
              </Fragment>
            </Slot>
          </Body>
        ).instances
      );
      selectInstance([selectedId, "fragment", "slot1", "bodyId"]);

      wrapInstance(elementComponent, "div");

      const wrapperId = $instances
        .get()
        .get("fragment")
        ?.children.find(
          (child) =>
            child.type === "id" &&
            child.value !== "box" &&
            child.value !== "heading"
        )?.value;
      expect($instances.get().get("slot1")?.children).toEqual([
        { type: "id", value: "fragment" },
      ]);
      expect($instances.get().get("slot2")?.children).toEqual([
        { type: "id", value: "fragment" },
      ]);
      expect($instances.get().get("fragment")?.children).toEqual(
        expectedSiblingIds.map((value) => ({ type: "id", value }))
      );
      expect(wrapperId).toEqual(expect.any(String));
      expect($instances.get().get(wrapperId ?? "")?.children).toEqual([
        { type: "id", value: selectedId },
      ]);
    }
  );

  test("wrap nested shared slot child in shared slot content", () => {
    $registeredComponentMetas.set(defaultMetasMap);
    $instances.set(
      renderData(
        <Body ws:id="bodyId">
          <Slot ws:id="slot1">
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div">
                <Box ws:id="box"></Box>
              </ws.element>
            </Fragment>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <Fragment ws:id="fragment">
              <ws.element ws:tag="div" ws:id="div">
                <Box ws:id="box"></Box>
              </ws.element>
            </Fragment>
          </Slot>
        </Body>
      ).instances
    );
    selectInstance(["box", "div", "fragment", "slot1", "bodyId"]);

    wrapInstance(elementComponent, "div");

    const wrapperId = $instances.get().get("div")?.children[0]?.value;
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect($instances.get().get("div")?.children).toEqual([
      { type: "id", value: wrapperId },
    ]);
    expect($instances.get().get(wrapperId ?? "")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
  });

  test("avoid wrapping text with link in link", () => {
    const { instances } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <ws.element ws:tag="p" ws:id="textId">
          <ws.element ws:tag="a" ws:id="linkId"></ws.element>
        </ws.element>
      </ws.element>
    );
    $instances.set(instances);
    selectInstance(["textId", "bodyId"]);
    wrapInstance(elementComponent, "a");
    // nothing is changed
    expect($instances.get()).toEqual(instances);
  });

  test("avoid wrapping textual content", () => {
    const { instances } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <ws.element ws:tag="div" ws:id="textId">
          <ws.element ws:tag="bold" ws:id="boldId"></ws.element>
        </ws.element>
      </ws.element>
    );
    $instances.set(instances);
    selectInstance(["boldId", "textId", "bodyId"]);
    wrapInstance(elementComponent);
    // nothing is changed
    expect($instances.get()).toEqual(instances);
  });

  test("avoid wrapping list item", () => {
    const { instances } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <ws.element ws:tag="ul" ws:id="listId">
          <ws.element ws:tag="li" ws:id="listItemId"></ws.element>
        </ws.element>
      </ws.element>
    );
    $instances.set(instances);
    selectInstance(["listItemId", "listId", "bodyId"]);
    wrapInstance(elementComponent);
    // nothing is changed
    expect($instances.get()).toEqual(instances);
  });
});

describe("toggleInstanceShow", () => {
  test("creates show prop with false value when it doesn't exist", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Box ws:id="box"></Box>
      </Body>
    );
    $instances.set(instances);
    $props.set(new Map());
    $pages.set(createDefaultPages({ rootInstanceId: "body" }));

    toggleInstanceShow("box");

    const props = $props.get();
    const showProp = Array.from(props.values()).find(
      (prop) => prop.instanceId === "box" && prop.name === showAttribute
    );
    expect(showProp).toEqual({
      id: expect.any(String),
      instanceId: "box",
      name: showAttribute,
      type: "boolean",
      value: false,
    });
  });

  test("toggles show prop from true to false", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Box ws:id="box" ws:show={true}></Box>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    $pages.set(createDefaultPages({ rootInstanceId: "body" }));

    toggleInstanceShow("box");

    const updatedProps = $props.get();
    const showProp = Array.from(updatedProps.values()).find(
      (prop) => prop.instanceId === "box" && prop.name === showAttribute
    );
    expect(showProp?.type).toBe("boolean");
    if (showProp?.type === "boolean") {
      expect(showProp.value).toBe(false);
    }
  });

  test("toggles show prop from false to true", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Box ws:id="box" ws:show={false}></Box>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    $pages.set(createDefaultPages({ rootInstanceId: "body" }));

    toggleInstanceShow("box");

    const updatedProps = $props.get();
    const showProp = Array.from(updatedProps.values()).find(
      (prop) => prop.instanceId === "box" && prop.name === showAttribute
    );
    expect(showProp?.type).toBe("boolean");
    if (showProp?.type === "boolean") {
      expect(showProp.value).toBe(true);
    }
  });

  test("preserves non-boolean show prop", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Box ws:id="box" ws:show={expression`isVisible`}></Box>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    $pages.set(createDefaultPages({ rootInstanceId: "body" }));

    toggleInstanceShow("box");

    expect($props.get()).toEqual(props);
  });
});

describe("unwrap instance", () => {
  test("unwrap command skips hidden slot fragment", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["div", "fragment", "slot", "body"]);

    unwrapInstance();

    expect($selectedInstanceSelector.get()).toEqual(["div", "body"]);
    expect($instances.get().get("body")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect($instances.get().has("slot")).toBe(false);
    expect($instances.get().has("fragment")).toBe(false);
  });

  test("unwrap command moves only shared slot child out of all slot occurrences", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["div", "fragment", "slot1", "body"]);

    unwrapInstance();

    const bodyChildren = $instances.get().get("body")?.children;
    const unwrappedDivId =
      bodyChildren?.[0]?.type === "id" ? bodyChildren[0].value : undefined;

    expect(unwrappedDivId).toBeDefined();
    expect(unwrappedDivId).toBe("div");
    expect($selectedInstanceSelector.get()).toEqual([unwrappedDivId, "body"]);
    expect($instances.get().get("slot1")).toBeUndefined();
    const fragmentId = getSlotFragmentId($instances.get(), "slot2");
    expect(fragmentId).toBe("fragment");
    expect($instances.get().get(fragmentId ?? "")?.children).toEqual([]);
  });

  test("unwrap command moves direct shared slot child out of all slots and preserves siblings", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "fragment", "slot1", "body"]);

    unwrapInstance();

    const bodyChildren = $instances.get().get("body")?.children;
    const slot1Id = bodyChildren?.find(
      (child) => child.type === "id" && child.value === "slot1"
    )?.value;
    const unwrappedBoxId = bodyChildren?.find(
      (child) =>
        child.type === "id" &&
        child.value !== "slot1" &&
        child.value !== "slot2"
    )?.value;
    const slot1FragmentId =
      slot1Id === undefined
        ? undefined
        : $instances.get().get(slot1Id)?.children[0]?.value;

    expect(slot1Id).toBe("slot1");
    const sharedFragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    expect(slot1FragmentId).toBe(sharedFragmentId);
    expect(unwrappedBoxId).toBeDefined();
    expect(unwrappedBoxId).toBe("box");
    expect($selectedInstanceSelector.get()).toEqual([unwrappedBoxId, "body"]);
    expect($instances.get().get(sharedFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
  });

  test("unwrap command moves direct legacy shared slot child out of all slots and preserves siblings", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "slot1", "body"]);

    unwrapInstance();

    const bodyChildren = $instances.get().get("body")?.children;
    const slot1Id =
      bodyChildren?.[0]?.type === "id" ? bodyChildren[0].value : undefined;
    const unwrappedBoxId =
      bodyChildren?.[1]?.type === "id" ? bodyChildren[1].value : undefined;
    const sharedFragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    const slot1FragmentId =
      slot1Id === undefined
        ? undefined
        : getSlotFragmentId($instances.get(), slot1Id);

    expect(slot1Id).toBe("slot1");
    expect(slot1FragmentId).toBe(sharedFragmentId);
    expect(unwrappedBoxId).toBeDefined();
    expect(unwrappedBoxId).toBe("box");
    expect($selectedInstanceSelector.get()).toEqual([unwrappedBoxId, "body"]);
    expect($instances.get().get(sharedFragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
  });

  test.each([
    {
      selectedId: "box1",
      remainingIds: ["box2", "box3"],
    },
    {
      selectedId: "box2",
      remainingIds: ["box1", "box3"],
    },
    {
      selectedId: "box3",
      remainingIds: ["box1", "box2"],
    },
  ])(
    "unwrap command moves direct shared slot child in $selectedId position out of all slots",
    ({ selectedId, remainingIds }) => {
      const { instances, props } = renderData(
        <Body ws:id="body">
          <Slot ws:id="slot1">
            <Fragment ws:id="fragment">
              <Box ws:id="box1"></Box>
              <Box ws:id="box2"></Box>
              <Box ws:id="box3"></Box>
            </Fragment>
          </Slot>
          <Slot ws:id="slot2">
            {/* same ids */}
            <Fragment ws:id="fragment">
              <Box ws:id="box1"></Box>
              <Box ws:id="box2"></Box>
              <Box ws:id="box3"></Box>
            </Fragment>
          </Slot>
        </Body>
      );
      $instances.set(instances);
      $props.set(props);
      const pages = createDefaultPages({ rootInstanceId: "body" });
      $pages.set(pages);
      $selectedPageId.set(pages.homePageId);
      selectInstance([selectedId, "fragment", "slot1", "body"]);

      unwrapInstance();

      const bodyChildren = $instances.get().get("body")?.children ?? [];
      const unwrappedId = bodyChildren.find(
        (child) =>
          child.type === "id" &&
          child.value !== "slot1" &&
          child.value !== "slot2"
      )?.value;
      const sharedFragmentId = expectSlotsShareFragment($instances.get(), [
        "slot1",
        "slot2",
      ]);
      expect(unwrappedId).toBe(selectedId);
      expect($selectedInstanceSelector.get()).toEqual([unwrappedId, "body"]);
      expect($instances.get().get(sharedFragmentId ?? "")?.children).toEqual(
        remainingIds.map((id) => ({ type: "id", value: id }))
      );
    }
  );

  test("unwrap command keeps nested shared slot child in shared slot content", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "div", "fragment", "slot1", "body"]);

    unwrapInstance();

    expect($selectedInstanceSelector.get()).toEqual([
      "box",
      "fragment",
      "slot1",
      "body",
    ]);
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
    expect($instances.get().has("div")).toBe(false);
  });

  test("unwrap command keeps nested shared slot child with siblings in shared slot content", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "div", "fragment", "slot1", "body"]);

    unwrapInstance();

    expect($selectedInstanceSelector.get()).toEqual([
      "box",
      "fragment",
      "slot1",
      "body",
    ]);
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
      { type: "id", value: "box" },
    ]);
    expect($instances.get().get("div")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
  });
});

describe("canUnwrapInstance", () => {
  beforeEach(() => {
    $project.set({ id: "projectId" } as Project);
    $registeredComponentMetas.set(defaultMetasMap);
  });

  test("returns true for unwrappable instance", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Box ws:id="parent">
          <Box ws:id="wrapper">
            <Box ws:id="child"></Box>
          </Box>
        </Box>
      </Body>
    );

    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);

    const instancePath = [
      {
        instanceSelector: ["wrapper", "parent", "body"],
        instance: instances.get("wrapper")!,
      },
      {
        instanceSelector: ["parent", "body"],
        instance: instances.get("parent")!,
      },
      {
        instanceSelector: ["body"],
        instance: instances.get("body")!,
      },
    ] satisfies InstancePath;

    expect(canUnwrapInstance(instancePath)).toBe(true);
  });

  test("returns false if parent is root instance", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Box ws:id="box"></Box>
      </Body>
    );

    $instances.set(instances);
    $props.set(props);
    $registeredComponentMetas.set(defaultMetasMap);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);

    const instancePath = [
      {
        instanceSelector: ["box", "body"],
        instance: instances.get("box")!,
      },
      {
        instanceSelector: ["body"],
        instance: instances.get("body")!,
      },
    ] satisfies InstancePath;

    expect(canUnwrapInstance(instancePath)).toBe(false);
  });

  test("returns false for textual instance", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Paragraph ws:id="paragraph">
          <Bold ws:id="bold">text</Bold>
        </Paragraph>
      </Body>
    );

    $instances.set(instances);
    $props.set(props);
    $registeredComponentMetas.set(defaultMetasMap);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);

    const instancePath = [
      {
        instanceSelector: ["bold", "paragraph", "body"],
        instance: instances.get("bold")!,
      },
      {
        instanceSelector: ["paragraph", "body"],
        instance: instances.get("paragraph")!,
      },
    ] satisfies InstancePath;

    expect(canUnwrapInstance(instancePath)).toBe(false);
  });

  test("returns true for Body > div > a scenario", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <ws.element ws:tag="div" ws:id="div">
          <ws.element ws:tag="a" ws:id="link">
            Link text
          </ws.element>
        </ws.element>
      </Body>
    );

    $instances.set(instances);
    $props.set(props);
    $registeredComponentMetas.set(defaultMetasMap);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);

    const instancePath = [
      {
        instanceSelector: ["link", "div", "body"],
        instance: instances.get("link")!,
      },
      {
        instanceSelector: ["div", "body"],
        instance: instances.get("div")!,
      },
      {
        instanceSelector: ["body"],
        instance: instances.get("body")!,
      },
    ] satisfies InstancePath;

    // Should be able to unwrap the link from the div
    expect(canUnwrapInstance(instancePath)).toBe(true);
  });
});

describe("canConvertInstance", () => {
  test("returns true for valid conversion", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="body">
        <Box ws:id="box"></Box>
      </ws.element>
    );

    const result = canConvertInstance({
      instanceId: "box",
      instanceSelector: ["box", "body"],
      component: elementComponent,
      tag: "div",
      instances,
      props,
      metas: defaultMetasMap,
    });

    expect(result).toBe(true);
  });

  test("returns false for non-existent instance", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="body"></ws.element>
    );

    const result = canConvertInstance({
      instanceId: "nonexistent",
      instanceSelector: ["nonexistent", "body"],
      component: elementComponent,
      tag: "div",
      instances,
      props,
      metas: defaultMetasMap,
    });

    expect(result).toBe(false);
  });

  test("returns true when converting Box to Heading", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="body">
        <Box ws:id="box"></Box>
      </ws.element>
    );

    const result = canConvertInstance({
      instanceId: "box",
      instanceSelector: ["box", "body"],
      component: "@webstudio-is/sdk-components-react:Heading",
      instances,
      props,
      metas: defaultMetasMap,
    });

    expect(result).toBe(true);
  });

  test("uses preset tag when available", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="body">
        <Box ws:id="box"></Box>
      </ws.element>
    );

    const result = canConvertInstance({
      instanceId: "box",
      instanceSelector: ["box", "body"],
      component: "@webstudio-is/sdk-components-react:Heading",
      instances,
      props,
      metas: defaultMetasMap,
    });

    expect(result).toBe(true);
  });
});

describe("convertInstance", () => {
  beforeEach(() => {
    $registeredComponentMetas.set(defaultMetasMap);
  });

  test("detach shared slot children when converting slot", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div"></ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["slot1", "body"]);

    convertInstance(elementComponent, "section");

    const convertedSlot = $instances.get().get("slot1");
    expect(convertedSlot?.component).toBe(elementComponent);
    expect(convertedSlot?.tag).toBe("section");
    expect(convertedSlot?.children).not.toEqual(
      $instances.get().get("slot2")?.children
    );
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
  });

  test("detach shared slot children with siblings when converting slot", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["slot1", "body"]);

    convertInstance(elementComponent, "section");

    const convertedSlot = $instances.get().get("slot1");
    const convertedFragmentId = convertedSlot?.children[0]?.value;
    expect(convertedSlot?.component).toBe(elementComponent);
    expect(convertedSlot?.tag).toBe("section");
    expect(convertedFragmentId).toBeDefined();
    expect(convertedFragmentId).not.toBe("fragment");
    expect($instances.get().get(convertedFragmentId ?? "")?.children).toEqual([
      { type: "id", value: expect.any(String) },
      { type: "id", value: expect.any(String) },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
    ]);
  });

  test("detach legacy shared slot children when converting slot", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["slot1", "body"]);

    convertInstance(elementComponent, "section");

    const convertedSlot = $instances.get().get("slot1");
    const convertedFragmentId = convertedSlot?.children[0]?.value;
    const slot2FragmentId = getSlotFragmentId($instances.get(), "slot2");
    expect(convertedSlot?.component).toBe(elementComponent);
    expect(convertedSlot?.tag).toBe("section");
    expect(convertedFragmentId).toBeDefined();
    expect(slot2FragmentId).toBeDefined();
    expect(convertedFragmentId).not.toBe(slot2FragmentId);
    expect($instances.get().get(convertedFragmentId ?? "")?.component).toBe(
      "Fragment"
    );
    expect($instances.get().get(convertedFragmentId ?? "")?.children).toEqual([
      { type: "id", value: expect.any(String) },
      { type: "id", value: expect.any(String) },
    ]);
    expect($instances.get().get(slot2FragmentId ?? "")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
    ]);
  });

  test("converts shared slot child in shared slot content", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["box", "fragment", "slot1", "body"]);

    convertInstance(elementComponent, "section");

    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
    expect($instances.get().get("box")?.component).toBe(elementComponent);
    expect($instances.get().get("box")?.tag).toBe("section");
  });

  test("converts legacy shared slot child in shared slot content", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["box", "slot1", "body"]);

    convertInstance(elementComponent, "section");

    const fragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: fragmentId },
    ]);
    expect($instances.get().get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
    ]);
    expect($instances.get().get("box")?.component).toBe(elementComponent);
    expect($instances.get().get("box")?.tag).toBe("section");
  });

  test("converts nested shared slot child in shared slot content", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["box", "div", "fragment", "slot1", "body"]);

    convertInstance(elementComponent, "section");

    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect($instances.get().get("div")?.children).toEqual([
      { type: "id", value: "box" },
    ]);
    expect($instances.get().get("box")?.component).toBe(elementComponent);
    expect($instances.get().get("box")?.tag).toBe("section");
  });

  test("converts nested shared slot child and preserves siblings", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <ws.element ws:tag="div" ws:id="div">
              <Box ws:id="box"></Box>
              <Heading ws:id="heading"></Heading>
            </ws.element>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["box", "div", "fragment", "slot1", "body"]);

    convertInstance(elementComponent, "section");

    expect($instances.get().get("slot1")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("slot2")?.children).toEqual([
      { type: "id", value: "fragment" },
    ]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "div" },
    ]);
    expect($instances.get().get("div")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
    ]);
    expect($instances.get().get("box")?.component).toBe(elementComponent);
    expect($instances.get().get("box")?.tag).toBe("section");
  });

  test("command sequence preserves shared slot content through wrap, convert, and unwrap", () => {
    const { instances, props } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
            <Heading ws:id="heading"></Heading>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    $props.set(props);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "fragment", "slot1", "body"]);

    wrapInstance(elementComponent, "div");

    const wrapperId = $selectedInstanceSelector.get()?.[0];
    expect(wrapperId).toEqual(expect.any(String));
    if (wrapperId === undefined) {
      throw new Error("Expected wrapper to be selected");
    }
    expectSlotTreeIntegrity($instances.get(), {
      selectedInstanceSelector: $selectedInstanceSelector.get(),
    });
    expectSlotsShareFragment($instances.get(), ["slot1", "slot2"]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: wrapperId },
      { type: "id", value: "heading" },
    ]);

    convertInstance(elementComponent, "section");

    expect($instances.get().get(wrapperId)?.component).toBe(elementComponent);
    expect($instances.get().get(wrapperId)?.tag).toBe("section");
    expectSlotTreeIntegrity($instances.get(), {
      selectedInstanceSelector: $selectedInstanceSelector.get(),
    });
    expectSlotsShareFragment($instances.get(), ["slot1", "slot2"]);

    selectInstance(["box", wrapperId, "fragment", "slot1", "body"]);
    unwrapInstance();

    expect($selectedInstanceSelector.get()).toEqual([
      "box",
      "fragment",
      "slot1",
      "body",
    ]);
    expectSlotTreeIntegrity($instances.get(), {
      selectedInstanceSelector: $selectedInstanceSelector.get(),
    });
    expectSlotsShareFragment($instances.get(), ["slot1", "slot2"]);
    expect($instances.get().get("fragment")?.children).toEqual([
      { type: "id", value: "box" },
      { type: "id", value: "heading" },
    ]);
    expect($instances.get().has(wrapperId)).toBe(false);
  });

  test("converts legacy tag to element", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <Box tag="article" ws:id="articleId"></Box>
      </ws.element>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["articleId", "bodyId"]);
    convertInstance(elementComponent);
    const { instances: newInstances, props: newProps } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <ws.element ws:tag="article" ws:id="articleId"></ws.element>
      </ws.element>
    );
    expect({ instances: $instances.get(), props: $props.get() }).toEqual({
      instances: newInstances,
      props: newProps,
    });
  });

  test("migrates legacy properties", () => {
    const { instances, props } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <Box
          ws:tag="div"
          ws:id="divId"
          className="my-class"
          htmlFor="my-id"
        ></Box>
      </ws.element>
    );
    $instances.set(instances);
    $props.set(props);
    selectInstance(["divId", "bodyId"]);
    convertInstance(elementComponent);
    const { instances: newInstances, props: newProps } = renderData(
      <ws.element ws:tag="body" ws:id="bodyId">
        <ws.element
          ws:tag="div"
          ws:id="divId"
          class="my-class"
          for="my-id"
        ></ws.element>
      </ws.element>
    );
    expect({ instances: $instances.get(), props: $props.get() }).toEqual({
      instances: newInstances,
      props: newProps,
    });
  });

  test("preserves currently specified tag", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <Box ws:tag="article" ws:id="articleId"></Box>
        </ws.element>
      ).instances
    );
    selectInstance(["articleId", "bodyId"]);
    convertInstance(elementComponent);
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="article" ws:id="articleId"></ws.element>
        </ws.element>
      ).instances
    );
  });

  test("converts to first tag from presets", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <Heading ws:id="headingId"></Heading>
        </ws.element>
      ).instances
    );
    selectInstance(["headingId", "bodyId"]);
    convertInstance(elementComponent);
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="h1" ws:id="headingId"></ws.element>
        </ws.element>
      ).instances
    );
  });

  test("falls back to div", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <Box ws:id="divId"></Box>
        </ws.element>
      ).instances
    );
    selectInstance(["divId", "bodyId"]);
    convertInstance(elementComponent);
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="div" ws:id="divId"></ws.element>
        </ws.element>
      ).instances
    );
  });

  test("converts with specific tag", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <Box ws:id="divId"></Box>
        </ws.element>
      ).instances
    );
    selectInstance(["divId", "bodyId"]);
    convertInstance(elementComponent, "a");
    expect($instances.get()).toEqual(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <ws.element ws:tag="a" ws:id="divId"></ws.element>
        </ws.element>
      ).instances
    );
  });

  test("converts between components", () => {
    $instances.set(
      renderData(
        <ws.element ws:tag="body" ws:id="bodyId">
          <Box ws:id="boxId"></Box>
        </ws.element>
      ).instances
    );
    selectInstance(["boxId", "bodyId"]);
    convertInstance("@webstudio-is/sdk-components-react:Heading");
    const result = $instances.get();
    const boxInstance = result.get("boxId");
    expect(boxInstance?.component).toBe(
      "@webstudio-is/sdk-components-react:Heading"
    );
  });

  test("prevents converting root instance", () => {
    const initialInstances = renderData(
      <ws.element ws:tag="html" ws:id="rootId">
        <ws.element ws:tag="body" ws:id="bodyId"></ws.element>
      </ws.element>
    ).instances;
    $instances.set(initialInstances);
    selectInstance(["rootId"]);
    convertInstance(elementComponent, "div");
    // Should not change
    expect($instances.get()).toEqual(initialInstances);
  });

  test("prevents converting body instance", () => {
    const pages = createDefaultPages({ rootInstanceId: "bodyId" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);

    const initialInstances = renderData(
      <ws.element ws:tag="html" ws:id="rootId">
        <ws.element ws:tag="body" ws:id="bodyId">
          <Box ws:id="boxId"></Box>
        </ws.element>
      </ws.element>
    ).instances;
    $instances.set(initialInstances);
    selectInstance(["bodyId", "rootId"]);
    convertInstance(elementComponent, "div");
    // Should not change
    expect($instances.get()).toEqual(initialInstances);
  });
});

describe("deleteSelectedInstance", () => {
  test("delete selected instance and select next one", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Box ws:id="parent">
          <Box ws:id="child1"></Box>
          <Box ws:id="child2"></Box>
          <Box ws:id="child3"></Box>
        </Box>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["child2", "parent", "body"]);
    deleteSelectedInstance();
    expect($selectedInstanceSelector.get()).toEqual([
      "child3",
      "parent",
      "body",
    ]);
  });

  test("delete selected instance and select previous one", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Box ws:id="parent">
          <Box ws:id="child1"></Box>
          <Box ws:id="child2"></Box>
          <Box ws:id="child3"></Box>
        </Box>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["child3", "parent", "body"]);
    deleteSelectedInstance();
    expect($selectedInstanceSelector.get()).toEqual([
      "child2",
      "parent",
      "body",
    ]);
  });

  test("delete selected instance and select parent one", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Box ws:id="parent">
          <Box ws:id="child1"></Box>
        </Box>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["child1", "parent", "body"]);
    deleteSelectedInstance();
    expect($selectedInstanceSelector.get()).toEqual(["parent", "body"]);
  });

  test("delete selected legacy shared slot child and select next normalized sibling", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
          <Heading ws:id="heading"></Heading>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "slot1", "body"]);

    deleteSelectedInstance();

    const fragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    expect($selectedInstanceSelector.get()).toEqual([
      "heading",
      fragmentId,
      "slot1",
      "body",
    ]);
    expect($instances.get().get(fragmentId ?? "")?.children).toEqual([
      { type: "id", value: "heading" },
    ]);
  });

  test("delete last selected shared slot child and select visible slot occurrence", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Fragment ws:id="fragment">
            <Box ws:id="box"></Box>
          </Fragment>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "fragment", "slot1", "body"]);

    deleteSelectedInstance();

    expect($selectedInstanceSelector.get()).toEqual(["slot1", "body"]);
    expectSlotsShareFragment($instances.get(), ["slot1", "slot2"]);
    expect($instances.get().get("fragment")?.children).toEqual([]);
  });

  test("delete last selected legacy shared slot child and select visible slot occurrence", () => {
    const { instances } = renderData(
      <Body ws:id="body">
        <Slot ws:id="slot1">
          <Box ws:id="box"></Box>
        </Slot>
        <Slot ws:id="slot2">
          {/* same ids */}
          <Box ws:id="box"></Box>
        </Slot>
      </Body>
    );
    $instances.set(instances);
    const pages = createDefaultPages({ rootInstanceId: "body" });
    $pages.set(pages);
    $selectedPageId.set(pages.homePageId);
    selectInstance(["box", "slot1", "body"]);

    deleteSelectedInstance();

    const fragmentId = expectSlotsShareFragment($instances.get(), [
      "slot1",
      "slot2",
    ]);
    expect($selectedInstanceSelector.get()).toEqual(["slot1", "body"]);
    expect($instances.get().get(fragmentId ?? "")?.children).toEqual([]);
  });
});