@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/tabdocs/tab-keys.d.ts

@@ -0,0 +1,12 @@
+import type { TabDocumentKeys } from './tab-document-keys';
+/**
+ * The keys of a desktop code editor. In a browser tab the browser keeps Ctrl+W, Ctrl+Tab,
+ * Ctrl+Shift+T, Ctrl+PageUp / PageDown and often Ctrl+1…9 for itself; an installed app gets them.
+ */
+export declare const DESKTOP_KEYS: Readonly<TabDocumentKeys>;
+/**
+ * Keys a page in a browser tab receives, chosen the way the web version of the editor chooses them:
+ * Ctrl+Alt in place of a Ctrl the browser keeps (Ctrl+E, the quick-open key, for the recent list),
+ * then the desktop key as well, for an installed app or a browser that lets it through.
+ */
+export declare const BROWSER_KEYS: Readonly<TabDocumentKeys>;

package/dist/components/tabdocs/tab-layout-area.d.ts

@@ -0,0 +1,13 @@
+import type { TabDockSide } from './tab-dock-side';
+import type { TabLayoutBar } from './tab-layout-bar';
+import type { TabLayoutNode } from './tab-layout-node';
+/** A dock area as `saveLayout` writes it. */
+export interface TabLayoutArea {
+    side: TabDockSide;
+    /** Pixels, or a share such as `'25%'`. */
+    size: number | string;
+    autoHide?: boolean;
+    /** Its bar settings given as plain values (`TabBarSettings`). */
+    bar?: TabLayoutBar;
+    root: TabLayoutNode;
+}

package/dist/components/tabdocs/tab-layout-bar.d.ts

@@ -0,0 +1,12 @@
+import type { TabBarButton } from './tab-bar-button';
+import type { TabBarButtonSize } from './tab-bar-button-size';
+import type { TabSize } from './tab-size';
+/** The bar settings of a dock area or a floating window that were set as plain values, as `saveLayout` writes them. */
+export interface TabLayoutBar {
+    scrollButtons?: boolean;
+    tabSize?: TabSize;
+    tabMinWidth?: number;
+    singleTabTitle?: boolean;
+    barButtons?: readonly TabBarButton[] | 'all' | 'auto';
+    barButtonSize?: TabBarButtonSize;
+}

package/dist/components/tabdocs/tab-layout-browser-window.d.ts

@@ -0,0 +1,10 @@
+import type { TabLayoutNode } from './tab-layout-node';
+import type { TabRect } from './tab-rect';
+/** A new browser window as `saveLayout` writes it. */
+export interface TabLayoutBrowserWindow {
+    /** Its place and size on the screen. */
+    rect: TabRect;
+    root: TabLayoutNode;
+    /** The group (its index in `groups`) its documents came from, where they go back to. */
+    home?: number | null;
+}

package/dist/components/tabdocs/tab-layout-change.d.ts

@@ -0,0 +1,2 @@
+/** What changed in the layout. */
+export type TabLayoutChange = 'split' | 'closeGroup' | 'resize' | 'evenSizes' | 'maximize' | 'restore' | 'move' | 'load' | 'float' | 'dock' | 'autoHide' | 'resizeArea' | 'moveWindow' | 'resizeWindow' | 'maximizeWindow' | 'restoreWindow' | 'closeWindow' | 'newWindow' | 'mainWindow' | 'hide' | 'show';

package/dist/components/tabdocs/tab-layout-document.d.ts

@@ -0,0 +1,9 @@
+/** A document as `saveLayout` writes it. */
+export interface TabLayoutDocument {
+    id: string;
+    type: string;
+    title: string;
+    state?: unknown;
+    pinned?: boolean;
+    preview?: boolean;
+}

package/dist/components/tabdocs/tab-layout-factory.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentBase } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentOptions } from './tab-document-options';
+import type { TabLayoutDocument } from './tab-layout-document';
+/**
+ * Makes a saved document again for `loadLayout`, usually by its `type`: the document itself, the
+ * options to make it with (over the saved ones), or only its content. `null` leaves it out.
+ */
+export type TabLayoutFactory = (saved: TabLayoutDocument) => TabDocument | TabDocumentOptions | ComponentBase | null | undefined;

