@skyux/lists 8.7.0 → 9.0.0-alpha.0

package/esm2022/lib/modules/repeater/repeater.component.mjs

@@ -0,0 +1,373 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, Input, Output, Renderer2, inject, } from '@angular/core';
+import { SkyLogService } from '@skyux/core';
+import { SkyScrollableHostService } from '@skyux/core';
+import { DragulaService } from 'ng2-dragula';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyRepeaterAdapterService } from './repeater-adapter.service';
+import { SkyRepeaterAutoScrollService } from './repeater-auto-scroll.service';
+import { SkyRepeaterItemComponent } from './repeater-item.component';
+import { SkyRepeaterService } from './repeater.service';
+import * as i0 from "@angular/core";
+import * as i1 from "ng2-dragula";
+import * as i2 from "@angular/cdk/observers";
+import * as i3 from "@skyux/i18n";
+/**
+ * Creates a container to display repeater items.
+ */
+export class SkyRepeaterComponent {
+    /**
+     * The layout that determines which repeater items are expanded by default and whether
+     * repeater items are expandable and collapsible. Collapsed items display titles only.
+     * The valid options are `multiple`, `none`, and `single`.
+     * - `multiple` loads repeater items in an expanded state unless `isExpanded` is set to
+     * `false` for a repeater item. This layout allows users to expand and collapse
+     * as many repeater items as necessary. It is best-suited to repeater items where body
+     * content is important but users don't always need to see it.
+     * - `none` loads all repeater items in an expanded state and does not allow users to
+     * collapse them. This default layout provides the quickest access to the details in the
+     * repeater items. It is best-suited to repeater items with concise content
+     * that users need to view frequently.
+     * - `single` loads one repeater item in an expanded state and collapses all others.
+     * The expanded repeater item is the first one where `isExpanded` is set to `true`. This layout
+     * allows users to expand one item at a time. It provides the most compact view and is
+     * best-suited to repeater items where the most important information is in the titles
+     * and users only occasionally need to view the body content.
+     * @default "none"
+     */
+    set expandMode(value) {
+        this.#repeaterService.expandMode = value;
+        this.#updateForExpandMode();
+    }
+    get expandMode() {
+        return this.#repeaterService.expandMode;
+    }
+    #autoScroller;
+    #ngUnsubscribe;
+    #itemNameWarned;
+    #adapterService;
+    #changeDetector;
+    #dragulaService;
+    #elementRef;
+    #renderer;
+    #repeaterService;
+    #autoScrollSvc;
+    #scrollableHostSvc;
+    #logSvc;
+    constructor() {
+        /**
+         * Whether users can change the order of items in the repeater list.
+         * Each repeater item also has `reorderable` property to indicate whether
+         * users can change its order.
+         */
+        this.reorderable = false;
+        /**
+         * Fires when the active repeater item changes.
+         */
+        this.activeIndexChange = new EventEmitter();
+        /**
+         * Fires when users change the order of repeater items.
+         * This event emits an ordered array of the `tag` properties that the consumer provides for each repeater item.
+         */
+        this.orderChange = new EventEmitter();
+        this.#ngUnsubscribe = new Subject();
+        this.#itemNameWarned = false;
+        this.#adapterService = inject(SkyRepeaterAdapterService);
+        this.#changeDetector = inject(ChangeDetectorRef);
+        this.#dragulaService = inject(DragulaService);
+        this.#elementRef = inject(ElementRef);
+        this.#renderer = inject(Renderer2);
+        this.#repeaterService = inject(SkyRepeaterService);
+        this.#autoScrollSvc = inject(SkyRepeaterAutoScrollService);
+        this.#scrollableHostSvc = inject(SkyScrollableHostService);
+        this.#logSvc = inject(SkyLogService);
+        this.dragulaGroupName = `sky-repeater-dragula-${this.#repeaterService.repeaterGroupId}`;
+        this.#repeaterService.itemCollapseStateChange
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((item) => {
+            if (this.expandMode === 'single' && item.isExpanded) {
+                this.items?.forEach((otherItem) => {
+                    if (otherItem !== item &&
+                        otherItem.isExpanded &&
+                        otherItem.isCollapsible) {
+                        otherItem.isExpanded = false;
+                    }
+                });
+            }
+        });
+        this.#repeaterService.activeItemIndexChange
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((index) => {
+            if (index !== this.activeIndex) {
+                this.activeIndex = index;
+                this.activeIndexChange.emit(index);
+            }
+        });
+        this.#repeaterService.orderChange
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe(() => {
+            this.#emitTags();
+        });
+        this.#updateForExpandMode();
+        this.#adapterService.setRepeaterHost(this.#elementRef);
+        this.#initializeDragAndDrop();
+    }
+    ngAfterContentInit() {
+        // If activeIndex has been set on init, call service to activate the appropriate item.
+        setTimeout(() => {
+            if (this.activeIndex || this.activeIndex === 0) {
+                this.#repeaterService.activateItemByIndex(this.activeIndex);
+            }
+            this.#validateTags();
+        });
+        // HACK: Not updating for expand mode in a timeout causes an error.
+        // https://github.com/angular/angular/issues/6005
+        this.items?.changes.pipe(takeUntil(this.#ngUnsubscribe)).subscribe(() => {
+            setTimeout(() => {
+                if (this.items?.length) {
+                    this.#updateForExpandMode(this.items.last);
+                    this.#updateReorderability();
+                    this.#repeaterService.items = this.items.toArray();
+                }
+                if (this.activeIndex !== undefined) {
+                    this.#repeaterService.activateItemByIndex(this.activeIndex);
+                }
+                this.#updateRole();
+                this.#validateTags();
+            });
+        });
+        setTimeout(() => {
+            this.#updateForExpandMode();
+            this.items?.forEach((item) => {
+                item.reorderable = this.reorderable;
+            });
+            this.#updateRole();
+        }, 0);
+    }
+    ngAfterViewChecked() {
+        if (!this.#itemNameWarned && this.items?.some((item) => !item.itemName)) {
+            this.#logSvc?.deprecated('SkyRepeaterItemComponent without `itemName`', {
+                deprecationMajorVersion: 8,
+                replacementRecommendation: 'Always specify an `itemName` property.',
+            });
+            this.#itemNameWarned = true;
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['activeIndex']) {
+            this.#repeaterService.enableActiveState = true;
+            if (changes['activeIndex'].currentValue !==
+                changes['activeIndex'].previousValue) {
+                this.#repeaterService.activateItemByIndex(this.activeIndex);
+            }
+        }
+        if (changes['reorderable']) {
+            if (this.items) {
+                this.#updateReorderability();
+            }
+            this.#updateRole();
+            this.#changeDetector.markForCheck();
+        }
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+        this.#destroyDragAndDrop();
+    }
+    ngOnInit() {
+        this.#updateRole();
+    }
+    onCdkObserveContent() {
+        this.#updateRole();
+    }
+    #updateForExpandMode(itemAdded) {
+        if (this.items) {
+            let foundExpanded = false;
+            const isCollapsible = this.expandMode !== 'none';
+            const isSingle = this.expandMode === 'single';
+            // Keep any newly-added expanded item expanded and collapse the rest.
+            if (itemAdded && itemAdded.isExpanded) {
+                foundExpanded = true;
+            }
+            for (const item of this.items) {
+                item.isCollapsible = isCollapsible && !!item.hasItemContent;
+                // Collapse any items that aren't the item that was just added.
+                if (item !== itemAdded && isSingle && item.isExpanded) {
+                    if (foundExpanded) {
+                        // If this item is being collapsed because a new item was
+                        // added, animate it.
+                        item.updateForExpanded(false, !!itemAdded);
+                    }
+                    foundExpanded = true;
+                }
+            }
+            this.#updateRole();
+        }
+    }
+    #initializeDragAndDrop() {
+        /* Sanity check that we haven't already set up dragging abilities */
+        /* istanbul ignore else */
+        if (!this.#dragulaService.find(this.dragulaGroupName)) {
+            this.#dragulaService.createGroup(this.dragulaGroupName, {
+                moves: (el, _container, handle) => {
+                    const target = el?.querySelector('.sky-repeater-item-grab-handle');
+                    return !!(this.reorderable && target?.contains(handle));
+                },
+            });
+        }
+        let draggedItemIndex = -1;
+        this.#dragulaService
+            .drag(this.dragulaGroupName)
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((args) => {
+            /* istanbul ignore else */
+            if (args.name === this.dragulaGroupName) {
+                this.#destroyAutoScroll();
+                this.#autoScroller = this.#autoScrollSvc.autoScroll([this.#scrollableHostSvc.getScrollableHost(this.#elementRef)], {
+                    margin: 20,
+                    maxSpeed: 10,
+                    scrollWhenOutside: true,
+                    autoScroll: () => true,
+                });
+                this.#renderer.addClass(args.el, 'sky-repeater-item-dragging');
+                draggedItemIndex = this.#adapterService.getRepeaterItemIndex(args.el);
+            }
+        });
+        this.#dragulaService
+            .dragend(this.dragulaGroupName)
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((args) => {
+            /* istanbul ignore else */
+            if (args.name === this.dragulaGroupName) {
+                this.#destroyAutoScroll();
+                this.#renderer.removeClass(args.el, 'sky-repeater-item-dragging');
+                const newItemIndex = this.#adapterService.getRepeaterItemIndex(args.el);
+                /* sanity check */
+                /* istanbul ignore else */
+                if (draggedItemIndex >= 0) {
+                    this.#repeaterService.reorderItem(draggedItemIndex, newItemIndex);
+                    draggedItemIndex = -1;
+                }
+                this.#emitTags();
+            }
+        });
+    }
+    #destroyDragAndDrop() {
+        /* Sanity check that we have set up dragging abilities */
+        /* istanbul ignore else */
+        if (this.#dragulaService.find(this.dragulaGroupName)) {
+            this.#dragulaService.destroy(this.dragulaGroupName);
+        }
+        this.#destroyAutoScroll();
+    }
+    #destroyAutoScroll() {
+        if (this.#autoScroller) {
+            this.#autoScroller.destroy();
+            this.#autoScroller = undefined;
+        }
+    }
+    #emitTags() {
+        const tags = this.#repeaterService.items.map((item) => item.tag);
+        this.orderChange.emit(tags);
+    }
+    #everyItemHasTag() {
+        /* sanity check */
+        /* istanbul ignore if */
+        if (!this.items || this.items.length === 0) {
+            return false;
+        }
+        return this.items.toArray().every((item) => {
+            return item.tag !== undefined;
+        });
+    }
+    #updateRole() {
+        // Determine a role using a hierarchy based on https://www.w3.org/TR/wai-aria-practices-1.1/
+        //   1. If there are one or more interactions in the repeater item projected content, use grid.
+        //   2. If there are selectable repeater items and no other interactions, use listbox.
+        //   3. If there are no interactions, use list.
+        // Default to list role.
+        let autoRole = 'list';
+        const roleMap = {
+            list: { item: 'listitem', title: undefined, content: undefined },
+            listbox: { item: 'option', title: undefined, content: undefined },
+            grid: { item: 'row', title: 'rowheader', content: 'gridcell' },
+        };
+        // Based on https://html.spec.whatwg.org/multipage/dom.html#interactive-content
+        const interactionSelector = [
+            'a[href]',
+            'audio[controls]',
+            'button',
+            'details',
+            'embed',
+            'iframe',
+            'img[usemap]',
+            'input:not([type="hidden"])',
+            'label',
+            'select',
+            'textarea',
+            'video[controls]',
+            '[contenteditable]',
+            '.sky-repeater[role="grid"]',
+        ]
+            .map((selector) => `sky-repeater-item-title ${selector}:not([hidden]), sky-repeater-item-content ${selector}:not([hidden])`)
+            .concat([`skyux-dropdown`])
+            .join(', ');
+        const hasInteraction = this.reorderable ||
+            this.items?.some((item) => item.isCollapsible) ||
+            this.items?.some((item) => !!item.selectable) ||
+            !!this.#elementRef.nativeElement.querySelector(interactionSelector);
+        if (hasInteraction) {
+            // If the repeater matches interaction selector https://www.w3.org/TR/wai-aria-practices-1.1/#grid
+            autoRole = 'grid';
+        }
+        if (this.role !== autoRole) {
+            this.#repeaterService.itemRole.next({
+                ...roleMap[autoRole],
+            });
+            this.role = `${autoRole}`;
+            this.#changeDetector.markForCheck();
+        }
+    }
+    #updateReorderability() {
+        if (this.items) {
+            for (const item of this.items) {
+                item.reorderable = this.reorderable;
+            }
+        }
+    }
+    #validateTags() {
+        if (this.reorderable && !this.#everyItemHasTag()) {
+            console.warn('Please supply tag properties for each repeater item when reordering functionality is enabled.');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyRepeaterComponent, selector: "sky-repeater", inputs: { activeIndex: "activeIndex", ariaLabel: "ariaLabel", reorderable: "reorderable", expandMode: "expandMode" }, outputs: { activeIndexChange: "activeIndexChange", orderChange: "orderChange" }, providers: [
+            SkyRepeaterService,
+            SkyRepeaterAdapterService,
+            SkyRepeaterAutoScrollService,
+        ], queries: [{ propertyName: "items", predicate: SkyRepeaterItemComponent }], usesOnChanges: true, ngImport: i0, template: "<ng-container #repeaterHost>\n  <div\n    class=\"sky-repeater\"\n    [attr.role]=\"role\"\n    [attr.aria-label]=\"ariaLabel || ('skyux_repeater_label' | skyLibResources)\"\n    [dragula]=\"dragulaGroupName\"\n    (cdkObserveContent)=\"onCdkObserveContent()\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-container>\n", styles: [".sky-repeater{padding:0}\n"], dependencies: [{ kind: "directive", type: i1.DragulaDirective, selector: "[dragula]", inputs: ["dragula", "dragulaModel"], outputs: ["dragulaModelChange"] }, { kind: "directive", type: i2.CdkObserveContent, selector: "[cdkObserveContent]", inputs: ["cdkObserveContentDisabled", "debounce"], outputs: ["cdkObserveContent"], exportAs: ["cdkObserveContent"] }, { kind: "pipe", type: i3.SkyLibResourcesPipe, name: "skyLibResources" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-repeater', providers: [
+                        SkyRepeaterService,
+                        SkyRepeaterAdapterService,
+                        SkyRepeaterAutoScrollService,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container #repeaterHost>\n  <div\n    class=\"sky-repeater\"\n    [attr.role]=\"role\"\n    [attr.aria-label]=\"ariaLabel || ('skyux_repeater_label' | skyLibResources)\"\n    [dragula]=\"dragulaGroupName\"\n    (cdkObserveContent)=\"onCdkObserveContent()\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-container>\n", styles: [".sky-repeater{padding:0}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { activeIndex: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], reorderable: [{
+                type: Input
+            }], expandMode: [{
+                type: Input
+            }], activeIndexChange: [{
+                type: Output
+            }], orderChange: [{
+                type: Output
+            }], items: [{
+                type: ContentChildren,
+                args: [SkyRepeaterItemComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"repeater.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/lists/src/lib/modules/repeater/repeater.component.ts","../../../../../../../../libs/components/lists/src/lib/modules/repeater/repeater.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewChecked,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  inject,\n} from '@angular/core';\nimport { SkyLogService } from '@skyux/core';\nimport { SkyScrollableHostService } from '@skyux/core';\n\nimport { DragulaService } from 'ng2-dragula';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyRepeaterAdapterService } from './repeater-adapter.service';\nimport { SkyRepeaterAutoScrollService } from './repeater-auto-scroll.service';\nimport { SkyRepeaterAutoScroller } from './repeater-auto-scroller';\nimport { SkyRepeaterExpandModeType } from './repeater-expand-mode-type';\nimport { SkyRepeaterItemRolesType } from './repeater-item-roles.type';\nimport { SkyRepeaterItemComponent } from './repeater-item.component';\nimport { SkyRepeaterRoleType } from './repeater-role.type';\nimport { SkyRepeaterService } from './repeater.service';\n\n/**\n * Creates a container to display repeater items.\n */\n@Component({\n  selector: 'sky-repeater',\n  styleUrls: ['./repeater.component.scss'],\n  templateUrl: './repeater.component.html',\n  providers: [\n    SkyRepeaterService,\n    SkyRepeaterAdapterService,\n    SkyRepeaterAutoScrollService,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SkyRepeaterComponent\n  implements AfterContentInit, AfterViewChecked, OnChanges, OnDestroy, OnInit\n{\n  /**\n   * The index of the repeater item to visually highlight as active.\n   * For example, use this property in conjunction with the\n   * [split view component](https://developer.blackbaud.com/skyux/components/split-view)\n   * to highlight a repeater item while users edit it. Only one item can be active at a time.\n   */\n  @Input()\n  public activeIndex: number | undefined;\n\n  /**\n   * The ARIA label for the repeater list.\n   * This sets the repeater list's `aria-label` attribute to provide a text equivalent for screen readers\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).\n   * For more information about the `aria-label` attribute, see the [WAI-ARIA definition](https://www.w3.org/TR/wai-aria/#aria-label).\n   * @default \"List of items\"\n   */\n  @Input()\n  public ariaLabel: string | undefined;\n\n  /**\n   * Whether users can change the order of items in the repeater list.\n   * Each repeater item also has `reorderable` property to indicate whether\n   * users can change its order.\n   */\n  @Input()\n  public reorderable: boolean | undefined = false;\n\n  /**\n   * The layout that determines which repeater items are expanded by default and whether\n   * repeater items are expandable and collapsible. Collapsed items display titles only.\n   * The valid options are `multiple`, `none`, and `single`.\n   * - `multiple` loads repeater items in an expanded state unless `isExpanded` is set to\n   * `false` for a repeater item. This layout allows users to expand and collapse\n   * as many repeater items as necessary. It is best-suited to repeater items where body\n   * content is important but users don't always need to see it.\n   * - `none` loads all repeater items in an expanded state and does not allow users to\n   * collapse them. This default layout provides the quickest access to the details in the\n   * repeater items. It is best-suited to repeater items with concise content\n   * that users need to view frequently.\n   * - `single` loads one repeater item in an expanded state and collapses all others.\n   * The expanded repeater item is the first one where `isExpanded` is set to `true`. This layout\n   * allows users to expand one item at a time. It provides the most compact view and is\n   * best-suited to repeater items where the most important information is in the titles\n   * and users only occasionally need to view the body content.\n   * @default \"none\"\n   */\n  @Input()\n  public set expandMode(value: SkyRepeaterExpandModeType | undefined) {\n    this.#repeaterService.expandMode = value;\n    this.#updateForExpandMode();\n  }\n\n  public get expandMode(): SkyRepeaterExpandModeType {\n    return this.#repeaterService.expandMode;\n  }\n\n  /**\n   * Fires when the active repeater item changes.\n   */\n  @Output()\n  public activeIndexChange = new EventEmitter<number>();\n\n  /**\n   * Fires when users change the order of repeater items.\n   * This event emits an ordered array of the `tag` properties that the consumer provides for each repeater item.\n   */\n  @Output()\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public orderChange = new EventEmitter<any[]>();\n\n  @ContentChildren(SkyRepeaterItemComponent)\n  public items: QueryList<SkyRepeaterItemComponent> | undefined;\n\n  public dragulaGroupName: string;\n\n  public role: SkyRepeaterRoleType | undefined;\n\n  #autoScroller: SkyRepeaterAutoScroller | undefined;\n  #ngUnsubscribe = new Subject<void>();\n  #itemNameWarned = false;\n\n  #adapterService = inject(SkyRepeaterAdapterService);\n  #changeDetector = inject(ChangeDetectorRef);\n  #dragulaService = inject(DragulaService);\n  #elementRef = inject(ElementRef);\n  #renderer = inject(Renderer2);\n  #repeaterService = inject(SkyRepeaterService);\n  #autoScrollSvc = inject(SkyRepeaterAutoScrollService);\n  #scrollableHostSvc = inject(SkyScrollableHostService);\n  #logSvc = inject(SkyLogService);\n\n  constructor() {\n    this.dragulaGroupName = `sky-repeater-dragula-${\n      this.#repeaterService.repeaterGroupId\n    }`;\n\n    this.#repeaterService.itemCollapseStateChange\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((item: SkyRepeaterItemComponent) => {\n        if (this.expandMode === 'single' && item.isExpanded) {\n          this.items?.forEach((otherItem) => {\n            if (\n              otherItem !== item &&\n              otherItem.isExpanded &&\n              otherItem.isCollapsible\n            ) {\n              otherItem.isExpanded = false;\n            }\n          });\n        }\n      });\n\n    this.#repeaterService.activeItemIndexChange\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((index) => {\n        if (index !== this.activeIndex) {\n          this.activeIndex = index;\n          this.activeIndexChange.emit(index);\n        }\n      });\n\n    this.#repeaterService.orderChange\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe(() => {\n        this.#emitTags();\n      });\n\n    this.#updateForExpandMode();\n\n    this.#adapterService.setRepeaterHost(this.#elementRef);\n\n    this.#initializeDragAndDrop();\n  }\n\n  public ngAfterContentInit(): void {\n    // If activeIndex has been set on init, call service to activate the appropriate item.\n    setTimeout(() => {\n      if (this.activeIndex || this.activeIndex === 0) {\n        this.#repeaterService.activateItemByIndex(this.activeIndex);\n      }\n\n      this.#validateTags();\n    });\n\n    // HACK: Not updating for expand mode in a timeout causes an error.\n    // https://github.com/angular/angular/issues/6005\n    this.items?.changes.pipe(takeUntil(this.#ngUnsubscribe)).subscribe(() => {\n      setTimeout(() => {\n        if (this.items?.length) {\n          this.#updateForExpandMode(this.items.last);\n\n          this.#updateReorderability();\n\n          this.#repeaterService.items = this.items.toArray();\n        }\n\n        if (this.activeIndex !== undefined) {\n          this.#repeaterService.activateItemByIndex(this.activeIndex);\n        }\n\n        this.#updateRole();\n\n        this.#validateTags();\n      });\n    });\n\n    setTimeout(() => {\n      this.#updateForExpandMode();\n\n      this.items?.forEach((item) => {\n        item.reorderable = this.reorderable;\n      });\n\n      this.#updateRole();\n    }, 0);\n  }\n\n  public ngAfterViewChecked(): void {\n    if (!this.#itemNameWarned && this.items?.some((item) => !item.itemName)) {\n      this.#logSvc?.deprecated('SkyRepeaterItemComponent without `itemName`', {\n        deprecationMajorVersion: 8,\n        replacementRecommendation: 'Always specify an `itemName` property.',\n      });\n\n      this.#itemNameWarned = true;\n    }\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (changes['activeIndex']) {\n      this.#repeaterService.enableActiveState = true;\n      if (\n        changes['activeIndex'].currentValue !==\n        changes['activeIndex'].previousValue\n      ) {\n        this.#repeaterService.activateItemByIndex(this.activeIndex);\n      }\n    }\n\n    if (changes['reorderable']) {\n      if (this.items) {\n        this.#updateReorderability();\n      }\n      this.#updateRole();\n\n      this.#changeDetector.markForCheck();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n    this.#destroyDragAndDrop();\n  }\n\n  public ngOnInit(): void {\n    this.#updateRole();\n  }\n\n  public onCdkObserveContent(): void {\n    this.#updateRole();\n  }\n\n  #updateForExpandMode(itemAdded?: SkyRepeaterItemComponent): void {\n    if (this.items) {\n      let foundExpanded = false;\n      const isCollapsible = this.expandMode !== 'none';\n      const isSingle = this.expandMode === 'single';\n\n      // Keep any newly-added expanded item expanded and collapse the rest.\n      if (itemAdded && itemAdded.isExpanded) {\n        foundExpanded = true;\n      }\n\n      for (const item of this.items) {\n        item.isCollapsible = isCollapsible && !!item.hasItemContent;\n\n        // Collapse any items that aren't the item that was just added.\n        if (item !== itemAdded && isSingle && item.isExpanded) {\n          if (foundExpanded) {\n            // If this item is being collapsed because a new item was\n            // added, animate it.\n            item.updateForExpanded(false, !!itemAdded);\n          }\n\n          foundExpanded = true;\n        }\n      }\n\n      this.#updateRole();\n    }\n  }\n\n  #initializeDragAndDrop(): void {\n    /* Sanity check that we haven't already set up dragging abilities */\n    /* istanbul ignore else */\n    if (!this.#dragulaService.find(this.dragulaGroupName)) {\n      this.#dragulaService.createGroup(this.dragulaGroupName, {\n        moves: (el, _container, handle) => {\n          const target = el?.querySelector('.sky-repeater-item-grab-handle');\n          return !!(\n            this.reorderable && target?.contains(handle as Element | null)\n          );\n        },\n      });\n    }\n\n    let draggedItemIndex = -1;\n\n    this.#dragulaService\n      .drag(this.dragulaGroupName)\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((args) => {\n        /* istanbul ignore else */\n        if (args.name === this.dragulaGroupName) {\n          this.#destroyAutoScroll();\n\n          this.#autoScroller = this.#autoScrollSvc.autoScroll(\n            [this.#scrollableHostSvc.getScrollableHost(this.#elementRef)],\n            {\n              margin: 20,\n              maxSpeed: 10,\n              scrollWhenOutside: true,\n              autoScroll: () => true,\n            }\n          );\n\n          this.#renderer.addClass(args.el, 'sky-repeater-item-dragging');\n          draggedItemIndex = this.#adapterService.getRepeaterItemIndex(\n            args.el as HTMLElement\n          );\n        }\n      });\n\n    this.#dragulaService\n      .dragend(this.dragulaGroupName)\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((args) => {\n        /* istanbul ignore else */\n        if (args.name === this.dragulaGroupName) {\n          this.#destroyAutoScroll();\n\n          this.#renderer.removeClass(args.el, 'sky-repeater-item-dragging');\n          const newItemIndex = this.#adapterService.getRepeaterItemIndex(\n            args.el as HTMLElement\n          );\n\n          /* sanity check */\n          /* istanbul ignore else */\n          if (draggedItemIndex >= 0) {\n            this.#repeaterService.reorderItem(draggedItemIndex, newItemIndex);\n            draggedItemIndex = -1;\n          }\n\n          this.#emitTags();\n        }\n      });\n  }\n\n  #destroyDragAndDrop(): void {\n    /* Sanity check that we have set up dragging abilities */\n    /* istanbul ignore else */\n    if (this.#dragulaService.find(this.dragulaGroupName)) {\n      this.#dragulaService.destroy(this.dragulaGroupName);\n    }\n\n    this.#destroyAutoScroll();\n  }\n\n  #destroyAutoScroll(): void {\n    if (this.#autoScroller) {\n      this.#autoScroller.destroy();\n      this.#autoScroller = undefined;\n    }\n  }\n\n  #emitTags(): void {\n    const tags = this.#repeaterService.items.map((item) => item.tag);\n    this.orderChange.emit(tags);\n  }\n\n  #everyItemHasTag(): boolean {\n    /* sanity check */\n    /* istanbul ignore if */\n    if (!this.items || this.items.length === 0) {\n      return false;\n    }\n    return this.items.toArray().every((item) => {\n      return item.tag !== undefined;\n    });\n  }\n\n  #updateRole(): void {\n    // Determine a role using a hierarchy based on https://www.w3.org/TR/wai-aria-practices-1.1/\n    //   1. If there are one or more interactions in the repeater item projected content, use grid.\n    //   2. If there are selectable repeater items and no other interactions, use listbox.\n    //   3. If there are no interactions, use list.\n\n    // Default to list role.\n    let autoRole: SkyRepeaterRoleType = 'list';\n\n    const roleMap: Record<SkyRepeaterRoleType, SkyRepeaterItemRolesType> = {\n      list: { item: 'listitem', title: undefined, content: undefined },\n      listbox: { item: 'option', title: undefined, content: undefined },\n      grid: { item: 'row', title: 'rowheader', content: 'gridcell' },\n    };\n\n    // Based on https://html.spec.whatwg.org/multipage/dom.html#interactive-content\n    const interactionSelector = [\n      'a[href]',\n      'audio[controls]',\n      'button',\n      'details',\n      'embed',\n      'iframe',\n      'img[usemap]',\n      'input:not([type=\"hidden\"])',\n      'label',\n      'select',\n      'textarea',\n      'video[controls]',\n      '[contenteditable]',\n      '.sky-repeater[role=\"grid\"]',\n    ]\n      .map(\n        (selector) =>\n          `sky-repeater-item-title ${selector}:not([hidden]), sky-repeater-item-content ${selector}:not([hidden])`\n      )\n      .concat([`skyux-dropdown`])\n      .join(', ');\n\n    const hasInteraction =\n      this.reorderable ||\n      this.items?.some((item) => item.isCollapsible) ||\n      this.items?.some((item) => !!item.selectable) ||\n      !!(this.#elementRef.nativeElement as HTMLElement).querySelector(\n        interactionSelector\n      );\n\n    if (hasInteraction) {\n      // If the repeater matches interaction selector https://www.w3.org/TR/wai-aria-practices-1.1/#grid\n      autoRole = 'grid';\n    }\n\n    if (this.role !== autoRole) {\n      this.#repeaterService.itemRole.next({\n        ...roleMap[autoRole],\n      });\n      this.role = `${autoRole}`;\n      this.#changeDetector.markForCheck();\n    }\n  }\n\n  #updateReorderability(): void {\n    if (this.items) {\n      for (const item of this.items) {\n        item.reorderable = this.reorderable;\n      }\n    }\n  }\n\n  #validateTags(): void {\n    if (this.reorderable && !this.#everyItemHasTag()) {\n      console.warn(\n        'Please supply tag properties for each repeater item when reordering functionality is enabled.'\n      );\n    }\n  }\n}\n","<ng-container #repeaterHost>\n  <div\n    class=\"sky-repeater\"\n    [attr.role]=\"role\"\n    [attr.aria-label]=\"ariaLabel || ('skyux_repeater_label' | skyLibResources)\"\n    [dragula]=\"dragulaGroupName\"\n    (cdkObserveContent)=\"onCdkObserveContent()\"\n  >\n    <ng-content></ng-content>\n  </div>\n</ng-container>\n"]}

package/{esm2020 → esm2022}/lib/modules/repeater/repeater.module.mjs

@@ -13,33 +13,33 @@ import { SkyRepeaterItemComponent } from './repeater-item.component';
 import { SkyRepeaterComponent } from './repeater.component';
 import * as i0 from "@angular/core";
 export class SkyRepeaterModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterModule, declarations: [SkyRepeaterComponent,
+            SkyRepeaterItemComponent,
+            SkyRepeaterItemContentComponent,
+            SkyRepeaterItemContextMenuComponent,
+            SkyRepeaterItemTitleComponent], imports: [CommonModule,
+            DragulaModule,
+            ObserversModule,
+            SkyChevronModule,
+            SkyCheckboxModule,
+            SkyIconModule,
+            SkyInlineFormModule,
+            SkyListsResourcesModule], exports: [SkyRepeaterComponent,
+            SkyRepeaterItemComponent,
+            SkyRepeaterItemContentComponent,
+            SkyRepeaterItemContextMenuComponent,
+            SkyRepeaterItemTitleComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterModule, providers: [DragulaService], imports: [CommonModule,
+            DragulaModule,
+            ObserversModule,
+            SkyChevronModule,
+            SkyCheckboxModule,
+            SkyIconModule,
+            SkyInlineFormModule,
+            SkyListsResourcesModule] }); }
 }
-SkyRepeaterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyRepeaterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SkyRepeaterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SkyRepeaterModule, declarations: [SkyRepeaterComponent,
-        SkyRepeaterItemComponent,
-        SkyRepeaterItemContentComponent,
-        SkyRepeaterItemContextMenuComponent,
-        SkyRepeaterItemTitleComponent], imports: [CommonModule,
-        DragulaModule,
-        ObserversModule,
-        SkyChevronModule,
-        SkyCheckboxModule,
-        SkyIconModule,
-        SkyInlineFormModule,
-        SkyListsResourcesModule], exports: [SkyRepeaterComponent,
-        SkyRepeaterItemComponent,
-        SkyRepeaterItemContentComponent,
-        SkyRepeaterItemContextMenuComponent,
-        SkyRepeaterItemTitleComponent] });
-SkyRepeaterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyRepeaterModule, providers: [DragulaService], imports: [CommonModule,
-        DragulaModule,
-        ObserversModule,
-        SkyChevronModule,
-        SkyCheckboxModule,
-        SkyIconModule,
-        SkyInlineFormModule,
-        SkyListsResourcesModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyRepeaterModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -69,4 +69,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     providers: [DragulaService],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/repeater/repeater.service.mjs

@@ -0,0 +1,86 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+let uniqueId = 0;
+const DEFAULT_EXPAND_MODE = 'none';
+/**
+ * @internal
+ */
+export class SkyRepeaterService {
+    constructor() {
+        this.activeItemChange = new BehaviorSubject(undefined);
+        this.activeItemIndexChange = new BehaviorSubject(undefined);
+        this.enableActiveState = false;
+        this.itemCollapseStateChange = new EventEmitter();
+        this.items = [];
+        this.itemRole = new BehaviorSubject({
+            content: undefined,
+            item: undefined,
+            title: undefined,
+        });
+        this.orderChange = new BehaviorSubject(undefined);
+        this.repeaterGroupId = ++uniqueId;
+        this.#_expandMode = DEFAULT_EXPAND_MODE;
+    }
+    // TODO: Remove 'string' as a valid type in a breaking change.
+    get expandMode() {
+        return this.#_expandMode;
+    }
+    set expandMode(value) {
+        this.#_expandMode = value ?? DEFAULT_EXPAND_MODE;
+    }
+    #_expandMode;
+    ngOnDestroy() {
+        this.activeItemChange.complete();
+        this.itemCollapseStateChange.complete();
+        this.orderChange.complete();
+    }
+    activateItem(item) {
+        if (this.enableActiveState) {
+            /* istanbul ignore else */
+            if (item && !item.disabled) {
+                const index = this.items.findIndex((i) => i === item);
+                this.activeItemIndexChange.next(index);
+                this.activeItemChange.next(item);
+            }
+        }
+    }
+    activateItemByIndex(index) {
+        /* istanbul ignore else */
+        if (this.enableActiveState) {
+            if (index === undefined) {
+                this.activeItemChange.next(undefined);
+            }
+            else {
+                const activeItem = this.items[index];
+                if (activeItem && !activeItem.disabled) {
+                    this.activeItemChange.next(activeItem);
+                }
+            }
+        }
+    }
+    registerItem(item) {
+        this.items.push(item);
+    }
+    unregisterItem(item) {
+        const indexOfDestroyedItem = this.items.indexOf(item);
+        if (indexOfDestroyedItem > -1) {
+            this.items.splice(indexOfDestroyedItem, 1);
+        }
+    }
+    onItemCollapseStateChange(item) {
+        this.itemCollapseStateChange.emit(item);
+    }
+    registerOrderChange() {
+        this.orderChange.next();
+    }
+    reorderItem(oldIndex, newIndex) {
+        this.items.splice(newIndex, 0, this.items.splice(oldIndex, 1)[0]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyRepeaterService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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