@tylertech/forge 2.8.0 → 2.9.0

package/esm/split-view/split-view-panel/split-view-panel-adapter.js

@@ -0,0 +1,295 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { getShadowElement, playKeyframeAnimation, toggleAttribute } from '@tylertech/forge-core';
+import { BaseAdapter } from '../../core/base/base-adapter';
+import { SPLIT_VIEW_PANEL_CONSTANTS } from './split-view-panel-constants';
+import { SPLIT_VIEW_CONSTANTS } from '../split-view/split-view-constants';
+import { getCursor, getHandleIcon, getSplitViewPanelSibling } from './split-view-panel-utils';
+export class SplitViewPanelAdapter extends BaseAdapter {
+    constructor(component) {
+        super(component);
+        this._root = getShadowElement(component, SPLIT_VIEW_PANEL_CONSTANTS.selectors.ROOT);
+        this._handle = getShadowElement(component, SPLIT_VIEW_PANEL_CONSTANTS.selectors.HANDLE);
+        this._icon = getShadowElement(component, SPLIT_VIEW_PANEL_CONSTANTS.selectors.ICON);
+        this._ripple = getShadowElement(component, SPLIT_VIEW_PANEL_CONSTANTS.selectors.RIPPLE);
+        this._content = getShadowElement(component, SPLIT_VIEW_PANEL_CONSTANTS.selectors.CONTENT);
+    }
+    initialize() {
+        // Set the parent split view
+        const parent = this._component.parentElement;
+        if ((parent === null || parent === void 0 ? void 0 : parent.tagName.toLowerCase()) === SPLIT_VIEW_CONSTANTS.elementName) {
+            this._parent = parent;
+        }
+    }
+    setPointerdownListener(listener) {
+        this._handle.addEventListener('pointerdown', listener);
+    }
+    setPointerupListener(listener) {
+        document.addEventListener('pointerup', listener);
+    }
+    removePointerupListener(listener) {
+        document.removeEventListener('pointerup', listener);
+    }
+    setPointermoveListener(listener) {
+        document.addEventListener('pointermove', listener);
+    }
+    removePointermoveListener(listener) {
+        document.removeEventListener('pointermove', listener);
+    }
+    setKeydownListener(listener) {
+        this._handle.addEventListener('keydown', listener);
+    }
+    setKeyupListener(listener) {
+        this._handle.addEventListener('keyup', listener);
+    }
+    removeKeyupListener(listener) {
+        this._handle.removeEventListener('keyup', listener);
+    }
+    /**
+     * Gets the specified property value from the parent split view.
+     * @param name The property name.
+     * @returns The value of the property.
+     */
+    getParentProperty(name) {
+        var _a;
+        return (_a = this._parent) === null || _a === void 0 ? void 0 : _a[name];
+    }
+    /**
+     * Sets the accessible label of the resize handle.
+     * @param value The label text.
+     */
+    setAccessibleLabel(value) {
+        this._handle.setAttribute('aria-label', value);
+    }
+    /**
+     * Sets the disabled state of the component.
+     * @param value Whether the component is disabled.
+     */
+    setDisabled(value) {
+        this._root.classList.toggle(SPLIT_VIEW_PANEL_CONSTANTS.classes.DISABLED, value);
+        if (this._handle) {
+            this._handle.setAttribute('tabindex', value ? '-1' : '0');
+            toggleAttribute(this._handle, value, 'aria-disabled', 'true');
+        }
+    }
+    /**
+     * Sets the whether the component's handle is present and at its start or end.
+     * @param value The component's resizable value.
+     */
+    setResizable(value) {
+        this._root.setAttribute(SPLIT_VIEW_PANEL_CONSTANTS.attributes.RESIZABLE, value.toString());
+        toggleAttribute(this._handle, value !== 'off', 'aria-valuemin', '0');
+        toggleAttribute(this._handle, value !== 'off', 'aria-valuemax', '100');
+        if (value === 'off') {
+            return;
+        }
+        this._handle.remove();
+        if (value === 'end') {
+            // Place the handle after the content
+            this._root.append(this._handle);
+        }
+        else {
+            // Place the handle before the content
+            this._root.prepend(this._handle);
+        }
+    }
+    /**
+     * Sets the orientation of the component including ARIA attributes and the resize handle icon.
+     * @param value The component's orientation.
+     */
+    setOrientation(value) {
+        this._root.setAttribute(SPLIT_VIEW_PANEL_CONSTANTS.attributes.ORIENTATION, value);
+        // The divider's orientation is perpendicular to the layout of the component
+        this._handle.setAttribute('aria-orientation', value === 'horizontal' ? 'vertical' : 'horizontal');
+        this._icon.setAttribute('name', getHandleIcon(value));
+    }
+    /**
+     * Opens or closes the component.
+     * @param value Whether the component is open.
+     * @param withAnimation Whether to use the animation. Defaults to `true`.
+     */
+    setOpen(value, withAnimation = true, event) {
+        var _a, _b;
+        const finish = () => {
+            var _a, _b;
+            if (!value) {
+                this._root.classList.add(SPLIT_VIEW_PANEL_CONSTANTS.classes.CLOSED);
+            }
+            if (event) {
+                this.emitHostEvent(value ? SPLIT_VIEW_PANEL_CONSTANTS.events.DID_OPEN : SPLIT_VIEW_PANEL_CONSTANTS.events.DID_CLOSE, event);
+            }
+            (_a = this._parent) === null || _a === void 0 ? void 0 : _a.unlayerSlottedPanels();
+            (_b = this._parent) === null || _b === void 0 ? void 0 : _b.update({ accessibility: true, cursor: true });
+        };
+        if (value && this._root.classList.contains(SPLIT_VIEW_PANEL_CONSTANTS.classes.CLOSED)) {
+            this._root.classList.remove(SPLIT_VIEW_PANEL_CONSTANTS.classes.CLOSED);
+            if (!withAnimation) {
+                finish();
+                return;
+            }
+            (_a = this._parent) === null || _a === void 0 ? void 0 : _a.layerSlottedPanels(this._component);
+            playKeyframeAnimation(this._root, SPLIT_VIEW_PANEL_CONSTANTS.classes.OPENING, true).then(() => {
+                finish();
+            });
+        }
+        else if (!value && !this._root.classList.contains(SPLIT_VIEW_PANEL_CONSTANTS.classes.CLOSED)) {
+            if (!withAnimation) {
+                finish();
+                return;
+            }
+            (_b = this._parent) === null || _b === void 0 ? void 0 : _b.layerSlottedPanels(this._component);
+            playKeyframeAnimation(this._root, SPLIT_VIEW_PANEL_CONSTANTS.classes.CLOSING, true).then(() => {
+                finish();
+            });
+        }
+    }
+    /**
+     * Sets the components appearance and accessibility to indicated whether it is currently grabbed
+     * by the user. Applies a cursor style to the document body.
+     * @param value Whether the component is currently being resized via pointer interaction.
+     */
+    setGrabbed(value) {
+        var _a;
+        this._root.classList.toggle(SPLIT_VIEW_PANEL_CONSTANTS.classes.GRABBED, value);
+        this._handle.setAttribute('aria-grabbed', value.toString());
+        (_a = this._parent) === null || _a === void 0 ? void 0 : _a.update({ clearCursor: true });
+        if (!value) {
+            document.body.style.removeProperty('cursor');
+        }
+    }
+    /**
+     * Applies a cursor style to the resize handle.
+     * @param orientation The component's orientation. If absent the cursor will be removed.
+     * @param config The component's resizable value and whether it's at the min or max value.
+     */
+    setHandleCursor(orientation, config) {
+        if (orientation) {
+            this._root.style.setProperty(SPLIT_VIEW_PANEL_CONSTANTS.customCssProperties.CURSOR, getCursor(orientation, config));
+        }
+        else {
+            this._root.style.removeProperty(SPLIT_VIEW_PANEL_CONSTANTS.customCssProperties.CURSOR);
+        }
+    }
+    /**
+     * Applies a cursor style to the document body.
+     * @param orientation The component's orientation.
+     * @param config The component's resizable value and whether it's at the min or max value.
+     */
+    setBodyCursor(orientation, config) {
+        document.body.style.setProperty('cursor', getCursor(orientation, config));
+    }
+    /**
+     * Gets the size of the content along the orientation axis. Does not include the resize handle.
+     * @param orientation The component's orientation.
+     * @returns The width or height of the content in pixels.
+     */
+    getContentSize(orientation) {
+        return orientation === 'horizontal' ? this._content.clientWidth : this._content.clientHeight;
+    }
+    /**
+     * Sets the size of the content not including the resize handle.
+     * @param value The width or height of the content in pixels.
+     */
+    setContentSize(value) {
+        this._component.style.setProperty(SPLIT_VIEW_PANEL_CONSTANTS.customCssProperties.SIZE, `${value}px`);
+    }
+    /**
+     * Sets the ARIA attribute representing the size of the content compared to its min and max.
+     * @param value The content size scaled from 0 to 100.
+     */
+    setValuenow(value) {
+        this._handle.setAttribute('aria-valuenow', value.toFixed(2));
+    }
+    /**
+     * Sets focus on the handle element.
+     */
+    focusHandle() {
+        this._handle.focus();
+    }
+    /**
+     * Gets the amount of space that the component is allowed to take. This includes the current
+     * size of the component and the size of the sibling it resizes into along the axis of
+     * orientation. The sibling's min and max values are taken into account but the component's are
+     * not.
+     * @param orientation The component's orientation.
+     * @param resizable The component's resizable value.
+     * @returns The amount of space available for the component to resize into in pixels.
+     */
+    getAvailableSpace(orientation, resizable) {
+        if (resizable === 'off') {
+            // Return -1 if the panel is static (i.e. can't be user resized)
+            return -1;
+        }
+        const sibling = getSplitViewPanelSibling(this._component);
+        if (sibling) {
+            const siblingSize = sibling.getCollapsibleSize();
+            return siblingSize + this.getContentSize(orientation);
+        }
+        else {
+            return this.getParentSize(orientation);
+        }
+    }
+    /**
+     * Gets the content size of the sibling panel the component resizes into along its axis of
+     * orientation.
+     * @returns The sibling's content size in pixels or 0 if the sibling does not exist.
+     */
+    getSiblingContentSize() {
+        var _a;
+        const sibling = getSplitViewPanelSibling(this._component);
+        return (_a = sibling === null || sibling === void 0 ? void 0 : sibling.getContentSize()) !== null && _a !== void 0 ? _a : 0;
+    }
+    /**
+     * Sets the content size of the sibling panel the component resizes into along its axis of
+     * orientation.
+     * @returns The sibling's content size in pixels.
+     */
+    setSiblingContentSize(value) {
+        const sibling = getSplitViewPanelSibling(this._component);
+        sibling === null || sibling === void 0 ? void 0 : sibling.setContentSize(value);
+    }
+    /**
+     * Runs the ripple animation.
+     * @param fromActivated Whether the ripple starts from and should end in an activated state.
+     */
+    activateRipple(fromActivated) {
+        if (fromActivated) {
+            this._ripple.deactivate();
+            // Wait a short amount of time so the animation is distinguishable
+            window.setTimeout(() => {
+                this._ripple.activate();
+            }, SPLIT_VIEW_PANEL_CONSTANTS.numbers.RIPPLE_ACTIVATION_WAIT);
+        }
+        else {
+            this._ripple.activate();
+            this._ripple.deactivate();
+        }
+    }
+    /**
+     * Deactivates the ripple.
+     */
+    deactivateRipple() {
+        this._ripple.deactivate();
+    }
+    /**
+     * Gets the size of the parent split view along the axis of orientation.
+     * @param orientation The component's orientation.
+     * @returns The parent's size in pixels.
+     */
+    getParentSize(orientation) {
+        var _a, _b;
+        const parentSize = orientation === 'horizontal' ? (_a = this._parent) === null || _a === void 0 ? void 0 : _a.clientWidth : (_b = this._parent) === null || _b === void 0 ? void 0 : _b.clientHeight;
+        return parentSize !== null && parentSize !== void 0 ? parentSize : 0;
+    }
+    /**
+     * Updates the provided characteristics of all panels.
+     * @param config An update configuration.
+     */
+    updateParent(config) {
+        var _a;
+        (_a = this._parent) === null || _a === void 0 ? void 0 : _a.update(config);
+    }
+}

