@mmlogic/components 0.3.8 → 0.3.9

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

@@ -0,0 +1,108 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ClientArchetype, ClientLayoutItem } from '../../types/client-layout';
+/** A distinct value as returned by the /distinct endpoint. */
+export interface DistinctValue {
+    /** Relation slot → `{ href, name }`; value slot (folder) → the raw path string. */
+    value: {
+        href: string;
+        name: string;
+    } | string | number | null;
+    count: number;
+}
+/** A loaded document row (raw data object from the /data endpoint). */
+export type DocRow = Record<string, any>;
+/**
+ * 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 declare class MrdDocumentList {
+    el: HTMLElement;
+    /** The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config). */
+    item: ClientLayoutItem | null;
+    /** Resolved `commons.document` binding: slot name → concrete field/relation name. */
+    archetype: ClientArchetype;
+    /** Parent record id — required for RELATED_VIEW path building. */
+    parentId: string;
+    locale: string;
+    /** Request distinct values for a field/relation. Host fetches `{path}?{qs}` and calls `setDistinct(nodeId, values)`. */
+    mrdLoadDistinct: EventEmitter<{
+        nodeId: string;
+        distinct: string;
+        path: string;
+        qs: string;
+    }>;
+    /** Request the documents in one folder — the same filtered list load a table does.
+     *  Host fetches `{path}?{qs}` and calls `setDocuments(nodeId, docs)` (via setViewPage). */
+    mrdLoadPage: EventEmitter<{
+        nodeId: string;
+        page: number;
+        sort: string;
+        path: string;
+        qs: string;
+    }>;
+    /** A document row was clicked. Host routes to the document object page. */
+    mrdNavigate: EventEmitter<{
+        href?: string;
+        label: string;
+    }>;
+    /** 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;
+    private nodeIndex;
+    componentDidLoad(): void;
+    private get containerField();
+    private get folderField();
+    private get titleField();
+    private get dateField();
+    /** VIEW: `/{dataClass}`; RELATED_VIEW: `/{fromClass}/{parentId}/{dataClass}`. */
+    private buildDataPath;
+    /** View-level static filters + filterClass, shared by every request. */
+    private baseParams;
+    private emitContainerDistinct;
+    private emitFolderDistinct;
+    private emitDocuments;
+    /** Inject distinct values for a node. `nodeId` is the sentinel root (containers)
+     *  or a container node id (folders). */
+    setDistinct(nodeId: string, values: DistinctValue[]): Promise<void>;
+    /** Inject the documents loaded for one folder node. */
+    setDocuments(nodeId: string, docs: DocRow[]): Promise<void>;
+    private applyContainers;
+    private applyFolders;
+    /** Normalise a folder path: null/""/"/" → root ([]); else split on "/" dropping empties. */
+    private splitFolder;
+    private makeContainerNode;
+    private makeFolderNode;
+    private computeTotals;
+    /** Force a re-render after mutating nodes in place. */
+    private bump;
+    private toggleContainer;
+    private toggleFolder;
+    private openDoc;
+    private renderChevron;
+    private renderDossierIcon;
+    private renderFolderIcon;
+    private renderDocIcon;
+    private indent;
+    private renderDocRow;
+    private renderLoadingRow;
+    private renderChildren;
+    private renderFolderNode;
+    private renderContainerNode;
+    render(): any;
+}

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

