@mmlogic/components 0.5.1 → 0.5.3

package/dist/collection/components/merge/mrd-merge-view/mrd-merge-view.js

@@ -0,0 +1,397 @@
+import { Host, h } from "@stencil/core";
+import { diffFields, buildPatch, candidateLabel } from "./merge-diff";
+import { MergeSearchStep, MergeCompareStep, MergeConfirmStep } from "./merge-parts";
+/**
+ * Merges two DataObjects of the same basic type (FINDING-0114 / TASK-0177).
+ * Never performs network I/O itself: it emits `mrdSearch` (host searches and
+ * calls `setSearchResults()`, mirroring mrd-relation-field) and `mrdMerge`
+ * (host calls the merge endpoint — `POST {winnerHref}/merge` with
+ * `{ loser: loserHref, patch }`, per DataController.merge()).
+ *
+ * Has no exit/cancel affordance of its own — hosts show this inside their
+ * own overlay-page chrome (its close button), the same way mrd-layout-section
+ * never renders a page-level close button either.
+ */
+export class MrdMergeView {
+    constructor() {
+        this.locale = navigator.language;
+        /** Dot-notation class, passed through on mrdSearch (host may use it to pick the right search endpoint). */
+        this.basicType = '';
+        /** URL segment for the search endpoint; falls back to basicType when absent. */
+        this.mostSignificantClass = '';
+        /** Flat FIELD/RELATION items describing the basic type's schema (host flattens SECTION/GROUP, same as mrd-table's `columns`). */
+        this.fields = [];
+        /** Href of A (winner) — the object the merge screen was opened from. */
+        this.currentHref = '';
+        /** A's full raw record: flat fields + `_links`, the same row shape CellRenderer.render expects. */
+        this.currentRecord = {};
+        /** Display name for A, shown in the compare step's column header. */
+        this.currentLabel = '';
+        this.step = 'search';
+        this.searchQuery = '';
+        this.searchResults = [];
+        this.isLoading = false;
+        this.candidate = null;
+        this.resolutions = {};
+        /** Which history badge popover is open, keyed e.g. `legalName:A` / `legalName:confirm`. */
+        this.openHistoryKey = null;
+        this.historyClickOutside = null;
+        this.searchDebounce = null;
+        this.handleSearchInput = (query) => {
+            this.searchQuery = query;
+            if (this.searchDebounce)
+                clearTimeout(this.searchDebounce);
+            if (query.trim().length >= 2) {
+                this.isLoading = true;
+                this.searchDebounce = setTimeout(() => {
+                    this.mrdSearch.emit({
+                        query,
+                        basicType: this.basicType,
+                        mostSignificantClass: this.mostSignificantClass || undefined,
+                    });
+                }, 300);
+            }
+            else {
+                this.searchResults = [];
+                this.isLoading = false;
+            }
+        };
+        this.handleSelect = (record) => {
+            this.candidate = record;
+            const { conflicts } = diffFields(this.fields, this.currentRecord, record);
+            const resolutions = {};
+            conflicts.forEach(({ item }) => { var _a; resolutions[(_a = item.name) !== null && _a !== void 0 ? _a : ''] = 'A'; });
+            this.resolutions = resolutions;
+            this.openHistoryKey = null;
+            this.step = 'compare';
+        };
+        this.handleChangeCandidate = () => {
+            this.candidate = null;
+            this.resolutions = {};
+            this.openHistoryKey = null;
+            this.step = 'search';
+        };
+        this.handleResolve = (name, side) => {
+            this.resolutions = Object.assign(Object.assign({}, this.resolutions), { [name]: side });
+        };
+        this.handleToggleHistory = (key) => {
+            this.openHistoryKey = key;
+        };
+        this.handleContinue = () => {
+            this.step = 'confirm';
+        };
+        this.handleBack = () => {
+            this.step = 'compare';
+        };
+        this.handleConfirm = () => {
+            var _a, _b, _c, _d;
+            if (!this.candidate)
+                return;
+            const diff = diffFields(this.fields, this.currentRecord, this.candidate);
+            const patch = buildPatch(diff, this.resolutions);
+            const loserHref = (_d = (_c = (_b = (_a = this.candidate) === null || _a === void 0 ? void 0 : _a._links) === null || _b === void 0 ? void 0 : _b.self) === null || _c === void 0 ? void 0 : _c.href) !== null && _d !== void 0 ? _d : '';
+            this.mrdMerge.emit({ winnerHref: this.currentHref, loserHref, patch });
+        };
+    }
+    connectedCallback() {
+        this.historyClickOutside = (e) => {
+            if (!this.el.contains(e.target))
+                this.openHistoryKey = null;
+        };
+        document.addEventListener('mousedown', this.historyClickOutside);
+    }
+    disconnectedCallback() {
+        if (this.historyClickOutside) {
+            document.removeEventListener('mousedown', this.historyClickOutside);
+            this.historyClickOutside = null;
+        }
+    }
+    /**
+     * Stores search results, filtering out A itself regardless of what the
+     * host's search returns — A must never appear as a mergeable candidate.
+     */
+    async setSearchResults(records) {
+        this.searchResults = (records !== null && records !== void 0 ? records : []).filter(r => { var _a, _b, _c; return ((_c = (_b = (_a = r === null || r === void 0 ? void 0 : r._links) === null || _a === void 0 ? void 0 : _a.self) === null || _b === void 0 ? void 0 : _b.href) !== null && _c !== void 0 ? _c : null) !== this.currentHref; });
+        this.isLoading = false;
+    }
+    async setLoading(loading) {
+        this.isLoading = loading;
+    }
+    render() {
+        var _a, _b;
+        let stepContent;
+        if (this.step === 'search') {
+            stepContent = (h(MergeSearchStep, { key: '3adb36fb46aa7260641a46a2cf27cc0ef320876f', locale: this.locale, searchQuery: this.searchQuery, searchResults: this.searchResults, isLoading: this.isLoading, onSearchInput: this.handleSearchInput, onSelect: this.handleSelect }));
+        }
+        else {
+            const diff = diffFields(this.fields, this.currentRecord, this.candidate);
+            const bLabel = candidateLabel(this.candidate);
+            stepContent = this.step === 'compare' ? (h(MergeCompareStep, { locale: this.locale, currentLabel: this.currentLabel, candidateLabel: bLabel, conflicts: diff.conflicts, autoFilled: diff.autoFilled, recordA: this.currentRecord, recordB: (_a = this.candidate) !== null && _a !== void 0 ? _a : {}, resolutions: this.resolutions, openHistoryKey: this.openHistoryKey, onResolve: this.handleResolve, onToggleHistory: this.handleToggleHistory, onChangeCandidate: this.handleChangeCandidate, onContinue: this.handleContinue })) : (h(MergeConfirmStep, { locale: this.locale, candidateLabel: bLabel, conflicts: diff.conflicts, autoFilled: diff.autoFilled, resolutions: this.resolutions, recordB: (_b = this.candidate) !== null && _b !== void 0 ? _b : {}, openHistoryKey: this.openHistoryKey, onToggleHistory: this.handleToggleHistory, onBack: this.handleBack, onConfirm: this.handleConfirm }));
+        }
+        return (h(Host, { key: 'e33a6d66a220b28cc9533da78dc274e2d7ec5c4a' }, h("div", { key: 'b5fb1390d86192f9f6f15e3ccb89e2d21d9c7c8b', class: "mrd-merge-view" }, stepContent)));
+    }
+    static get is() { return "mrd-merge-view"; }
+    static get encapsulation() { return "scoped"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["mrd-merge-view.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["mrd-merge-view.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "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"
+            },
+            "basicType": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Dot-notation class, passed through on mrdSearch (host may use it to pick the right search endpoint)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "basic-type",
+                "defaultValue": "''"
+            },
+            "mostSignificantClass": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "URL segment for the search endpoint; falls back to basicType when absent."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "most-significant-class",
+                "defaultValue": "''"
+            },
+            "fields": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ClientLayoutItem[]",
+                    "resolved": "ClientLayoutItem[]",
+                    "references": {
+                        "ClientLayoutItem": {
+                            "location": "import",
+                            "path": "../../../types/client-layout",
+                            "id": "src/types/client-layout.ts::ClientLayoutItem",
+                            "referenceLocation": "ClientLayoutItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Flat FIELD/RELATION items describing the basic type's schema (host flattens SECTION/GROUP, same as mrd-table's `columns`)."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[]"
+            },
+            "currentHref": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Href of A (winner) \u2014 the object the merge screen was opened from."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "current-href",
+                "defaultValue": "''"
+            },
+            "currentRecord": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Record<string, any>",
+                    "resolved": "any | string",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "A's full raw record: flat fields + `_links`, the same row shape CellRenderer.render expects."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{}"
+            },
+            "currentLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Display name for A, shown in the compare step's column header."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "current-label",
+                "defaultValue": "''"
+            }
+        };
+    }
+    static get states() {
+        return {
+            "step": {},
+            "searchQuery": {},
+            "searchResults": {},
+            "isLoading": {},
+            "candidate": {},
+            "resolutions": {},
+            "openHistoryKey": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "mrdSearch",
+                "name": "mrdSearch",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "{ query: string; basicType: string; mostSignificantClass?: string }",
+                    "resolved": "{ query: string; basicType: string; mostSignificantClass?: string | undefined; }",
+                    "references": {}
+                }
+            }, {
+                "method": "mrdMerge",
+                "name": "mrdMerge",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "{ winnerHref: string; loserHref: string; patch: Record<string, unknown> }",
+                    "resolved": "{ winnerHref: string; loserHref: string; patch: Record<string, unknown>; }",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "setSearchResults": {
+                "complexType": {
+                    "signature": "(records: Record<string, any>[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "records",
+                            "type": "Record<string, any>[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Stores search results, filtering out A itself regardless of what the\nhost's search returns \u2014 A must never appear as a mergeable candidate.",
+                    "tags": []
+                }
+            },
+            "setLoading": {
+                "complexType": {
+                    "signature": "(loading: boolean) => Promise<void>",
+                    "parameters": [{
+                            "name": "loading",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "el"; }
+}

package/dist/collection/dev/api.js

@@ -19,7 +19,21 @@ async function apiRequest(method, path, token, body) {
   const text = await resp.text();
   let json;
   try { json = JSON.parse(text); } catch (_) { json = text; }
-  return { status: resp.status, ok: resp.ok, body: json };
+  return { status: resp.status, ok: resp.ok, body: json, location: resp.headers.get('Location') };
+}
+
+/**
+ * Write (POST/PATCH) that returns no body — only a Location header
+ * (create/patch/merge on /data/**, per TASK-0203). Follows the Location
+ * header with a GET to hand callers the current record, mirroring
+ * content-app's ApiClientService create/update methods.
+ */
+async function apiWriteAndFetch(method, path, token, payload) {
+  const write = await apiRequest(method, path, token, payload);
+  if (!write.ok) return write;
+  const href = write.location || path;
+  const { body } = await apiRequest('GET', href, token);
+  return { ...write, body };
 }
 
 /** Resolve a file/image reference href to a signed, directly-usable URL.
@@ -95,7 +109,7 @@ async function apiFetchPage(token, baseHref, pageNumber, sort = '') {
 }
 
 async function apiSubmitForm(token, tenantCode, pluralName, values) {
-  const { status, ok, body } = await apiRequest('POST', `/data/${tenantCode}/${pluralName}`, token, values);
+  const { status, ok, body } = await apiWriteAndFetch('POST', `/data/${tenantCode}/${pluralName}`, token, values);
   return { status, ok, body };
 }
 
@@ -135,6 +149,31 @@ async function apiSearchRelation(token, tenantCode, mostSignificantClass, query)
   }));
 }
 
+/**
+ * Search for merge candidates. Unlike apiSearchRelation, this does NOT map
+ * results down to {id, label} — mrd-merge-view needs the full raw records
+ * (fields + _links) up front so it can diff without a second fetch per
+ * candidate once one is selected.
+ */
+async function apiSearchMergeCandidates(token, tenantCode, mostSignificantClass, query) {
+  const q = encodeURIComponent(query);
+  const { ok, status, body } = await apiRequest('GET', `/data/${tenantCode}/${mostSignificantClass}?q=${q}`, token);
+  if (!ok) throw new Error(`${status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`);
+  return (body._embedded && body._embedded[mostSignificantClass]) || [];
+}
+
+/**
+ * Merge two DataObjects of the same basic type. Mirrors DataController.merge():
+ * POST {winnerHref}/merge with { loser: loserHref, patch }. Returns no body
+ * (204 + Location, per TASK-0203) — follows Location with a GET for the
+ * patched winner record.
+ */
+async function apiMerge(token, winnerHref, loserHref, patch) {
+  const { ok, status, body } = await apiWriteAndFetch('POST', `${winnerHref}/merge`, token, { loser: loserHref, patch });
+  if (!ok) throw new Error(`${status}: ${typeof body === 'string' ? body : JSON.stringify(body)}`);
+  return body;
+}
+
 /* =====================================================================
    LAYOUT MAPPERS
    mrd-form and mrd-field now accept the flat API format directly.