@theseam/ui-common 0.4.26 → 0.4.28-beta.0

package/esm2020/framework/nav/nav-utils.mjs

@@ -0,0 +1,107 @@
+import { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils';
+export function isHorizontalNavItemType(item, type) {
+    return item.itemType === type;
+}
+export function isHorizontalNavItemActive(item) {
+    return item.__state?.active ?? false;
+}
+export function isHorizontalNavItemExpanded(item) {
+    return item.__state?.expanded ?? false;
+}
+export function isHorizontalNavItemFocused(item) {
+    return item.__state?.focused ?? false;
+}
+export function horizontalNavItemHasChildren(item) {
+    return horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children') && item.children.length > 0;
+}
+export function horizontalNavItemCanHaveChildren(item) {
+    return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link');
+}
+export function horizontalNavItemHasActiveChild(item) {
+    if (!horizontalNavItemHasChildren(item)) {
+        return false;
+    }
+    for (const child of item.children) {
+        if (getHorizontalNavItemStateProp(child, 'active') || horizontalNavItemHasActiveChild(child)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function horizontalNavItemHasExpandedChild(item) {
+    if (!horizontalNavItemHasChildren(item)) {
+        return false;
+    }
+    for (const child of item.children) {
+        if (getHorizontalNavItemStateProp(child, 'expanded')) {
+            return true;
+        }
+    }
+    return false;
+}
+export function horizontalNavItemCanBeActive(item) {
+    return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link');
+}
+export function horizontalNavItemCanExpand(item) {
+    return horizontalNavItemCanHaveChildren(item);
+}
+export function findHorizontalNavLinkItems(items) {
+    const linkItems = [];
+    const _fn = (_items) => {
+        for (const item of _items) {
+            if (isHorizontalNavItemType(item, 'link')) {
+                linkItems.push(item);
+            }
+            if (horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children')) {
+                _fn(item.children);
+            }
+        }
+    };
+    _fn(items);
+    return linkItems;
+}
+export function setHorizontalNavItemStateProp(item, prop, value) {
+    if (hasProperty(item, '__state')) {
+        item.__state[prop] = value;
+    }
+}
+export function getHorizontalNavItemStateProp(item, prop) {
+    return setDefaultHorizontalNavItemState(item).__state[prop];
+}
+export function setDefaultHorizontalNavItemState(item) {
+    if (hasProperty(item, '__state')) {
+        return item;
+    }
+    item.__state = {
+        active: false,
+        expanded: false,
+        focused: false
+    };
+    // TODO: See if there is a nice way to fix the typing for this.
+    return item;
+}
+export function areSameHorizontalNavItem(item1, item2) {
+    if (isNullOrUndefined(item1) || isNullOrUndefined(item2)) {
+        return false;
+    }
+    if (item1.itemType !== item2.itemType) {
+        return false;
+    }
+    if (isHorizontalNavItemType(item1, 'title') && isHorizontalNavItemType(item2, 'title')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'divider') && isHorizontalNavItemType(item2, 'divider')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'basic') && isHorizontalNavItemType(item2, 'basic')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'link') && isHorizontalNavItemType(item2, 'link')) {
+        return item1.label === item2.label && item1.link === item2.link;
+    }
+    else if (isHorizontalNavItemType(item1, 'button') && isHorizontalNavItemType(item2, 'button')) {
+        return item1.onClick === item2.onClick;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-utils.js","sourceRoot":"","sources":["../../../../../projects/ui-common/framework/nav/nav-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport {\n  INavBasic,\n  INavButton,\n  INavDivider,\n  INavItem,\n  INavItemState,\n  INavLink,\n  INavTitle,\n  NavItemCanHaveChildren,\n  NavItemCanHaveState\n} from './nav.models'\n\nexport function isHorizontalNavItemType(item: INavItem, type: 'title'): item is INavTitle\nexport function isHorizontalNavItemType(item: INavItem, type: 'divider'): item is INavDivider\nexport function isHorizontalNavItemType(item: INavItem, type: 'basic'): item is INavBasic\nexport function isHorizontalNavItemType(item: INavItem, type: 'link'): item is INavLink\nexport function isHorizontalNavItemType(item: INavItem, type: 'button'): item is INavButton\nexport function isHorizontalNavItemType(item: INavItem, type: string): item is INavItem {\n  return item.itemType === type\n}\n\nexport function isHorizontalNavItemActive(item: INavItem): boolean {\n  return item.__state?.active ?? false\n}\n\nexport function isHorizontalNavItemExpanded(item: INavItem): boolean {\n  return item.__state?.expanded ?? false\n}\n\nexport function isHorizontalNavItemFocused(item: INavItem): boolean {\n  return item.__state?.focused ?? false\n}\n\nexport function horizontalNavItemHasChildren(item: INavItem): item is (INavBasic | INavLink) & Required<NavItemCanHaveChildren> {\n  return horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children') && item.children.length > 0\n}\n\nexport function horizontalNavItemCanHaveChildren(item: INavItem): item is (INavBasic | INavLink) {\n  return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link')\n}\n\nexport function horizontalNavItemHasActiveChild(item: INavItem): boolean {\n  if (!horizontalNavItemHasChildren(item)) {\n    return false\n  }\n\n  for (const child of item.children) {\n    if (getHorizontalNavItemStateProp(child, 'active') || horizontalNavItemHasActiveChild(child)) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport function horizontalNavItemHasExpandedChild(item: INavItem): boolean {\n  if (!horizontalNavItemHasChildren(item)) {\n    return false\n  }\n\n  for (const child of item.children) {\n    if (getHorizontalNavItemStateProp(child, 'expanded')) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport function horizontalNavItemCanBeActive(item: INavItem): item is (INavBasic | INavLink) {\n  return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link')\n}\n\nexport function horizontalNavItemCanExpand(item: INavItem): item is (INavBasic | INavLink) {\n  return horizontalNavItemCanHaveChildren(item)\n}\n\nexport function findHorizontalNavLinkItems(items: INavItem[]): INavLink[] {\n  const linkItems: INavLink[] = []\n\n  const _fn = (_items: INavItem[]) => {\n    for (const item of _items) {\n      if (isHorizontalNavItemType(item, 'link')) {\n        linkItems.push(item)\n      }\n      if (horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children')) {\n        _fn(item.children)\n      }\n    }\n  }\n  _fn(items)\n\n  return linkItems\n}\n\nexport function setHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K, value: INavItemState[K]): void {\n  if (hasProperty(item, '__state')) {\n    item.__state[prop] = value\n  }\n}\n\nexport function getHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K): INavItemState[K] {\n  return setDefaultHorizontalNavItemState(item).__state[prop]\n}\n\nexport function setDefaultHorizontalNavItemState(item: INavItem): INavItem & Required<NavItemCanHaveState> {\n  if (hasProperty(item, '__state')) {\n    return item\n  }\n\n  item.__state = {\n    active: false,\n    expanded: false,\n    focused: false\n  } as INavItemState\n\n  // TODO: See if there is a nice way to fix the typing for this.\n  return item as any\n}\n\nexport function areSameHorizontalNavItem(item1: INavItem | undefined, item2: INavItem | undefined): boolean {\n  if (isNullOrUndefined(item1) || isNullOrUndefined(item2)) {\n    return false\n  }\n\n  if (item1.itemType !== item2.itemType) {\n    return false\n  }\n\n  if (isHorizontalNavItemType(item1, 'title') && isHorizontalNavItemType(item2, 'title')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'divider') && isHorizontalNavItemType(item2, 'divider')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'basic') && isHorizontalNavItemType(item2, 'basic')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'link') && isHorizontalNavItemType(item2, 'link')) {\n    return item1.label === item2.label && item1.link === item2.link\n  } else if (isHorizontalNavItemType(item1, 'button') && isHorizontalNavItemType(item2, 'button')) {\n    return item1.onClick === item2.onClick\n  }\n\n  return false\n}\n"]}

package/esm2020/framework/nav/nav.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/framework/nav/nav.module.mjs

@@ -0,0 +1,67 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { NgbTooltipModule } from '@ng-bootstrap/ng-bootstrap';
+import { TheSeamIconModule } from '@theseam/ui-common/icon';
+import { TheSeamLayoutModule } from '@theseam/ui-common/layout';
+import { TheSeamMenuModule } from '@theseam/ui-common/menu';
+import { TheSeamScrollbarModule } from '@theseam/ui-common/scrollbar';
+import { HorizontalNavComponent } from './horizontal-nav/horizontal-nav.component';
+import { NavItemComponent } from './nav-item/nav-item.component';
+import { TheSeamNavService } from './nav.service';
+import * as i0 from "@angular/core";
+export class TheSeamNavModule {
+}
+TheSeamNavModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamNavModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavModule, declarations: [NavItemComponent,
+        HorizontalNavComponent], imports: [CommonModule,
+        RouterModule,
+        TheSeamIconModule,
+        A11yModule,
+        TheSeamScrollbarModule,
+        TheSeamLayoutModule,
+        NgbTooltipModule,
+        PortalModule,
+        TheSeamMenuModule], exports: [NavItemComponent,
+        HorizontalNavComponent] });
+TheSeamNavModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavModule, providers: [
+        TheSeamNavService,
+    ], imports: [CommonModule,
+        RouterModule,
+        TheSeamIconModule,
+        A11yModule,
+        TheSeamScrollbarModule,
+        TheSeamLayoutModule,
+        NgbTooltipModule,
+        PortalModule,
+        TheSeamMenuModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        NavItemComponent,
+                        HorizontalNavComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        RouterModule,
+                        TheSeamIconModule,
+                        A11yModule,
+                        TheSeamScrollbarModule,
+                        TheSeamLayoutModule,
+                        NgbTooltipModule,
+                        PortalModule,
+                        TheSeamMenuModule
+                    ],
+                    exports: [
+                        NavItemComponent,
+                        HorizontalNavComponent,
+                    ],
+                    providers: [
+                        TheSeamNavService,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/framework/nav/nav.service.mjs

@@ -0,0 +1,204 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { BehaviorSubject, defer, Observable, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, shareReplay, startWith, switchMap } from 'rxjs/operators';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { areSameHorizontalNavItem, getHorizontalNavItemStateProp, horizontalNavItemCanExpand, horizontalNavItemHasActiveChild, horizontalNavItemHasChildren, horizontalNavItemHasExpandedChild, isHorizontalNavItemActive, isHorizontalNavItemType, setDefaultHorizontalNavItemState, setHorizontalNavItemStateProp } from './nav-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class TheSeamNavService {
+    constructor(_router) {
+        this._router = _router;
+        this._updatingCount = new BehaviorSubject(0);
+        this.itemChanged = new Subject();
+        this.loading$ = this._updatingCount.pipe(map(count => count > 0), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    createItemsObservable(items) {
+        return defer(() => {
+            this.updateItemsStates(items);
+            this.updateRouterFocusedItem(items);
+            return new Observable((subscriber) => {
+                const stateChangeSub = this.itemChanged.pipe(switchMap(change => {
+                    if (change.prop === 'focused' && change.newValue) {
+                        this.updateFocusedItem(items, change.item);
+                    }
+                    return this.loading$.pipe(filter(loading => !loading));
+                })).subscribe(() => {
+                    subscriber.next(items);
+                });
+                try {
+                    this.updateItemsStates(items);
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+                const routeChangeSub = this._router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe(event => {
+                    try {
+                        this.updateItemsStates(items);
+                        this.updateRouterFocusedItem(items);
+                    }
+                    catch (err) {
+                        subscriber.error(err);
+                    }
+                });
+                return () => {
+                    stateChangeSub.unsubscribe();
+                    routeChangeSub.unsubscribe();
+                };
+            }).pipe(startWith(items));
+        });
+    }
+    _incUpdatingCount() {
+        this._updatingCount.next(this._updatingCount.value + 1);
+    }
+    _decrUpdatingCount() {
+        this._updatingCount.next(this._updatingCount.value - 1);
+    }
+    updateItemsStates(items) {
+        this._incUpdatingCount();
+        try {
+            for (const item of items) {
+                if (horizontalNavItemHasChildren(item)) {
+                    this.updateItemsStates(item.children);
+                }
+                this.updateItemState(item);
+            }
+            this._decrUpdatingCount();
+        }
+        catch (err) {
+            this._decrUpdatingCount();
+            throw err;
+        }
+    }
+    updateItemState(item) {
+        this._incUpdatingCount();
+        try {
+            setDefaultHorizontalNavItemState(item);
+            this.setItemStateProp(item, 'active', this.horizontalNavLinkActive(item));
+            // TODO: Implement this in a more optimized way. Unless our apps start
+            // having large navs constantly updating their state, this shouldn't
+            // have much impact on performance.
+            this._updateItemExpandedState(item);
+            this._decrUpdatingCount();
+        }
+        catch (err) {
+            this._decrUpdatingCount();
+            throw err;
+        }
+    }
+    horizontalNavLinkActive(item) {
+        if (isHorizontalNavItemType(item, 'link')) {
+            const url = this._getUrl(item);
+            if (notNullOrUndefined(url)) {
+                const opts = this._getMatchOptions(item);
+                return this._router.isActive(url, opts);
+            }
+        }
+        return false;
+    }
+    _updateItemsExpandedState(items) {
+        for (const item of items) {
+            if (horizontalNavItemHasChildren(item)) {
+                this._updateItemsExpandedState(item.children);
+            }
+            this._updateItemExpandedState(item);
+        }
+    }
+    _updateItemExpandedState(item) {
+        if (!horizontalNavItemCanExpand(item)) {
+            if (getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', false);
+            }
+            return;
+        }
+        if (horizontalNavItemHasChildren(item)) {
+            this._updateItemsExpandedState(item.children);
+        }
+        if (horizontalNavItemHasActiveChild(item) || horizontalNavItemHasExpandedChild(item)) {
+            if (!getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', true);
+            }
+        }
+        else {
+            if (getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', false);
+            }
+        }
+    }
+    updateRouterFocusedItem(items) {
+        const focusedItem = items.find(i => isHorizontalNavItemActive(i)) || items.find(i => horizontalNavItemHasActiveChild(i));
+        if (notNullOrUndefined(focusedItem)) {
+            this.updateFocusedItem(items, focusedItem);
+        }
+    }
+    updateFocusedItem(items, focusedItem) {
+        for (const item of items) {
+            if (areSameHorizontalNavItem(item, focusedItem)) {
+                setHorizontalNavItemStateProp(item, 'focused', true);
+            }
+            else {
+                setHorizontalNavItemStateProp(item, 'focused', false);
+            }
+        }
+    }
+    _getNavExtras(item) {
+        const navigationExtras = {};
+        if (hasProperty(item, 'queryParams')) {
+            navigationExtras.queryParams = item.queryParams;
+        }
+        if (hasProperty(item, 'fragment')) {
+            navigationExtras.fragment = item.fragment;
+        }
+        if (hasProperty(item, 'queryParamsHandling')) {
+            navigationExtras.queryParamsHandling = item.queryParamsHandling;
+        }
+        if (hasProperty(item, 'preserveFragment')) {
+            navigationExtras.preserveFragment = item.preserveFragment;
+        }
+        return navigationExtras;
+    }
+    _getUrl(item) {
+        const link = item.link;
+        if (typeof link === 'string') {
+            return this._router.createUrlTree([link], this._getNavExtras(item)).toString();
+        }
+        else if (Array.isArray(link)) {
+            return this._router.createUrlTree(link, this._getNavExtras(item)).toString();
+        }
+        return null;
+    }
+    _getMatchOptions(item) {
+        const defaultMatchOpts = {
+            paths: 'subset',
+            queryParams: 'subset',
+            fragment: 'ignored',
+            matrixParams: 'ignored'
+        };
+        if (hasProperty(item, 'matchOptions')) {
+            return {
+                ...defaultMatchOpts,
+                ...item.matchOptions
+            };
+        }
+        return defaultMatchOpts;
+    }
+    setItemStateProp(item, prop, value) {
+        const currentValue = getHorizontalNavItemStateProp(item, prop);
+        if (currentValue !== value) {
+            setHorizontalNavItemStateProp(item, prop, value);
+            const changed = {
+                item,
+                prop,
+                prevValue: currentValue,
+                newValue: value
+            };
+            this.itemChanged.next(changed);
+        }
+    }
+}
+TheSeamNavService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+TheSeamNavService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamNavService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/framework/nav/nav.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { IsActiveMatchOptions, NavigationEnd, Router, UrlCreationOptions } from '@angular/router'\nimport { BehaviorSubject, defer, Observable, Subject, Subscriber } from 'rxjs'\nimport { distinctUntilChanged, filter, map, shareReplay, startWith, switchMap } from 'rxjs/operators'\n\nimport { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport {\n  areSameHorizontalNavItem,\n  getHorizontalNavItemStateProp,\n  horizontalNavItemCanExpand,\n  horizontalNavItemHasActiveChild,\n  horizontalNavItemHasChildren,\n  horizontalNavItemHasExpandedChild,\n  isHorizontalNavItemActive,\n  isHorizontalNavItemType,\n  setDefaultHorizontalNavItemState,\n  setHorizontalNavItemStateProp\n} from './nav-utils'\nimport { INavItem, INavItemState, INavLink, NavItemStateChanged } from './nav.models'\n\n@Injectable()\nexport class TheSeamNavService {\n\n  private readonly _updatingCount = new BehaviorSubject<number>(0)\n\n  public readonly loading$: Observable<boolean>\n\n  public readonly itemChanged = new Subject<NavItemStateChanged>()\n\n  constructor(\n    private readonly _router: Router\n  ) {\n    this.loading$ = this._updatingCount.pipe(\n      map(count => count > 0),\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  public createItemsObservable(items: INavItem[]): Observable<INavItem[]> {\n    return defer(() => {\n      this.updateItemsStates(items)\n      this.updateRouterFocusedItem(items)\n      return new Observable((subscriber: Subscriber<INavItem[]>) => {\n        const stateChangeSub = this.itemChanged.pipe(\n          switchMap(change => {\n            if (change.prop === 'focused' && change.newValue) {\n              this.updateFocusedItem(items, change.item)\n            }\n            return this.loading$.pipe(filter(loading => !loading))\n          })\n        ).subscribe(() => {\n          subscriber.next(items)\n        })\n\n        try {\n          this.updateItemsStates(items)\n        } catch (err) {\n          subscriber.error(err)\n        }\n\n        const routeChangeSub = this._router.events.pipe(\n          filter(event => event instanceof NavigationEnd),\n        ).subscribe(event => {\n          try {\n            this.updateItemsStates(items)\n            this.updateRouterFocusedItem(items)\n          } catch (err) {\n            subscriber.error(err)\n          }\n        })\n\n        return () => {\n          stateChangeSub.unsubscribe()\n          routeChangeSub.unsubscribe()\n        }\n      }).pipe(startWith(items))\n    })\n  }\n\n  private _incUpdatingCount(): void {\n    this._updatingCount.next(this._updatingCount.value + 1)\n  }\n\n  private _decrUpdatingCount(): void {\n    this._updatingCount.next(this._updatingCount.value - 1)\n  }\n\n  public updateItemsStates(items: INavItem[]): void {\n    this._incUpdatingCount()\n\n    try {\n      for (const item of items) {\n        if (horizontalNavItemHasChildren(item)) {\n          this.updateItemsStates(item.children)\n        }\n\n        this.updateItemState(item)\n      }\n\n      this._decrUpdatingCount()\n    } catch (err) {\n      this._decrUpdatingCount()\n      throw err\n    }\n  }\n\n  public updateItemState(item: INavItem): void {\n    this._incUpdatingCount()\n\n    try {\n      setDefaultHorizontalNavItemState(item)\n\n      this.setItemStateProp(item, 'active', this.horizontalNavLinkActive(item))\n\n      // TODO: Implement this in a more optimized way. Unless our apps start\n      // having large navs constantly updating their state, this shouldn't\n      // have much impact on performance.\n      this._updateItemExpandedState(item)\n\n      this._decrUpdatingCount()\n    } catch (err) {\n      this._decrUpdatingCount()\n      throw err\n    }\n  }\n\n  public horizontalNavLinkActive(item: INavItem): boolean {\n    if (isHorizontalNavItemType(item, 'link')) {\n      const url = this._getUrl(item)\n      if (notNullOrUndefined(url)) {\n        const opts = this._getMatchOptions(item)\n        return this._router.isActive(url, opts)\n      }\n    }\n    return false\n  }\n\n  private _updateItemsExpandedState(items: INavItem[]): void {\n    for (const item of items) {\n      if (horizontalNavItemHasChildren(item)) {\n        this._updateItemsExpandedState(item.children)\n      }\n      this._updateItemExpandedState(item)\n    }\n  }\n\n  private _updateItemExpandedState(item: INavItem): void {\n    if (!horizontalNavItemCanExpand(item)) {\n      if (getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', false)\n      }\n      return\n    }\n\n    if (horizontalNavItemHasChildren(item)) {\n      this._updateItemsExpandedState(item.children)\n    }\n\n    if (horizontalNavItemHasActiveChild(item) || horizontalNavItemHasExpandedChild(item)) {\n      if (!getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', true)\n      }\n    } else {\n      if (getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', false)\n      }\n    }\n  }\n\n  public updateRouterFocusedItem(items: INavItem[]) {\n    const focusedItem = items.find(i => isHorizontalNavItemActive(i)) || items.find(i => horizontalNavItemHasActiveChild(i))\n    if (notNullOrUndefined(focusedItem)) {\n      this.updateFocusedItem(items, focusedItem)\n    }\n  }\n\n  public updateFocusedItem(items: INavItem[], focusedItem: INavItem | undefined): void {\n    for (const item of items) {\n      if (areSameHorizontalNavItem(item, focusedItem)) {\n        setHorizontalNavItemStateProp(item, 'focused', true)\n      } else {\n        setHorizontalNavItemStateProp(item, 'focused', false)\n      }\n    }\n  }\n\n  private _getNavExtras(item: INavLink): UrlCreationOptions {\n    const navigationExtras: UrlCreationOptions = { }\n    if (hasProperty(item, 'queryParams')) {\n      navigationExtras.queryParams = item.queryParams\n    }\n    if (hasProperty(item, 'fragment')) {\n      navigationExtras.fragment = item.fragment\n    }\n    if (hasProperty(item, 'queryParamsHandling')) {\n      navigationExtras.queryParamsHandling = item.queryParamsHandling\n    }\n    if (hasProperty(item, 'preserveFragment')) {\n      navigationExtras.preserveFragment = item.preserveFragment\n    }\n    return navigationExtras\n  }\n\n  private _getUrl(item: INavLink): string | null {\n    const link = item.link\n\n    if (typeof link === 'string') {\n      return this._router.createUrlTree([ link ], this._getNavExtras(item)).toString()\n    } else if (Array.isArray(link)) {\n      return this._router.createUrlTree(link, this._getNavExtras(item)).toString()\n    }\n\n    return null\n  }\n\n  private _getMatchOptions(item: INavLink): IsActiveMatchOptions {\n    const defaultMatchOpts: IsActiveMatchOptions = {\n      paths: 'subset',\n      queryParams: 'subset',\n      fragment: 'ignored',\n      matrixParams: 'ignored'\n    }\n\n    if (hasProperty(item, 'matchOptions')) {\n      return {\n        ...defaultMatchOpts,\n        ...item.matchOptions\n      }\n    }\n\n    return defaultMatchOpts\n  }\n\n  public setItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K, value: INavItemState[K]): void {\n    const currentValue = getHorizontalNavItemStateProp(item, prop)\n    if (currentValue !== value) {\n      setHorizontalNavItemStateProp(item, prop, value)\n\n      const changed: NavItemStateChanged = {\n        item,\n        prop,\n        prevValue: currentValue,\n        newValue: value\n      }\n      this.itemChanged.next(changed)\n    }\n  }\n}\n"]}

package/esm2020/framework/public-api.mjs

@@ -4,4 +4,5 @@ export * from './side-nav/index';
 export * from './top-bar/index';
 export * from './dynamic-router/index';
 export * from './schema-form/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9mcmFtZXdvcmsvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS1sYXlvdXQvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vc2lkZS1uYXYvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL3RvcC1iYXIvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtcm91dGVyL2luZGV4J1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEtZm9ybS9pbmRleCdcbiJdfQ==
+export * from './nav/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9mcmFtZXdvcmsvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS1sYXlvdXQvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vc2lkZS1uYXYvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL3RvcC1iYXIvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtcm91dGVyL2luZGV4J1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEtZm9ybS9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vbmF2L2luZGV4J1xuIl19

package/esm2020/framework/schema-form-controls/schema-form-submit-split/schema-form-submit-split.component.mjs

@@ -135,7 +135,7 @@ export class TheSeamSchemaFormSubmitSplitComponent {
     }
 }
 TheSeamSchemaFormSubmitSplitComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamSchemaFormSubmitSplitComponent, deps: [{ token: i1.JsonSchemaFormService }], target: i0.ɵɵFactoryTarget.Component });
-TheSeamSchemaFormSubmitSplitComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: TheSeamSchemaFormSubmitSplitComponent, isStandalone: true, selector: "seam-schema-form-submit-split", inputs: { layoutNode: "layoutNode", layoutIndex: "layoutIndex", dataIndex: "dataIndex" }, ngImport: i0, template: "<div\n  [class]=\"options?.htmlClass || ''\">\n  <div [class.btn-group]=\"_dropdownObj\">\n    <button seamButton theme=\"primary\" type=\"submit\"\n      [attr.aria-describedby]=\"'control' + layoutNode?._id + 'Status'\"\n      [attr.readonly]=\"options?.readonly ? 'readonly' : null\"\n      [attr.required]=\"options?.required\"\n      [class]=\"'btn btn-primary ' + (options?.fieldHtmlClass || '')\"\n      [disabled]=\"controlDisabled\"\n      [id]=\"'control' + layoutNode?._id\"\n      [name]=\"controlName\"\n      [value]=\"controlValue\"\n      (click)=\"updateValue($event)\">\n      {{ _buttonLabel }}\n      <span *ngIf=\"_selectedItem\">\n        [{{ _selectedItem.name }}]\n      </span>\n    </button>\n    <ng-container *ngIf=\"_dropdownObj\">\n      <button\n        [seamMenuToggle]=\"menu\" seamButton theme=\"primary\"\n        class=\"dropdown-toggle dropdown-toggle-split\"\n        [disabled]=\"_dropdownDisabled\">\n        <span class=\"sr-only\">Toggle Dropdown</span>\n      </button>\n      <seam-menu #menu>\n        <ng-container *ngFor=\"let item of _selectList\">\n          <button seamMenuItem\n            [class.active]=\"item.checked\"\n            (click)=\"_setDropdownValue(item.value)\">\n            {{ item.name }}\n          </button>\n        </ng-container>\n      </seam-menu>\n    </ng-container>\n  </div>\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "ngmodule", type: JsonSchemaFormModule }, { kind: "ngmodule", type: TheSeamFormFieldModule }, { kind: "ngmodule", type: TheSeamMenuModule }, { kind: "component", type: i3.MenuComponent, selector: "seam-menu", inputs: ["menuClass", "baseWidth", "animationType"], outputs: ["closed"], exportAs: ["seamMenu"] }, { kind: "directive", type: i3.MenuToggleDirective, selector: "[seamMenuToggle]", inputs: ["seamMenuToggle", "positions", "seamMenuTogglePositionsOffsetY"], outputs: ["menuOpened", "menuClosed"], exportAs: ["seamMenuToggle"] }, { kind: "component", type: i3.MenuItemComponent, selector: "[seamMenuItem]", inputs: ["disabled", "role", "icon", "iconClass", "sublevelIcon", "subLevelIconClass", "badgeText", "badgeTheme"], exportAs: ["seamMenuItem"] }, { kind: "ngmodule", type: TheSeamButtonsModule }, { kind: "component", type: i4.TheSeamButtonComponent, selector: "button[seamButton]", inputs: ["disabled", "theme", "size", "type"], exportAs: ["seamButton"] }] });
+TheSeamSchemaFormSubmitSplitComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: TheSeamSchemaFormSubmitSplitComponent, isStandalone: true, selector: "seam-schema-form-submit-split", inputs: { layoutNode: "layoutNode", layoutIndex: "layoutIndex", dataIndex: "dataIndex" }, ngImport: i0, template: "<div\n  [class]=\"options?.htmlClass || ''\">\n  <div [class.btn-group]=\"_dropdownObj\">\n    <button seamButton theme=\"primary\" type=\"submit\"\n      [attr.aria-describedby]=\"'control' + layoutNode?._id + 'Status'\"\n      [attr.readonly]=\"options?.readonly ? 'readonly' : null\"\n      [attr.required]=\"options?.required\"\n      [class]=\"'btn btn-primary ' + (options?.fieldHtmlClass || '')\"\n      [disabled]=\"controlDisabled\"\n      [id]=\"'control' + layoutNode?._id\"\n      [name]=\"controlName\"\n      [value]=\"controlValue\"\n      (click)=\"updateValue($event)\">\n      {{ _buttonLabel }}\n      <span *ngIf=\"_selectedItem\">\n        [{{ _selectedItem.name }}]\n      </span>\n    </button>\n    <ng-container *ngIf=\"_dropdownObj\">\n      <button\n        [seamMenuToggle]=\"menu\" seamButton theme=\"primary\"\n        class=\"dropdown-toggle dropdown-toggle-split\"\n        [disabled]=\"_dropdownDisabled\">\n        <span class=\"sr-only\">Toggle Dropdown</span>\n      </button>\n      <seam-menu #menu>\n        <ng-container *ngFor=\"let item of _selectList\">\n          <button seamMenuItem\n            [class.active]=\"item.checked\"\n            (click)=\"_setDropdownValue(item.value)\">\n            {{ item.name }}\n          </button>\n        </ng-container>\n      </seam-menu>\n    </ng-container>\n  </div>\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "ngmodule", type: JsonSchemaFormModule }, { kind: "ngmodule", type: TheSeamFormFieldModule }, { kind: "ngmodule", type: TheSeamMenuModule }, { kind: "component", type: i3.MenuComponent, selector: "seam-menu", inputs: ["menuClass", "baseWidth", "animationType"], outputs: ["closed"], exportAs: ["seamMenu"] }, { kind: "directive", type: i3.MenuToggleDirective, selector: "[seamMenuToggle]", inputs: ["seamMenuToggle", "positions", "seamMenuTogglePositionsOffsetY"], outputs: ["menuToggle", "menuOpened", "menuClosed"], exportAs: ["seamMenuToggle"] }, { kind: "component", type: i3.MenuItemComponent, selector: "[seamMenuItem]", inputs: ["disabled", "role", "icon", "iconClass", "sublevelIcon", "subLevelIconClass", "badgeText", "badgeTheme"], exportAs: ["seamMenuItem"] }, { kind: "ngmodule", type: TheSeamButtonsModule }, { kind: "component", type: i4.TheSeamButtonComponent, selector: "button[seamButton]", inputs: ["disabled", "theme", "size", "type"], exportAs: ["seamButton"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: TheSeamSchemaFormSubmitSplitComponent, decorators: [{
             type: Component,
             args: [{ selector: 'seam-schema-form-submit-split', standalone: true, imports: [
@@ -153,4 +153,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
             }], dataIndex: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-form-submit-split.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/framework/schema-form-controls/schema-form-submit-split/schema-form-submit-split.component.ts","../../../../../../projects/ui-common/framework/schema-form-controls/schema-form-submit-split/schema-form-submit-split.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, isDevMode, OnDestroy, OnInit } from '@angular/core'\nimport { CommonModule } from '@angular/common'\nimport { AbstractControl, ReactiveFormsModule, UntypedFormControl } from '@angular/forms'\nimport { Subject } from 'rxjs'\nimport { takeUntil } from 'rxjs/operators'\n\nimport { buildTitleMap, hasOwn, JsonSchemaFormModule, JsonSchemaFormService, TitleMapItem } from '@ajsf/core'\nimport { observeControlStatus, observeControlValue } from '@theseam/ui-common/utils'\nimport { TheSeamSchemaFormControlWidget, TheSeamSchemaFormWidgetLayoutNodeOptions } from '../../schema-form'\nimport { TheSeamFormFieldModule } from '@theseam/ui-common/form-field'\nimport { TheSeamMenuModule } from '@theseam/ui-common/menu'\nimport { TheSeamButtonsModule } from '@theseam/ui-common/buttons'\n\n// NOTE: This is aliasing TitleMapItem, because we may want to extend it's\n// options. For simplicity, I am letting this work similar to a 'select' widget.\nexport type TheSeamSchemaFormSubmitSplitItem = TitleMapItem\n\n// NOTE: This component is a little hacky, because I am basically creating a\n// data widget that acts like a data and 'submit' widget at the same time.\n//\n// TODO: Try and think of a nicer way to implement this, but still make sense\n// from a schema definition. The library may need to me forked to actually\n// support this in the way I expect, but maybe there is another way.\n@Component({\n  selector: 'seam-schema-form-submit-split',\n  templateUrl: './schema-form-submit-split.component.html',\n  styleUrls: ['./schema-form-submit-split.component.scss'],\n  // changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    JsonSchemaFormModule,\n    TheSeamFormFieldModule,\n    TheSeamMenuModule,\n    TheSeamButtonsModule,\n  ],\n})\nexport class TheSeamSchemaFormSubmitSplitComponent implements OnInit, OnDestroy, TheSeamSchemaFormControlWidget {\n\n  /** @ignore */\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  formControl?: AbstractControl\n  controlName?: string\n  controlValue?: any\n  controlDisabled = false\n  boundControl = false\n  options?: TheSeamSchemaFormWidgetLayoutNodeOptions\n\n  @Input() layoutNode: TheSeamSchemaFormControlWidget['layoutNode']\n  @Input() layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex']\n  @Input() dataIndex: TheSeamSchemaFormControlWidget['dataIndex']\n\n  _buttonLabel = ''\n\n  _dropdownObj: any\n  _dropdownDisabled = false\n  _selectList: TheSeamSchemaFormSubmitSplitItem[] = []\n  _selectedItem?: TheSeamSchemaFormSubmitSplitItem\n\n  constructor(\n    private readonly _jsf: JsonSchemaFormService\n  ) { }\n\n  /** @ignore */\n  ngOnInit() {\n    this.options = this.layoutNode?.options || {} as TheSeamSchemaFormWidgetLayoutNodeOptions\n    this._jsf.initializeControl(this)\n\n    // NOTE: This is commented out, because there is a bug with submit widgets\n    // manually defined in layout. All nodes initialized from the provided\n    // layout have their options populated from the defaults and 'disabled' is\n    // on of the default properties, so the 'disableInvalidSubmit' condition\n    // never gets reached.\n    //\n    // My initial idea for fixing would be to check if the disabled property\n    // exists and is a boolean, or possibly anything defined that can coerce\n    // into a boolean. I can't think of a reason disabled should be anything\n    // else, so that may be an acceptable fix, but I don't want to enable that\n    // yet.\n    //\n    // if (hasOwn(this.options, 'disabled')) {\n    //   console.log('[TheSeamSchemaFormSubmitSplitComponent] hasDisabled', this.options.disabled)\n    //   this.controlDisabled = this.options.disabled\n    // } else\n    if (this._jsf.formOptions.disableInvalidSubmit) {\n      this.controlDisabled = !this._jsf.isValid\n      this._jsf.isValidChanges.subscribe(isValid => this.controlDisabled = !isValid)\n    }\n    if (this.controlValue === null || this.controlValue === undefined) {\n      this.controlValue = this.options.title\n    }\n\n    if (hasOwn(this.options, 'title')) {\n      this._buttonLabel = this.options.title\n    }\n\n    this._initDropdown()\n\n    // console.log('this', this)\n  }\n\n  /** @ignore */\n  ngOnDestroy(): void {\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  updateValue(event: any) {\n    if (typeof this.options?.onClick === 'function') {\n      this.options.onClick(event)\n    } else {\n      this._jsf.updateValue(this, event.target.value)\n    }\n  }\n\n  private _initDropdown(): void {\n    if (!hasOwn(this.layoutNode, 'items') || !(this.layoutNode?.items || []).length) {\n      return\n    }\n\n    if (isDevMode()) {\n      if (this.layoutNode?.items && this.layoutNode?.items.length > 1) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `TheSeamSchemaFormSubmitSplitComponent only supports one item.` +\n          ` items after index 0 will be ignored.`\n        )\n      }\n    }\n\n    const idx = 0\n    const item = (this.layoutNode?.items as any)[idx] || {}\n    this._dropdownObj = {\n      layoutNode: item,\n      layoutIndex: (this.layoutIndex || []).concat(idx),\n      dataIndex: this.layoutNode?.dataType === 'array' ? (this.dataIndex || []).concat(idx) : this.dataIndex,\n\n      options: item.options || {}\n    }\n\n    this._jsf.initializeControl(this._dropdownObj)\n\n    const items = buildTitleMap(\n      this._dropdownObj.options.titleMap || this._dropdownObj.options.enumNames,\n      this._dropdownObj.options.enum,\n      !!this._dropdownObj.options.required,\n      !!this._dropdownObj.options.flatList\n    )\n\n    this._selectList = items\n\n    // TODO: Should this be checking if the control is bound?\n    const dropdownControl = this._getDropdownControl()\n    if (!dropdownControl) {\n      return\n    }\n\n    observeControlValue(dropdownControl).pipe(\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe(value => {\n      this._setSelectListCheckedProp(value)\n      this._selectedItem = this._getSelectedItem()\n    })\n\n    observeControlStatus(dropdownControl).pipe(\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe(value => {\n      this._dropdownDisabled = dropdownControl.disabled\n    })\n  }\n\n  private _getDropdownControl(): UntypedFormControl | undefined {\n    return this._dropdownObj.formControl as UntypedFormControl\n  }\n\n  private _setSelectListCheckedProp(value: any) {\n    const items = this._selectList\n    for (const item of items) {\n      if (item.value === value) {\n        item.checked = true\n      } else if (item.checked) {\n        item.checked = false\n      }\n    }\n    this._selectList = [ ...items ]\n  }\n\n  private _getSelectedItem(): TheSeamSchemaFormSubmitSplitItem | undefined {\n    return (this._selectList || []).find(x => x.checked === true)\n  }\n\n  _setDropdownValue(value: any) {\n    const formControl = this._getDropdownControl()\n    formControl?.setValue(value)\n  }\n\n}\n","<div\n  [class]=\"options?.htmlClass || ''\">\n  <div [class.btn-group]=\"_dropdownObj\">\n    <button seamButton theme=\"primary\" type=\"submit\"\n      [attr.aria-describedby]=\"'control' + layoutNode?._id + 'Status'\"\n      [attr.readonly]=\"options?.readonly ? 'readonly' : null\"\n      [attr.required]=\"options?.required\"\n      [class]=\"'btn btn-primary ' + (options?.fieldHtmlClass || '')\"\n      [disabled]=\"controlDisabled\"\n      [id]=\"'control' + layoutNode?._id\"\n      [name]=\"controlName\"\n      [value]=\"controlValue\"\n      (click)=\"updateValue($event)\">\n      {{ _buttonLabel }}\n      <span *ngIf=\"_selectedItem\">\n        [{{ _selectedItem.name }}]\n      </span>\n    </button>\n    <ng-container *ngIf=\"_dropdownObj\">\n      <button\n        [seamMenuToggle]=\"menu\" seamButton theme=\"primary\"\n        class=\"dropdown-toggle dropdown-toggle-split\"\n        [disabled]=\"_dropdownDisabled\">\n        <span class=\"sr-only\">Toggle Dropdown</span>\n      </button>\n      <seam-menu #menu>\n        <ng-container *ngFor=\"let item of _selectList\">\n          <button seamMenuItem\n            [class.active]=\"item.checked\"\n            (click)=\"_setDropdownValue(item.value)\">\n            {{ item.name }}\n          </button>\n        </ng-container>\n      </seam-menu>\n    </ng-container>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-form-submit-split.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/framework/schema-form-controls/schema-form-submit-split/schema-form-submit-split.component.ts","../../../../../../projects/ui-common/framework/schema-form-controls/schema-form-submit-split/schema-form-submit-split.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, isDevMode, OnDestroy, OnInit } from '@angular/core'\nimport { CommonModule } from '@angular/common'\nimport { AbstractControl, ReactiveFormsModule, UntypedFormControl } from '@angular/forms'\nimport { Subject } from 'rxjs'\nimport { takeUntil } from 'rxjs/operators'\n\nimport { buildTitleMap, hasOwn, JsonSchemaFormModule, JsonSchemaFormService, TitleMapItem } from '@ajsf/core'\nimport { observeControlStatus, observeControlValue } from '@theseam/ui-common/utils'\nimport { TheSeamSchemaFormControlWidget, TheSeamSchemaFormWidgetLayoutNodeOptions } from '../../schema-form'\nimport { TheSeamFormFieldModule } from '@theseam/ui-common/form-field'\nimport { TheSeamMenuModule } from '@theseam/ui-common/menu'\nimport { TheSeamButtonsModule } from '@theseam/ui-common/buttons'\n\n// NOTE: This is aliasing TitleMapItem, because we may want to extend it's\n// options. For simplicity, I am letting this work similar to a 'select' widget.\nexport type TheSeamSchemaFormSubmitSplitItem = TitleMapItem\n\n// NOTE: This component is a little hacky, because I am basically creating a\n// data widget that acts like a data and 'submit' widget at the same time.\n//\n// TODO: Try and think of a nicer way to implement this, but still make sense\n// from a schema definition. The library may need to me forked to actually\n// support this in the way I expect, but maybe there is another way.\n@Component({\n  selector: 'seam-schema-form-submit-split',\n  templateUrl: './schema-form-submit-split.component.html',\n  styleUrls: ['./schema-form-submit-split.component.scss'],\n  // changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    JsonSchemaFormModule,\n    TheSeamFormFieldModule,\n    TheSeamMenuModule,\n    TheSeamButtonsModule,\n  ],\n})\nexport class TheSeamSchemaFormSubmitSplitComponent implements OnInit, OnDestroy, TheSeamSchemaFormControlWidget {\n\n  /** @ignore */\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  formControl?: AbstractControl\n  controlName?: string\n  controlValue?: any\n  controlDisabled = false\n  boundControl = false\n  options?: TheSeamSchemaFormWidgetLayoutNodeOptions\n\n  @Input() layoutNode: TheSeamSchemaFormControlWidget['layoutNode']\n  @Input() layoutIndex: TheSeamSchemaFormControlWidget['layoutIndex']\n  @Input() dataIndex: TheSeamSchemaFormControlWidget['dataIndex']\n\n  _buttonLabel = ''\n\n  _dropdownObj: any\n  _dropdownDisabled = false\n  _selectList: TheSeamSchemaFormSubmitSplitItem[] = []\n  _selectedItem?: TheSeamSchemaFormSubmitSplitItem\n\n  constructor(\n    private readonly _jsf: JsonSchemaFormService\n  ) { }\n\n  /** @ignore */\n  ngOnInit() {\n    this.options = this.layoutNode?.options || {} as TheSeamSchemaFormWidgetLayoutNodeOptions\n    this._jsf.initializeControl(this)\n\n    // NOTE: This is commented out, because there is a bug with submit widgets\n    // manually defined in layout. All nodes initialized from the provided\n    // layout have their options populated from the defaults and 'disabled' is\n    // on of the default properties, so the 'disableInvalidSubmit' condition\n    // never gets reached.\n    //\n    // My initial idea for fixing would be to check if the disabled property\n    // exists and is a boolean, or possibly anything defined that can coerce\n    // into a boolean. I can't think of a reason disabled should be anything\n    // else, so that may be an acceptable fix, but I don't want to enable that\n    // yet.\n    //\n    // if (hasOwn(this.options, 'disabled')) {\n    //   console.log('[TheSeamSchemaFormSubmitSplitComponent] hasDisabled', this.options.disabled)\n    //   this.controlDisabled = this.options.disabled\n    // } else\n    if (this._jsf.formOptions.disableInvalidSubmit) {\n      this.controlDisabled = !this._jsf.isValid\n      this._jsf.isValidChanges.subscribe(isValid => this.controlDisabled = !isValid)\n    }\n    if (this.controlValue === null || this.controlValue === undefined) {\n      this.controlValue = this.options.title\n    }\n\n    if (hasOwn(this.options, 'title')) {\n      this._buttonLabel = this.options.title\n    }\n\n    this._initDropdown()\n\n    // console.log('this', this)\n  }\n\n  /** @ignore */\n  ngOnDestroy(): void {\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  updateValue(event: any) {\n    if (typeof this.options?.onClick === 'function') {\n      this.options.onClick(event)\n    } else {\n      this._jsf.updateValue(this, event.target.value)\n    }\n  }\n\n  private _initDropdown(): void {\n    if (!hasOwn(this.layoutNode, 'items') || !(this.layoutNode?.items || []).length) {\n      return\n    }\n\n    if (isDevMode()) {\n      if (this.layoutNode?.items && this.layoutNode?.items.length > 1) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `TheSeamSchemaFormSubmitSplitComponent only supports one item.` +\n          ` items after index 0 will be ignored.`\n        )\n      }\n    }\n\n    const idx = 0\n    const item = (this.layoutNode?.items as any)[idx] || {}\n    this._dropdownObj = {\n      layoutNode: item,\n      layoutIndex: (this.layoutIndex || []).concat(idx),\n      dataIndex: this.layoutNode?.dataType === 'array' ? (this.dataIndex || []).concat(idx) : this.dataIndex,\n\n      options: item.options || {}\n    }\n\n    this._jsf.initializeControl(this._dropdownObj)\n\n    const items = buildTitleMap(\n      this._dropdownObj.options.titleMap || this._dropdownObj.options.enumNames,\n      this._dropdownObj.options.enum,\n      !!this._dropdownObj.options.required,\n      !!this._dropdownObj.options.flatList\n    )\n\n    this._selectList = items\n\n    // TODO: Should this be checking if the control is bound?\n    const dropdownControl = this._getDropdownControl()\n    if (!dropdownControl) {\n      return\n    }\n\n    observeControlValue(dropdownControl).pipe(\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe(value => {\n      this._setSelectListCheckedProp(value)\n      this._selectedItem = this._getSelectedItem()\n    })\n\n    observeControlStatus(dropdownControl).pipe(\n      takeUntil(this._ngUnsubscribe)\n    ).subscribe(value => {\n      this._dropdownDisabled = dropdownControl.disabled\n    })\n  }\n\n  private _getDropdownControl(): UntypedFormControl | undefined {\n    return this._dropdownObj.formControl as UntypedFormControl\n  }\n\n  private _setSelectListCheckedProp(value: any) {\n    const items = this._selectList\n    for (const item of items) {\n      if (item.value === value) {\n        item.checked = true\n      } else if (item.checked) {\n        item.checked = false\n      }\n    }\n    this._selectList = [ ...items ]\n  }\n\n  private _getSelectedItem(): TheSeamSchemaFormSubmitSplitItem | undefined {\n    return (this._selectList || []).find(x => x.checked === true)\n  }\n\n  _setDropdownValue(value: any) {\n    const formControl = this._getDropdownControl()\n    formControl?.setValue(value)\n  }\n\n}\n","<div\n  [class]=\"options?.htmlClass || ''\">\n  <div [class.btn-group]=\"_dropdownObj\">\n    <button seamButton theme=\"primary\" type=\"submit\"\n      [attr.aria-describedby]=\"'control' + layoutNode?._id + 'Status'\"\n      [attr.readonly]=\"options?.readonly ? 'readonly' : null\"\n      [attr.required]=\"options?.required\"\n      [class]=\"'btn btn-primary ' + (options?.fieldHtmlClass || '')\"\n      [disabled]=\"controlDisabled\"\n      [id]=\"'control' + layoutNode?._id\"\n      [name]=\"controlName\"\n      [value]=\"controlValue\"\n      (click)=\"updateValue($event)\">\n      {{ _buttonLabel }}\n      <span *ngIf=\"_selectedItem\">\n        [{{ _selectedItem.name }}]\n      </span>\n    </button>\n    <ng-container *ngIf=\"_dropdownObj\">\n      <button\n        [seamMenuToggle]=\"menu\" seamButton theme=\"primary\"\n        class=\"dropdown-toggle dropdown-toggle-split\"\n        [disabled]=\"_dropdownDisabled\">\n        <span class=\"sr-only\">Toggle Dropdown</span>\n      </button>\n      <seam-menu #menu>\n        <ng-container *ngFor=\"let item of _selectList\">\n          <button seamMenuItem\n            [class.active]=\"item.checked\"\n            (click)=\"_setDropdownValue(item.value)\">\n            {{ item.name }}\n          </button>\n        </ng-container>\n      </seam-menu>\n    </ng-container>\n  </div>\n</div>\n"]}