package/esm/split-view/split-view-panel/split-view-panel-constants.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { SplitViewOrientation } from '../split-view/split-view-constants';
+export declare const SPLIT_VIEW_PANEL_CONSTANTS: {
+    elementName: "forge-split-view-panel";
+    attributes: {
+        RESIZABLE: string;
+        SIZE: string;
+        MIN: string;
+        MAX: string;
+        OPEN: string;
+        ACCESSIBLE_LABEL: string;
+        DISABLED: string;
+        ALLOW_CLOSE: string;
+        AUTO_CLOSE: string;
+        AUTO_CLOSE_THRESHOLD: string;
+        ORIENTATION: string;
+    };
+    classes: {
+        ROOT: string;
+        GRABBED: string;
+        HANDLE: string;
+        ICON: string;
+        CONTENT: string;
+        CLOSED: string;
+        CLOSING: string;
+        OPENING: string;
+        DISABLED: string;
+    };
+    ids: {
+        ROOT: string;
+        HANDLE: string;
+        ICON: string;
+        RIPPLE: string;
+        CONTENT: string;
+    };
+    selectors: {
+        ROOT: string;
+        HANDLE: string;
+        ICON: string;
+        RIPPLE: string;
+        CONTENT: string;
+    };
+    events: {
+        WILL_RESIZE: string;
+        RESIZE_START: string;
+        RESIZE_END: string;
+        RESIZE: string;
+        DID_OPEN: string;
+        DID_CLOSE: string;
+        WILL_OPEN: string;
+        WILL_CLOSE: string;
+    };
+    numbers: {
+        RIPPLE_ACTIVATION_WAIT: number;
+    };
+    customCssProperties: {
+        SIZE: string;
+        CURSOR: string;
+    };
+};
+export declare type SplitViewPanelResizable = 'start' | 'end' | 'off';
+export declare type SplitViewInputDeviceType = 'pointer' | 'keyboard';
+export declare enum SplitViewAnimatingLayer {
+    Under = 1,
+    Active = 2,
+    Above = 3
+}
+export interface ISplitViewPanelCursorConfig {
+    resizable: SplitViewPanelResizable;
+    boundary: 'min' | 'max' | 'none';
+}
+export interface ISplitViewPanelState {
+    orientation: SplitViewOrientation;
+    resizable: SplitViewPanelResizable;
+    arrowKeyHeld: boolean;
+    startPoint?: number;
+    startSize?: number;
+    currentSize?: number;
+    availableSpace?: number;
+    siblingSize?: number;
+    keyboardDelta: number;
+    isAtMin: boolean;
+    isAtMax: boolean;
+    min: number;
+    max?: number;
+}
+export interface ISplitViewPanelWillResizeEvent {
+    inputDeviceType: SplitViewInputDeviceType;
+}
+export interface ISplitViewPanelOpenEvent {
+    auto: boolean;
+    userInitiated: boolean;
+}

