@beetag/antd 4.24.16

package/es/upload/style/rtl.less

@@ -0,0 +1,165 @@
+@import '../../style/themes/index';
+@import '../../style/mixins/index';
+
+@upload-prefix-cls: ~'@{ant-prefix}-upload';
+@upload-item: ~'@{ant-prefix}-upload-list-item';
+
+.@{upload-prefix-cls} {
+  &-rtl {
+    direction: rtl;
+  }
+
+  &&-select-picture-card {
+    .@{upload-prefix-cls}-rtl& {
+      margin-right: auto;
+      margin-left: 8px;
+    }
+  }
+}
+
+.@{upload-prefix-cls}-list {
+  &-rtl {
+    direction: rtl;
+  }
+
+  &-item-list-type-text {
+    &:hover {
+      .@{upload-prefix-cls}-list-item-name-icon-count-1 {
+        .@{upload-prefix-cls}-list-rtl & {
+          padding-right: 22px;
+          padding-left: 14px;
+        }
+      }
+      .@{upload-prefix-cls}-list-item-name-icon-count-2 {
+        .@{upload-prefix-cls}-list-rtl & {
+          padding-right: 22px;
+          padding-left: 28px;
+        }
+      }
+    }
+  }
+
+  &-item {
+    &-name {
+      .@{upload-prefix-cls}-list-rtl & {
+        padding-right: @font-size-base + 8px;
+        padding-left: 0;
+      }
+    }
+
+    &-name-icon-count-1 {
+      .@{upload-prefix-cls}-list-rtl & {
+        padding-left: 14px;
+      }
+    }
+
+    &-card-actions {
+      .@{upload-prefix-cls}-list-rtl & {
+        right: auto;
+        left: 0;
+      }
+      .@{iconfont-css-prefix} {
+        .@{upload-prefix-cls}-list-rtl & {
+          padding-right: 0;
+          padding-left: 5px;
+        }
+      }
+    }
+
+    &-info {
+      .@{upload-prefix-cls}-list-rtl & {
+        padding: 0 4px 0 12px;
+      }
+    }
+
+    &-error &-card-actions {
+      .@{iconfont-css-prefix} {
+        .@{upload-prefix-cls}-list-rtl & {
+          padding-right: 0;
+          padding-left: 5px;
+        }
+      }
+    }
+
+    &-progress {
+      .@{upload-prefix-cls}-list-rtl & {
+        padding-right: @font-size-base + 12px;
+        padding-left: 0;
+      }
+    }
+  }
+
+  &-picture,
+  &-picture-card {
+    .@{upload-item}-info {
+      padding: 0;
+    }
+
+    .@{upload-item}-thumbnail {
+      .@{upload-prefix-cls}-list-rtl& {
+        right: 8px;
+        left: auto;
+      }
+    }
+
+    .@{upload-item}-icon {
+      .@{upload-prefix-cls}-list-rtl& {
+        right: 50%;
+        left: auto;
+        transform: translate(50%, -50%);
+      }
+    }
+
+    .@{upload-item}-name {
+      .@{upload-prefix-cls}-list-rtl& {
+        margin: 0 8px 0 0;
+        padding-right: 48px;
+        padding-left: 8px;
+      }
+    }
+
+    .@{upload-item}-name-icon-count-1 {
+      .@{upload-prefix-cls}-list-rtl& {
+        padding-right: 48px;
+        padding-left: 18px;
+      }
+    }
+
+    .@{upload-item}-name-icon-count-2 {
+      .@{upload-prefix-cls}-list-rtl& {
+        padding-right: 48px;
+        padding-left: 36px;
+      }
+    }
+
+    .@{upload-item}-progress {
+      .@{upload-prefix-cls}-list-rtl& {
+        padding-right: 0;
+        padding-left: 0;
+      }
+    }
+  }
+
+  &-picture-card {
+    &-container {
+      .@{upload-prefix-cls}-list-rtl & {
+        margin: 0 0 @margin-xs @margin-xs;
+      }
+    }
+
+    .@{upload-item}-actions {
+      .@{upload-prefix-cls}-list-rtl& {
+        right: 50%;
+        left: auto;
+        transform: translate(50%, -50%);
+      }
+    }
+
+    .@{upload-item}-file + .@{upload-item}-name {
+      .@{upload-prefix-cls}-list-rtl& {
+        margin: 8px 0 0;
+        padding: 0;
+      }
+    }
+  }
+}