package/dist/components/tabdocs/tab-layout-group.d.ts

@@ -0,0 +1,16 @@
+import type { TabDropSide } from './tab-drop-side';
+import type { TabLayoutDocument } from './tab-layout-document';
+/** A group as `saveLayout` writes it. */
+export interface TabLayoutGroup {
+    kind: 'group';
+    documents: TabLayoutDocument[];
+    /** The index of the active document, -1 for none. */
+    active: number;
+    /** Indexes of the documents, the one used last first. */
+    recent: number[];
+    locked?: boolean;
+    /** Written when the group takes no drops. */
+    allowDrop?: boolean;
+    /** Written when the group has drop sides of its own. */
+    dropSides?: TabDropSide[];
+}

package/dist/components/tabdocs/tab-layout-hidden.d.ts

@@ -0,0 +1,16 @@
+import type { TabDockSide } from './tab-dock-side';
+import type { TabLayoutDocument } from './tab-layout-document';
+import type { TabRect } from './tab-rect';
+/** A hidden document as `saveLayout` writes it, with where it goes back to. */
+export interface TabLayoutHidden {
+    document: TabLayoutDocument;
+    /** The group it was hidden from (its index in `groups`), while that group is there. */
+    group?: number;
+    index?: number;
+    /** The dock area it was in: its side, its size and whether it was folded. */
+    side?: TabDockSide;
+    size?: number | string;
+    autoHide?: boolean;
+    /** The floating window it was in. */
+    rect?: TabRect;
+}

package/dist/components/tabdocs/tab-layout-node.d.ts

@@ -0,0 +1,3 @@
+import type { TabLayoutGroup } from './tab-layout-group';
+import type { TabLayoutSplit } from './tab-layout-split';
+export type TabLayoutNode = TabLayoutSplit | TabLayoutGroup;

package/dist/components/tabdocs/tab-layout-split.d.ts

@@ -0,0 +1,10 @@
+import type { LayoutOrientation } from '../layout/layout-orientation';
+import type { TabLayoutNode } from './tab-layout-node';
+/** Groups side by side (`horizontal`) or one under the other, each with its share of the room. */
+export interface TabLayoutSplit {
+    kind: 'split';
+    orientation: LayoutOrientation;
+    /** One share per child, adding up to 1. */
+    sizes: number[];
+    children: TabLayoutNode[];
+}

package/dist/components/tabdocs/tab-layout-window.d.ts

@@ -0,0 +1,17 @@
+import type { TabDockSide } from './tab-dock-side';
+import type { TabLayoutBar } from './tab-layout-bar';
+import type { TabLayoutNode } from './tab-layout-node';
+import type { TabRect } from './tab-rect';
+/** A floating window as `saveLayout` writes it. */
+export interface TabLayoutWindow {
+    rect: TabRect;
+    maximized?: boolean;
+    /** Its bar settings given as plain values (`TabBarSettings`). */
+    bar?: TabLayoutBar;
+    root: TabLayoutNode;
+    /** Where "Dock" puts it back: a dock area, or the group (its index in `groups`) it came from. */
+    dock?: {
+        side: TabDockSide | null;
+        group: number | null;
+    };
+}

package/dist/components/tabdocs/tab-layout.d.ts

@@ -0,0 +1,23 @@
+import type { TabLayoutArea } from './tab-layout-area';
+import type { TabLayoutBrowserWindow } from './tab-layout-browser-window';
+import type { TabLayoutHidden } from './tab-layout-hidden';
+import type { TabLayoutNode } from './tab-layout-node';
+import type { TabLayoutWindow } from './tab-layout-window';
+/** The layout as `saveLayout` writes it: plain JSON. Layouts of versions 1 (no dock areas, no windows) and 2 (no new windows) still load. */
+export interface TabLayout {
+    version: 1 | 2 | 3;
+    /** The documents' area. */
+    root: TabLayoutNode;
+    /** The index of the active group, in the order of `groups`. */
+    activeGroup: number;
+    /** The index of the maximized group, `null` when none is. */
+    maximizedGroup: number | null;
+    /** The dock areas, the outermost first. */
+    areas?: TabLayoutArea[];
+    /** The floating windows, the one at the back first. */
+    windows?: TabLayoutWindow[];
+    /** The new browser windows, the one used last at the end. */
+    browserWindows?: TabLayoutBrowserWindow[];
+    /** The hidden documents, in the order they were hidden. */
+    hidden?: TabLayoutHidden[];
+}

