@mmlogic/components 0.3.8 → 0.3.10

package/dist/collection/components/mrd-document-list/mrd-document-list.js

@@ -0,0 +1,1129 @@
+import { Host, h } from "@stencil/core";
+import { ClientLayoutItemType } from "../../types/client-layout";
+import { t } from "../../utils/i18n";
+import { formatDate } from "../../utils/format";
+/**
+ * Archetype-driven document collection view. Renders documents as a lazy,
+ * file-explorer-style folder tree, grouped by the `commons.document` archetype's
+ * `container` (dossier, the top folder) and `folder` (a path string like
+ * `/draft documents/may 2020`, the sub-path beneath it).
+ *
+ * Loading is lazy per level, mirroring the /distinct endpoint (FINDING-0106):
+ *  - on load → `mrdLoadDistinct` for the `container` relation → top folders;
+ *  - on expanding a container → `mrdLoadDistinct` for the `folder` field, filtered
+ *    by `{containerField}_href` → all folder path strings for that container
+ *    (the client splits them on `/` and builds the sub-tree locally);
+ *  - on expanding a node that holds documents → `mrdLoadPage` (a plain filtered list
+ *    load, the same one a table page uses), filtered by container + exact folder string.
+ *
+ * When exactly one container exists (e.g. a dossier detail page) the container
+ * level is hidden and its folder tree is shown directly at the root.
+ */
+export class MrdDocumentList {
+    constructor() {
+        /** The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config). */
+        this.item = null;
+        /** Parent record id — required for RELATED_VIEW path building. */
+        this.parentId = '';
+        this.locale = navigator.language;
+        this.containers = [];
+        this.rootLoading = true;
+        /** True when the single-container level is collapsed away (dossier context). */
+        this.singleContainer = false;
+        /** Currently selected node id — the target for "New folder" and (later) drops. */
+        this.selectedId = null;
+        /** Node id currently highlighted as a drag-drop target (null = none). */
+        this.dropTargetId = null;
+        /** Node id showing an "uploading…" indicator while a dropped file is processed. */
+        this.uploadingNodeId = null;
+        this.nodeIndex = new Map();
+        // ── New-folder editing state ───────────────────────────────────────────────
+        /** The pending node whose inline name input is open (null = not creating). */
+        this.pendingNode = null;
+        /** The node the pending folder is being created under. */
+        this.pendingParent = null;
+        /** The container the pending folder belongs to. */
+        this.pendingContainer = null;
+        /** Current text in the inline name input. */
+        this.pendingName = '';
+        /** Ref to the inline input, so we can focus it after it mounts. */
+        this.pendingInputEl = null;
+        /** Set when a fresh input needs focus on the next render. */
+        this.pendingNeedsFocus = false;
+        /** Monotonic counter for unique temporary pending-node ids. */
+        this.newFolderSeq = 0;
+        /** Last emitted canCreateFolder value, to only emit mrdCanCreate on change. */
+        this.lastCanCreate = false;
+        // ── Drag & drop (move a document into another folder) ──────────────────────
+        /** The document row currently being dragged. */
+        this.dragDoc = null;
+        /** Id of the node the dragged document currently lives in. */
+        this.dragFromId = null;
+        /** External file dropped onto a node, awaiting its upload to complete. */
+        this.pendingUpload = null;
+        /** The optimistic document row awaiting its self href from the create POST. */
+        this.lastOptimisticDoc = null;
+        this.startCreateFolder = () => {
+            const resolved = this.resolveTarget();
+            if (!resolved || this.pendingNode)
+                return;
+            const { target, container } = resolved;
+            const tempId = `${container.id}/__new__${this.newFolderSeq++}`;
+            const node = this.makeFolderNode(tempId, '', container.id);
+            node.pending = true;
+            node.editing = true;
+            target.children = [...target.children, node];
+            target.open = true;
+            this.nodeIndex.set(node.id, node);
+            this.pendingNode = node;
+            this.pendingParent = target;
+            this.pendingContainer = container;
+            this.pendingName = '';
+            this.pendingNeedsFocus = true;
+            this.bump();
+        };
+        this.onPendingInput = (e) => {
+            var _a;
+            this.pendingName = e.target.value;
+            if ((_a = this.pendingNode) === null || _a === void 0 ? void 0 : _a.error) {
+                this.pendingNode.error = undefined;
+                this.bump();
+            }
+        };
+        this.onPendingKeyDown = (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                this.commitFolder();
+            }
+            else if (e.key === 'Escape') {
+                e.preventDefault();
+                this.cancelFolder();
+            }
+        };
+        // ── Drag & drop: move a document into another folder / container ────────────
+        this.onDocDragStart = (e, doc, node) => {
+            var _a, _b, _c;
+            this.dragDoc = doc;
+            this.dragFromId = node.id;
+            if (e.dataTransfer) {
+                e.dataTransfer.effectAllowed = 'move';
+                // A payload is required for a drag to start in some browsers.
+                e.dataTransfer.setData('text/plain', (_c = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc._links) === null || _a === void 0 ? void 0 : _a.self) === null || _b === void 0 ? void 0 : _b.href) !== null && _c !== void 0 ? _c : '');
+            }
+        };
+        this.onDocDragEnd = () => {
+            this.dragDoc = null;
+            this.dragFromId = null;
+            if (this.dropTargetId !== null)
+                this.dropTargetId = null;
+        };
+        /** A folder/container node (or a document inside it) accepts an internal move
+         *  or an external file drop. Always claims the event so it never bubbles to the
+         *  root drop-zone; a different node is highlighted (its own folder = no-op). */
+        this.onNodeDragOver = (e, node) => {
+            const file = this.isFileDrag(e);
+            if (!this.dragDoc && !file)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            if (e.dataTransfer)
+                e.dataTransfer.dropEffect = file ? 'copy' : 'move';
+            const target = !file && node.id === this.dragFromId ? null : node.id;
+            if (this.dropTargetId !== target)
+                this.dropTargetId = target;
+        };
+        this.onNodeDragLeave = (node) => {
+            if (this.dropTargetId === node.id)
+                this.dropTargetId = null;
+        };
+        this.onNodeDrop = (e, node, container) => {
+            if (this.isFileDrag(e)) {
+                e.preventDefault();
+                e.stopPropagation();
+                this.startFileUpload(e, node, container);
+                return;
+            }
+            if (!this.dragDoc)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            this.moveDocument(node, container);
+            this.onDocDragEnd();
+        };
+        /** Root-zone drop (dossier context): target the single container's root. */
+        this.onRootDragOver = (e) => {
+            if (!this.singleContainer)
+                return;
+            const file = this.isFileDrag(e);
+            if (!this.dragDoc && !file)
+                return;
+            e.preventDefault();
+            if (e.dataTransfer)
+                e.dataTransfer.dropEffect = file ? 'copy' : 'move';
+        };
+        this.onRootDrop = (e) => {
+            if (!this.singleContainer)
+                return;
+            const only = this.containers[0];
+            if (this.isFileDrag(e)) {
+                e.preventDefault();
+                this.startFileUpload(e, only, only);
+                return;
+            }
+            if (!this.dragDoc)
+                return;
+            e.preventDefault();
+            this.moveDocument(only, only);
+            this.onDocDragEnd();
+        };
+    }
+    componentDidLoad() {
+        this.emitContainerDistinct();
+    }
+    componentDidRender() {
+        if (this.pendingNeedsFocus && this.pendingInputEl) {
+            this.pendingInputEl.focus();
+            this.pendingInputEl.select();
+            this.pendingNeedsFocus = false;
+        }
+        const can = this.canCreateFolder;
+        if (can !== this.lastCanCreate) {
+            this.lastCanCreate = can;
+            this.mrdCanCreate.emit(can);
+        }
+    }
+    // ── Slot field names ─────────────────────────────────────────────────────
+    get containerField() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.archetype) === null || _a === void 0 ? void 0 : _a.slots) === null || _b === void 0 ? void 0 : _b.container) !== null && _c !== void 0 ? _c : 'container';
+    }
+    get folderField() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.archetype) === null || _a === void 0 ? void 0 : _a.slots) === null || _b === void 0 ? void 0 : _b.folder) !== null && _c !== void 0 ? _c : 'folder';
+    }
+    get titleField() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.archetype) === null || _a === void 0 ? void 0 : _a.slots) === null || _b === void 0 ? void 0 : _b.title) !== null && _c !== void 0 ? _c : 'name';
+    }
+    get fileField() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.archetype) === null || _a === void 0 ? void 0 : _a.slots) === null || _b === void 0 ? void 0 : _b.file) !== null && _c !== void 0 ? _c : 'file';
+    }
+    get dateField() {
+        var _a, _b;
+        return (_b = (_a = this.archetype) === null || _a === void 0 ? void 0 : _a.slots) === null || _b === void 0 ? void 0 : _b.date;
+    }
+    // ── Path / query building (mirrors mrd-table conventions) ────────────────
+    /** VIEW: `/{dataClass}`; RELATED_VIEW: `/{fromClass}/{parentId}/{dataClass}`. */
+    buildDataPath() {
+        var _a, _b, _c;
+        const it = this.item;
+        const dataClass = (_b = (_a = it === null || it === void 0 ? void 0 : it.dataClass) !== null && _a !== void 0 ? _a : it === null || it === void 0 ? void 0 : it.relatedClass) !== null && _b !== void 0 ? _b : '';
+        if ((it === null || it === void 0 ? void 0 : it.type) === ClientLayoutItemType.RELATED_VIEW) {
+            return `/${(_c = it.fromClass) !== null && _c !== void 0 ? _c : ''}/${this.parentId}/${dataClass}`;
+        }
+        return `/${dataClass}`;
+    }
+    /** View-level static filters + filterClass, shared by every request. */
+    baseParams() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const p = new URLSearchParams();
+        const filterClass = (_a = this.item) === null || _a === void 0 ? void 0 : _a.filterClass;
+        if (filterClass)
+            p.set('type', filterClass);
+        for (const f of ((_d = (_c = (_b = this.item) === null || _b === void 0 ? void 0 : _b.view) === null || _c === void 0 ? void 0 : _c.filter) !== null && _d !== void 0 ? _d : [])) {
+            if (!f.name)
+                continue;
+            if (f.operator === 'EMPTY') {
+                p.set(f.name, '');
+                continue;
+            }
+            if (f.operator === 'NOT_EMPTY') {
+                p.set(f.name + '_notempty', 'true');
+                continue;
+            }
+            if (f.operator === 'STARTS_WITH') {
+                p.set(f.name + '_startswith', String((_e = f.value) !== null && _e !== void 0 ? _e : ''));
+                continue;
+            }
+            if (f.operator === 'FROM') {
+                p.set(f.name + '_from', String((_f = f.value) !== null && _f !== void 0 ? _f : ''));
+                continue;
+            }
+            if (f.operator === 'TO') {
+                p.set(f.name + '_to', String((_g = f.value) !== null && _g !== void 0 ? _g : ''));
+                continue;
+            }
+            if (f.value != null) {
+                p.set(f.name, String(f.value));
+            }
+        }
+        return p;
+    }
+    emitContainerDistinct() {
+        const p = this.baseParams();
+        p.set('distinct', this.containerField);
+        this.mrdLoadDistinct.emit({
+            nodeId: MrdDocumentList.ROOT,
+            distinct: this.containerField,
+            path: this.buildDataPath() + '/distinct',
+            qs: p.toString(),
+        });
+    }
+    emitFolderDistinct(container) {
+        var _a;
+        const p = this.baseParams();
+        p.set('distinct', this.folderField);
+        p.set(this.containerField + '_href', (_a = container.href) !== null && _a !== void 0 ? _a : '');
+        container.loading = true;
+        this.mrdLoadDistinct.emit({
+            nodeId: container.id,
+            distinct: this.folderField,
+            path: this.buildDataPath() + '/distinct',
+            qs: p.toString(),
+        });
+    }
+    emitDocuments(container, node) {
+        var _a, _b;
+        const p = this.baseParams();
+        p.set(this.containerField + '_href', (_a = container.href) !== null && _a !== void 0 ? _a : '');
+        p.set(this.folderField, (_b = node.fullPath) !== null && _b !== void 0 ? _b : '');
+        node.loading = true;
+        this.mrdLoadPage.emit({
+            nodeId: node.id,
+            page: 0,
+            sort: '',
+            path: this.buildDataPath(),
+            qs: p.toString(),
+        });
+    }
+    // ── Public injection API ─────────────────────────────────────────────────
+    /** Inject distinct values for a node. `nodeId` is the sentinel root (containers)
+     *  or a container node id (folders). */
+    async setDistinct(nodeId, values) {
+        if (nodeId === MrdDocumentList.ROOT) {
+            this.applyContainers(values);
+        }
+        else {
+            this.applyFolders(nodeId, values);
+        }
+    }
+    /** Inject the documents loaded for one folder node. */
+    async setDocuments(nodeId, docs) {
+        const node = this.nodeIndex.get(nodeId);
+        if (!node)
+            return;
+        node.docs = docs !== null && docs !== void 0 ? docs : [];
+        node.docsLoaded = true;
+        node.loading = false;
+        this.bump();
+    }
+    applyContainers(values) {
+        const nodes = [];
+        for (const v of values) {
+            if (!v.value || typeof v.value !== 'object')
+                continue;
+            const href = v.value.href;
+            const node = this.makeContainerNode(href, v.value.name, v.count);
+            nodes.push(node);
+            this.nodeIndex.set(node.id, node);
+        }
+        this.containers = nodes;
+        this.rootLoading = false;
+        this.singleContainer = nodes.length === 1;
+        // Single container (dossier context): collapse the level away, load its folders now.
+        if (this.singleContainer) {
+            const only = nodes[0];
+            only.open = true;
+            this.emitFolderDistinct(only);
+        }
+    }
+    applyFolders(containerId, values) {
+        const container = this.nodeIndex.get(containerId);
+        if (!container)
+            return;
+        container.children = [];
+        container.hasDocs = false;
+        container.docCount = 0;
+        for (const v of values) {
+            const raw = typeof v.value === 'string' ? v.value : v.value == null ? '' : String(v.value);
+            const segs = this.splitFolder(raw);
+            if (segs.length === 0) {
+                // Root documents — the container's own direct documents.
+                container.hasDocs = true;
+                container.docCount = v.count;
+                container.fullPath = raw;
+                continue;
+            }
+            let node = container;
+            const acc = [];
+            for (const seg of segs) {
+                acc.push(seg);
+                let child = node.children.find(c => c.label === seg);
+                if (!child) {
+                    child = this.makeFolderNode(container.id + '/' + acc.join('/'), seg, container.id);
+                    node.children.push(child);
+                    this.nodeIndex.set(child.id, child);
+                }
+                node = child;
+            }
+            node.hasDocs = true;
+            node.docCount = v.count;
+            node.fullPath = raw;
+        }
+        this.computeTotals(container);
+        container.foldersLoaded = true;
+        container.loading = false;
+        // If the container has root documents, load them now (they show inline on expand).
+        if (container.hasDocs && !container.docsLoaded) {
+            this.emitDocuments(container, container);
+        }
+        this.bump();
+    }
+    // ── Tree helpers ─────────────────────────────────────────────────────────
+    /** Normalise a folder path: null/""/"/" → root ([]); else split on "/" dropping empties. */
+    splitFolder(path) {
+        if (path == null)
+            return [];
+        const s = String(path).trim();
+        if (s === '' || s === '/')
+            return [];
+        return s.split('/').map(x => x.trim()).filter(Boolean);
+    }
+    makeContainerNode(href, label, count) {
+        return {
+            id: 'c:' + href, kind: 'container', label, href,
+            hasDocs: false, docCount: 0, totalCount: count, children: [],
+            open: false, loading: false, foldersLoaded: false, docsLoaded: false, docs: [],
+        };
+    }
+    makeFolderNode(id, label, containerId) {
+        return {
+            id, kind: 'folder', label, containerId,
+            hasDocs: false, docCount: 0, totalCount: 0, children: [],
+            open: false, loading: false, foldersLoaded: false, docsLoaded: false, docs: [],
+        };
+    }
+    computeTotals(node) {
+        let total = node.docCount;
+        for (const c of node.children)
+            total += this.computeTotals(c);
+        node.totalCount = total;
+        return total;
+    }
+    /** Force a re-render after mutating nodes in place. */
+    bump() {
+        this.containers = [...this.containers];
+    }
+    // ── Interaction ──────────────────────────────────────────────────────────
+    toggleContainer(node) {
+        this.selectedId = node.id;
+        node.open = !node.open;
+        if (node.open && !node.foldersLoaded && !node.loading) {
+            this.emitFolderDistinct(node);
+        }
+        this.bump();
+    }
+    toggleFolder(container, node) {
+        this.selectedId = node.id;
+        node.open = !node.open;
+        if (node.open && node.hasDocs && !node.docsLoaded && !node.loading) {
+            this.emitDocuments(container, node);
+        }
+        this.bump();
+    }
+    // ── New folder (client-side pending, materialises on document drop) ─────────
+    /** Resolve the node a new folder should be created under, and its container.
+     *  Uses the current selection; falls back to the single container (dossier). */
+    resolveTarget() {
+        if (this.selectedId) {
+            const n = this.nodeIndex.get(this.selectedId);
+            if (n && n.kind === 'container')
+                return { target: n, container: n };
+            if (n && n.kind === 'folder') {
+                const container = n.containerId ? this.nodeIndex.get(n.containerId) : undefined;
+                if (container)
+                    return { target: n, container };
+            }
+        }
+        if (this.singleContainer && this.containers[0]) {
+            const only = this.containers[0];
+            return { target: only, container: only };
+        }
+        return null;
+    }
+    get canCreateFolder() {
+        return !this.pendingNode && this.resolveTarget() !== null;
+    }
+    /** Start creating a folder under the current target. Called by the host toolbar
+     *  (mrd-document-container). No-op when there is no valid target. */
+    async createFolder() {
+        this.startCreateFolder();
+    }
+    /** Folder path segments of a node relative to its container (derived from its id). */
+    segmentsOf(node, container) {
+        if (node.kind === 'container')
+            return [];
+        const prefix = container.id + '/';
+        const rest = node.id.startsWith(prefix) ? node.id.slice(prefix.length) : '';
+        return rest ? rest.split('/') : [];
+    }
+    commitFolder() {
+        const node = this.pendingNode;
+        const parent = this.pendingParent;
+        const container = this.pendingContainer;
+        if (!node || !parent || !container)
+            return;
+        const name = this.pendingName.trim();
+        if (!name) {
+            this.cancelFolder();
+            return;
+        }
+        if (name.includes('/')) {
+            node.error = t('folder_no_slash', this.locale);
+            this.bump();
+            return;
+        }
+        const dup = parent.children.some(c => c !== node && c.label.toLowerCase() === name.toLowerCase());
+        if (dup) {
+            node.error = t('folder_duplicate', this.locale);
+            this.bump();
+            return;
+        }
+        // Finalise: swap the temp id for the real path-derived id so a later distinct
+        // value with the same folder string merges onto this node.
+        const segs = [...this.segmentsOf(parent, container), name];
+        this.nodeIndex.delete(node.id);
+        node.id = container.id + '/' + segs.join('/');
+        node.fullPath = '/' + segs.join('/');
+        node.label = name;
+        node.editing = false;
+        node.error = undefined;
+        node.open = true;
+        this.nodeIndex.set(node.id, node);
+        this.selectedId = node.id;
+        this.clearPending();
+        this.bump();
+    }
+    cancelFolder() {
+        const node = this.pendingNode;
+        const parent = this.pendingParent;
+        if (node && parent) {
+            parent.children = parent.children.filter(c => c !== node);
+            this.nodeIndex.delete(node.id);
+        }
+        this.clearPending();
+        this.bump();
+    }
+    clearPending() {
+        this.pendingNode = null;
+        this.pendingParent = null;
+        this.pendingContainer = null;
+        this.pendingName = '';
+        this.pendingInputEl = null;
+        this.pendingNeedsFocus = false;
+    }
+    /** True when the drag carries external files (an OS file drop, not an internal move). */
+    isFileDrag(e) {
+        return !this.dragDoc && !!e.dataTransfer && Array.from(e.dataTransfer.types).includes('Files');
+    }
+    // ── External file drop → upload → create document ──────────────────────────
+    /** Begin an upload: emit mrdUpload; the host uploads and calls setFileReference. */
+    startFileUpload(e, node, container) {
+        var _a, _b;
+        const file = (_b = (_a = e.dataTransfer) === null || _a === void 0 ? void 0 : _a.files) === null || _b === void 0 ? void 0 : _b[0]; // single file per drop
+        this.dropTargetId = null;
+        if (!file)
+            return;
+        this.pendingUpload = { file, node, container };
+        node.open = true;
+        this.uploadingNodeId = node.id;
+        this.bump();
+        this.mrdUpload.emit({ file });
+    }
+    /** Strip a single trailing extension for the document title. */
+    stripExtension(name) {
+        return name.replace(/\.[^./\\]+$/, '');
+    }
+    /** Host callback with the uploaded file reference. Builds the create payload
+     *  from the archetype slots and requests the new document. */
+    async setFileReference(uri) {
+        const up = this.pendingUpload;
+        if (!up)
+            return;
+        const { file, node, container } = up;
+        const folder = this.folderStringOf(node, container);
+        const values = {
+            [this.fileField]: uri,
+            [this.titleField]: this.stripExtension(file.name),
+            [this.folderField]: folder,
+            [this.containerField]: container.href,
+        };
+        this.mrdCreateObject.emit({ path: this.buildDataPath(), values });
+        // Optimistically show the new document (no href until a reload).
+        const optimistic = { [this.titleField]: this.stripExtension(file.name), _optimistic: true };
+        const wasUnloadedEmpty = !node.docsLoaded && node.docCount === 0;
+        node.hasDocs = true;
+        node.pending = false;
+        node.docCount += 1;
+        if (wasUnloadedEmpty) {
+            node.docsLoaded = true;
+            node.docs = [optimistic];
+        }
+        else if (node.docsLoaded)
+            node.docs = [...node.docs, optimistic];
+        this.recomputeContainerTotals(container, +1);
+        this.lastOptimisticDoc = optimistic;
+        this.pendingUpload = null;
+        this.uploadingNodeId = null;
+        this.bump();
+    }
+    /** Host callback with the created document's self href, so the optimistic row
+     *  becomes navigable without waiting for a reload. */
+    async setCreatedHref(href) {
+        var _a;
+        const doc = this.lastOptimisticDoc;
+        if (!doc || !href)
+            return;
+        doc._links = Object.assign(Object.assign({}, ((_a = doc._links) !== null && _a !== void 0 ? _a : {})), { self: { href } });
+        doc._optimistic = false;
+        this.lastOptimisticDoc = null;
+        this.bump();
+    }
+    /** Folder string a node represents: the raw distinct value when it holds
+     *  documents, else derived from its path segments; null for a container root. */
+    folderStringOf(node, container) {
+        if (node.kind === 'container')
+            return null;
+        if (node.fullPath != null && node.fullPath !== '')
+            return node.fullPath;
+        const segs = this.segmentsOf(node, container);
+        return segs.length ? '/' + segs.join('/') : null;
+    }
+    moveDocument(toNode, toContainer) {
+        var _a, _b;
+        const doc = this.dragDoc;
+        const fromNode = this.dragFromId ? this.nodeIndex.get(this.dragFromId) : undefined;
+        if (!doc || !fromNode)
+            return;
+        const fromContainer = fromNode.kind === 'container'
+            ? fromNode
+            : (fromNode.containerId ? this.nodeIndex.get(fromNode.containerId) : undefined);
+        if (!fromContainer)
+            return;
+        const targetFolder = this.folderStringOf(toNode, toContainer);
+        const sourceFolder = this.folderStringOf(fromNode, fromContainer);
+        const sameContainer = toContainer === fromContainer;
+        // No-op: dropped back onto its own folder.
+        if (toNode === fromNode || (sameContainer && targetFolder === sourceFolder))
+            return;
+        // ── Optimistic tree update (fire-and-forget; no refetch) ──
+        fromNode.docs = fromNode.docs.filter(d => d !== doc);
+        fromNode.docCount = Math.max(0, fromNode.docCount - 1);
+        // A now-empty folder should stop showing an expand chevron (it disappears on
+        // the next reload anyway, since it is derived from document folder strings).
+        if (fromNode.docsLoaded)
+            fromNode.hasDocs = fromNode.docs.length > 0;
+        toNode.hasDocs = true;
+        toNode.pending = false; // a pending folder is now materialised
+        toNode.docCount += 1;
+        if (toNode.kind === 'folder')
+            toNode.fullPath = targetFolder !== null && targetFolder !== void 0 ? targetFolder : '';
+        if (toNode.docsLoaded)
+            toNode.docs = [...toNode.docs, doc];
+        this.recomputeContainerTotals(fromContainer, -1);
+        if (!sameContainer)
+            this.recomputeContainerTotals(toContainer, +1);
+        // ── Emit the generic update; host PATCHes the document ──
+        const href = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc._links) === null || _a === void 0 ? void 0 : _a.self) === null || _b === void 0 ? void 0 : _b.href;
+        if (href) {
+            const values = { [this.folderField]: targetFolder };
+            if (!sameContainer)
+                values[this.containerField] = toContainer.href;
+            this.mrdUpdateObject.emit({ href, values });
+        }
+        this.bump();
+    }
+    /** Recompute a container's subtree totals from docCounts when its folders are
+     *  loaded; otherwise just nudge the aggregate badge by the delta. */
+    recomputeContainerTotals(container, delta) {
+        if (container.foldersLoaded) {
+            this.computeTotals(container);
+        }
+        else {
+            container.totalCount = Math.max(0, container.totalCount + delta);
+        }
+    }
+    openDoc(doc) {
+        var _a, _b, _c, _d;
+        const href = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc._links) === null || _a === void 0 ? void 0 : _a.self) === null || _b === void 0 ? void 0 : _b.href;
+        const label = (_d = (_c = doc === null || doc === void 0 ? void 0 : doc[this.titleField]) !== null && _c !== void 0 ? _c : doc === null || doc === void 0 ? void 0 : doc.name) !== null && _d !== void 0 ? _d : '';
+        this.mrdNavigate.emit({ href, label });
+    }
+    // ── Render ───────────────────────────────────────────────────────────────
+    renderChevron(open, leaf) {
+        return (h("span", { class: `mrd-document-list__chev${leaf ? ' mrd-document-list__chev--leaf' : ''}${open ? ' mrd-document-list__chev--open' : ''}` }, h("svg", { viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" }, h("path", { d: "M9 6l6 6-6 6" }))));
+    }
+    renderDossierIcon() {
+        return (h("svg", { class: "mrd-document-list__icon mrd-document-list__icon--dossier", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" }, h("path", { d: "M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" })));
+    }
+    renderFolderIcon() {
+        return (h("svg", { class: "mrd-document-list__icon mrd-document-list__icon--folder", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" }, h("path", { d: "M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z" })));
+    }
+    renderDocIcon() {
+        return (h("svg", { class: "mrd-document-list__icon mrd-document-list__icon--doc", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", "stroke-width": "2", "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true" }, h("path", { d: "M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" }), h("path", { d: "M14 2v6h6" })));
+    }
+    indent(depth) {
+        return h("span", { class: "mrd-document-list__indent", style: { width: `${depth * 18}px` } });
+    }
+    renderDocRow(doc, node, container, depth) {
+        var _a, _b, _c, _d, _e;
+        const label = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc[this.titleField]) !== null && _a !== void 0 ? _a : doc === null || doc === void 0 ? void 0 : doc.name) !== null && _b !== void 0 ? _b : '';
+        const dateRaw = this.dateField ? doc === null || doc === void 0 ? void 0 : doc[this.dateField] : undefined;
+        const date = dateRaw ? formatDate(dateRaw, this.locale) : '';
+        return (h("div", { class: "mrd-document-list__row mrd-document-list__row--doc", key: (_e = (_d = (_c = doc === null || doc === void 0 ? void 0 : doc._links) === null || _c === void 0 ? void 0 : _c.self) === null || _d === void 0 ? void 0 : _d.href) !== null && _e !== void 0 ? _e : label, draggable: true, onClick: () => this.openDoc(doc), onDragStart: (e) => this.onDocDragStart(e, doc, node), onDragEnd: this.onDocDragEnd, onDragOver: (e) => this.onNodeDragOver(e, node), onDragLeave: () => this.onNodeDragLeave(node), onDrop: (e) => this.onNodeDrop(e, node, container) }, this.indent(depth), this.renderChevron(false, true), this.renderDocIcon(), h("span", { class: "mrd-document-list__label" }, label), date && h("span", { class: "mrd-document-list__date" }, date)));
+    }
+    renderLoadingRow(depth) {
+        return (h("div", { class: "mrd-document-list__loading", key: "loading" }, this.indent(depth), h("span", { class: "mrd-document-list__spinner" }), t('loading', this.locale)));
+    }
+    renderChildren(container, node, depth) {
+        const out = [];
+        // Direct documents of this node (root docs live on the container node).
+        if (node.hasDocs) {
+            if (node.docsLoaded) {
+                for (const doc of node.docs)
+                    out.push(this.renderDocRow(doc, node, container, depth));
+            }
+            else if (node.loading) {
+                out.push(this.renderLoadingRow(depth));
+            }
+        }
+        // Child folders.
+        for (const child of node.children) {
+            out.push(this.renderFolderNode(container, child, depth));
+        }
+        // An uploading file dropped onto this node.
+        if (node.id === this.uploadingNodeId)
+            out.push(this.renderUploadingRow(depth));
+        return out;
+    }
+    renderUploadingRow(depth) {
+        return (h("div", { class: "mrd-document-list__loading", key: "uploading" }, this.indent(depth), h("span", { class: "mrd-document-list__spinner" }), t('upload_file', this.locale)));
+    }
+    renderFolderEditRow(node, depth) {
+        return (h("div", { class: "mrd-document-list__node", key: node.id }, h("div", { class: "mrd-document-list__row mrd-document-list__row--edit" }, this.indent(depth), this.renderChevron(false, true), this.renderFolderIcon(), h("input", { class: "mrd-document-list__name-input", type: "text", placeholder: t('folder_name_placeholder', this.locale), ref: el => (this.pendingInputEl = el), onInput: this.onPendingInput, onKeyDown: this.onPendingKeyDown, onBlur: () => this.cancelFolder() })), node.error && (h("div", { class: "mrd-document-list__error", style: { paddingLeft: `${depth * 18 + 52}px` } }, node.error))));
+    }
+    renderFolderNode(container, node, depth) {
+        if (node.editing)
+            return this.renderFolderEditRow(node, depth);
+        const leaf = node.children.length === 0 && !node.hasDocs;
+        const selected = node.id === this.selectedId;
+        const cls = 'mrd-document-list__row'
+            + (selected ? ' mrd-document-list__row--selected' : '')
+            + (node.pending ? ' mrd-document-list__row--pending' : '')
+            + (node.id === this.dropTargetId ? ' mrd-document-list__row--drop' : '');
+        return (h("div", { class: "mrd-document-list__node", key: node.id }, h("div", { class: cls, onClick: () => this.toggleFolder(container, node), onDragOver: (e) => this.onNodeDragOver(e, node), onDragLeave: () => this.onNodeDragLeave(node), onDrop: (e) => this.onNodeDrop(e, node, container) }, this.indent(depth), this.renderChevron(node.open, leaf), this.renderFolderIcon(), h("span", { class: "mrd-document-list__label" }, node.label), h("span", { class: "mrd-document-list__count" }, node.totalCount)), node.open && h("div", { class: "mrd-document-list__kids" }, this.renderChildren(container, node, depth + 1))));
+    }
+    renderContainerNode(node, depth) {
+        const selected = node.id === this.selectedId;
+        const cls = 'mrd-document-list__row mrd-document-list__row--dossier'
+            + (selected ? ' mrd-document-list__row--selected' : '')
+            + (node.id === this.dropTargetId ? ' mrd-document-list__row--drop' : '');
+        return (h("div", { class: "mrd-document-list__node", key: node.id }, h("div", { class: cls, onClick: () => this.toggleContainer(node), onDragOver: (e) => this.onNodeDragOver(e, node), onDragLeave: () => this.onNodeDragLeave(node), onDrop: (e) => this.onNodeDrop(e, node, node) }, this.indent(depth), this.renderChevron(node.open, false), this.renderDossierIcon(), h("span", { class: "mrd-document-list__label" }, node.label), h("span", { class: "mrd-document-list__count" }, node.totalCount)), node.open && (h("div", { class: "mrd-document-list__kids" }, node.loading && !node.foldersLoaded
+            ? this.renderLoadingRow(depth + 1)
+            : this.renderChildren(node, node, depth + 1)))));
+    }
+    render() {
+        let body;
+        if (this.rootLoading) {
+            body = this.renderLoadingRow(0);
+        }
+        else if (this.containers.length === 0) {
+            body = h("div", { key: 'b8c3297cd7cff5bf79ce694d2ee1a64c570df5ce', class: "mrd-document-list__empty" }, t('no_results', this.locale));
+        }
+        else if (this.singleContainer) {
+            // Dossier context: render the single container's folder tree at the root.
+            const only = this.containers[0];
+            body = only.loading && !only.foldersLoaded
+                ? this.renderLoadingRow(0)
+                : this.renderChildren(only, only, 0);
+        }
+        else {
+            body = this.containers.map(c => this.renderContainerNode(c, 0));
+        }
+        return (h(Host, { key: 'ff3b024a79ba2270aa28861923bc6406f98061aa' }, h("div", { key: '9db121e5336a4e3c82443257f6424db5ab4f0baf', class: "mrd-document-list", onDragOver: this.onRootDragOver, onDrop: this.onRootDrop }, body)));
+    }
+    static get is() { return "mrd-document-list"; }
+    static get encapsulation() { return "scoped"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["mrd-document-list.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["mrd-document-list.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "item": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ClientLayoutItem | null",
+                    "resolved": "ClientLayoutItem | null",
+                    "references": {
+                        "ClientLayoutItem": {
+                            "location": "import",
+                            "path": "../../types/client-layout",
+                            "id": "src/types/client-layout.ts::ClientLayoutItem",
+                            "referenceLocation": "ClientLayoutItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config)."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "null"
+            },
+            "archetype": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ClientArchetype",
+                    "resolved": "ClientArchetype",
+                    "references": {
+                        "ClientArchetype": {
+                            "location": "import",
+                            "path": "../../types/client-layout",
+                            "id": "src/types/client-layout.ts::ClientArchetype",
+                            "referenceLocation": "ClientArchetype"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Resolved `commons.document` binding: slot name \u2192 concrete field/relation name."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "parentId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Parent record id \u2014 required for RELATED_VIEW path building."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "parent-id",
+                "defaultValue": "''"
+            },
+            "locale": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "locale",
+                "defaultValue": "navigator.language"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "containers": {},
+            "rootLoading": {},
+            "singleContainer": {},
+            "selectedId": {},
+            "dropTargetId": {},
+            "uploadingNodeId": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "mrdLoadDistinct",
+                "name": "mrdLoadDistinct",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Request distinct values for a field/relation. Host fetches `{path}?{qs}` and calls `setDistinct(nodeId, values)`."
+                },
+                "complexType": {
+                    "original": "{ nodeId: string; distinct: string; path: string; qs: string }",
+                    "resolved": "{ nodeId: string; distinct: string; path: string; qs: string; }",
+                    "references": {}
+                }
+            }, {
+                "method": "mrdLoadPage",
+                "name": "mrdLoadPage",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Request the documents in one folder \u2014 the same filtered list load a table does.\nHost fetches `{path}?{qs}` and calls `setDocuments(nodeId, docs)` (via setViewPage)."
+                },
+                "complexType": {
+                    "original": "{ nodeId: string; page: number; sort: string; path: string; qs: string }",
+                    "resolved": "{ nodeId: string; page: number; sort: string; path: string; qs: string; }",
+                    "references": {}
+                }
+            }, {
+                "method": "mrdNavigate",
+                "name": "mrdNavigate",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "A document row was clicked. Host routes to the document object page."
+                },
+                "complexType": {
+                    "original": "{ href?: string; label: string }",
+                    "resolved": "{ href?: string | undefined; label: string; }",
+                    "references": {}
+                }
+            }, {
+                "method": "mrdCanCreate",
+                "name": "mrdCanCreate",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitted whenever the \"can create a folder here\" state changes, so a host\ntoolbar (mrd-document-container) can enable/disable its New folder button."
+                },
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                }
+            }, {
+                "method": "mrdUpdateObject",
+                "name": "mrdUpdateObject",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Generic \"update an existing object\" request \u2014 fired when a document is\ndragged into another folder/container. Host PATCHes `href` with `values`\n(no move/folder knowledge needed). `values` carries the new folder string\n(or null for the container root) and, on a cross-container move, the new\ncontainer relation href."
+                },
+                "complexType": {
+                    "original": "{ href: string; values: Record<string, unknown> }",
+                    "resolved": "{ href: string; values: Record<string, unknown>; }",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                }
+            }, {
+                "method": "mrdUpload",
+                "name": "mrdUpload",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "An external file was dropped onto a folder/container. Same flow as mrd-form:\nhost uploads the file and calls `setFileReference(uri)` with the result."
+                },
+                "complexType": {
+                    "original": "{ file: File }",
+                    "resolved": "{ file: File; }",
+                    "references": {
+                        "File": {
+                            "location": "global",
+                            "id": "global::File"
+                        }
+                    }
+                }
+            }, {
+                "method": "mrdCreateObject",
+                "name": "mrdCreateObject",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Fired once the dropped file is uploaded \u2014 requests creation of a new document.\nHost POSTs `values` to `path` (on a 400 it can open the create form itself)."
+                },
+                "complexType": {
+                    "original": "{ path: string; values: Record<string, unknown> }",
+                    "resolved": "{ path: string; values: Record<string, unknown>; }",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "setDistinct": {
+                "complexType": {
+                    "signature": "(nodeId: string, values: DistinctValue[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "nodeId",
+                            "type": "string",
+                            "docs": ""
+                        }, {
+                            "name": "values",
+                            "type": "DistinctValue[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DistinctValue": {
+                            "location": "local",
+                            "path": "/Users/michiel/Mosterd/mosterd-components/src/components/mrd-document-list/mrd-document-list.tsx",
+                            "id": "src/components/mrd-document-list/mrd-document-list.tsx::DistinctValue"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Inject distinct values for a node. `nodeId` is the sentinel root (containers)\nor a container node id (folders).",
+                    "tags": []
+                }
+            },
+            "setDocuments": {
+                "complexType": {
+                    "signature": "(nodeId: string, docs: DocRow[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "nodeId",
+                            "type": "string",
+                            "docs": ""
+                        }, {
+                            "name": "docs",
+                            "type": "DocRow[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DocRow": {
+                            "location": "local",
+                            "path": "/Users/michiel/Mosterd/mosterd-components/src/components/mrd-document-list/mrd-document-list.tsx",
+                            "id": "src/components/mrd-document-list/mrd-document-list.tsx::DocRow"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Inject the documents loaded for one folder node.",
+                    "tags": []
+                }
+            },
+            "createFolder": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Start creating a folder under the current target. Called by the host toolbar\n(mrd-document-container). No-op when there is no valid target.",
+                    "tags": []
+                }
+            },
+            "setFileReference": {
+                "complexType": {
+                    "signature": "(uri: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "uri",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        },
+                        "DocRow": {
+                            "location": "local",
+                            "path": "/Users/michiel/Mosterd/mosterd-components/src/components/mrd-document-list/mrd-document-list.tsx",
+                            "id": "src/components/mrd-document-list/mrd-document-list.tsx::DocRow"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Host callback with the uploaded file reference. Builds the create payload\nfrom the archetype slots and requests the new document.",
+                    "tags": []
+                }
+            },
+            "setCreatedHref": {
+                "complexType": {
+                    "signature": "(href: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "href",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Host callback with the created document's self href, so the optimistic row\nbecomes navigable without waiting for a reload.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+}
+/** Root sentinel id for the container-level distinct request. */
+MrdDocumentList.ROOT = '__root__';