@@ -0,0 +1,36 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ClientArchetype } from '../../types/client-layout';
+/**
+ * Archetype-driven single-document view. Given a `commons.document` binding and a
+ * data record, renders the document recognisably — title, file preview/download,
+ * summary and date — plus a navigation link to the container (the dossier),
+ * instead of a generic field form.
+ *
+ * The component keys on the slot→field map (`archetype.slots`) to locate values:
+ * value slots read `data[field]`; the `container` relation slot reads
+ * `data._links[field]` (`{ href, name }`). Empty slots are omitted.
+ */
+export declare class MrdDocumentView {
+    /** Resolved `commons.document` binding: slot name → concrete field/relation name. */
+    archetype: ClientArchetype;
+    /** The data record from the /data endpoint. Fields keyed by name; relations under `_links`. */
+    data: Record<string, unknown>;
+    locale: string;
+    /** Navigate to the container (dossier). Host resolves the href and routes. */
+    mrdNavigate: EventEmitter<{
+        href?: string;
+        label: string;
+    }>;
+    /** Download the document file. Host resolves the href to a signed URL. */
+    mrdDownload: EventEmitter<{
+        href: string;
+        fileName: string;
+    }>;
+    /** Value of a value-slot: reads data[field] via the slot→field map. */
+    private slotValue;
+    /** Relation link for a relation-slot: reads data._links[field]. */
+    private slotLink;
+    private renderContainer;
+    private renderFile;
+    render(): any;
+}

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

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { ClientLayoutItem, ClientLayoutItemNavigate, ClientViewMetadata, RelationSearchResult } from '../../types/client-layout';
+import { ClientLayoutItem, ClientLayoutItemNavigate, ClientViewMetadata, ClientArchetype, RelationSearchResult } from '../../types/client-layout';
+import { DistinctValue } from '../mrd-document-list/mrd-document-list';
 export declare class MrdLayoutSection {
     el: HTMLElement;
     /** Items from one layout entry in ClientDashboardMetadata.layouts[]. */
@@ -13,11 +14,16 @@ export declare class MrdLayoutSection {
         href: string;
     }>;
     locale: string;
+    /** Top-level archetypes on the object dashboard. When it contains commons.document,
+     *  the record is rendered as a single-document view instead of generic fields. */
+    archetypes: ClientArchetype[];
     private searchQueryMap;
     private searchResultsMap;
     private imagePreviewUrl;
     private imagePreviews;
     private openHistoryField;
+    /** Per-view display mode for document collection views. Default 'tree'. */
+    private docViewMode;
     private historyClickOutside;
     mrdNavigate: EventEmitter<{
         href?: string;
@@ -32,13 +38,15 @@ export declare class MrdLayoutSection {
         href: string;
         fileName: string;
     }>;
-    /** Re-emitted from an embedded mrd-table's mrdLoadPage; host fetches the next page and calls setViewPage(). */
+    /** Re-emitted from an embedded mrd-table's or mrd-document-list's mrdLoadPage; host fetches the
+     *  rows and calls setViewPage(). `nodeId` is present for a document-list folder load. */
     mrdLoadViewPage: EventEmitter<{
         name: string;
         page: number;
         sort: string;
         path: string;
         qs: string;
+        nodeId?: string;
     }>;
     /** Fired once on load for each IMAGE field that has an href; host resolves the URL and calls setImagePreview(). */
     mrdLoadImage: EventEmitter<{
@@ -63,6 +71,14 @@ export declare class MrdLayoutSection {
         qs: string;
         aggQs: string;
     }>;
+    /** Re-emitted from an embedded mrd-document-list's mrdLoadDistinct; host fetches distinct values and calls setViewDistinct(). */
+    mrdLoadViewDistinct: EventEmitter<{
+        name: string;
+        nodeId: string;
+        distinct: string;
+        path: string;
+        qs: string;
+    }>;
     private searchTimers;
     componentDidLoad(): void;
     disconnectedCallback(): void;
@@ -74,13 +90,16 @@ export declare class MrdLayoutSection {
     /** Inject search results. Pass dataClass to target a specific SEARCH item; omit when there is only one. */
     setSearchResults(results: RelationSearchResult[], dataClass?: string): Promise<void>;
     /**
-     * Inject data into an embedded mrd-table for a RELATED_VIEW or VIEW item.
-     * Pass totalElements to update the pagination total (safe to pass on every page).
-     * Pass hasNext (from _links.next presence) so the table can decide whether to emit aggregations.
+     * Inject rows for a VIEW / RELATED_VIEW item.
+     * - Table view: injects the page into the embedded mrd-table (pass totalElements/hasNext).
+     * - Document view: pass `nodeId` to route the rows to that folder node in the embedded
+     *   mrd-document-list. Folder loading is just a filtered list load, so it reuses this method.
      */
-    setViewPage(name: string, page: number, rows: any[], totalElements?: number, hasNext?: boolean): Promise<void>;
+    setViewPage(name: string, page: number, rows: any[], totalElements?: number, hasNext?: boolean, nodeId?: string): Promise<void>;
     /** Inject aggregation totals into an embedded mrd-table for a VIEW or RELATED_VIEW item. */
     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>;
     /** 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). */
@@ -95,7 +114,15 @@ export declare class MrdLayoutSection {
     private renderRelation;
     private renderSearch;
     private renderRelatedView;
+    /** Tree / list segmented toggle for document collection views (+ upload placeholder). */
+    private renderDocToolbar;
+    private renderDocumentList;
+    private renderTable;
     private renderItem;
     private renderImageModal;
+    /** Single-document view: the record's own type carries commons.document. Renders
+     *  a recognisable document instead of generic fields, keeping any related views/
+     *  searches below it. */
+    private renderDocumentObject;
     render(): any;
 }