survey-core 1.9.135 → 1.9.137

package/typings/survey-element.d.ts

@@ -324,7 +324,7 @@ export declare class SurveyElement<E = any> extends SurveyElementCore implements
     protected setPage(parent: IPanel, newPage: IPage): void;
     protected getSearchableLocKeys(keys: Array<string>): void;
     get isDefaultV2Theme(): boolean;
-    get hasParent(): any;
+    get hasParent(): boolean;
     isSingleInRow: boolean;
     private shouldAddRunnerStyles;
     protected get isCompact(): boolean;
@@ -399,5 +399,19 @@ export declare class SurveyElement<E = any> extends SurveyElementCore implements
     protected getAdditionalTitleToolbar(): ActionContainer | null;
     protected getCssTitle(cssClasses: any): string;
     localeChanged(): void;
+    private wrapperElement?;
+    setWrapperElement(element?: HTMLElement): void;
+    getWrapperElement(): HTMLElement;
+    private _renderedIsExpanded;
+    private _isAnimatingCollapseExpand;
+    private set isAnimatingCollapseExpand(value);
+    private get isAnimatingCollapseExpand();
+    private getExpandCollapseAnimationOptions;
+    private animationCollapsed;
+    set renderedIsExpanded(val: boolean);
+    get renderedIsExpanded(): boolean;
+    private animationAllowedValue;
+    get animationAllowed(): boolean;
+    set animationAllowed(val: boolean);
     dispose(): void;
 }

package/typings/utils/animation.d.ts

@@ -0,0 +1,50 @@
+export interface AnimationOptions {
+    cssClass: string;
+    onBeforeRunAnimation?: (element: HTMLElement) => void;
+    onAfterRunAnimation?: (element: HTMLElement) => void;
+}
+export interface IAnimationConsumer<T extends Array<any> = []> {
+    getLeaveOptions(...args: T): AnimationOptions;
+    getEnterOptions(...args: T): AnimationOptions;
+    getAnimatedElement(...args: T): HTMLElement;
+    isAnimationEnabled(): boolean;
+}
+export declare class AnimationUtils {
+    private getMsFromRule;
+    private getAnimationsCount;
+    private getAnimationDuration;
+    private cancelQueue;
+    protected onAnimationEnd(element: HTMLElement, callback: (isCancel?: boolean) => void, options: AnimationOptions): void;
+    protected beforeAnimationRun(element: HTMLElement, options: AnimationOptions | AnimationOptions): void;
+    protected runLeaveAnimation(element: HTMLElement, options: AnimationOptions, callback: () => void): void;
+    protected runEnterAnimation(element: HTMLElement, options: AnimationOptions): void;
+    cancel(): void;
+}
+export declare class AnimationPropertyUtils extends AnimationUtils {
+    onEnter(getElement: () => HTMLElement, options: AnimationOptions): void;
+    onLeave(getElement: () => HTMLElement, callback: () => void, options: AnimationOptions): void;
+}
+export declare class AnimationGroupUtils<T> extends AnimationUtils {
+    onEnter(getElement: (el: T) => HTMLElement, getOptions: (el: T) => AnimationOptions, elements: Array<T>): void;
+    onLeave(getElement: (el: T) => HTMLElement, callback: () => void, getOptions: (el: T) => AnimationOptions, elements: Array<T>): void;
+}
+declare abstract class AnimationProperty<T, S extends Array<any> = []> {
+    protected animationOptions: IAnimationConsumer<S>;
+    protected update: (val: T) => void;
+    protected getCurrentValue: () => T;
+    constructor(animationOptions: IAnimationConsumer<S>, update: (val: T) => void, getCurrentValue: () => T);
+    protected animation: AnimationUtils;
+    protected abstract _sync(newValue: T): void;
+    private _debouncedSync;
+    sync(newValue: T): void;
+    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]> {
+    protected animation: AnimationGroupUtils<T>;
+    protected _sync(newValue: Array<T>): void;
+}
+export {};

package/typings/utils/taskmanager.d.ts

@@ -0,0 +1,28 @@
+export interface IExecutable {
+    id?: string;
+    execute: () => void;
+    isCompleted: boolean;
+    dispose?: () => void;
+}
+export declare class Task implements IExecutable {
+    private func;
+    private isMultiple;
+    private _isCompleted;
+    constructor(func: () => void, isMultiple?: boolean);
+    execute: () => void;
+    discard(): void;
+    get isCompleted(): boolean;
+}
+export declare class TaskManger {
+    private interval;
+    private static instance;
+    private static tasks;
+    private constructor();
+    static Instance(): TaskManger;
+    private tick;
+    static schedule(task: IExecutable): void;
+}
+export declare function debounce<T extends (...args: any) => void>(func: T): {
+    run: T;
+    cancel: () => void;
+};