@mmlogic/components 0.3.9 → 0.3.11

package/dist/types/components/mrd-document-container/mrd-document-container.d.ts

@@ -0,0 +1,99 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ClientArchetype, ClientLayoutItem } from '../../types/client-layout';
+/**
+ * Owns a document collection view: a single toolbar (view switch + collection
+ * actions like "New folder", and — later — upload / drag-drop) plus the two
+ * interchangeable bodies, the folder tree (`mrd-document-list`) and the flat
+ * table (`mrd-table`).
+ *
+ * `mrd-layout-section` renders one of these per document VIEW / RELATED_VIEW and
+ * forwards the re-emitted load/navigate/action events to the host. The embedded
+ * table/list keep their `data-view` / `data-doclist` attributes so the host's
+ * existing `setViewPage` / `setViewDistinct` / `setViewAggregations` lookups
+ * (recursive querySelector) still resolve them unchanged.
+ */
+export declare class MrdDocumentContainer {
+    el: HTMLElement;
+    /** The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config). */
+    item: ClientLayoutItem | null;
+    /** Resolved `commons.document` archetype binding for the folder tree. */
+    archetype: ClientArchetype;
+    /** Parent record id — required for RELATED_VIEW path building. */
+    parentId: string;
+    /** Canonical parent href, forwarded to the folder tree for single-container seeding. */
+    containerHref: string;
+    /** Lookup key used for the embedded `data-doclist` / `data-view` attributes. */
+    viewKey: string;
+    /** Fixed height (px) of the scrolling folder-tree body — the toolbar stays put
+     *  on top, Finder-style. The table manages its own height. */
+    height: number;
+    locale: string;
+    /** Re-emitted from the embedded list/table. `nodeId` present for a folder load. */
+    mrdLoadPage: EventEmitter<{
+        page: number;
+        sort: string;
+        path: string;
+        qs: string;
+        nodeId?: string;
+    }>;
+    /** Re-emitted from the embedded folder tree. */
+    mrdLoadDistinct: EventEmitter<{
+        nodeId: string;
+        distinct: string;
+        path: string;
+        qs: string;
+    }>;
+    /** Re-emitted from the embedded table. */
+    mrdLoadAggregations: EventEmitter<{
+        path: string;
+        qs: string;
+        aggQs: string;
+    }>;
+    /** A row / document was activated. Host routes to the object page. */
+    mrdNavigate: EventEmitter<{
+        href?: string;
+        label: string;
+    }>;
+    /** A table toolbar action was triggered. */
+    mrdAction: EventEmitter<{
+        action: string;
+        path?: string;
+        qs?: string;
+        parentPath?: string | null;
+        basicType?: string;
+    }>;
+    /** Generic "update an existing object" request, re-emitted from the folder tree
+     *  (a document was dragged into another folder/container). */
+    mrdUpdateObject: EventEmitter<{
+        href: string;
+        values: Record<string, unknown>;
+    }>;
+    /** An external file was dropped on a folder; host uploads and calls back. */
+    mrdUpload: EventEmitter<{
+        file: File;
+    }>;
+    /** Create a new document from an uploaded file; host POSTs `values` to `path`. */
+    mrdCreateObject: EventEmitter<{
+        path: string;
+        values: Record<string, unknown>;
+    }>;
+    /** Active body: folder tree or flat table. */
+    private mode;
+    /** Whether the folder tree currently has a valid target for "New folder". */
+    private canCreate;
+    private listEl?;
+    private tableEl?;
+    /** Whether the currently mounted table has been init()'d. Reset on every mode switch. */
+    private tableInited;
+    /** The embedded table does not self-load: like every mrd-table it waits for the
+     *  host to call init() (which emits mrdLoadPage, and — once page 0 lands —
+     *  mrdLoadAggregations). The section only init()s tables mounted at load time, so
+     *  when the user switches to list view we init the freshly mounted table here. */
+    componentDidRender(): void;
+    private setMode;
+    private createFolder;
+    private renderToolbar;
+    private renderTree;
+    private renderList;
+    render(): any;
+}

package/dist/types/components/mrd-document-list/mrd-document-list.d.ts

