@firestitch/report 18.0.19 → 18.0.20

package/esm2022/app/reports/views/reports/fs-ai-reports.component.mjs

@@ -1,29 +1,46 @@
-import { ChangeDetectionStrategy, Component, DestroyRef, ViewChild, effect, inject, input } from '@angular/core';
+import { ChangeDetectionStrategy, Component, DestroyRef, effect, inject, input, signal, viewChild, } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { ActivatedRoute, Router, RouterLink } from '@angular/router';
 import { MatDialog } from '@angular/material/dialog';
-import { FsDateModule } from '@firestitch/date';
-import { FsListComponent, FsListModule } from '@firestitch/list';
+import { MatIconModule } from '@angular/material/icon';
+import { FsFilterModule, ItemType } from '@firestitch/filter';
+import { FsMessage } from '@firestitch/message';
 import { FsPrompt } from '@firestitch/prompt';
-import { map, switchMap } from 'rxjs/operators';
+import { FsSkeletonModule } from '@firestitch/skeleton';
+import { FsTreeComponent, FsTreeModule, TreeActionType, TreeDragMode, } from '@firestitch/tree';
+import { switchMap } from 'rxjs';
 import { ReportData } from '../../data/report.data';
 import { GlobalSettingsComponent } from '../../dialogs/global-settings/global-settings.component';
-import { ReportState } from '../../interfaces/report.interface';
+import { ReportNodeType, ReportState, ReportStates, } from '../../interfaces/report.interface';
 import * as i0 from "@angular/core";
-import * as i1 from "@firestitch/date";
-import * as i2 from "@firestitch/list";
-// The reports listing — an fs-list of reports. Rows are links built from a URL
-// pattern (a ':id' token → the report id; a leading '/' makes it absolute,
-// otherwise it's relative to this component's route). Create prompts for a
-// title, creates the report, then routes to it. The header gear opens the
-// global Report Settings dialog (AI knowledge document + semantic-database
-// build), which lives in this package. No routing is hard-coded here.
+import * as i1 from "@firestitch/filter";
+import * as i2 from "@firestitch/skeleton";
+import * as i3 from "@firestitch/tree";
+import * as i4 from "@angular/material/icon";
+// The reports listing — an fs-tree of folders and the reports filed into them.
+// Rows link out through a URL pattern (a ':id' token → the report id; a leading
+// '/' makes it absolute, otherwise it's relative to this component's route).
+// Create prompts for a title, creates the report, then routes to it. The gear
+// opens the global Report Settings dialog (AI knowledge document +
+// semantic-database build), which lives in this package. No routing is
+// hard-coded here.
+//
+// Folders nest; reports are always leaves — canDrop enforces it here, and the
+// backend enforces it structurally by keeping the tree in its own table. A
+// report in no folder is a root node, which is where every report sat before
+// folders existed, so nothing had to be migrated or bucketed as "uncategorized".
 //
 // Reports are soft-deletable: the row kebab deletes, "Show Deleted" flips the
