@mmlogic/components 0.5.1 → 0.5.2

package/dist/types/components/fields/mrd-textarea-field/mrd-textarea-field.d.ts

@@ -21,5 +21,6 @@ export declare class MrdTextareaField implements ComponentDidLoad {
     private editorEl;
     componentDidLoad(): void;
     private initQuill;
+    private getSanitizedHtml;
     render(): any;
 }

package/dist/types/components/merge/mrd-merge-view/merge-diff.d.ts

@@ -0,0 +1,43 @@
+import { ClientLayoutItem } from '../../../types/client-layout';
+/** A single field/relation whose value differs between the two records being merged. */
+export interface MergeFieldDiff {
+    item: ClientLayoutItem;
+    aValue: unknown;
+    bValue: unknown;
+}
+/**
+ * Whether a layout item can appear in the merge diff at all. m-n relations
+ * (`multiple: true`) are unioned automatically server-side (DataService.merge)
+ * and must never be surfaced as a user choice — only FIELD and single-value
+ * (n-1) RELATION items are diffable.
+ */
+export declare function isDiffable(item: ClientLayoutItem): boolean;
+/**
+ * Raw value for a field/relation off a record in the API's row shape (flat
+ * fields + `_links`). History-enabled fields come back as `{ current,
+ * history: [...] }` — this returns that whole object as-is, since a winning
+ * B value must carry its entire history into the patch (FINDING-0114: "the
+ * entire history list follows whichever value wins ... never interleaved").
+ */
+export declare function getRawValue(item: ClientLayoutItem, record: Record<string, any> | null | undefined): unknown;
+/**
+ * Splits diffable fields into `conflicts` (both records have a — different —
+ * value, user must pick) and `autoFilled` (A has no value, B does; silently
+ * taken from B without a UI choice).
+ */
+export declare function diffFields(fields: ClientLayoutItem[], recordA: Record<string, any> | null | undefined, recordB: Record<string, any> | null | undefined): {
+    conflicts: MergeFieldDiff[];
+    autoFilled: MergeFieldDiff[];
+};
+/**
+ * Builds the patch payload per the merge endpoint contract: every `autoFilled`
+ * entry is always included (A had nothing to lose); a `conflicts` entry is
+ * only included when the user explicitly resolved it to B — anything left
+ * unresolved keeps A's value by omission.
+ */
+export declare function buildPatch(diff: {
+    conflicts: MergeFieldDiff[];
+    autoFilled: MergeFieldDiff[];
+}, resolutions: Record<string, 'A' | 'B'>): Record<string, unknown>;
+/** Display label for a candidate record in the search results list. */
+export declare function candidateLabel(record: Record<string, any> | null | undefined): string;

package/dist/types/components/merge/mrd-merge-view/merge-parts.d.ts

@@ -0,0 +1,37 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+import { MergeFieldDiff } from './merge-diff';
+export declare const MergeSearchStep: FunctionalComponent<{
+    locale: string;
+    searchQuery: string;
+    searchResults: Record<string, any>[];
+    isLoading: boolean;
+    onSearchInput: (query: string) => void;
+    onSelect: (record: Record<string, any>) => void;
+}>;
+export declare const MergeCompareStep: FunctionalComponent<{
+    locale: string;
+    currentLabel: string;
+    candidateLabel: string;
+    conflicts: MergeFieldDiff[];
+    autoFilled: MergeFieldDiff[];
+    recordA: Record<string, any>;
+    recordB: Record<string, any>;
+    resolutions: Record<string, 'A' | 'B'>;
+    openHistoryKey: string | null;
+    onResolve: (name: string, side: 'A' | 'B') => void;
+    onToggleHistory: (key: string | null) => void;
+    onChangeCandidate: () => void;
+    onContinue: () => void;
+}>;
+export declare const MergeConfirmStep: FunctionalComponent<{
+    locale: string;
+    candidateLabel: string;
+    conflicts: MergeFieldDiff[];
+    autoFilled: MergeFieldDiff[];
+    resolutions: Record<string, 'A' | 'B'>;
+    recordB: Record<string, any>;
+    openHistoryKey: string | null;
+    onToggleHistory: (key: string | null) => void;
+    onBack: () => void;
+    onConfirm: () => void;
+}>;

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

