@ndla/ui 56.0.13-alpha.0 → 56.0.15-alpha.0

package/es/TreeStructure/TreeStructure.js

@@ -1,209 +1,320 @@
-import _styled from "@emotion/styled/base";
-function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
 /**
- * Copyright (c) 2022-present, NDLA.
+ * Copyright (c) 2024-present, NDLA.
  *
  * This source code is licensed under the GPLv3 license found in the
  * LICENSE file in the root directory of this source tree.
  *
  */
 
-import { useEffect, useState, useMemo, useRef } from "react";
-import { colors, fonts, misc, utils } from "@ndla/core";
-import AddFolderButton from "./AddFolderButton";
-import ComboboxButton from "./ComboboxButton";
-import FolderItems from "./FolderItems";
-import { flattenFolders, treestructureId } from "./helperFunctions";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { flushSync } from "react-dom";
+import { useTranslation } from "react-i18next";
+import { useTreeView, usePopoverContext } from "@ark-ui/react";
+import { AddLine, HeartFill } from "@ndla/icons/action";
+import { ArrowDownShortLine, ArrowRightShortLine } from "@ndla/icons/common";
+import { FolderUserLine } from "@ndla/icons/contentType";
+import { FolderLine } from "@ndla/icons/editor";
+import { Button, IconButton, PopoverContent, PopoverRoot, PopoverTrigger, Tree, TreeBranch, TreeBranchContent, TreeBranchControl, TreeBranchIndicator, TreeBranchText, TreeBranchTrigger, TreeItem, TreeItemText, TreeLabel, TreeRootProvider } from "@ndla/primitives";
+import { HStack, Stack, styled } from "@ndla/styled-system/jsx";
+import { flattenFolders } from "./helperFunctions";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export const MAX_LEVEL_FOR_FOLDERS = 5;
-const uniq = array => Array.from(new Set(array));
-const StyledLabel = /*#__PURE__*/_styled("label", {
-  target: "e1dg1gdn4",
-  label: "StyledLabel"
-})("font-weight:", fonts.weight.semibold, ";" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TreeStructure.tsx"],"names":[],"mappings":"AAsBgC","file":"TreeStructure.tsx","sourcesContent":["/**\n * Copyright (c) 2022-present, NDLA.\n *\n * This source code is licensed under the GPLv3 license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { useEffect, useState, useMemo, useRef } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { colors, fonts, misc, utils } from \"@ndla/core\";\nimport { IFolder } from \"@ndla/types-backend/myndla-api\";\nimport AddFolderButton from \"./AddFolderButton\";\nimport ComboboxButton from \"./ComboboxButton\";\nimport FolderItems from \"./FolderItems\";\nimport { flattenFolders, treestructureId } from \"./helperFunctions\";\nimport { CommonTreeStructureProps, NewFolderInputFunc } from \"./types\";\n\nexport const MAX_LEVEL_FOR_FOLDERS = 5;\n\nconst uniq = <T,>(array: T[]): T[] => Array.from(new Set(array));\n\nconst StyledLabel = styled.label`\n  font-weight: ${fonts.weight.semibold};\n`;\n\nconst StyledTreeStructure = styled.div`\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst Row = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\n\nconst TreeStructureWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  transition: ${misc.transition.default};\n  &[data-type=\"picker\"] {\n    overflow: hidden;\n    border: 1px solid ${colors.brand.neutral7};\n    border-radius: ${misc.borderRadius};\n    scroll-behavior: smooth;\n  }\n  &:focus-within {\n    border-color: ${colors.brand.tertiary};\n  }\n`;\n\nconst ScrollableDiv = styled.div`\n  &[data-type=\"picker\"] {\n    overflow: auto;\n    overflow: overlay;\n    ${utils.scrollbar}\n  }\n`;\n\nexport interface TreeStructureProps extends CommonTreeStructureProps {\n  defaultOpenFolders?: string[];\n  folders: IFolder[];\n  label?: string;\n  maxLevel?: number;\n  newFolderInput?: NewFolderInputFunc;\n  onSelectFolder?: (id: string) => void;\n  ariaDescribedby?: string;\n}\n\nconst TreeStructure = ({\n  defaultOpenFolders,\n  folders,\n  label,\n  loading,\n  maxLevel = MAX_LEVEL_FOR_FOLDERS,\n  onSelectFolder,\n  targetResource,\n  type,\n  newFolderInput,\n  ariaDescribedby,\n}: TreeStructureProps) => {\n  const ref = useRef<HTMLButtonElement>(null);\n\n  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];\n\n  const [openFolders, setOpenFolders] = useState<string[]>(defaultOpenFolders || []);\n\n  const [newFolderParentId, setNewFolderParentId] = useState<string | undefined>();\n  const [focusedFolder, _setFocusedFolder] = useState<IFolder | undefined>();\n  const [selectedFolder, _setSelectedFolder] = useState<IFolder | undefined>();\n  const [showTree, setShowTree] = useState(type === \"navigation\");\n\n  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);\n\n  useEffect(() => {\n    if (defaultOpenFolders) {\n      if (!defaultOpenFolders.every((element) => openFolders.includes(element))) {\n        setOpenFolders((prev) => {\n          return uniq(defaultOpenFolders.concat(prev));\n        });\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultOpenFolders]);\n\n  useEffect(() => {\n    if (defaultSelectedFolderId !== undefined) {\n      const selected = flattenFolders(folders).find((folder) => folder.id === defaultSelectedFolderId);\n      if (selected) {\n        _setSelectedFolder(selected);\n        if (type === \"picker\") {\n          _setFocusedFolder(selected);\n        }\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultSelectedFolderId]);\n\n  const onToggleTree = (open: boolean) => {\n    setShowTree(open);\n    if (!open) {\n      setNewFolderParentId(undefined);\n    }\n  };\n\n  const setSelectedFolder = (folder: IFolder) => {\n    _setSelectedFolder(folder);\n    onSelectFolder?.(folder.id);\n  };\n\n  const setFocusedFolder = (folder: IFolder) => {\n    _setFocusedFolder(folder);\n    setNewFolderParentId(undefined);\n\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const onOpenFolder = (id: string) => {\n    setOpenFolders(uniq(openFolders.concat(id)));\n  };\n\n  const onCloseFolder = (id: string) => {\n    const closedFolder = flattenedFolders.find((folder) => folder.id === id);\n\n    if (closedFolder) {\n      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);\n      if (subFolders.some((folder) => folder.id === selectedFolder?.id)) {\n        setFocusedFolder(closedFolder);\n      }\n    }\n    setOpenFolders(openFolders.filter((folderId) => folderId !== id));\n  };\n\n  const onNewFolderCreated = (newFolder: IFolder | undefined, parentId: string) => {\n    if (newFolder) {\n      setSelectedFolder(newFolder);\n      setFocusedFolder(newFolder);\n      setOpenFolders(uniq(openFolders.concat(parentId)));\n      setNewFolderParentId?.(undefined);\n      ref.current?.focus({ preventScroll: true });\n    }\n  };\n\n  const onCancelNewFolder = () => {\n    setNewFolderParentId?.(undefined);\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);\n\n  return (\n    <StyledTreeStructure\n      onBlur={(e) => {\n        if (type === \"picker\" && !e.currentTarget.contains(e.relatedTarget)) {\n          onToggleTree(false);\n        }\n      }}\n    >\n      <Row>\n        {label && <StyledLabel id={treestructureId(type, \"label\")}>{label}</StyledLabel>}\n        {type === \"picker\" && (\n          <AddFolderButton\n            loading={loading}\n            canAddFolder={!!canAddFolder}\n            focusedFolder={focusedFolder}\n            setNewFolderParentId={setNewFolderParentId}\n            setShowTree={setShowTree}\n          />\n        )}\n      </Row>\n      <TreeStructureWrapper aria-label={label} data-type={type}>\n        {type === \"picker\" && (\n          <ComboboxButton\n            ref={ref}\n            showTree={showTree}\n            type={type}\n            label={label}\n            loading={loading}\n            focusedFolder={focusedFolder}\n            selectedFolder={selectedFolder}\n            setSelectedFolder={setSelectedFolder}\n            setFocusedFolder={setFocusedFolder}\n            onToggleTree={onToggleTree}\n            flattenedFolders={flattenedFolders}\n            onCloseFolder={onCloseFolder}\n            onOpenFolder={onOpenFolder}\n            ariaDescribedby={ariaDescribedby}\n          />\n        )}\n        {showTree && (\n          <ScrollableDiv data-type={type}>\n            <FolderItems\n              focusedFolder={focusedFolder}\n              folders={folders}\n              level={0}\n              loading={loading}\n              selectedFolder={selectedFolder}\n              maxLevel={maxLevel}\n              newFolderParentId={newFolderParentId}\n              onCancelNewFolder={onCancelNewFolder}\n              onCloseFolder={onCloseFolder}\n              onOpenFolder={onOpenFolder}\n              openFolders={openFolders}\n              setFocusedFolder={setFocusedFolder}\n              setSelectedFolder={setSelectedFolder}\n              targetResource={targetResource}\n              visibleFolders={flattenedFolders}\n              type={type}\n              closeTree={() => onToggleTree(false)}\n              newFolderInput={newFolderInput}\n              onCreate={onNewFolderCreated}\n            />\n          </ScrollableDiv>\n        )}\n      </TreeStructureWrapper>\n    </StyledTreeStructure>\n  );\n};\n\nexport default TreeStructure;\n"]} */"));
-const StyledTreeStructure = /*#__PURE__*/_styled("div", {
-  target: "e1dg1gdn3",
-  label: "StyledTreeStructure"
-})(process.env.NODE_ENV === "production" ? {
-  name: "1t91kdm",
-  styles: "flex:1;display:flex;flex-direction:column"
-} : {
-  name: "1t91kdm",
-  styles: "flex:1;display:flex;flex-direction:column",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TreeStructure.tsx"],"names":[],"mappings":"AA0BsC","file":"TreeStructure.tsx","sourcesContent":["/**\n * Copyright (c) 2022-present, NDLA.\n *\n * This source code is licensed under the GPLv3 license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { useEffect, useState, useMemo, useRef } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { colors, fonts, misc, utils } from \"@ndla/core\";\nimport { IFolder } from \"@ndla/types-backend/myndla-api\";\nimport AddFolderButton from \"./AddFolderButton\";\nimport ComboboxButton from \"./ComboboxButton\";\nimport FolderItems from \"./FolderItems\";\nimport { flattenFolders, treestructureId } from \"./helperFunctions\";\nimport { CommonTreeStructureProps, NewFolderInputFunc } from \"./types\";\n\nexport const MAX_LEVEL_FOR_FOLDERS = 5;\n\nconst uniq = <T,>(array: T[]): T[] => Array.from(new Set(array));\n\nconst StyledLabel = styled.label`\n  font-weight: ${fonts.weight.semibold};\n`;\n\nconst StyledTreeStructure = styled.div`\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst Row = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\n\nconst TreeStructureWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  transition: ${misc.transition.default};\n  &[data-type=\"picker\"] {\n    overflow: hidden;\n    border: 1px solid ${colors.brand.neutral7};\n    border-radius: ${misc.borderRadius};\n    scroll-behavior: smooth;\n  }\n  &:focus-within {\n    border-color: ${colors.brand.tertiary};\n  }\n`;\n\nconst ScrollableDiv = styled.div`\n  &[data-type=\"picker\"] {\n    overflow: auto;\n    overflow: overlay;\n    ${utils.scrollbar}\n  }\n`;\n\nexport interface TreeStructureProps extends CommonTreeStructureProps {\n  defaultOpenFolders?: string[];\n  folders: IFolder[];\n  label?: string;\n  maxLevel?: number;\n  newFolderInput?: NewFolderInputFunc;\n  onSelectFolder?: (id: string) => void;\n  ariaDescribedby?: string;\n}\n\nconst TreeStructure = ({\n  defaultOpenFolders,\n  folders,\n  label,\n  loading,\n  maxLevel = MAX_LEVEL_FOR_FOLDERS,\n  onSelectFolder,\n  targetResource,\n  type,\n  newFolderInput,\n  ariaDescribedby,\n}: TreeStructureProps) => {\n  const ref = useRef<HTMLButtonElement>(null);\n\n  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];\n\n  const [openFolders, setOpenFolders] = useState<string[]>(defaultOpenFolders || []);\n\n  const [newFolderParentId, setNewFolderParentId] = useState<string | undefined>();\n  const [focusedFolder, _setFocusedFolder] = useState<IFolder | undefined>();\n  const [selectedFolder, _setSelectedFolder] = useState<IFolder | undefined>();\n  const [showTree, setShowTree] = useState(type === \"navigation\");\n\n  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);\n\n  useEffect(() => {\n    if (defaultOpenFolders) {\n      if (!defaultOpenFolders.every((element) => openFolders.includes(element))) {\n        setOpenFolders((prev) => {\n          return uniq(defaultOpenFolders.concat(prev));\n        });\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultOpenFolders]);\n\n  useEffect(() => {\n    if (defaultSelectedFolderId !== undefined) {\n      const selected = flattenFolders(folders).find((folder) => folder.id === defaultSelectedFolderId);\n      if (selected) {\n        _setSelectedFolder(selected);\n        if (type === \"picker\") {\n          _setFocusedFolder(selected);\n        }\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultSelectedFolderId]);\n\n  const onToggleTree = (open: boolean) => {\n    setShowTree(open);\n    if (!open) {\n      setNewFolderParentId(undefined);\n    }\n  };\n\n  const setSelectedFolder = (folder: IFolder) => {\n    _setSelectedFolder(folder);\n    onSelectFolder?.(folder.id);\n  };\n\n  const setFocusedFolder = (folder: IFolder) => {\n    _setFocusedFolder(folder);\n    setNewFolderParentId(undefined);\n\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const onOpenFolder = (id: string) => {\n    setOpenFolders(uniq(openFolders.concat(id)));\n  };\n\n  const onCloseFolder = (id: string) => {\n    const closedFolder = flattenedFolders.find((folder) => folder.id === id);\n\n    if (closedFolder) {\n      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);\n      if (subFolders.some((folder) => folder.id === selectedFolder?.id)) {\n        setFocusedFolder(closedFolder);\n      }\n    }\n    setOpenFolders(openFolders.filter((folderId) => folderId !== id));\n  };\n\n  const onNewFolderCreated = (newFolder: IFolder | undefined, parentId: string) => {\n    if (newFolder) {\n      setSelectedFolder(newFolder);\n      setFocusedFolder(newFolder);\n      setOpenFolders(uniq(openFolders.concat(parentId)));\n      setNewFolderParentId?.(undefined);\n      ref.current?.focus({ preventScroll: true });\n    }\n  };\n\n  const onCancelNewFolder = () => {\n    setNewFolderParentId?.(undefined);\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);\n\n  return (\n    <StyledTreeStructure\n      onBlur={(e) => {\n        if (type === \"picker\" && !e.currentTarget.contains(e.relatedTarget)) {\n          onToggleTree(false);\n        }\n      }}\n    >\n      <Row>\n        {label && <StyledLabel id={treestructureId(type, \"label\")}>{label}</StyledLabel>}\n        {type === \"picker\" && (\n          <AddFolderButton\n            loading={loading}\n            canAddFolder={!!canAddFolder}\n            focusedFolder={focusedFolder}\n            setNewFolderParentId={setNewFolderParentId}\n            setShowTree={setShowTree}\n          />\n        )}\n      </Row>\n      <TreeStructureWrapper aria-label={label} data-type={type}>\n        {type === \"picker\" && (\n          <ComboboxButton\n            ref={ref}\n            showTree={showTree}\n            type={type}\n            label={label}\n            loading={loading}\n            focusedFolder={focusedFolder}\n            selectedFolder={selectedFolder}\n            setSelectedFolder={setSelectedFolder}\n            setFocusedFolder={setFocusedFolder}\n            onToggleTree={onToggleTree}\n            flattenedFolders={flattenedFolders}\n            onCloseFolder={onCloseFolder}\n            onOpenFolder={onOpenFolder}\n            ariaDescribedby={ariaDescribedby}\n          />\n        )}\n        {showTree && (\n          <ScrollableDiv data-type={type}>\n            <FolderItems\n              focusedFolder={focusedFolder}\n              folders={folders}\n              level={0}\n              loading={loading}\n              selectedFolder={selectedFolder}\n              maxLevel={maxLevel}\n              newFolderParentId={newFolderParentId}\n              onCancelNewFolder={onCancelNewFolder}\n              onCloseFolder={onCloseFolder}\n              onOpenFolder={onOpenFolder}\n              openFolders={openFolders}\n              setFocusedFolder={setFocusedFolder}\n              setSelectedFolder={setSelectedFolder}\n              targetResource={targetResource}\n              visibleFolders={flattenedFolders}\n              type={type}\n              closeTree={() => onToggleTree(false)}\n              newFolderInput={newFolderInput}\n              onCreate={onNewFolderCreated}\n            />\n          </ScrollableDiv>\n        )}\n      </TreeStructureWrapper>\n    </StyledTreeStructure>\n  );\n};\n\nexport default TreeStructure;\n"]} */",
-  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+const StyledButton = styled(Button, {
+  base: {
+    width: "100%",
+    justifyContent: "space-between",
+    "& span": {
+      overflow: "hidden",
+      textOverflow: "ellipsis"
+    }
+  }
+});
+const StyledHStack = styled(HStack, {
+  base: {
+    overflow: "hidden"
+  }
+});
+const StyledHeartFill = styled(HeartFill, {
+  base: {
+    color: "icon.strong"
+  }
+});
+const StyledFolderLine = styled(FolderLine, {
+  base: {
+    color: "icon.strong"
+  }
+});
+const StyledFolderUserLine = styled(FolderUserLine, {
+  base: {
+    color: "icon.strong"
+  }
 });
-const Row = /*#__PURE__*/_styled("div", {
-  target: "e1dg1gdn2",
-  label: "Row"
-})(process.env.NODE_ENV === "production" ? {
-  name: "bcffy2",
-  styles: "display:flex;align-items:center;justify-content:space-between"
-} : {
-  name: "bcffy2",
-  styles: "display:flex;align-items:center;justify-content:space-between",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TreeStructure.tsx"],"names":[],"mappings":"AAgCsB","file":"TreeStructure.tsx","sourcesContent":["/**\n * Copyright (c) 2022-present, NDLA.\n *\n * This source code is licensed under the GPLv3 license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { useEffect, useState, useMemo, useRef } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { colors, fonts, misc, utils } from \"@ndla/core\";\nimport { IFolder } from \"@ndla/types-backend/myndla-api\";\nimport AddFolderButton from \"./AddFolderButton\";\nimport ComboboxButton from \"./ComboboxButton\";\nimport FolderItems from \"./FolderItems\";\nimport { flattenFolders, treestructureId } from \"./helperFunctions\";\nimport { CommonTreeStructureProps, NewFolderInputFunc } from \"./types\";\n\nexport const MAX_LEVEL_FOR_FOLDERS = 5;\n\nconst uniq = <T,>(array: T[]): T[] => Array.from(new Set(array));\n\nconst StyledLabel = styled.label`\n  font-weight: ${fonts.weight.semibold};\n`;\n\nconst StyledTreeStructure = styled.div`\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst Row = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\n\nconst TreeStructureWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  transition: ${misc.transition.default};\n  &[data-type=\"picker\"] {\n    overflow: hidden;\n    border: 1px solid ${colors.brand.neutral7};\n    border-radius: ${misc.borderRadius};\n    scroll-behavior: smooth;\n  }\n  &:focus-within {\n    border-color: ${colors.brand.tertiary};\n  }\n`;\n\nconst ScrollableDiv = styled.div`\n  &[data-type=\"picker\"] {\n    overflow: auto;\n    overflow: overlay;\n    ${utils.scrollbar}\n  }\n`;\n\nexport interface TreeStructureProps extends CommonTreeStructureProps {\n  defaultOpenFolders?: string[];\n  folders: IFolder[];\n  label?: string;\n  maxLevel?: number;\n  newFolderInput?: NewFolderInputFunc;\n  onSelectFolder?: (id: string) => void;\n  ariaDescribedby?: string;\n}\n\nconst TreeStructure = ({\n  defaultOpenFolders,\n  folders,\n  label,\n  loading,\n  maxLevel = MAX_LEVEL_FOR_FOLDERS,\n  onSelectFolder,\n  targetResource,\n  type,\n  newFolderInput,\n  ariaDescribedby,\n}: TreeStructureProps) => {\n  const ref = useRef<HTMLButtonElement>(null);\n\n  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];\n\n  const [openFolders, setOpenFolders] = useState<string[]>(defaultOpenFolders || []);\n\n  const [newFolderParentId, setNewFolderParentId] = useState<string | undefined>();\n  const [focusedFolder, _setFocusedFolder] = useState<IFolder | undefined>();\n  const [selectedFolder, _setSelectedFolder] = useState<IFolder | undefined>();\n  const [showTree, setShowTree] = useState(type === \"navigation\");\n\n  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);\n\n  useEffect(() => {\n    if (defaultOpenFolders) {\n      if (!defaultOpenFolders.every((element) => openFolders.includes(element))) {\n        setOpenFolders((prev) => {\n          return uniq(defaultOpenFolders.concat(prev));\n        });\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultOpenFolders]);\n\n  useEffect(() => {\n    if (defaultSelectedFolderId !== undefined) {\n      const selected = flattenFolders(folders).find((folder) => folder.id === defaultSelectedFolderId);\n      if (selected) {\n        _setSelectedFolder(selected);\n        if (type === \"picker\") {\n          _setFocusedFolder(selected);\n        }\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultSelectedFolderId]);\n\n  const onToggleTree = (open: boolean) => {\n    setShowTree(open);\n    if (!open) {\n      setNewFolderParentId(undefined);\n    }\n  };\n\n  const setSelectedFolder = (folder: IFolder) => {\n    _setSelectedFolder(folder);\n    onSelectFolder?.(folder.id);\n  };\n\n  const setFocusedFolder = (folder: IFolder) => {\n    _setFocusedFolder(folder);\n    setNewFolderParentId(undefined);\n\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const onOpenFolder = (id: string) => {\n    setOpenFolders(uniq(openFolders.concat(id)));\n  };\n\n  const onCloseFolder = (id: string) => {\n    const closedFolder = flattenedFolders.find((folder) => folder.id === id);\n\n    if (closedFolder) {\n      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);\n      if (subFolders.some((folder) => folder.id === selectedFolder?.id)) {\n        setFocusedFolder(closedFolder);\n      }\n    }\n    setOpenFolders(openFolders.filter((folderId) => folderId !== id));\n  };\n\n  const onNewFolderCreated = (newFolder: IFolder | undefined, parentId: string) => {\n    if (newFolder) {\n      setSelectedFolder(newFolder);\n      setFocusedFolder(newFolder);\n      setOpenFolders(uniq(openFolders.concat(parentId)));\n      setNewFolderParentId?.(undefined);\n      ref.current?.focus({ preventScroll: true });\n    }\n  };\n\n  const onCancelNewFolder = () => {\n    setNewFolderParentId?.(undefined);\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);\n\n  return (\n    <StyledTreeStructure\n      onBlur={(e) => {\n        if (type === \"picker\" && !e.currentTarget.contains(e.relatedTarget)) {\n          onToggleTree(false);\n        }\n      }}\n    >\n      <Row>\n        {label && <StyledLabel id={treestructureId(type, \"label\")}>{label}</StyledLabel>}\n        {type === \"picker\" && (\n          <AddFolderButton\n            loading={loading}\n            canAddFolder={!!canAddFolder}\n            focusedFolder={focusedFolder}\n            setNewFolderParentId={setNewFolderParentId}\n            setShowTree={setShowTree}\n          />\n        )}\n      </Row>\n      <TreeStructureWrapper aria-label={label} data-type={type}>\n        {type === \"picker\" && (\n          <ComboboxButton\n            ref={ref}\n            showTree={showTree}\n            type={type}\n            label={label}\n            loading={loading}\n            focusedFolder={focusedFolder}\n            selectedFolder={selectedFolder}\n            setSelectedFolder={setSelectedFolder}\n            setFocusedFolder={setFocusedFolder}\n            onToggleTree={onToggleTree}\n            flattenedFolders={flattenedFolders}\n            onCloseFolder={onCloseFolder}\n            onOpenFolder={onOpenFolder}\n            ariaDescribedby={ariaDescribedby}\n          />\n        )}\n        {showTree && (\n          <ScrollableDiv data-type={type}>\n            <FolderItems\n              focusedFolder={focusedFolder}\n              folders={folders}\n              level={0}\n              loading={loading}\n              selectedFolder={selectedFolder}\n              maxLevel={maxLevel}\n              newFolderParentId={newFolderParentId}\n              onCancelNewFolder={onCancelNewFolder}\n              onCloseFolder={onCloseFolder}\n              onOpenFolder={onOpenFolder}\n              openFolders={openFolders}\n              setFocusedFolder={setFocusedFolder}\n              setSelectedFolder={setSelectedFolder}\n              targetResource={targetResource}\n              visibleFolders={flattenedFolders}\n              type={type}\n              closeTree={() => onToggleTree(false)}\n              newFolderInput={newFolderInput}\n              onCreate={onNewFolderCreated}\n            />\n          </ScrollableDiv>\n        )}\n      </TreeStructureWrapper>\n    </StyledTreeStructure>\n  );\n};\n\nexport default TreeStructure;\n"]} */",
-  toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+const StyledTreeRootProvider = styled(TreeRootProvider, {
+  base: {
+    width: "100%",
+    maxHeight: "inherit"
+  }
 });
-const TreeStructureWrapper = /*#__PURE__*/_styled("div", {
-  target: "e1dg1gdn1",
-  label: "TreeStructureWrapper"
-})("display:flex;flex-direction:column;transition:", misc.transition.default, ";&[data-type=\"picker\"]{overflow:hidden;border:1px solid ", colors.brand.neutral7, ";border-radius:", misc.borderRadius, ";scroll-behavior:smooth;}&:focus-within{border-color:", colors.brand.tertiary, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TreeStructure.tsx"],"names":[],"mappings":"AAsCuC","file":"TreeStructure.tsx","sourcesContent":["/**\n * Copyright (c) 2022-present, NDLA.\n *\n * This source code is licensed under the GPLv3 license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { useEffect, useState, useMemo, useRef } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { colors, fonts, misc, utils } from \"@ndla/core\";\nimport { IFolder } from \"@ndla/types-backend/myndla-api\";\nimport AddFolderButton from \"./AddFolderButton\";\nimport ComboboxButton from \"./ComboboxButton\";\nimport FolderItems from \"./FolderItems\";\nimport { flattenFolders, treestructureId } from \"./helperFunctions\";\nimport { CommonTreeStructureProps, NewFolderInputFunc } from \"./types\";\n\nexport const MAX_LEVEL_FOR_FOLDERS = 5;\n\nconst uniq = <T,>(array: T[]): T[] => Array.from(new Set(array));\n\nconst StyledLabel = styled.label`\n  font-weight: ${fonts.weight.semibold};\n`;\n\nconst StyledTreeStructure = styled.div`\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst Row = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\n\nconst TreeStructureWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  transition: ${misc.transition.default};\n  &[data-type=\"picker\"] {\n    overflow: hidden;\n    border: 1px solid ${colors.brand.neutral7};\n    border-radius: ${misc.borderRadius};\n    scroll-behavior: smooth;\n  }\n  &:focus-within {\n    border-color: ${colors.brand.tertiary};\n  }\n`;\n\nconst ScrollableDiv = styled.div`\n  &[data-type=\"picker\"] {\n    overflow: auto;\n    overflow: overlay;\n    ${utils.scrollbar}\n  }\n`;\n\nexport interface TreeStructureProps extends CommonTreeStructureProps {\n  defaultOpenFolders?: string[];\n  folders: IFolder[];\n  label?: string;\n  maxLevel?: number;\n  newFolderInput?: NewFolderInputFunc;\n  onSelectFolder?: (id: string) => void;\n  ariaDescribedby?: string;\n}\n\nconst TreeStructure = ({\n  defaultOpenFolders,\n  folders,\n  label,\n  loading,\n  maxLevel = MAX_LEVEL_FOR_FOLDERS,\n  onSelectFolder,\n  targetResource,\n  type,\n  newFolderInput,\n  ariaDescribedby,\n}: TreeStructureProps) => {\n  const ref = useRef<HTMLButtonElement>(null);\n\n  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];\n\n  const [openFolders, setOpenFolders] = useState<string[]>(defaultOpenFolders || []);\n\n  const [newFolderParentId, setNewFolderParentId] = useState<string | undefined>();\n  const [focusedFolder, _setFocusedFolder] = useState<IFolder | undefined>();\n  const [selectedFolder, _setSelectedFolder] = useState<IFolder | undefined>();\n  const [showTree, setShowTree] = useState(type === \"navigation\");\n\n  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);\n\n  useEffect(() => {\n    if (defaultOpenFolders) {\n      if (!defaultOpenFolders.every((element) => openFolders.includes(element))) {\n        setOpenFolders((prev) => {\n          return uniq(defaultOpenFolders.concat(prev));\n        });\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultOpenFolders]);\n\n  useEffect(() => {\n    if (defaultSelectedFolderId !== undefined) {\n      const selected = flattenFolders(folders).find((folder) => folder.id === defaultSelectedFolderId);\n      if (selected) {\n        _setSelectedFolder(selected);\n        if (type === \"picker\") {\n          _setFocusedFolder(selected);\n        }\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultSelectedFolderId]);\n\n  const onToggleTree = (open: boolean) => {\n    setShowTree(open);\n    if (!open) {\n      setNewFolderParentId(undefined);\n    }\n  };\n\n  const setSelectedFolder = (folder: IFolder) => {\n    _setSelectedFolder(folder);\n    onSelectFolder?.(folder.id);\n  };\n\n  const setFocusedFolder = (folder: IFolder) => {\n    _setFocusedFolder(folder);\n    setNewFolderParentId(undefined);\n\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const onOpenFolder = (id: string) => {\n    setOpenFolders(uniq(openFolders.concat(id)));\n  };\n\n  const onCloseFolder = (id: string) => {\n    const closedFolder = flattenedFolders.find((folder) => folder.id === id);\n\n    if (closedFolder) {\n      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);\n      if (subFolders.some((folder) => folder.id === selectedFolder?.id)) {\n        setFocusedFolder(closedFolder);\n      }\n    }\n    setOpenFolders(openFolders.filter((folderId) => folderId !== id));\n  };\n\n  const onNewFolderCreated = (newFolder: IFolder | undefined, parentId: string) => {\n    if (newFolder) {\n      setSelectedFolder(newFolder);\n      setFocusedFolder(newFolder);\n      setOpenFolders(uniq(openFolders.concat(parentId)));\n      setNewFolderParentId?.(undefined);\n      ref.current?.focus({ preventScroll: true });\n    }\n  };\n\n  const onCancelNewFolder = () => {\n    setNewFolderParentId?.(undefined);\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);\n\n  return (\n    <StyledTreeStructure\n      onBlur={(e) => {\n        if (type === \"picker\" && !e.currentTarget.contains(e.relatedTarget)) {\n          onToggleTree(false);\n        }\n      }}\n    >\n      <Row>\n        {label && <StyledLabel id={treestructureId(type, \"label\")}>{label}</StyledLabel>}\n        {type === \"picker\" && (\n          <AddFolderButton\n            loading={loading}\n            canAddFolder={!!canAddFolder}\n            focusedFolder={focusedFolder}\n            setNewFolderParentId={setNewFolderParentId}\n            setShowTree={setShowTree}\n          />\n        )}\n      </Row>\n      <TreeStructureWrapper aria-label={label} data-type={type}>\n        {type === \"picker\" && (\n          <ComboboxButton\n            ref={ref}\n            showTree={showTree}\n            type={type}\n            label={label}\n            loading={loading}\n            focusedFolder={focusedFolder}\n            selectedFolder={selectedFolder}\n            setSelectedFolder={setSelectedFolder}\n            setFocusedFolder={setFocusedFolder}\n            onToggleTree={onToggleTree}\n            flattenedFolders={flattenedFolders}\n            onCloseFolder={onCloseFolder}\n            onOpenFolder={onOpenFolder}\n            ariaDescribedby={ariaDescribedby}\n          />\n        )}\n        {showTree && (\n          <ScrollableDiv data-type={type}>\n            <FolderItems\n              focusedFolder={focusedFolder}\n              folders={folders}\n              level={0}\n              loading={loading}\n              selectedFolder={selectedFolder}\n              maxLevel={maxLevel}\n              newFolderParentId={newFolderParentId}\n              onCancelNewFolder={onCancelNewFolder}\n              onCloseFolder={onCloseFolder}\n              onOpenFolder={onOpenFolder}\n              openFolders={openFolders}\n              setFocusedFolder={setFocusedFolder}\n              setSelectedFolder={setSelectedFolder}\n              targetResource={targetResource}\n              visibleFolders={flattenedFolders}\n              type={type}\n              closeTree={() => onToggleTree(false)}\n              newFolderInput={newFolderInput}\n              onCreate={onNewFolderCreated}\n            />\n          </ScrollableDiv>\n        )}\n      </TreeStructureWrapper>\n    </StyledTreeStructure>\n  );\n};\n\nexport default TreeStructure;\n"]} */"));
-const ScrollableDiv = /*#__PURE__*/_styled("div", {
-  target: "e1dg1gdn0",
-  label: "ScrollableDiv"
-})("&[data-type=\"picker\"]{overflow:auto;overflow:overlay;", utils.scrollbar, ";}" + (process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["TreeStructure.tsx"],"names":[],"mappings":"AAqDgC","file":"TreeStructure.tsx","sourcesContent":["/**\n * Copyright (c) 2022-present, NDLA.\n *\n * This source code is licensed under the GPLv3 license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { useEffect, useState, useMemo, useRef } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { colors, fonts, misc, utils } from \"@ndla/core\";\nimport { IFolder } from \"@ndla/types-backend/myndla-api\";\nimport AddFolderButton from \"./AddFolderButton\";\nimport ComboboxButton from \"./ComboboxButton\";\nimport FolderItems from \"./FolderItems\";\nimport { flattenFolders, treestructureId } from \"./helperFunctions\";\nimport { CommonTreeStructureProps, NewFolderInputFunc } from \"./types\";\n\nexport const MAX_LEVEL_FOR_FOLDERS = 5;\n\nconst uniq = <T,>(array: T[]): T[] => Array.from(new Set(array));\n\nconst StyledLabel = styled.label`\n  font-weight: ${fonts.weight.semibold};\n`;\n\nconst StyledTreeStructure = styled.div`\n  flex: 1;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst Row = styled.div`\n  display: flex;\n  align-items: center;\n  justify-content: space-between;\n`;\n\nconst TreeStructureWrapper = styled.div`\n  display: flex;\n  flex-direction: column;\n  transition: ${misc.transition.default};\n  &[data-type=\"picker\"] {\n    overflow: hidden;\n    border: 1px solid ${colors.brand.neutral7};\n    border-radius: ${misc.borderRadius};\n    scroll-behavior: smooth;\n  }\n  &:focus-within {\n    border-color: ${colors.brand.tertiary};\n  }\n`;\n\nconst ScrollableDiv = styled.div`\n  &[data-type=\"picker\"] {\n    overflow: auto;\n    overflow: overlay;\n    ${utils.scrollbar}\n  }\n`;\n\nexport interface TreeStructureProps extends CommonTreeStructureProps {\n  defaultOpenFolders?: string[];\n  folders: IFolder[];\n  label?: string;\n  maxLevel?: number;\n  newFolderInput?: NewFolderInputFunc;\n  onSelectFolder?: (id: string) => void;\n  ariaDescribedby?: string;\n}\n\nconst TreeStructure = ({\n  defaultOpenFolders,\n  folders,\n  label,\n  loading,\n  maxLevel = MAX_LEVEL_FOR_FOLDERS,\n  onSelectFolder,\n  targetResource,\n  type,\n  newFolderInput,\n  ariaDescribedby,\n}: TreeStructureProps) => {\n  const ref = useRef<HTMLButtonElement>(null);\n\n  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];\n\n  const [openFolders, setOpenFolders] = useState<string[]>(defaultOpenFolders || []);\n\n  const [newFolderParentId, setNewFolderParentId] = useState<string | undefined>();\n  const [focusedFolder, _setFocusedFolder] = useState<IFolder | undefined>();\n  const [selectedFolder, _setSelectedFolder] = useState<IFolder | undefined>();\n  const [showTree, setShowTree] = useState(type === \"navigation\");\n\n  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);\n\n  useEffect(() => {\n    if (defaultOpenFolders) {\n      if (!defaultOpenFolders.every((element) => openFolders.includes(element))) {\n        setOpenFolders((prev) => {\n          return uniq(defaultOpenFolders.concat(prev));\n        });\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultOpenFolders]);\n\n  useEffect(() => {\n    if (defaultSelectedFolderId !== undefined) {\n      const selected = flattenFolders(folders).find((folder) => folder.id === defaultSelectedFolderId);\n      if (selected) {\n        _setSelectedFolder(selected);\n        if (type === \"picker\") {\n          _setFocusedFolder(selected);\n        }\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [defaultSelectedFolderId]);\n\n  const onToggleTree = (open: boolean) => {\n    setShowTree(open);\n    if (!open) {\n      setNewFolderParentId(undefined);\n    }\n  };\n\n  const setSelectedFolder = (folder: IFolder) => {\n    _setSelectedFolder(folder);\n    onSelectFolder?.(folder.id);\n  };\n\n  const setFocusedFolder = (folder: IFolder) => {\n    _setFocusedFolder(folder);\n    setNewFolderParentId(undefined);\n\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const onOpenFolder = (id: string) => {\n    setOpenFolders(uniq(openFolders.concat(id)));\n  };\n\n  const onCloseFolder = (id: string) => {\n    const closedFolder = flattenedFolders.find((folder) => folder.id === id);\n\n    if (closedFolder) {\n      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);\n      if (subFolders.some((folder) => folder.id === selectedFolder?.id)) {\n        setFocusedFolder(closedFolder);\n      }\n    }\n    setOpenFolders(openFolders.filter((folderId) => folderId !== id));\n  };\n\n  const onNewFolderCreated = (newFolder: IFolder | undefined, parentId: string) => {\n    if (newFolder) {\n      setSelectedFolder(newFolder);\n      setFocusedFolder(newFolder);\n      setOpenFolders(uniq(openFolders.concat(parentId)));\n      setNewFolderParentId?.(undefined);\n      ref.current?.focus({ preventScroll: true });\n    }\n  };\n\n  const onCancelNewFolder = () => {\n    setNewFolderParentId?.(undefined);\n    ref.current?.focus({ preventScroll: true });\n  };\n\n  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);\n\n  return (\n    <StyledTreeStructure\n      onBlur={(e) => {\n        if (type === \"picker\" && !e.currentTarget.contains(e.relatedTarget)) {\n          onToggleTree(false);\n        }\n      }}\n    >\n      <Row>\n        {label && <StyledLabel id={treestructureId(type, \"label\")}>{label}</StyledLabel>}\n        {type === \"picker\" && (\n          <AddFolderButton\n            loading={loading}\n            canAddFolder={!!canAddFolder}\n            focusedFolder={focusedFolder}\n            setNewFolderParentId={setNewFolderParentId}\n            setShowTree={setShowTree}\n          />\n        )}\n      </Row>\n      <TreeStructureWrapper aria-label={label} data-type={type}>\n        {type === \"picker\" && (\n          <ComboboxButton\n            ref={ref}\n            showTree={showTree}\n            type={type}\n            label={label}\n            loading={loading}\n            focusedFolder={focusedFolder}\n            selectedFolder={selectedFolder}\n            setSelectedFolder={setSelectedFolder}\n            setFocusedFolder={setFocusedFolder}\n            onToggleTree={onToggleTree}\n            flattenedFolders={flattenedFolders}\n            onCloseFolder={onCloseFolder}\n            onOpenFolder={onOpenFolder}\n            ariaDescribedby={ariaDescribedby}\n          />\n        )}\n        {showTree && (\n          <ScrollableDiv data-type={type}>\n            <FolderItems\n              focusedFolder={focusedFolder}\n              folders={folders}\n              level={0}\n              loading={loading}\n              selectedFolder={selectedFolder}\n              maxLevel={maxLevel}\n              newFolderParentId={newFolderParentId}\n              onCancelNewFolder={onCancelNewFolder}\n              onCloseFolder={onCloseFolder}\n              onOpenFolder={onOpenFolder}\n              openFolders={openFolders}\n              setFocusedFolder={setFocusedFolder}\n              setSelectedFolder={setSelectedFolder}\n              targetResource={targetResource}\n              visibleFolders={flattenedFolders}\n              type={type}\n              closeTree={() => onToggleTree(false)}\n              newFolderInput={newFolderInput}\n              onCreate={onNewFolderCreated}\n            />\n          </ScrollableDiv>\n        )}\n      </TreeStructureWrapper>\n    </StyledTreeStructure>\n  );\n};\n\nexport default TreeStructure;\n"]} */"));
-const TreeStructure = _ref => {
+const StyledPopoverContent = styled(PopoverContent, {
+  base: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "xsmall",
+    overflow: "auto",
+    maxHeight: "inherit",
+    paddingInline: "xsmall",
+    paddingBlock: "xsmall"
+  }
+});
+const LabelHStack = styled(HStack, {
+  base: {
+    width: "100%"
+  }
+});
+export const TreeStructure = _ref => {
   let {
-    defaultOpenFolders,
     folders,
+    defaultOpenFolders,
+    newFolderInput,
     label,
+    targetResource,
     loading,
     maxLevel = MAX_LEVEL_FOR_FOLDERS,
     onSelectFolder,
-    targetResource,
-    type,
-    newFolderInput,
     ariaDescribedby
   } = _ref;
-  const ref = useRef(null);
-  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];
-  const [openFolders, setOpenFolders] = useState(defaultOpenFolders || []);
-  const [newFolderParentId, setNewFolderParentId] = useState();
-  const [focusedFolder, _setFocusedFolder] = useState();
-  const [selectedFolder, _setSelectedFolder] = useState();
-  const [showTree, setShowTree] = useState(type === "navigation");
-  const flattenedFolders = useMemo(() => flattenFolders(folders, openFolders), [folders, openFolders]);
-  useEffect(() => {
-    if (defaultOpenFolders) {
-      if (!defaultOpenFolders.every(element => openFolders.includes(element))) {
-        setOpenFolders(prev => {
-          return uniq(defaultOpenFolders.concat(prev));
-        });
-      }
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [defaultOpenFolders]);
-  useEffect(() => {
-    if (defaultSelectedFolderId !== undefined) {
-      const selected = flattenFolders(folders).find(folder => folder.id === defaultSelectedFolderId);
-      if (selected) {
-        _setSelectedFolder(selected);
-        if (type === "picker") {
-          _setFocusedFolder(selected);
-        }
-      }
+  const [open, setOpen] = useState(false);
+  const [selectedValue, setSelectedValue] = useState(defaultOpenFolders?.[defaultOpenFolders?.length - 1] ?? "");
+  const [expandedValue, setExpandedValue] = useState(defaultOpenFolders ?? []);
+  const [focusedValue, setFocusedValue] = useState(selectedValue);
+  const [newFolderParentId, setNewFolderParentId] = useState(null);
+  const newFolderButtonRef = useRef(null);
+  const {
+    t
+  } = useTranslation();
+  const rootFolderIds = useMemo(() => folders.map(folder => folder.id), [folders]);
+  const contentRef = useRef(null);
+  const selectedFolder = useMemo(() => {
+    return flattenFolders(folders).find(folder => folder.id === selectedValue);
+  }, [folders, selectedValue]);
+  const disableCreateFolder = useMemo(() => {
+    return (selectedFolder?.breadcrumbs.length ?? 0) > maxLevel - 1;
+  }, [maxLevel, selectedFolder?.breadcrumbs.length]);
+  const onOpenChange = useCallback(details => {
+    setOpen(details.open);
+    if (!details.open) {
+      setNewFolderParentId(null);
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [defaultSelectedFolderId]);
-  const onToggleTree = open => {
-    setShowTree(open);
-    if (!open) {
-      setNewFolderParentId(undefined);
+  }, []);
+  const onKeyDown = useCallback(e => {
+    if (e.key === "ArrowUp" || e.key === "ArrowDown") {
+      e.stopPropagation();
+      setOpen(true);
     }
-  };
-  const setSelectedFolder = folder => {
-    _setSelectedFolder(folder);
-    onSelectFolder?.(folder.id);
-  };
-  const setFocusedFolder = folder => {
-    _setFocusedFolder(folder);
-    setNewFolderParentId(undefined);
-    ref.current?.focus({
-      preventScroll: true
-    });
-  };
-  const onOpenFolder = id => {
-    setOpenFolders(uniq(openFolders.concat(id)));
-  };
-  const onCloseFolder = id => {
-    const closedFolder = flattenedFolders.find(folder => folder.id === id);
-    if (closedFolder) {
-      const subFolders = closedFolder.subfolders && flattenFolders(closedFolder.subfolders);
-      if (subFolders.some(folder => folder.id === selectedFolder?.id)) {
-        setFocusedFolder(closedFolder);
+  }, []);
+  const onShowInput = useCallback(() => {
+    if (disableCreateFolder) return;
+    const flattenedFolders = flattenFolders(folders);
+    const folder = flattenedFolders.find(folder => folder.id === selectedValue);
+    const newExpandedIds = rootFolderIds.concat(folder?.breadcrumbs.map(bc => bc.id) ?? []);
+    setOpen(true);
+    setExpandedValue(prev => Array.from(new Set([...prev, ...newExpandedIds])));
+    setNewFolderParentId(selectedValue);
+  }, [disableCreateFolder, folders, rootFolderIds, selectedValue]);
+  const treeView = useTreeView({
+    focusedValue,
+    onFocusChange: details => !!details.focusedValue && setFocusedValue(details.focusedValue),
+    expandedValue,
+    onExpandedChange: details => setExpandedValue(details.expandedValue),
+    selectedValue: [selectedValue],
+    onSelectionChange: details => {
+      // TODO: This is currently a bug in zag. The TreeView component simply expects the already selected value to remain selected. As such, always choose the "last" selected value.
+      const val = details.selectedValue[details.selectedValue.length - 1];
+      if (!val) return;
+      if (val === selectedValue && details.focusedValue === selectedValue) {
+        setOpen(false);
+        return;
       }
-    }
-    setOpenFolders(openFolders.filter(folderId => folderId !== id));
-  };
-  const onNewFolderCreated = (newFolder, parentId) => {
-    if (newFolder) {
-      setSelectedFolder(newFolder);
-      setFocusedFolder(newFolder);
-      setOpenFolders(uniq(openFolders.concat(parentId)));
-      setNewFolderParentId?.(undefined);
-      ref.current?.focus({
-        preventScroll: true
+      setSelectedValue(val);
+      onSelectFolder?.(val);
+    },
+    expandOnClick: false
+  });
+  const onCreateFolder = useCallback(folder => {
+    if (!folder) return;
+    const focus = treeView.focusItem;
+    const expand = treeView.expand;
+    const select = treeView.select;
+    flushSync(() => {
+      setOpen(true);
+    });
+    flushSync(() => {
+      expand(folder.breadcrumbs.map(bc => bc.id));
+    });
+    flushSync(() => {
+      select([folder.id]);
+    });
+    flushSync(() => {
+      focus(folder.id);
+    });
+    setNewFolderParentId(null);
+  }, [treeView.expand, treeView.focusItem, treeView.select]);
+  const onAnimationEnd = useCallback(() => {
+    if (open && focusedValue) {
+      document.getElementById(focusedValue)?.scrollIntoView({
+        behavior: "smooth",
+        block: "nearest"
       });
     }
-  };
-  const onCancelNewFolder = () => {
-    setNewFolderParentId?.(undefined);
-    ref.current?.focus({
-      preventScroll: true
-    });
-  };
-  const canAddFolder = selectedFolder && selectedFolder?.breadcrumbs.length < (maxLevel || 1);
-  return /*#__PURE__*/_jsxs(StyledTreeStructure, {
-    onBlur: e => {
-      if (type === "picker" && !e.currentTarget.contains(e.relatedTarget)) {
-        onToggleTree(false);
-      }
-    },
-    children: [/*#__PURE__*/_jsxs(Row, {
-      children: [label && /*#__PURE__*/_jsx(StyledLabel, {
-        id: treestructureId(type, "label"),
-        children: label
-      }), type === "picker" && /*#__PURE__*/_jsx(AddFolderButton, {
-        loading: loading,
-        canAddFolder: !!canAddFolder,
-        focusedFolder: focusedFolder,
-        setNewFolderParentId: setNewFolderParentId,
-        setShowTree: setShowTree
-      })]
-    }), /*#__PURE__*/_jsxs(TreeStructureWrapper, {
-      "aria-label": label,
-      "data-type": type,
-      children: [type === "picker" && /*#__PURE__*/_jsx(ComboboxButton, {
-        ref: ref,
-        showTree: showTree,
-        type: type,
-        label: label,
-        loading: loading,
-        focusedFolder: focusedFolder,
-        selectedFolder: selectedFolder,
-        setSelectedFolder: setSelectedFolder,
-        setFocusedFolder: setFocusedFolder,
-        onToggleTree: onToggleTree,
-        flattenedFolders: flattenedFolders,
-        onCloseFolder: onCloseFolder,
-        onOpenFolder: onOpenFolder,
-        ariaDescribedby: ariaDescribedby
-      }), showTree && /*#__PURE__*/_jsx(ScrollableDiv, {
-        "data-type": type,
-        children: /*#__PURE__*/_jsx(FolderItems, {
-          focusedFolder: focusedFolder,
-          folders: folders,
-          level: 0,
+  }, [focusedValue, open]);
+  const onCancelFolder = useCallback(() => {
+    if (!selectedFolder) return;
+    const focusFunc = selectedFolder.subfolders.length ? treeView.focusBranch : treeView.focusItem;
+    focusFunc(selectedFolder.id);
+    setNewFolderParentId(null);
+  }, [selectedFolder, treeView.focusBranch, treeView.focusItem]);
+  const addTooltip = loading ? t("loading") : disableCreateFolder ? t("treeStructure.maxFoldersAlreadyAdded") : t("myNdla.newFolderUnder", {
+    folderName: selectedFolder?.name
+  });
+  return /*#__PURE__*/_jsx(StyledTreeRootProvider, {
+    value: treeView,
+    asChild: true,
+    ...treeView.getRootProps(),
+    children: /*#__PURE__*/_jsxs(Stack, {
+      align: "flex-end",
+      children: [/*#__PURE__*/_jsxs(LabelHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/_jsx(TreeLabel, {
+          children: label
+        }), /*#__PURE__*/_jsxs(Button, {
+          size: "small",
+          variant: "tertiary",
+          ref: newFolderButtonRef,
+          "aria-disabled": disableCreateFolder,
+          title: addTooltip,
+          "aria-label": addTooltip,
           loading: loading,
-          selectedFolder: selectedFolder,
-          maxLevel: maxLevel,
-          newFolderParentId: newFolderParentId,
-          onCancelNewFolder: onCancelNewFolder,
-          onCloseFolder: onCloseFolder,
-          onOpenFolder: onOpenFolder,
-          openFolders: openFolders,
-          setFocusedFolder: setFocusedFolder,
-          setSelectedFolder: setSelectedFolder,
-          targetResource: targetResource,
-          visibleFolders: flattenedFolders,
-          type: type,
-          closeTree: () => onToggleTree(false),
-          newFolderInput: newFolderInput,
-          onCreate: onNewFolderCreated
-        })
+          onClick: onShowInput,
+          children: [/*#__PURE__*/_jsx(AddLine, {}), t("myNdla.newFolder")]
+        })]
+      }), /*#__PURE__*/_jsxs(PopoverRoot, {
+        open: open,
+        positioning: {
+          sameWidth: true
+        },
+        onOpenChange: onOpenChange,
+        persistentElements: [() => newFolderButtonRef.current],
+        initialFocusEl: () => contentRef.current?.querySelector("input") ?? null,
+        children: [/*#__PURE__*/_jsx(PopoverTrigger, {
+          asChild: true,
+          children: /*#__PURE__*/_jsxs(StyledButton, {
+            variant: "secondary",
+            onKeyDown: onKeyDown,
+            "aria-haspopup": "tree",
+            role: "combobox",
+            "aria-describedby": ariaDescribedby,
+            "aria-activedescendant": focusedValue ?? undefined,
+            children: [/*#__PURE__*/_jsx("span", {
+              children: selectedFolder?.name
+            }), /*#__PURE__*/_jsx(ArrowDownShortLine, {})]
+          })
+        }), /*#__PURE__*/_jsxs(StyledPopoverContent, {
+          onAnimationEnd: onAnimationEnd,
+          ref: contentRef,
+          children: [!!newFolderParentId && newFolderInput?.({
+            parentId: newFolderParentId,
+            onCreate: onCreateFolder,
+            onCancel: onCancelFolder
+          }), /*#__PURE__*/_jsx(Tree, {
+            children: folders.map(folder => /*#__PURE__*/_jsx(TreeStructureItem, {
+              folder: folder,
+              targetResource: targetResource
+            }, folder.id))
+          })]
+        })]
       })]
-    })]
+    })
   });
 };
-export default TreeStructure;
+const TreeStructureItem = _ref2 => {
+  let {
+    folder,
+    targetResource
+  } = _ref2;
+  const {
+    t
+  } = useTranslation();
+  const {
+    setOpen
+  } = usePopoverContext();
+  const containsResource = targetResource && folder.resources.some(resource => resource.resourceId === targetResource.resourceId);
+  const FolderIcon = folder.status === "shared" ? StyledFolderUserLine : StyledFolderLine;
+
+  // TODO: Pressing enter selects the item and closes the popover immediately. Do we actually want this? Old behavior.
+  const onKeyDown = useCallback(e => {
+    if (e.key === "Enter") {
+      setOpen(false);
+    }
+  }, [setOpen]);
+  if (!folder.subfolders.length) {
+    return /*#__PURE__*/_jsx(TreeItem, {
+      value: folder.id,
+      onKeyDown: onKeyDown,
+      id: folder.id,
+      children: /*#__PURE__*/_jsxs(StyledHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/_jsxs(StyledHStack, {
+          gap: "xxsmall",
+          justify: "center",
+          children: [/*#__PURE__*/_jsx(FolderIcon, {}), /*#__PURE__*/_jsx(TreeItemText, {
+            children: folder.name
+          })]
+        }), containsResource && /*#__PURE__*/_jsx(StyledHeartFill, {
+          title: t("myNdla.alreadyInFolder")
+        })]
+      })
+    }, folder.id);
+  }
+  const ariaLabel = folder.status === "shared" ? `${folder.name}. ${t("myNdla.folder.sharing.shared")}` : folder.name;
+  return /*#__PURE__*/_jsxs(TreeBranch, {
+    value: folder.id,
+    id: folder.id,
+    children: [/*#__PURE__*/_jsx(TreeBranchControl, {
+      onKeyDown: onKeyDown,
+      asChild: true,
+      children: /*#__PURE__*/_jsxs(StyledHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/_jsxs(StyledHStack, {
+          gap: "xxsmall",
+          justify: "center",
+          children: [/*#__PURE__*/_jsx(IconButton, {
+            variant: "clear",
+            asChild: true,
+            children: /*#__PURE__*/_jsx(TreeBranchTrigger, {
+              children: /*#__PURE__*/_jsx(TreeBranchIndicator, {
+                asChild: true,
+                children: /*#__PURE__*/_jsx(ArrowRightShortLine, {})
+              })
+            })
+          }), /*#__PURE__*/_jsx(FolderIcon, {}), /*#__PURE__*/_jsx(TreeBranchText, {
+            "aria-label": ariaLabel,
+            title: ariaLabel,
+            children: folder.name
+          })]
+        }), containsResource && /*#__PURE__*/_jsx(StyledHeartFill, {
+          title: t("myNdla.alreadyInFolder"),
+          "aria-label": t("myNdla.alreadyInFolder"),
+          "aria-hidden": false
+        })]
+      })
+    }), /*#__PURE__*/_jsx(TreeBranchContent, {
+      children: folder.subfolders.map(subfolder => /*#__PURE__*/_jsx(TreeStructureItem, {
+        folder: subfolder,
+        targetResource: targetResource
+      }, subfolder.id))
+    })]
+  }, folder.id);
+};

package/es/TreeStructure/helperFunctions.js

@@ -26,7 +26,4 @@ export const flattenFolders = (folders, openFolders) => {
       ...rest
     }, flattenFolders(subfolders, openFolders));
   }, []);
-};
-export const treestructureId = (type, modifier) => {
-  return `${type}-treestructure-${modifier}`;
 };

package/es/TreeStructure/index.js

@@ -6,5 +6,4 @@
  *
  */
 
-import TreeStructure from "./TreeStructure";
-export { TreeStructure };
+export { TreeStructure } from "./TreeStructure";