survey-core 1.10.5 → 1.11.1

package/ts3.4/typings/utils/animation.d.ts

@@ -1,3 +1,4 @@
+import { EventBase, Base } from "../base";
 export interface AnimationOptions {
     cssClass: string;
     onBeforeRunAnimation?: (element: HTMLElement) => void;
@@ -5,10 +6,25 @@ export interface AnimationOptions {
 }
 export interface IAnimationConsumer<T extends Array<any> = [
 ]> {
-    getLeaveOptions(...args: T): AnimationOptions;
-    getEnterOptions(...args: T): AnimationOptions;
+    getLeaveOptions?(...args: T): AnimationOptions;
+    getEnterOptions?(...args: T): AnimationOptions;
     getAnimatedElement(...args: T): HTMLElement;
     isAnimationEnabled(): boolean;
+    getRerenderEvent(): EventBase<Base>;
+}
+interface IGroupAnimationInfo {
+    isReorderingRunning: boolean;
+    isDeletingRunning: boolean;
+    isAddingRunning: boolean;
+}
+export interface IAnimationGroupConsumer<T> extends IAnimationConsumer<[
+    T
+]> {
+    getLeaveOptions?(item: T, info?: IGroupAnimationInfo): AnimationOptions;
+    getEnterOptions?(item: T, info?: IGroupAnimationInfo): AnimationOptions;
+    getReorderOptions?(item: T, movedForward: boolean, info?: IGroupAnimationInfo): AnimationOptions;
+    getKey?: (item: T) => any;
+    allowSyncRemovalAddition?: boolean;
 }
 export declare class AnimationUtils {
     private getMsFromRule;
@@ -19,11 +35,12 @@ export declare class AnimationUtils {
     private addCancelCallback;
     private removeCancelCallback;
     protected onAnimationEnd(element: HTMLElement, callback: (isCancel?: boolean) => void, options: AnimationOptions): void;
+    protected afterAnimationRun(element: HTMLElement, options: AnimationOptions | AnimationOptions): void;
     protected beforeAnimationRun(element: HTMLElement, options: AnimationOptions | AnimationOptions): void;
     private getCssClasses;
     protected runAnimation(element: HTMLElement, options: AnimationOptions, callback: (isCancel?: boolean) => void): void;
     protected clearHtmlElement(element: HTMLElement, options: AnimationOptions): void;
-    protected onNextRender(callback: () => void, runEarly?: () => boolean, isCancel?: boolean): void;
+    protected onNextRender(callback: (isCancel?: boolean) => void, isCancel?: boolean): void;
     cancel(): void;
 }
 export declare class AnimationPropertyUtils extends AnimationUtils {
@@ -31,41 +48,38 @@ export declare class AnimationPropertyUtils extends AnimationUtils {
     onLeave(options: IAnimationConsumer, callback: () => void): void;
 }
 export declare class AnimationGroupUtils<T> extends AnimationUtils {
-    runGroupAnimation(options: IAnimationConsumer<[
-        T
-    ]>, addedElements: Array<T>, removedElements: Array<T>, callback?: () => void): void;
+    runGroupAnimation(options: IAnimationGroupConsumer<T>, addedItems: Array<T>, removedItems: Array<T>, reorderedItems: Array<{
+        item: T;
+        movedForward: boolean;
+    }>, callback?: () => void): void;
 }
-export declare abstract class AnimationProperty<T, S extends Array<any> = [
-]> {
-    protected animationOptions: IAnimationConsumer<S>;
+export declare abstract class AnimationProperty<T, S extends IAnimationConsumer<any> = IAnimationConsumer> {
+    protected animationOptions: S;
     protected update: (val: T, isTempUpdate?: boolean) => void;
     protected getCurrentValue: () => T;
-    constructor(animationOptions: IAnimationConsumer<S>, update: (val: T, isTempUpdate?: boolean) => void, getCurrentValue: () => T);
+    constructor(animationOptions: S, update: (val: T, isTempUpdate?: boolean) => void, getCurrentValue: () => T);
     protected animation: AnimationUtils;
+    protected onNextRender(callback: () => void, onCancel?: () => void): void;
     protected abstract _sync(newValue: T): void;
     private _debouncedSync;
     sync(newValue: T): void;
+    private cancelCallback;
     cancel(): void;
 }
 export declare class AnimationBoolean extends AnimationProperty<boolean> {
     protected animation: AnimationPropertyUtils;
     protected _sync(newValue: boolean): void;
 }
-export declare class AnimationGroup<T> extends AnimationProperty<Array<T>, [
-    T
-]> {
+export declare class AnimationGroup<T> extends AnimationProperty<Array<T>, IAnimationGroupConsumer<T>> {
     protected animation: AnimationGroupUtils<T>;
     protected _sync(newValue: Array<T>): void;
 }
-export declare class AnimationTab<T> extends AnimationProperty<Array<T>, [
-    T
-]> {
+export declare class AnimationTab<T> extends AnimationProperty<Array<T>, IAnimationGroupConsumer<T>> {
     protected mergeValues?: (newValue: Array<T>, oldValue: Array<T>) => Array<T>;
     protected animation: AnimationGroupUtils<T>;
-    constructor(animationOptions: IAnimationConsumer<[
-        T
-    ]>, update: (val: Array<T>, isTempUpdate?: boolean) => void, getCurrentValue: () => Array<T>, mergeValues?: (newValue: Array<T>, oldValue: Array<T>) => Array<T>);
+    constructor(animationOptions: IAnimationGroupConsumer<T>, update: (val: Array<T>, isTempUpdate?: boolean) => void, getCurrentValue: () => Array<T>, mergeValues?: (newValue: Array<T>, oldValue: Array<T>) => Array<T>);
     protected _sync(newValue: [
         T
     ]): void;
 }
+export {};

package/ts3.4/typings/utils/popup.d.ts

@@ -13,10 +13,21 @@ export interface ISize {
     width: number;
     height: number;
 }
+export declare class Rect implements ISize, INumberPosition {
+    private x;
+    private y;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
 export declare class PopupUtils {
     static bottomIndent: number;
-    static calculatePosition(targetRect: ClientRect, height: number, width: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, showPointer: boolean, positionMode?: PositionMode): INumberPosition;
-    static getCorrectedVerticalDimensions(top: number, height: number, windowHeight: number, verticalPosition: VerticalPosition): any;
+    static calculatePosition(targetRect: Rect, height: number, width: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, positionMode?: PositionMode): INumberPosition;
+    static getCorrectedVerticalDimensions(top: number, height: number, windowHeight: number, verticalPosition: VerticalPosition, canShrink?: boolean): any;
     static updateHorizontalDimensions(left: number, width: number, windowWidth: number, horizontalPosition: HorizontalPosition, positionMode?: PositionMode, margins?: {
         left: number;
         right: number;
@@ -24,7 +35,8 @@ export declare class PopupUtils {
         width: number;
         left: number;
     };
-    static updateVerticalPosition(targetRect: ClientRect, height: number, verticalPosition: VerticalPosition, showPointer: boolean, windowHeight: number): VerticalPosition;
+    static updateVerticalPosition(targetRect: Rect, height: number, horizontalPosition: HorizontalPosition, verticalPosition: VerticalPosition, windowHeight: number): VerticalPosition;
+    static updateHorizontalPosition(targetRect: Rect, width: number, horizontalPosition: HorizontalPosition, windowWidth: number): HorizontalPosition;
     static calculatePopupDirection(verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition): string;
-    static calculatePointerTarget(targetRect: ClientRect, top: number, left: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, marginLeft?: number, marginRight?: number): INumberPosition;
+    static calculatePointerTarget(targetRect: Rect, top: number, left: number, verticalPosition: VerticalPosition, horizontalPosition: HorizontalPosition, marginLeft?: number, marginRight?: number): INumberPosition;
 }

package/ts3.4/typings/utils/utils.d.ts

@@ -44,4 +44,13 @@ export declare class Logger {
 export declare function showConfirmDialog(message: string, callback: (res: boolean) => void, applyTitle?: string, locale?: string, rootElement?: HTMLElement): boolean;
 export declare function configConfirmDialog(popupViewModel: PopupBaseViewModel): void;
 declare function chooseFiles(input: HTMLInputElement, callback: (files: File[]) => void): void;
+export declare function compareArrays<T>(oldValue: Array<T>, newValue: Array<T>, getKey: (item: T) => any): {
+    addedItems: Array<T>;
+    deletedItems: Array<T>;
+    reorderedItems: Array<{
+        item: T;
+        movedForward: boolean;
+    }>;
+    mergedItems: Array<T>;
+};
 export { mergeValues, getElementWidth, isContainerVisible, classesToSelector, compareVersions, confirmAction, confirmActionAsync, detectIEOrEdge, detectIEBrowser, loadFileFromBase64, isMobile, isShadowDOM, getElement, isElementVisible, findScrollableParent, scrollElementByChildId, navigateToUrl, wrapUrlForBackgroundImage, createSvg, getIconNameFromProxy, increaseHeightByContent, getOriginalEvent, preventDefaults, findParentByClassNames, getFirstVisibleChild, chooseFiles };

package/typings/actions/action.d.ts

@@ -1,7 +1,7 @@
 import { ILocalizableOwner, LocalizableString } from "../localizablestring";
 import { Base, ComputedUpdater } from "../base";
 import { IListModel } from "../list";
-import { IPopupOptionsBase } from "../popup";
+import { IPopupOptionsBase, PopupModel } from "../popup";
 export declare type actionModeType = "large" | "small" | "popup" | "removed";
 /**
  * An action item.
@@ -146,13 +146,20 @@ export interface IAction {
     ariaExpanded?: boolean;
     ariaRole?: string;
     elementId?: string;
+    items?: Array<IAction>;
+    markerIconName?: string;
+    markerIconSize?: number;
+    showPopup?: () => void;
+    hidePopup?: () => void;
 }
 export interface IActionDropdownPopupOptions extends IListModel, IPopupOptionsBase {
 }
 export declare function createDropdownActionModel(actionOptions: IAction, dropdownOptions: IActionDropdownPopupOptions, locOwner?: ILocalizableOwner): Action;
-export declare function createDropdownActionModelAdvanced(actionOptions: IAction, listOptions: IListModel, popupOptions?: IPopupOptionsBase, locOwner?: ILocalizableOwner): Action;
+export declare function createDropdownActionModelAdvanced(actionOptions: IAction, listOptions: IListModel, popupOptions?: IPopupOptionsBase): Action;
+export declare function createPopupModelWithListModel(listOptions: IListModel, popupOptions: IPopupOptionsBase): PopupModel;
 export declare function getActionDropdownButtonTarget(container: HTMLElement): HTMLElement;
 export declare abstract class BaseAction extends Base implements IAction {
+    items?: IAction[];
     private static renderedId;
     private static getNextRendredId;
     private cssClassesValue;
@@ -180,6 +187,8 @@ export declare abstract class BaseAction extends Base implements IAction {
     removePriority: number;
     iconName: string;
     iconSize: number;
+    markerIconName: string;
+    markerIconSize: number;
     css?: string;
     minDimension: number;
     maxDimension: number;
@@ -207,6 +216,15 @@ export declare abstract class BaseAction extends Base implements IAction {
     getActionRootCss(): string;
     getTooltip(): string;
     getIsTrusted(args: any): boolean;
+    showPopup(): void;
+    hidePopup(): void;
+    isPressed: boolean;
+    isHovered: boolean;
+    private showPopupTimeout;
+    private hidePopupTimeout;
+    private clearPopupTimeouts;
+    showPopupDelayed(delay: number): void;
+    hidePopupDelayed(delay: number): void;
     protected abstract getEnabled(): boolean;
     protected abstract setEnabled(val: boolean): void;
     protected abstract getVisible(): boolean;
@@ -225,6 +243,7 @@ export declare class Action extends BaseAction implements IAction, ILocalizableO
     private raiseUpdate;
     constructor(innerItem: IAction);
     private createLocTitle;
+    setItems(items: Array<IAction>, onSelectionChanged?: (item: Action, ...params: any[]) => void): void;
     location?: string;
     id: string;
     private _visible;

package/typings/actions/adaptive-container.d.ts

@@ -13,7 +13,6 @@ export declare class AdaptiveActionContainer<T extends Action = Action> extends
     private static ContainerID;
     constructor();
     get hiddenItemsListModel(): ListModel;
-    protected hiddenItemSelected(item: T): void;
     protected onSet(): void;
     protected onPush(item: T): void;
     protected getRenderedActions(): Array<T>;

package/typings/actions/container.d.ts

@@ -45,6 +45,10 @@ export declare class ActionContainer<T extends BaseAction = Action> extends Base
     addAction(val: IAction, sortByVisibleIndex?: boolean): T;
     private sortItems;
     setItems(items: Array<IAction>, sortByVisibleIndex?: boolean): void;
+    subItemsShowDelay: number;
+    subItemsHideDelay: number;
+    protected popupAfterShowCallback(itemValue: T): void;
+    mouseOverHandler(itemValue: T): void;
     initResponsivityManager(container: HTMLDivElement, delayedUpdateFunction?: (callback: () => void) => void): void;
     resetResponsivityManager(): void;
     getActionById(id: string): T;

package/typings/base-interfaces.d.ts

@@ -153,7 +153,7 @@ export interface ISurvey extends ITextProcessor, ISurveyErrorOwner {
     dynamicPanelGetTabTitle(question: IQuestion, options: any): any;
     dynamicPanelCurrentIndexChanged(question: IQuestion, options: any): void;
     dragAndDropAllow(options: DragDropAllowEvent): boolean;
-    scrollElementToTop(element: ISurveyElement, question: IQuestion, page: IPage, id: string, scrollIfVisible?: boolean): any;
+    scrollElementToTop(element: ISurveyElement, question: IQuestion, page: IPage, id: string, scrollIfVisible?: boolean, scrollIntoViewOptions?: ScrollIntoViewOptions): any;
     runExpression(expression: string): any;
     elementContentVisibilityChanged(element: ISurveyElement): void;
     onCorrectQuestionAnswer(question: IQuestion, options: any): void;

package/typings/base.d.ts

@@ -302,6 +302,13 @@ export declare class Base {
     private animationAllowedLock;
     blockAnimations(): void;
     releaseAnimations(): void;
+    supportOnElementRenderedEvent: boolean;
+    onElementRenderedEventEnabled: boolean;
+    enableOnElementRenderedEvent(): void;
+    disableOnElementRenderedEvent(): void;
+    protected _onElementRerendered: EventBase<Base>;
+    get onElementRerendered(): EventBase<Base>;
+    afterRerender(): void;
 }
 export declare class ArrayChanges<T = any> {
     index: number;

package/typings/defaultCss/defaultV2Css.d.ts

@@ -166,6 +166,7 @@ export declare var defaultV2Css: {
     rowMultiple: string;
     rowCompact: string;
     rowFadeIn: string;
+    rowDelayedFadeIn: string;
     rowFadeOut: string;
     pageRow: string;
     question: {
@@ -225,6 +226,7 @@ export declare var defaultV2Css: {
         disabled: string;
         readOnly: string;
         preview: string;
+        noPointerEventsMode: string;
         errorsContainer: string;
         errorsContainerTop: string;
         errorsContainerBottom: string;
@@ -565,6 +567,7 @@ export declare var defaultV2Css: {
         dragElementDecorator: string;
         iconDragElement: string;
         footer: string;
+        footerTotalCell: string;
         emptyRowsSection: string;
         iconDrag: string;
         ghostRow: string;

package/typings/dragdrop/ranking-choices.d.ts

@@ -1,5 +1,6 @@
 import { ItemValue } from "../itemvalue";
 import { DragDropChoices } from "./choices";
+import { QuestionRankingModel } from "../question_ranking";
 export declare class DragDropRankingChoices extends DragDropChoices {
     protected get draggedElementType(): string;
     protected createDraggedElementShortcut(text: string, draggedElementNode: HTMLElement, event: PointerEvent): HTMLElement;
@@ -9,9 +10,14 @@ export declare class DragDropRankingChoices extends DragDropChoices {
     protected findDropTargetNodeByDragOverNode(dragOverNode: HTMLElement): HTMLElement;
     private getIsDragOverRootNode;
     protected isDropTargetValid(dropTarget: ItemValue, dropTargetNode?: HTMLElement): boolean;
-    protected calculateIsBottom(clientY: number): boolean;
+    protected calculateIsBottom(clientY: number, dropTargetNode?: HTMLElement): boolean;
     protected doDragOver: () => any;
+    getIndixies(model: any, fromChoicesArray: Array<ItemValue>, toChoicesArray: Array<ItemValue>): {
+        fromIndex: number;
+        toIndex: number;
+    };
     protected afterDragOver(dropTargetNode: HTMLElement): void;
+    reorderRankedItem: (questionModel: QuestionRankingModel, fromIndex: number, toIndex: number) => void;
     protected updateDraggedElementShortcut(newIndex: number): void;
     protected ghostPositionChanged(): void;
     protected doBanDropHere: () => any;

package/typings/dragdrop/ranking-select-to-rank.d.ts

@@ -8,19 +8,10 @@ export declare class DragDropRankingSelectToRank extends DragDropRankingChoices
     protected isDropTargetValid(dropTarget: ItemValue | string, dropTargetNode?: HTMLElement): boolean;
     protected afterDragOver(dropTargetNode: HTMLElement): void;
     doRankBetween(dropTargetNode: HTMLElement, fromChoicesArray: Array<ItemValue>, toChoicesArray: Array<ItemValue>, rankFunction: Function): void;
-    getIndixies(model: any, fromChoicesArray: Array<ItemValue>, toChoicesArray: Array<ItemValue>): {
-        fromIndex: number;
-        toIndex: number;
-    };
-    protected calculateIsBottom(clientY: number, dropTargetNode?: HTMLElement): boolean;
-    private doUIEffects;
     private get isDraggedElementRanked();
     private get isDropTargetRanked();
     private get isDraggedElementUnranked();
-    private get isDropTargetUnranked();
     private updateChoices;
     selectToRank: (questionModel: QuestionRankingModel, fromIndex: number, toIndex: number) => void;
     unselectFromRank: (questionModel: QuestionRankingModel, fromIndex: number, toIndex?: number) => void;
-    reorderRankedItem: (questionModel: QuestionRankingModel, fromIndex: number, toIndex: number, dropTargetNode?: HTMLElement) => void;
-    clear(): void;
 }

package/typings/functionsfactory.d.ts

@@ -3,12 +3,12 @@ export declare class FunctionFactory {
     static Instance: FunctionFactory;
     private functionHash;
     private isAsyncHash;
-    register(name: string, func: (params: any[]) => any, isAsync?: boolean): void;
+    register(name: string, func: (params: any[], originalParams?: any[]) => any, isAsync?: boolean): void;
     unregister(name: string): void;
     hasFunction(name: string): boolean;
     isAsyncFunction(name: string): boolean;
     clear(): void;
     getAll(): Array<string>;
-    run(name: string, params: any[], properties?: HashTable<any>): any;
+    run(name: string, params: any[], properties: HashTable<any>, originalParams: any[]): any;
 }
-export declare var registerFunction: (name: string, func: (params: any[]) => any, isAsync?: boolean) => void;
+export declare var registerFunction: (name: string, func: (params: any[], originalParams?: any[]) => any, isAsync?: boolean) => void;

package/typings/list.d.ts

@@ -1,5 +1,6 @@
 import { ActionContainer } from "./actions/container";
 import { Action, BaseAction, IAction } from "./actions/action";
+import { ILocalizableOwner } from "./localizablestring";
 export declare let defaultListCss: {
     root: string;
     item: string;
@@ -9,8 +10,10 @@ export declare let defaultListCss: {
     itemWithIcon: string;
     itemDisabled: string;
     itemFocused: string;
+    itemHovered: string;
     itemTextWrap: string;
     itemIcon: string;
+    itemMarkerIcon: string;
     itemSeparator: string;
     itemBody: string;
     itemsContainer: string;
@@ -23,19 +26,23 @@ export declare let defaultListCss: {
 };
 export interface IListModel {
     items: Array<IAction>;
-    onSelectionChanged: (item: Action, ...params: any[]) => void;
+    onSelectionChanged?: (item: IAction, ...params: any[]) => void;
     allowSelection?: boolean;
+    searchEnabled?: boolean;
     selectedItem?: IAction;
+    elementId?: string;
+    locOwner?: ILocalizableOwner;
     onFilterStringChangedCallback?: (text: string) => void;
-    onTextSearchCallback?: (text: string, textToSearch: string) => boolean;
+    onTextSearchCallback?: (item: IAction, textToSearch: string) => boolean;
 }
 export declare class ListModel<T extends BaseAction = Action> extends ActionContainer<T> {
-    onSelectionChanged: (item: T, ...params: any[]) => void;
-    allowSelection: boolean;
+    onSelectionChanged?: (item: T, ...params: any[]) => void;
+    allowSelection?: boolean;
     elementId?: string;
     private listContainerHtmlElement;
     private loadingIndicatorValue;
-    private onFilterStringChangedCallback?;
+    private onFilterStringChangedCallback;
+    private onTextSearchCallback;
     searchEnabled: boolean;
     showFilter: boolean;
     forceShowFilter: boolean;
@@ -54,12 +61,12 @@ export declare class ListModel<T extends BaseAction = Action> extends ActionCont
     areSameItemsCallback: (item1: IAction, item2: IAction) => boolean;
     private hasText;
     isItemVisible(item: T): boolean;
+    protected getRenderedActions(): Array<T>;
     get visibleItems(): Array<T>;
     private get shouldProcessFilter();
     private onFilterStringChanged;
     private scrollToItem;
-    constructor(items: Array<IAction>, onSelectionChanged: (item: T, ...params: any[]) => void, allowSelection: boolean, selectedItem?: IAction, elementId?: string);
-    private onTextSearchCallback;
+    constructor(items: Array<IAction> | IListModel, onSelectionChanged?: (item: T, ...params: any[]) => void, allowSelection?: boolean, selectedItem?: IAction, elementId?: string);
     setOnFilterStringChangedCallback(callback: (text: string) => void): void;
     setOnTextSearchCallback(callback: (item: T, textToSearch: string) => boolean): void;
     setItems(items: Array<IAction>, sortByVisibleIndex?: boolean): void;
@@ -73,8 +80,10 @@ export declare class ListModel<T extends BaseAction = Action> extends ActionCont
         itemWithIcon: string;
         itemDisabled: string;
         itemFocused: string;
+        itemHovered: string;
         itemTextWrap: string;
         itemIcon: string;
+        itemMarkerIcon: string;
         itemSeparator: string;
         itemBody: string;
         itemsContainer: string;
@@ -86,6 +95,9 @@ export declare class ListModel<T extends BaseAction = Action> extends ActionCont
         emptyText: string;
     };
     onItemClick: (itemValue: T) => void;
+    protected popupAfterShowCallback(itemValue: T): void;
+    onItemHover: (itemValue: T) => void;
+    onItemLeave(itemValue: T): void;
     isItemDisabled: (itemValue: T) => boolean;
     isItemSelected: (itemValue: T) => boolean;
     isItemFocused: (itemValue: T) => boolean;

package/typings/multiSelectListModel.d.ts

@@ -1,10 +1,13 @@
 import { Action, BaseAction, IAction } from "./actions/action";
-import { ListModel } from "./list";
+import { IListModel, ListModel } from "./list";
+export interface IMultiSelectListModel extends IListModel {
+    selectedItems?: Array<IAction>;
+}
 export declare class MultiSelectListModel<T extends BaseAction = Action> extends ListModel<T> {
     selectedItems: Array<IAction>;
     hideSelectedItems: boolean;
     private updateItemState;
-    constructor(items: Array<IAction>, onSelectionChanged: (item: T, status: string) => void, allowSelection: boolean, selectedItems?: Array<IAction>, elementId?: string);
+    constructor(options: IMultiSelectListModel);
     onItemClick: (item: T) => void;
     isItemDisabled: (itemValue: T) => boolean;
     isItemSelected: (itemValue: T) => boolean;

package/typings/panel.d.ts

@@ -524,7 +524,6 @@ export declare class PanelModel extends PanelModelBase implements IElement {
     protected getPanelStartIndex(index: number): number;
     protected isContinueNumbering(): boolean;
     private notifySurveyOnVisibilityChanged;
-    protected hasErrorsCore(rec: any): void;
     protected getRenderedTitle(str: string): string;
     /**
      * Increases or decreases an indent of panel content from the left edge. Accepts positive integer values and 0.
@@ -559,6 +558,7 @@ export declare class PanelModel extends PanelModelBase implements IElement {
     protected getHasFrameV2(): boolean;
     protected getIsNested(): boolean;
     get showPanelAsPage(): boolean;
+    protected onElementExpanded(elementIsRendered: boolean): void;
     protected getCssRoot(cssClasses: {
         [index: string]: string;
     }): string;

package/typings/popup-dropdown-view-model.d.ts

@@ -1,9 +1,10 @@
-import { IPosition } from "./utils/popup";
+import { IPosition, Rect } from "./utils/popup";
 import { CssClassBuilder } from "./utils/cssClassBuilder";
 import { PopupModel } from "./popup";
 import { PopupBaseViewModel } from "./popup-view-model";
 export declare class PopupDropdownViewModel extends PopupBaseViewModel {
     targetElement?: HTMLElement;
+    areaElement?: HTMLElement;
     private scrollEventCallBack;
     private static readonly tabletSizeBreakpoint;
     private calculateIsTablet;
@@ -13,6 +14,8 @@ export declare class PopupDropdownViewModel extends PopupBaseViewModel {
     private isTablet;
     private touchStartEventCallback;
     private touchMoveEventCallback;
+    protected getAvailableAreaRect(): Rect;
+    protected getTargetElementRect(): Rect;
     private _updatePosition;
     protected getActualHorizontalPosition(): "left" | "center" | "right";
     protected getStyleClass(): CssClassBuilder;
@@ -21,8 +24,8 @@ export declare class PopupDropdownViewModel extends PopupBaseViewModel {
     popupDirection: string;
     pointerTarget: IPosition;
     private recalculatePositionHandler;
-    constructor(model: PopupModel, targetElement?: HTMLElement);
-    setComponentElement(componentRoot: HTMLElement, targetElement?: HTMLElement | null): void;
+    constructor(model: PopupModel, targetElement?: HTMLElement, areaElement?: HTMLElement);
+    setComponentElement(componentRoot: HTMLElement, targetElement?: HTMLElement | null, areaElement?: HTMLElement | null): void;
     resetComponentElement(): void;
     updateOnShowing(): void;
     private get shouldCreateResizeCallback();

package/typings/popup-view-model.d.ts

@@ -19,14 +19,17 @@ export declare class PopupBaseViewModel extends Base implements IAnimationConsum
     _isVisible: boolean;
     locale: string;
     private updateIsVisible;
+    private updateBeforeShowing;
+    private updateAfterHiding;
     private visibilityAnimation;
     getLeaveOptions(): AnimationOptions;
     getEnterOptions(): AnimationOptions;
     getAnimatedElement(): HTMLElement;
     isAnimationEnabled(): boolean;
+    getRerenderEvent(): EventBase<Base>;
     private getAnimationContainer;
-    set isVisible(val: boolean);
     get isVisible(): boolean;
+    set isVisible(val: boolean);
     onVisibilityChanged: EventBase<PopupBaseViewModel, any>;
     get container(): HTMLElement;
     private containerElement;
@@ -72,7 +75,7 @@ export declare class PopupBaseViewModel extends Base implements IAnimationConsum
     cancel(): void;
     dispose(): void;
     initializePopupContainer(): void;
-    setComponentElement(componentRoot: HTMLElement, targetElement?: HTMLElement | null): void;
+    setComponentElement(componentRoot: HTMLElement, targetElement?: HTMLElement | null, areaElement?: HTMLElement | null): void;
     resetComponentElement(): void;
     protected preventScrollOuside(event: any, deltaY: number): void;
 }

package/typings/popup.d.ts

@@ -12,6 +12,7 @@ export interface IPopupOptionsBase {
     horizontalPosition?: HorizontalPosition;
     showPointer?: boolean;
     isModal?: boolean;
+    canShrink?: boolean;
     displayMode?: "popup" | "overlay";
 }
 export interface IDialogOptions extends IPopupOptionsBase {
@@ -35,6 +36,7 @@ export declare class PopupModel<T = any> extends Base implements IPopupOptionsBa
     horizontalPosition: HorizontalPosition;
     showPointer: boolean;
     isModal: boolean;
+    canShrink: boolean;
     isFocusedContent: boolean;
     isFocusedContainer: boolean;
     cssClass: string;
@@ -50,8 +52,11 @@ export declare class PopupModel<T = any> extends Base implements IPopupOptionsBa
     get isVisible(): boolean;
     set isVisible(value: boolean);
     toggleVisibility(): void;
+    show(): void;
+    hide(): void;
     recalculatePosition(isResetHeight: boolean): void;
     updateFooterActions(footerActions: Array<IAction>): Array<IAction>;
+    onHiding(): void;
     dispose(): void;
 }
 export declare function createDialogOptions(componentName: string, data: any, onApply: () => boolean, onCancel?: () => void, onHide?: () => void, onShow?: () => void, cssClass?: string, title?: string, displayMode?: "popup" | "overlay"): IDialogOptions;

package/typings/question.d.ts

@@ -427,7 +427,8 @@ export declare class Question extends SurveyElement<Question> implements IQuesti
      */
     focus(onError?: boolean, scrollIfVisible?: boolean): void;
     private focuscore;
-    private expandAllParents;
+    expandAllParents(): void;
+    private expandAllParentsCore;
     focusIn(): void;
     protected fireCallback(callback: () => void): void;
     getOthersMaxLength(): any;
@@ -492,6 +493,8 @@ export declare class Question extends SurveyElement<Question> implements IQuesti
     get isInputReadOnly(): boolean;
     get renderedInputReadOnly(): string;
     get renderedInputDisabled(): string;
+    get isReadOnlyAttr(): boolean;
+    get isDisabledAttr(): boolean;
     protected onReadOnlyChanged(): void;
     /**
      * A Boolean expression. If it evaluates to `false`, this question becomes read-only.
@@ -712,6 +715,7 @@ export declare class Question extends SurveyElement<Question> implements IQuesti
     */
     isAnswerCorrect(): boolean;
     updateValueWithDefaults(): void;
+    get isValueDefault(): boolean;
     protected get isClearValueOnHidden(): boolean;
     getQuestionFromArray(name: string, index: number): IQuestion;
     getDefaultValue(): any;
@@ -802,7 +806,7 @@ export declare class Question extends SurveyElement<Question> implements IQuesti
     protected isNewValueCorrect(val: any): boolean;
     protected isNewValueEqualsToValue(newValue: any): boolean;
     protected isTextValue(): boolean;
-    get isSurveyInputTextUpdate(): boolean;
+    protected getIsInputTextUpdate(): boolean;
     get requireStrictCompare(): boolean;
     private getDataLocNotification;
     get isInputTextUpdate(): boolean;

package/typings/question_baseselect.d.ts

@@ -45,6 +45,8 @@ export declare class QuestionSelectBase extends Question {
     isLayoutTypeSupported(layoutType: string): boolean;
     localeChanged(): void;
     locStrsChanged(): void;
+    private prevOtherErrorValue;
+    private updatePrevOtherErrorValue;
     get otherValue(): string;
     set otherValue(val: string);
     protected get otherValueCore(): string;

package/typings/question_boolean.d.ts

@@ -96,6 +96,8 @@ export declare class QuestionBooleanModel extends Question {
     getItemCss(): string;
     getCheckboxItemCss(): string;
     getLabelCss(checked: boolean): string;
+    updateValueFromSurvey(newValue: any, clearData?: boolean): void;
+    protected onValueChanged(): void;
     get svgIcon(): string;
     get itemSvgIcon(): string;
     get allowClick(): boolean;

package/typings/question_file.d.ts

@@ -263,8 +263,9 @@ export declare class QuestionFileModel extends QuestionFileModelBase {
     doChange: (event: any) => void;
     doClean: () => void;
     private clearFilesCore;
-    doRemoveFile(data: any): void;
+    doRemoveFile(data: any, event: any): void;
     private removeFileCore;
+    doDownloadFileFromContainer: (event: MouseEvent) => void;
     doDownloadFile: (event: any, data: any) => void;
     dispose(): void;
 }

package/typings/question_matrix.d.ts

@@ -12,6 +12,8 @@ export interface IMatrixData {
     cssClasses: any;
     isDisabledStyle: boolean;
     isInputReadOnly: boolean;
+    isDisabledAttr: boolean;
+    isReadOnlyAttr: boolean;
     hasErrorInRow(row: MatrixRowModel): boolean;
 }
 export declare class MatrixRowModel extends Base {
@@ -27,6 +29,8 @@ export declare class MatrixRowModel extends Base {
     set value(val: any);
     setValueDirectly(val: any): void;
     get isReadOnly(): boolean;
+    get isReadOnlyAttr(): boolean;
+    get isDisabledAttr(): boolean;
     get rowTextClasses(): string;
     get hasError(): boolean;
     set hasError(val: boolean);

package/typings/question_matrixdropdown.d.ts

@@ -41,6 +41,9 @@ export declare class QuestionMatrixDropdownModel extends QuestionMatrixDropdownM
     protected isNewValueCorrect(val: any): boolean;
     clearIncorrectValues(): void;
     protected clearValueIfInvisibleCore(reason: string): void;
+    private defaultValuesInRows;
+    protected clearGeneratedRows(): void;
+    private getRowValueForCreation;
     protected generateRows(): Array<MatrixDropdownRowModel>;
     protected createMatrixRow(item: ItemValue, value: any): MatrixDropdownRowModel;
     protected getSearchableItemValueKeys(keys: Array<string>): void;