@theia/core 1.53.0-next.6 → 1.53.1

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-types.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import * as React from 'react';
-import { ArrayUtils, Event, isFunction, isObject, isString, MenuPath } from '../../../common';
+import { ArrayUtils, Event, isFunction, isObject, MenuPath } from '../../../common';
 import { Widget } from '../../widgets';
 
 /** Items whose group is exactly 'navigation' will be rendered inline. */
@@ -32,58 +32,21 @@ export namespace TabBarDelegator {
     }
 }
 
-interface RegisteredToolbarItem {
+export type TabBarToolbarItem = RenderedToolbarItem | ReactTabBarToolbarItem;
+
+/**
+ * Representation of an item in the tab
+ */
+export interface TabBarToolbarItemBase {
     /**
      * The unique ID of the toolbar item.
      */
     id: string;
-}
-
-interface RenderedToolbarItem {
-    /**
-     * Optional icon for the item.
-     */
-    icon?: string | (() => string);
-
-    /**
-     * Optional text of the item.
-     *
-     * Strings in the format `$(iconIdentifier~animationType) will be treated as icon references.
-     * If the iconIdentifier begins with fa-, Font Awesome icons will be used; otherwise it will be treated as Codicon name.
-     *
-     * You can find Codicon classnames here: https://microsoft.github.io/vscode-codicons/dist/codicon.html
-     * You can find Font Awesome classnames here: http://fontawesome.io/icons/
-     * The type of animation can be either `spin` or `pulse`.
-     */
-    text?: string;
-
-    /**
-     * Optional tooltip for the item.
-     */
-    tooltip?: string;
-}
-
-interface SelfRenderingToolbarItem {
-    render(widget?: Widget): React.ReactNode;
-}
-
-interface ExecutableToolbarItem {
     /**
      * The command to execute when the item is selected.
      */
-    command: string;
-}
-
-export interface MenuToolbarItem {
-    /**
-     * A menu path with which this item is associated.
-     * If accompanied by a command, this data will be passed to the {@link MenuCommandExecutor}.
-     * If no command is present, this menu will be opened.
-     */
-    menuPath: MenuPath;
-}
+    command?: string;
 
-export interface ConditionalToolbarItem {
     /**
      * https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts
      */
@@ -98,61 +61,67 @@ export interface ConditionalToolbarItem {
      * Note: currently, each item of the container toolbar will be re-rendered if any of the items have changed.
      */
     onDidChange?: Event<void>;
-}
 
-interface InlineToolbarItemMetadata {
     /**
      * Priority among the items. Can be negative. The smaller the number the left-most the item will be placed in the toolbar. It is `0` by default.
      */
     priority?: number;
-    group: 'navigation' | undefined;
-}
-
-interface MenuToolbarItemMetadata {
+    group?: string;
     /**
-     * Optional group for the item. Default `navigation`.
-     * `navigation` group will be inlined, while all the others will appear in the `...` dropdown.
-     * A group in format `submenu_group_1/submenu 1/.../submenu_group_n/ submenu n/item_group` means that the item will be located in a submenu(s) of the `...` dropdown.
-     * The submenu's title is named by the submenu section name, e.g. `group/<submenu name>/subgroup`.
+     * A menu path with which this item is associated.
+     * If accompanied by a command, this data will be passed to the {@link MenuCommandExecutor}.
+     * If no command is present, this menu will be opened.
      */
-    group: string;
+    menuPath?: MenuPath;
+    contextKeyOverlays?: Record<string, string>;
     /**
      * Optional ordering string for placing the item within its group
      */
     order?: string;
 }
 
-/**
- * Representation of an item in the tab
- */
-export interface TabBarToolbarItem extends RegisteredToolbarItem,
-    ExecutableToolbarItem,
-    RenderedToolbarItem,
-    Omit<ConditionalToolbarItem, 'isVisible'>,
-    Pick<InlineToolbarItemMetadata, 'priority'>,
-    Partial<MenuToolbarItem>,
-    Partial<MenuToolbarItemMetadata> { }
+export interface RenderedToolbarItem extends TabBarToolbarItemBase {
+    /**
+     * Optional icon for the item.
+     */
+    icon?: string | (() => string);
+
+    /**
+     * Optional text of the item.
+     *
+     * Strings in the format `$(iconIdentifier~animationType) will be treated as icon references.
+     * If the iconIdentifier begins with fa-, Font Awesome icons will be used; otherwise it will be treated as Codicon name.
+     *
+     * You can find Codicon classnames here: https://microsoft.github.io/vscode-codicons/dist/codicon.html
+     * You can find Font Awesome classnames here: http://fontawesome.io/icons/
+     * The type of animation can be either `spin` or `pulse`.
+     */
+    text?: string;
+
+    /**
+     * Optional tooltip for the item.
+     */
+    tooltip?: string;
+}
 
 /**
  * Tab-bar toolbar item backed by a `React.ReactNode`.
  * Unlike the `TabBarToolbarItem`, this item is not connected to the command service.
  */
-export interface ReactTabBarToolbarItem extends RegisteredToolbarItem,
-    SelfRenderingToolbarItem,
-    ConditionalToolbarItem,
-    Pick<InlineToolbarItemMetadata, 'priority'>,
-    Pick<Partial<MenuToolbarItemMetadata>, 'group'> { }
-
-export interface AnyToolbarItem extends RegisteredToolbarItem,
-    Partial<ExecutableToolbarItem>,
-    Partial<RenderedToolbarItem>,
-    Partial<SelfRenderingToolbarItem>,
-    Partial<ConditionalToolbarItem>,
-    Partial<MenuToolbarItem>,
-    Pick<InlineToolbarItemMetadata, 'priority'>,
-    Partial<MenuToolbarItemMetadata> { }
-
-export interface MenuDelegate extends MenuToolbarItem, Required<Pick<ConditionalToolbarItem, 'isVisible'>> { }
+export interface ReactTabBarToolbarItem extends TabBarToolbarItemBase {
+    render(widget?: Widget): React.ReactNode;
+}
+
+export namespace ReactTabBarToolbarItem {
+    export function is(item: TabBarToolbarItem): item is ReactTabBarToolbarItem {
+        return isObject<ReactTabBarToolbarItem>(item) && typeof item.render === 'function';
+    }
+}
+
+export interface MenuDelegate {
+    menuPath: MenuPath;
+    isVisible(widget?: Widget): boolean;
+}
 
 export namespace TabBarToolbarItem {
 
@@ -160,48 +129,17 @@ export namespace TabBarToolbarItem {
      * Compares the items by `priority` in ascending. Undefined priorities will be treated as `0`.
      */
     export const PRIORITY_COMPARATOR = (left: TabBarToolbarItem, right: TabBarToolbarItem) => {
-        const leftGroup = left.group ?? NAVIGATION;
-        const rightGroup = right.group ?? NAVIGATION;
-        if (leftGroup === NAVIGATION && rightGroup !== NAVIGATION) { return ArrayUtils.Sort.LeftBeforeRight; }
-        if (rightGroup === NAVIGATION && leftGroup !== NAVIGATION) { return ArrayUtils.Sort.RightBeforeLeft; }
-        if (leftGroup !== rightGroup) { return leftGroup.localeCompare(rightGroup); }
+        const leftGroup: string = left.group ?? NAVIGATION;
+        const rightGroup: string = right.group ?? NAVIGATION;
+        if (leftGroup === NAVIGATION && rightGroup !== NAVIGATION) {
+            return ArrayUtils.Sort.LeftBeforeRight;
+        }
+        if (rightGroup === NAVIGATION && leftGroup !== NAVIGATION) {
+            return ArrayUtils.Sort.RightBeforeLeft;
+        }
+        if (leftGroup !== rightGroup) {
+            return leftGroup.localeCompare(rightGroup);
+        }
         return (left.priority || 0) - (right.priority || 0);
     };
-
-    export function is(arg: unknown): arg is TabBarToolbarItem {
-        return isObject<TabBarToolbarItem>(arg) && isString(arg.command);
-    }
-
-}
-
-export namespace MenuToolbarItem {
-    /**
-     * Type guard for a toolbar item that actually is a menu item, amongst
-     * the other kinds of item that it may also be.
-     *
-     * @param item a toolbar item
-     * @returns whether the `item` is a menu item
-     */
-    export function is<T extends AnyToolbarItem>(item: T): item is T & MenuToolbarItem {
-        return Array.isArray(item.menuPath);
-    }
-
-    export function getMenuPath(item: AnyToolbarItem): MenuPath | undefined {
-        return Array.isArray(item.menuPath) ? item.menuPath : undefined;
-    }
-}
-
-export namespace AnyToolbarItem {
-    /**
-     * Type guard for a toolbar item that actually manifests any of the
-     * features of a conditional toolbar item.
-     *
-     * @param item a toolbar item
-     * @returns whether the `item` is a conditional item
-     */
-    export function isConditional<T extends AnyToolbarItem>(item: T): item is T & ConditionalToolbarItem {
-        return 'isVisible' in item && typeof item.isVisible === 'function'
-            || 'onDidChange' in item && typeof item.onDidChange === 'function'
-            || 'when' in item && typeof item.when === 'string';
-    }
 }

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -16,13 +16,13 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
-import { ContextKeyService } from '../../context-key-service';
+import { ContextKeyService, ContextMatcher } from '../../context-key-service';
 import { CommandRegistry, Disposable, DisposableCollection, MenuCommandExecutor, MenuModelRegistry, MenuPath, nls } from '../../../common';
 import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
 import { LabelIcon, LabelParser } from '../../label-parser';
 import { ACTION_ITEM, codicon, ReactWidget, Widget } from '../../widgets';
 import { TabBarToolbarRegistry } from './tab-bar-toolbar-registry';
-import { AnyToolbarItem, ReactTabBarToolbarItem, TabBarDelegator, TabBarToolbarItem, TAB_BAR_TOOLBAR_CONTEXT_MENU, MenuToolbarItem } from './tab-bar-toolbar-types';
+import { ReactTabBarToolbarItem, TabBarDelegator, TabBarToolbarItem, TAB_BAR_TOOLBAR_CONTEXT_MENU, RenderedToolbarItem } from './tab-bar-toolbar-types';
 import { KeybindingRegistry } from '../..//keybinding';
 
 /**
@@ -87,7 +87,7 @@ export class TabBarToolbar extends ReactWidget {
 
         const contextKeys = new Set<string>();
         for (const item of items.sort(TabBarToolbarItem.PRIORITY_COMPARATOR).reverse()) {
-            if ('command' in item) {
+            if (item.command) {
                 this.commands.getAllHandlers(item.command).forEach(handler => {
                     if (handler.onDidChangeEnabled) {
                         this.toDisposeOnUpdateItems.push(handler.onDidChangeEnabled(() => this.maybeUpdate()));
@@ -154,9 +154,13 @@ export class TabBarToolbar extends ReactWidget {
         this.keybindingContextKeys.clear();
         return <React.Fragment>
             {this.renderMore()}
-            {[...this.inline.values()].map(item => TabBarToolbarItem.is(item)
-                ? (MenuToolbarItem.is(item) && !item.command ? this.renderMenuItem(item) : this.renderItem(item))
-                : item.render(this.current))}
+            {[...this.inline.values()].map(item => {
+                if (ReactTabBarToolbarItem.is(item)) {
+                    return item.render(this.current);
+                } else {
+                    return (item.menuPath && this.toolbarRegistry.isNonEmptyMenu(item, this.current) ? this.renderMenuItem(item) : this.renderItem(item));
+                }
+            })}
         </React.Fragment>;
     }
 
@@ -180,7 +184,7 @@ export class TabBarToolbar extends ReactWidget {
         return result;
     }
 
-    protected renderItem(item: AnyToolbarItem): React.ReactNode {
+    protected renderItem(item: RenderedToolbarItem): React.ReactNode {
         let innerText = '';
         const classNames = [];
         const command = item.command ? this.commands.getCommand(item.command) : undefined;
@@ -222,13 +226,13 @@ export class TabBarToolbar extends ReactWidget {
             onMouseUp={this.onMouseUpEvent}
             onMouseOut={this.onMouseUpEvent} >
             <div id={item.id} className={classNames.join(' ')}
-                onClick={this.executeCommand}
+                onClick={e => this.executeCommand(e, item)}
                 title={tooltip}>{innerText}
             </div>
         </div>;
     }
 
-    protected isEnabled(item: AnyToolbarItem): boolean {
+    protected isEnabled(item: TabBarToolbarItem): boolean {
         if (!!item.command) {
             return this.commandIsEnabled(item.command) && this.evaluateWhenClause(item.when);
         } else {
@@ -236,7 +240,7 @@ export class TabBarToolbar extends ReactWidget {
         }
     }
 
-    protected getToolbarItemClassNames(item: AnyToolbarItem): string[] {
+    protected getToolbarItemClassNames(item: TabBarToolbarItem): string[] {
         const classNames = [TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM];
         if (item.command) {
             if (this.isEnabled(item)) {
@@ -279,7 +283,7 @@ export class TabBarToolbar extends ReactWidget {
         if (subpath) {
             toDisposeOnHide.push(this.menus.linkSubmenu(TAB_BAR_TOOLBAR_CONTEXT_MENU, subpath));
         } else {
-            for (const item of this.more.values() as IterableIterator<AnyToolbarItem>) {
+            for (const item of this.more.values()) {
                 if (item.menuPath && !item.command) {
                     toDisposeOnHide.push(this.menus.linkSubmenu(TAB_BAR_TOOLBAR_CONTEXT_MENU, item.menuPath, undefined, item.group));
                 } else if (item.command) {
@@ -293,10 +297,10 @@ export class TabBarToolbar extends ReactWidget {
                         }
                     }
                     toDisposeOnHide.push(this.menus.registerMenuAction([...TAB_BAR_TOOLBAR_CONTEXT_MENU, ...item.group!.split('/')], {
-                        label: item.tooltip,
+                        label: (item as RenderedToolbarItem).tooltip,
                         commandId: item.command,
                         when: item.when,
-                        order: item.order,
+                        order: item.order
                     }));
                 }
             }
@@ -318,14 +322,26 @@ export class TabBarToolbar extends ReactWidget {
      * @param item a toolbar item that is a menu item
      * @returns the rendered toolbar item
      */
-    protected renderMenuItem(item: TabBarToolbarItem & MenuToolbarItem): React.ReactNode {
-        const icon = typeof item.icon === 'function' ? item.icon() : item.icon ?? 'ellipsis';
+    protected renderMenuItem(item: RenderedToolbarItem): React.ReactNode {
+        const command = item.command ? this.commands.getCommand(item.command) : undefined;
+        const icon = (typeof item.icon === 'function' && item.icon()) || item.icon as string || (command && command.iconClass) || 'ellipsis';
+
+        let contextMatcher: ContextMatcher = this.contextKeyService;
+        if (item.contextKeyOverlays) {
+            contextMatcher = this.contextKeyService.createOverlay(Object.keys(item.contextKeyOverlays).map(key => [key, item.contextKeyOverlays![key]]));
+        }
+
         return <div key={item.id}
             className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}
-            onClick={this.showPopupMenu.bind(this, item.menuPath)}>
-            <div id={item.id} className={codicon(icon, true)}
-                title={item.text} />
-            <div className={codicon('chevron-down') + ' chevron'} />
+        >
+            <div className={codicon(icon, true)}
+                title={item.text}
+                onClick={e => this.executeCommand(e, item)}
+            />
+            <div className={ACTION_ITEM} onClick={event => this.showPopupMenu(item.menuPath!, event, contextMatcher)}>
+                <div className={codicon('chevron-down') + ' chevron'} />
+            </div>
+
         </div >;
     }
 
@@ -336,11 +352,11 @@ export class TabBarToolbar extends ReactWidget {
      * @param menuPath the path of the registered menu to show
      * @param event the mouse event triggering the menu
      */
-    protected showPopupMenu = (menuPath: MenuPath, event: React.MouseEvent) => {
+    protected showPopupMenu = (menuPath: MenuPath, event: React.MouseEvent, contextMatcher: ContextMatcher) => {
         event.stopPropagation();
         event.preventDefault();
         const anchor = this.toAnchor(event);
-        this.renderPopupMenu(menuPath, anchor);
+        this.renderPopupMenu(menuPath, anchor, contextMatcher);
     };
 
     /**
@@ -350,7 +366,7 @@ export class TabBarToolbar extends ReactWidget {
      * @param anchor a description of where to render the menu
      * @returns platform-specific access to the rendered context menu
      */
-    protected renderPopupMenu(menuPath: MenuPath, anchor: Anchor): ContextMenuAccess {
+    protected renderPopupMenu(menuPath: MenuPath, anchor: Anchor, contextMatcher: ContextMatcher): ContextMenuAccess {
         const toDisposeOnHide = new DisposableCollection();
         this.addClass('menu-open');
         toDisposeOnHide.push(Disposable.create(() => this.removeClass('menu-open')));
@@ -360,6 +376,7 @@ export class TabBarToolbar extends ReactWidget {
             args: [this.current],
             anchor,
             context: this.current?.node,
+            contextKeyService: contextMatcher,
             onHide: () => toDisposeOnHide.dispose()
         });
     }
@@ -380,12 +397,10 @@ export class TabBarToolbar extends ReactWidget {
         return whenClause ? this.contextKeyService.match(whenClause, this.current?.node) : true;
     }
 
-    protected executeCommand = (e: React.MouseEvent<HTMLElement>) => {
+    protected executeCommand(e: React.MouseEvent<HTMLElement>, item: TabBarToolbarItem): void {
         e.preventDefault();
         e.stopPropagation();
 
-        const item: AnyToolbarItem | undefined = this.inline.get(e.currentTarget.id);
-
         if (!item || !this.isEnabled(item)) {
             return;
         }

package/src/browser/style/index.css

@@ -350,3 +350,4 @@ button.secondary[disabled],
 @import "./progress-bar.css";
 @import "./breadcrumbs.css";
 @import "./tooltip.css";
+@import "./split-widget.css";

package/src/browser/style/split-widget.css

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (C) 2024 1C-Soft LLC and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+.theia-split-widget > .p-SplitPanel {
+  height: 100%;
+  width: 100%;
+  outline: none;
+}
+
+.theia-split-widget > .p-SplitPanel > .p-SplitPanel-child {
+  min-width: 50px;
+  min-height: var(--theia-content-line-height);
+}
+
+.theia-split-widget > .p-SplitPanel > .p-SplitPanel-handle {
+  box-sizing: border-box;
+}
+
+.theia-split-widget > .p-SplitPanel[data-orientation="horizontal"] > .p-SplitPanel-handle {
+  border-left: var(--theia-border-width) solid var(--theia-sideBarSectionHeader-border);
+}
+
+.theia-split-widget > .p-SplitPanel[data-orientation="vertical"] > .p-SplitPanel-handle {
+  border-top: var(--theia-border-width) solid var(--theia-sideBarSectionHeader-border);
+}

package/src/browser/style/tabs.css

@@ -464,11 +464,16 @@
 }
 
 .p-TabBar-toolbar .item {
-  display: flex;
-  align-items: center;
-  margin-left: 4px; /* `padding` + `margin-right` from the container toolbar */
   opacity: var(--theia-mod-disabled-opacity);
   cursor: default;
+  display: flex;
+  flex-direction: row;
+  column-gap: 0px;
+  align-items: centery;
+}
+
+.p-TabBar-toolbar .item>div {
+    height: 100%;
 }
 
 .p-TabBar-toolbar .item.enabled {
@@ -476,10 +481,6 @@
   cursor: pointer;
 }
 
-.p-TabBar-toolbar .item.enabled .action-label::before {
-  display: flex;
-}
-
 .p-TabBar-toolbar :not(.item.enabled) .action-label {
   background: transparent;
   cursor: default;
@@ -491,8 +492,8 @@
 }
 
 .p-TabBar-toolbar .item > div {
-  height: 18px;
-  width: 18px;
+  line-height: calc(var(--theia-icon-size)+2px);
+  height: calc(var(--theia-icon-size)+2px);
   background-repeat: no-repeat;
   line-height: 18px;
 }
@@ -522,25 +523,13 @@
   background: var(--theia-icon-close) no-repeat;
 }
 
-/** Configure layout of a toolbar item that shows a pop-up menu. */
-.p-TabBar-toolbar .item.menu {
-  display: grid;
-}
-
-/** The elements of the item that shows a pop-up menu are stack atop one other. */
-.p-TabBar-toolbar .item.menu > div {
-  grid-area: 1 / 1;
-}
-
 /**
  * The chevron for the pop-up menu indication is shrunk and
  * stuffed in the bottom-right corner.
  */
-.p-TabBar-toolbar .item.menu > .chevron {
-  scale: 50%;
-  align-self: end;
-  justify-self: end;
-  translate: 5px 3px;
+.p-TabBar-toolbar .item.menu .chevron {
+  font-size: 8px;
+  vertical-align: bottom;
 }
 
 #theia-main-content-panel

package/src/browser/style/view-container.css

@@ -168,13 +168,6 @@
   padding-right: calc(var(--theia-ui-padding) * 2 / 3);
 }
 
-.theia-view-container-part-title .item > div {
-  height: var(--theia-icon-size);
-  width: var(--theia-icon-size);
-  background-size: var(--theia-icon-size);
-  line-height: var(--theia-icon-size);
-}
-
 .theia-view-container-part-title {
   display: none;
 }

package/src/browser/view-container.ts

@@ -29,7 +29,7 @@ import { MAIN_AREA_ID, BOTTOM_AREA_ID } from './shell/theia-dock-panel';
 import { FrontendApplicationStateService } from './frontend-application-state';
 import { ContextMenuRenderer, Anchor } from './context-menu-renderer';
 import { parseCssMagnitude } from './browser';
-import { TabBarToolbarRegistry, TabBarToolbarFactory, TabBarToolbar, TabBarDelegator, TabBarToolbarItem } from './shell/tab-bar-toolbar';
+import { TabBarToolbarRegistry, TabBarToolbarFactory, TabBarToolbar, TabBarDelegator, RenderedToolbarItem } from './shell/tab-bar-toolbar';
 import { isEmpty, isObject, nls } from '../common';
 import { WidgetManager } from './widget-manager';
 import { Key } from './keys';
@@ -324,7 +324,7 @@ export class ViewContainer extends BaseWidget implements StatefulWidget, Applica
         return 'view';
     }
 
-    protected registerToolbarItem(commandId: string, options?: Partial<Omit<TabBarToolbarItem, 'id' | 'command'>>): void {
+    protected registerToolbarItem(commandId: string, options?: Partial<Omit<RenderedToolbarItem, 'id' | 'command'>>): void {
         const newId = `${this.id}-tabbar-toolbar-${commandId}`;
         const existingHandler = this.commandRegistry.getAllHandlers(commandId)[0];
         const existingCommand = this.commandRegistry.getCommand(commandId);

package/src/browser/widget-open-handler.ts

@@ -24,7 +24,10 @@ import { WidgetManager } from './widget-manager';
 
 export type WidgetOpenMode = 'open' | 'reveal' | 'activate';
 /**
- * `WidgetOpenerOptions` define serializable generic options used by the {@link WidgetOpenHandler}.
+ * `WidgetOpenerOptions` define generic options used by the {@link WidgetOpenHandler}.
+ *
+ * _Note:_ This object may contain references to widgets (e.g. `widgetOptions.ref`);
+ * these need to be transformed before it can be serialized.
  */
 export interface WidgetOpenerOptions extends OpenerOptions {
     /**

package/src/browser/widgets/index.ts

@@ -18,3 +18,4 @@ export * from './widget';
 export * from './react-renderer';
 export * from './react-widget';
 export * from './extractable-widget';
+export * from './split-widget';