@angular/animations 13.0.0-next.0 → 13.0.0-next.12

package/esm2020/browser/src/render/shared.mjs

@@ -0,0 +1,221 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AUTO_STYLE, NoopAnimationPlayer, ɵAnimationGroupPlayer, ɵPRE_STYLE as PRE_STYLE } from '@angular/animations';
+export function isBrowser() {
+    return (typeof window !== 'undefined' && typeof window.document !== 'undefined');
+}
+export function isNode() {
+    // Checking only for `process` isn't enough to identify whether or not we're in a Node
+    // environment, because Webpack by default will polyfill the `process`. While we can discern
+    // that Webpack polyfilled it by looking at `process.browser`, it's very Webpack-specific and
+    // might not be future-proof. Instead we look at the stringified version of `process` which
+    // is `[object process]` in Node and `[object Object]` when polyfilled.
+    return typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+}
+export function optimizeGroupPlayer(players) {
+    switch (players.length) {
+        case 0:
+            return new NoopAnimationPlayer();
+        case 1:
+            return players[0];
+        default:
+            return new ɵAnimationGroupPlayer(players);
+    }
+}
+export function normalizeKeyframes(driver, normalizer, element, keyframes, preStyles = {}, postStyles = {}) {
+    const errors = [];
+    const normalizedKeyframes = [];
+    let previousOffset = -1;
+    let previousKeyframe = null;
+    keyframes.forEach(kf => {
+        const offset = kf['offset'];
+        const isSameOffset = offset == previousOffset;
+        const normalizedKeyframe = (isSameOffset && previousKeyframe) || {};
+        Object.keys(kf).forEach(prop => {
+            let normalizedProp = prop;
+            let normalizedValue = kf[prop];
+            if (prop !== 'offset') {
+                normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);
+                switch (normalizedValue) {
+                    case PRE_STYLE:
+                        normalizedValue = preStyles[prop];
+                        break;
+                    case AUTO_STYLE:
+                        normalizedValue = postStyles[prop];
+                        break;
+                    default:
+                        normalizedValue =
+                            normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);
+                        break;
+                }
+            }
+            normalizedKeyframe[normalizedProp] = normalizedValue;
+        });
+        if (!isSameOffset) {
+            normalizedKeyframes.push(normalizedKeyframe);
+        }
+        previousKeyframe = normalizedKeyframe;
+        previousOffset = offset;
+    });
+    if (errors.length) {
+        const LINE_START = '\n - ';
+        throw new Error(`Unable to animate due to the following errors:${LINE_START}${errors.join(LINE_START)}`);
+    }
+    return normalizedKeyframes;
+}
+export function listenOnPlayer(player, eventName, event, callback) {
+    switch (eventName) {
+        case 'start':
+            player.onStart(() => callback(event && copyAnimationEvent(event, 'start', player)));
+            break;
+        case 'done':
+            player.onDone(() => callback(event && copyAnimationEvent(event, 'done', player)));
+            break;
+        case 'destroy':
+            player.onDestroy(() => callback(event && copyAnimationEvent(event, 'destroy', player)));
+            break;
+    }
+}
+export function copyAnimationEvent(e, phaseName, player) {
+    const totalTime = player.totalTime;
+    const disabled = player.disabled ? true : false;
+    const event = makeAnimationEvent(e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName, totalTime == undefined ? e.totalTime : totalTime, disabled);
+    const data = e['_data'];
+    if (data != null) {
+        event['_data'] = data;
+    }
+    return event;
+}
+export function makeAnimationEvent(element, triggerName, fromState, toState, phaseName = '', totalTime = 0, disabled) {
+    return { element, triggerName, fromState, toState, phaseName, totalTime, disabled: !!disabled };
+}
+export function getOrSetAsInMap(map, key, defaultValue) {
+    let value;
+    if (map instanceof Map) {
+        value = map.get(key);
+        if (!value) {
+            map.set(key, value = defaultValue);
+        }
+    }
+    else {
+        value = map[key];
+        if (!value) {
+            value = map[key] = defaultValue;
+        }
+    }
+    return value;
+}
+export function parseTimelineCommand(command) {
+    const separatorPos = command.indexOf(':');
+    const id = command.substring(1, separatorPos);
+    const action = command.substr(separatorPos + 1);
+    return [id, action];
+}
+let _contains = (elm1, elm2) => false;
+let _matches = (element, selector) => false;
+let _query = (element, selector, multi) => {
+    return [];
+};
+// Define utility methods for browsers and platform-server(domino) where Element
+// and utility methods exist.
+const _isNode = isNode();
+if (_isNode || typeof Element !== 'undefined') {
+    if (!isBrowser()) {
+        _contains = (elm1, elm2) => elm1.contains(elm2);
+    }
+    else {
+        _contains = (elm1, elm2) => {
+            while (elm2 && elm2 !== document.documentElement) {
+                if (elm2 === elm1) {
+                    return true;
+                }
+                elm2 = elm2.parentNode || elm2.host; // consider host to support shadow DOM
+            }
+            return false;
+        };
+    }
+    _matches = (() => {
+        if (_isNode || Element.prototype.matches) {
+            return (element, selector) => element.matches(selector);
+        }
+        else {
+            const proto = Element.prototype;
+            const fn = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector ||
+                proto.oMatchesSelector || proto.webkitMatchesSelector;
+            if (fn) {
+                return (element, selector) => fn.apply(element, [selector]);
+            }
+            else {
+                return _matches;
+            }
+        }
+    })();
+    _query = (element, selector, multi) => {
+        let results = [];
+        if (multi) {
+            // DO NOT REFACTOR TO USE SPREAD SYNTAX.
+            // For element queries that return sufficiently large NodeList objects,
+            // using spread syntax to populate the results array causes a RangeError
+            // due to the call stack limit being reached. `Array.from` can not be used
+            // as well, since NodeList is not iterable in IE 11, see
+            // https://developer.mozilla.org/en-US/docs/Web/API/NodeList
+            // More info is available in #38551.
+            const elems = element.querySelectorAll(selector);
+            for (let i = 0; i < elems.length; i++) {
+                results.push(elems[i]);
+            }
+        }
+        else {
+            const elm = element.querySelector(selector);
+            if (elm) {
+                results.push(elm);
+            }
+        }
+        return results;
+    };
+}
+function containsVendorPrefix(prop) {
+    // Webkit is the only real popular vendor prefix nowadays
+    // cc: http://shouldiprefix.com/
+    return prop.substring(1, 6) == 'ebkit'; // webkit or Webkit
+}
+let _CACHED_BODY = null;
+let _IS_WEBKIT = false;
+export function validateStyleProperty(prop) {
+    if (!_CACHED_BODY) {
+        _CACHED_BODY = getBodyNode() || {};
+        _IS_WEBKIT = _CACHED_BODY.style ? ('WebkitAppearance' in _CACHED_BODY.style) : false;
+    }
+    let result = true;
+    if (_CACHED_BODY.style && !containsVendorPrefix(prop)) {
+        result = prop in _CACHED_BODY.style;
+        if (!result && _IS_WEBKIT) {
+            const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.substr(1);
+            result = camelProp in _CACHED_BODY.style;
+        }
+    }
+    return result;
+}
+export function getBodyNode() {
+    if (typeof document != 'undefined') {
+        return document.body;
+    }
+    return null;
+}
+export const matchesElement = _matches;
+export const containsElement = _contains;
+export const invokeQuery = _query;
+export function hypenatePropsObject(object) {
+    const newObj = {};
+    Object.keys(object).forEach(prop => {
+        const newProp = prop.replace(/([a-z])([A-Z])/g, '$1-$2');
+        newObj[newProp] = object[prop];
+    });
+    return newObj;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../../../../../../packages/animations/browser/src/render/shared.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {AnimationEvent, AnimationPlayer, AUTO_STYLE, NoopAnimationPlayer, ɵAnimationGroupPlayer, ɵPRE_STYLE as PRE_STYLE, ɵStyleData} from '@angular/animations';\n\nimport {AnimationStyleNormalizer} from '../../src/dsl/style_normalization/animation_style_normalizer';\nimport {AnimationDriver} from '../../src/render/animation_driver';\n\n// We don't include ambient node types here since @angular/animations/browser\n// is meant to target the browser so technically it should not depend on node\n// types. `process` is just declared locally here as a result.\ndeclare const process: any;\n\nexport function isBrowser(): boolean {\n  return (typeof window !== 'undefined' && typeof window.document !== 'undefined');\n}\n\nexport function isNode(): boolean {\n  // Checking only for `process` isn't enough to identify whether or not we're in a Node\n  // environment, because Webpack by default will polyfill the `process`. While we can discern\n  // that Webpack polyfilled it by looking at `process.browser`, it's very Webpack-specific and\n  // might not be future-proof. Instead we look at the stringified version of `process` which\n  // is `[object process]` in Node and `[object Object]` when polyfilled.\n  return typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';\n}\n\nexport function optimizeGroupPlayer(players: AnimationPlayer[]): AnimationPlayer {\n  switch (players.length) {\n    case 0:\n      return new NoopAnimationPlayer();\n    case 1:\n      return players[0];\n    default:\n      return new ɵAnimationGroupPlayer(players);\n  }\n}\n\nexport function normalizeKeyframes(\n    driver: AnimationDriver, normalizer: AnimationStyleNormalizer, element: any,\n    keyframes: ɵStyleData[], preStyles: ɵStyleData = {},\n    postStyles: ɵStyleData = {}): ɵStyleData[] {\n  const errors: string[] = [];\n  const normalizedKeyframes: ɵStyleData[] = [];\n  let previousOffset = -1;\n  let previousKeyframe: ɵStyleData|null = null;\n  keyframes.forEach(kf => {\n    const offset = kf['offset'] as number;\n    const isSameOffset = offset == previousOffset;\n    const normalizedKeyframe: ɵStyleData = (isSameOffset && previousKeyframe) || {};\n    Object.keys(kf).forEach(prop => {\n      let normalizedProp = prop;\n      let normalizedValue = kf[prop];\n      if (prop !== 'offset') {\n        normalizedProp = normalizer.normalizePropertyName(normalizedProp, errors);\n        switch (normalizedValue) {\n          case PRE_STYLE:\n            normalizedValue = preStyles[prop];\n            break;\n\n          case AUTO_STYLE:\n            normalizedValue = postStyles[prop];\n            break;\n\n          default:\n            normalizedValue =\n                normalizer.normalizeStyleValue(prop, normalizedProp, normalizedValue, errors);\n            break;\n        }\n      }\n      normalizedKeyframe[normalizedProp] = normalizedValue;\n    });\n    if (!isSameOffset) {\n      normalizedKeyframes.push(normalizedKeyframe);\n    }\n    previousKeyframe = normalizedKeyframe;\n    previousOffset = offset;\n  });\n  if (errors.length) {\n    const LINE_START = '\\n - ';\n    throw new Error(\n        `Unable to animate due to the following errors:${LINE_START}${errors.join(LINE_START)}`);\n  }\n\n  return normalizedKeyframes;\n}\n\nexport function listenOnPlayer(\n    player: AnimationPlayer, eventName: string, event: AnimationEvent|undefined,\n    callback: (event: any) => any) {\n  switch (eventName) {\n    case 'start':\n      player.onStart(() => callback(event && copyAnimationEvent(event, 'start', player)));\n      break;\n    case 'done':\n      player.onDone(() => callback(event && copyAnimationEvent(event, 'done', player)));\n      break;\n    case 'destroy':\n      player.onDestroy(() => callback(event && copyAnimationEvent(event, 'destroy', player)));\n      break;\n  }\n}\n\nexport function copyAnimationEvent(\n    e: AnimationEvent, phaseName: string, player: AnimationPlayer): AnimationEvent {\n  const totalTime = player.totalTime;\n  const disabled = (player as any).disabled ? true : false;\n  const event = makeAnimationEvent(\n      e.element, e.triggerName, e.fromState, e.toState, phaseName || e.phaseName,\n      totalTime == undefined ? e.totalTime : totalTime, disabled);\n  const data = (e as any)['_data'];\n  if (data != null) {\n    (event as any)['_data'] = data;\n  }\n  return event;\n}\n\nexport function makeAnimationEvent(\n    element: any, triggerName: string, fromState: string, toState: string, phaseName: string = '',\n    totalTime: number = 0, disabled?: boolean): AnimationEvent {\n  return {element, triggerName, fromState, toState, phaseName, totalTime, disabled: !!disabled};\n}\n\nexport function getOrSetAsInMap(\n    map: Map<any, any>|{[key: string]: any}, key: any, defaultValue: any) {\n  let value: any;\n  if (map instanceof Map) {\n    value = map.get(key);\n    if (!value) {\n      map.set(key, value = defaultValue);\n    }\n  } else {\n    value = map[key];\n    if (!value) {\n      value = map[key] = defaultValue;\n    }\n  }\n  return value;\n}\n\nexport function parseTimelineCommand(command: string): [string, string] {\n  const separatorPos = command.indexOf(':');\n  const id = command.substring(1, separatorPos);\n  const action = command.substr(separatorPos + 1);\n  return [id, action];\n}\n\nlet _contains: (elm1: any, elm2: any) => boolean = (elm1: any, elm2: any) => false;\nlet _matches: (element: any, selector: string) => boolean = (element: any, selector: string) =>\n    false;\nlet _query: (element: any, selector: string, multi: boolean) => any[] =\n    (element: any, selector: string, multi: boolean) => {\n      return [];\n    };\n\n// Define utility methods for browsers and platform-server(domino) where Element\n// and utility methods exist.\nconst _isNode = isNode();\nif (_isNode || typeof Element !== 'undefined') {\n  if (!isBrowser()) {\n    _contains = (elm1, elm2) => elm1.contains(elm2);\n  } else {\n    _contains = (elm1, elm2) => {\n      while (elm2 && elm2 !== document.documentElement) {\n        if (elm2 === elm1) {\n          return true;\n        }\n        elm2 = elm2.parentNode || elm2.host;  // consider host to support shadow DOM\n      }\n      return false;\n    };\n  }\n\n  _matches = (() => {\n    if (_isNode || Element.prototype.matches) {\n      return (element: any, selector: string) => element.matches(selector);\n    } else {\n      const proto = Element.prototype as any;\n      const fn = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector ||\n          proto.oMatchesSelector || proto.webkitMatchesSelector;\n      if (fn) {\n        return (element: any, selector: string) => fn.apply(element, [selector]);\n      } else {\n        return _matches;\n      }\n    }\n  })();\n\n  _query = (element: any, selector: string, multi: boolean): any[] => {\n    let results: any[] = [];\n    if (multi) {\n      // DO NOT REFACTOR TO USE SPREAD SYNTAX.\n      // For element queries that return sufficiently large NodeList objects,\n      // using spread syntax to populate the results array causes a RangeError\n      // due to the call stack limit being reached. `Array.from` can not be used\n      // as well, since NodeList is not iterable in IE 11, see\n      // https://developer.mozilla.org/en-US/docs/Web/API/NodeList\n      // More info is available in #38551.\n      const elems = element.querySelectorAll(selector);\n      for (let i = 0; i < elems.length; i++) {\n        results.push(elems[i]);\n      }\n    } else {\n      const elm = element.querySelector(selector);\n      if (elm) {\n        results.push(elm);\n      }\n    }\n    return results;\n  };\n}\n\nfunction containsVendorPrefix(prop: string): boolean {\n  // Webkit is the only real popular vendor prefix nowadays\n  // cc: http://shouldiprefix.com/\n  return prop.substring(1, 6) == 'ebkit';  // webkit or Webkit\n}\n\nlet _CACHED_BODY: {style: any}|null = null;\nlet _IS_WEBKIT = false;\nexport function validateStyleProperty(prop: string): boolean {\n  if (!_CACHED_BODY) {\n    _CACHED_BODY = getBodyNode() || {};\n    _IS_WEBKIT = _CACHED_BODY!.style ? ('WebkitAppearance' in _CACHED_BODY!.style) : false;\n  }\n\n  let result = true;\n  if (_CACHED_BODY!.style && !containsVendorPrefix(prop)) {\n    result = prop in _CACHED_BODY!.style;\n    if (!result && _IS_WEBKIT) {\n      const camelProp = 'Webkit' + prop.charAt(0).toUpperCase() + prop.substr(1);\n      result = camelProp in _CACHED_BODY!.style;\n    }\n  }\n\n  return result;\n}\n\nexport function getBodyNode(): any|null {\n  if (typeof document != 'undefined') {\n    return document.body;\n  }\n  return null;\n}\n\nexport const matchesElement = _matches;\nexport const containsElement = _contains;\nexport const invokeQuery = _query;\n\nexport function hypenatePropsObject(object: {[key: string]: any}): {[key: string]: any} {\n  const newObj: {[key: string]: any} = {};\n  Object.keys(object).forEach(prop => {\n    const newProp = prop.replace(/([a-z])([A-Z])/g, '$1-$2');\n    newObj[newProp] = object[prop];\n  });\n  return newObj;\n}\n"]}

package/esm2020/browser/src/render/special_cased_styles.mjs

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { eraseStyles, setStyles } from '../util';
+/**
+ * Returns an instance of `SpecialCasedStyles` if and when any special (non animateable) styles are
+ * detected.
+ *
+ * In CSS there exist properties that cannot be animated within a keyframe animation
+ * (whether it be via CSS keyframes or web-animations) and the animation implementation
+ * will ignore them. This function is designed to detect those special cased styles and
+ * return a container that will be executed at the start and end of the animation.
+ *
+ * @returns an instance of `SpecialCasedStyles` if any special styles are detected otherwise `null`
+ */
+export function packageNonAnimatableStyles(element, styles) {
+    let startStyles = null;
+    let endStyles = null;
+    if (Array.isArray(styles) && styles.length) {
+        startStyles = filterNonAnimatableStyles(styles[0]);
+        if (styles.length > 1) {
+            endStyles = filterNonAnimatableStyles(styles[styles.length - 1]);
+        }
+    }
+    else if (styles) {
+        startStyles = filterNonAnimatableStyles(styles);
+    }
+    return (startStyles || endStyles) ? new SpecialCasedStyles(element, startStyles, endStyles) :
+        null;
+}
+/**
+ * Designed to be executed during a keyframe-based animation to apply any special-cased styles.
+ *
+ * When started (when the `start()` method is run) then the provided `startStyles`
+ * will be applied. When finished (when the `finish()` method is called) the
+ * `endStyles` will be applied as well any any starting styles. Finally when
+ * `destroy()` is called then all styles will be removed.
+ */
+export class SpecialCasedStyles {
+    constructor(_element, _startStyles, _endStyles) {
+        this._element = _element;
+        this._startStyles = _startStyles;
+        this._endStyles = _endStyles;
+        this._state = 0 /* Pending */;
+        let initialStyles = SpecialCasedStyles.initialStylesByElement.get(_element);
+        if (!initialStyles) {
+            SpecialCasedStyles.initialStylesByElement.set(_element, initialStyles = {});
+        }
+        this._initialStyles = initialStyles;
+    }
+    start() {
+        if (this._state < 1 /* Started */) {
+            if (this._startStyles) {
+                setStyles(this._element, this._startStyles, this._initialStyles);
+            }
+            this._state = 1 /* Started */;
+        }
+    }
+    finish() {
+        this.start();
+        if (this._state < 2 /* Finished */) {
+            setStyles(this._element, this._initialStyles);
+            if (this._endStyles) {
+                setStyles(this._element, this._endStyles);
+                this._endStyles = null;
+            }
+            this._state = 1 /* Started */;
+        }
+    }
+    destroy() {
+        this.finish();
+        if (this._state < 3 /* Destroyed */) {
+            SpecialCasedStyles.initialStylesByElement.delete(this._element);
+            if (this._startStyles) {
+                eraseStyles(this._element, this._startStyles);
+                this._endStyles = null;
+            }
+            if (this._endStyles) {
+                eraseStyles(this._element, this._endStyles);
+                this._endStyles = null;
+            }
+            setStyles(this._element, this._initialStyles);
+            this._state = 3 /* Destroyed */;
+        }
+    }
+}
+SpecialCasedStyles.initialStylesByElement = ( /* @__PURE__ */new WeakMap());
+function filterNonAnimatableStyles(styles) {
+    let result = null;
+    const props = Object.keys(styles);
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        if (isNonAnimatableStyle(prop)) {
+            result = result || {};
+            result[prop] = styles[prop];
+        }
+    }
+    return result;
+}
+function isNonAnimatableStyle(prop) {
+    return prop === 'display' || prop === 'position';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"special_cased_styles.js","sourceRoot":"","sources":["../../../../../../../../packages/animations/browser/src/render/special_cased_styles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {eraseStyles, setStyles} from '../util';\n\n/**\n * Returns an instance of `SpecialCasedStyles` if and when any special (non animateable) styles are\n * detected.\n *\n * In CSS there exist properties that cannot be animated within a keyframe animation\n * (whether it be via CSS keyframes or web-animations) and the animation implementation\n * will ignore them. This function is designed to detect those special cased styles and\n * return a container that will be executed at the start and end of the animation.\n *\n * @returns an instance of `SpecialCasedStyles` if any special styles are detected otherwise `null`\n */\nexport function packageNonAnimatableStyles(\n    element: any, styles: {[key: string]: any}|{[key: string]: any}[]): SpecialCasedStyles|null {\n  let startStyles: {[key: string]: any}|null = null;\n  let endStyles: {[key: string]: any}|null = null;\n  if (Array.isArray(styles) && styles.length) {\n    startStyles = filterNonAnimatableStyles(styles[0]);\n    if (styles.length > 1) {\n      endStyles = filterNonAnimatableStyles(styles[styles.length - 1]);\n    }\n  } else if (styles) {\n    startStyles = filterNonAnimatableStyles(styles);\n  }\n\n  return (startStyles || endStyles) ? new SpecialCasedStyles(element, startStyles, endStyles) :\n                                      null;\n}\n\n/**\n * Designed to be executed during a keyframe-based animation to apply any special-cased styles.\n *\n * When started (when the `start()` method is run) then the provided `startStyles`\n * will be applied. When finished (when the `finish()` method is called) the\n * `endStyles` will be applied as well any any starting styles. Finally when\n * `destroy()` is called then all styles will be removed.\n */\nexport class SpecialCasedStyles {\n  static initialStylesByElement = (/* @__PURE__ */ new WeakMap<any, {[key: string]: any}>());\n\n  private _state = SpecialCasedStylesState.Pending;\n  private _initialStyles!: {[key: string]: any};\n\n  constructor(\n      private _element: any, private _startStyles: {[key: string]: any}|null,\n      private _endStyles: {[key: string]: any}|null) {\n    let initialStyles = SpecialCasedStyles.initialStylesByElement.get(_element);\n    if (!initialStyles) {\n      SpecialCasedStyles.initialStylesByElement.set(_element, initialStyles = {});\n    }\n    this._initialStyles = initialStyles;\n  }\n\n  start() {\n    if (this._state < SpecialCasedStylesState.Started) {\n      if (this._startStyles) {\n        setStyles(this._element, this._startStyles, this._initialStyles);\n      }\n      this._state = SpecialCasedStylesState.Started;\n    }\n  }\n\n  finish() {\n    this.start();\n    if (this._state < SpecialCasedStylesState.Finished) {\n      setStyles(this._element, this._initialStyles);\n      if (this._endStyles) {\n        setStyles(this._element, this._endStyles);\n        this._endStyles = null;\n      }\n      this._state = SpecialCasedStylesState.Started;\n    }\n  }\n\n  destroy() {\n    this.finish();\n    if (this._state < SpecialCasedStylesState.Destroyed) {\n      SpecialCasedStyles.initialStylesByElement.delete(this._element);\n      if (this._startStyles) {\n        eraseStyles(this._element, this._startStyles);\n        this._endStyles = null;\n      }\n      if (this._endStyles) {\n        eraseStyles(this._element, this._endStyles);\n        this._endStyles = null;\n      }\n      setStyles(this._element, this._initialStyles);\n      this._state = SpecialCasedStylesState.Destroyed;\n    }\n  }\n}\n\n/**\n * An enum of states reflective of what the status of `SpecialCasedStyles` is.\n *\n * Depending on how `SpecialCasedStyles` is interacted with, the start and end\n * styles may not be applied in the same way. This enum ensures that if and when\n * the ending styles are applied then the starting styles are applied. It is\n * also used to reflect what the current status of the special cased styles are\n * which helps prevent the starting/ending styles not be applied twice. It is\n * also used to cleanup the styles once `SpecialCasedStyles` is destroyed.\n */\nconst enum SpecialCasedStylesState {\n  Pending = 0,\n  Started = 1,\n  Finished = 2,\n  Destroyed = 3,\n}\n\nfunction filterNonAnimatableStyles(styles: {[key: string]: any}) {\n  let result: {[key: string]: any}|null = null;\n  const props = Object.keys(styles);\n  for (let i = 0; i < props.length; i++) {\n    const prop = props[i];\n    if (isNonAnimatableStyle(prop)) {\n      result = result || {};\n      result[prop] = styles[prop];\n    }\n  }\n  return result;\n}\n\nfunction isNonAnimatableStyle(prop: string) {\n  return prop === 'display' || prop === 'position';\n}\n"]}