package/es/upload/utils.d.ts

@@ -0,0 +1,8 @@
+import type { InternalUploadFile, RcFile, UploadFile } from './interface';
+export declare function file2Obj(file: RcFile): InternalUploadFile;
+/** Upload fileList. Replace file if exist or just push into it. */
+export declare function updateFileList(file: UploadFile<any>, fileList: UploadFile<any>[]): UploadFile<any>[];
+export declare function getFileItem(file: RcFile, fileList: UploadFile[]): UploadFile<any>;
+export declare function removeFileItem(file: UploadFile, fileList: UploadFile[]): UploadFile<any>[] | null;
+export declare const isImageUrl: (file: UploadFile) => boolean;
+export declare function previewImage(file: File | Blob): Promise<string>;

package/es/upload/utils.js

@@ -0,0 +1,126 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+export function file2Obj(file) {
+  return _extends(_extends({}, file), {
+    lastModified: file.lastModified,
+    lastModifiedDate: file.lastModifiedDate,
+    name: file.name,
+    size: file.size,
+    type: file.type,
+    uid: file.uid,
+    percent: 0,
+    originFileObj: file
+  });
+}
+/** Upload fileList. Replace file if exist or just push into it. */
+export function updateFileList(file, fileList) {
+  var nextFileList = _toConsumableArray(fileList);
+  var fileIndex = nextFileList.findIndex(function (_ref) {
+    var uid = _ref.uid;
+    return uid === file.uid;
+  });
+  if (fileIndex === -1) {
+    nextFileList.push(file);
+  } else {
+    nextFileList[fileIndex] = file;
+  }
+  return nextFileList;
+}
+export function getFileItem(file, fileList) {
+  var matchKey = file.uid !== undefined ? 'uid' : 'name';
+  return fileList.filter(function (item) {
+    return item[matchKey] === file[matchKey];
+  })[0];
+}
+export function removeFileItem(file, fileList) {
+  var matchKey = file.uid !== undefined ? 'uid' : 'name';
+  var removed = fileList.filter(function (item) {
+    return item[matchKey] !== file[matchKey];
+  });
+  if (removed.length === fileList.length) {
+    return null;
+  }
+  return removed;
+}
+// ==================== Default Image Preview ====================
+var extname = function extname() {
+  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var temp = url.split('/');
+  var filename = temp[temp.length - 1];
+  var filenameWithoutSuffix = filename.split(/#|\?/)[0];
+  return (/\.[^./\\]*$/.exec(filenameWithoutSuffix) || [''])[0];
+};
+var isImageFileType = function isImageFileType(type) {
+  return type.indexOf('image/') === 0;
+};
+export var isImageUrl = function isImageUrl(file) {
+  if (file.type && !file.thumbUrl) {
+    return isImageFileType(file.type);
+  }
+  var url = file.thumbUrl || file.url || '';
+  var extension = extname(url);
+  if (/^data:image\//.test(url) || /(webp|svg|png|gif|jpg|jpeg|jfif|bmp|dpg|ico|heic|heif)$/i.test(extension)) {
+    return true;
+  }
+  if (/^data:/.test(url)) {
+    // other file types of base64
+    return false;
+  }
+  if (extension) {
+    // other file types which have extension
+    return false;
+  }
+  return true;
+};
+var MEASURE_SIZE = 200;
+export function previewImage(file) {
+  return new Promise(function (resolve) {
+    if (!file.type || !isImageFileType(file.type)) {
+      resolve('');
+      return;
+    }
+    var canvas = document.createElement('canvas');
+    canvas.width = MEASURE_SIZE;
+    canvas.height = MEASURE_SIZE;
+    canvas.style.cssText = "position: fixed; left: 0; top: 0; width: ".concat(MEASURE_SIZE, "px; height: ").concat(MEASURE_SIZE, "px; z-index: 9999; display: none;");
+    document.body.appendChild(canvas);
+    var ctx = canvas.getContext('2d');
+    var img = new Image();
+    img.onload = function () {
+      var width = img.width,
+        height = img.height;
+      var drawWidth = MEASURE_SIZE;
+      var drawHeight = MEASURE_SIZE;
+      var offsetX = 0;
+      var offsetY = 0;
+      if (width > height) {
+        drawHeight = height * (MEASURE_SIZE / width);
+        offsetY = -(drawHeight - drawWidth) / 2;
+      } else {
+        drawWidth = width * (MEASURE_SIZE / height);
+        offsetX = -(drawWidth - drawHeight) / 2;
+      }
+      ctx.drawImage(img, offsetX, offsetY, drawWidth, drawHeight);
+      var dataURL = canvas.toDataURL();
+      document.body.removeChild(canvas);
+      window.URL.revokeObjectURL(img.src);
+      resolve(dataURL);
+    };
+    img.crossOrigin = 'anonymous';
+    if (file.type.startsWith('image/svg+xml')) {
+      var reader = new FileReader();
+      reader.onload = function () {
+        if (reader.result) img.src = reader.result;
+      };
+      reader.readAsDataURL(file);
+    } else if (file.type.startsWith('image/gif')) {
+      var _reader = new FileReader();
+      _reader.onload = function () {
+        if (_reader.result) resolve(_reader.result);
+      };
+      _reader.readAsDataURL(file);
+    } else {
+      img.src = window.URL.createObjectURL(file);
+    }
+  });
+}

package/es/version/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "4.24.16";
+export default _default;

package/es/version/index.js

@@ -0,0 +1 @@
+export default '4.24.16';

package/es/version/style/css.js

@@ -0,0 +1,2 @@
+// empty file prevent babel-plugin-import error
+import '../../style/default.css';

package/es/version/style/index.d.ts

@@ -0,0 +1 @@
+import '../../style/default.less';

package/es/version/style/index.js

@@ -0,0 +1,2 @@
+// empty file prevent babel-plugin-import error
+import '../../style/default.less';

package/lib/_util/ActionButton.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import type { ButtonProps, LegacyButtonType } from '../button/button';
+export interface ActionButtonProps {
+    type?: LegacyButtonType;
+    actionFn?: (...args: any[]) => any | PromiseLike<any>;
+    close?: Function;
+    autoFocus?: boolean;
+    prefixCls: string;
+    buttonProps?: ButtonProps;
+    emitEvent?: boolean;
+    quitOnNullishReturnValue?: boolean;
+    children?: React.ReactNode;
+}
+declare const ActionButton: React.FC<ActionButtonProps>;
+export default ActionButton;

package/lib/_util/ActionButton.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useState3 = _interopRequireDefault(require("rc-util/lib/hooks/useState"));
+var React = _interopRequireWildcard(require("react"));
+var _button = _interopRequireDefault(require("../button"));
+var _button2 = require("../button/button");
+function isThenable(thing) {
+  return !!(thing && !!thing.then);
+}
+var ActionButton = function ActionButton(props) {
+  var clickedRef = React.useRef(false);
+  var ref = React.useRef(null);
+  var _useState = (0, _useState3["default"])(false),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var close = props.close;
+  var onInternalClose = function onInternalClose() {
+    close === null || close === void 0 ? void 0 : close.apply(void 0, arguments);
+  };
+  React.useEffect(function () {
+    var timeoutId = null;
+    if (props.autoFocus) {
+      timeoutId = setTimeout(function () {
+        var _a;
+        (_a = ref.current) === null || _a === void 0 ? void 0 : _a.focus();
+      });
+    }
+    return function () {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
+  }, []);
+  var handlePromiseOnOk = function handlePromiseOnOk(returnValueOfOnOk) {
+    if (!isThenable(returnValueOfOnOk)) {
+      return;
+    }
+    setLoading(true);
+    returnValueOfOnOk.then(function () {
+      setLoading(false, true);
+      onInternalClose.apply(void 0, arguments);
+      clickedRef.current = false;
+    }, function (e) {
+      // See: https://github.com/ant-design/ant-design/issues/6183
+      setLoading(false, true);
+      clickedRef.current = false;
+      return Promise.reject(e);
+    });
+  };
+  var onClick = function onClick(e) {
+    var actionFn = props.actionFn;
+    if (clickedRef.current) {
+      return;
+    }
+    clickedRef.current = true;
+    if (!actionFn) {
+      onInternalClose();
+      return;
+    }
+    var returnValueOfOnOk;
+    if (props.emitEvent) {
+      returnValueOfOnOk = actionFn(e);
+      if (props.quitOnNullishReturnValue && !isThenable(returnValueOfOnOk)) {
+        clickedRef.current = false;
+        onInternalClose(e);
+        return;
+      }
+    } else if (actionFn.length) {
+      returnValueOfOnOk = actionFn(close);
+      // https://github.com/ant-design/ant-design/issues/23358
+      clickedRef.current = false;
+    } else {
+      returnValueOfOnOk = actionFn();
+      if (!returnValueOfOnOk) {
+        onInternalClose();
+        return;
+      }
+    }
+    handlePromiseOnOk(returnValueOfOnOk);
+  };
+  var type = props.type,
+    children = props.children,
+    prefixCls = props.prefixCls,
+    buttonProps = props.buttonProps;
+  return /*#__PURE__*/React.createElement(_button["default"], (0, _extends2["default"])({}, (0, _button2.convertLegacyProps)(type), {
+    onClick: onClick,
+    loading: loading,
+    prefixCls: prefixCls
+  }, buttonProps, {
+    ref: ref
+  }), children);
+};
+var _default = exports["default"] = ActionButton;

package/lib/_util/colors.d.ts

@@ -0,0 +1,5 @@
+import type { ElementOf } from './type';
+export declare const PresetStatusColorTypes: ["success", "processing", "error", "default", "warning"];
+export declare const PresetColorTypes: ["pink", "red", "yellow", "orange", "cyan", "green", "blue", "purple", "geekblue", "magenta", "volcano", "gold", "lime"];
+export type PresetColorType = ElementOf<typeof PresetColorTypes>;
+export type PresetStatusColorType = ElementOf<typeof PresetStatusColorTypes>;

package/lib/_util/colors.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PresetStatusColorTypes = exports.PresetColorTypes = void 0;
+var _type = require("./type");
+var PresetStatusColorTypes = exports.PresetStatusColorTypes = (0, _type.tuple)('success', 'processing', 'error', 'default', 'warning');
+// eslint-disable-next-line import/prefer-default-export
+var PresetColorTypes = exports.PresetColorTypes = (0, _type.tuple)('pink', 'red', 'yellow', 'orange', 'cyan', 'green', 'blue', 'purple', 'geekblue', 'magenta', 'volcano', 'gold', 'lime');

package/lib/_util/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/lib/_util/easings.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.easeInOutCubic = easeInOutCubic;
+// eslint-disable-next-line import/prefer-default-export
+function easeInOutCubic(t, b, c, d) {
+  var cc = c - b;
+  t /= d / 2;
+  if (t < 1) {
+    return cc / 2 * t * t * t + b;
+  }
+  // eslint-disable-next-line no-return-assign
+  return cc / 2 * ((t -= 2) * t * t + 2) + b;
+}

package/lib/_util/getDataOrAriaProps.d.ts

@@ -0,0 +1 @@
+export default function getDataOrAriaProps(props: any): any;

package/lib/_util/getDataOrAriaProps.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getDataOrAriaProps;
+function getDataOrAriaProps(props) {
+  return Object.keys(props).reduce(function (prev, key) {
+    if ((key.startsWith('data-') || key.startsWith('aria-') || key === 'role') && !key.startsWith('data-__')) {
+      prev[key] = props[key];
+    }
+    return prev;
+  }, {});
+}

package/lib/_util/getRenderPropValue.d.ts

@@ -0,0 +1,3 @@
+import type * as React from 'react';
+export type RenderFunction = () => React.ReactNode;
+export declare const getRenderPropValue: (propValue?: React.ReactNode | RenderFunction) => React.ReactNode;

package/lib/_util/getRenderPropValue.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRenderPropValue = void 0;
+var getRenderPropValue = exports.getRenderPropValue = function getRenderPropValue(propValue) {
+  if (!propValue) {
+    return null;
+  }
+  if (typeof propValue === 'function') {
+    return propValue();
+  }
+  return propValue;
+};

package/lib/_util/getScroll.d.ts

@@ -0,0 +1,2 @@
+export declare function isWindow(obj: any): obj is Window;
+export default function getScroll(target: HTMLElement | Window | Document | null, top: boolean): number;

package/lib/_util/getScroll.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = getScroll;
+exports.isWindow = isWindow;
+function isWindow(obj) {
+  return obj !== null && obj !== undefined && obj === obj.window;
+}
+function getScroll(target, top) {
+  var _a, _b;
+  if (typeof window === 'undefined') {
+    return 0;
+  }
+  var method = top ? 'scrollTop' : 'scrollLeft';
+  var result = 0;
+  if (isWindow(target)) {
+    result = target[top ? 'pageYOffset' : 'pageXOffset'];
+  } else if (target instanceof Document) {
+    result = target.documentElement[method];
+  } else if (target instanceof HTMLElement) {
+    result = target[method];
+  } else if (target) {
+    // According to the type inference, the `target` is `never` type.
+    // Since we configured the loose mode type checking, and supports mocking the target with such shape below::
+    //    `{ documentElement: { scrollLeft: 200, scrollTop: 400 } }`,
+    //    the program may falls into this branch.
+    // Check the corresponding tests for details. Don't sure what is the real scenario this happens.
+    result = target[method];
+  }
+  if (target && !isWindow(target) && typeof result !== 'number') {
+    result = (_b = ((_a = target.ownerDocument) !== null && _a !== void 0 ? _a : target).documentElement) === null || _b === void 0 ? void 0 : _b[method];
+  }
+  return result;
+}

package/lib/_util/hooks/useFlexGapSupport.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/lib/_util/hooks/useFlexGapSupport.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+var _styleChecker = require("../styleChecker");
+var _default = exports["default"] = function _default() {
+  var _React$useState = React.useState(false),
+    _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+    flexible = _React$useState2[0],
+    setFlexible = _React$useState2[1];
+  React.useEffect(function () {
+    setFlexible((0, _styleChecker.detectFlexGapSupported)());
+  }, []);
+  return flexible;
+};

package/lib/_util/hooks/useForceUpdate.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useForceUpdate(): React.DispatchWithoutAction;

package/lib/_util/hooks/useForceUpdate.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useForceUpdate;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+function useForceUpdate() {
+  var _React$useReducer = React.useReducer(function (x) {
+      return x + 1;
+    }, 0),
+    _React$useReducer2 = (0, _slicedToArray2["default"])(_React$useReducer, 2),
+    forceUpdate = _React$useReducer2[1];
+  return forceUpdate;
+}

package/lib/_util/hooks/usePatchElement.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export default function usePatchElement(): [
+    React.ReactElement[],
+    (element: React.ReactElement) => Function
+];

package/lib/_util/hooks/usePatchElement.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = usePatchElement;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var React = _interopRequireWildcard(require("react"));
+function usePatchElement() {
+  var _React$useState = React.useState([]),
+    _React$useState2 = (0, _slicedToArray2["default"])(_React$useState, 2),
+    elements = _React$useState2[0],
+    setElements = _React$useState2[1];
+  var patchElement = React.useCallback(function (element) {
+    // append a new element to elements (and create a new ref)
+    setElements(function (originElements) {
+      return [].concat((0, _toConsumableArray2["default"])(originElements), [element]);
+    });
+    // return a function that removes the new element out of elements (and create a new ref)
+    // it works a little like useEffect
+    return function () {
+      setElements(function (originElements) {
+        return originElements.filter(function (ele) {
+          return ele !== element;
+        });
+      });
+    };
+  }, []);
+  return [elements, patchElement];
+}

package/lib/_util/hooks/useSyncState.d.ts

@@ -0,0 +1,3 @@
+type UseSyncStateProps<T> = readonly [() => T, (newValue: T) => void];
+export default function useSyncState<T>(initialValue: T): UseSyncStateProps<T>;
+export {};

package/lib/_util/hooks/useSyncState.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = useSyncState;
+var React = _interopRequireWildcard(require("react"));
+var _useForceUpdate = _interopRequireDefault(require("./useForceUpdate"));
+function useSyncState(initialValue) {
+  var ref = React.useRef(initialValue);
+  var forceUpdate = (0, _useForceUpdate["default"])();
+  return [function () {
+    return ref.current;
+  }, function (newValue) {
+    ref.current = newValue;
+    // re-render
+    forceUpdate();
+  }];
+}