package/esm/split-view/split-view-panel/split-view-panel-constants.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { COMPONENT_NAME_PREFIX } from '../../constants';
+const elementName = `${COMPONENT_NAME_PREFIX}split-view-panel`;
+const attributes = {
+    RESIZABLE: 'resizable',
+    SIZE: 'size',
+    MIN: 'min',
+    MAX: 'max',
+    OPEN: 'open',
+    ACCESSIBLE_LABEL: 'accessible-label',
+    DISABLED: 'disabled',
+    ALLOW_CLOSE: 'allow-close',
+    AUTO_CLOSE: 'auto-close',
+    AUTO_CLOSE_THRESHOLD: 'auto-close-threshold',
+    ORIENTATION: 'orientation'
+};
+const classes = {
+    ROOT: 'forge-split-view-panel',
+    GRABBED: 'forge-split-view-panel--grabbed',
+    HANDLE: 'forge-split-view-panel__handle',
+    ICON: 'forge-split-view-panel__icon',
+    CONTENT: 'forge-split-view-panel__content',
+    CLOSED: 'forge-split-view-panel--closed',
+    CLOSING: 'forge-split-view-panel--closing',
+    OPENING: 'forge-split-view-panel--opening',
+    DISABLED: 'forge-split-view-panel--disabled'
+};
+const ids = {
+    ROOT: 'root',
+    HANDLE: 'handle',
+    ICON: 'icon',
+    RIPPLE: 'ripple',
+    CONTENT: 'content'
+};
+const selectors = {
+    ROOT: `#${ids.ROOT}`,
+    HANDLE: `#${ids.HANDLE}`,
+    ICON: `#${ids.ICON}`,
+    RIPPLE: `#${ids.RIPPLE}`,
+    CONTENT: `#${ids.CONTENT}`
+};
+const events = {
+    WILL_RESIZE: `${elementName}-will-resize`,
+    RESIZE_START: `${elementName}-resize-start`,
+    RESIZE_END: `${elementName}-resize-end`,
+    RESIZE: `${elementName}-resize`,
+    DID_OPEN: `${elementName}-did-open`,
+    DID_CLOSE: `${elementName}-did-close`,
+    WILL_OPEN: `${elementName}-will-open`,
+    WILL_CLOSE: `${elementName}-will-close`
+};
+const numbers = {
+    RIPPLE_ACTIVATION_WAIT: 200
+};
+const customCssProperties = {
+    SIZE: '--forge-split-view-panel-size',
+    CURSOR: '--forge-split-view-panel-cursor'
+};
+export const SPLIT_VIEW_PANEL_CONSTANTS = {
+    elementName,
+    attributes,
+    classes,
+    ids,
+    selectors,
+    events,
+    numbers,
+    customCssProperties
+};
+export var SplitViewAnimatingLayer;
+(function (SplitViewAnimatingLayer) {
+    SplitViewAnimatingLayer[SplitViewAnimatingLayer["Under"] = 1] = "Under";
+    SplitViewAnimatingLayer[SplitViewAnimatingLayer["Active"] = 2] = "Active";
+    SplitViewAnimatingLayer[SplitViewAnimatingLayer["Above"] = 3] = "Above";
+})(SplitViewAnimatingLayer || (SplitViewAnimatingLayer = {}));