@@ -36,6 +36,11 @@ export declare class MrdDocumentList {
     archetype: ClientArchetype;
     /** Parent record id — required for RELATED_VIEW path building. */
     parentId: string;
+    /** Canonical parent href (`/{base}/{tenant}/{fromClass}/{parentId}`) supplied by
+     *  the host. When the RELATED_VIEW's `inverseRelation` equals the archetype
+     *  `container` slot, this seeds a single container so an empty dossier still
+     *  accepts file drops and folder creation. */
+    containerHref: string;
     locale: string;
     /** Request distinct values for a field/relation. Host fetches `{path}?{qs}` and calls `setDistinct(nodeId, values)`. */
     mrdLoadDistinct: EventEmitter<{
@@ -58,20 +63,92 @@ export declare class MrdDocumentList {
         href?: string;
         label: string;
     }>;
+    /** Emitted whenever the "can create a folder here" state changes, so a host
+     *  toolbar (mrd-document-container) can enable/disable its New folder button. */
+    mrdCanCreate: EventEmitter<boolean>;
+    /** Generic "update an existing object" request — fired when a document is
+     *  dragged into another folder/container. Host PATCHes `href` with `values`
+     *  (no move/folder knowledge needed). `values` carries the new folder string
+     *  (or null for the container root) and, on a cross-container move, the new
+     *  container relation href. */
+    mrdUpdateObject: EventEmitter<{
+        href: string;
+        values: Record<string, unknown>;
+    }>;
+    /** An external file was dropped onto a folder/container. Same flow as mrd-form:
+     *  host uploads the file and calls `setFileReference(uri)` with the result. */
+    mrdUpload: EventEmitter<{
+        file: File;
+    }>;
+    /** Fired once the dropped file is uploaded — requests creation of a new document.
+     *  Host POSTs `values` to `path` (on a 400 it can open the create form itself). */
+    mrdCreateObject: EventEmitter<{
+        path: string;
+        values: Record<string, unknown>;
+    }>;
     /** Root sentinel id for the container-level distinct request. */
     private static readonly ROOT;
     private containers;
     private rootLoading;
     /** True when the single-container level is collapsed away (dossier context). */
     private singleContainer;
+    /** Currently selected node id — the target for "New folder" and (later) drops. */
+    private selectedId;
+    /** Node id currently highlighted as a drag-drop target (null = none). */
+    private dropTargetId;
+    /** Node id showing an "uploading…" indicator while a dropped file is processed. */
+    private uploadingNodeId;
+    /** Whether a drag is hovering the root drop-zone (single-container area highlight). */
+    private rootDropActive;
     private nodeIndex;
+    /** The pending node whose inline name input is open (null = not creating). */
+    private pendingNode;
+    /** The node the pending folder is being created under. */
+    private pendingParent;
+    /** The container the pending folder belongs to. */
+    private pendingContainer;
+    /** Current text in the inline name input. */
+    private pendingName;
+    /** Ref to the inline input, so we can focus it after it mounts. */
+    private pendingInputEl;
+    /** Set when a fresh input needs focus on the next render. */
+    private pendingNeedsFocus;
+    /** Monotonic counter for unique temporary pending-node ids. */
+    private newFolderSeq;
+    /** Last emitted canCreateFolder value, to only emit mrdCanCreate on change. */
+    private lastCanCreate;
+    /** The document row currently being dragged. */
+    private dragDoc;
+    /** Id of the node the dragged document currently lives in. */
+    private dragFromId;
+    /** External file dropped onto a node, awaiting its upload to complete. */
+    private pendingUpload;
+    /** The optimistic document row awaiting its self href from the create POST. */
+    private lastOptimisticDoc;
     componentDidLoad(): void;
+    /** True when the view is a single-container context: a RELATED_VIEW whose
+     *  `inverseRelation` matches the archetype `container` slot, with a known
+     *  parent href. The container is then implied by context (not by distinct),
+     *  so it works even with zero documents. */
+    private isSeededSingleContainer;
+    /** Seed the single implied container from context and load its folders. */
+    private seedSingleContainer;
+    componentDidRender(): void;
     private get containerField();
     private get folderField();
     private get titleField();
+    private get fileField();
     private get dateField();
-    /** VIEW: `/{dataClass}`; RELATED_VIEW: `/{fromClass}/{parentId}/{dataClass}`. */
+    /** VIEW: `/{dataClass}`; RELATED_VIEW: `/{fromClass}/{parentId}/{dataClass}`.
+     *  Used for reads (list/distinct): `dataClass`/`relatedClass` may be an abstract
+     *  type (e.g. "contents"), filtered down to the concrete `filterClass` via the
+     *  `type` query param — see baseParams(). */
     private buildDataPath;
+    /** Path for creating a new document (file-drop). Unlike buildDataPath(), this
+     *  must target the concrete type: `dataClass`/`relatedClass` can be an abstract
+     *  base type (e.g. "contents") that cannot be POSTed to directly, so prefer
+     *  `filterClass` (e.g. "documents") when present. */
+    private buildCreatePath;
     /** View-level static filters + filterClass, shared by every request. */
     private baseParams;
     private emitContainerDistinct;
@@ -93,6 +170,52 @@ export declare class MrdDocumentList {
     private bump;
     private toggleContainer;
     private toggleFolder;
+    /** Resolve the node a new folder should be created under, and its container.
+     *  Uses the current selection; falls back to the single container (dossier). */
+    private resolveTarget;
+    private get canCreateFolder();
+    /** Start creating a folder under the current target. Called by the host toolbar
+     *  (mrd-document-container). No-op when there is no valid target. */
+    createFolder(): Promise<void>;
+    /** Folder path segments of a node relative to its container (derived from its id). */
+    private segmentsOf;
+    private startCreateFolder;
+    private onPendingInput;
+    private onPendingKeyDown;
+    private commitFolder;
+    private cancelFolder;
+    private clearPending;
+    private onDocDragStart;
+    private onDocDragEnd;
+    /** True when the drag carries external files (an OS file drop, not an internal move). */
+    private isFileDrag;
+    /** 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). */
+    private onNodeDragOver;
+    private onNodeDragLeave;
+    private onNodeDrop;
+    /** Root-zone drop (dossier context): target the single container's root. */
+    private onRootDragOver;
+    private onRootDragLeave;
+    private onRootDrop;
+    /** Begin an upload: emit mrdUpload; the host uploads and calls setFileReference. */
+    private startFileUpload;
+    /** Strip a single trailing extension for the document title. */
+    private stripExtension;
+    /** Host callback with the uploaded file reference. Builds the create payload
+     *  from the archetype slots and requests the new document. */
+    setFileReference(uri: string): Promise<void>;
+    /** Host callback with the created document's self href, so the optimistic row
+     *  becomes navigable without waiting for a reload. */
+    setCreatedHref(href: string): Promise<void>;
+    /** Folder string a node represents: the raw distinct value when it holds
+     *  documents, else derived from its path segments; null for a container root. */
+    private folderStringOf;
+    private moveDocument;
+    /** Recompute a container's subtree totals from docCounts when its folders are
+     *  loaded; otherwise just nudge the aggregate badge by the delta. */
+    private recomputeContainerTotals;
     private openDoc;
     private renderChevron;
     private renderDossierIcon;
@@ -102,6 +225,8 @@ export declare class MrdDocumentList {
     private renderDocRow;
     private renderLoadingRow;
     private renderChildren;
+    private renderUploadingRow;
+    private renderFolderEditRow;
     private renderFolderNode;
     private renderContainerNode;
     render(): any;

package/dist/types/components/mrd-layout-section/mrd-layout-section.d.ts

@@ -22,8 +22,6 @@ export declare class MrdLayoutSection {
     private imagePreviewUrl;
     private imagePreviews;
     private openHistoryField;
-    /** Per-view display mode for document collection views. Default 'tree'. */
-    private docViewMode;
     private historyClickOutside;
     mrdNavigate: EventEmitter<{
         href?: string;
@@ -79,6 +77,25 @@ export declare class MrdLayoutSection {
         path: string;
         qs: string;
     }>;
+    /** Generic "update an existing object" request from an embedded document view
+     *  (a document dragged into another folder). Host PATCHes `href` with `values`. */
+    mrdUpdateObject: EventEmitter<{
+        href: string;
+        values: Record<string, unknown>;
+    }>;
+    /** An external file was dropped on a document view; host uploads and calls
+     *  setViewFileReference(name, uri). */
+    mrdViewUpload: EventEmitter<{
+        name: string;
+        file: File;
+    }>;
+    /** Create a new document from an uploaded file; host POSTs `values` to `path`,
+     *  then calls setViewCreatedObject(name, href) with the new object's href. */
+    mrdCreateObject: EventEmitter<{
+        name: string;
+        path: string;
+        values: Record<string, unknown>;
+    }>;
     private searchTimers;
     componentDidLoad(): void;
     disconnectedCallback(): void;
@@ -100,6 +117,12 @@ export declare class MrdLayoutSection {
     setViewAggregations(name: string, data: any): Promise<void>;
     /** Inject distinct values into an embedded mrd-document-list for a document view. */
     setViewDistinct(name: string, nodeId: string, values: DistinctValue[]): Promise<void>;
+    /** Inject the uploaded file reference for a dropped file, so the document view
+     *  can request creation of the new document (see mrdViewUpload). */
+    setViewFileReference(name: string, uri: string): Promise<void>;
+    /** Inject the created document's href after a file-drop create, so the
+     *  optimistic row becomes navigable (see mrdCreateObject). */
+    setViewCreatedObject(name: string, href: string): Promise<void>;
     /** Provide a resolved URL for an IMAGE field. Shows as thumbnail; clicking opens the lightbox. */
     setImagePreview(fieldName: string, url: string): Promise<void>;
     /** Open the lightbox directly with a URL (e.g. after mrdDownload on a FILE field). */
@@ -114,9 +137,13 @@ export declare class MrdLayoutSection {
     private renderRelation;
     private renderSearch;
     private renderRelatedView;
-    /** Tree / list segmented toggle for document collection views (+ upload placeholder). */
-    private renderDocToolbar;
-    private renderDocumentList;
+    /** Build the canonical parent href `/{base}/{tenant}/{fromClass}/{parentId}` from
+     *  the object's self href. Empty unless it is a RELATED_VIEW with a fromClass. */
+    private buildContainerHref;
+    /** Document collection view: owns the view-switch + collection actions and
+     *  swaps between the folder tree and the flat table. Events are re-emitted to
+     *  the host with the view key, exactly as the raw list/table events were. */
+    private renderDocumentContainer;
     private renderTable;
     private renderItem;
     private renderImageModal;