Skip to content

📚 The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.

refactor: switch to new tree system

Smaug6739221e113e714f
diff --git a/frontend/app/components/AppSelect.vue b/frontend/app/components/AppSelect.vue
index 5e280c53..31e5947d 100644
--- a/frontend/app/components/AppSelect.vue
+++ b/frontend/app/components/AppSelect.vue
@@ -119,8 +119,8 @@ const selected = computed(() => {
const findSelected = (items: ANode[]): ANode | null => {
for (const item of items) {
if (item.id === selectedId.value) return item;
- if (item.childrens) {
- const found = findSelected(item.childrens);
+ if (item.children) {
+ const found = findSelected(item.children);
if (found) return found;
}
}
@@ -227,6 +227,19 @@ onBeforeUnmount(() => {
// Ensure body scroll is restored
document.body.style.overflow = '';
});
+
+const filterRecursive = <T extends ANode>(items: T[], filter: Ref<string>): T[] => {
+ return items
+ .map(item => {
+ const matches = item.label.toLowerCase().includes(filter.value.toLowerCase());
+ const filteredChildren = item.children ? filterRecursive(item.children, filter) : [];
+ if (matches || filteredChildren.length > 0) {
+ return { ...item, children: filteredChildren };
+ }
+ return null;
+ })
+ .filter(Boolean) as T[];
+};
</script>
<style scoped lang="scss">
diff --git a/frontend/app/components/AppSelectNode.vue b/frontend/app/components/AppSelectNode.vue
index 10988e3a..8e7538f0 100644
--- a/frontend/app/components/AppSelectNode.vue
+++ b/frontend/app/components/AppSelectNode.vue
@@ -2,14 +2,14 @@
<li>
<div
class="tree-node"
- :style="{ marginLeft: `${level * 20}px`, fontWeight: node.childrens?.length ? 500 : 400 }"
+ :style="{ marginLeft: `${level * 20}px`, fontWeight: node.children?.length ? 500 : 400 }"
:disabled="disabled && disabled(node)"
@click.stop="select"
>
{{ node.label }}
</div>
- <ul v-if="node.childrens?.length">
- <AppSelectNode v-for="child in node.childrens" :key="child.id" :node="child" :level="level + 1" :disabled="disabled" @select="$emit('select', $event)" />
+ <ul v-if="node.children?.length">
+ <AppSelectNode v-for="child in node.children" :key="child.id" :node="child" :level="level + 1" :disabled="disabled" @select="$emit('select', $event)" />
</ul>
</li>
</template>
diff --git a/frontend/app/components/CommandCenter/AdvancedSearchTab.vue b/frontend/app/components/CommandCenter/AdvancedSearchTab.vue
index cad6a7e3..d8c7362d 100644
--- a/frontend/app/components/CommandCenter/AdvancedSearchTab.vue
+++ b/frontend/app/components/CommandCenter/AdvancedSearchTab.vue
@@ -75,7 +75,8 @@ const props = defineProps<{ query: string; selectedIndex: number }>();
defineEmits<{ updateSelectedIndex: [index: number] }>();
const nodesStore = useNodesStore();
-const categoriesTree = new TreeStructure(useSidebarTree().nodes.value.filter(n => n.data.role <= 2)).generateTree();
+const nodesTree = useNodesTree();
+const categoriesTree = nodesTree.categoriesTree;
// UI State
const showFilters = ref(true);
diff --git a/frontend/app/components/MarkdownEditor/Toolbar.vue b/frontend/app/components/MarkdownEditor/Toolbar.vue
index e9d1f738..e755594d 100644
--- a/frontend/app/components/MarkdownEditor/Toolbar.vue
+++ b/frontend/app/components/MarkdownEditor/Toolbar.vue
@@ -163,7 +163,8 @@ const emitAction = (action: string) => emit('execute-action', action);
const openHelp = () => useModal().add(new Modal(shallowRef(ModalSyntax), { size: 'large' }));
const openSettings = () => useModal().add(new Modal(shallowRef(EditorPreferences), { size: 'medium' }));
-const categories = computed(() => new TreeStructure(useSidebarTree().nodes.value.filter(n => n.data.role <= 2)).generateTree());
+const nodesTree = useNodesTree();
+const categories = nodesTree.categoriesTree;
// Tool type with optional shortcut
interface ToolItem {
diff --git a/frontend/app/components/Node/Document/Header.vue b/frontend/app/components/Node/Document/Header.vue
index 4190b321..e15ac648 100644
--- a/frontend/app/components/Node/Document/Header.vue
+++ b/frontend/app/components/Node/Document/Header.vue
@@ -34,9 +34,10 @@ import HeaderActionRow from './HeaderActionRow.vue';
const preferences = usePreferences();
const api = useApi();
+const nodesTree = useNodesTree();
const props = defineProps<{ doc?: Node; public?: boolean }>();
-const category = computed(() => useSidebarTree().getCategoryFromNode(props.doc?.parent_id)?.data);
+const category = computed(() => nodesTree.getAncestorCategory(props.doc?.parent_id)?.data);
const store = useUserStore();
const user = ref<PublicUser | null>(null);
watchEffect(() => {
diff --git a/frontend/app/components/Node/Modals/CreateCategory.vue b/frontend/app/components/Node/Modals/CreateCategory.vue
index 4c862add..5c37ee61 100644
--- a/frontend/app/components/Node/Modals/CreateCategory.vue
+++ b/frontend/app/components/Node/Modals/CreateCategory.vue
@@ -32,16 +32,16 @@ const emit = defineEmits(['close']);
const categoriesStore = useNodesStore();
-const sidebarTree = useSidebarTree();
+const nodesTree = useNodesTree();
const sidebar = useSidebar();
-const categoriesItem = computed(() => new TreeStructure(sidebarTree.nodes.value.filter(c => c.data.role == 1 || c.data.role == 2)).generateTree());
+const categoriesItem = nodesTree.categoriesTree;
const category = ref<Partial<Node>>({
name: '',
role: props.role,
accessibility: 1,
- parent_id: sidebarTree.getCategoryFromNode(sidebar.active_id.value)?.id || sidebar.workspaceId.value,
+ parent_id: nodesTree.getAncestorCategory(sidebar.active_id.value)?.id || sidebar.workspaceId.value,
});
const createCategory = () => {
diff --git a/frontend/app/components/Node/Modals/Delete.vue b/frontend/app/components/Node/Modals/Delete.vue
index f3f9be8f..5170c5a9 100644
--- a/frontend/app/components/Node/Modals/Delete.vue
+++ b/frontend/app/components/Node/Modals/Delete.vue
@@ -41,9 +41,9 @@ const props = defineProps<{
const emit = defineEmits(['close']);
const store = useNodesStore();
-const tree = useSidebarTree();
+const nodesTree = useNodesTree();
-const allChildren = computed(() => (props.node ? tree.getSubTreeById(props.node.id) : []));
+const allChildren = computed(() => (props.node ? nodesTree.getSubtreeAsArray(props.node.id) : []));
const nodeType = computed(() => getRoleName(props.node?.role).toLowerCase());
diff --git a/frontend/app/components/Node/Modals/Metadata.vue b/frontend/app/components/Node/Modals/Metadata.vue
index fbff658c..f4568a9b 100644
--- a/frontend/app/components/Node/Modals/Metadata.vue
+++ b/frontend/app/components/Node/Modals/Metadata.vue
@@ -31,7 +31,7 @@
:items="parentsTree"
placeholder="Select a parent"
:nullable="true"
- :disabled="(i) => i.id == node.id || nodeStore.isDescendant(node, (i as Item).id)"
+ :disabled="i => i.id == node.id || nodeStore.isDescendant(node, i.id as string)"
/>
<div class="inline-input">
<label for="accessibility">Color</label>
@@ -48,10 +48,11 @@ import type { Node } from '~/stores';
const props = defineProps<{ doc: Node }>();
const nodeStore = useNodesStore();
+const nodesTree = useNodesTree();
const node = ref<Node>(props.doc);
const pinnedToggle = ref(node.value.order == -1);
-const parentsTree = computed(() => new TreeStructure(useSidebarTree().nodes.value.filter(n => n.data.role <= node.value.role)).generateTree());
+const parentsTree = computed(() => nodesTree.getTreeByMaxRole(node.value.role));
watch(pinnedToggle, val => (node.value.order = val ? -1 : 0));
watch(
diff --git a/frontend/app/components/Node/Modals/RemoveShared.vue b/frontend/app/components/Node/Modals/RemoveShared.vue
index a796d1f1..a1d82131 100644
--- a/frontend/app/components/Node/Modals/RemoveShared.vue
+++ b/frontend/app/components/Node/Modals/RemoveShared.vue
@@ -15,7 +15,8 @@
const props = defineProps<{ nodeId: string }>();
const emit = defineEmits(['close']);
-const allChildren = useSidebarTree().getSubTreeById(props.nodeId);
+const nodesTree = useNodesTree();
+const allChildren = nodesTree.getSubtreeAsArray(props.nodeId);
const removeDoc = () => {
useNodesStore()
diff --git a/frontend/app/components/Node/TOC/TOC.vue b/frontend/app/components/Node/TOC/TOC.vue
index 3f9c6aef..60946d2b 100644
--- a/frontend/app/components/Node/TOC/TOC.vue
+++ b/frontend/app/components/Node/TOC/TOC.vue
@@ -21,6 +21,7 @@
<script lang="ts" setup>
import type { Node } from '~/stores';
+import type { TreeItem as NodeTreeItem } from '~/helpers/TreeBuilder';
const props = defineProps<{ element?: HTMLElement; doc?: Node }>();
const list = ref<HTMLElement>();
@@ -107,12 +108,9 @@ function updateActiveHeader() {
}
}
-const childs = computed(
- () =>
- useSidebarTree()
- .structure.value.childrenMap.get(props.doc?.id || '')
- ?.filter(c => c.data.role === 3) || [],
-) as Ref<Item<Node>[]>;
+const nodesTree = useNodesTree();
+
+const childs = computed(() => nodesTree.getChildren(props.doc?.id).filter(c => c.data.role === 3)) as Ref<NodeTreeItem<Node>[]>;
</script>
<style lang="scss" scoped>
diff --git a/frontend/app/components/Sidebar/CollapseItem.vue b/frontend/app/components/Sidebar/CollapseItem.vue
index dc7ec1b1..7431d10e 100644
--- a/frontend/app/components/Sidebar/CollapseItem.vue
+++ b/frontend/app/components/Sidebar/CollapseItem.vue
@@ -1,30 +1,33 @@
<template>
- <div v-if="item.childrens?.length">
+ <div v-if="hasChildren">
<SidebarItem :level="level" :item="item" class="collapse-header doc">
- <svg :class="{ rotated: !props.item.show.value }" xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 -960 960 960" width="24" @click="toggleShow">
+ <svg :class="{ rotated: !isExpanded }" xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 -960 960 960" width="24" @click="toggleShow">
<path d="M480-345 240-585l56-56 184 184 184-184 56 56-240 240Z" />
</svg>
</SidebarItem>
- <template v-if="getCollapseState(item.id)">
- <div v-for="child in item.childrens" :key="child.id" class="collapse-body" style="margin-left: 15px">
- <CollapseItem v-if="child.childrens?.length" :item="child" :level="level + 1" />
+ <template v-if="isExpanded">
+ <div v-for="child in children" :key="child.id" class="collapse-body" style="margin-left: 15px">
+ <CollapseItem v-if="getItemChildren(child)?.length" :item="child" :level="level + 1" />
<SidebarItem v-else :level="level + 1" :item="child" />
</div>
</template>
</div>
<!-- Filter hidden "navigation items" -->
- <SidebarItem v-else-if="item.data.role !== -1 || item.show.value" :item="item" :level="level" />
+ <SidebarItem v-else-if="item.data?.role !== -1 || isVisible" :item="item" :level="level" />
</template>
<script setup lang="ts">
-import type { DefaultItem } from './helpers';
+import { type SidebarItem, getItemChildren, isItemVisible } from './helpers';
-const props = withDefaults(defineProps<{ item: Item | DefaultItem; level?: number }>(), { level: 0 });
+const props = withDefaults(defineProps<{ item: SidebarItem; level?: number }>(), { level: 0 });
-const { getCollapseState, setCollapseState } = useCollapseStates();
+const nodesTree = useNodesTree();
-const toggleShow = () => {
- setCollapseState(props.item.id, !props.item.show.value);
-};
+const children = computed(() => getItemChildren(props.item));
+const hasChildren = computed(() => (children.value?.length ?? 0) > 0);
+const isExpanded = computed(() => nodesTree.isExpanded(props.item.id));
+const isVisible = computed(() => isItemVisible(props.item));
+
+const toggleShow = () => nodesTree.toggleExpand(props.item.id);
</script>
<style lang="scss" scoped>
diff --git a/frontend/app/components/Sidebar/Sidebar.vue b/frontend/app/components/Sidebar/Sidebar.vue
index 1c85fd63..9c148ea8 100644
--- a/frontend/app/components/Sidebar/Sidebar.vue
+++ b/frontend/app/components/Sidebar/Sidebar.vue
@@ -28,11 +28,11 @@
><Icon name="add_folder" />
<p class="hint-tooltip">New category</p></NuxtLink
>
- <NuxtLink v-if="!sidebarTree.isCollapsed()" class="nav-item" @click="sidebarTree.collapseAll"
+ <NuxtLink v-if="!nodesTree.isAllCollapsed()" class="nav-item" @click="nodesTree.collapseAll"
><Icon name="collapse" />
<p class="hint-tooltip">Close all</p></NuxtLink
>
- <NuxtLink v-else class="nav-item" @click="sidebarTree.expandAll"
+ <NuxtLink v-else class="nav-item" @click="nodesTree.expandAll"
><Icon name="arrow-expand" />
<p class="hint-tooltip">Open all</p></NuxtLink
>
@@ -66,12 +66,13 @@ import SidebarSkeleton from './SidebarSkeleton.vue';
import { navigationItems } from './helpers';
import NewCategoryModal from '~/components/Node/Modals/CreateCategory.vue';
import Dock from './Dock.vue';
+import { filterTreeByLabel } from '~/helpers/TreeBuilder';
const nodesStore = useNodesStore();
const preferences = usePreferences();
const userStore = useUserStore();
-const sidebarTree = useSidebarTree();
+const nodesTree = useNodesTree();
const { isOpened, hasSidebar, filtered } = useSidebar();
const { isMobile } = useDevice();
const { avatarURL } = useApi();
@@ -81,12 +82,11 @@ const workspaces = computed(() => [...nodesStore.getAll.filter(c => c.role === 1
const isLoading = computed(() => nodesStore.isFetching);
const toggleDock = () => preferences.set('view_dock', !preferences.get('view_dock').value);
-const filterItems = (items: Item[]): Item[] => {
- if (!filter.value.trim()) return items;
- return filterRecursive(items, filter);
-};
-const tree = computed(() => filterItems(filtered.value));
+const tree = computed(() => {
+ if (!filter.value.trim()) return filtered.value;
+ return filterTreeByLabel(filtered.value, filter.value);
+});
const handleClickOutside = (e: MouseEvent) => {
if (isOpened.value && e.target && !(e.target as Element).closest('.sidebar') && !(e.target as Element).closest('.open-sidebar')) isOpened.value = false;
diff --git a/frontend/app/components/Sidebar/SidebarItem.vue b/frontend/app/components/Sidebar/SidebarItem.vue
index b0391382..9b5345f7 100644
--- a/frontend/app/components/Sidebar/SidebarItem.vue
+++ b/frontend/app/components/Sidebar/SidebarItem.vue
@@ -23,14 +23,14 @@
<NuxtLink v-if="item.data.role === 2" :to="`/dashboard/docs/new?cat=${item.id}`" :prefetch="false" class="nav close">
<Icon name="plus" />
</NuxtLink>
- <Icon v-if="item.data.role < 4 && item.data.order === -1" name="pin" fill="var(--font-color-light)" class="ni" />
+ <Icon v-if="item.data.order === -1" name="pin" fill="var(--font-color-light)" />
<slot />
</span>
</template>
<script setup lang="ts">
import NodeContextMenu from '~/components/Node/Action/ContextMenu.vue';
-import { navigationItems, type DefaultItem } from './helpers';
+import { navigationItems, type SidebarItem, getItemChildren } from './helpers';
import type { Node } from '~/stores';
const nodesStore = useNodesStore();
@@ -38,18 +38,20 @@ const { isOpened, workspaceId } = useSidebar();
const { getAppAccent } = useAppColors();
const { isMobile } = useDevice();
const preferences = usePreferences();
+const contextMenu = useContextMenu();
-const props = defineProps<{ item: Item | DefaultItem; level: number }>();
+const props = defineProps<{ item: SidebarItem; level: number }>();
const isDragOver = ref<boolean>(false);
const customClass = computed(() => {
- if ('color' in props.item.data && props.item.data.color != null && props.item.data.color != -1)
+ if (props.item?.data && 'color' in props.item.data && props.item.data.color != null && props.item.data.color != -1)
return `item-icon ${getAppAccent(props.item.data.color as number)}`;
return 'default-icon';
});
-const iconsNormalized = computed(() => preferences.get('normalizeFileIcons').value);
+const iconsNormalized = preferences.get('normalizeFileIcons');
const icon = computed(() => {
- if (!iconsNormalized.value && props.item.icon === 'sidebar/file' && props.item.childrens?.some(child => child.data.role != 4)) return 'file_parent';
+ const children = getItemChildren(props.item);
+ if (!iconsNormalized.value && props.item.icon === 'sidebar/file' && children?.some(child => child.data?.role != 4)) return 'file_parent';
return props.item.icon || '';
});
@@ -59,7 +61,7 @@ const onClick = (m: MouseEvent) => {
if (isMobile.value && (props.item.route || props.item.onClick)) isOpened.value = false;
};
-const contextMenu = useContextMenu();
+/* Context menu */
function showContextMenu(event: MouseEvent) {
if (props.item.data.role === -1) return; // Prevent context menu on nav items
@@ -67,18 +69,18 @@ function showContextMenu(event: MouseEvent) {
props: { node: props.item.data as Node, contextMenu: true },
});
}
+
+/* Drag and drop handlers */
+
const dragStart = (event: DragEvent) => {
- // Stocke l'ID de l'élément en cours de glissement
event.dataTransfer!.setData('text/plain', props.item.id.toString());
};
const dragOver = () => {
- // Indique que l'élément est survolé lors du glisser-déposer
isDragOver.value = true;
};
const dragLeave = () => {
- // Réinitialise l'état de survol lorsque l'élément quitte la zone de dépôt
isDragOver.value = false;
};
const drop = async (event: DragEvent) => {
@@ -92,12 +94,15 @@ const drop = async (event: DragEvent) => {
if (draggedItem.role === -1) return; // Prevent dropping nav items
if (props.item.data.role === 4) return; // Prevent dropping on resource items
if (draggedItem.id === props.item.id) return; // Prevent dropping on itself
- if (draggedItem.role <= 2 && props.item.data.role > 2) return; // Prevent dropping categories / workspaces on resources / documents
+ if (draggedItem.role <= 2 && props.item.data.role !== undefined && props.item.data.role > 2) return; // Prevent dropping categories / workspaces on resources / documents
// Move item to root
if (props.item.data.role === -1) {
return nodesStore.update({ ...(draggedItem as Node), parent_id: workspaceId.value });
}
+ // Prevent dropping on its own descendants
+ if (nodesStore.isDescendant(draggedItem as Node, props.item.id.toString())) return;
+
nodesStore.update({ ...(draggedItem as Node), parent_id: props.item.id });
};
</script>
diff --git a/frontend/app/components/Sidebar/helpers.ts b/frontend/app/components/Sidebar/helpers.ts
index 958df020..9909793e 100644
--- a/frontend/app/components/Sidebar/helpers.ts
+++ b/frontend/app/components/Sidebar/helpers.ts
@@ -1,7 +1,43 @@
import SettingsModal from '~/pages/dashboard/settings/modal.vue';
import type { Node } from '~/stores';
+import type { TreeItem } from '~/helpers/TreeBuilder';
+
+export interface NavigationItem {
+ id: string;
+ parent_id?: string;
+ label: string;
+ route: string;
+ icon: string;
+ onClick?: () => void;
+ data: {
+ id: string;
+ role: number;
+ name: string;
+ icon: string;
+ permissions: unknown[];
+ shared: boolean;
+ order?: number;
+ };
+ show: Ref<boolean>;
+}
+
+export type DefaultItem = NavigationItem;
+
+// Type union for sidebar items
+export type SidebarItem = TreeItem<Node> | NavigationItem;
+
+// Helper to get children of a sidebar item with type safety
+export function getItemChildren(item: SidebarItem): SidebarItem[] | undefined {
+ if ('children' in item) return item.children as SidebarItem[];
+ return undefined;
+}
+
+// Helper to check if a sidebar item is visible
+export function isItemVisible(item: SidebarItem): boolean {
+ if ('show' in item && item.show) return item.show.value;
+ return true;
+}
-export type DefaultItem = Item<Omit<Node, 'user_id' | 'data' | 'show' | 'access' | 'accessibility' | 'created_timestamp' | 'updated_timestamp'>>;
export interface Workspace {
text: string;
value?: string;
diff --git a/frontend/app/composables/Preferences.ts b/frontend/app/composables/Preferences.ts
index 3b55537b..d518ff05 100644
--- a/frontend/app/composables/Preferences.ts
+++ b/frontend/app/composables/Preferences.ts
@@ -1,4 +1,7 @@
-import type { ANode } from './TreeStructure';
+import type { TreeNode } from '../helpers/TreeBuilder';
+
+// Alias pour compatibilité
+export type ANode<ID = string | number> = Omit<TreeNode<unknown, ID>, 'data'>;
export const DEFAULT_PREFERENCES = {
printMode: false as boolean,
diff --git a/frontend/app/composables/TreeStructure.ts b/frontend/app/composables/TreeStructure.ts
deleted file mode 100644
index 4b73a177..00000000
--- a/frontend/app/composables/TreeStructure.ts
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * Tree Structure utilities
- * Provides hierarchical data management for nodes (categories, documents, etc.)
- */
-import type { Node } from '~/stores';
-
-/** Base node interface for tree structures */
-export interface ANode<id = string | number> {
- id: id;
- label: string;
- parent_id?: string;
- childrens?: ANode[];
-}
-
-/** Extended node with routing and display properties */
-export interface Item<T = Node> extends ANode {
- id: string;
- route: string;
- onClick?: () => void;
- data: T;
- show: Ref<boolean>;
- childrens?: Item<T>[];
- icon?: string;
-}
-
-/**
- * Manages a flat list of items and provides tree operations
- * Uses Maps for O(1) lookups by ID and parent ID
- */
-export class TreeStructure {
- public readonly items: Item[];
-
- public readonly itemMap: Map<string, Item>; // Map for quick access by ID
-
- public readonly childrenMap: Map<string, Item[]>; // Map for quick access to children by parent ID
-
- constructor(items: Item[]) {
- this.items = items;
- this.itemMap = new Map(items.map(item => [item.id, item]));
- this.childrenMap = new Map();
- for (const item of items) {
- if (!this.childrenMap.has(item.parent_id || '')) this.childrenMap.set(item.parent_id || '', []);
- this.childrenMap.get(item.parent_id!)!.push(item);
- }
- }
-
- // Get item by ID
- public getItem(id: string): Item | undefined {
- return this.itemMap.get(id);
- }
-
- public generateTree(): Item[] {
- return this.items
- .filter(item => item.data.role === 1 || item.parent_id === '' || (item.parent_id && !this.itemMap.has(item.parent_id || '')))
- .map(root => this.buildTree(root, new Set()));
- }
- public getSubTreeById(id: string): Item | undefined {
- const root = this.getItem(id);
- if (!root) return undefined;
- return this.buildTree(root, new Set());
- }
- public treeToArray(tree: Item[]): Item[] {
- const result: Item[] = [];
- const stack: Item[] = [...tree];
- while (stack.length) {
- const node = stack.pop()!;
- result.push(node);
- if (node.childrens) {
- stack.push(...node.childrens);
- }
- }
- return result;
- }
-
- // Generate sub tree
- private buildTree(item: Item, visited: Set<string> = new Set()): Item {
- // Prevent infinite recursion by checking if we've already visited this item
- if (visited.has(item.id)) {
- return { ...item, childrens: [] };
- }
-
- visited.add(item.id);
- const children = this.childrenMap.get(item.id) || [];
- const newVisited = new Set(visited);
-
- return {
- ...item,
- childrens: children.map(child => this.buildTree(child, newVisited)),
- };
- }
-
- public next(id?: string): Item | undefined {
- const item = this.itemMap.get(id || '');
- if (!item) return undefined;
- const childrens = this.childrenMap.get(item.parent_id || '')?.filter(c => c.data.role === 3) || [];
- const index = childrens.findIndex(child => child.id === id);
- if (index === -1 || index === childrens.length - 1) return undefined;
- return childrens[index + 1];
- }
-
- public previous(id?: string): Item | undefined {
- const item = this.itemMap.get(id || '');
- if (!item) return undefined;
- const childrens = this.childrenMap.get(item.parent_id || '')?.filter(c => c.data.role === 3) || [];
- const index = childrens.findIndex(child => child.id === id);
- if (index === -1 || index === 0) return undefined;
- return childrens[index - 1];
- }
-}
-export const filterRecursive = <T extends ANode>(items: T[], filter: Ref<string>): T[] => {
- return items
- .map(item => {
- const matches = item.label.toLowerCase().includes(filter.value.toLowerCase());
- const filteredChildren = item.childrens ? filterRecursive(item.childrens, filter) : [];
- if (matches || filteredChildren.length > 0) {
- return { ...item, childrens: filteredChildren };
- }
- return null;
- })
- .filter(Boolean) as T[];
-};
diff --git a/frontend/app/composables/useCollapseStates.ts b/frontend/app/composables/useCollapseStates.ts
deleted file mode 100644
index 7134268f..00000000
--- a/frontend/app/composables/useCollapseStates.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- * Collapse state management
- * Persists sidebar item expand/collapse states to localStorage
- */
-
-const STORAGE_KEY = 'collapse-states';
-
-function loadCollapseStates(): Record<string, boolean> {
- try {
- const raw = localStorage.getItem(STORAGE_KEY);
- return raw ? JSON.parse(raw) : {};
- } catch {
- return {};
- }
-}
-
-// Global reactive state (shared across components)
-const states = reactive<Record<string, boolean>>(loadCollapseStates());
-
-function saveStates() {
- localStorage.setItem(STORAGE_KEY, JSON.stringify(states));
-}
-
-/** Get collapse state for an item (defaults to expanded) */
-function getCollapseState(id: string): boolean {
- if (!(id in states)) states[id] = true;
- return states[id] ?? true;
-}
-
-/** Set collapse state for an item */
-function setCollapseState(id: string, value: boolean) {
- states[id] = value;
- saveStates();
-}
-
-/** Toggle collapse state for an item */
-function toggleCollapseState(id: string) {
- states[id] = !getCollapseState(id);
- saveStates();
-}
-
-/** Collapse all items */
-function collapseAllStates() {
- Object.keys(states).forEach(key => (states[key] = false));
- saveStates();
-}
-
-/** Expand all items */
-function expandAllStates() {
- Object.keys(states).forEach(key => (states[key] = true));
- saveStates();
-}
-
-/* Is all collapsed */
-function isAllCollapsed() {
- return Object.values(states).every(state => state === false);
-}
-
-/** Access the raw reactive states object */
-export function useCollapseStates() {
- return {
- getCollapseState,
- setCollapseState,
- toggleCollapseState,
- collapseAllStates,
- expandAllStates,
- isAllCollapsed,
- };
-}
diff --git a/frontend/app/composables/useNodesTree.ts b/frontend/app/composables/useNodesTree.ts
index 54991886..a64b9f98 100644
--- a/frontend/app/composables/useNodesTree.ts
+++ b/frontend/app/composables/useNodesTree.ts
@@ -1,106 +1,168 @@
-import { resolveIcon, resolveNodeLink } from '~/helpers/node';
+/**
+ * Nodes Tree Composable
+ * Single source of truth for the hierarchical node structure
+ */
import type { Node } from '~/stores';
+import { TreeBuilder, type TreeItem } from '~/helpers/TreeBuilder';
+import { resolveIcon, resolveNodeLink } from '~/helpers/node';
+
+// ============================================================================
+// Collapse States (localStorage persistence)
+// ============================================================================
+const COLLAPSE_STORAGE_KEY = 'collapse-states';
+
+function createCollapseStore() {
+ const states = ref<Record<string, boolean>>({});
+ let initialized = false;
+
+ function init() {
+ if (initialized || import.meta.server) return;
+ try {
+ const raw = localStorage.getItem(COLLAPSE_STORAGE_KEY);
+ states.value = raw ? JSON.parse(raw) : {};
+ } catch {
+ states.value = {};
+ }
+ initialized = true;
+ }
+
+ function save() {
+ if (import.meta.server) return;
+ localStorage.setItem(COLLAPSE_STORAGE_KEY, JSON.stringify(states.value));
+ }
+
+ return {
+ isExpanded: (id: string) => {
+ init();
+ return states.value[id] ?? true;
+ },
+ setExpanded: (id: string, value: boolean) => {
+ init();
+ states.value[id] = value;
+ save();
+ },
+ toggle: (id: string) => {
+ init();
+ states.value[id] = !(states.value[id] ?? true);
+ save();
+ },
+ setAll: (expanded: boolean) => {
+ init();
+ Object.keys(states.value).forEach(key => (states.value[key] = expanded));
+ save();
+ },
+ isAllCollapsed: () => {
+ init();
+ return Object.values(states.value).every(v => v === false);
+ },
+ };
+}
-const collapse = useCollapseStates();
+// Singleton collapse store
+const collapseStore = createCollapseStore();
-let nodes: ComputedRef<Item<Node>[]> | Ref<Item<Node>[]> = ref([]);
-const structure = computed(() => new TreeStructure(nodes.value));
+// ============================================================================
+// Main Composable
+// ============================================================================
-/* Do operations in the tree and return the final tree */
-const tree = computed(() => {
- return structure.value.generateTree();
-});
+/** Transform Node to TreeItem */
+function transformNode(node: Node): Omit<TreeItem<Node>, 'children'> {
+ return {
+ id: node.id,
+ parentId: node.role === 1 ? null : (node.parent_id ?? null),
+ label: node.name,
+ route: resolveNodeLink(node),
+ icon: resolveIcon(node),
+ data: node,
+ };
+}
-/* Collapse operations */
-const collapseAll = collapse.collapseAllStates;
+export function useNodesTree() {
+ const nodesStore = useNodesStore();
-const expandAll = collapse.expandAllStates;
+ // Sorted nodes
+ const sortedNodes = computed(() => nodesStore.nodes.toArray().sort((a, b) => (a.order ?? 0) - (b.order ?? 0) || a.name.localeCompare(b.name)));
-const isCollapsed = collapse.isAllCollapsed;
+ // Tree builder instance (recreated when nodes change)
+ const builder = computed(() => new TreeBuilder(sortedNodes.value, transformNode));
-/* Get subtree by id as a flat array */
+ // Full tree
+ const tree = computed(() => builder.value.buildTree(node => node?.role === 1));
-const getSubTreeById = (id: string) => {
- return structure.value.treeToArray(structure.value.getSubTreeById(id)?.childrens || []);
-};
+ // Categories only tree (roles 1 and 2)
+ const categoriesTree = computed(() => {
+ const filtered = sortedNodes.value.filter(n => n.role <= 2);
+ return new TreeBuilder(filtered, transformNode).buildTree(node => node?.role === 1);
+ });
-function useSidebarTree() {
- const nodesStore = useNodesStore();
+ // Get filtered tree by max role
+ const getTreeByMaxRole = (maxRole: number) => {
+ const filtered = sortedNodes.value.filter(n => n.role <= maxRole);
+ return new TreeBuilder(filtered, transformNode).buildTree(node => node?.role === 1);
+ };
- // Wait for categories and documents to be fetched
- const isReady = computed(() => !nodesStore.isFetching);
-
- if (!nodes.value.length) {
- nodes = computed(() =>
- isReady.value
- ? nodesStore.nodes
- .map<Item<Node>>(node => ({
- id: node.id,
- parent_id: node.role !== 1 ? node.parent_id || '' : '',
- label: node.name,
- route: resolveNodeLink(node),
- icon: ref(resolveIcon(node)).value,
- data: node,
- show: ref(collapse.getCollapseState(node.id)),
- }))
- .sort((a, b) => (a.data.order ?? 0) - (b.data.order ?? 0) || a.data.name.localeCompare(b.data.name))
- : [],
- );
- }
+ // === Filtered views ===
+ const workspaceTree = (workspaceId?: string): TreeItem<Node>[] => {
+ if (!workspaceId) return tree.value;
+ if (workspaceId === 'shared') {
+ return tree.value.filter(item => item.data?.shared);
+ }
+ const workspace = tree.value.find(item => item.id === workspaceId);
+ return (workspace?.children as TreeItem<Node>[]) ?? [];
+ };
- const groupedByWorkspace = (roles = [1, 2, 3]) => {
- const workspaces: Item<Node>[] = [
- ...nodesStore.getAll
- .filter(c => c.role === 1)
- .map(c => ({
- id: c.id,
- parent_id: c.parent_id || '',
- label: c.name,
- route: `/dashboard/categories/${c.id}`,
- icon: c.icon || 'folder',
- data: c,
- show: ref(collapse.getCollapseState(c.id)),
- })),
- ];
-
- tree.value.forEach(item => {
- if (!roles.includes(item.data.role)) return;
- const workspaceId = item.parent_id;
- const existing = workspaces.find(w => w.id === workspaceId);
- if (!existing) workspaces.push(item);
- else {
- if (existing.childrens) existing.childrens.push(item);
- else existing.childrens = [item];
- }
- });
- return workspaces;
+ // === Get subtree as flat array ===
+ const getSubtreeAsArray = (id: string): TreeItem<Node>[] => {
+ const subtree = builder.value.buildSubtree(id);
+ return subtree?.children ? builder.value.flatten(subtree.children as TreeItem<Node>[]) : [];
};
- const getCategoryFromNode = (parentId?: string | null) => {
- let category: Item<Node> | null = null;
- let parent_id: string | undefined | null = parentId;
- while (parent_id) {
- const parent = structure.value.itemMap.get(parent_id);
- if (parent?.data.role === 2 || parent?.data.role === 1) {
- category = parent as Item<Node>;
- break;
+ // === Navigation ===
+ const getAncestorCategory = (nodeId?: string | null): TreeItem<Node> | null => {
+ if (!nodeId) return null;
+ let current = builder.value.get(nodeId);
+ while (current?.parentId) {
+ const parent = builder.value.get(current.parentId);
+ if (parent && (parent.data?.role === 1 || parent.data?.role === 2)) {
+ return parent;
}
- parent_id = parent?.parent_id;
+ current = parent;
}
- return category;
+ return null;
+ };
+
+ const nextDocument = (id?: string) => (id ? builder.value.getSibling(id, 'next', n => n?.role === 3)?.data : undefined);
+ const prevDocument = (id?: string) => (id ? builder.value.getSibling(id, 'prev', n => n?.role === 3)?.data : undefined);
+
+ // === Get children of a node ===
+ const getChildren = (parentId?: string | null): TreeItem<Node>[] => {
+ return builder.value.getChildren(parentId ?? null);
};
return {
- structure,
- nodes,
- collapseAll,
- expandAll,
- isCollapsed,
- getSubTreeById,
- groupedByWorkspace,
- getCategoryFromNode,
+ // Tree data
tree,
+ categoriesTree,
+ getTreeByMaxRole,
+ workspaceTree,
+ getSubtreeAsArray,
+ getAncestorCategory,
+ getChildren,
+ builder,
+
+ // Navigation
+ nextDocument,
+ prevDocument,
+
+ // Collapse state
+ isExpanded: collapseStore.isExpanded,
+ setExpanded: collapseStore.setExpanded,
+ toggleExpand: collapseStore.toggle,
+ expandAll: () => collapseStore.setAll(true),
+ collapseAll: () => collapseStore.setAll(false),
+ isAllCollapsed: collapseStore.isAllCollapsed,
};
}
-export { useSidebarTree };
+// Legacy alias for backward compatibility during migration
+export { useNodesTree as useSidebarTree };
diff --git a/frontend/app/composables/useSidebar.ts b/frontend/app/composables/useSidebar.ts
index eab53ef8..f045cb2e 100644
--- a/frontend/app/composables/useSidebar.ts
+++ b/frontend/app/composables/useSidebar.ts
@@ -1,52 +1,47 @@
/**
- * Sidebar state management
- * Controls sidebar visibility, width, and content filtering
+ * Sidebar UI State
+ * Controls visibility, width, and active selection
*/
-
-// Module-level state (safe - these don't depend on Pinia)
-const isOpened = ref(false);
-const hasSidebar = ref(false);
-const isResizing = ref(false);
-const workspaceId = ref<string | undefined>(undefined);
-const active_id = ref<string | null>(null);
-
-const { isMobile } = useDevice();
-
-const toggleSidebar = () => (isOpened.value = !isOpened.value);
-
-// Lazy-initialized references (only set once when useSidebar is first called)
-let _sidebarTreeRef: ReturnType<typeof useSidebarTree> | null = null;
-const preferences = usePreferences();
-let _filtered: ComputedRef<Item[]> | null = null;
-const paneWidth = ref(isMobile.value ? 340 : 390);
+import type { TreeItem } from '../helpers/TreeBuilder';
+import type { Node } from '~/stores';
export function useSidebar() {
- // Lazy init: only create these once
- if (!_sidebarTreeRef) {
- _sidebarTreeRef = useSidebarTree();
- }
-
- if (!_filtered) {
- /** Filter tree items based on selected workspace and preferences */
- _filtered = computed(() => {
- const tree = _sidebarTreeRef!.tree;
- const found = tree.value.find(i => i.id === workspaceId.value);
-
- if (found) return found.childrens || [];
- if (workspaceId.value === 'shared') return tree.value.filter(i => i.data && i.data.shared);
- if (!preferences.get('displayUncategorizedResources').value) return tree.value.filter(i => i.data && i.data.role != 4); // hide uncategorized
- return tree.value;
- });
- }
+ const { isMobile } = useDevice();
+ const nodesTree = useNodesTree();
+ const preferences = usePreferences();
+
+ // UI State - using useState for SSR safety
+ const isOpen = useState('sidebar-open', () => false);
+ const hasSidebar = useState('sidebar-has', () => false);
+ const isResizing = useState('sidebar-resizing', () => false);
+ const paneWidth = useState('sidebar-width', () => (isMobile.value ? 340 : 390));
+ const activeNodeId = useState<string | null>('sidebar-active', () => null);
+ const workspaceId = useState<string | undefined>('sidebar-workspace', () => undefined);
+
+ // Filtered tree based on current workspace and preferences
+ const filtered = computed((): TreeItem<Node>[] => {
+ const items = nodesTree.workspaceTree(workspaceId.value);
+ if (!preferences.get('displayUncategorizedResources').value) {
+ return items.filter(item => item.data.role !== 4);
+ }
+ return items;
+ });
+
+ const toggle = () => (isOpen.value = !isOpen.value);
return {
- filtered: _filtered,
- toggleSidebar,
- isOpened,
+ // UI State
+ isOpened: isOpen,
hasSidebar,
paneWidth,
isResizing,
+ toggleSidebar: toggle,
+
+ // Selection
+ active_id: activeNodeId,
workspaceId,
- active_id,
+
+ // Filtered content
+ filtered,
};
}
diff --git a/frontend/app/helpers/TreeBuilder.ts b/frontend/app/helpers/TreeBuilder.ts
new file mode 100644
index 00000000..71f67226
--- /dev/null
+++ b/frontend/app/helpers/TreeBuilder.ts
@@ -0,0 +1,128 @@
+/**
+ * TreeBuilder - Pure utility class for tree operations
+ * No reactivity, no side effects - just data transformation
+ */
+
+/** Base tree node interface */
+export interface TreeNode<T = unknown, id = string> {
+ id: id;
+ parentId?: string | null;
+ label: string;
+ data: T;
+ children?: TreeNode<T>[];
+}
+
+/** Extended tree item with routing and display properties */
+export interface TreeItem<T = unknown> {
+ id: string;
+ parentId?: string | null;
+ label: string;
+ data: T;
+ route: string;
+ icon?: string;
+ children?: TreeItem<T>[];
+ onClick?: () => void;
+}
+
+/**
+ * Builds and manages tree structures from flat arrays
+ * Uses Maps for O(1) lookups
+ */
+export class TreeBuilder<T extends { id: string; parent_id?: string | null }> {
+ private readonly items: TreeItem<T>[];
+ private readonly itemMap: Map<string, TreeItem<T>>;
+ private readonly childrenMap: Map<string, TreeItem<T>[]>;
+
+ constructor(
+ sourceItems: T[],
+ private readonly transform: (item: T) => Omit<TreeItem<T>, 'children'>,
+ ) {
+ this.items = sourceItems.map(item => this.transform(item) as TreeItem<T>);
+ this.itemMap = new Map(this.items.map(item => [item.id, item]));
+ this.childrenMap = new Map();
+
+ for (const item of this.items) {
+ const parentId = item.parentId ?? '';
+ if (!this.childrenMap.has(parentId)) {
+ this.childrenMap.set(parentId, []);
+ }
+ this.childrenMap.get(parentId)!.push(item);
+ }
+ }
+
+ /** Get item by ID */
+ get(id: string): TreeItem<T> | undefined {
+ return this.itemMap.get(id);
+ }
+
+ /** Get children of a parent */
+ getChildren(parentId?: string | null): TreeItem<T>[] {
+ return this.childrenMap.get(parentId ?? '') ?? [];
+ }
+
+ /** Build complete tree from roots */
+ buildTree(isRoot: (item?: T) => boolean = item => !item?.parent_id): TreeItem<T>[] {
+ return this.items
+ .filter(item => isRoot(item.data) || !this.itemMap.has(item.parentId ?? ''))
+ .map(root => this.buildSubtree(root.id))
+ .filter((item): item is TreeItem<T> => item !== undefined);
+ }
+
+ /** Build subtree from a specific node */
+ buildSubtree(id: string, visited = new Set<string>()): TreeItem<T> | undefined {
+ const item = this.itemMap.get(id);
+ if (!item || visited.has(id)) return undefined;
+
+ visited.add(id);
+ const children = this.getChildren(id)
+ .map(child => this.buildSubtree(child.id, new Set(visited)))
+ .filter((c): c is TreeItem<T> => c !== undefined);
+
+ return { ...item, children: children.length ? children : undefined };
+ }
+
+ /** Flatten a tree back to array */
+ flatten(tree: TreeItem<T>[]): TreeItem<T>[] {
+ const result: TreeItem<T>[] = [];
+ const stack: TreeItem<T>[] = [...tree];
+ while (stack.length) {
+ const node = stack.pop()!;
+ result.push(node);
+ if (node.children) stack.push(...(node.children as TreeItem<T>[]));
+ }
+ return result;
+ }
+
+ /** Get next/previous sibling for navigation */
+ getSibling(id: string, direction: 'next' | 'prev', filter?: (item?: T) => boolean): TreeItem<T> | undefined {
+ const item = this.itemMap.get(id);
+ if (!item) return undefined;
+
+ let siblings = this.getChildren(item.parentId);
+ if (filter) siblings = siblings.filter(s => filter(s.data));
+
+ const index = siblings.findIndex(s => s.id === id);
+ if (index === -1) return undefined;
+
+ const targetIndex = direction === 'next' ? index + 1 : index - 1;
+ return siblings[targetIndex];
+ }
+}
+
+/** Filter tree recursively, keeping branches with matches */
+export function filterTree<T extends TreeNode<unknown>>(items: T[], predicate: (item: T) => boolean): T[] {
+ const result: T[] = [];
+ for (const item of items) {
+ const filteredChildren = item.children ? filterTree(item.children as T[], predicate) : [];
+ if (predicate(item) || filteredChildren.length > 0) {
+ result.push({ ...item, children: filteredChildren.length ? filteredChildren : undefined } as T);
+ }
+ }
+ return result;
+}
+
+/** Filter tree by label (case-insensitive) */
+export function filterTreeByLabel<T extends TreeNode>(items: T[], query: string): T[] {
+ const lowerQuery = query.toLowerCase();
+ return filterTree(items, item => item.label.toLowerCase().includes(lowerQuery));
+}
diff --git a/frontend/app/pages/dashboard/categories/[id]/edit.vue b/frontend/app/pages/dashboard/categories/[id]/edit.vue
index 60ec1f85..caddd1ad 100644
--- a/frontend/app/pages/dashboard/categories/[id]/edit.vue
+++ b/frontend/app/pages/dashboard/categories/[id]/edit.vue
@@ -20,7 +20,7 @@
v-model="category.parent_id"
:items="categoriesItem"
placeholder="Select a category parent"
- :disabled="i => i.id == category!.id || nodesStore.isDescendant(category!, (i as Item).id)"
+ :disabled="i => i.id == category!.id || nodesStore.isDescendant(category!, i.id as string)"
/>
</div>
<div class="form-column">
@@ -50,9 +50,10 @@ definePageMeta({ breadcrumb: 'Edit' });
const nodesStore = useNodesStore();
const route = useRoute();
+const nodesTree = useNodesTree();
const category = computed(() => nodesStore.getById(route.params.id as string));
-const categoriesItem = computed(() => new TreeStructure(useSidebarTree().nodes.value.filter(i => i.data.role <= 2)).generateTree());
+const categoriesItem = nodesTree.categoriesTree;
const updateCategory = async () => {
if (category.value)
diff --git a/frontend/app/pages/dashboard/categories/_components/WorkspaceTree.vue b/frontend/app/pages/dashboard/categories/_components/WorkspaceTree.vue
index 59f669ed..ecbd9b58 100644
--- a/frontend/app/pages/dashboard/categories/_components/WorkspaceTree.vue
+++ b/frontend/app/pages/dashboard/categories/_components/WorkspaceTree.vue
@@ -11,16 +11,17 @@
</div>
</div>
- <div v-if="node.childrens && node.childrens.length" class="tree-children">
- <WorkspaceTree v-for="child in node.childrens" :key="child.id" :node="child" @edit="$emit('edit', $event)" @delete="$emit('delete', $event)" />
+ <div v-if="node.children && node.children.length" class="tree-children">
+ <WorkspaceTree v-for="child in node.children" :key="child.id" :node="child" @edit="$emit('edit', $event)" @delete="$emit('delete', $event)" />
</div>
</div>
</template>
<script lang="ts" setup>
+import type { TreeItem } from '~/helpers/TreeBuilder';
import type { Node } from '~/stores';
-defineProps<{ node: Item<Node> }>();
+defineProps<{ node: TreeItem<Node> }>();
defineEmits(['edit', 'delete']);
</script>
diff --git a/frontend/app/pages/dashboard/categories/index.vue b/frontend/app/pages/dashboard/categories/index.vue
index 6a8ebac5..f22e783f 100644
--- a/frontend/app/pages/dashboard/categories/index.vue
+++ b/frontend/app/pages/dashboard/categories/index.vue
@@ -19,7 +19,7 @@
<h3 class="wp-name">
<NuxtLink :to="`/dashboard/categories/${workspace.id}/edit`">{{ workspace.label }}</NuxtLink>
</h3>
- <WorkspaceTree v-for="node in workspace.childrens" :key="node.id" :node="node" @edit="editNode" @delete="deleteNode" />
+ <WorkspaceTree v-for="node in workspace.children" :key="node.id" :node="node" @edit="editNode" @delete="deleteNode" />
</div>
<div v-if="!filteredItems.length" style="color: #6c757d; font-style: italic">No workspaces or category found</div>
</div>
@@ -30,23 +30,25 @@ import CreateCategoryModal from '~/components/Node/Modals/CreateCategory.vue';
import DeleteCategoryModal from '~/components/Node/Modals/Delete.vue';
import WorkspaceTree from './_components/WorkspaceTree.vue';
import type { Node } from '~/stores';
+import { filterTreeByLabel, type TreeItem } from '~/helpers/TreeBuilder';
const filter = ref('');
-const tree = computed(() => new TreeStructure(useSidebarTree().nodes.value.filter(n => n.data.role <= 2)).generateTree());
+const nodesTree = useNodesTree();
const filteredItems = computed(() => {
- if (!filter.value.trim()) return tree.value;
- return filterRecursive<Item<Node>>(tree.value, filter);
+ const items = nodesTree.categoriesTree.value;
+ if (!filter.value.trim()) return items;
+ return filterTreeByLabel(items, filter.value);
});
const createWorkspace = () => useModal().add(new Modal(shallowRef(CreateCategoryModal), { props: { role: 1 } }));
const createCategory = () => useModal().add(new Modal(shallowRef(CreateCategoryModal), { props: { role: 2 } }));
-function editNode(node: Item) {
+function editNode(node: TreeItem<Node>) {
useRouter().push('/dashboard/categories/' + node.id + '/edit');
}
-function deleteNode(node: Item) {
+function deleteNode(node: TreeItem<Node>) {
useModal().add(new Modal(shallowRef(DeleteCategoryModal), { props: { categoryId: node.id } }));
}
</script>
diff --git a/frontend/app/pages/dashboard/cdn/[id]/index.vue b/frontend/app/pages/dashboard/cdn/[id]/index.vue
index d13e8af6..a6dfbb98 100644
--- a/frontend/app/pages/dashboard/cdn/[id]/index.vue
+++ b/frontend/app/pages/dashboard/cdn/[id]/index.vue
@@ -21,7 +21,7 @@
<label>Name</label>
<input id="name" v-model="resource.name" type="text" required />
<label style="display: flex; align-items: center">Parent <AppHint text="To organize your uploads" /></label>
- <AppSelect v-model="resource.parent_id" :items="tree" :disabled="i => (i as Item).data?.role !== 3" placeholder="Select a resource parent" />
+ <AppSelect v-model="resource.parent_id" :items="tree" :disabled="i => (i as TreeItem<Node>).data?.role !== 3" placeholder="Select a resource parent" />
<label>Type</label>
<input id="id" type="text" :value="resource.metadata?.filetype" disabled />
<label>Original path</label>
@@ -43,6 +43,7 @@
<script lang="ts" setup>
import DeleteNodeModal from '~/components/Node/Modals/Delete.vue';
import { readableFileSize } from '~/helpers/resources';
+import type { Node } from '~/stores';
definePageMeta({ breadcrumb: 'Edit' });
@@ -55,10 +56,11 @@ const resource = computed(() => nodeStore.getById(route.params.id as string));
const defaultItem: ANode = {
id: '',
label: 'None',
- parent_id: '',
- childrens: [],
+ parentId: '',
+ children: [],
};
-const tree = computed(() => [defaultItem, ...useSidebarTree().tree.value]);
+const nodesTree = useNodesTree();
+const tree = computed(() => [defaultItem, ...nodesTree.tree.value]);
const updateCategory = async () => {
if (resource.value)
diff --git a/frontend/app/pages/dashboard/cdn/[id]/preview.vue b/frontend/app/pages/dashboard/cdn/[id]/preview.vue
index 6c7f9f3c..06752666 100644
--- a/frontend/app/pages/dashboard/cdn/[id]/preview.vue
+++ b/frontend/app/pages/dashboard/cdn/[id]/preview.vue
@@ -5,10 +5,21 @@
<h1>Preview <tag yellow>Beta</tag> • {{ resource.name }}</h1>
<div class="actions-row">
<AppSelect v-if="isPdfFile(mimeType)" v-model="zoom" :items="PDF_SCALES" :searchable="false" label="Scale" style="width: 200px" />
- <NuxtLink :to="`/dashboard/cdn/${resource.id}`"><AppButton type="primary">Edit</AppButton></NuxtLink>
- <AppButton type="secondary" class="no-mobile" @click="copyLink">Copy link</AppButton>
+ <NuxtLink :to="`/dashboard/cdn/${resource.id}`" class="btn-icon">
+ <Icon name="edit" display="lg" />
+ <p class="hint-tooltip">Edit</p>
+ </NuxtLink>
+ <span class="btn-icon" @click="copyLink">
+ <Icon name="copy" display="lg" />
+ <p class="hint-tooltip">Copy link</p>
+ </span>
<NuxtLink :href="resourceURL(resource, true)" download rel="noopener" class="btn-icon">
<Icon name="download" display="lg" />
+ <p class="hint-tooltip">Download</p>
+ </NuxtLink>
+ <NuxtLink @click="showDeleteModal" class="btn-icon">
+ <Icon name="delete" display="lg" />
+ <p class="hint-tooltip">Delete</p>
</NuxtLink>
</div>
</header>
@@ -31,6 +42,7 @@
</template>
<script setup lang="ts">
+import DeleteNodeModal from '~/components/Node/Modals/Delete.vue';
import { PDF_SCALES } from '~/helpers/constants';
import { isImageFile, isPdfFile, isVideoFile, isAudioFile } from '~/helpers/resources';
@@ -47,12 +59,19 @@ const copyLink = () => {
const link = resourceURL(resource.value!);
navigator.clipboard.writeText(link);
};
+
+const showDeleteModal = () => {
+ useModal().add(new Modal(shallowRef(DeleteNodeModal), { props: { nodes: [resource.value], redirectTo: '/dashboard/cdn' }, size: 'small' }));
+};
</script>
<style scoped lang="scss">
-.card {
- display: flex;
- flex-direction: column;
- height: 100%;
+.btn-icon {
+ position: relative;
+ margin: 0 1px;
+ &:hover .hint-tooltip {
+ opacity: 1;
+ visibility: visible;
+ }
}
header {
diff --git a/frontend/app/pages/dashboard/docs/[id].vue b/frontend/app/pages/dashboard/docs/[id].vue
index e103ce98..3e4530b8 100644
--- a/frontend/app/pages/dashboard/docs/[id].vue
+++ b/frontend/app/pages/dashboard/docs/[id].vue
@@ -42,7 +42,7 @@ const preferencesStore = usePreferences();
const devise = useDevice();
const sidebar = useSidebar();
-const tree = useSidebarTree();
+const nodesTree = useNodesTree();
const route = useRoute();
const router = useRouter();
@@ -76,8 +76,8 @@ definePageMeta({
},
});
-const next = computed(() => tree.structure.value.next(node.value?.id)?.data);
-const previous = computed(() => tree.structure.value.previous(node.value?.id)?.data);
+const next = computed(() => nodesTree.nextDocument(node.value?.id));
+const previous = computed(() => nodesTree.prevDocument(node.value?.id));
const width = computed(() => {
if (preferencesStore.get('docSize').value == 2) return '980px';
if (preferencesStore.get('docSize').value == 1) return '800px';