@ngrdt/tabs 0.0.1 → 0.0.3

package/esm2022/lib/directives/rdt-tab-controller.directive.mjs

@@ -0,0 +1,366 @@
+import { ContentChildren, DestroyRef, Directive, inject, Injector, Input, QueryList, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { canTransition$, RDT_GUARDED_COMPONENT, RdtContainerDirective, } from '@ngrdt/core';
+import { RdtShortcutService } from '@ngrdt/shortcuts';
+import { firstValueFrom, Subscription, takeWhile } from 'rxjs';
+import { RdtTabContainerComponent } from '../components/tab-container/rdt-tab-container.component';
+import { RdtTabComponent } from '../components/tab/rdt-tab.component';
+import { AutoRdtTabsShortcutStrategy } from '../strategies/auto-rdt-tabs-shortcut-strategy';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrdt/core";
+export class RdtTabControllerDirective {
+    destroyRef = inject(DestroyRef);
+    injector = inject(Injector);
+    shortcutService = inject(RdtShortcutService);
+    shortcutSub = new Subscription();
+    // String value lets you use the directive without param.
+    set rdtTabController(value) {
+        if (value && typeof value !== 'string') {
+            this._strategy = value;
+            this.updateShortcuts();
+        }
+    }
+    get tabContainers() {
+        return this.containerDirective
+            .getChildrenRecursive()
+            .filter((ch) => ch instanceof RdtTabContainerComponent);
+    }
+    get tabs() {
+        return this.containerDirective
+            .getChildrenRecursive()
+            .filter((ch) => ch instanceof RdtTabComponent);
+    }
+    childControllers;
+    get strategy() {
+        return this._strategy;
+    }
+    _strategy = new AutoRdtTabsShortcutStrategy();
+    _lastActiveTabContainer = null;
+    _contentWasInit = false;
+    get disabled() {
+        return this._disabled;
+    }
+    _disabled = false;
+    get shortcuts() {
+        return this._shortcuts;
+    }
+    set shortcuts(value) {
+        const oldSet = new Set(this._shortcuts.map((s) => s.hotkeysValue));
+        this._shortcuts = value;
+        if (oldSet.size !== value.length ||
+            value.some((s) => !oldSet.has(s.hotkeysValue))) {
+            this.bindAll();
+        }
+    }
+    _shortcuts = [];
+    get activeContainer() {
+        return this._lastActiveTabContainer?.container;
+    }
+    containerDirective;
+    ngOnInit() {
+        this.containerDirective = this.injector.get(RdtContainerDirective, undefined, {
+            self: true,
+        });
+        this.updateShortcuts();
+    }
+    ngAfterContentInit() {
+        this.setDefaultActive();
+        this.disableSelfWhenChildCtrlExists();
+        this._contentWasInit = true;
+        if (this.tabs.length > 0) {
+            this.onTabChanges();
+        }
+        if (this.tabContainers.length > 0) {
+            this.onTabContainerChanges();
+        }
+    }
+    ngOnDestroy() {
+        this.unbindAll();
+        this._shortcuts.length = 0;
+    }
+    getTabContainerIndex(cont) {
+        const level = this.getSameLevelContainers(cont);
+        return level.indexOf(cont);
+    }
+    /**
+     * Activates first parent container of current container
+     * that is not disabled and has any non disabled tabs.
+     */
+    goLevelUp() {
+        let cont = this.activeContainer;
+        while (cont) {
+            cont = cont.parentTab?.tabContainer;
+            if (cont && !cont.disabled && cont.hasNonDisabledTabs) {
+                this.activateTabContainer(cont);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Activates first container under current tab which
+     * is not disabled and has any non disabled tabs.
+     */
+    goLevelDown() {
+        const cont = this.activeContainer;
+        if (!cont || cont.disabled) {
+            return false;
+        }
+        let tab = cont.tabsList.find((t) => t.stateId === cont.value);
+        if (!tab || tab.disabled) {
+            tab = cont.tabsList.find((t) => !t.disabled);
+        }
+        if (!tab) {
+            return false;
+        }
+        const targetCont = tab.childContainers.find((c) => !c.disabled && c.hasNonDisabledTabs);
+        if (targetCont) {
+            this.activateTabContainer(targetCont);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Activates next container on current level
+     * (under parent container of currently active container).
+     * Is cyclic.
+     */
+    goToNextContainer() {
+        return this.goToAdjacentContainer(1);
+    }
+    /**
+     * Activates previous container on current level
+     * (under parent container of currently active container).
+     * Is cyclic.
+     */
+    goToPrevContainer() {
+        return this.goToAdjacentContainer(-1);
+    }
+    /**
+     * Activates tab within active container at the index of argument.
+     */
+    goToTabWithIndex(index) {
+        const cont = this.activeContainer;
+        if (!cont) {
+            return false;
+        }
+        const tab = cont.tabsList.get(index);
+        if (!tab) {
+            return false;
+        }
+        this.activateTab(tab);
+        return true;
+    }
+    /**
+     * Activates next tab within active container. Is cyclic.
+     */
+    goToNextTab() {
+        return this.goToAdjacentTab(1);
+    }
+    /**
+     * Activates previous tab within active container. Is cyclic.
+     */
+    goToPrevTab() {
+        return this.goToAdjacentTab(-1);
+    }
+    goToAdjacentContainer(dir) {
+        const cont = this.activeContainer;
+        if (!cont) {
+            return false;
+        }
+        const level = this.getSameLevelContainers(cont);
+        if (!level) {
+            return false;
+        }
+        const currentIndex = level.indexOf(cont);
+        if (currentIndex < 0) {
+            throw new Error('Current container is not within its own level?');
+        }
+        for (let i = (currentIndex + dir + level.length) % level.length; i !== currentIndex; i = (i + dir + level.length) % level.length) {
+            const next = level[i];
+            if (!next.disabled && next.hasNonDisabledTabs) {
+                this.activateTabContainer(next);
+                return true;
+            }
+        }
+        return false;
+    }
+    goToAdjacentTab(dir) {
+        const cont = this.activeContainer;
+        if (!cont) {
+            return false;
+        }
+        const tabs = cont.tabsList.toArray();
+        const currentIndex = tabs.findIndex((tab) => tab.stateId === cont.value);
+        if (currentIndex < 0) {
+            throw new Error('Current tab is not found in its container?!');
+        }
+        for (let i = (currentIndex + dir + tabs.length) % tabs.length; i !== currentIndex; i = (i + dir + tabs.length) % tabs.length) {
+            const next = tabs[i];
+            if (!next.disabled) {
+                this.activateTab(next);
+                return true;
+            }
+        }
+        return false;
+    }
+    getSameLevelContainers(cont) {
+        if (cont.parentTab) {
+            return cont.parentTab.childContainers;
+        }
+        else {
+            return this.tabContainers.filter((cont) => cont.isTopLevel);
+        }
+    }
+    getTabByValue(value) {
+        for (const container of this.tabContainers) {
+            const tab = container.tabsList.find((ch) => ch.stateId === value);
+            if (tab) {
+                return tab;
+            }
+        }
+        return null;
+    }
+    activateTabContainer(tabs, scrollIntoView = true) {
+        if (this._lastActiveTabContainer) {
+            this._lastActiveTabContainer.container.active = false;
+        }
+        tabs.active = true;
+        if (scrollIntoView) {
+            tabs.scrollIntoView();
+        }
+        this._lastActiveTabContainer = {
+            container: tabs,
+            timestamp: null,
+        };
+    }
+    activateTabContainerFromClick(tabs, timestamp) {
+        if (this._lastActiveTabContainer) {
+            if (this._lastActiveTabContainer.timestamp !== null &&
+                this._lastActiveTabContainer.timestamp >= timestamp) {
+                return;
+            }
+            this._lastActiveTabContainer.container.active = false;
+        }
+        tabs.active = true;
+        this._lastActiveTabContainer = {
+            container: tabs,
+            timestamp,
+        };
+    }
+    async activateTab(tab) {
+        if (!this.canActivateTab(tab)) {
+            console.warn('Trying to activate disabled tab.');
+            return;
+        }
+        const formsCheck = await this.canActivateTabForms(tab);
+        if (!formsCheck) {
+            console.warn('Trying to activate tab while current tab has unsaved forms');
+            return;
+        }
+        let current = tab;
+        do {
+            const container = current.tabContainer;
+            container.value = current.stateId;
+            current = container.parentTab;
+        } while (current !== null);
+    }
+    canActivateTab(tab) {
+        let current = tab;
+        do {
+            const container = current.tabContainer;
+            if (current.disabled || container.disabled) {
+                return false;
+            }
+            current = container.parentTab;
+        } while (current !== null);
+        return true;
+    }
+    async canActivateTabForms(tab) {
+        const container = tab.tabContainer;
+        return firstValueFrom(canTransition$(container.activeTab?.contDir, tab?.contDir));
+    }
+    onTabChanges() {
+        this.updateShortcuts();
+    }
+    onTabContainerChanges() {
+        this.setDefaultActiveWhenAvailable();
+    }
+    disableSelfWhenChildCtrlExists() {
+        this.childControllers.changes
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((val) => {
+            this._disabled = val.length > 0;
+            if (this._disabled) {
+                this.unbindAll();
+            }
+            else {
+                this.bindAll();
+            }
+        });
+    }
+    setDefaultActive() {
+        if (this.tabContainers) {
+            const defaultCont = this.tabContainers.find(this.canContainerBeDefault);
+            if (defaultCont) {
+                this.activateTabContainer(defaultCont, false);
+            }
+        }
+    }
+    setDefaultActiveWhenAvailable() {
+        const active = this.activeContainer;
+        if (active && this.tabContainers.some((cont) => cont === active)) {
+            return;
+        }
+        const newDefault = this.tabContainers.find(this.canContainerBeDefault);
+        if (newDefault) {
+            this.activateTabContainer(newDefault, false);
+        }
+    }
+    canContainerBeDefault(c) {
+        return c.isTopLevel && !c.disabled && c.hasNonDisabledTabs;
+    }
+    updateShortcuts() {
+        this.shortcuts = this._strategy.updateShortcuts(this);
+    }
+    bindAll() {
+        this.shortcutSub.unsubscribe();
+        if (!this._disabled) {
+            this.shortcutSub = this.shortcutService
+                .listen(this._shortcuts)
+                .pipe(takeWhile(() => !this._disabled))
+                .subscribe((event) => {
+                this._strategy.onShortcut(event.shortcut, this);
+            });
+        }
+    }
+    unbindAll() {
+        this.shortcutSub.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabControllerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", type: RdtTabControllerDirective, selector: "[rdtTabController]", inputs: { rdtTabController: "rdtTabController" }, providers: [
+            {
+                provide: RDT_GUARDED_COMPONENT,
+                useExisting: RdtTabControllerDirective,
+            },
+        ], queries: [{ propertyName: "childControllers", predicate: RdtTabControllerDirective, descendants: true }], hostDirectives: [{ directive: i1.RdtContainerDirective }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabControllerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdtTabController]',
+                    providers: [
+                        {
+                            provide: RDT_GUARDED_COMPONENT,
+                            useExisting: RdtTabControllerDirective,
+                        },
+                    ],
+                    hostDirectives: [RdtContainerDirective],
+                }]
+        }], propDecorators: { rdtTabController: [{
+                type: Input
+            }], childControllers: [{
+                type: ContentChildren,
+                args: [RdtTabControllerDirective, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rdt-tab-controller.directive.js","sourceRoot":"","sources":["../../../../../../@ngrdt/tabs/src/lib/directives/rdt-tab-controller.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ContentChildren,\n  DestroyRef,\n  Directive,\n  inject,\n  Injector,\n  Input,\n  OnDestroy,\n  OnInit,\n  QueryList,\n} from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport {\n  canTransition$,\n  RDT_GUARDED_COMPONENT,\n  RdtContainerDirective,\n} from '@ngrdt/core';\nimport { RdtShortcut, RdtShortcutService } from '@ngrdt/shortcuts';\nimport { firstValueFrom, Subscription, takeWhile } from 'rxjs';\nimport { RdtTabContainerComponent } from '../components/tab-container/rdt-tab-container.component';\nimport { RdtTabComponent } from '../components/tab/rdt-tab.component';\nimport { AutoRdtTabsShortcutStrategy } from '../strategies/auto-rdt-tabs-shortcut-strategy';\nimport { RdtTabsShortcutStrategy } from '../strategies/rdt-tabs-shortcut-strategy';\n\n@Directive({\n  selector: '[rdtTabController]',\n  providers: [\n    {\n      provide: RDT_GUARDED_COMPONENT,\n      useExisting: RdtTabControllerDirective,\n    },\n  ],\n  hostDirectives: [RdtContainerDirective],\n})\nexport class RdtTabControllerDirective\n  implements OnInit, AfterContentInit, OnDestroy\n{\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly injector = inject(Injector);\n  private readonly shortcutService = inject(RdtShortcutService);\n  private shortcutSub = new Subscription();\n\n  // String value lets you use the directive without param.\n  @Input()\n  set rdtTabController(value: RdtTabsShortcutStrategy | string | null) {\n    if (value && typeof value !== 'string') {\n      this._strategy = value;\n      this.updateShortcuts();\n    }\n  }\n\n  protected get tabContainers() {\n    return this.containerDirective\n      .getChildrenRecursive()\n      .filter(\n        (ch) => ch instanceof RdtTabContainerComponent\n      ) as unknown as RdtTabContainerComponent[];\n  }\n  protected get tabs() {\n    return this.containerDirective\n      .getChildrenRecursive()\n      .filter(\n        (ch) => ch instanceof RdtTabComponent\n      ) as unknown as RdtTabComponent[];\n  }\n\n  @ContentChildren(RdtTabControllerDirective, { descendants: true })\n  protected childControllers!: QueryList<RdtTabControllerDirective>;\n\n  get strategy() {\n    return this._strategy;\n  }\n  private _strategy: RdtTabsShortcutStrategy =\n    new AutoRdtTabsShortcutStrategy();\n\n  private _lastActiveTabContainer: {\n    timestamp: number | null;\n    container: RdtTabContainerComponent;\n  } | null = null;\n\n  private _contentWasInit = false;\n\n  get disabled() {\n    return this._disabled;\n  }\n  private _disabled = false;\n\n  get shortcuts() {\n    return this._shortcuts;\n  }\n  set shortcuts(value: RdtShortcut[]) {\n    const oldSet = new Set<string>(this._shortcuts.map((s) => s.hotkeysValue));\n    this._shortcuts = value;\n\n    if (\n      oldSet.size !== value.length ||\n      value.some((s) => !oldSet.has(s.hotkeysValue))\n    ) {\n      this.bindAll();\n    }\n  }\n  private _shortcuts: RdtShortcut[] = [];\n\n  get activeContainer() {\n    return this._lastActiveTabContainer?.container;\n  }\n\n  protected containerDirective!: RdtContainerDirective;\n\n  ngOnInit() {\n    this.containerDirective = this.injector.get(\n      RdtContainerDirective,\n      undefined,\n      {\n        self: true,\n      }\n    );\n    this.updateShortcuts();\n  }\n\n  ngAfterContentInit() {\n    this.setDefaultActive();\n    this.disableSelfWhenChildCtrlExists();\n    this._contentWasInit = true;\n    if (this.tabs.length > 0) {\n      this.onTabChanges();\n    }\n    if (this.tabContainers.length > 0) {\n      this.onTabContainerChanges();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.unbindAll();\n    this._shortcuts.length = 0;\n  }\n\n  getTabContainerIndex(cont: RdtTabContainerComponent): number {\n    const level = this.getSameLevelContainers(cont);\n    return level.indexOf(cont);\n  }\n\n  /**\n   * Activates first parent container of current container\n   * that is not disabled and has any non disabled tabs.\n   */\n  goLevelUp(): boolean {\n    let cont = this.activeContainer;\n    while (cont) {\n      cont = cont.parentTab?.tabContainer;\n      if (cont && !cont.disabled && cont.hasNonDisabledTabs) {\n        this.activateTabContainer(cont);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Activates first container under current tab which\n   * is not disabled and has any non disabled tabs.\n   */\n  goLevelDown(): boolean {\n    const cont = this.activeContainer;\n    if (!cont || cont.disabled) {\n      return false;\n    }\n    let tab = cont.tabsList.find((t) => t.stateId === cont.value);\n    if (!tab || tab.disabled) {\n      tab = cont.tabsList.find((t) => !t.disabled);\n    }\n    if (!tab) {\n      return false;\n    }\n    const targetCont = tab.childContainers.find(\n      (c) => !c.disabled && c.hasNonDisabledTabs\n    );\n    if (targetCont) {\n      this.activateTabContainer(targetCont);\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Activates next container on current level\n   * (under parent container of currently active container).\n   * Is cyclic.\n   */\n  goToNextContainer(): boolean {\n    return this.goToAdjacentContainer(1);\n  }\n\n  /**\n   * Activates previous container on current level\n   * (under parent container of currently active container).\n   * Is cyclic.\n   */\n  goToPrevContainer(): boolean {\n    return this.goToAdjacentContainer(-1);\n  }\n\n  /**\n   * Activates tab within active container at the index of argument.\n   */\n  goToTabWithIndex(index: number): boolean {\n    const cont = this.activeContainer;\n    if (!cont) {\n      return false;\n    }\n    const tab = cont.tabsList.get(index);\n    if (!tab) {\n      return false;\n    }\n    this.activateTab(tab);\n    return true;\n  }\n\n  /**\n   * Activates next tab within active container. Is cyclic.\n   */\n  goToNextTab(): boolean {\n    return this.goToAdjacentTab(1);\n  }\n\n  /**\n   * Activates previous tab within active container. Is cyclic.\n   */\n  goToPrevTab(): boolean {\n    return this.goToAdjacentTab(-1);\n  }\n\n  private goToAdjacentContainer(dir: -1 | 1) {\n    const cont = this.activeContainer;\n    if (!cont) {\n      return false;\n    }\n\n    const level = this.getSameLevelContainers(cont);\n    if (!level) {\n      return false;\n    }\n\n    const currentIndex = level.indexOf(cont);\n    if (currentIndex < 0) {\n      throw new Error('Current container is not within its own level?');\n    }\n    for (\n      let i = (currentIndex + dir + level.length) % level.length;\n      i !== currentIndex;\n      i = (i + dir + level.length) % level.length\n    ) {\n      const next = level[i];\n      if (!next.disabled && next.hasNonDisabledTabs) {\n        this.activateTabContainer(next);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private goToAdjacentTab(dir: -1 | 1) {\n    const cont = this.activeContainer;\n    if (!cont) {\n      return false;\n    }\n\n    const tabs = cont.tabsList.toArray();\n    const currentIndex = tabs.findIndex((tab) => tab.stateId === cont.value);\n    if (currentIndex < 0) {\n      throw new Error('Current tab is not found in its container?!');\n    }\n\n    for (\n      let i = (currentIndex + dir + tabs.length) % tabs.length;\n      i !== currentIndex;\n      i = (i + dir + tabs.length) % tabs.length\n    ) {\n      const next = tabs[i];\n      if (!next.disabled) {\n        this.activateTab(next);\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private getSameLevelContainers(cont: RdtTabContainerComponent) {\n    if (cont.parentTab) {\n      return cont.parentTab.childContainers;\n    } else {\n      return this.tabContainers.filter((cont) => cont.isTopLevel);\n    }\n  }\n\n  getTabByValue(value: string) {\n    for (const container of this.tabContainers) {\n      const tab = container.tabsList.find((ch) => ch.stateId === value);\n      if (tab) {\n        return tab;\n      }\n    }\n    return null;\n  }\n\n  activateTabContainer(tabs: RdtTabContainerComponent, scrollIntoView = true) {\n    if (this._lastActiveTabContainer) {\n      this._lastActiveTabContainer.container.active = false;\n    }\n\n    tabs.active = true;\n    if (scrollIntoView) {\n      tabs.scrollIntoView();\n    }\n\n    this._lastActiveTabContainer = {\n      container: tabs,\n      timestamp: null,\n    };\n  }\n\n  activateTabContainerFromClick(\n    tabs: RdtTabContainerComponent,\n    timestamp: number\n  ) {\n    if (this._lastActiveTabContainer) {\n      if (\n        this._lastActiveTabContainer.timestamp !== null &&\n        this._lastActiveTabContainer.timestamp >= timestamp\n      ) {\n        return;\n      }\n\n      this._lastActiveTabContainer.container.active = false;\n    }\n\n    tabs.active = true;\n\n    this._lastActiveTabContainer = {\n      container: tabs,\n      timestamp,\n    };\n  }\n\n  async activateTab(tab: RdtTabComponent) {\n    if (!this.canActivateTab(tab)) {\n      console.warn('Trying to activate disabled tab.');\n      return;\n    }\n\n    const formsCheck = await this.canActivateTabForms(tab);\n    if (!formsCheck) {\n      console.warn(\n        'Trying to activate tab while current tab has unsaved forms'\n      );\n      return;\n    }\n\n    let current: RdtTabComponent | null = tab;\n\n    do {\n      const container: RdtTabContainerComponent = current!.tabContainer;\n      container.value = current!.stateId;\n      current = container.parentTab;\n    } while (current !== null);\n  }\n\n  canActivateTab(tab: RdtTabComponent) {\n    let current: RdtTabComponent | null = tab;\n\n    do {\n      const container: RdtTabContainerComponent = current.tabContainer;\n      if (current.disabled || container.disabled) {\n        return false;\n      }\n      current = container.parentTab;\n    } while (current !== null);\n\n    return true;\n  }\n\n  async canActivateTabForms(tab: RdtTabComponent) {\n    const container = tab.tabContainer;\n    return firstValueFrom(\n      canTransition$(container.activeTab?.contDir, tab?.contDir)\n    );\n  }\n\n  onTabChanges() {\n    this.updateShortcuts();\n  }\n\n  onTabContainerChanges() {\n    this.setDefaultActiveWhenAvailable();\n  }\n\n  private disableSelfWhenChildCtrlExists() {\n    this.childControllers.changes\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((val: QueryList<RdtTabControllerDirective>) => {\n        this._disabled = val.length > 0;\n\n        if (this._disabled) {\n          this.unbindAll();\n        } else {\n          this.bindAll();\n        }\n      });\n  }\n\n  private setDefaultActive() {\n    if (this.tabContainers) {\n      const defaultCont = this.tabContainers.find(this.canContainerBeDefault);\n      if (defaultCont) {\n        this.activateTabContainer(defaultCont, false);\n      }\n    }\n  }\n\n  private setDefaultActiveWhenAvailable() {\n    const active = this.activeContainer;\n    if (active && this.tabContainers.some((cont) => cont === active)) {\n      return;\n    }\n    const newDefault = this.tabContainers.find(this.canContainerBeDefault);\n    if (newDefault) {\n      this.activateTabContainer(newDefault, false);\n    }\n  }\n\n  private canContainerBeDefault(c: RdtTabContainerComponent) {\n    return c.isTopLevel && !c.disabled && c.hasNonDisabledTabs;\n  }\n\n  private updateShortcuts() {\n    this.shortcuts = this._strategy.updateShortcuts(this);\n  }\n\n  private bindAll() {\n    this.shortcutSub.unsubscribe();\n    if (!this._disabled) {\n      this.shortcutSub = this.shortcutService\n        .listen(this._shortcuts)\n        .pipe(takeWhile(() => !this._disabled))\n        .subscribe((event) => {\n          this._strategy.onShortcut(event.shortcut, this);\n        });\n    }\n  }\n\n  private unbindAll() {\n    this.shortcutSub.unsubscribe();\n  }\n}\n"]}

package/esm2022/lib/rdt-tabs-models.mjs

@@ -0,0 +1,4 @@
+export var RdtTabMode;
+(function (RdtTabMode) {
+})(RdtTabMode || (RdtTabMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmR0LXRhYnMtbW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vQG5ncmR0L3RhYnMvc3JjL2xpYi9yZHQtdGFicy1tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBV0EsTUFBTSxDQUFOLElBQVksVUFBYTtBQUF6QixXQUFZLFVBQVU7QUFBRSxDQUFDLEVBQWIsVUFBVSxLQUFWLFVBQVUsUUFBRyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUmR0VGFiQ29udGFpbmVyU3RhdGUge1xuICBpZDogYW55O1xuICB2YWx1ZTogYW55O1xuICB0YWJTdGF0ZXM6IFJkdFRhYlN0YXRlW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmR0VGFiU3RhdGUge1xuICBpZDogYW55O1xuICBjb250YWluZXJTdGF0ZXM6IFJkdFRhYkNvbnRhaW5lclN0YXRlW107XG59XG5cbmV4cG9ydCBlbnVtIFJkdFRhYk1vZGUge31cbiJdfQ==

package/esm2022/lib/rdt-tabs.module.mjs

@@ -0,0 +1,37 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RdtTabContainerComponent } from './components/tab-container/rdt-tab-container.component';
+import { RdtTabComponent } from './components/tab/rdt-tab.component';
+import { RdtDestroyInactiveDirective } from './directives/rdt-destroy-inactive.directive';
+import { RdtTabControllerDirective } from './directives/rdt-tab-controller.directive';
+import * as i0 from "@angular/core";
+export class RdtTabsModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.7", ngImport: i0, type: RdtTabsModule, declarations: [RdtTabComponent,
+            RdtTabContainerComponent,
+            RdtTabControllerDirective,
+            RdtDestroyInactiveDirective], imports: [CommonModule], exports: [RdtTabComponent,
+            RdtTabContainerComponent,
+            RdtTabControllerDirective,
+            RdtDestroyInactiveDirective] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabsModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: RdtTabsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        RdtTabComponent,
+                        RdtTabContainerComponent,
+                        RdtTabControllerDirective,
+                        RdtDestroyInactiveDirective,
+                    ],
+                    exports: [
+                        RdtTabComponent,
+                        RdtTabContainerComponent,
+                        RdtTabControllerDirective,
+                        RdtDestroyInactiveDirective,
+                    ],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmR0LXRhYnMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vQG5ncmR0L3RhYnMvc3JjL2xpYi9yZHQtdGFicy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFDbEcsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBQzFGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDJDQUEyQyxDQUFDOztBQWlCdEYsTUFBTSxPQUFPLGFBQWE7dUdBQWIsYUFBYTt3R0FBYixhQUFhLGlCQWJ0QixlQUFlO1lBQ2Ysd0JBQXdCO1lBQ3hCLHlCQUF5QjtZQUN6QiwyQkFBMkIsYUFRbkIsWUFBWSxhQUxwQixlQUFlO1lBQ2Ysd0JBQXdCO1lBQ3hCLHlCQUF5QjtZQUN6QiwyQkFBMkI7d0dBSWxCLGFBQWEsWUFGZCxZQUFZOzsyRkFFWCxhQUFhO2tCQWZ6QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRTt3QkFDWixlQUFlO3dCQUNmLHdCQUF3Qjt3QkFDeEIseUJBQXlCO3dCQUN6QiwyQkFBMkI7cUJBQzVCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxlQUFlO3dCQUNmLHdCQUF3Qjt3QkFDeEIseUJBQXlCO3dCQUN6QiwyQkFBMkI7cUJBQzVCO29CQUNELE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztpQkFDeEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJkdFRhYkNvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy90YWItY29udGFpbmVyL3JkdC10YWItY29udGFpbmVyLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBSZHRUYWJDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvdGFiL3JkdC10YWIuY29tcG9uZW50JztcbmltcG9ydCB7IFJkdERlc3Ryb3lJbmFjdGl2ZURpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9yZHQtZGVzdHJveS1pbmFjdGl2ZS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgUmR0VGFiQ29udHJvbGxlckRpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9yZHQtdGFiLWNvbnRyb2xsZXIuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgUmR0VGFiQ29tcG9uZW50LFxuICAgIFJkdFRhYkNvbnRhaW5lckNvbXBvbmVudCxcbiAgICBSZHRUYWJDb250cm9sbGVyRGlyZWN0aXZlLFxuICAgIFJkdERlc3Ryb3lJbmFjdGl2ZURpcmVjdGl2ZSxcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFJkdFRhYkNvbXBvbmVudCxcbiAgICBSZHRUYWJDb250YWluZXJDb21wb25lbnQsXG4gICAgUmR0VGFiQ29udHJvbGxlckRpcmVjdGl2ZSxcbiAgICBSZHREZXN0cm95SW5hY3RpdmVEaXJlY3RpdmUsXG4gIF0sXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxufSlcbmV4cG9ydCBjbGFzcyBSZHRUYWJzTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/strategies/auto-rdt-tabs-shortcut-strategy.mjs

@@ -0,0 +1,64 @@
+import { RdtShortcut } from '@ngrdt/shortcuts';
+import { RdtTabsShortcutStrategy } from './rdt-tabs-shortcut-strategy';
+const TAB_BASE = 'alt';
+const TAB_KEY_SETS = [
+    ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'],
+    ['+', 'ě', 'š', 'č', 'ř', 'ž', 'ý', 'á', 'í', 'é'],
+];
+const NEXT_CONTAINER = RdtShortcut.create('alt', 's');
+const PREV_CONTAINER = RdtShortcut.create('alt', 'w');
+const LEVEL_UP = RdtShortcut.create('ctrl', 'alt', 'up');
+const LEVEL_DOWN = RdtShortcut.create('ctrl', 'alt', 'down');
+const NEXT_TAB = RdtShortcut.create('ctrl', 'alt', 'right');
+const PREV_TAB = RdtShortcut.create('ctrl', 'alt', 'left');
+export class AutoRdtTabsShortcutStrategy extends RdtTabsShortcutStrategy {
+    updateShortcuts() {
+        return AutoRdtTabsShortcutStrategy.shortcuts;
+    }
+    onShortcut(shortcut, ctrl) {
+        const key = shortcut.lastKey;
+        if (!key) {
+            throw new Error('Key should not be undefined!');
+        }
+        const action = AutoRdtTabsShortcutStrategy.actions[key];
+        if (!action) {
+            throw new Error(`Unknown action for key ${key}`);
+        }
+        action(ctrl);
+    }
+    static generateActions() {
+        const actions = {
+            [LEVEL_UP.lastKey]: (ctrl) => ctrl.goLevelUp(),
+            [LEVEL_DOWN.lastKey]: (ctrl) => ctrl.goLevelDown(),
+            [NEXT_CONTAINER.lastKey]: (ctrl) => ctrl.goToNextContainer(),
+            [PREV_CONTAINER.lastKey]: (ctrl) => ctrl.goToPrevContainer(),
+            [NEXT_TAB.lastKey]: (ctrl) => ctrl.goToNextTab(),
+            [PREV_TAB.lastKey]: (ctrl) => ctrl.goToPrevTab(),
+        };
+        TAB_KEY_SETS.forEach((set) => {
+            set.forEach((char, i) => {
+                actions[char] = (ctrl) => ctrl.goToTabWithIndex(i);
+            });
+        });
+        return actions;
+    }
+    static generateShortcuts() {
+        const shortcuts = [
+            LEVEL_UP,
+            LEVEL_DOWN,
+            NEXT_CONTAINER,
+            PREV_CONTAINER,
+            NEXT_TAB,
+            PREV_TAB,
+        ];
+        TAB_KEY_SETS.forEach((set) => {
+            set.forEach((tabKey) => {
+                shortcuts.push(RdtShortcut.create(TAB_BASE, tabKey));
+            });
+        });
+        return shortcuts;
+    }
+    static shortcuts = AutoRdtTabsShortcutStrategy.generateShortcuts();
+    static actions = AutoRdtTabsShortcutStrategy.generateActions();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/strategies/rdt-tabs-shortcut-strategy.mjs

@@ -0,0 +1,3 @@
+export class RdtTabsShortcutStrategy {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmR0LXRhYnMtc2hvcnRjdXQtc3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9AbmdyZHQvdGFicy9zcmMvbGliL3N0cmF0ZWdpZXMvcmR0LXRhYnMtc2hvcnRjdXQtc3RyYXRlZ3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsTUFBTSxPQUFnQix1QkFBdUI7Q0FnQjVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmR0U2hvcnRjdXQgfSBmcm9tICdAbmdyZHQvc2hvcnRjdXRzJztcbmltcG9ydCB7IFJkdFRhYkNvbnRyb2xsZXJEaXJlY3RpdmUgfSBmcm9tICcuLi9kaXJlY3RpdmVzL3JkdC10YWItY29udHJvbGxlci5kaXJlY3RpdmUnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgUmR0VGFic1Nob3J0Y3V0U3RyYXRlZ3kge1xuICAvKipcbiAgICogR2V0cyBjYWxsZWQgb25Jbml0IGFuZCB3aGVuZXZlciB0YWJzIGFyZSBhZGRlZC9yZW1vdmVkIGZyb20gQ29udHJvbGxlci5cbiAgICogQHBhcmFtIGN0cmwgQ29udHJvbGxlciB1c2luZyB0aGlzIHN0cmF0ZWd5LlxuICAgKiBAcmV0dXJucyBMaXN0IG9mIHNob3J0Y3V0cyB0byByZWdpc3Rlci5cbiAgICovXG4gIGFic3RyYWN0IHVwZGF0ZVNob3J0Y3V0cyhjdHJsOiBSZHRUYWJDb250cm9sbGVyRGlyZWN0aXZlKTogUmR0U2hvcnRjdXRbXTtcbiAgLyoqXG4gICAqIEdldHMgY2FsbGVkIHdoZW5ldmVyIGhvdGtleXMgZGV0ZWN0cyBvbmUgb2YgdGhlIHJlZ2lzdGVyZWQgc2hvcnRjdXRzLlxuICAgKiBAcGFyYW0gc2hvcnRjdXQgUmVnaXN0ZXJlZCBzaG9ydGN1dC5cbiAgICogQHBhcmFtIGN0cmwgQ29udHJvbGxlciB1c2luZyB0aGlzIHN0cmF0ZWd5LlxuICAgKi9cbiAgYWJzdHJhY3Qgb25TaG9ydGN1dChcbiAgICBzaG9ydGN1dDogUmR0U2hvcnRjdXQsXG4gICAgY3RybDogUmR0VGFiQ29udHJvbGxlckRpcmVjdGl2ZVxuICApOiB2b2lkO1xufVxuIl19

package/esm2022/lib/strategies/static-rdt-tabs-shortcut-strategy.mjs

@@ -0,0 +1,23 @@
+export class StaticRdtTabsShortcutStrategy {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    updateShortcuts() {
+        return Array.from(this.config.shortcuts.keys());
+    }
+    onShortcut(shortcut, ctrl) {
+        const value = this.config.shortcuts.get(shortcut);
+        const tab = ctrl.getTabByValue(value);
+        if (tab) {
+            ctrl.activateTab(tab);
+            ctrl.activateTabContainer(tab.tabContainer);
+        }
+        else {
+            console.warn(`Registered shortcut has been detected,
+          but there is no tab with appropriate value.
+          Shortcut: ${shortcut}, value: ${value}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ngrdt-tabs.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdyZHQtdGFicy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL0BuZ3JkdC90YWJzL3NyYy9uZ3JkdC10YWJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19