-// list into deleted mode (the backend hides deleted reports otherwise), and in
-// that mode fs-list swaps Delete for Restore, which calls the undelete action
-// endpoint.
+// listing into deleted mode (the backend hides deleted reports otherwise), and
+// in that mode the kebab offers Restore instead. Folders do NOT take part in
+// that — a folder is only deletable once it is empty, so it hard deletes and has
+// nothing to restore. The upshot is that deleted mode keeps the folder structure
+// on screen with the deleted reports sitting where they belong, so restoring one
+// puts it back rather than dropping it at the root.
 export class FsAiReportsComponent {
+    // How deep the tree opens on load. Folders are audience buckets, not a
+    // filesystem, so there is nothing worth hiding behind a closed chevron.
+    static EXPAND_LEVEL = 10;
     // API base for the reports endpoints; override to mount elsewhere.
     basePath = input('reports');
     // Where a row links to; ':id' is replaced with the report id. Default takes
@@ -31,27 +48,44 @@ export class FsAiReportsComponent {
     openPattern = input(':id');
     // Where a freshly-created report routes to; same ':id' pattern rules.
     createPattern = input(':id');
-    list = null;
-    listConfig;
-    // Template-side handle on the enum, so the name cell can tell a deleted row
-    // (shown in Show Deleted mode) from a live one.
-    deletedState = ReportState.Deleted;
+    // Null until the first load resolves — that is what gates *fsSkeleton.
+    nodes = signal(null);
+    treeConfig;
+    filterConfig;
+    // Template-side handle on the enum, so a row can tell a folder from a report.
+    nodeType = ReportNodeType;
+    _tree = viewChild(FsTreeComponent);
     _reportData = inject(ReportData);
     _router = inject(Router);
     _route = inject(ActivatedRoute);
     _prompt = inject(FsPrompt);
+    _message = inject(FsMessage);
     _dialog = inject(MatDialog);
     _destroyRef = inject(DestroyRef);
+    // The filter bar's current query — carries `state` when Show Deleted is on.
+    _query = {};
     constructor() {
         effect(() => {
             this._reportData.basePath = this.basePath();
         });
-        this._initListConfig();
+    }
+    ngOnInit() {
+        // Set before the first fetch rather than waiting on the effect above, which
+        // does not run until after the initial change detection pass.
+        this._reportData.basePath = this.basePath();
+        this._initFilterConfig();
+        this._initTreeConfig();
+        this._load();
     }
     // routerLink commands for a report row (built from openPattern).
     openLink(report) {
         return this._patternCommands(this.openPattern(), report.id);
     }
+    // A deleted report can't be opened — the backend only assembles active ones —
+    // so in Show Deleted mode its name renders as plain text rather than a link.
+    isDeleted(report) {
+        return report?.state === ReportState.Deleted;
+    }
     // Prompt for a title, create the report, then route to it (createPattern).
     createReport() {
         this._prompt.input({
@@ -66,21 +100,6 @@ export class FsAiReportsComponent {
             this._router.navigate(this._patternCommands(pattern, report.id), pattern.startsWith('/') ? {} : { relativeTo: this._route });
         });
     }
-    // Turn a ':id' pattern into router commands. Relative unless it starts
-    // with '/', in which case the first segment carries the leading slash.
-    _patternCommands(pattern, id) {
-        const absolute = pattern.startsWith('/');
-        const segments = pattern.split('/')
-            .filter((segment) => segment.length > 0)
-            .map((segment) => (segment === ':id' ? id : segment));
-        if (!segments.length) {
-            return [id];
-        }
-        if (absolute) {
-            segments[0] = `/${segments[0]}`;
-        }
-        return segments;
-    }
     // The global Report Settings dialog: the AI knowledge document and the
     // semantic-database build. A running build streams into the FsProcess dock,
     // which survives the dialog closing.
@@ -92,64 +111,313 @@ export class FsAiReportsComponent {
             autoFocus: false,
         });
     }
-    _initListConfig() {
-        this.listConfig = {
-            // The backend list is not paged yet; show the full set until it is.
-            paging: false,
+    _initFilterConfig() {
+        this.filterConfig = {
+            items: [
+                {
+                    name: 'keyword',
+                    type: ItemType.Keyword,
+                    label: 'Search',
+                },
+                {
+                    name: 'state',
+                    type: ItemType.Select,
+                    label: 'Status',
+                    multiple: true,
+                    values: () => ReportStates,
+                    isolate: { label: 'Show Deleted', value: ReportState.Deleted },
+                },
+            ],
             actions: [
                 {
-                    // Icon-only: the global Report Settings dialog.
+                    icon: 'unfold_more',
+                    tooltip: 'Expand all',
+                    primary: false,
+                    click: () => this._tree()?.expandAll(),
+                },
+                {
+                    icon: 'unfold_less',
+                    tooltip: 'Collapse all',
+                    primary: false,
+                    click: () => this._tree()?.collapseAll(),
+                },
+                {
                     icon: 'settings',
                     tooltip: 'Report settings',
                     primary: false,
                     click: () => this.openSettings(),
                 },
+                {
+                    label: 'New Folder',
+                    primary: false,
+                    click: () => this._createFolder(null),
+                },
                 {
                     label: 'Create',
                     primary: true,
                     click: () => this.createReport(),
                 },
             ],
-            rowActions: [
+            // The two items are answered in different places and both have to run.
+            // The keyword drives the tree's own search, which is the whole point of
+            // searching a tree — it reveals a match nested inside collapsed folders
+            // rather than only filtering what is already on screen. `state` is the
+            // Show Deleted toggle, and only the server can answer that.
+            change: (query) => {
+                const stateChanged = String(query?.state ?? '') !== String(this._query.state ?? '');
+                this._query = { ...query };
+                this._search(query?.keyword);
+                if (stateChanged) {
+                    this._load();
+                }
+            },
+        };
+    }
+    _initTreeConfig() {
+        this.treeConfig = {
+            data: [],
+            childrenName: 'children',
+            expandLevel: FsAiReportsComponent.EXPAND_LEVEL,
+            draggable: true,
+            // The whole row is the grip and the handle stays hidden; a press only
+            // becomes a drag once the pointer moves, so the kebab, the chevron and the
+            // report link all stay clickable.
+            dragMode: TreeDragMode.Node,
+            // canDrop is asked about the node being DRAGGED, so only `toParent`
+            // describes the destination — reading node.level/node.parent here would
+            // describe where it came from. A report can never be a parent because its
+            // type says so, and that single test is the whole "folders nest, reports
+            // are leaves" rule on this side.
+            canDrop: (node, fromParent, toParent) => {
+                return !toParent || toParent.data?.type === ReportNodeType.Folder;
+            },
+            changeReorder: (event) => this._move(event),
+            nodeClass: (node) => node.data?.type,
+            // Match on the name only. The library's default matcher stringifies the
+            // whole node, so it would hit ids, the literal type word, and everything
+            // else riding on the row.
+            filterItem: (node, query) => {
+                return String(node.data?.name ?? '')
+                    .toLowerCase()
+                    .includes(String(query ?? '').toLowerCase());
+            },
+            actions: [
                 {
-                    click: (report) => this._reportData.delete(report.id),
-                    remove: {
-                        title: 'Confirm',
-                        template: 'Are you sure you would like to delete this report?',
-                    },
-                    menu: true,
-                    label: 'Delete',
+                    type: TreeActionType.Menu,
+                    icon: 'more_vert',
+                    items: [
+                        {
+                            label: 'Rename',
+                            show: (node) => !this._isDeletedNode(node),
+                            click: (node) => this._rename(node),
+                        },
+                        {
+                            label: 'New Folder Inside',
+                            show: (node) => this._isFolderNode(node),
+                            click: (node) => this._createFolder(node.data?.id),
+                        },
+                        {
+                            label: 'Delete',
+                            show: (node) => !this._isDeletedNode(node),
+                            click: (node) => this._delete(node),
+                        },
+                        // Folders never reach this: they hard delete, so a deleted folder
+                        // does not exist to be restored.
+                        {
+                            label: 'Restore',
+                            show: (node) => this._isDeletedNode(node),
+                            click: (node) => this._restore(node),
+                        },
+                    ],
                 },
             ],
-            // `filter: true` makes fs-list render the Show Deleted toggle and send
-            // `query` with the fetch; in that mode it also swaps the row's Delete
-            // action for Restore.
-            restore: {
-                query: { state: ReportState.Deleted },
-                filter: true,
-                filterLabel: 'Show Deleted',
-                menuLabel: 'Restore',
-                reload: true,
-                click: (report) => this._reportData.undelete(report.id),
-            },
-            fetch: (query) => {
-                return this._reportData.reports(query)
-                    .pipe(map((reports) => ({ data: reports ?? [] })));
-            },
         };
     }
+    _isFolderNode(node) {
+        return node?.data?.type === ReportNodeType.Folder;
+    }
+    _isDeletedNode(node) {
+        return this.isDeleted(node?.data?.report);
+    }
+    // Drive the tree's built-in search: it collapses everything, hides every node,
+    // then unhides each match and walks its ancestors open, so a report several
+    // folders deep surfaces with its path expanded. Clearing does NOT undo that
+    // initial collapse, so the tree is re-opened here — otherwise the listing is
+    // left fully collapsed the moment somebody empties the search box.
+    _search(keyword) {
+        const tree = this._tree();
+        if (!tree) {
+            return;
+        }
+        if (keyword) {
+            tree.search(keyword);
+            return;
+        }
+        tree.clearSearch();
+        tree.expandAll();
+    }
+    _load() {
+        this._reportData.tree(this._query)
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((tree) => {
+            const nodes = this._buildNodes(tree);
+            this.nodes.set(nodes);
+            // The tree reads `config` once, in its own ngOnInit. The first load
+            // lands before it exists, so the data has to arrive through the config;
+            // every later one has to go through the instance or nothing changes.
+            this.treeConfig = { ...this.treeConfig, data: nodes };
+            this._tree()?.setData(nodes);
+        });
+    }
+    // Flat API rows → the nested shape fs-tree renders. Folders come before
+    // reports at every level, each already name-ordered by the backend.
+    _buildNodes(tree) {
+        const folders = tree?.folders ?? [];
+        const reports = tree?.reports ?? [];
+        const build = (parentId) => {
+            const folderNodes = folders
+                .filter((folder) => (folder.parentReportFolderId ?? null) === parentId)
+                .map((folder) => ({
+                key: `f:${folder.id}`,
+                id: folder.id,
+                name: folder.name,
+                type: ReportNodeType.Folder,
+                children: build(folder.id),
+            }));
+            const reportNodes = reports
+                .filter((report) => (report.reportFolderId ?? null) === parentId)
+                .map((report) => ({
+                key: `r:${report.id}`,
+                id: report.id,
+                name: report.name,
+                type: ReportNodeType.Report,
+                children: [],
+                report,
+            }));
+            return [...folderNodes, ...reportNodes];
+        };
+        return build(null);
+    }
+    // A drop moved a node under a new parent, or out to the root. The tree has
+    // already moved it on screen, so both outcomes reload: a success to pick up
+    // the server's ordering, a failure to put the row back where it really is.
+    _move(event) {
+        const node = event.node?.data;
+        if (!node) {
+            return;
+        }
+        const parentReportFolderId = event.toParent?.data?.id ?? null;
+        if (event.toParent && !event.toParent.isExpanded()) {
+            event.toParent.expand();
+        }
+        const save$ = node.type === ReportNodeType.Folder
+            ? this._reportData.updateFolder(node.id, { parentReportFolderId })
+            : this._reportData.moveReport(node.id, parentReportFolderId);
+        save$
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe({
+            next: () => {
+                this._message.success('Saved changes');
+                this._load();
+            },
+            error: () => this._load(),
+        });
+    }
+    _createFolder(parentReportFolderId) {
+        this._prompt.input({
+            title: 'New Folder',
+            label: 'Name',
+            commitLabel: 'Create',
+            required: true,
+        })
+            .pipe(switchMap((name) => this._reportData.createFolder(name, parentReportFolderId)), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this._message.success('Created folder');
+            this._load();
+        });
+    }
+    _rename(node) {
+        const data = node?.data;
+        if (!data) {
+            return;
+        }
+        const folder = data.type === ReportNodeType.Folder;
+        this._prompt.input({
+            title: folder ? 'Rename Folder' : 'Rename Report',
+            label: 'Name',
+            default: data.name,
+            commitLabel: 'Save',
+            required: true,
+        })
+            .pipe(switchMap((name) => (folder
+            ? this._reportData.updateFolder(data.id, { name })
+            : this._reportData.rename(data.id, name))), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this._message.success('Saved changes');
+            this._load();
+        });
+    }
+    // Deleting a folder is refused server-side while it still holds a sub-folder
+    // or an active report, and the message says which — so the confirm here warns
+    // that a folder delete is permanent rather than trying to restate the rule.
+    _delete(node) {
+        const data = node?.data;
+        if (!data) {
+            return;
+        }
+        const folder = data.type === ReportNodeType.Folder;
+        this._prompt.confirm({
+            title: 'Confirm',
+            template: folder
+                ? `Are you sure you would like to delete the folder "${data.name}"? This cannot be undone.`
+                : 'Are you sure you would like to delete this report?',
+        })
+            .pipe(switchMap(() => (folder
+            ? this._reportData.deleteFolder(data.id)
+            : this._reportData.delete(data.id))), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this._message.success(folder ? 'Deleted folder' : 'Deleted report');
+            this._load();
+        });
+    }
+    _restore(node) {
+        const data = node?.data;
+        if (!data) {
+            return;
+        }
+        this._reportData.undelete(data.id)
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            this._message.success('Restored report');
+            this._load();
+        });
+    }
+    // Turn a ':id' pattern into router commands. Relative unless it starts
+    // with '/', in which case the first segment carries the leading slash.
+    _patternCommands(pattern, id) {
+        const absolute = pattern.startsWith('/');
+        const segments = pattern.split('/')
+            .filter((segment) => segment.length > 0)
+            .map((segment) => (segment === ':id' ? id : segment));
+        if (!segments.length) {
+            return [id];
+        }
+        if (absolute) {
+            segments[0] = `/${segments[0]}`;
+        }
+        return segments;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FsAiReportsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: FsAiReportsComponent, isStandalone: true, selector: "fs-ai-reports", inputs: { basePath: { classPropertyName: "basePath", publicName: "basePath", isSignal: true, isRequired: false, transformFunction: null }, openPattern: { classPropertyName: "openPattern", publicName: "openPattern", isSignal: true, isRequired: false, transformFunction: null }, createPattern: { classPropertyName: "createPattern", publicName: "createPattern", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "list", first: true, predicate: FsListComponent, descendants: true }], ngImport: i0, template: "<fs-list\n    [config]=\"listConfig\"\n    #list>\n\n  <fs-list-column title=\"Name\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <!-- A deleted report can't be opened (the backend only assembles active\n           ones), so in Show Deleted mode the name is plain text \u2014 restore it\n           from the row menu first. -->\n      @if (row.state === deletedState) {\n        {{ row.name }}\n      } @else {\n        <a [routerLink]=\"openLink(row)\">{{ row.name }}</a>\n      }\n    </ng-template>\n  </fs-list-column>\n\n  <fs-list-column title=\"Modified\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <fs-date [date]=\"row.modifyDate\"></fs-date>\n    </ng-template>\n  </fs-list-column>\n\n</fs-list>\n", styles: ["a{cursor:pointer}\n"], dependencies: [{ kind: "ngmodule", type: FsDateModule }, { kind: "component", type: i1.FsDateComponent, selector: "fs-date", inputs: ["date", "format", "timezone"] }, { kind: "ngmodule", type: FsListModule }, { kind: "component", type: i2.FsListComponent, selector: "fs-list", inputs: ["config", "loaderLines", "cellRowType"], outputs: ["filtersReady"] }, { kind: "directive", type: i2.FsListColumnDirective, selector: "fs-list-column", inputs: ["show", "title", "name", "customizable", "sortable", "sortableDefault", "sortableDirection", "direction", "align", "width", "class"] }, { kind: "directive", type: i2.FsListCellDirective, selector: "[fs-list-cell],[fsListCell]", inputs: ["colspan", "align", "class", "fsListCell", "configTyping"] }, { kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: FsAiReportsComponent, isStandalone: true, selector: "fs-ai-reports", inputs: { basePath: { classPropertyName: "basePath", publicName: "basePath", isSignal: true, isRequired: false, transformFunction: null }, openPattern: { classPropertyName: "openPattern", publicName: "openPattern", isSignal: true, isRequired: false, transformFunction: null }, createPattern: { classPropertyName: "createPattern", publicName: "createPattern", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "_tree", first: true, predicate: FsTreeComponent, descendants: true, isSignal: true }], ngImport: i0, template: "<fs-filter [config]=\"filterConfig\"></fs-filter>\n\n<ng-container *fsSkeleton=\"nodes()\">\n  <fs-tree [config]=\"treeConfig\">\n    <ng-template\n        fsTreeNode\n        let-data=\"data\">\n      <div class=\"fs-row.gap-sm.align-center node-row\">\n        <mat-icon class=\"node-icon\">\n          {{ data.type === nodeType.Folder ? 'folder' : 'insert_chart_outlined' }}\n        </mat-icon>\n\n        @if (data.type === nodeType.Folder) {\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else if (isDeleted(data.report)) {\n          <!-- A deleted report can't be opened (the backend only assembles\n               active ones), so in Show Deleted mode the name is plain text \u2014\n               restore it from the row menu first. -->\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else {\n          <a\n              class=\"node-name\"\n              [routerLink]=\"openLink(data.report)\">\n            {{ data.name }}\n          </a>\n        }\n      </div>\n    </ng-template>\n  </fs-tree>\n\n  @if (!nodes().length) {\n    <p class=\"small tree-empty\">\n      No reports yet. Create one, or add a folder to group them.\n    </p>\n  }\n</ng-container>\n", styles: ["a{cursor:pointer}fs-tree .node>.container{flex:1;min-width:0}fs-tree .node>.container>.content{min-width:0}fs-tree .node>.container>button{margin-top:-5px}.node-row{min-width:0}.node-icon{font-size:18px;width:18px;height:18px;flex:none}.node-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tree-empty{margin-top:10px}\n"], dependencies: [{ kind: "ngmodule", type: FsFilterModule }, { kind: "component", type: i1.FilterComponent, selector: "fs-filter", inputs: ["config"], outputs: ["closed", "opened", "ready"] }, { kind: "ngmodule", type: FsSkeletonModule }, { kind: "directive", type: i2.FsSkeletonContentDirective, selector: "[fsSkeleton]", inputs: ["fsSkeleton", "fsSkeletonPattern"] }, { kind: "ngmodule", type: FsTreeModule }, { kind: "component", type: i3.FsTreeComponent, selector: "fs-tree", inputs: ["config"] }, { kind: "directive", type: i3.FsTreeNodeDirective, selector: "[fsTreeNode]", inputs: ["class"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: FsAiReportsComponent, decorators: [{
             type: Component,
             args: [{ selector: 'fs-ai-reports', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
-                        FsDateModule,
-                        FsListModule,
+                        FsFilterModule,
+                        FsSkeletonModule,
+                        FsTreeModule,
+                        MatIconModule,
                         RouterLink,
-                    ], template: "<fs-list\n    [config]=\"listConfig\"\n    #list>\n\n  <fs-list-column title=\"Name\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <!-- A deleted report can't be opened (the backend only assembles active\n           ones), so in Show Deleted mode the name is plain text \u2014 restore it\n           from the row menu first. -->\n      @if (row.state === deletedState) {\n        {{ row.name }}\n      } @else {\n        <a [routerLink]=\"openLink(row)\">{{ row.name }}</a>\n      }\n    </ng-template>\n  </fs-list-column>\n\n  <fs-list-column title=\"Modified\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <fs-date [date]=\"row.modifyDate\"></fs-date>\n    </ng-template>\n  </fs-list-column>\n\n</fs-list>\n", styles: ["a{cursor:pointer}\n"] }]
-        }], ctorParameters: () => [], propDecorators: { list: [{
-                type: ViewChild,
-                args: [FsListComponent]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fs-ai-reports.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/views/reports/fs-ai-reports.component.ts","../../../../../../src/app/reports/views/reports/fs-ai-reports.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, DestroyRef, ViewChild, effect, inject, input } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute, Router, RouterLink } from '@angular/router';\n\nimport { MatDialog } from '@angular/material/dialog';\n\nimport { FsDateModule } from '@firestitch/date';\nimport { FsListComponent, FsListConfig, FsListModule } from '@firestitch/list';\nimport { FsPrompt } from '@firestitch/prompt';\n\nimport { map, switchMap } from 'rxjs/operators';\n\nimport { ReportData } from '../../data/report.data';\nimport { GlobalSettingsComponent } from '../../dialogs/global-settings/global-settings.component';\nimport { ReportListItem, ReportState } from '../../interfaces/report.interface';\n\n\n// The reports listing — an fs-list of reports. Rows are links built from a URL\n// pattern (a ':id' token → the report id; a leading '/' makes it absolute,\n// otherwise it's relative to this component's route). Create prompts for a\n// title, creates the report, then routes to it. The header gear opens the\n// global Report Settings dialog (AI knowledge document + semantic-database\n// build), which lives in this package. No routing is hard-coded here.\n//\n// Reports are soft-deletable: the row kebab deletes, \"Show Deleted\" flips the\n// list into deleted mode (the backend hides deleted reports otherwise), and in\n// that mode fs-list swaps Delete for Restore, which calls the undelete action\n// endpoint.\n@Component({\n  selector: 'fs-ai-reports',\n  templateUrl: './fs-ai-reports.component.html',\n  styleUrls: ['./fs-ai-reports.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    FsDateModule,\n    FsListModule,\n    RouterLink,\n  ],\n})\nexport class FsAiReportsComponent {\n\n  // API base for the reports endpoints; override to mount elsewhere.\n  public readonly basePath = input<string>('reports');\n\n  // Where a row links to; ':id' is replaced with the report id. Default takes\n  // you to <current route>/:id. Absolute when it starts with '/'.\n  public readonly openPattern = input<string>(':id');\n\n  // Where a freshly-created report routes to; same ':id' pattern rules.\n  public readonly createPattern = input<string>(':id');\n\n  @ViewChild(FsListComponent)\n  public list: FsListComponent = null;\n\n  public listConfig: FsListConfig<ReportListItem>;\n\n  // Template-side handle on the enum, so the name cell can tell a deleted row\n  // (shown in Show Deleted mode) from a live one.\n  public readonly deletedState = ReportState.Deleted;\n\n  private _reportData = inject(ReportData);\n  private _router = inject(Router);\n  private _route = inject(ActivatedRoute);\n  private _prompt = inject(FsPrompt);\n  private _dialog = inject(MatDialog);\n  private _destroyRef = inject(DestroyRef);\n\n  constructor() {\n    effect(() => {\n      this._reportData.basePath = this.basePath();\n    });\n\n    this._initListConfig();\n  }\n\n  // routerLink commands for a report row (built from openPattern).\n  public openLink(report: ReportListItem): unknown[] {\n    return this._patternCommands(this.openPattern(), report.id);\n  }\n\n  // Prompt for a title, create the report, then route to it (createPattern).\n  public createReport(): void {\n    this._prompt.input({\n      title: 'Create Report',\n      label: 'Title',\n      commitLabel: 'Create',\n      required: true,\n    })\n      .pipe(\n        switchMap((name: string) => this._reportData.create(name)),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe((report: ReportListItem) => {\n        const pattern = this.createPattern();\n        this._router.navigate(\n          this._patternCommands(pattern, report.id),\n          pattern.startsWith('/') ? {} : { relativeTo: this._route },\n        );\n      });\n  }\n\n  // Turn a ':id' pattern into router commands. Relative unless it starts\n  // with '/', in which case the first segment carries the leading slash.\n  private _patternCommands(pattern: string, id: number): unknown[] {\n    const absolute = pattern.startsWith('/');\n    const segments: unknown[] = pattern.split('/')\n      .filter((segment) => segment.length > 0)\n      .map((segment) => (segment === ':id' ? id : segment));\n\n    if (!segments.length) {\n      return [id];\n    }\n\n    if (absolute) {\n      segments[0] = `/${segments[0]}`;\n    }\n\n    return segments;\n  }\n\n  // The global Report Settings dialog: the AI knowledge document and the\n  // semantic-database build. A running build streams into the FsProcess dock,\n  // which survives the dialog closing.\n  public openSettings(): void {\n    this._dialog.open(GlobalSettingsComponent, {\n      width: '900px',\n      maxWidth: '95vw',\n      maxHeight: '90vh',\n      autoFocus: false,\n    });\n  }\n\n  private _initListConfig(): void {\n    this.listConfig = {\n      // The backend list is not paged yet; show the full set until it is.\n      paging: false,\n      actions: [\n        {\n          // Icon-only: the global Report Settings dialog.\n          icon: 'settings',\n          tooltip: 'Report settings',\n          primary: false,\n          click: () => this.openSettings(),\n        },\n        {\n          label: 'Create',\n          primary: true,\n          click: () => this.createReport(),\n        },\n      ],\n      rowActions: [\n        {\n          click: (report) => this._reportData.delete(report.id),\n          remove: {\n            title: 'Confirm',\n            template: 'Are you sure you would like to delete this report?',\n          },\n          menu: true,\n          label: 'Delete',\n        },\n      ],\n      // `filter: true` makes fs-list render the Show Deleted toggle and send\n      // `query` with the fetch; in that mode it also swaps the row's Delete\n      // action for Restore.\n      restore: {\n        query: { state: ReportState.Deleted },\n        filter: true,\n        filterLabel: 'Show Deleted',\n        menuLabel: 'Restore',\n        reload: true,\n        click: (report) => this._reportData.undelete(report.id),\n      },\n      fetch: (query) => {\n        return this._reportData.reports(query)\n          .pipe(\n            map((reports: ReportListItem[]) => ({ data: reports ?? [] })),\n          );\n      },\n    };\n  }\n}\n","<fs-list\n    [config]=\"listConfig\"\n    #list>\n\n  <fs-list-column title=\"Name\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <!-- A deleted report can't be opened (the backend only assembles active\n           ones), so in Show Deleted mode the name is plain text — restore it\n           from the row menu first. -->\n      @if (row.state === deletedState) {\n        {{ row.name }}\n      } @else {\n        <a [routerLink]=\"openLink(row)\">{{ row.name }}</a>\n      }\n    </ng-template>\n  </fs-list-column>\n\n  <fs-list-column title=\"Modified\">\n    <ng-template\n        fs-list-cell\n        let-row=\"row\">\n      <fs-date [date]=\"row.modifyDate\"></fs-date>\n    </ng-template>\n  </fs-list-column>\n\n</fs-list>\n"]}
+                    ], template: "<fs-filter [config]=\"filterConfig\"></fs-filter>\n\n<ng-container *fsSkeleton=\"nodes()\">\n  <fs-tree [config]=\"treeConfig\">\n    <ng-template\n        fsTreeNode\n        let-data=\"data\">\n      <div class=\"fs-row.gap-sm.align-center node-row\">\n        <mat-icon class=\"node-icon\">\n          {{ data.type === nodeType.Folder ? 'folder' : 'insert_chart_outlined' }}\n        </mat-icon>\n\n        @if (data.type === nodeType.Folder) {\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else if (isDeleted(data.report)) {\n          <!-- A deleted report can't be opened (the backend only assembles\n               active ones), so in Show Deleted mode the name is plain text \u2014\n               restore it from the row menu first. -->\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else {\n          <a\n              class=\"node-name\"\n              [routerLink]=\"openLink(data.report)\">\n            {{ data.name }}\n          </a>\n        }\n      </div>\n    </ng-template>\n  </fs-tree>\n\n  @if (!nodes().length) {\n    <p class=\"small tree-empty\">\n      No reports yet. Create one, or add a folder to group them.\n    </p>\n  }\n</ng-container>\n", styles: ["a{cursor:pointer}fs-tree .node>.container{flex:1;min-width:0}fs-tree .node>.container>.content{min-width:0}fs-tree .node>.container>button{margin-top:-5px}.node-row{min-width:0}.node-icon{font-size:18px;width:18px;height:18px;flex:none}.node-name{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tree-empty{margin-top:10px}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fs-ai-reports.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/views/reports/fs-ai-reports.component.ts","../../../../../../src/app/reports/views/reports/fs-ai-reports.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  DestroyRef,\n  OnInit,\n  effect,\n  inject,\n  input,\n  signal,\n  viewChild,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ActivatedRoute, Router, RouterLink } from '@angular/router';\n\nimport { MatDialog } from '@angular/material/dialog';\nimport { MatIconModule } from '@angular/material/icon';\n\nimport { FilterConfig, FsFilterModule, ItemType } from '@firestitch/filter';\nimport { FsMessage } from '@firestitch/message';\nimport { FsPrompt } from '@firestitch/prompt';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\nimport {\n  FlatItemNode,\n  FsTreeComponent,\n  FsTreeModule,\n  ITreeChangeReorder,\n  ITreeConfig,\n  TreeActionType,\n  TreeDragMode,\n} from '@firestitch/tree';\n\nimport { Observable, switchMap } from 'rxjs';\n\nimport { ReportData } from '../../data/report.data';\nimport { GlobalSettingsComponent } from '../../dialogs/global-settings/global-settings.component';\nimport {\n  ReportFolder,\n  ReportListItem,\n  ReportNode,\n  ReportNodeType,\n  ReportState,\n  ReportStates,\n  ReportTree,\n} from '../../interfaces/report.interface';\n\n\n// The reports listing — an fs-tree of folders and the reports filed into them.\n// Rows link out through a URL pattern (a ':id' token → the report id; a leading\n// '/' makes it absolute, otherwise it's relative to this component's route).\n// Create prompts for a title, creates the report, then routes to it. The gear\n// opens the global Report Settings dialog (AI knowledge document +\n// semantic-database build), which lives in this package. No routing is\n// hard-coded here.\n//\n// Folders nest; reports are always leaves — canDrop enforces it here, and the\n// backend enforces it structurally by keeping the tree in its own table. A\n// report in no folder is a root node, which is where every report sat before\n// folders existed, so nothing had to be migrated or bucketed as \"uncategorized\".\n//\n// Reports are soft-deletable: the row kebab deletes, \"Show Deleted\" flips the\n// listing into deleted mode (the backend hides deleted reports otherwise), and\n// in that mode the kebab offers Restore instead. Folders do NOT take part in\n// that — a folder is only deletable once it is empty, so it hard deletes and has\n// nothing to restore. The upshot is that deleted mode keeps the folder structure\n// on screen with the deleted reports sitting where they belong, so restoring one\n// puts it back rather than dropping it at the root.\n@Component({\n  selector: 'fs-ai-reports',\n  templateUrl: './fs-ai-reports.component.html',\n  styleUrls: ['./fs-ai-reports.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    FsFilterModule,\n    FsSkeletonModule,\n    FsTreeModule,\n    MatIconModule,\n    RouterLink,\n  ],\n})\nexport class FsAiReportsComponent implements OnInit {\n\n  // How deep the tree opens on load. Folders are audience buckets, not a\n  // filesystem, so there is nothing worth hiding behind a closed chevron.\n  public static readonly EXPAND_LEVEL = 10;\n\n  // API base for the reports endpoints; override to mount elsewhere.\n  public readonly basePath = input<string>('reports');\n\n  // Where a row links to; ':id' is replaced with the report id. Default takes\n  // you to <current route>/:id. Absolute when it starts with '/'.\n  public readonly openPattern = input<string>(':id');\n\n  // Where a freshly-created report routes to; same ':id' pattern rules.\n  public readonly createPattern = input<string>(':id');\n\n  // Null until the first load resolves — that is what gates *fsSkeleton.\n  public readonly nodes = signal<ReportNode[]>(null);\n\n  public treeConfig: ITreeConfig<ReportNode[]>;\n  public filterConfig: FilterConfig;\n\n  // Template-side handle on the enum, so a row can tell a folder from a report.\n  public readonly nodeType = ReportNodeType;\n\n  private readonly _tree = viewChild(FsTreeComponent);\n\n  private _reportData = inject(ReportData);\n  private _router = inject(Router);\n  private _route = inject(ActivatedRoute);\n  private _prompt = inject(FsPrompt);\n  private _message = inject(FsMessage);\n  private _dialog = inject(MatDialog);\n  private _destroyRef = inject(DestroyRef);\n\n  // The filter bar's current query — carries `state` when Show Deleted is on.\n  private _query: Record<string, unknown> = {};\n\n  constructor() {\n    effect(() => {\n      this._reportData.basePath = this.basePath();\n    });\n  }\n\n  public ngOnInit(): void {\n    // Set before the first fetch rather than waiting on the effect above, which\n    // does not run until after the initial change detection pass.\n    this._reportData.basePath = this.basePath();\n\n    this._initFilterConfig();\n    this._initTreeConfig();\n    this._load();\n  }\n\n  // routerLink commands for a report row (built from openPattern).\n  public openLink(report: ReportListItem): unknown[] {\n    return this._patternCommands(this.openPattern(), report.id);\n  }\n\n  // A deleted report can't be opened — the backend only assembles active ones —\n  // so in Show Deleted mode its name renders as plain text rather than a link.\n  public isDeleted(report: ReportListItem): boolean {\n    return report?.state === ReportState.Deleted;\n  }\n\n  // Prompt for a title, create the report, then route to it (createPattern).\n  public createReport(): void {\n    this._prompt.input({\n      title: 'Create Report',\n      label: 'Title',\n      commitLabel: 'Create',\n      required: true,\n    })\n      .pipe(\n        switchMap((name: string) => this._reportData.create(name)),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe((report: ReportListItem) => {\n        const pattern = this.createPattern();\n        this._router.navigate(\n          this._patternCommands(pattern, report.id),\n          pattern.startsWith('/') ? {} : { relativeTo: this._route },\n        );\n      });\n  }\n\n  // The global Report Settings dialog: the AI knowledge document and the\n  // semantic-database build. A running build streams into the FsProcess dock,\n  // which survives the dialog closing.\n  public openSettings(): void {\n    this._dialog.open(GlobalSettingsComponent, {\n      width: '900px',\n      maxWidth: '95vw',\n      maxHeight: '90vh',\n      autoFocus: false,\n    });\n  }\n\n  private _initFilterConfig(): void {\n    this.filterConfig = {\n      items: [\n        {\n          name: 'keyword',\n          type: ItemType.Keyword,\n          label: 'Search',\n        },\n        {\n          name: 'state',\n          type: ItemType.Select,\n          label: 'Status',\n          multiple: true,\n          values: () => ReportStates,\n          isolate: { label: 'Show Deleted', value: ReportState.Deleted },\n        },\n      ],\n      actions: [\n        {\n          icon: 'unfold_more',\n          tooltip: 'Expand all',\n          primary: false,\n          click: () => this._tree()?.expandAll(),\n        },\n        {\n          icon: 'unfold_less',\n          tooltip: 'Collapse all',\n          primary: false,\n          click: () => this._tree()?.collapseAll(),\n        },\n        {\n          icon: 'settings',\n          tooltip: 'Report settings',\n          primary: false,\n          click: () => this.openSettings(),\n        },\n        {\n          label: 'New Folder',\n          primary: false,\n          click: () => this._createFolder(null),\n        },\n        {\n          label: 'Create',\n          primary: true,\n          click: () => this.createReport(),\n        },\n      ],\n      // The two items are answered in different places and both have to run.\n      // The keyword drives the tree's own search, which is the whole point of\n      // searching a tree — it reveals a match nested inside collapsed folders\n      // rather than only filtering what is already on screen. `state` is the\n      // Show Deleted toggle, and only the server can answer that.\n      change: (query) => {\n        const stateChanged = String(query?.state ?? '') !== String(this._query.state ?? '');\n        this._query = { ...query };\n\n        this._search(query?.keyword);\n\n        if (stateChanged) {\n          this._load();\n        }\n      },\n    };\n  }\n\n  private _initTreeConfig(): void {\n    this.treeConfig = {\n      data: [],\n      childrenName: 'children',\n      expandLevel: FsAiReportsComponent.EXPAND_LEVEL,\n      draggable: true,\n      // The whole row is the grip and the handle stays hidden; a press only\n      // becomes a drag once the pointer moves, so the kebab, the chevron and the\n      // report link all stay clickable.\n      dragMode: TreeDragMode.Node,\n      // canDrop is asked about the node being DRAGGED, so only `toParent`\n      // describes the destination — reading node.level/node.parent here would\n      // describe where it came from. A report can never be a parent because its\n      // type says so, and that single test is the whole \"folders nest, reports\n      // are leaves\" rule on this side.\n      canDrop: (node: FlatItemNode, fromParent: FlatItemNode, toParent: FlatItemNode) => {\n        return !toParent || toParent.data?.type === ReportNodeType.Folder;\n      },\n      changeReorder: (event: ITreeChangeReorder) => this._move(event),\n      nodeClass: (node: FlatItemNode) => node.data?.type,\n      // Match on the name only. The library's default matcher stringifies the\n      // whole node, so it would hit ids, the literal type word, and everything\n      // else riding on the row.\n      filterItem: (node, query) => {\n        return String(node.data?.name ?? '')\n          .toLowerCase()\n          .includes(String(query ?? '').toLowerCase());\n      },\n      actions: [\n        {\n          type: TreeActionType.Menu,\n          icon: 'more_vert',\n          items: [\n            {\n              label: 'Rename',\n              show: (node: FlatItemNode) => !this._isDeletedNode(node),\n              click: (node: FlatItemNode) => this._rename(node),\n            },\n            {\n              label: 'New Folder Inside',\n              show: (node: FlatItemNode) => this._isFolderNode(node),\n              click: (node: FlatItemNode) => this._createFolder(node.data?.id),\n            },\n            {\n              label: 'Delete',\n              show: (node: FlatItemNode) => !this._isDeletedNode(node),\n              click: (node: FlatItemNode) => this._delete(node),\n            },\n            // Folders never reach this: they hard delete, so a deleted folder\n            // does not exist to be restored.\n            {\n              label: 'Restore',\n              show: (node: FlatItemNode) => this._isDeletedNode(node),\n              click: (node: FlatItemNode) => this._restore(node),\n            },\n          ],\n        },\n      ],\n    };\n  }\n\n  private _isFolderNode(node: FlatItemNode): boolean {\n    return node?.data?.type === ReportNodeType.Folder;\n  }\n\n  private _isDeletedNode(node: FlatItemNode): boolean {\n    return this.isDeleted(node?.data?.report);\n  }\n\n  // Drive the tree's built-in search: it collapses everything, hides every node,\n  // then unhides each match and walks its ancestors open, so a report several\n  // folders deep surfaces with its path expanded. Clearing does NOT undo that\n  // initial collapse, so the tree is re-opened here — otherwise the listing is\n  // left fully collapsed the moment somebody empties the search box.\n  private _search(keyword: string): void {\n    const tree = this._tree();\n    if (!tree) {\n      return;\n    }\n\n    if (keyword) {\n      tree.search(keyword);\n      return;\n    }\n\n    tree.clearSearch();\n    tree.expandAll();\n  }\n\n  private _load(): void {\n    this._reportData.tree(this._query)\n      .pipe(\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe((tree: ReportTree) => {\n        const nodes = this._buildNodes(tree);\n        this.nodes.set(nodes);\n\n        // The tree reads `config` once, in its own ngOnInit. The first load\n        // lands before it exists, so the data has to arrive through the config;\n        // every later one has to go through the instance or nothing changes.\n        this.treeConfig = { ...this.treeConfig, data: nodes };\n        this._tree()?.setData(nodes);\n      });\n  }\n\n  // Flat API rows → the nested shape fs-tree renders. Folders come before\n  // reports at every level, each already name-ordered by the backend.\n  private _buildNodes(tree: ReportTree): ReportNode[] {\n    const folders = tree?.folders ?? [];\n    const reports = tree?.reports ?? [];\n\n    const build = (parentId: number | null): ReportNode[] => {\n      const folderNodes: ReportNode[] = folders\n        .filter((folder: ReportFolder) => (folder.parentReportFolderId ?? null) === parentId)\n        .map((folder: ReportFolder) => ({\n          key: `f:${folder.id}`,\n          id: folder.id,\n          name: folder.name,\n          type: ReportNodeType.Folder,\n          children: build(folder.id),\n        }));\n\n      const reportNodes: ReportNode[] = reports\n        .filter((report: ReportListItem) => (report.reportFolderId ?? null) === parentId)\n        .map((report: ReportListItem) => ({\n          key: `r:${report.id}`,\n          id: report.id,\n          name: report.name,\n          type: ReportNodeType.Report,\n          children: [],\n          report,\n        }));\n\n      return [...folderNodes, ...reportNodes];\n    };\n\n    return build(null);\n  }\n\n  // A drop moved a node under a new parent, or out to the root. The tree has\n  // already moved it on screen, so both outcomes reload: a success to pick up\n  // the server's ordering, a failure to put the row back where it really is.\n  private _move(event: ITreeChangeReorder): void {\n    const node: ReportNode = event.node?.data;\n    if (!node) {\n      return;\n    }\n\n    const parentReportFolderId: number = event.toParent?.data?.id ?? null;\n\n    if (event.toParent && !event.toParent.isExpanded()) {\n      event.toParent.expand();\n    }\n\n    const save$: Observable<unknown> = node.type === ReportNodeType.Folder\n      ? this._reportData.updateFolder(node.id, { parentReportFolderId })\n      : this._reportData.moveReport(node.id, parentReportFolderId);\n\n    save$\n      .pipe(\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe({\n        next: () => {\n          this._message.success('Saved changes');\n          this._load();\n        },\n        error: () => this._load(),\n      });\n  }\n\n  private _createFolder(parentReportFolderId: number): void {\n    this._prompt.input({\n      title: 'New Folder',\n      label: 'Name',\n      commitLabel: 'Create',\n      required: true,\n    })\n      .pipe(\n        switchMap((name: string) => this._reportData.createFolder(name, parentReportFolderId)),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this._message.success('Created folder');\n        this._load();\n      });\n  }\n\n  private _rename(node: FlatItemNode): void {\n    const data: ReportNode = node?.data;\n    if (!data) {\n      return;\n    }\n\n    const folder = data.type === ReportNodeType.Folder;\n\n    this._prompt.input({\n      title: folder ? 'Rename Folder' : 'Rename Report',\n      label: 'Name',\n      default: data.name,\n      commitLabel: 'Save',\n      required: true,\n    })\n      .pipe(\n        switchMap((name: string) => (folder\n          ? this._reportData.updateFolder(data.id, { name })\n          : this._reportData.rename(data.id, name))),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this._message.success('Saved changes');\n        this._load();\n      });\n  }\n\n  // Deleting a folder is refused server-side while it still holds a sub-folder\n  // or an active report, and the message says which — so the confirm here warns\n  // that a folder delete is permanent rather than trying to restate the rule.\n  private _delete(node: FlatItemNode): void {\n    const data: ReportNode = node?.data;\n    if (!data) {\n      return;\n    }\n\n    const folder = data.type === ReportNodeType.Folder;\n\n    this._prompt.confirm({\n      title: 'Confirm',\n      template: folder\n        ? `Are you sure you would like to delete the folder \"${data.name}\"? This cannot be undone.`\n        : 'Are you sure you would like to delete this report?',\n    })\n      .pipe(\n        switchMap(() => (folder\n          ? this._reportData.deleteFolder(data.id)\n          : this._reportData.delete(data.id))),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this._message.success(folder ? 'Deleted folder' : 'Deleted report');\n        this._load();\n      });\n  }\n\n  private _restore(node: FlatItemNode): void {\n    const data: ReportNode = node?.data;\n    if (!data) {\n      return;\n    }\n\n    this._reportData.undelete(data.id)\n      .pipe(\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this._message.success('Restored report');\n        this._load();\n      });\n  }\n\n  // Turn a ':id' pattern into router commands. Relative unless it starts\n  // with '/', in which case the first segment carries the leading slash.\n  private _patternCommands(pattern: string, id: number): unknown[] {\n    const absolute = pattern.startsWith('/');\n    const segments: unknown[] = pattern.split('/')\n      .filter((segment) => segment.length > 0)\n      .map((segment) => (segment === ':id' ? id : segment));\n\n    if (!segments.length) {\n      return [id];\n    }\n\n    if (absolute) {\n      segments[0] = `/${segments[0]}`;\n    }\n\n    return segments;\n  }\n}\n","<fs-filter [config]=\"filterConfig\"></fs-filter>\n\n<ng-container *fsSkeleton=\"nodes()\">\n  <fs-tree [config]=\"treeConfig\">\n    <ng-template\n        fsTreeNode\n        let-data=\"data\">\n      <div class=\"fs-row.gap-sm.align-center node-row\">\n        <mat-icon class=\"node-icon\">\n          {{ data.type === nodeType.Folder ? 'folder' : 'insert_chart_outlined' }}\n        </mat-icon>\n\n        @if (data.type === nodeType.Folder) {\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else if (isDeleted(data.report)) {\n          <!-- A deleted report can't be opened (the backend only assembles\n               active ones), so in Show Deleted mode the name is plain text —\n               restore it from the row menu first. -->\n          <span class=\"node-name\">{{ data.name }}</span>\n        } @else {\n          <a\n              class=\"node-name\"\n              [routerLink]=\"openLink(data.report)\">\n            {{ data.name }}\n          </a>\n        }\n      </div>\n    </ng-template>\n  </fs-tree>\n\n  @if (!nodes().length) {\n    <p class=\"small tree-empty\">\n      No reports yet. Create one, or add a folder to group them.\n    </p>\n  }\n</ng-container>\n"]}