package/dist/components/tabdocs/tab-list-scope.d.ts

@@ -0,0 +1,2 @@
+/** Which documents a list shows: the group's, or every group's. */
+export type TabListScope = 'group' | 'all';

package/dist/components/tabdocs/tab-menu-command.d.ts

@@ -0,0 +1,2 @@
+/** The built-in items of the tab and strip context menus; each one is in `menuItems` and in the items' `data`. */
+export type TabMenuCommand = 'close' | 'hide' | 'showHidden' | 'closeOthers' | 'closeRight' | 'closeLeft' | 'closeSaved' | 'closeAll' | 'keepOpen' | 'pin' | 'unpin' | 'splitUp' | 'splitDown' | 'splitLeft' | 'splitRight' | 'moveNext' | 'movePrevious' | 'moveTo' | 'moveGroupTo' | 'copyTitle' | 'newDocument' | 'reopenClosed' | 'lock' | 'unlock' | 'float' | 'dock' | 'dockLeft' | 'dockRight' | 'dockTop' | 'dockBottom' | 'autoHide' | 'maximizeWindow' | 'closeWindow' | 'newWindow' | 'mainWindow';

package/dist/components/tabdocs/tab-narrow-bars.d.ts

@@ -0,0 +1,2 @@
+/** How the bars of the documents' groups look on a tablet or a phone: with the `compact…` settings, or as on a desktop. */
+export type TabNarrowBars = 'compact' | 'documents';

package/dist/components/tabdocs/tab-new-document.d.ts

@@ -0,0 +1,5 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentOptions } from './tab-document-options';
+import type { TabGroup } from './TabGroup';
+/** Makes a new document for a group: a double click on the empty strip, or the strip menu. `null` makes none. */
+export type TabNewDocument = (group: TabGroup) => TabDocument | TabDocumentOptions | null | undefined;

package/dist/components/tabdocs/tab-new-window-close-action.d.ts

@@ -0,0 +1,2 @@
+/** What the documents of a new window do when it closes: go back to the main window, or close (each one asks through `onClosing`). */
+export type TabNewWindowCloseAction = 'back' | 'close';

package/dist/components/tabdocs/tab-new-window-fallback.d.ts

@@ -0,0 +1,2 @@
+/** When the browser blocks a new window: `float` opens a floating window in the page instead, `none` leaves everything where it is. */
+export type TabNewWindowFallback = 'float' | 'none';

package/dist/components/tabdocs/tab-new-window-options.d.ts

@@ -0,0 +1,8 @@
+import type { TabRect } from './tab-rect';
+/** What `moveToNewWindow` may be told. */
+export interface TabNewWindowOptions {
+    /** The window's place and size on the screen; by default the size of what moves (or `newWindowSize`), beside it. */
+    rect?: TabRect;
+    /** The page the window opens, on the page's own origin; `newWindowUrl` by default. */
+    url?: string;
+}

package/dist/components/tabdocs/tab-new-window-title.d.ts

@@ -0,0 +1,7 @@
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocument } from './TabDocument';
+/**
+ * A new window's title: a text where `{title}` is its active document's title and `{page}` the
+ * page's own title, or a function that makes it.
+ */
+export type TabNewWindowTitle = string | ((document: TabDocument | null, window: TabBrowserWindow) => string);

package/dist/components/tabdocs/tab-open-options.d.ts

