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

package/lib/TreeStructure/TreeStructure.js

@@ -3,212 +3,325 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.MAX_LEVEL_FOR_FOLDERS = void 0;
-var _base = _interopRequireDefault(require("@emotion/styled/base"));
+exports.TreeStructure = exports.MAX_LEVEL_FOR_FOLDERS = void 0;
 var _react = require("react");
-var _core = require("@ndla/core");
-var _AddFolderButton = _interopRequireDefault(require("./AddFolderButton"));
-var _ComboboxButton = _interopRequireDefault(require("./ComboboxButton"));
-var _FolderItems = _interopRequireDefault(require("./FolderItems"));
+var _reactDom = require("react-dom");
+var _reactI18next = require("react-i18next");
+var _react2 = require("@ark-ui/react");
+var _action = require("@ndla/icons/action");
+var _common = require("@ndla/icons/common");
+var _contentType = require("@ndla/icons/contentType");
+var _editor = require("@ndla/icons/editor");
+var _primitives = require("@ndla/primitives");
+var _jsx2 = require("@ndla/styled-system/jsx");
 var _helperFunctions = require("./helperFunctions");
 var _jsxRuntime = require("react/jsx-runtime");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-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.
  *
  */
+
 const MAX_LEVEL_FOR_FOLDERS = exports.MAX_LEVEL_FOR_FOLDERS = 5;
-const uniq = array => Array.from(new Set(array));
-const StyledLabel = /*#__PURE__*/(0, _base.default)("label", {
-  target: "e1dg1gdn4",
-  label: "StyledLabel"
-})("font-weight:", _core.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__*/(0, _base.default)("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 = (0, _jsx2.styled)(_primitives.Button, {
+  base: {
+    width: "100%",
+    justifyContent: "space-between",
+    "& span": {
+      overflow: "hidden",
+      textOverflow: "ellipsis"
+    }
+  }
+});
+const StyledHStack = (0, _jsx2.styled)(_jsx2.HStack, {
+  base: {
+    overflow: "hidden"
+  }
+});
+const StyledHeartFill = (0, _jsx2.styled)(_action.HeartFill, {
+  base: {
+    color: "icon.strong"
+  }
+});
+const StyledFolderLine = (0, _jsx2.styled)(_editor.FolderLine, {
+  base: {
+    color: "icon.strong"
+  }
 });
-const Row = /*#__PURE__*/(0, _base.default)("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 StyledFolderUserLine = (0, _jsx2.styled)(_contentType.FolderUserLine, {
+  base: {
+    color: "icon.strong"
+  }
+});
+const StyledTreeRootProvider = (0, _jsx2.styled)(_primitives.TreeRootProvider, {
+  base: {
+    width: "100%",
+    maxHeight: "inherit"
+  }
+});
+const StyledPopoverContent = (0, _jsx2.styled)(_primitives.PopoverContent, {
+  base: {
+    display: "flex",
+    flexDirection: "column",
+    gap: "xsmall",
+    overflow: "auto",
+    maxHeight: "inherit",
+    paddingInline: "xsmall",
+    paddingBlock: "xsmall"
+  }
+});
+const LabelHStack = (0, _jsx2.styled)(_jsx2.HStack, {
+  base: {
+    width: "100%"
+  }
 });
