@dhtmlx/vault 5.0.6

package/README.md

@@ -0,0 +1,251 @@
+# DHTMLX Vault — JavaScript File Uploader (GPL Edition)
+
+[![dhtmlx.com](https://img.shields.io/badge/made%20by-DHTMLX-blue)](https://dhtmlx.com/)
+[![npm: v.5.0.6](https://img.shields.io/badge/npm-v.5.0.6-blue.svg)](https://www.npmjs.com/package/@dhtmlx/vault)
+[![License: GPL v2](https://img.shields.io/badge/license-GPL%20v2-blue.svg)](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html)
+
+![](https://raw.githubusercontent.com/DHTMLX/public-files/main/logo/dhtmlx_logo.svg)
+
+`@dhtmlx/vault` is a JavaScript file upload and management component with drag-and-drop queuing, real-time progress tracking, list and grid display modes, inline file renaming, file download support, upload restrictions, custom HTML templates, and a configurable toolbar.
+
+It is a standalone widget that works with plain JavaScript and integrates with React, Angular, Vue, and Svelte.
+
+It is ideal for prototyping file upload interfaces, embedding file management in open-source applications, and evaluating DHTMLX Vault's core features under the GPL v2 license.
+
+![DHTMLX Vault screenshot](https://raw.githubusercontent.com/DHTMLX/public-files/main/image/dhtmlx_vault.png)
+
+---
+
+## License
+
+**This edition of DHTMLX Vault** is licensed under the GNU General Public License v2.0 (GPL v2).
+
+You can redistribute this package and/or modify it under the terms of the GPL v2.
+
+GPL v2 requires that any project using this package also be open source under a GPL-compatible license.
+
+**You may NOT use this package in closed-source, proprietary, or commercial applications** without a separate commercial license. For commercial use, please obtain a commercial license of DHTMLX Vault.
+
+This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GPL v2 for more details.
+
+### Using DHTMLX Vault in a commercial or closed-source project?
+
+You need a commercial license. DHTMLX offers Individual, Commercial, Enterprise, and Ultimate license tiers.
+
+- [Compare licenses and pricing](https://dhtmlx.com/docs/products/licenses.shtml)
+- [Download a free 30-day trial of DHTMLX Vault](https://dhtmlx.com/docs/products/dhtmlxVault/download.shtml)
+- [Download 30-day trial versions of all DHTMLX components](https://dhtmlx.com/docs/download/)
+- Contact us regarding licensing: [info@dhtmlx.com](mailto:info@dhtmlx.com)
+
+Copyright © 2026 XB Software Ltd.
+
+---
+
+## What is DHTMLX Vault
+
+**DHTMLX Vault** is a JavaScript file upload and management component for web applications. It renders a configurable layout consisting of a toolbar, a real-time progress bar, and a file area where users can add files by clicking or by dragging them from the file system. Files are displayed in list mode (default) or grid mode with image previews. Uploaded files can be renamed inline, reordered in the queue by drag-and-drop, cleared individually or in bulk, and downloaded from the server. Developers control upload behavior via the `uploader` configuration object, including the server target URL, automatic or manual upload triggering, and file restrictions by type, size, and count. Custom HTML templates can be applied to the list view, grid view, and progress bar for full visual control.
+
+**DHTMLX Vault is a standalone component.** It is not part of the DHTMLX Suite library, is distributed and licensed separately, and does not require Suite as a dependency. It can be combined with Suite widgets such as DHTMLX Form or Layout to embed the uploader inside larger application interfaces.
+
+Use this GPL edition when you want to prototype a file upload feature, integrate file management into an open-source project, or evaluate DHTMLX Vault's core features before obtaining a commercial license.
+
+---
+
+## Quick Start
+
+Install the package, import the styles, and initialize Vault in a container element.
+
+### Install
+
+```bash
+npm install @dhtmlx/vault
+```
+
+### Include in your project
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+```
+
+Or with script tags pointing to local codebase files:
+
+```html
+<script type="text/javascript" src="./codebase/vault.js"></script>
+<link rel="stylesheet" href="./codebase/vault.css">
+```
+
+The CSS import is required for default Vault styling and layout.
+
+### Initialize
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+
+const vault = new Vault("vault_container", {
+    uploader: {
+        target: "/upload"   // required: URL of your server-side upload handler
+    }
+});
+```
+
+Add a container element to your HTML:
+
+```html
+<div id="vault_container" style="width: 100%; height: 400px;"></div>
+```
+
+[See a live demo](https://snippet.dhtmlx.com/8qkj3kz1?tag=vault)
+
+---
+
+## Basic Usage — DHTMLX Vault
+
+### Manual upload with file restrictions
+
+Disable automatic upload so users queue files first and upload on demand. Restrict uploads to images under 2 MB:
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+
+const vault = new Vault("vault_container", {
+    uploader: {
+        target: "/upload",
+        autosend: false,        // disable auto-upload; show Upload button instead
+        singleRequest: false,   // upload files one by one (not as a single request)
+        params: {               // additional params sent with each upload request
+            userId: "123"
+        }
+    }
+});
+
+// React to successful upload of each file
+vault.events.on("uploadComplete", function(files) {
+    console.log("All files uploaded:", files);
+});
+
+// React to upload errors
+vault.events.on("uploadFail", function(file) {
+    console.warn("Upload failed for:", file.name);
+});
+```
+
+### Grid mode with image previews
+
+Switch Vault to grid mode to show thumbnails for uploaded images:
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+
+const vault = new Vault("vault_container", {
+    mode: "grid",               // display files as a grid with image previews
+    scaleFactor: 2,             // preview image quality (1 = 98×98px, 2 = 196×196px)
+    uploader: {
+        target: "/photos"
+    },
+    downloadURL: "/files/"      // base URL for file download links
+});
+```
+
+### Loading a pre-existing file list from the server
+
+Pre-populate the file area with files already stored on the server:
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+
+const vault = new Vault("vault_container", {
+    uploader: {
+        target: "/upload"
+    },
+    downloadURL: "/files/"
+});
+
+// Load a JSON list of previously uploaded files
+vault.data.load("/api/files");
+```
+
+### Custom progress bar template
+
+Replace the default progress bar with a custom template showing uploaded vs. total size:
+
+```js
+import { Vault } from "@dhtmlx/vault";
+import "@dhtmlx/vault/vault.css";
+
+function formatBytes(bytes) {
+    return (bytes / 1024 / 1024).toFixed(2) + " MB";
+}
+
+const vault = new Vault("vault_container", {
+    uploader: { target: "/upload" },
+    templates: {
+        progressBar: function(percent, extra) {
+            return formatBytes(extra.current) + " / " + formatBytes(extra.total);
+        }
+    }
+});
+```
+
+The `templates.progressBar` function receives the current upload percentage and an `extra` object containing `current` (bytes uploaded so far) and `total` (total bytes to upload). Return any HTML string to fully replace the default progress bar content.
+
+---
+
+## DHTMLX Vault Features
+
+DHTMLX Vault includes the following features in the GPL edition.
+
+| Feature | Details |
+|:---|:---|
+| Drag-and-drop file adding | Drag files from the file system directly into the Vault file area |
+| Drag-and-drop queue reordering | Reorder files in the upload queue by dragging them within the file area |
+| List mode | Display uploaded files as a vertical list with file name, size, and status |
+| Grid mode | Display uploaded files as a grid of thumbnails; image previews generated as HTML canvas |
+| Automatic upload | Files upload to the server as soon as they are added (default behavior) |
+| Manual upload | Disable autosend to let users queue files and upload on demand via a toolbar button |
+| Real-time progress bar | Total upload progress displayed in the toolbar area as a percentage |
+| Per-file progress bars | Individual progress indicators shown on each file item during upload |
+| Cancel upload | Cancel an in-progress upload batch via the Cancel button in the progress bar |
+| Inline file renaming | Rename files by double-clicking the file name; enabled via `editable: true` |
+| File download | Set `downloadURL` to enable direct download links for uploaded files |
+| Load file list from server | Pre-populate the file area from a server JSON endpoint via `vault.data.load(url)` |
+| File restrictions | Restrict uploads by file extension, file size, or total file count |
+| Single or multi-request upload | Send all files in one request or upload them individually via `singleRequest` |
+| Custom upload params | Pass additional parameters with each upload request via `uploader.params` |
+| Configurable toolbar | Show, hide, or replace toolbar buttons; add custom controls with any icon font |
+| Custom list template | Replace the default list item HTML via `templates.list` function |
+| Custom grid template | Replace the default grid item HTML via `templates.grid` function |
+| Custom progress bar template | Replace the default progress bar HTML via `templates.progressBar` function |
+| Event handlers in templates | Attach DOM event handlers to custom template elements via `eventHandlers` config |
+| Keyboard navigation | Navigate files in the queue using keyboard controls |
+| Four built-in themes | Light, Dark, Light High Contrast, and Dark High Contrast themes |
+| CSS variable theming | Customize colors, borders, and spacing via CSS variables |
+| Localization | Translate all UI labels via the `locale` configuration option |
+| Event system | API events including `uploadComplete`, `uploadFail`, `beforeUpload`, `fileAdded`, and more |
+
+This table highlights key features. For the complete and up-to-date feature list, see the [DHTMLX Vault documentation](https://docs.dhtmlx.com/vault/how_to_start.html).
+
+---
+
+## Framework Integration
+
+DHTMLX Vault works with popular front-end frameworks including React, Angular, Vue, and Svelte. These integration guides apply to both the GPL edition and the commercial editions of DHTMLX Vault.
+
+- [React integration guide](https://docs.dhtmlx.com/vault/react_integration.html)
+- [Angular integration guide](https://docs.dhtmlx.com/vault/angular_integration.html)
+- [Vue.js integration guide](https://docs.dhtmlx.com/vault/vuejs_integration.html)
+- [Svelte integration guide](https://docs.dhtmlx.com/vault/svelte_integration.html)
+
+---
+
+## Documentation and Resources
+
+- [Product page](https://dhtmlx.com/docs/products/dhtmlxVault/) – overview, screenshots, and key features.
+- [Documentation](https://docs.dhtmlx.com/vault/how_to_start.html) – getting started, guides, and configuration options.
+- [API reference](https://docs.dhtmlx.com/vault/api__refs__vault.html) – full JavaScript API for DHTMLX Vault.
+- [Live demos and samples](https://snippet.dhtmlx.com/8qkj3kz1?tag=vault) – interactive examples of DHTMLX Vault features.
+- [Support forum](https://forum.dhtmlx.com/c/vault) – community Q&A and discussions for DHTMLX Vault.

package/codebase/types/ts-calendar/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sources/Calendar";
+export * from "./sources/types";

package/codebase/types/ts-calendar/sources/Calendar.d.ts

@@ -0,0 +1,37 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { CalendarEvents, ICalendar, ICalendarConfig, ViewMode, ICalendarHandlersMap } from "./types";
+export declare class Calendar extends View implements ICalendar {
+    events: IEventSystem<CalendarEvents, ICalendarHandlersMap>;
+    config: ICalendarConfig;
+    private _selected;
+    private _currentDate;
+    private _currentViewMode;
+    private _isSelectedInCurrentRange;
+    private _handlers;
+    private _timepicker;
+    private _time;
+    private _linkedCalendar;
+    constructor(container: HTMLElement | string, config?: ICalendarConfig);
+    setValue(value: Date | Date[] | string | string[]): boolean;
+    getValue<T extends boolean = false>(asDateObject?: T): Date | string;
+    getValue<T extends boolean = true>(asDateObject?: T): Date[] | string[];
+    getCurrentMode(): ViewMode;
+    showDate(date?: Date, mode?: ViewMode): void;
+    destructor(): void;
+    clear(): void;
+    link(targetCalendar: Calendar): void;
+    private _unlink;
+    private _setSelected;
+    private _getSelected;
+    private _draw;
+    private _initHandlers;
+    private _getData;
+    private _drawCalendar;
+    private _drawMonthSelector;
+    private _drawYearSelector;
+    private _drawHeader;
+    private _drawTimepicker;
+    private _selectDate;
+    private _moveBrowseFocus;
+}

package/codebase/types/ts-calendar/sources/helper.d.ts

@@ -0,0 +1 @@
+export declare const linkButtonClasses = ".dhx_button.dhx_button--view_link.dhx_button--icon.dhx_button--size_medium.dhx_button--color_secondary";

package/codebase/types/ts-calendar/sources/types.d.ts

@@ -0,0 +1,64 @@
+export interface ICalendarConfig {
+    value?: Date | Date[] | string | string[];
+    date?: Date | string;
+    css?: string;
+    mark?: (a: Date) => string;
+    disabledDates?: (a: Date) => boolean;
+    weekStart?: "saturday" | "sunday" | "monday";
+    weekNumbers?: boolean;
+    mode?: ViewMode;
+    timePicker?: boolean;
+    dateFormat?: string;
+    timeFormat?: 24 | 12;
+    thisMonthOnly?: boolean;
+    width?: string | number;
+    range?: boolean;
+    $rangeMark?: (a: Date) => string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    block?: (a: Date) => boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    view?: ViewMode;
+}
+export interface ICalendar {
+    paint(): void;
+    destructor(): void;
+    clear(): void;
+    showDate(date?: Date, mode?: ViewMode): void;
+    setValue(value: Date | Date[] | string | string[]): boolean;
+    getValue(asDatObj?: boolean): Date | Date[] | string | string[];
+    getCurrentMode(): ViewMode;
+    link(calendar: ICalendar): void;
+}
+export type ViewMode = "calendar" | "year" | "month" | "timepicker";
+export interface ICalendarDay {
+    css: string;
+    date: Date;
+    day: number;
+}
+export interface ICalendarWeek {
+    weekNumber: number;
+    days: ICalendarDay[];
+    disabledWeekNumber?: boolean;
+}
+export declare enum CalendarEvents {
+    change = "change",
+    beforeChange = "beforechange",
+    modeChange = "modeChange",
+    monthSelected = "monthSelected",
+    yearSelected = "yearSelected",
+    cancelClick = "cancelClick",
+    dateMouseOver = "dateMouseOver",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    dateHover = "dateHover"
+}
+export interface ICalendarHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [CalendarEvents.change]: (date: Date, oldDate: Date, byClick: boolean, mode?: "clear") => void;
+    [CalendarEvents.beforeChange]: (date: Date, oldDate: Date, byClick: boolean) => boolean | void;
+    [CalendarEvents.dateMouseOver]: (date: Date, e: MouseEvent) => void;
+    [CalendarEvents.modeChange]: (mode: string) => void;
+    [CalendarEvents.monthSelected]: (month: number) => void;
+    [CalendarEvents.yearSelected]: (year: number) => void;
+    [CalendarEvents.cancelClick]: () => void;
+    [CalendarEvents.dateHover]: (date: Date, e: MouseEvent) => any;
+}

package/codebase/types/ts-combobox/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sources/Combobox";
+export * from "./sources/ProCombobox";
+export * from "./sources/types";

package/codebase/types/ts-combobox/sources/Combobox.d.ts

@@ -0,0 +1,53 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { DataCollection, DataEvents, IDataEventsHandlersMap, IDataItem } from "../../ts-data";
+import { Layout } from "../../ts-layout";
+import { List } from "../../ts-list";
+import { Popup } from "../../ts-popup";
+import { Id, IHandlers } from "../../ts-common/types";
+import { ComboboxEvents, ICombobox, IComboboxConfig, IComboboxEventHandlersMap, State } from "./types";
+export declare const $template: VNode;
+export declare class Combobox extends View implements ICombobox {
+    data: DataCollection;
+    config: IComboboxConfig;
+    events: IEventSystem<DataEvents | ComboboxEvents, IComboboxEventHandlersMap | IDataEventsHandlersMap>;
+    list: List;
+    popup: Popup;
+    protected _helper: Popup;
+    private _keyListener;
+    protected _layout: Layout;
+    private _isPopupConfiqureted;
+    private _state;
+    protected _handlers: IHandlers;
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    focus(): void | boolean;
+    blur(): void | boolean;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    clear(): void | boolean;
+    getValue<T extends boolean = false>(asArray?: T): T extends true ? Id[] : Id;
+    setValue(ids: Id[] | Id, silent?: boolean): void | boolean;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    destructor(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+    private _setValue;
+    protected _createLayout(): void;
+    private _initHandlers;
+    private _initEvents;
+    private _showOptions;
+    private _configurePopup;
+    private _hideOptions;
+    private _filter;
+    private _findBest;
+    private _exsistId;
+    private _draw;
+    private _drawSelectedItems;
+    private _drawImageOrIcon;
+    private _getItemText;
+    private _updateSelectedItem;
+    private _changePopupPosition;
+    private _updatePopup;
+}

package/codebase/types/ts-combobox/sources/ProCombobox.d.ts

@@ -0,0 +1,6 @@
+import { Combobox } from "./Combobox";
+import { IComboboxConfig } from "./types";
+export declare class ProCombobox extends Combobox {
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    protected _createLayout(): void;
+}

package/codebase/types/ts-combobox/sources/helper.d.ts

@@ -0,0 +1,4 @@
+export declare function selectAllView(): any;
+export declare function unselectAllView(): any;
+export declare function emptyListView(value?: string): any;
+export declare function emptyListHeight(value: string, width: number): number;

package/codebase/types/ts-combobox/sources/keyListener.d.ts

@@ -0,0 +1,14 @@
+export declare class KeyListener {
+    private _isActive;
+    private _sequence;
+    private _currentAction;
+    private _clearTimeout;
+    private _handler;
+    constructor();
+    startNewListen(action: (seq: string) => any): void;
+    endListen(): void;
+    reset(): void;
+    destructor(): void;
+    private _change;
+    private _addClearTimeout;
+}

package/codebase/types/ts-combobox/sources/locales/en.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    notFound: string;
+    selectAll: string;
+    unselectAll: string;
+    selectedItems: string;
+    createItem: string;
+};
+export default _default;

package/codebase/types/ts-combobox/sources/types.d.ts

@@ -0,0 +1,95 @@
+import { Id } from "../../ts-common/types";
+import { DataCollection, IDataItem } from "../../ts-data";
+export type ILabelPosition = "left" | "top";
+export interface IComboboxConfig {
+    data?: DataCollection<any> | any[];
+    disabled?: boolean;
+    readOnly?: boolean;
+    template?: (item: any) => string;
+    filter?: (item: any, input: string) => boolean;
+    multiselection?: boolean;
+    label?: string;
+    labelPosition?: ILabelPosition;
+    labelWidth?: string | number;
+    placeholder?: string;
+    selectAllButton?: boolean;
+    itemsCount?: boolean | ((count: number) => string);
+    itemHeight?: number | string;
+    virtual?: boolean;
+    listHeight?: number | string;
+    required?: boolean;
+    helpMessage?: string;
+    hiddenLabel?: boolean;
+    css?: string;
+    value?: Id | Id[];
+    newOptions?: boolean;
+    htmlEnable?: boolean;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, id: Id) => void | boolean;
+        };
+    };
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    cellHeight?: number;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    help?: string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    showItemsCount?: boolean | ((count: number) => string);
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    labelInline?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    readonly?: boolean;
+}
+export declare enum ComboboxEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    focus = "focus",
+    blur = "blur",
+    keydown = "keydown",
+    input = "input",
+    beforeOpen = "beforeOpen",
+    afterOpen = "afterOpen",
+    beforeClose = "beforeClose",
+    afterClose = "afterClose",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    open = "open",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close = "close"
+}
+export interface IComboboxEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ComboboxEvents.beforeChange]: (ids: Id | Id[]) => boolean | void;
+    [ComboboxEvents.change]: (ids: Id | Id[]) => void;
+    [ComboboxEvents.focus]: () => void;
+    [ComboboxEvents.blur]: () => void;
+    [ComboboxEvents.keydown]: (event: KeyboardEvent, id: Id | undefined) => void;
+    [ComboboxEvents.input]: (value: string) => void;
+    [ComboboxEvents.beforeOpen]: () => boolean | void;
+    [ComboboxEvents.afterOpen]: () => void;
+    [ComboboxEvents.beforeClose]: () => boolean | void;
+    [ComboboxEvents.afterClose]: () => void;
+    [ComboboxEvents.open]: () => void;
+    [ComboboxEvents.close]: () => void;
+}
+export interface ICombobox {
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    paint(): void;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    getValue(asArray?: boolean): Id[] | Id;
+    setValue(ids: Id[] | Id): void;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+}
+export declare enum ComboState {
+    default = 0,
+    error = 1,
+    success = 2
+}
+/** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+export type State = "success" | "error" | "default";

package/codebase/types/ts-common/FocusManager.d.ts

@@ -0,0 +1,15 @@
+export interface IFocusManager {
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+declare class FocusManager implements IFocusManager {
+    private _activeWidgetId;
+    private _initHandler;
+    private _removeFocusClass;
+    private _addFocusClass;
+    constructor();
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+export declare const focusManager: FocusManager;
+export {};

package/codebase/types/ts-common/KeyManager.d.ts

@@ -0,0 +1,19 @@
+import { anyFunction } from "./types";
+export interface IKeyManager {
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, context?: any): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}
+export declare class KeyManager implements IKeyManager {
+    private _keysStorage;
+    private _beforeCall;
+    private _initHandler;
+    constructor(beforeCall?: (e: Event, focus: any) => boolean);
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, handler?: anyFunction): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}

package/codebase/types/ts-common/ScrollView.d.ts

@@ -0,0 +1,40 @@
+import { anyFunction } from "./types";
+interface IScrollViewConfig {
+    enable: boolean;
+    autoHide: boolean;
+    timeout: number;
+    scrollHandler: anyFunction;
+}
+export declare const scrollViewConfig: IScrollViewConfig;
+export interface IScrollView {
+    config: IScrollViewConfig;
+    enable(): void;
+    disable(): void;
+    render(nods?: any[]): any;
+    update(): void;
+}
+export declare class ScrollView implements IScrollView {
+    config: IScrollViewConfig;
+    private _getRootView;
+    private _scrollYTop;
+    private _scrollXLeft;
+    private _runnerYTop;
+    private _runnerXLeft;
+    private _runnerHeight;
+    private _runnerWidth;
+    private _visibleYArea;
+    private _visibleXArea;
+    private _scrollWidth;
+    private _scrollHeight;
+    private _wheelName;
+    private _handlers;
+    private _autoHideFunc;
+    private _uid;
+    constructor(getRootView: any, config?: {});
+    enable(): void;
+    disable(): void;
+    render(element: any, uid?: string): any;
+    update(): void;
+    private _getRefs;
+}
+export {};