@@ -0,0 +1,16 @@
+import type { TabGroup } from './TabGroup';
+/** Where and how `open` puts a document. */
+export interface TabOpenOptions {
+    /** Default: the active group (never a locked one). */
+    group?: TabGroup;
+    /** Default: as the manager's `openPosition` says. */
+    index?: number;
+    /** Make it the active tab. Default `true`. */
+    active?: boolean;
+    /** Move focus to it as well. Default `false`. */
+    focus?: boolean;
+    /** Open it as a preview tab, which the next preview replaces (when `previewTabs` is on). `false` keeps a preview tab open. */
+    preview?: boolean;
+    /** Open it pinned. */
+    pinned?: boolean;
+}

package/dist/components/tabdocs/tab-open-position.d.ts

@@ -0,0 +1,2 @@
+/** Where a new tab goes in its group: after the active tab, at the end or at the start. */
+export type TabOpenPosition = 'afterActive' | 'end' | 'start';

package/dist/components/tabdocs/tab-open-window.d.ts

@@ -0,0 +1,7 @@
+import type { TabWindowRequest } from './tab-window-request';
+/**
+ * Opens the browser window a document moves into: a window of the page's origin, `null` when
+ * none could be opened. The default calls `window.open`; an Electron app, a host page with a
+ * frame of its own or a test gives its own.
+ */
+export type TabOpenWindow = (request: TabWindowRequest) => Window | null;

package/dist/components/tabdocs/tab-presentation-kind.d.ts

@@ -0,0 +1,2 @@
+/** How a manager shows its layout now. */
+export type TabPresentationKind = 'desktop' | 'tablet' | 'phone';

package/dist/components/tabdocs/tab-presentation.d.ts

@@ -0,0 +1,2 @@
+/** How a manager shows its layout: `'auto'` by its own width (`tabletWidth`, `phoneWidth`), or always as on a desktop, a tablet or a phone. */
+export type TabPresentation = 'auto' | 'desktop' | 'tablet' | 'phone';

package/dist/components/tabdocs/tab-rect.d.ts

@@ -0,0 +1,7 @@
+/** A box on the screen, in pixels of the viewport: a floating window's place and size. */
+export interface TabRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/dist/components/tabdocs/tab-restore-windows.d.ts

@@ -0,0 +1,7 @@
+/**
+ * What `loadLayout` does with the new windows a layout saved: `float` puts their documents in
+ * floating windows, `reopen` opens the windows again (a browser lets a page open windows only
+ * on a click or a key: what it blocks stays floating until `reopenWindows`), `main` puts them
+ * among the documents of the main window.
+ */
+export type TabRestoreWindows = 'float' | 'reopen' | 'main';

package/dist/components/tabdocs/tab-show-description.d.ts

@@ -0,0 +1,2 @@
+/** When a tab shows its document's description: always, only when another open document has the same title, or never. */
+export type TabShowDescription = 'always' | 'duplicates' | 'never';

package/dist/components/tabdocs/tab-show-options.d.ts

@@ -0,0 +1,15 @@
+import type { TabDockSide } from './tab-dock-side';
+import type { TabGroup } from './TabGroup';
+/** Where and how `show` puts a hidden document back. Without `group` or `side`, it goes back where it was hidden from. */
+export interface TabShowOptions {
+    /** Into this group. */
+    group?: TabGroup;
+    /** Into the dock area of this side (made when there is none). */
+    side?: TabDockSide;
+    /** Its place in the group's strip. Default: where it was, or as `openPosition` says in another group. */
+    index?: number;
+    /** Make it the active tab. Default `true`. */
+    active?: boolean;
+    /** Move focus to it as well. Default `false`. */
+    focus?: boolean;
+}

package/dist/components/tabdocs/tab-size.d.ts

@@ -0,0 +1,2 @@
+/** How wide tabs are: as wide as their text, shrinking when they do not fit, or all the same width. */
+export type TabSize = 'fit' | 'shrink' | 'fixed';

package/dist/components/tabdocs/tab-slide-event-args.d.ts