package/esm/split-view/split-view-panel/split-view-panel-foundation.d.ts

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { ICustomElementFoundation } from '@tylertech/forge-core';
+import { SplitViewPanelResizable } from './split-view-panel-constants';
+import { ISplitViewPanelAdapter } from './split-view-panel-adapter';
+import { ISplitViewUpdateConfig } from '../split-view/split-view-constants';
+import { ISplitViewBase } from '../core/split-view-base';
+export interface ISplitViewPanelFoundation extends Partial<ISplitViewBase>, ICustomElementFoundation {
+    resizable: SplitViewPanelResizable;
+    size: number | string;
+    min: number | string;
+    max: number | string | undefined;
+    accessibleLabel: string;
+    open: boolean;
+    getContentSize(): number;
+    getCollapsibleSize(): number;
+    setContentSize(size: number): void;
+    update(config: ISplitViewUpdateConfig): void;
+}
+export declare class SplitViewPanelFoundation implements ISplitViewPanelFoundation {
+    private _adapter;
+    private _size;
+    private _min;
+    private _max;
+    private _accessibleLabel;
+    private _open;
+    private _disabled?;
+    private _allowClose?;
+    private _autoClose?;
+    private _autoCloseThreshold?;
+    private _state;
+    private _isInitialized;
+    private get _orientation();
+    private set _orientation(value);
+    private get _resizable();
+    private set _resizable(value);
+    private get _pixelMin();
+    private set _pixelMin(value);
+    private get _pixelMax();
+    private set _pixelMax(value);
+    private _parentProperties;
+    private get _appliedDisabled();
+    private get _appliedAllowClose();
+    private get _appliedAutoClose();
+    private get _appliedAutoCloseThreshold();
+    private _pointerdownListener;
+    private _pointerupListener;
+    private _pointermoveListener;
+    private _keydownListener;
+    private _keyupListener;
+    constructor(_adapter: ISplitViewPanelAdapter);
+    initialize(): void;
+    disconnect(): void;
+    /**
+     * Handles a pointerdown event and sets further pointer event listeners.
+     * @param evt The pointer event.
+     */
+    private _onPointerdown;
+    /**
+     * Handles a pointerup event and removes pointer event listeners.
+     * @param evt The pointer event.
+     */
+    private _onPointerup;
+    /**
+     * Handles a pointermove event and removes pointer events if the mouse button is released.
+     * @param evt The pointer event.
+     */
+    private _onPointermove;
+    /**
+     * Handles a keydown event and sets a keyup listener if an arrow key is pressed.
+     * @param evt The keyboard event.
+     */
+    private _onKeydown;
+    /**
+     * Handles a keyup event and removes the keyup listener if an arrow key was released.
+     * @param evt The keyboard event.
+     */
+    private _onKeyup;
+    /**
+     * Toggles the open state.
+     * @param evt
+     */
+    private _handleEnterKey;
+    /**
+     * Sets panel size to the min.
+     * @param evt
+     */
+    private _handleHomeKey;
+    /**
+     * Sets panel size to the max.
+     * @param evt
+     */
+    private _handleEndKey;
+    /**
+     * Runs resize logic if an arrow key is included in the event.
+     * @param evt
+     */
+    private _handleArrowKey;
+    /**
+     * Sets resize properties when an arrow key is first pressed.
+     */
+    private _tryHandleArrowKeyDown;
+    /**
+     * Performs cleanup logic after a keyboard driven resize.
+     */
+    private _handleArrowKeyUp;
+    /**
+     * Resizes the panel by a set amount.
+     * @param increment The pixel change in size.
+     */
+    private _handleArrowKeyHeld;
+    /**
+     * Handles the beginning of a pointer driven resize.
+     * @param evt
+     */
+    private _handlePointerdown;
+    /**
+     * Handles the end of a pointer driven resize.
+     */
+    private _handlePointerup;
+    /**
+     * Resizes the panel from a pointer event.
+     * @param evt
+     */
+    private _handlePointermove;
+    /**
+     * Emits a will resize event and allows it to be cancelled.
+     * @returns Whether the resize should proceed.
+     */
+    private _allowResize;
+    /**
+     * Handles common logic to begin a resize.
+     */
+    private _startResize;
+    /**
+     * Handles common logic to end a resize.
+     */
+    private _endResize;
+    /**
+     * Emits a will open or will close event and sets the panel open or closed if allowed.
+     * @param shouldOpen Whether the panel should open or close. Defaults to `true`.
+     * @param auto Whether the panel auto-opened or auto-closed.
+     * @param userInitiated Whether opening or closing via user action instead of programmatically.
+     */
+    private _tryOpenOrClose;
+    /**
+     * Auto close the panel if enabled and within the size threshold.
+     */
+    private _tryAutoClose;
+    /**
+     * Sets orientation, disabled, disable close, and autoclose to reflect the parent split view.
+     */
+    private _getParentProperties;
+    private _applyOrientation;
+    /**
+     * Get/set resizable. This affects the side the handle appears on and the direction the panel closes into.
+     */
+    get resizable(): SplitViewPanelResizable;
+    set resizable(value: SplitViewPanelResizable);
+    private _applyResizable;
+    /**
+     * Get/set panel size.
+     */
+    get size(): number | string;
+    set size(value: number | string);
+    private _applySize;
+    /** Get/set min panel size. */
+    get min(): number | string;
+    set min(value: number | string);
+    private _applyMin;
+    /** Get/set max panel size. */
+    get max(): number | string | undefined;
+    set max(value: number | string | undefined);
+    private _applyMax;
+    /**
+     * Get/set the accessible label.
+     */
+    get accessibleLabel(): string;
+    set accessibleLabel(value: string);
+    private _applyAccessibleLabel;
+    /**
+     * Get/set whether the panel is open.
+     */
+    get open(): boolean;
+    set open(value: boolean);
+    private _applyOpen;
+    /**
+     * Get/set whether interactions are disabled.
+     */
+    get disabled(): boolean | undefined;
+    set disabled(value: boolean | undefined);
+    private _applyDisabled;
+    private _applyParentDisabled;
+    /**
+     * Get/set whether closing the panel is disabled.
+     */
+    get allowClose(): boolean | undefined;
+    set allowClose(value: boolean | undefined);
+    private _applyAllowClose;
+    /**
+     * Get/set whether the panel closes when a threshold size is reached.
+     */
+    get autoClose(): boolean | undefined;
+    set autoClose(value: boolean | undefined);
+    private _applyAutoClose;
+    private _applyParentAutoClose;
+    /** Get/set the size at which the panel auto closes. */
+    get autoCloseThreshold(): number | undefined;
+    set autoCloseThreshold(value: number | undefined);
+    private _applyAutoCloseThreshold;
+    private _applyParentAutoCloseThreshold;
+    /**
+     * Gets the size of panel content without the handle.
+     * @returns Content size in pixels.
+     */
+    getContentSize(): number;
+    /**
+     * Gets how much the panel can shrink from its current size.
+     * @returns The difference between the current and min size in pixels.
+     */
+    getCollapsibleSize(): number;
+    /**
+     * Sets a new size for the content area.
+     * @param size The new content size in pixels.
+     */
+    setContentSize(size: number): void;
+    /**
+     * Updates the proved characteristics.
+     * @param config An update configuration.
+     */
+    update(config: ISplitViewUpdateConfig): void;
+}