@jupyterlab/ui-components 4.1.0-alpha.3 → 4.1.0-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -721,7 +721,8 @@ export abstract class WindowedListModel implements WindowedList.IModel {
721
721
  * Windowed list widget
722
722
  */
723
723
  export class WindowedList<
724
- T extends WindowedList.IModel = WindowedList.IModel
724
+ T extends WindowedList.IModel = WindowedList.IModel,
725
+ U = any
725
726
  > extends Widget {
726
727
  /**
727
728
  * Default widget size
@@ -733,29 +734,50 @@ export class WindowedList<
733
734
  *
734
735
  * @param options Constructor options
735
736
  */
736
- constructor(options: WindowedList.IOptions<T>) {
737
- // TODO probably needs to be able to customize outer HTML tag (could be ul / ol / table, ...)
737
+ constructor(options: WindowedList.IOptions<T, U>) {
738
+ const renderer = options.renderer ?? WindowedList.defaultRenderer;
739
+
738
740
  const node = document.createElement('div');
739
- node.className = 'jp-WindowedPanel-outer';
740
- const innerElement = node.appendChild(document.createElement('div'));
741
- innerElement.className = 'jp-WindowedPanel-inner';
742
- const windowContainer = innerElement.appendChild(
741
+ node.className = 'jp-WindowedPanel';
742
+
743
+ const scrollbarElement = node.appendChild(document.createElement('div'));
744
+ scrollbarElement.classList.add('jp-WindowedPanel-scrollbar');
745
+
746
+ const list = scrollbarElement.appendChild(renderer.createScrollbar());
747
+ list.classList.add('jp-WindowedPanel-scrollbar-content');
748
+
749
+ const outerElement = node.appendChild(renderer.createOuter());
750
+ outerElement.classList.add('jp-WindowedPanel-outer');
751
+
752
+ const innerElement = outerElement.appendChild(
743
753
  document.createElement('div')
744
754
  );
745
- windowContainer.className = 'jp-WindowedPanel-window';
755
+ innerElement.className = 'jp-WindowedPanel-inner';
756
+
757
+ const viewport = innerElement.appendChild(renderer.createViewport());
758
+ viewport.classList.add('jp-WindowedPanel-viewport');
759
+
746
760
  super({ node });
747
761
  super.layout = options.layout ?? new WindowedLayout();
748
- this._viewModel = options.model;
762
+ this.renderer = renderer;
763
+
749
764
  this._innerElement = innerElement;
750
765
  this._isScrolling = null;
751
- this._windowElement = windowContainer;
766
+ this._outerElement = outerElement;
767
+ this._resizeObserver = null;
768
+ this._scrollbarElement = scrollbarElement;
752
769
  this._scrollToItem = null;
753
770
  this._scrollRepaint = null;
754
771
  this._scrollUpdateWasRequested = false;
755
772
  this._updater = new Throttler(() => this.update(), 50);
756
- this._resizeObserver = null;
773
+ this._viewModel = options.model;
774
+ this._viewport = viewport;
775
+
776
+ if (options.scrollbar) {
777
+ node.classList.add('jp-mod-virtual-scrollbar');
778
+ }
757
779
 
758
- this._viewModel.stateChanged.connect(this.onStateChanged, this);
780
+ this.viewModel.stateChanged.connect(this.onStateChanged, this);
759
781
  }
760
782
 
761
783
  /**
@@ -778,13 +800,41 @@ export class WindowedList<
778
800
  return super.layout as WindowedLayout;
779
801
  }
780
802
 
803
+ /**
804
+ * The outer container of the windowed list.
805
+ */
806
+ get outerNode(): HTMLElement {
807
+ return this._outerElement;
808
+ }
809
+
781
810
  /**
782
811
  * Viewport
783
812
  */
784
- get viewportNode(): HTMLDivElement {
785
- return this._windowElement;
813
+ get viewportNode(): HTMLElement {
814
+ return this._viewport;
786
815
  }
787
816
 
817
+ /**
818
+ * Flag to enable virtual scrollbar.
819
+ */
820
+ get scrollbar(): boolean {
821
+ return this.node.classList.contains('jp-mod-virtual-scrollbar');
822
+ }
823
+ set scrollbar(enabled: boolean) {
824
+ if (enabled) {
825
+ this.node.classList.add('jp-mod-virtual-scrollbar');
826
+ } else {
827
+ this.node.classList.remove('jp-mod-virtual-scrollbar');
828
+ }
829
+ this._adjustDimensionsForScrollbar();
830
+ this.update();
831
+ }
832
+
833
+ /**
834
+ * The renderer for this windowed list. Set at instantiation.
835
+ */
836
+ protected renderer: WindowedList.IRenderer<U>;
837
+
788
838
  /**
789
839
  * Windowed list view model
790
840
  */
@@ -807,6 +857,11 @@ export class WindowedList<
807
857
  */
808
858
  handleEvent(event: Event): void {
809
859
  switch (event.type) {
860
+ case 'pointerdown':
861
+ event.preventDefault();
862
+ event.stopPropagation();
863
+ this._evtPointerDown(event as PointerEvent);
864
+ break;
810
865
  case 'scroll':
811
866
  this.onScroll(event);
812
867
  break;
@@ -885,7 +940,7 @@ export class WindowedList<
885
940
  this._resetScrollToItem();
886
941
  this.scrollTo(
887
942
  this.viewModel.getOffsetForIndexAndAlignment(
888
- Math.max(0, Math.min(index, this._viewModel.widgetCount - 1)),
943
+ Math.max(0, Math.min(index, this.viewModel.widgetCount - 1)),
889
944
  align,
890
945
  margin
891
946
  )
@@ -899,7 +954,7 @@ export class WindowedList<
899
954
  */
900
955
  protected onAfterAttach(msg: Message): void {
901
956
  super.onAfterAttach(msg);
902
- if (this._viewModel.windowingActive) {
957
+ if (this.viewModel.windowingActive) {
903
958
  this._addListeners();
904
959
  } else {
905
960
  this._applyNoWindowingStyles();
@@ -907,15 +962,18 @@ export class WindowedList<
907
962
  this.viewModel.height = this.node.getBoundingClientRect().height;
908
963
  const style = window.getComputedStyle(this.node);
909
964
  this.viewModel.paddingTop = parseFloat(style.paddingTop);
965
+ this._scrollbarElement.addEventListener('pointerdown', this);
910
966
  }
911
967
 
912
968
  /**
913
969
  * A message handler invoked on an `'before-detach'` message.
914
970
  */
915
971
  protected onBeforeDetach(msg: Message): void {
916
- if (this._viewModel.windowingActive) {
972
+ if (this.viewModel.windowingActive) {
917
973
  this._removeListeners();
918
974
  }
975
+ this._scrollbarElement.removeEventListener('pointerdown', this);
976
+ super.onBeforeDetach(msg);
919
977
  }
920
978
 
921
979
  /**
@@ -962,6 +1020,7 @@ export class WindowedList<
962
1020
  void this._updater.invoke();
963
1021
  }
964
1022
  super.onResize(msg);
1023
+ void this._updater.invoke();
965
1024
  }
966
1025
 
967
1026
  /**
@@ -996,6 +1055,9 @@ export class WindowedList<
996
1055
  * The default implementation of this handler is a no-op.
997
1056
  */
998
1057
  protected onUpdateRequest(msg: Message): void {
1058
+ if (this.scrollbar) {
1059
+ this._renderScrollbar();
1060
+ }
999
1061
  if (this.viewModel.windowingActive) {
1000
1062
  // Throttle update request
1001
1063
  if (this._scrollRepaint === null) {
@@ -1016,6 +1078,52 @@ export class WindowedList<
1016
1078
  }
1017
1079
  }
1018
1080
 
1081
+ /**
1082
+ * A signal that emits the index when the virtual scrollbar jumps to an item.
1083
+ */
1084
+ protected jumped = new Signal<this, number>(this);
1085
+
1086
+ /*
1087
+ * Hide the native scrollbar if necessary and update dimensions
1088
+ */
1089
+ private _adjustDimensionsForScrollbar() {
1090
+ const outer = this._outerElement;
1091
+ const scrollbar = this._scrollbarElement;
1092
+ if (this.scrollbar) {
1093
+ // Query DOM
1094
+ let outerScrollbarWidth = outer.offsetWidth - outer.clientWidth;
1095
+ // Update DOM
1096
+
1097
+ // 1) The native scrollbar is hidden by shifting it out of view.
1098
+ if (outerScrollbarWidth == 0) {
1099
+ // If the scrollbar width is zero, one of the following is true:
1100
+ // - (a) the content is not overflowing
1101
+ // - (b) the browser uses overlay scrollbars
1102
+ // In (b) the overlay scrollbars could show up even even if
1103
+ // occluded by a child element; to prevent this resulting in
1104
+ // double scrollbar we shift the content by an arbitrary offset.
1105
+ outerScrollbarWidth = 1000;
1106
+ outer.style.paddingRight = `${outerScrollbarWidth}px`;
1107
+ outer.style.boxSizing = 'border-box';
1108
+ } else {
1109
+ outer.style.paddingRight = '0';
1110
+ }
1111
+ outer.style.width = `calc(100% + ${outerScrollbarWidth}px)`;
1112
+
1113
+ // 2) The inner window is shrank to accommodate the virtual scrollbar
1114
+ this._innerElement.style.marginRight = `${scrollbar.offsetWidth}px`;
1115
+ } else {
1116
+ // Reset all styles that may have been touched.
1117
+ outer.style.width = '100%';
1118
+ this._innerElement.style.marginRight = '0';
1119
+ outer.style.paddingRight = '0';
1120
+ outer.style.boxSizing = '';
1121
+ }
1122
+ }
1123
+
1124
+ /**
1125
+ * Add listeners for viewport, contents and the virtual scrollbar.
1126
+ */
1019
1127
  private _addListeners() {
1020
1128
  if (!this._resizeObserver) {
1021
1129
  this._resizeObserver = new ResizeObserver(
@@ -1028,22 +1136,39 @@ export class WindowedList<
1028
1136
  () => this._resizeObserver?.unobserve(widget.node)
1029
1137
  );
1030
1138
  }
1031
- this.node.addEventListener('scroll', this, passiveIfSupported);
1032
- this._windowElement.style.position = 'absolute';
1139
+ this._outerElement.addEventListener('scroll', this, passiveIfSupported);
1140
+ this._viewport.style.position = 'absolute';
1141
+
1142
+ this._scrollbarResizeObserver = new ResizeObserver(
1143
+ this._adjustDimensionsForScrollbar.bind(this)
1144
+ );
1145
+ this._scrollbarResizeObserver.observe(this._outerElement);
1146
+ this._scrollbarResizeObserver.observe(this._scrollbarElement);
1033
1147
  }
1034
1148
 
1149
+ /**
1150
+ * Turn off windowing related styles in the viewport.
1151
+ */
1035
1152
  private _applyNoWindowingStyles() {
1036
- this._windowElement.style.position = 'relative';
1037
- this._windowElement.style.top = '0px';
1153
+ this._viewport.style.position = 'relative';
1154
+ this._viewport.style.top = '0px';
1038
1155
  }
1039
1156
 
1157
+ /**
1158
+ * Remove listeners for viewport and contents (but not the virtual scrollbar).
1159
+ */
1040
1160
  private _removeListeners() {
1041
- this.node.removeEventListener('scroll', this);
1161
+ this._outerElement.removeEventListener('scroll', this);
1042
1162
  this._resizeObserver?.disconnect();
1043
1163
  this._resizeObserver = null;
1164
+ this._scrollbarResizeObserver?.disconnect();
1165
+ this._scrollbarResizeObserver = null;
1044
1166
  this._applyNoWindowingStyles();
1045
1167
  }
1046
1168
 
1169
+ /**
1170
+ * Update viewport and DOM state.
1171
+ */
1047
1172
  private _update(): void {
1048
1173
  if (this.isDisposed || !this.layout) {
1049
1174
  return;
@@ -1097,27 +1222,27 @@ export class WindowedList<
1097
1222
  startIndex,
1098
1223
  stopIndex
1099
1224
  );
1100
- this._windowElement.style.top = `${top}px`;
1101
- this._windowElement.style.minHeight = `${minHeight}px`;
1225
+ this._viewport.style.top = `${top}px`;
1226
+ this._viewport.style.minHeight = `${minHeight}px`;
1102
1227
  } else {
1103
1228
  // Update inner container height
1104
1229
  this._innerElement.style.height = `0px`;
1105
1230
 
1106
- // Update position of window container
1107
- this._windowElement.style.top = `0px`;
1108
- this._windowElement.style.minHeight = `0px`;
1231
+ // Update position of viewport node
1232
+ this._viewport.style.top = `0px`;
1233
+ this._viewport.style.minHeight = `0px`;
1109
1234
  }
1110
1235
 
1111
1236
  // Update scroll
1112
1237
  if (this._scrollUpdateWasRequested) {
1113
- this.node.scrollTop = this.viewModel.scrollOffset;
1238
+ this._outerElement.scrollTop = this.viewModel.scrollOffset;
1114
1239
  this._scrollUpdateWasRequested = false;
1115
1240
  }
1116
1241
  }
1117
1242
  }
1118
1243
 
1119
1244
  let index2 = -1;
1120
- for (const w of this.viewportNode.children) {
1245
+ for (const w of this._viewport.children) {
1121
1246
  const currentIdx = parseInt(
1122
1247
  (w as HTMLElement).dataset.windowedListIndex!,
1123
1248
  10
@@ -1130,6 +1255,9 @@ export class WindowedList<
1130
1255
  }
1131
1256
  }
1132
1257
 
1258
+ /**
1259
+ * Handle viewport content (e.g. widgets) resize.
1260
+ */
1133
1261
  private _onWidgetResize(entries: ResizeObserverEntry[]): void {
1134
1262
  this._resetScrollToItem();
1135
1263
 
@@ -1166,6 +1294,9 @@ export class WindowedList<
1166
1294
  }
1167
1295
  }
1168
1296
 
1297
+ /**
1298
+ * Clear any outstanding timeout and enqueue scrolling to a new item.
1299
+ */
1169
1300
  private _resetScrollToItem(): void {
1170
1301
  if (this._resetScrollToItemTimeout) {
1171
1302
  clearTimeout(this._resetScrollToItemTimeout);
@@ -1182,18 +1313,60 @@ export class WindowedList<
1182
1313
  }
1183
1314
  }
1184
1315
 
1185
- protected _viewModel: T;
1186
- private _innerElement: HTMLDivElement;
1316
+ /**
1317
+ * Render virtual scrollbar.
1318
+ */
1319
+ private _renderScrollbar(): void {
1320
+ const { node, renderer, viewModel } = this;
1321
+ const content = node.querySelector('.jp-WindowedPanel-scrollbar-content')!;
1322
+
1323
+ while (content.firstChild) {
1324
+ content.removeChild(content.firstChild);
1325
+ }
1326
+
1327
+ const list = viewModel.itemsList;
1328
+ const count = list?.length ?? viewModel.widgetCount;
1329
+ for (let index = 0; index < count; index += 1) {
1330
+ const item = list?.get?.(index);
1331
+ const element = renderer.createScrollbarItem(this, index, item);
1332
+ element.classList.add('jp-WindowedPanel-scrollbar-item');
1333
+ element.dataset.index = `${index}`;
1334
+ content.appendChild(element);
1335
+ }
1336
+ }
1337
+
1338
+ /**
1339
+ * Handle `pointerdown` events on the virtual scrollbar.
1340
+ */
1341
+ private _evtPointerDown(event: PointerEvent): void {
1342
+ let target = event.target as HTMLElement;
1343
+ while (target && target.parentElement) {
1344
+ if (target.hasAttribute('data-index')) {
1345
+ const index = parseInt(target.getAttribute('data-index')!, 10);
1346
+ return void (async () => {
1347
+ await this.scrollToItem(index);
1348
+ this.jumped.emit(index);
1349
+ })();
1350
+ }
1351
+ target = target.parentElement;
1352
+ }
1353
+ }
1354
+
1355
+ private _innerElement: HTMLElement;
1187
1356
  private _isParentHidden: boolean;
1188
1357
  private _isScrolling: PromiseDelegate<void> | null;
1189
1358
  private _needsUpdate = false;
1190
- private _windowElement: HTMLDivElement;
1359
+ private _outerElement: HTMLElement;
1191
1360
  private _resetScrollToItemTimeout: number | null;
1192
1361
  private _resizeObserver: ResizeObserver | null;
1362
+ private _scrollbarElement: HTMLElement;
1363
+ private _scrollbarResizeObserver: ResizeObserver | null;
1193
1364
  private _scrollRepaint: number | null;
1194
1365
  private _scrollToItem: [number, WindowedList.ScrollToAlign] | null;
1195
1366
  private _scrollUpdateWasRequested: boolean;
1196
1367
  private _updater: Throttler;
1368
+ private _viewModel: T;
1369
+ private _viewport: HTMLElement;
1197
1370
  }
1198
1371
 
1199
1372
  /**
@@ -1340,10 +1513,50 @@ export class WindowedLayout extends PanelLayout {
1340
1513
  * A namespace for windowed list
1341
1514
  */
1342
1515
  export namespace WindowedList {
1516
+ /**
1517
+ * The default renderer class for windowed lists.
1518
+ */
1519
+ export class Renderer<T = any> implements IRenderer<T> {
1520
+ /**
1521
+ * Create the outer, root element of the windowed list.
1522
+ */
1523
+ createOuter(): HTMLElement {
1524
+ return document.createElement('div');
1525
+ }
1526
+
1527
+ /**
1528
+ * Create the virtual scrollbar element.
1529
+ */
1530
+ createScrollbar(): HTMLOListElement {
1531
+ return document.createElement('ol');
1532
+ }
1533
+
1534
+ /**
1535
+ * Create an individual item rendered in the scrollbar.
1536
+ */
1537
+ createScrollbarItem(_: WindowedList, index: number): HTMLLIElement {
1538
+ const li = document.createElement('li');
1539
+ li.appendChild(document.createTextNode(`${index}`));
1540
+ return li;
1541
+ }
1542
+
1543
+ /**
1544
+ * Create the viewport element into which virtualized children are added.
1545
+ */
1546
+ createViewport(): HTMLElement {
1547
+ return document.createElement('div');
1548
+ }
1549
+ }
1550
+
1551
+ /**
1552
+ * The default renderer for windowed lists.
1553
+ */
1554
+ export const defaultRenderer = new Renderer();
1555
+
1343
1556
  /**
1344
1557
  * Windowed list model interface
1345
1558
  */
1346
- export interface IModel extends IDisposable {
1559
+ export interface IModel<T = any> extends IDisposable {
1347
1560
  /**
1348
1561
  * Provide a best guess for the widget size at position index
1349
1562
  *
@@ -1387,6 +1600,7 @@ export namespace WindowedList {
1387
1600
  align?: ScrollToAlign,
1388
1601
  margin?: number
1389
1602
  ): number;
1603
+
1390
1604
  /**
1391
1605
  * Compute the items range to display.
1392
1606
  *
@@ -1420,6 +1634,7 @@ export namespace WindowedList {
1420
1634
  * Items list to be rendered
1421
1635
  */
1422
1636
  itemsList: {
1637
+ get?: (index: number) => T;
1423
1638
  length: number;
1424
1639
  changed: ISignal<any, IObservableList.IChangedArgs<any>>;
1425
1640
  } | null;
@@ -1524,7 +1739,8 @@ export namespace WindowedList {
1524
1739
  * Windowed list view constructor options
1525
1740
  */
1526
1741
  export interface IOptions<
1527
- T extends WindowedList.IModel = WindowedList.IModel
1742
+ T extends WindowedList.IModel = WindowedList.IModel,
1743
+ U = any
1528
1744
  > {
1529
1745
  /**
1530
1746
  * Windowed list model to display
@@ -1534,6 +1750,45 @@ export namespace WindowedList {
1534
1750
  * Windowed list layout
1535
1751
  */
1536
1752
  layout?: WindowedLayout;
1753
+
1754
+ /**
1755
+ * A renderer for the elements of the windowed list.
1756
+ */
1757
+ renderer?: IRenderer<U>;
1758
+
1759
+ /**
1760
+ * Whether the windowed list should display a scrollbar UI.
1761
+ */
1762
+ scrollbar?: boolean;
1763
+ }
1764
+
1765
+ /**
1766
+ * A windowed list element renderer.
1767
+ */
1768
+ export interface IRenderer<T = any> {
1769
+ /**
1770
+ * Create the outer, root element of the windowed list.
1771
+ */
1772
+ createOuter(): HTMLElement;
1773
+
1774
+ /**
1775
+ * Create the virtual scrollbar element.
1776
+ */
1777
+ createScrollbar(): HTMLElement;
1778
+
1779
+ /**
1780
+ * Create an individual item rendered in the scrollbar.
1781
+ */
1782
+ createScrollbarItem(
1783
+ list: WindowedList,
1784
+ index: number,
1785
+ item: T | undefined
1786
+ ): HTMLElement;
1787
+
1788
+ /**
1789
+ * Create the viewport element into which virtualized children are added.
1790
+ */
1791
+ createViewport(): HTMLElement;
1537
1792
  }
1538
1793
 
1539
1794
  /**
@@ -332,28 +332,39 @@ export class LabIcon implements LabIcon.ILabIcon, VirtualElement.IRenderer {
332
332
  return document.createElement('div');
333
333
  }
334
334
 
335
- let returnSvgElement = true;
336
335
  if (container) {
337
336
  // take ownership by removing any existing children
338
337
  while (container.firstChild) {
339
338
  container.firstChild.remove();
340
339
  }
341
- } else {
340
+ } else if (tag) {
342
341
  // create a container if needed
343
342
  container = document.createElement(tag);
343
+ }
344
344
 
345
- returnSvgElement = false;
345
+ const svgElement = this.svgElement.cloneNode(true) as HTMLElement;
346
+ if (!container) {
347
+ if (label) {
348
+ console.warn();
349
+ }
350
+ return svgElement;
346
351
  }
352
+
347
353
  if (label != null) {
348
354
  container.textContent = label;
349
355
  }
350
- Private.initContainer({ container, className, styleProps, title });
356
+
357
+ Private.initContainer({
358
+ container: container!,
359
+ className,
360
+ styleProps,
361
+ title
362
+ });
351
363
 
352
364
  // add the svg node to the container
353
- const svgElement = this.svgElement.cloneNode(true) as HTMLElement;
354
365
  container.appendChild(svgElement);
355
366
 
356
- return returnSvgElement ? svgElement : container;
367
+ return container;
357
368
  }
358
369
 
359
370
  render(container: HTMLElement, options?: LabIcon.IRendererOptions): void {
@@ -468,7 +479,7 @@ export class LabIcon implements LabIcon.ILabIcon, VirtualElement.IRenderer {
468
479
  });
469
480
 
470
481
  // make it so that tag can be used as a jsx component
471
- const Tag = tag;
482
+ const Tag = tag ?? React.Fragment;
472
483
 
473
484
  // ensure that svg html is valid
474
485
  if (!(this.svgInnerHTML && this.svgReactAttrs)) {
@@ -494,15 +505,18 @@ export class LabIcon implements LabIcon.ILabIcon, VirtualElement.IRenderer {
494
505
  </React.Fragment>
495
506
  );
496
507
  } else {
497
- return (
498
- <Tag
499
- className={
508
+ let attributes = {};
509
+ if (Tag !== React.Fragment) {
510
+ attributes = {
511
+ className:
500
512
  className || styleProps
501
513
  ? classes(className, LabIconStyle.styleClass(styleProps))
502
- : undefined
503
- }
504
- title={title}
505
- >
514
+ : undefined,
515
+ title: title
516
+ };
517
+ }
518
+ return (
519
+ <Tag {...attributes}>
506
520
  {svgComponent}
507
521
  {label}
508
522
  </Tag>
@@ -670,8 +684,12 @@ export namespace LabIcon {
670
684
  /**
671
685
  * HTML element tag used to create the icon's outermost container node,
672
686
  * if no container is passed in
687
+ *
688
+ * #### Notes
689
+ * If `null` is provided and no container is defined, the icon SVG will return directly
690
+ * ignoring all other attributes (label, title,...)
673
691
  */
674
- tag?: 'div' | 'span';
692
+ tag?: 'div' | 'span' | null;
675
693
 
676
694
  /**
677
695
  * Optional title that will be set on the icon's outermost container node
@@ -741,7 +759,7 @@ namespace Private {
741
759
  }
742
760
  } else {
743
761
  // create a container if needed
744
- container = document.createElement(tag);
762
+ container = document.createElement(tag ?? 'div');
745
763
  }
746
764
  if (label != null) {
747
765
  container.textContent = label;
@@ -764,7 +782,7 @@ namespace Private {
764
782
  ref: LabIcon.IReactRef
765
783
  ) => {
766
784
  // make it so that tag can be used as a jsx component
767
- const Tag = tag;
785
+ const Tag = tag ?? 'div';
768
786
 
769
787
  if (container) {
770
788
  initContainer({ container, className, styleProps, title });