-const TreeStructureWrapper = /*#__PURE__*/(0, _base.default)("div", {
-  target: "e1dg1gdn1",
-  label: "TreeStructureWrapper"
-})("display:flex;flex-direction:column;transition:", _core.misc.transition.default, ";&[data-type=\"picker\"]{overflow:hidden;border:1px solid ", _core.colors.brand.neutral7, ";border-radius:", _core.misc.borderRadius, ";scroll-behavior:smooth;}&:focus-within{border-color:", _core.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__*/(0, _base.default)("div", {
-  target: "e1dg1gdn0",
-  label: "ScrollableDiv"
-})("&[data-type=\"picker\"]{overflow:auto;overflow:overlay;", _core.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 => {
   let {
-    defaultOpenFolders,
     folders,
+    defaultOpenFolders,
+    newFolderInput,
     label,
+    targetResource,
     loading,
     maxLevel = MAX_LEVEL_FOR_FOLDERS,
     onSelectFolder,
-    targetResource,
-    type,
-    newFolderInput,
     ariaDescribedby
   } = _ref;
-  const ref = (0, _react.useRef)(null);
-  const defaultSelectedFolderId = defaultOpenFolders?.[defaultOpenFolders.length - 1];
-  const [openFolders, setOpenFolders] = (0, _react.useState)(defaultOpenFolders || []);
-  const [newFolderParentId, setNewFolderParentId] = (0, _react.useState)();
-  const [focusedFolder, _setFocusedFolder] = (0, _react.useState)();
-  const [selectedFolder, _setSelectedFolder] = (0, _react.useState)();
-  const [showTree, setShowTree] = (0, _react.useState)(type === "navigation");
-  const flattenedFolders = (0, _react.useMemo)(() => (0, _helperFunctions.flattenFolders)(folders, openFolders), [folders, openFolders]);
-  (0, _react.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]);
-  (0, _react.useEffect)(() => {
-    if (defaultSelectedFolderId !== undefined) {
-      const selected = (0, _helperFunctions.flattenFolders)(folders).find(folder => folder.id === defaultSelectedFolderId);
-      if (selected) {
-        _setSelectedFolder(selected);
-        if (type === "picker") {
-          _setFocusedFolder(selected);
-        }
-      }
+  const [open, setOpen] = (0, _react.useState)(false);
+  const [selectedValue, setSelectedValue] = (0, _react.useState)(defaultOpenFolders?.[defaultOpenFolders?.length - 1] ?? "");
+  const [expandedValue, setExpandedValue] = (0, _react.useState)(defaultOpenFolders ?? []);
+  const [focusedValue, setFocusedValue] = (0, _react.useState)(selectedValue);
+  const [newFolderParentId, setNewFolderParentId] = (0, _react.useState)(null);
+  const newFolderButtonRef = (0, _react.useRef)(null);
+  const {
+    t
+  } = (0, _reactI18next.useTranslation)();
+  const rootFolderIds = (0, _react.useMemo)(() => folders.map(folder => folder.id), [folders]);
+  const contentRef = (0, _react.useRef)(null);
+  const selectedFolder = (0, _react.useMemo)(() => {
+    return (0, _helperFunctions.flattenFolders)(folders).find(folder => folder.id === selectedValue);
+  }, [folders, selectedValue]);
+  const disableCreateFolder = (0, _react.useMemo)(() => {
+    return (selectedFolder?.breadcrumbs.length ?? 0) > maxLevel - 1;
+  }, [maxLevel, selectedFolder?.breadcrumbs.length]);
+  const onOpenChange = (0, _react.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 = (0, _react.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 && (0, _helperFunctions.flattenFolders)(closedFolder.subfolders);
-      if (subFolders.some(folder => folder.id === selectedFolder?.id)) {
-        setFocusedFolder(closedFolder);
+  }, []);
+  const onShowInput = (0, _react.useCallback)(() => {
+    if (disableCreateFolder) return;
+    const flattenedFolders = (0, _helperFunctions.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 = (0, _react2.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 = (0, _react.useCallback)(folder => {
+    if (!folder) return;
+    const focus = treeView.focusItem;
+    const expand = treeView.expand;
+    const select = treeView.select;
+    (0, _reactDom.flushSync)(() => {
+      setOpen(true);
+    });
+    (0, _reactDom.flushSync)(() => {
+      expand(folder.breadcrumbs.map(bc => bc.id));
+    });
+    (0, _reactDom.flushSync)(() => {
+      select([folder.id]);
+    });
+    (0, _reactDom.flushSync)(() => {
+      focus(folder.id);
+    });
+    setNewFolderParentId(null);
+  }, [treeView.expand, treeView.focusItem, treeView.select]);
+  const onAnimationEnd = (0, _react.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__*/(0, _jsxRuntime.jsxs)(StyledTreeStructure, {
-    onBlur: e => {
-      if (type === "picker" && !e.currentTarget.contains(e.relatedTarget)) {
-        onToggleTree(false);
-      }
-    },
-    children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(Row, {
-      children: [label && /*#__PURE__*/(0, _jsxRuntime.jsx)(StyledLabel, {
-        id: (0, _helperFunctions.treestructureId)(type, "label"),
-        children: label
-      }), type === "picker" && /*#__PURE__*/(0, _jsxRuntime.jsx)(_AddFolderButton.default, {
-        loading: loading,
-        canAddFolder: !!canAddFolder,
-        focusedFolder: focusedFolder,
-        setNewFolderParentId: setNewFolderParentId,
-        setShowTree: setShowTree
-      })]
-    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(TreeStructureWrapper, {
-      "aria-label": label,
-      "data-type": type,
-      children: [type === "picker" && /*#__PURE__*/(0, _jsxRuntime.jsx)(_ComboboxButton.default, {
-        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__*/(0, _jsxRuntime.jsx)(ScrollableDiv, {
-        "data-type": type,
-        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_FolderItems.default, {
-          focusedFolder: focusedFolder,
-          folders: folders,
-          level: 0,
+  }, [focusedValue, open]);
+  const onCancelFolder = (0, _react.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__*/(0, _jsxRuntime.jsx)(StyledTreeRootProvider, {
+    value: treeView,
+    asChild: true,
+    ...treeView.getRootProps(),
+    children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsx2.Stack, {
+      align: "flex-end",
+      children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(LabelHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeLabel, {
+          children: label
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_primitives.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__*/(0, _jsxRuntime.jsx)(_action.AddLine, {}), t("myNdla.newFolder")]
+        })]
+      }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_primitives.PopoverRoot, {
+        open: open,
+        positioning: {
+          sameWidth: true
+        },
+        onOpenChange: onOpenChange,
+        persistentElements: [() => newFolderButtonRef.current],
+        initialFocusEl: () => contentRef.current?.querySelector("input") ?? null,
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.PopoverTrigger, {
+          asChild: true,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledButton, {
+            variant: "secondary",
+            onKeyDown: onKeyDown,
+            "aria-haspopup": "tree",
+            role: "combobox",
+            "aria-describedby": ariaDescribedby,
+            "aria-activedescendant": focusedValue ?? undefined,
+            children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+              children: selectedFolder?.name
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_common.ArrowDownShortLine, {})]
+          })
+        }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledPopoverContent, {
+          onAnimationEnd: onAnimationEnd,
+          ref: contentRef,
+          children: [!!newFolderParentId && newFolderInput?.({
+            parentId: newFolderParentId,
+            onCreate: onCreateFolder,
+            onCancel: onCancelFolder
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.Tree, {
+            children: folders.map(folder => /*#__PURE__*/(0, _jsxRuntime.jsx)(TreeStructureItem, {
+              folder: folder,
+              targetResource: targetResource
+            }, folder.id))
+          })]
+        })]
       })]
-    })]
+    })
   });
 };
-var _default = exports.default = TreeStructure;
+exports.TreeStructure = TreeStructure;
+const TreeStructureItem = _ref2 => {
+  let {
+    folder,
+    targetResource
+  } = _ref2;
+  const {
+    t
+  } = (0, _reactI18next.useTranslation)();
+  const {
+    setOpen
+  } = (0, _react2.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 = (0, _react.useCallback)(e => {
+    if (e.key === "Enter") {
+      setOpen(false);
+    }
+  }, [setOpen]);
+  if (!folder.subfolders.length) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeItem, {
+      value: folder.id,
+      onKeyDown: onKeyDown,
+      id: folder.id,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledHStack, {
+          gap: "xxsmall",
+          justify: "center",
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(FolderIcon, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeItemText, {
+            children: folder.name
+          })]
+        }), containsResource && /*#__PURE__*/(0, _jsxRuntime.jsx)(StyledHeartFill, {
+          title: t("myNdla.alreadyInFolder")
+        })]
+      })
+    }, folder.id);
+  }
+  const ariaLabel = folder.status === "shared" ? `${folder.name}. ${t("myNdla.folder.sharing.shared")}` : folder.name;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_primitives.TreeBranch, {
+    value: folder.id,
+    id: folder.id,
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeBranchControl, {
+      onKeyDown: onKeyDown,
+      asChild: true,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledHStack, {
+        gap: "xsmall",
+        justify: "space-between",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsxs)(StyledHStack, {
+          gap: "xxsmall",
+          justify: "center",
+          children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.IconButton, {
+            variant: "clear",
+            asChild: true,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeBranchTrigger, {
+              children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeBranchIndicator, {
+                asChild: true,
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_common.ArrowRightShortLine, {})
+              })
+            })
+          }), /*#__PURE__*/(0, _jsxRuntime.jsx)(FolderIcon, {}), /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeBranchText, {
+            "aria-label": ariaLabel,
+            title: ariaLabel,
+            children: folder.name
+          })]
+        }), containsResource && /*#__PURE__*/(0, _jsxRuntime.jsx)(StyledHeartFill, {
+          title: t("myNdla.alreadyInFolder"),
+          "aria-label": t("myNdla.alreadyInFolder"),
+          "aria-hidden": false
+        })]
+      })
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_primitives.TreeBranchContent, {
+      children: folder.subfolders.map(subfolder => /*#__PURE__*/(0, _jsxRuntime.jsx)(TreeStructureItem, {
+        folder: subfolder,
+        targetResource: targetResource
+      }, subfolder.id))
+    })]
+  }, folder.id);
+};

package/lib/TreeStructure/helperFunctions.d.ts

@@ -6,6 +6,4 @@
  *
  */
 import { IFolder } from "@ndla/types-backend/myndla-api";
-import { TreeStructureType } from "./types";
 export declare const flattenFolders: (folders: IFolder[], openFolders?: string[]) => IFolder[];
-export declare const treestructureId: (type: TreeStructureType, modifier: string) => string;