mn-angular-lib 1.0.155 → 1.0.157

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "mn-angular-lib",
-  "version": "1.0.155",
+  "version": "1.0.157",
   "peerDependencies": {
     "@angular/common": "^21.1.3",
     "@angular/core": "^21.1.3",
+    "@angular/router": "^21.1.3",
     "@lucide/angular": "^1.18.0",
     "quill": "^2.0.3"
   },

package/types/mn-angular-lib.d.ts

@@ -6709,6 +6709,16 @@ type FormFieldView<TModel> = FormFieldConfig<TModel> & {
 };
 declare class MnFormBodyComponent<TModel = unknown, TResult = TModel> implements OnInit, OnDestroy, AfterViewInit {
     private fb;
+    /**
+     * Change detector used to announce state this component mutates outside an Angular
+     * event handler — after an `await`, or from an RxJS subscription. Consuming apps run
+     * zoneless, where such a write notifies nothing: the view is never marked dirty, so it
+     * keeps rendering the stale value and `checkNoChanges` then reports it as NG0100
+     * (e.g. the submit button staying disabled on "Submitting..." after a failed submit).
+     * Every async mutation of {@link isSubmitting}, {@link fieldLoading}, {@link fieldOptions}
+     * and {@link formErrors} must be followed by `markForCheck()`.
+     */
+    private readonly cdr;
     config: FormModalConfig<TModel, TResult>;
     modalRef: MnModalRef<TResult>;
     hideFooter: boolean;
@@ -7473,6 +7483,7 @@ declare class CalendarViewComponent implements OnInit, OnDestroy {
     private readonly mnConfigRef;
     private readonly destroyRef;
     private readonly lang;
+    private readonly cdr;
     constructor();
     onResize(): void;
     ngOnInit(): void;
@@ -7678,6 +7689,7 @@ declare class CalendarDayComponent implements OnInit, OnDestroy {
  */
 declare class CalendarMonthComponent implements OnInit, OnDestroy {
     private readonly lang;
+    private readonly cdr;
     /**
      * Accessible name for this control. Resolved through the conventional
      * `mnCalendar.monthView` key so an app can translate it, falling back to English when the
@@ -7772,6 +7784,7 @@ declare class CalendarEventDefaultComponent implements CalendarEventData, OnInit
  */
 declare class UpcomingEventsComponent implements OnInit, OnChanges, OnDestroy {
     private readonly lang;
+    private readonly cdr;
     /**
      * Accessible name for this control. Resolved through the conventional
      * `mnCalendar.upcomingEvents` key so an app can translate it, falling back to English when the
@@ -7963,6 +7976,17 @@ declare class CalendarUtility {
 type MnTabItem = {
     /** Translation key or label text for the tab. */
     label: string;
+    /**
+     * Stable value this tab is written as in the URL while the tab bar mirrors
+     * its selection there (see {@link MnTabDataSource.urlParam}).
+     *
+     * Defaults to a slug of the last segment of {@link label}
+     * (`matches.hub.tab.entrants` → `entrants`, `members.tabMembers` →
+     * `tab-members`). Set it when that slug is not the URL you want to hand out,
+     * or when the label key may be renamed — a shared link is only as stable as
+     * the value in it.
+     */
+    id?: string;
     /** Callback invoked when this tab becomes active. */
     onClick?: () => void;
     /** Callback invoked when this tab is deactivated. */
@@ -7990,13 +8014,59 @@ type MnTabDataSource = {
      * (e.g. tabs that depend on data being fetched) to predict the final count.
      */
     skeletonCount?: number;
+    /**
+     * Query parameter the active tab is mirrored in, so a reload or a shared
+     * link lands on the tab the user was looking at. Defaults to `'tab'`; pass
+     * `false` to keep this tab bar out of the URL.
+     *
+     * Each tab bar that can be on screen at the same time as another needs its
+     * own parameter name — two bars sharing one name fight over it. Turn it off
+     * for a tab bar whose selection is not worth sharing, such as one inside a
+     * modal, which would otherwise write to the URL of the page behind it.
+     *
+     * Only user selections are written, so a page nobody has clicked a tab on
+     * keeps a clean URL and falls back to {@link defaultActive}. Restoring a tab
+     * from the URL runs that tab's {@link MnTabItem.onClick} and emits
+     * `activeChange`, so a consumer tracking the active tab itself hears about
+     * the restored one.
+     */
+    urlParam?: string | false;
 };
 
 /**
  * Tab component that renders a horizontal tab bar.
  * Supports translation keys for labels via MnTranslatePipe.
+ *
+ * The active tab is mirrored in the URL query string by default, so a reload,
+ * a back button or a shared link lands on the same tab; see
+ * {@link MnTabDataSource.urlParam} to rename that parameter or switch it off.
  */
 declare class MnTabComponent implements DoCheck, AfterViewInit, OnDestroy {
+    /**
+     * Router the active tab is written to. Optional: a tab bar used outside a
+     * routed application still works, it just has no URL to mirror into.
+     */
+    private readonly router;
+    /** Route the tab value is read back from; absent for the same reason as {@link router}. */
+    private readonly route;
+    /** Watches the URL so a deep link, a back button or an in-app link moves the tab bar. */
+    private readonly queryParamsSub?;
+    /**
+     * URL keys of the current items, memoised on the items array so a slug is
+     * computed once per tab set rather than on every change-detection pass.
+     */
+    private urlKeyCache?;
+    /** URL key of {@link currentActive}, so a rebuilt tab set can be recognised as the same tab. */
+    private currentKey?;
+    /**
+     * Key of a selection whose URL write has not landed yet. Navigation is
+     * asynchronous, so a consumer that rebuilds its tabs in response to the click
+     * can be resolved against a URL that still names the previous tab; until the
+     * write completes, this is the truth about what the user picked.
+     */
+    private pendingKey?;
+    /** Set on destroy so a deferred restore can't announce a tab nobody is showing. */
+    private destroyed;
     /** The horizontally-scrolling wrapper the edge fade is painted onto. */
     private scrollContainer?;
     /** The tab row; queried for the active tab so the indicator can measure it. */
@@ -8054,6 +8124,7 @@ declare class MnTabComponent implements DoCheck, AfterViewInit, OnDestroy {
      * otherwise the number of known items, falling back to a default when none.
      */
     get skeletonTabs(): number[];
+    constructor();
     /**
      * Re-resolves the active tab on every change-detection pass.
      *
@@ -8080,10 +8151,19 @@ declare class MnTabComponent implements DoCheck, AfterViewInit, OnDestroy {
      */
     updateEdgeFades(): void;
     /**
-     * Sets the given tab item as active, invoking deactivate/activate callbacks.
+     * Sets the given tab item as active, invoking deactivate/activate callbacks,
+     * and records the selection in the URL so it survives a reload or a share.
      * @param item - The tab item to activate.
      */
     setActive(item: MnTabItem): void;
+    /**
+     * Moves the selection to `item` and tells the consumer about it: the
+     * deactivate/activate/emit sequence a click produces, shared by the click
+     * path and the URL-driven ones (deep link, back button), which owe the
+     * consumer the same notifications.
+     * @param item - The tab item to activate.
+     */
+    private activate;
     /**
      * Marks a click-driven slide as in progress and schedules the guard to lift
      * once the transition has finished. A timeout (not `transitionend`) so the
@@ -8111,10 +8191,54 @@ declare class MnTabComponent implements DoCheck, AfterViewInit, OnDestroy {
     getBadge(item: MnTabItem): number | undefined;
     /**
      * Ensures {@link currentActive} references a tab that still exists in the data
-     * source, falling back to the configured default tab when the current
-     * selection is missing or stale (e.g. after the items array is replaced).
+     * source, preferring the tab named in the URL and falling back to the
+     * configured default tab when the current selection is missing or stale
+     * (e.g. after the items array is replaced).
      */
     private syncActiveTab;
+    /**
+     * Records `item` as the selection, remembering its URL key so the same tab is
+     * recognised after the consumer rebuilds the items array.
+     * @param item - The newly selected tab.
+     */
+    private select;
+    /**
+     * Runs the restored tab's callbacks a change-detection pass later, unless the
+     * selection moved on in the meantime (a click, or another tab set arriving).
+     * @param item - The tab restored from the URL.
+     */
+    private announceRestored;
+    /**
+     * Activates the tab a URL value names, when it is not the tab already on
+     * screen. Values naming no known tab are ignored: another tab bar on the page
+     * may own that parameter, and a stale link should leave the default standing.
+     * @param key - The value read from the query parameter, if any.
+     */
+    private activateUrlKey;
+    /**
+     * The query parameter this tab bar mirrors into, or undefined when there is
+     * nothing to mirror into (no router) or the consumer switched it off.
+     */
+    private urlParam;
+    /**
+     * The tab the current URL asks for, if it names one of `items`.
+     * @param items - The tab set to resolve the URL value against.
+     */
+    private itemFromUrl;
+    /**
+     * Records the active tab in the query string, replacing the current history
+     * entry: switching tabs is not a navigation to walk back through, and back
+     * should leave the page rather than retrace its tabs.
+     * @param item - The tab that just became active.
+     */
+    private writeUrl;
+    /**
+     * The URL key of every tab, in item order: the item's `id`, else a slug of
+     * its label. Repeats are numbered so each tab still round-trips through the
+     * URL; give such tabs an explicit `id` to choose the value yourself.
+     * @param items - The tab set to key.
+     */
+    private urlKeys;
     static ɵfac: i0.ɵɵFactoryDeclaration<MnTabComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MnTabComponent, "mn-tab", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "justified": { "alias": "justified"; "required": false; }; }, { "activeChange": "activeChange"; }, never, never, true, never>;
 }