@@ -0,0 +1,68 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { ClientLayoutItem } from '../../../types/client-layout';
+type MergeStep = 'search' | 'compare' | 'confirm';
+/**
+ * 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 declare class MrdMergeView {
+    el: HTMLElement;
+    locale: string;
+    /** Dot-notation class, passed through on mrdSearch (host may use it to pick the right search endpoint). */
+    basicType: string;
+    /** URL segment for the search endpoint; falls back to basicType when absent. */
+    mostSignificantClass: string;
+    /** Flat FIELD/RELATION items describing the basic type's schema (host flattens SECTION/GROUP, same as mrd-table's `columns`). */
+    fields: ClientLayoutItem[];
+    /** Href of A (winner) — the object the merge screen was opened from. */
+    currentHref: string;
+    /** A's full raw record: flat fields + `_links`, the same row shape CellRenderer.render expects. */
+    currentRecord: Record<string, any>;
+    /** Display name for A, shown in the compare step's column header. */
+    currentLabel: string;
+    step: MergeStep;
+    searchQuery: string;
+    searchResults: Record<string, any>[];
+    isLoading: boolean;
+    candidate: Record<string, any> | null;
+    resolutions: Record<string, 'A' | 'B'>;
+    /** Which history badge popover is open, keyed e.g. `legalName:A` / `legalName:confirm`. */
+    openHistoryKey: string | null;
+    mrdSearch: EventEmitter<{
+        query: string;
+        basicType: string;
+        mostSignificantClass?: string;
+    }>;
+    mrdMerge: EventEmitter<{
+        winnerHref: string;
+        loserHref: string;
+        patch: Record<string, unknown>;
+    }>;
+    private historyClickOutside;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Stores search results, filtering out A itself regardless of what the
+     * host's search returns — A must never appear as a mergeable candidate.
+     */
+    setSearchResults(records: Record<string, any>[]): Promise<void>;
+    setLoading(loading: boolean): Promise<void>;
+    private searchDebounce;
+    private handleSearchInput;
+    private handleSelect;
+    private handleChangeCandidate;
+    private handleResolve;
+    private handleToggleHistory;
+    private handleContinue;
+    private handleBack;
+    private handleConfirm;
+    render(): any;
+}
+export {};

package/dist/types/components.d.ts

@@ -550,6 +550,57 @@ export namespace Components {
          */
         "value": string;
     }
