@syncfusion/ej2-base 19.2.57 → 19.3.53

package/src/ajax.js

@@ -17,19 +17,22 @@ var defaultType = 'GET';
 var Ajax = /** @class */ (function () {
     /**
      * Constructor for Ajax class
-     * @param  {string|Object} options?
-     * @param  {string} type?
-     * @param  {boolean} async?
-     * @returns defaultType
+     *
+     * @param  {string|Object} options ?
+     * @param  {string} type ?
+     * @param  {boolean} async ?
+     * @returns defaultType any
      */
     function Ajax(options, type, async, contentType) {
         /**
          * A boolean value indicating whether the request should be sent asynchronous or not.
+         *
          * @default true
          */
         this.mode = true;
         /**
          * A boolean value indicating whether to ignore the promise reject.
+         *
          * @private
          * @default true
          */
@@ -48,9 +51,11 @@ var Ajax = /** @class */ (function () {
         this.contentType = (this.contentType !== undefined) ? this.contentType : contentType;
     }
     /**
+     *
      * Send the request to server.
+     *
      * @param {any} data - To send the user data
-     * @return {Promise}
+     * @return {Promise} ?
      */
     Ajax.prototype.send = function (data) {
         var _this = this;
@@ -140,18 +145,21 @@ var Ajax = /** @class */ (function () {
     };
     /**
      * To get the response header from XMLHttpRequest
+     *
      * @param  {string} key Key to search in the response header
-     * @returns {string}
+     * @returns {string} ?
      */
     Ajax.prototype.getResponseHeader = function (key) {
         var responseHeaders;
         var header;
+        // eslint-disable-next-line
         responseHeaders = {};
         var headers = headerRegex.exec(this.httpRequest.getAllResponseHeaders());
         while (headers) {
             responseHeaders[headers[1].toLowerCase()] = headers[2];
             headers = headerRegex.exec(this.httpRequest.getAllResponseHeaders());
         }
+        // eslint-disable-next-line
         header = responseHeaders[key.toLowerCase()];
         return isNullOrUndefined(header) ? null : header;
     };

package/src/animation-model.d.ts

@@ -8,49 +8,57 @@ export interface AnimationModel {
 
     /**
      * Specify the type of animation
+     *
      * @default : 'FadeIn';
      */
     name?: Effect;
 
     /**
      * Specify the duration to animate
+     *
      * @default : 400;
      */
     duration?: number;
 
     /**
      * Specify the animation timing function
+     *
      * @default : 'ease';
      */
     timingFunction?: string;
 
     /**
      * Specify the delay to start animation
+     *
      * @default : 0;
      */
     delay?: number;
 
     /**
      * Triggers when animation is in-progress
-     * @event
+     *
+     * @event progress
      */
     progress?: EmitType<AnimationOptions>;
 
     /**
      * Triggers when the animation is started
-     * @event
+     *
+     * @event begin
      */
     begin?: EmitType<AnimationOptions>;
 
     /**
      * Triggers when animation is completed
-     * @event
+     *
+     * @event end
      */
     end?: EmitType<AnimationOptions>;
 
     /**
      * Triggers when animation is failed due to any scripts
-     * @event
+     *
+     * @event fail
      */
     fail?: EmitType<AnimationOptions>;
 

package/src/animation.d.ts

@@ -19,42 +19,50 @@ export declare type Effect = 'FadeIn' | 'FadeOut' | 'FadeZoomIn' | 'FadeZoomOut'
 export declare class Animation extends Base<HTMLElement> implements INotifyPropertyChanged {
     /**
      * Specify the type of animation
+     *
      * @default : 'FadeIn';
      */
     name: Effect;
     /**
      * Specify the duration to animate
+     *
      * @default : 400;
      */
     duration: number;
     /**
      * Specify the animation timing function
+     *
      * @default : 'ease';
      */
     timingFunction: string;
     /**
      * Specify the delay to start animation
+     *
      * @default : 0;
      */
     delay: number;
     /**
      * Triggers when animation is in-progress
-     * @event
+     *
+     * @event progress
      */
     progress: EmitType<AnimationOptions>;
     /**
      * Triggers when the animation is started
-     * @event
+     *
+     * @event begin
      */
     begin: EmitType<AnimationOptions>;
     /**
      * Triggers when animation is completed
-     * @event
+     *
+     * @event end
      */
     end: EmitType<AnimationOptions>;
     /**
      * Triggers when animation is failed due to any scripts
-     * @event
+     *
+     * @event fail
      */
     fail: EmitType<AnimationOptions>;
     /**
@@ -66,13 +74,15 @@ export declare class Animation extends Base<HTMLElement> implements INotifyPrope
     constructor(options: AnimationModel);
     /**
      * Applies animation to the current element.
+     *
      * @param {string | HTMLElement} element - Element which needs to be animated.
      * @param {AnimationModel} options - Overriding default animation settings.
-     * @return {void}
+     * @returns {void} ?
      */
     animate(element: string | HTMLElement, options?: AnimationModel): void;
     /**
      * Stop the animation effect on animated element.
+     *
      * @param {HTMLElement} element - Element which needs to be stop the animation.
      * @param {AnimationOptions} model - Handling the animation model at stop function.
      * @return {void}
@@ -80,33 +90,43 @@ export declare class Animation extends Base<HTMLElement> implements INotifyPrope
     static stop(element: HTMLElement, model?: AnimationOptions): void;
     /**
      * Set delay to animation element
-     * @param {AnimationModel} model
+     *
+     * @param {AnimationModel} model ?
      * @returns {void}
      */
     private static delayAnimation;
     /**
      * Triggers animation
-     * @param {AnimationModel} model
+     *
+     * @param {AnimationModel} model ?
      * @returns {void}
      */
     private static applyAnimation;
     /**
      * Returns Animation Model
-     * @param {AnimationModel} options
-     * @returns {AnimationModel}
+     *
+     * @param {AnimationModel} options ?
+     * @returns {AnimationModel} ?
      */
     private getModel;
     /**
      * @private
+     * @param {AnimationModel} newProp ?
+     * @param {AnimationModel} oldProp ?
+     * @returns {void} ?
      */
     onPropertyChanged(newProp: AnimationModel, oldProp: AnimationModel): void;
     /**
      * Returns module name as animation
+     *
      * @private
+     * @returns {void} ?
      */
     getModuleName(): string;
     /**
+     *
      * @private
+     * @returns {void} ?
      */
     destroy(): void;
 }
@@ -131,13 +151,17 @@ export interface AnimationOptions extends AnimationModel {
  *   rippleEffect(document.getElementById('ripple'));
  * </script>
  * ```
+ *
  * @private
- * @param HTMLElement element - Target element
- * @param RippleOptions rippleOptions - Ripple options .
+ * @param {HTMLElement} element - Target element
+ * @param {RippleOptions} rippleOptions - Ripple options .
+ * @param {Function} done .
+ * @returns {void} .
  */
 export declare function rippleEffect(element: HTMLElement, rippleOptions?: RippleOptions, done?: Function): () => void;
 /**
  * Ripple method arguments to handle ripple effect
+ *
  * @private
  */
 export interface RippleOptions {
@@ -165,7 +189,8 @@ export interface RippleOptions {
 export declare let isRippleEnabled: boolean;
 /**
  * Animation Module provides support to enable ripple effect functionality to Essential JS 2 components.
+ *
  * @param {boolean} isRipple Specifies the boolean value to enable or disable ripple effect.
- * @returns {boolean}
+ * @returns {boolean} ?
  */
 export declare function enableRipple(isRipple: boolean): boolean;

package/src/animation.js

@@ -55,9 +55,10 @@ var Animation = /** @class */ (function (_super) {
     Animation_1 = Animation;
     /**
      * Applies animation to the current element.
+     *
      * @param {string | HTMLElement} element - Element which needs to be animated.
      * @param {AnimationModel} options - Overriding default animation settings.
-     * @return {void}
+     * @returns {void} ?
      */
     Animation.prototype.animate = function (element, options) {
         options = !options ? {} : options;
@@ -77,6 +78,7 @@ var Animation = /** @class */ (function (_super) {
     };
     /**
      * Stop the animation effect on animated element.
+     *
      * @param {HTMLElement} element - Element which needs to be stop the animation.
      * @param {AnimationOptions} model - Handling the animation model at stop function.
      * @return {void}
@@ -96,7 +98,8 @@ var Animation = /** @class */ (function (_super) {
     };
     /**
      * Set delay to animation element
-     * @param {AnimationModel} model
+     *
+     * @param {AnimationModel} model ?
      * @returns {void}
      */
     Animation.delayAnimation = function (model) {
@@ -109,7 +112,8 @@ var Animation = /** @class */ (function (_super) {
     };
     /**
      * Triggers animation
-     * @param {AnimationModel} model
+     *
+     * @param {AnimationModel} model ?
      * @returns {void}
      */
     Animation.applyAnimation = function (model) {
@@ -117,7 +121,6 @@ var Animation = /** @class */ (function (_super) {
         model.timeStamp = 0;
         var step = 0;
         var timerId = 0;
-        var startTime = 0;
         var prevTimeStamp = 0;
         var duration = model.duration;
         model.element.setAttribute('e-animate', 'true');
@@ -137,12 +140,12 @@ var Animation = /** @class */ (function (_super) {
                     step = step + 1;
                     var avg = model.timeStamp / step;
                     if (model.timeStamp < duration && model.timeStamp + avg < duration && model.element.getAttribute('e-animate')) {
-                        // apply animation effect to the current element                
+                        // apply animation effect to the current element
                         model.element.style.animation = model.name + ' ' + model.duration + 'ms ' + model.timingFunction;
                         if (model.progress) {
                             model.progress.call(_this, model);
                         }
-                        // repeat requestAnimationFrame 
+                        // repeat requestAnimationFrame
                         requestAnimationFrame(startAnimation);
                     }
                     else {
@@ -157,7 +160,7 @@ var Animation = /** @class */ (function (_super) {
                     }
                 }
                 else {
-                    startTime = performance.now();
+                    //startTime = performance.now();
                     // set initial requestAnimationFrame
                     timerId = requestAnimationFrame(startAnimation);
                     model.element.setAttribute('e-animation-id', timerId.toString());
@@ -175,8 +178,9 @@ var Animation = /** @class */ (function (_super) {
     };
     /**
      * Returns Animation Model
-     * @param {AnimationModel} options
-     * @returns {AnimationModel}
+     *
+     * @param {AnimationModel} options ?
+     * @returns {AnimationModel} ?
      */
     Animation.prototype.getModel = function (options) {
         return {
@@ -193,19 +197,27 @@ var Animation = /** @class */ (function (_super) {
     };
     /**
      * @private
+     * @param {AnimationModel} newProp ?
+     * @param {AnimationModel} oldProp ?
+     * @returns {void} ?
      */
+    // eslint-disable-next-line
     Animation.prototype.onPropertyChanged = function (newProp, oldProp) {
         // no code needed
     };
     /**
      * Returns module name as animation
+     *
      * @private
+     * @returns {void} ?
      */
     Animation.prototype.getModuleName = function () {
         return 'animation';
     };
     /**
+     *
      * @private
+     * @returns {void} ?
      */
     Animation.prototype.destroy = function () {
         //Override base destroy;
@@ -249,14 +261,17 @@ export { Animation };
  *   rippleEffect(document.getElementById('ripple'));
  * </script>
  * ```
+ *
  * @private
- * @param HTMLElement element - Target element
- * @param RippleOptions rippleOptions - Ripple options .
+ * @param {HTMLElement} element - Target element
+ * @param {RippleOptions} rippleOptions - Ripple options .
+ * @param {Function} done .
+ * @returns {void} .
  */
 export function rippleEffect(element, rippleOptions, done) {
     var rippleModel = getRippleModel(rippleOptions);
     if (rippleModel.rippleFlag === false || (rippleModel.rippleFlag === undefined && !isRippleEnabled)) {
-        return (function () { });
+        return Function;
     }
     element.setAttribute('data-ripple', 'true');
     EventHandler.add(element, 'mousedown', rippleHandler, { parent: element, rippleOptions: rippleModel });
@@ -273,6 +288,12 @@ export function rippleEffect(element, rippleOptions, done) {
         EventHandler.remove(element, 'transitionend', rippleLeaveHandler);
     });
 }
+/**
+ * Handler for ripple model
+ *
+ * @param {RippleOptions} rippleOptions ?
+ * @returns {RippleOptions} ?
+ */
 function getRippleModel(rippleOptions) {
     var rippleModel = {
         selector: rippleOptions && rippleOptions.selector ? rippleOptions.selector : null,
@@ -285,8 +306,9 @@ function getRippleModel(rippleOptions) {
 }
 /**
  * Handler for ripple event
- * @param {MouseEvent} e
- * @returns {void}
+ *
+ * @param {MouseEvent} e ?
+ * @returns {void} ?
  * @private
  */
 function rippleHandler(e) {
@@ -325,8 +347,9 @@ function rippleHandler(e) {
 }
 /**
  * Handler for ripple element mouse up event
- * @param {MouseEvent} e
- * @returns {void}
+ *
+ * @param {MouseEvent} e ?
+ * @returns {void} ?
  * @private
  */
 function rippleUpHandler(e) {
@@ -334,8 +357,9 @@ function rippleUpHandler(e) {
 }
 /**
  * Handler for ripple element mouse move event
- * @param {MouseEvent} e
- * @returns {void}
+ *
+ * @param {MouseEvent} e ?
+ * @returns {void} ?
  * @private
  */
 function rippleLeaveHandler(e) {
@@ -343,9 +367,10 @@ function rippleLeaveHandler(e) {
 }
 /**
  * Handler for removing ripple element
- * @param {MouseEvent} e
- * @param {rippleArgs} eventArgs
- * @returns {void}
+ *
+ * @param {MouseEvent} e ?
+ * @param {RippleArgs} eventArgs ?
+ * @returns {void} ?
  * @private
  */
 function removeRipple(e, eventArgs) {
@@ -380,8 +405,9 @@ function removeRipple(e, eventArgs) {
 export var isRippleEnabled = false;
 /**
  * Animation Module provides support to enable ripple effect functionality to Essential JS 2 components.
+ *
  * @param {boolean} isRipple Specifies the boolean value to enable or disable ripple effect.
- * @returns {boolean}
+ * @returns {boolean} ?
  */
 export function enableRipple(isRipple) {
     isRippleEnabled = isRipple;

package/src/base.d.ts

@@ -13,6 +13,7 @@ export interface BlazorDotnetObject {
 }
 /**
  * Base library module is common module for Framework modules like touch,keyboard and etc.,
+ *
  * @private
  */
 export declare abstract class Base<ElementType extends HTMLElement> {
@@ -47,21 +48,26 @@ export declare abstract class Base<ElementType extends HTMLElement> {
     /** Property base section */
     /**
      * Function used to set bunch of property at a time.
+     *
      * @private
      * @param  {Object} prop - JSON object which holds components properties.
-     * @param  {boolean} muteOnChange? - Specifies to true when we set properties.
+     * @param  {boolean} muteOnChange ? - Specifies to true when we set properties.
+     * @returns {void} ?
      */
     setProperties(prop: Object, muteOnChange?: boolean): void;
     /**
      * Calls for child element data bind
-     * @param {Object} obj
-     * @param {Object} parent
-     * @returns {void}
+     *
+     * @param {Object} obj ?
+     * @param {Object} parent ?
+     * @returns {void} ?
      */
     private static callChildDataBind;
     protected clearChanges(): void;
     /**
      * Bind property changes immediately to components
+     *
+     * @returns {void} ?
      */
     dataBind(): void;
     serverDataBind(newChanges?: {
@@ -71,50 +77,64 @@ export declare abstract class Base<ElementType extends HTMLElement> {
     /** Event Base Section */
     /**
      * Adds the handler to the given event listener.
+     *
      * @param {string} eventName - A String that specifies the name of the event
-     * @param {Function} listener - Specifies the call to run when the event occurs.
-     * @return {void}
+     * @param {Function} handler - Specifies the call to run when the event occurs.
+     * @returns {void} ?
      */
     addEventListener(eventName: string, handler: Function): void;
     /**
      * Removes the handler from the given event listener.
+     *
      * @param {string} eventName - A String that specifies the name of the event to remove
-     * @param {Function} listener - Specifies the function to remove
-     * @return {void}
+     * @param {Function} handler - Specifies the function to remove
+     * @returns {void} ?
      */
     removeEventListener(eventName: string, handler: Function): void;
     /**
      * Triggers the handlers in the specified event.
+     *
      * @private
      * @param {string} eventName - Specifies the event to trigger for the specified component properties.
      * Can be a custom event, or any of the standard events.
      * @param {Event} eventProp - Additional parameters to pass on to the event properties
      * @param {Function} successHandler - this function will invoke after event successfully triggered
      * @param {Function} errorHandler - this function will invoke after event if it failured to call.
-     * @return {void}
+     * @returns {void} ?
      */
     trigger(eventName: string, eventProp?: Object, successHandler?: Function, errorHandler?: Function): void | object;
     /**
      * Base constructor accept options and element
+     *
+     * @param {Object} options ?
+     * @param {string} element ?
      */
     constructor(options: Object, element: ElementType | string);
     /**
      * To maintain instance in base class
+     *
+     * @returns {void} ?
      */
     protected addInstance(): void;
     /**
      * To remove the instance from the element
+     *
+     * @returns {void} ?
      */
     protected destroy(): void;
 }
 /**
  * Global function to get the component instance from the rendered element.
- * @param elem Specifies the HTMLElement or element id string.
- * @param comp Specifies the component module name or Component.
+ *
+ * @param {HTMLElement} elem Specifies the HTMLElement or element id string.
+ * @param {string} comp Specifies the component module name or Component.
+ * @returns {any} ?
  */
 export declare function getComponent<T>(elem: HTMLElement | string, comp: string | any | T): T;
 /**
  * Function to remove the child instances.
+ *
+ * @param {HTMLElement} element ?
  * @return {void}
  * @private
  */