@@ -0,0 +1,16 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDockArea } from './TabDockArea';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+/**
+ * A folded dock area is about to slide out over the documents with `document` (`open`), or to slide
+ * back (`onSlideChanging`; `cancel = true` leaves it); or it did (`onSlideChanged`).
+ */
+export interface TabSlideEventArgs extends EventArgs {
+    area: TabDockArea;
+    /** The document shown; `null` when it slides back. */
+    document: TabDocument | null;
+    open: boolean;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-tablet-when.d.ts

@@ -0,0 +1,2 @@
+/** When `presentation: 'auto'` shows the tablet layout: under `tabletWidth` on a touch screen (`'touch'`), or under it whatever the pointer (`'width'`). */
+export type TabTabletWhen = 'touch' | 'width';

package/dist/components/tabdocs/tab-tone.d.ts

@@ -0,0 +1,2 @@
+/** The colour of a tab's title and badge, by what the document needs: a warning, an error, a success, attention. */
+export type TabTone = 'warning' | 'danger' | 'success' | 'accent';

package/dist/components/tabdocs/tab-toolbar-items.d.ts

@@ -0,0 +1,4 @@
+import type { ToolbarItem } from '../toolbar/toolbar-item';
+import type { TabGroup } from './TabGroup';
+/** The app's own buttons for a group's toolbar, made once for each group; their fields (`visible`, `enabled`…) follow the app. */
+export type TabToolbarItems = (group: TabGroup) => readonly ToolbarItem[];

package/dist/components/tabdocs/tab-window-closed-event-args.d.ts

@@ -0,0 +1,14 @@
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabWindow } from './TabWindow';
+/**
+ * A floating window or a new browser window is gone: closed, docked (its documents went back),
+ * left without documents, or moved (a floating window's layout went into a new window).
+ */
+export interface TabWindowClosedEventArgs {
+    window: TabWindow | TabBrowserWindow;
+    kind: 'floating' | 'browser';
+    reason: 'closed' | 'docked' | 'empty' | 'moved';
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-window-closing-event-args.d.ts

@@ -0,0 +1,18 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabNewWindowCloseAction } from './tab-new-window-close-action';
+import type { TabWindow } from './TabWindow';
+/**
+ * A floating window or a new browser window is about to close. `then` says what its documents do:
+ * go back (a floating window: where it was docked; a new window: to the main window) or close (each
+ * one still asks through `onClosing`); it may be changed. `cancel = true` keeps the window, except
+ * a new window the user closed: that one is gone already, and its documents come back.
+ */
+export interface TabWindowClosingEventArgs extends EventArgs {
+    window: TabWindow | TabBrowserWindow;
+    kind: 'floating' | 'browser';
+    then: TabNewWindowCloseAction;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-window-opened-event-args.d.ts

@@ -0,0 +1,14 @@
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A new browser window was opened and the document (or the group, or the floating window's layout) moved into it. */
+export interface TabWindowOpenedEventArgs {
+    window: TabBrowserWindow;
+    /** The document that moved; `null` for a group or a floating window. */
+    document: TabDocument | null;
+    /** Its group in the new window that is active. */
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-window-opening-event-args.d.ts

@@ -0,0 +1,21 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+import type { TabRect } from './tab-rect';
+import type { TabWindow } from './TabWindow';
+/** A document, a group or a floating window is about to move into a new browser window; `rect` and `url` may be changed, `cancel = true` keeps it where it is. */
+export interface TabWindowOpeningEventArgs extends EventArgs {
+    /** The document; `null` when a whole group or a floating window moves. */
+    document: TabDocument | null;
+    /** The document's group, the group that moves, or the floating window's active group. */
+    group: TabGroup;
+    /** The floating window that moves with everything in it, if one. */
+    window: TabWindow | null;
+    /** The window's place and size on the screen. */
+    rect: TabRect;
+    /** The page the window opens. */
+    url: string;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/tab-window-request.d.ts

@@ -0,0 +1,11 @@
+import type { TabRect } from './tab-rect';
+/** What `openWindow` is asked to open: the arguments of `window.open`, and the place they say. */
+export interface TabWindowRequest {
+    url: string;
+    /** The window's name: a new one each time. */
+    name: string;
+    /** `popup,width=…,height=…,left=…,top=…`. */
+    features: string;
+    /** The place and size on the screen `features` says. */
+    rect: TabRect;
+}

package/dist/components/tabs/PanelContent.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentBase } from '@motifx/core';
+/** What a panel's `content` factory returns. */
+export type ContentFactory = () => ComponentBase | readonly ComponentBase[];
+/**
+ * The content of a panel that is built when it is first shown: the JSX children, kept once
+ * placed, and what a `content` factory makes, which can be dropped while the panel is hidden
+ * and made again the next time.
+ */
+export declare class PanelContent {
+    private readonly host;
+    private readonly children;
+    private readonly factory;
+    private placedChildren;
+    private made;
+    constructor(host: ComponentBase, children: readonly ComponentBase[], factory: ContentFactory | undefined);
+    get isBuilt(): boolean;
+    build(): void;
+    /** Disposes what the factory made; the JSX children stay. */
+    release(): void;
+}

package/dist/components/tabs/Tab.d.ts

@@ -0,0 +1,71 @@
+import { type Bind, type IBaseProp } from '@motifx/core';
+import { Control } from '../../core/control';
+import type { IconSource } from '../../core/icon-source';
+import type { TabProps } from './tab-props';
+import type { Tabs } from './Tabs';
+/**
+ * One tab of {@link Tabs}: its button in the tab strip and its panel. The JSX children are the
+ * panel's content, built when the tab is first shown (see `lazy`).
+ *
+ * @example
+ * <Tabs>
+ *   <Tab title="&General"><TextBox label="Name" /></Tab>
+ *   <Tab title="Log" badge={() => this.log.length} closable>…</Tab>
+ * </Tabs>
+ *
+ * tabs.add(new Tab({ title: 'Report', content: () => new ReportView() }));
+ */
+export declare class Tab extends Control<HTMLDivElement, TabProps> {
+    constructor(props?: IBaseProp<TabProps>);
+    get title(): string;
+    set title(value: Bind<string>);
+    /** The `key` prop (also when written as the JSX `key`), `''` without one. */
+    get key(): string;
+    set key(value: Bind<string>);
+    get icon(): IconSource | null;
+    set icon(value: Bind<IconSource | null>);
+    get badge(): string | number | null;
+    set badge(value: Bind<string | number | null>);
+    get hint(): string;
+    set hint(value: Bind<string>);
+    /** This tab's own setting; `undefined` follows the `Tabs`. */
+    get closable(): boolean | undefined;
+    set closable(value: Bind<boolean | undefined>);
+    get lazy(): boolean | undefined;
+    set lazy(value: Bind<boolean | undefined>);
+    get keepAlive(): boolean | undefined;
+    set keepAlive(value: Bind<boolean | undefined>);
+    /** Whether the tab shows a close button: its own `closable`, else the `Tabs` one. Reactive. */
+    get isClosable(): boolean;
+    /** The `Tabs` it belongs to. */
+    get owner(): Tabs | null;
+    /** Whether it is the selected tab. Reactive. */
+    get isSelected(): boolean;
+    /** Whether its panel content has been built (see `lazy`). */
+    get contentBuilt(): boolean;
+    /** The tab's button in the strip (`role="tab"`). The tab's own element is its panel. */
+    get headerElement(): HTMLButtonElement;
+    /** Selects the tab; `false` when it is hidden or not in a `Tabs`. */
+    select(): boolean;
+    /** Closes the tab as its close button does: `onClose` can cancel it. */
+    close(): boolean;
+    protected get focusElement(): HTMLElement;
+    /** The access key selects the tab and focuses it. */
+    onAccessKey(): boolean;
+    protected applyProperty(name: string, value: unknown): void;
+    /** @internal Joins or leaves a `Tabs`. */
+    attachTo(owner: Tabs | null): void;
+    /** @internal Shows or hides the panel; the Tabs decides. */
+    showPanel(on: boolean, keepAlive: boolean): void;
+    /** @internal Builds the panel content now. */
+    buildContent(): void;
+    /** @internal A panel with nothing focusable in it takes focus itself, so Tab reaches it. */
+    updatePanelFocus(): void;
+    /** @internal The `Tabs` closable setting changed. */
+    renderClose(): void;
+    private get parts();
+    private createParts;
+    private renderTitle;
+    private renderIcon;
+    private renderBadge;
+}