+    /**
+     * 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.
+     */
+    interface MrdMergeView {
+        /**
+          * Dot-notation class, passed through on mrdSearch (host may use it to pick the right search endpoint).
+          * @default ''
+         */
+        "basicType": string;
+        /**
+          * Href of A (winner) — the object the merge screen was opened from.
+          * @default ''
+         */
+        "currentHref": string;
+        /**
+          * Display name for A, shown in the compare step's column header.
+          * @default ''
+         */
+        "currentLabel": string;
+        /**
+          * A's full raw record: flat fields + `_links`, the same row shape CellRenderer.render expects.
+          * @default {}
+         */
+        "currentRecord": Record<string, any>;
+        /**
+          * Flat FIELD/RELATION items describing the basic type's schema (host flattens SECTION/GROUP, same as mrd-table's `columns`).
+          * @default []
+         */
+        "fields": ClientLayoutItem[];
+        /**
+          * @default navigator.language
+         */
+        "locale": string;
+        /**
+          * URL segment for the search endpoint; falls back to basicType when absent.
+          * @default ''
+         */
+        "mostSignificantClass": string;
+        "setLoading": (loading: boolean) => Promise<void>;
+        /**
+          * Stores search results, filtering out A itself regardless of what the host's search returns — A must never appear as a mergeable candidate.
+         */
+        "setSearchResults": (records: Record<string, any>[]) => Promise<void>;
+    }
     interface MrdNumberField {
         /**
           * @default ClientLayoutItemFieldDataType.INTEGER
@@ -880,6 +931,10 @@ export interface MrdLongtextFieldCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLMrdLongtextFieldElement;
 }
+export interface MrdMergeViewCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLMrdMergeViewElement;
+}
 export interface MrdNumberFieldCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLMrdNumberFieldElement;
@@ -1268,6 +1323,34 @@ declare global {
         prototype: HTMLMrdLongtextFieldElement;
         new (): HTMLMrdLongtextFieldElement;
     };
+    interface HTMLMrdMergeViewElementEventMap {
+        "mrdSearch": { query: string; basicType: string; mostSignificantClass?: string };
+        "mrdMerge": { winnerHref: string; loserHref: string; patch: Record<string, unknown> };
+    }
+    /**
+     * 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.
+     */
+    interface HTMLMrdMergeViewElement extends Components.MrdMergeView, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLMrdMergeViewElementEventMap>(type: K, listener: (this: HTMLMrdMergeViewElement, ev: MrdMergeViewCustomEvent<HTMLMrdMergeViewElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLMrdMergeViewElementEventMap>(type: K, listener: (this: HTMLMrdMergeViewElement, ev: MrdMergeViewCustomEvent<HTMLMrdMergeViewElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLMrdMergeViewElement: {
+        prototype: HTMLMrdMergeViewElement;
+        new (): HTMLMrdMergeViewElement;
+    };
     interface HTMLMrdNumberFieldElementEventMap {
         "mrdChange": { name: string; value: number | null };
         "mrdBlur": { name: string; value: number | null };
@@ -1417,6 +1500,7 @@ declare global {
         "mrd-layout-section": HTMLMrdLayoutSectionElement;
         "mrd-list-field": HTMLMrdListFieldElement;
         "mrd-longtext-field": HTMLMrdLongtextFieldElement;
+        "mrd-merge-view": HTMLMrdMergeViewElement;
         "mrd-number-field": HTMLMrdNumberFieldElement;
         "mrd-relation-field": HTMLMrdRelationFieldElement;
         "mrd-secret-field": HTMLMrdSecretFieldElement;
@@ -2062,6 +2146,54 @@ declare namespace LocalJSX {
          */
         "value"?: string;
     }
+    /**
+     * 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.
+     */
+    interface MrdMergeView {
+        /**
+          * Dot-notation class, passed through on mrdSearch (host may use it to pick the right search endpoint).
+          * @default ''
+         */
+        "basicType"?: string;
+        /**
+          * Href of A (winner) — the object the merge screen was opened from.
+          * @default ''
+         */
+        "currentHref"?: string;
+        /**
+          * Display name for A, shown in the compare step's column header.
+          * @default ''
+         */
+        "currentLabel"?: string;
+        /**
+          * A's full raw record: flat fields + `_links`, the same row shape CellRenderer.render expects.
+          * @default {}
+         */
+        "currentRecord"?: Record<string, any>;
+        /**
+          * Flat FIELD/RELATION items describing the basic type's schema (host flattens SECTION/GROUP, same as mrd-table's `columns`).
+          * @default []
+         */
+        "fields"?: ClientLayoutItem[];
+        /**
+          * @default navigator.language
+         */
+        "locale"?: string;
+        /**
+          * URL segment for the search endpoint; falls back to basicType when absent.
+          * @default ''
+         */
+        "mostSignificantClass"?: string;
+        "onMrdMerge"?: (event: MrdMergeViewCustomEvent<{ winnerHref: string; loserHref: string; patch: Record<string, unknown> }>) => void;
+        "onMrdSearch"?: (event: MrdMergeViewCustomEvent<{ query: string; basicType: string; mostSignificantClass?: string }>) => void;
+    }
     interface MrdNumberField {
         /**
           * @default ClientLayoutItemFieldDataType.INTEGER
@@ -2463,6 +2595,13 @@ declare namespace LocalJSX {
         "disabled": boolean;
         "locale": string;
     }
+    interface MrdMergeViewAttributes {
+        "locale": string;
+        "basicType": string;
+        "mostSignificantClass": string;
+        "currentHref": string;
+        "currentLabel": string;
+    }
     interface MrdNumberFieldAttributes {
         "name": string;
         "label": string;
@@ -2550,6 +2689,7 @@ declare namespace LocalJSX {
         "mrd-layout-section": Omit<MrdLayoutSection, keyof MrdLayoutSectionAttributes> & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes]?: MrdLayoutSection[K] } & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes as `attr:${K}`]?: MrdLayoutSectionAttributes[K] } & { [K in keyof MrdLayoutSection & keyof MrdLayoutSectionAttributes as `prop:${K}`]?: MrdLayoutSection[K] };
         "mrd-list-field": Omit<MrdListField, keyof MrdListFieldAttributes> & { [K in keyof MrdListField & keyof MrdListFieldAttributes]?: MrdListField[K] } & { [K in keyof MrdListField & keyof MrdListFieldAttributes as `attr:${K}`]?: MrdListFieldAttributes[K] } & { [K in keyof MrdListField & keyof MrdListFieldAttributes as `prop:${K}`]?: MrdListField[K] };
         "mrd-longtext-field": Omit<MrdLongtextField, keyof MrdLongtextFieldAttributes> & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes]?: MrdLongtextField[K] } & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes as `attr:${K}`]?: MrdLongtextFieldAttributes[K] } & { [K in keyof MrdLongtextField & keyof MrdLongtextFieldAttributes as `prop:${K}`]?: MrdLongtextField[K] };
+        "mrd-merge-view": Omit<MrdMergeView, keyof MrdMergeViewAttributes> & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes]?: MrdMergeView[K] } & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes as `attr:${K}`]?: MrdMergeViewAttributes[K] } & { [K in keyof MrdMergeView & keyof MrdMergeViewAttributes as `prop:${K}`]?: MrdMergeView[K] };
         "mrd-number-field": Omit<MrdNumberField, keyof MrdNumberFieldAttributes> & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes]?: MrdNumberField[K] } & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes as `attr:${K}`]?: MrdNumberFieldAttributes[K] } & { [K in keyof MrdNumberField & keyof MrdNumberFieldAttributes as `prop:${K}`]?: MrdNumberField[K] };
         "mrd-relation-field": Omit<MrdRelationField, keyof MrdRelationFieldAttributes> & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes]?: MrdRelationField[K] } & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes as `attr:${K}`]?: MrdRelationFieldAttributes[K] } & { [K in keyof MrdRelationField & keyof MrdRelationFieldAttributes as `prop:${K}`]?: MrdRelationField[K] };
         "mrd-secret-field": Omit<MrdSecretField, keyof MrdSecretFieldAttributes> & { [K in keyof MrdSecretField & keyof MrdSecretFieldAttributes]?: MrdSecretField[K] } & { [K in keyof MrdSecretField & keyof MrdSecretFieldAttributes as `attr:${K}`]?: MrdSecretFieldAttributes[K] } & { [K in keyof MrdSecretField & keyof MrdSecretFieldAttributes as `prop:${K}`]?: MrdSecretField[K] };
@@ -2620,6 +2760,17 @@ declare module "@stencil/core" {
             "mrd-layout-section": LocalJSX.IntrinsicElements["mrd-layout-section"] & JSXBase.HTMLAttributes<HTMLMrdLayoutSectionElement>;
             "mrd-list-field": LocalJSX.IntrinsicElements["mrd-list-field"] & JSXBase.HTMLAttributes<HTMLMrdListFieldElement>;
             "mrd-longtext-field": LocalJSX.IntrinsicElements["mrd-longtext-field"] & JSXBase.HTMLAttributes<HTMLMrdLongtextFieldElement>;
+            /**
+             * 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.
+             */
+            "mrd-merge-view": LocalJSX.IntrinsicElements["mrd-merge-view"] & JSXBase.HTMLAttributes<HTMLMrdMergeViewElement>;
             "mrd-number-field": LocalJSX.IntrinsicElements["mrd-number-field"] & JSXBase.HTMLAttributes<HTMLMrdNumberFieldElement>;
             "mrd-relation-field": LocalJSX.IntrinsicElements["mrd-relation-field"] & JSXBase.HTMLAttributes<HTMLMrdRelationFieldElement>;
             "mrd-secret-field": LocalJSX.IntrinsicElements["mrd-secret-field"] & JSXBase.HTMLAttributes<HTMLMrdSecretFieldElement>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmlogic/components",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Stencil.js web component library for dynamic forms and virtual-scroll data tables",
   "license": "MIT",
   "author": "Mosterd",
@@ -43,6 +43,7 @@
   },
   "dependencies": {
     "@stencil/core": "^4.43.5",
+    "dompurify": "^3.4.12",
     "quill": "^2.0.3"
   },
   "devDependencies": {