@mmlogic/components 0.5.15 → 0.5.17

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

@@ -33,6 +33,13 @@ export declare class MrdDocumentContainer {
      *  (with a tooltip explaining why) and the embedded table/list get it passed
      *  through so their own create/upload/drag-drop paths are disabled too. */
     readOnly: boolean;
+    /** Whether the current user may create a document here — set by mrd-layout-section from
+     *  its generic capability check (TASK-0299/FINDING-0155), the same answer the embedded
+     *  table gets in list mode. Named `mayCreate` (not `canCreate`) to avoid colliding with
+     *  the existing `canCreate` state below, which tracks something unrelated: whether the
+     *  folder tree currently has a valid drop target selected. Defaults to false (hidden)
+     *  until confirmed, same as mrd-table. */
+    mayCreate: boolean;
     /** Re-emitted from the embedded list/table. `nodeId` present for a folder load. */
     mrdLoadPage: EventEmitter<{
         page: number;

package/dist/types/components/form/mrd-field/mrd-field.d.ts

@@ -35,9 +35,19 @@ export declare class MrdField {
         until: string;
     }>;
     currentValue: unknown;
+    multiValues: unknown[];
+    multiError: string;
     componentWillLoad(): void;
     valueChanged(): void;
     private initHistoryState;
+    /** LIST/FILE/IMAGE already own their multiple-value UI end to end; every
+     *  other scalar dataType routes through the generic repeater below instead
+     *  of each leaf field re-implementing add/remove itself (FINDING-0149). */
+    private isMultiScalar;
+    private initMultiState;
+    private emptyRowValue;
+    private emitMultiChange;
+    private handleMultiRowBlur;
     private handleChange;
     private handleBlur;
     private handleSearch;
@@ -46,7 +56,13 @@ export declare class MrdField {
     private getDisplayValue;
     private historyValueInputType;
     private emitHistoryChange;
+    private renderRemoveIcon;
     private renderHistoryEditor;
     private renderLeafField;
+    /** Repeatable-row UI for a scalar dataType with multiple: true — mirrors the
+     *  add/remove pattern already established by renderHistoryEditor(), reusing
+     *  the single-row renderLeafField() per entry instead of duplicating repeat
+     *  UI into every leaf field component (FINDING-0149). */
+    private renderMultiScalarField;
     render(): any;
 }

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

@@ -19,4 +19,8 @@ export interface FieldViewContext {
     };
 }
 export declare function renderFieldValue(ctx: FieldViewContext, item: ClientLayoutItem, rawValue: unknown): any;
+/** Whether a FIELD item would render anything at all (value, or a showEmpty
+ *  placeholder). A `header` field always renders. Used by mrd-layout-section
+ *  to decide whether a preceding HEADER item's block is entirely empty. */
+export declare function isFieldVisible(ctx: FieldViewContext, item: ClientLayoutItem): boolean;
 export declare function renderField(ctx: FieldViewContext, item: ClientLayoutItem): any;

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

@@ -4,6 +4,9 @@ export declare function viewKeyFor(item: ClientLayoutItem): string;
 /** Whether a FIELD/RELATION item stays visible on an OBJECT_DASHBOARD when it
  *  has no value. Reads the flat API flag, falling back to the nested wrappers. */
 export declare function showsEmpty(item: ClientLayoutItem): boolean;
+/** Whether a RELATION item has a resolvable link value (`_links[item.name]`
+ *  carries either a multi-value `values[]` or a single `name`). */
+export declare function hasRelationValue(item: ClientLayoutItem, data: Record<string, unknown>): boolean;
 /** Depth-first flatten of the SECTION/GROUP tree. */
 export declare function flattenItems(items: ClientLayoutItem[]): ClientLayoutItem[];
 /** Build the canonical parent href `/{base}/{tenant}/{fromClass}/{parentId}` from

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

@@ -32,7 +32,16 @@ export declare class MrdLayoutSection {
     private imagePreviewUrl;
     private imagePreviews;
     private openHistoryField;
+    /** Answers to mrdViewCheckCapabilities, keyed by view key — see emitCapabilitiesChecks().
+     *  Passed straight down as a `canCreate`/`mayCreate` prop to whichever body (mrd-table,
+     *  mrd-memo-container, mrd-document-container) is mounted for that key; a missing entry
+     *  means "not answered yet" and is treated as false (hidden), same default as mrd-table's
+     *  own standalone behaviour (TASK-0299). */
+    private canCreateMap;
     private historyClickOutside;
+    /** Signature last asked per view key (see emitCapabilitiesChecks()) — avoids re-emitting
+     *  mrdViewCheckCapabilities on every data/items update when the binding hasn't changed. */
+    private capabilitiesAsked;
     /** `attachments`, when present, prefetches the clicked document row's file slot
      *  (see TASK-0169 / FINDING-0111) so the host can render a preview immediately,
      *  without waiting for the navigated-to page's own mrdAttachments. Only set for
@@ -101,6 +110,17 @@ export declare class MrdLayoutSection {
         path: string;
         qs: string;
     }>;
+    /** Emitted once per VIEW/RELATED_VIEW binding — computed here directly, not relayed from a
+     *  child (see emitCapabilitiesChecks()), so it covers mrd-table, mrd-memo-container and
+     *  mrd-document-container uniformly. `name` is the view key (viewKeyFor(item)) — pass it
+     *  back to setViewCanCreate() to answer it. */
+    mrdViewCheckCapabilities: EventEmitter<{
+        name: string;
+        type: string;
+        refType?: string;
+        refId?: string;
+        filterClass?: 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<{
@@ -129,8 +149,29 @@ export declare class MrdLayoutSection {
     componentDidLoad(): void;
     disconnectedCallback(): void;
     dataChanged(newVal: Record<string, unknown>): void;
+    /** A host can swap `items` (e.g. a different dashboard layout) without `data` changing —
+     *  dataChanged() alone would miss that binding change. */
+    itemsChanged(): void;
     private initEmbeddedTables;
     private emitLoadImages;
+    /** Parent record id extracted from `data._links.self.href` — the same value every
+     *  VIEW/RELATED_VIEW item on this record shares, used for RELATED_VIEW path construction
+     *  (renderRelatedView) and capability checks (emitCapabilitiesChecks). */
+    private computeParentId;
+    /** Asks, once per VIEW/RELATED_VIEW binding, whether the current user may create a record
+     *  there — the single generic place for this check (TASK-0299/FINDING-0155), so mrd-table,
+     *  mrd-memo-container and mrd-document-container all get the answer the same way: as a plain
+     *  `canCreate`/`mayCreate` prop from this component, computed here and handed down in
+     *  renderTable()/renderMemoContainer()/renderDocumentContainer() — none of the three leaf
+     *  components need to ask on their own when rendered through mrd-layout-section (mrd-table's
+     *  own self-ask only kicks in for standalone use, i.e. its `canCreate` prop left undefined).
+     *
+     *  The route/path variables mirror what each renderer already uses for its own rows —
+     *  `type` = `dataClass`, `refType`/`refId` = `fromClass`/parentId for a RELATED_VIEW, and
+     *  `filterClass` when the view is scoped to one subtype (the same value sent as `?type=` on
+     *  the row fetch). A signature (not just the key) is tracked per binding so a genuine route
+     *  change re-asks and hides again, without re-asking on every unrelated data/items update. */
+    private emitCapabilitiesChecks;
     /** Inject search results. Pass dataClass to target a specific SEARCH item; omit when there is only one. */
     setSearchResults(results: RelationSearchResult[], dataClass?: string): Promise<void>;
     /**
@@ -142,6 +183,12 @@ export declare class MrdLayoutSection {
     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>;
+    /** Host answer to mrdViewCheckCapabilities — whether the current user may create a record
+     *  for the given view's bound route. `name` is the view key from the event detail. Stored in
+     *  canCreateMap and passed down as a plain prop to whichever body is mounted for that key
+     *  (mrd-table, mrd-memo-container or mrd-document-container) — no DOM lookup needed, unlike
+     *  setViewPage/setViewAggregations, since the prop flows through the next render. */
+    setViewCanCreate(name: string, value: boolean): 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
@@ -172,6 +219,11 @@ export declare class MrdLayoutSection {
      *  the card list and the flat table, mirroring renderDocumentContainer(). */
     private renderMemoContainer;
     private renderTable;
+    /** Whether every FIELD/RELATION item following a HEADER (up to the next
+     *  HEADER/SECTION/GROUP or the end of `siblings`) would itself render
+     *  nothing — i.e. the HEADER would introduce an empty block. Other item
+     *  types (VIEW, NAVIGATE, TEXT, ...) always count as visible. */
+    private isHeaderBlockEmpty;
     private renderItem;
     private renderImageModal;
     /** Related VIEW/RELATED_VIEW/SEARCH items to keep rendering below an archetype's

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

@@ -28,6 +28,20 @@ export declare class MrdMemoContainer {
     /** Canonical parent href — set when this is a RELATED_VIEW embedded under a
      *  parent record, which already gives a new memo something to attach to. */
     containerHref: string;
+    /** False when this RELATED_VIEW's parent is related via a relation other than
+     *  the archetype's container slot (e.g. a person's "memos I authored" list,
+     *  related via `author`) — mrd-layout-section resolves this from the item's
+     *  `inverseRelation`. In that case the parent is not a valid container for a
+     *  new memo, and — unlike a top-level VIEW with no context at all — falling
+     *  back to `me` would be wrong too (creating a memo "on myself" from someone
+     *  else's authored-memos list makes no sense), so "New memo" is hidden outright. */
+    containerRelated: boolean;
+    /** True unless this is a container-scoped RELATED_VIEW (a company's own memo
+     *  tab, say) where every card's container is obviously the page you're
+     *  already on — forwarded to mrd-memo-list to show/hide its per-card
+     *  container link. A top-level VIEW or an author-scoped RELATED_VIEW both
+     *  still need it, since the container isn't implied by the page context. */
+    showContainerLink: boolean;
     /** Lookup key used for the embedded `data-view` attribute. */
     viewKey: string;
     locale: string;
@@ -38,6 +52,10 @@ export declare class MrdMemoContainer {
      *  tooltip, cards/rows are not clickable, and the embedded table's own
      *  create action is disabled too. */
     readOnly: boolean;
+    /** Whether the current user may create a memo here — set by mrd-layout-section from its
+     *  generic capability check (TASK-0299/FINDING-0155), the same answer the embedded table
+     *  gets in table mode. Defaults to false (hidden) until confirmed, same as mrd-table. */
+    canCreate: boolean;
     /** The active account's linked person record (userProfile.links.person), if any.
      *  Used both to gate "New memo" (see effectiveContainerHref) and, on submit, to
      *  fill the author slot. */
@@ -53,6 +71,12 @@ export declare class MrdMemoContainer {
         qs: string;
         aggQs: string;
     }>;
+    /** A card's container link was clicked — real navigation, unrelated to the
+     *  quick-edit dialog (mrdEdit is internal, handled by this component itself). */
+    mrdNavigate: EventEmitter<{
+        href?: string;
+        label: string;
+    }>;
     /** Only the embedded table's own toolbar (export, etc.) still routes through this. */
     mrdAction: EventEmitter<{
         action: string;
@@ -124,7 +148,8 @@ export declare class MrdMemoContainer {
     private get hasTitleSlot();
     private get hasImportantSlot();
     /** A parent record already gives a new memo somewhere to attach to (RELATED_VIEW);
-     *  otherwise fall back to the account's own linked person (top-level VIEW). */
+     *  otherwise fall back to the account's own linked person (top-level VIEW) — but
+     *  only when containerRelated allows it (see its doc comment). */
     private get effectiveContainerHref();
     /** The author slot is always filled from `me` (there is no author picker in
      *  the dialog), so without it there is nothing valid to create — regardless

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

@@ -32,6 +32,11 @@ export declare class MrdMemoList {
     /** listItems of the FIELD bound to the `labels` slot, resolved by mrd-layout-section
      *  from its own items array, same reason mrd-memo-view needs it. */
     labelsListItems: ClientListValue[] | null;
+    /** False when the list is already scoped to its own container (a company's own
+     *  memo tab) — showing "belongs to: <this same company>" on every card there
+     *  would be redundant. True everywhere else (top-level VIEW, or a RELATED_VIEW
+     *  scoped by a different relation, e.g. a person's authored-memos list). */
+    showContainerLink: boolean;
     /** Fired when a page needs fetching; same shape as mrd-table's mrdLoadPage minus `qs`'s
      *  column-filter support (cards have no filter UI) — host calls setPage() with the result. */
     mrdLoadPage: EventEmitter<{
@@ -45,6 +50,12 @@ export declare class MrdMemoList {
     mrdEdit: EventEmitter<{
         row: Record<string, unknown>;
     }>;
+    /** The container link on a card was clicked — this is real navigation (to the
+     *  container record), unrelated to mrdEdit. */
+    mrdNavigate: EventEmitter<{
+        href?: string;
+        label: string;
+    }>;
     private rows;
     private loading;
     private exhausted;
@@ -72,6 +83,7 @@ export declare class MrdMemoList {
     private slotLink;
     private plainTextLength;
     private toggleExpanded;
+    private renderContainer;
     private renderLabels;
     private renderBody;
     private renderCard;

package/dist/types/components/table/mrd-table/mrd-table.d.ts

@@ -63,6 +63,13 @@ export declare class MrdTable {
      *  explaining why) so a viewer-role user can see at a glance that this dashboard
      *  is read-only. Sorting, filtering and export stay available — those don't mutate data. */
     readOnly: boolean;
+    /** Whether the current user may create a record for the table's bound route. Leave
+     *  `undefined` for standalone use — the table then asks on its own via mrdCheckCapabilities
+     *  and hides the create button until setCanCreate() answers. Set it explicitly when a host
+     *  already knows the answer (e.g. mrd-layout-section, which asks once per binding and hands
+     *  the answer to whichever body it mounts) — the table then trusts it directly and never
+     *  asks on its own (TASK-0299). */
+    canCreate?: boolean;
     /** Clamp renderEnd when totalElements shrinks (e.g. after a filter is applied).
      *  0 means "unknown" (hosts that rely on minKnownTotal never set it, and some reset it
      *  while a filter is being applied) — clamping to it would collapse the window to a
@@ -70,6 +77,11 @@ export declare class MrdTable {
     totalElementsChanged(newVal: number): void;
     /** Reset to primary view when the item prop is replaced from outside. */
     itemChanged(newVal: ClientLayoutItem | null): void;
+    /** A parent-record navigation can reuse the same `item` reference while only `parentId`
+     *  changes (e.g. clicking a different dossier for the same RELATED_VIEW layout) — itemChanged()
+     *  would not fire for that. Re-ask so a stale canCreate answer from the previous parent never
+     *  leaks into the new one. */
+    parentIdChanged(): void;
     /** Index into allViews[] for the currently displayed view. 0 = primary, 1+ = alternatives. */
     private activeViewIdx;
     loadedPages: Map<number, Record<string, any>[]>;
@@ -116,6 +128,10 @@ export declare class MrdTable {
     private aggregationsPending;
     /** Lower bound on total derived from setPage() hasNext info; grows as pages load. */
     private minKnownTotal;
+    /** Self-asked answer for standalone use (the `canCreate` prop is undefined) — defaults to
+     *  hidden (TASK-0299) until the host answers mrdCheckCapabilities via setCanCreate(). Ignored
+     *  when the host controls `canCreate` directly; see effectiveCanCreate(). */
+    private selfCanCreate;
     /** Fired when a page needs to be fetched. Host fetches and calls setPage().
      *  `sort` is the raw query-param value, e.g. "name" or "name,desc". */
     mrdLoadPage: EventEmitter<{
@@ -160,6 +176,21 @@ export declare class MrdTable {
         qs: string;
         aggQs: string;
     }>;
+    /** Standalone use only (never fires while the `canCreate` prop is set — see there). Fired
+     *  once per table binding (initial load, and whenever the bound item, parent record or active
+     *  view changes) to ask the host whether the current user may create a record here. Carries
+     *  the same route the table already uses for its own rows, unconstructed — VIEW:
+     *  GET /data/{tenant}/{type}/capabilities; RELATED_VIEW: GET /data/{tenant}/{refType}/{refId}/{type}/capabilities.
+     *  `filterClass`, when the view declares one, is the same subtype the row fetch sends as
+     *  `?type=` — e.g. a "contents" RELATED_VIEW filtered to `document` asks specifically whether
+     *  a document may be created here, not any content type.
+     *  The add button stays hidden until the host calls setCanCreate() (FINDING-0155 / TASK-0299). */
+    mrdCheckCapabilities: EventEmitter<{
+        type: string;
+        refType?: string;
+        refId?: string;
+        filterClass?: string;
+    }>;
     componentWillLoad(): void;
     componentDidLoad(): void;
     private applyDefaultSort;
@@ -183,6 +214,12 @@ export declare class MrdTable {
     setPage(pageNumber: number, rows: Record<string, any>[], hasNext?: boolean): Promise<void>;
     /** Inject aggregation totals returned by the /aggregations endpoint. */
     setAggregations(data: AggregationResult): Promise<void>;
+    /** Host answer to mrdCheckCapabilities — whether the current user may create a record for
+     *  the table's currently bound route (standalone use only; ignored while the `canCreate`
+     *  prop is set, since the host controls it directly in that mode). Call it any time after
+     *  the event fires; a stale answer for an old binding is discarded automatically
+     *  (selfCanCreate is reset to false before every new mrdCheckCapabilities emission). */
+    setCanCreate(value: boolean): Promise<void>;
     disconnectedCallback(): void;
     componentDidRender(): void;
     /** Freeze the column widths once the first data page has rendered.
@@ -273,6 +310,12 @@ export declare class MrdTable {
      *  VIEW:         /{dataClass}
      *  RELATED_VIEW: /{fromClass}/{parentId}/{dataClass}  */
     private buildDataPath;
+    /** Asks the host whether creating is allowed for the table's current binding (item, parent
+     *  and active view) — only in standalone use (`canCreate` prop undefined). A host that
+     *  controls `canCreate` directly already knows the answer, so the table never asks on its
+     *  own in that mode. Resets selfCanCreate to false first so the add button stays hidden for
+     *  the new binding until the host answers — it never inherits the previous binding's answer. */
+    private emitCapabilitiesCheck;
     /** Build query params for a page request from current sort, view filters, filterClass and active column filters.
      *
      *  `q` and column filters are mutually exclusive on the backend — combining them breaks
@@ -291,6 +334,8 @@ export declare class MrdTable {
      *  mode must not flip back to the rows prop (and its "no results") while page 0 is in flight. */
     private get isPaginated();
     private get columns();
+    /** `canCreate` when the host controls it directly, else the table's own self-asked answer. */
+    private get effectiveCanCreate();
     private get tableActions();
     private toggleCreatePicker;
     private closeCreatePicker;

package/dist/types/components.d.ts

@@ -156,6 +156,11 @@ export namespace Components {
           * @default navigator.language
          */
         "locale": string;
+        /**
+          * Whether the current user may create a document here — set by mrd-layout-section from its generic capability check (TASK-0299/FINDING-0155), the same answer the embedded table gets in list mode. Named `mayCreate` (not `canCreate`) to avoid colliding with the existing `canCreate` state below, which tracks something unrelated: whether the folder tree currently has a valid drop target selected. Defaults to false (hidden) until confirmed, same as mrd-table.
+          * @default false
+         */
+        "mayCreate": boolean;
         /**
           * Parent record id — required for RELATED_VIEW path building.
           * @default ''
@@ -566,6 +571,10 @@ export namespace Components {
           * Inject aggregation totals into an embedded mrd-table for a VIEW or RELATED_VIEW item.
          */
         "setViewAggregations": (name: string, data: any) => Promise<void>;
+        /**
+          * Host answer to mrdViewCheckCapabilities — whether the current user may create a record for the given view's bound route. `name` is the view key from the event detail. Stored in canCreateMap and passed down as a plain prop to whichever body is mounted for that key (mrd-table, mrd-memo-container or mrd-document-container) — no DOM lookup needed, unlike setViewPage/setViewAggregations, since the prop flows through the next render.
+         */
+        "setViewCanCreate": (name: string, value: boolean) => Promise<void>;
         /**
           * Inject the created document's href after a file-drop create, so the optimistic row becomes navigable (see mrdCreateObject). For a memo quick-create there is no optimistic row to resolve — simply reload the container's current body so the new memo shows up.
          */
@@ -674,11 +683,21 @@ export namespace Components {
           * Resolved `commons.memo` archetype binding.
          */
         "archetype": ClientArchetype;
+        /**
+          * Whether the current user may create a memo here — set by mrd-layout-section from its generic capability check (TASK-0299/FINDING-0155), the same answer the embedded table gets in table mode. Defaults to false (hidden) until confirmed, same as mrd-table.
+          * @default false
+         */
+        "canCreate": boolean;
         /**
           * Canonical parent href — set when this is a RELATED_VIEW embedded under a parent record, which already gives a new memo something to attach to.
           * @default ''
          */
         "containerHref": string;
+        /**
+          * False when this RELATED_VIEW's parent is related via a relation other than the archetype's container slot (e.g. a person's "memos I authored" list, related via `author`) — mrd-layout-section resolves this from the item's `inverseRelation`. In that case the parent is not a valid container for a new memo, and — unlike a top-level VIEW with no context at all — falling back to `me` would be wrong too (creating a memo "on myself" from someone else's authored-memos list makes no sense), so "New memo" is hidden outright.
+          * @default true
+         */
+        "containerRelated": boolean;
         /**
           * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
           * @default null
@@ -712,6 +731,11 @@ export namespace Components {
           * Re-request page 0 of whichever body is currently mounted — called by mrd-layout-section after a successful mrdCreateObject, and by this component itself after an edit to a table row (which has no per-row optimistic-patch method the way mrd-memo-list does).
          */
         "refresh": () => Promise<void>;
+        /**
+          * True unless this is a container-scoped RELATED_VIEW (a company's own memo tab, say) where every card's container is obviously the page you're already on — forwarded to mrd-memo-list to show/hide its per-card container link. A top-level VIEW or an author-scoped RELATED_VIEW both still need it, since the container isn't implied by the page context.
+          * @default true
+         */
+        "showContainerLink": boolean;
         /**
           * Lookup key used for the embedded `data-view` attribute.
           * @default ''
@@ -782,6 +806,11 @@ export namespace Components {
           * Inject the rows for a page (0-based); page 0 replaces, later pages append.
          */
         "setPage": (pageNumber: number, rows: Record<string, unknown>[], hasNext?: boolean) => Promise<void>;
+        /**
+          * False when the list is already scoped to its own container (a company's own memo tab) — showing "belongs to: <this same company>" on every card there would be redundant. True everywhere else (top-level VIEW, or a RELATED_VIEW scoped by a different relation, e.g. a person's authored-memos list).
+          * @default true
+         */
+        "showContainerLink": boolean;
     }
     /**
      * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
@@ -982,6 +1011,10 @@ export namespace Components {
         "value": string;
     }
     interface MrdTable {
+        /**
+          * Whether the current user may create a record for the table's bound route. Leave `undefined` for standalone use — the table then asks on its own via mrdCheckCapabilities and hides the create button until setCanCreate() answers. Set it explicitly when a host already knows the answer (e.g. mrd-layout-section, which asks once per binding and hands the answer to whichever body it mounts) — the table then trusts it directly and never asks on its own (TASK-0299).
+         */
+        "canCreate"?: boolean;
         /**
           * Initialise (or reset) the virtual scroll. Call after setting all props and registering the mrdLoadPage listener, but before calling setPage(0, rows).
          */
@@ -1029,6 +1062,10 @@ export namespace Components {
           * Inject aggregation totals returned by the /aggregations endpoint.
          */
         "setAggregations": (data: AggregationResult) => Promise<void>;
+        /**
+          * Host answer to mrdCheckCapabilities — whether the current user may create a record for the table's currently bound route (standalone use only; ignored while the `canCreate` prop is set, since the host controls it directly in that mode). Call it any time after the event fires; a stale answer for an old binding is discarded automatically (selfCanCreate is reset to false before every new mrdCheckCapabilities emission).
+         */
+        "setCanCreate": (value: boolean) => Promise<void>;
         /**
           * Inject the rows for a given page (0-based). Creates a new Map reference so Stencil detects the state change.  When the page contains fewer rows than pageSize it is the last page. renderEnd is clamped immediately so no loading-placeholder rows appear beyond the actual data — without requiring the host to update totalElements.  Pass hasNext (from _links.next in the API response) for accurate last-page detection even when rows.length === pageSize (exact multiple of page size).
          */
@@ -1623,6 +1660,7 @@ declare global {
         "mrdViewAction": { name: string; action: string; dataClass: string; path?: string; qs?: string; parentPath?: string | null; basicType?: string };
         "mrdLoadViewAggregations": { name: string; dataClass: string; path: string; qs: string; aggQs: string };
         "mrdLoadViewDistinct": { name: string; nodeId: string; distinct: string; path: string; qs: string };
+        "mrdViewCheckCapabilities": { name: string; type: string; refType?: string; refId?: string; filterClass?: string };
         "mrdUpdateObject": { href: string; values: Record<string, unknown> };
         "mrdDeleteObject": { href: string };
         "mrdViewUpload": { name: string; file: File };
@@ -1681,6 +1719,7 @@ declare global {
     interface HTMLMrdMemoContainerElementEventMap {
         "mrdLoadPage": { page: number; sort: string; path: string; qs: string };
         "mrdLoadAggregations": { path: string; qs: string; aggQs: string };
+        "mrdNavigate": { href?: string; label: string };
         "mrdAction": { action: string; path?: string; qs?: string; parentPath?: string | null; basicType?: string };
         "mrdCreateObject": { path: string; values: Record<string, unknown> };
         "mrdUpdateObject": { href: string; values: Record<string, unknown> };
@@ -1719,6 +1758,7 @@ declare global {
     interface HTMLMrdMemoListElementEventMap {
         "mrdLoadPage": { page: number; sort: string; path: string; qs: string };
         "mrdEdit": { row: Record<string, unknown> };
+        "mrdNavigate": { href?: string; label: string };
     }
     /**
      * Card-view body for a `commons.memo` collection — the alternative to the flat
@@ -1862,6 +1902,7 @@ declare global {
         "mrdAction": { action: string; path?: string; qs?: string; dataClass?: string; parentPath?: string | null; basicType?: string };
         "mrdDownload": { href: string; fileName: string };
         "mrdLoadAggregations": { path: string; qs: string; aggQs: string };
+        "mrdCheckCapabilities": { type: string; refType?: string; refId?: string; filterClass?: string };
     }
     interface HTMLMrdTableElement extends Components.MrdTable, HTMLStencilElement {
         addEventListener<K extends keyof HTMLMrdTableElementEventMap>(type: K, listener: (this: HTMLMrdTableElement, ev: MrdTableCustomEvent<HTMLMrdTableElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
@@ -2112,6 +2153,11 @@ declare namespace LocalJSX {
           * @default navigator.language
          */
         "locale"?: string;
+        /**
+          * Whether the current user may create a document here — set by mrd-layout-section from its generic capability check (TASK-0299/FINDING-0155), the same answer the embedded table gets in list mode. Named `mayCreate` (not `canCreate`) to avoid colliding with the existing `canCreate` state below, which tracks something unrelated: whether the folder tree currently has a valid drop target selected. Defaults to false (hidden) until confirmed, same as mrd-table.
+          * @default false
+         */
+        "mayCreate"?: boolean;
         /**
           * A table toolbar action was triggered.
          */
@@ -2642,6 +2688,10 @@ declare namespace LocalJSX {
           * Re-emitted from an embedded mrd-table's mrdAction; host builds the target URL from dataClass.
          */
         "onMrdViewAction"?: (event: MrdLayoutSectionCustomEvent<{ name: string; action: string; dataClass: string; path?: string; qs?: string; parentPath?: string | null; basicType?: string }>) => void;
+        /**
+          * Emitted once per VIEW/RELATED_VIEW binding — computed here directly, not relayed from a child (see emitCapabilitiesChecks()), so it covers mrd-table, mrd-memo-container and mrd-document-container uniformly. `name` is the view key (viewKeyFor(item)) — pass it back to setViewCanCreate() to answer it.
+         */
+        "onMrdViewCheckCapabilities"?: (event: MrdLayoutSectionCustomEvent<{ name: string; type: string; refType?: string; refId?: string; filterClass?: string }>) => void;
         /**
           * An external file was dropped on a document view; host uploads and calls setViewFileReference(name, uri).
          */
@@ -2747,11 +2797,21 @@ declare namespace LocalJSX {
           * Resolved `commons.memo` archetype binding.
          */
         "archetype": ClientArchetype;
+        /**
+          * Whether the current user may create a memo here — set by mrd-layout-section from its generic capability check (TASK-0299/FINDING-0155), the same answer the embedded table gets in table mode. Defaults to false (hidden) until confirmed, same as mrd-table.
+          * @default false
+         */
+        "canCreate"?: boolean;
         /**
           * Canonical parent href — set when this is a RELATED_VIEW embedded under a parent record, which already gives a new memo something to attach to.
           * @default ''
          */
         "containerHref"?: string;
+        /**
+          * False when this RELATED_VIEW's parent is related via a relation other than the archetype's container slot (e.g. a person's "memos I authored" list, related via `author`) — mrd-layout-section resolves this from the item's `inverseRelation`. In that case the parent is not a valid container for a new memo, and — unlike a top-level VIEW with no context at all — falling back to `me` would be wrong too (creating a memo "on myself" from someone else's authored-memos list makes no sense), so "New memo" is hidden outright.
+          * @default true
+         */
+        "containerRelated"?: boolean;
         /**
           * The VIEW or RELATED_VIEW layout item (dataClass, fromClass, view config).
           * @default null
@@ -2785,6 +2845,10 @@ declare namespace LocalJSX {
         "onMrdDeleteObject"?: (event: MrdMemoContainerCustomEvent<{ href: string }>) => void;
         "onMrdLoadAggregations"?: (event: MrdMemoContainerCustomEvent<{ path: string; qs: string; aggQs: string }>) => void;
         "onMrdLoadPage"?: (event: MrdMemoContainerCustomEvent<{ page: number; sort: string; path: string; qs: string }>) => void;
+        /**
+          * A card's container link was clicked — real navigation, unrelated to the quick-edit dialog (mrdEdit is internal, handled by this component itself).
+         */
+        "onMrdNavigate"?: (event: MrdMemoContainerCustomEvent<{ href?: string; label: string }>) => void;
         /**
           * Quick-edit submit. Host PATCHes `href` with `values`, same as mrd-document-list's drag-move.
          */
@@ -2799,6 +2863,11 @@ declare namespace LocalJSX {
           * @default false
          */
         "readOnly"?: boolean;
+        /**
+          * True unless this is a container-scoped RELATED_VIEW (a company's own memo tab, say) where every card's container is obviously the page you're already on — forwarded to mrd-memo-list to show/hide its per-card container link. A top-level VIEW or an author-scoped RELATED_VIEW both still need it, since the container isn't implied by the page context.
+          * @default true
+         */
+        "showContainerLink"?: boolean;
         /**
           * Lookup key used for the embedded `data-view` attribute.
           * @default ''
@@ -2846,6 +2915,10 @@ declare namespace LocalJSX {
           * Fired when a page needs fetching; same shape as mrd-table's mrdLoadPage minus `qs`'s column-filter support (cards have no filter UI) — host calls setPage() with the result.
          */
         "onMrdLoadPage"?: (event: MrdMemoListCustomEvent<{ page: number; sort: string; path: string; qs: string }>) => void;
+        /**
+          * The container link on a card was clicked — this is real navigation (to the container record), unrelated to mrdEdit.
+         */
+        "onMrdNavigate"?: (event: MrdMemoListCustomEvent<{ href?: string; label: string }>) => void;
         /**
           * Records per page (must match API page size).
           * @default 20
@@ -2861,6 +2934,11 @@ declare namespace LocalJSX {
           * @default false
          */
         "readOnly"?: boolean;
+        /**
+          * False when the list is already scoped to its own container (a company's own memo tab) — showing "belongs to: <this same company>" on every card there would be redundant. True everywhere else (top-level VIEW, or a RELATED_VIEW scoped by a different relation, e.g. a person's authored-memos list).
+          * @default true
+         */
+        "showContainerLink"?: boolean;
     }
     /**
      * Archetype-driven single-memo view. Given a `commons.memo` binding and a data
@@ -3067,6 +3145,10 @@ declare namespace LocalJSX {
         "value"?: string;
     }
     interface MrdTable {
+        /**
+          * Whether the current user may create a record for the table's bound route. Leave `undefined` for standalone use — the table then asks on its own via mrdCheckCapabilities and hides the create button until setCanCreate() answers. Set it explicitly when a host already knows the answer (e.g. mrd-layout-section, which asks once per binding and hands the answer to whichever body it mounts) — the table then trusts it directly and never asks on its own (TASK-0299).
+         */
+        "canCreate"?: boolean;
         /**
           * The VIEW or RELATED_VIEW layout item. Contains view config, dataClass, fromClass, actions etc.
           * @default null
@@ -3080,6 +3162,10 @@ declare namespace LocalJSX {
           * Fired when a toolbar action button is clicked. For 'export': includes `path` (relative excel path) and `qs` (current sort+filter params). For 'create': includes `dataClass` (target type) and `parentPath` (e.g. /buyers/123 for RELATED_VIEW).
          */
         "onMrdAction"?: (event: MrdTableCustomEvent<{ action: string; path?: string; qs?: string; dataClass?: string; parentPath?: string | null; basicType?: string }>) => void;
+        /**
+          * Standalone use only (never fires while the `canCreate` prop is set — see there). Fired once per table binding (initial load, and whenever the bound item, parent record or active view changes) to ask the host whether the current user may create a record here. Carries the same route the table already uses for its own rows, unconstructed — VIEW: GET /data/{tenant}/{type}/capabilities; RELATED_VIEW: GET /data/{tenant}/{refType}/{refId}/{type}/capabilities. `filterClass`, when the view declares one, is the same subtype the row fetch sends as `?type=` — e.g. a "contents" RELATED_VIEW filtered to `document` asks specifically whether a document may be created here, not any content type. The add button stays hidden until the host calls setCanCreate() (FINDING-0155 / TASK-0299).
+         */
+        "onMrdCheckCapabilities"?: (event: MrdTableCustomEvent<{ type: string; refType?: string; refId?: string; filterClass?: string }>) => void;
         /**
           * Fired when a FILE or IMAGE cell is clicked. Host resolves the href to a signed download URL.
          */
@@ -3277,6 +3363,7 @@ declare namespace LocalJSX {
         "height": number;
         "locale": string;
         "readOnly": boolean;
+        "mayCreate": boolean;
     }
     interface MrdDocumentListAttributes {
         "parentId": string;
@@ -3366,15 +3453,19 @@ declare namespace LocalJSX {
     interface MrdMemoContainerAttributes {
         "parentId": string;
         "containerHref": string;
+        "containerRelated": boolean;
+        "showContainerLink": boolean;
         "viewKey": string;
         "locale": string;
         "readOnly": boolean;
+        "canCreate": boolean;
     }
     interface MrdMemoListAttributes {
         "parentId": string;
         "pageSize": number;
         "locale": string;
         "readOnly": boolean;
+        "showContainerLink": boolean;
     }
     interface MrdMemoViewAttributes {
         "locale": string;
@@ -3429,6 +3520,7 @@ declare namespace LocalJSX {
         "tableHeight": number;
         "requestTimeoutMs": number;
         "readOnly": boolean;
+        "canCreate": boolean;
     }
     interface MrdTextFieldAttributes {
         "name": string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmlogic/components",
-  "version": "0.5.15",
+  "version": "0.5.17",
   "description": "Stencil.js web component library for dynamic forms and virtual-scroll data tables",
   "license": "MIT",
   "author": "Mosterd",