@angular-wave/angular.ts 0.0.50 → 0.0.52

package/src/animations/animate-js.js

@@ -5,363 +5,360 @@ import {
   prepareAnimationOptions,
 } from "./shared";
 
-// TODO(matsko): use caching here to speed things up for detection
-// TODO(matsko): add documentation
-//  by the time...
-
-export const $$AnimateJsProvider = [
-  "$animateProvider",
-  function ($animateProvider) {
-    this.$get = [
-      "$injector",
-      "$$AnimateRunner",
-      function ($injector, $$AnimateRunner) {
-        const applyAnimationClasses = applyAnimationClassesFactory();
-        // $animateJs(element, 'enter');
-        return function (element, event, classes, options) {
-          let animationClosed = false;
-
-          // the `classes` argument is optional and if it is not used
-          // then the classes will be resolved from the element's className
-          // property as well as options.addClass/options.removeClass.
-          if (arguments.length === 3 && isObject(classes)) {
-            options = classes;
-            classes = null;
-          }
+// TODO: use caching here to speed things up for detection
+// TODO: add documentation
+
+$$AnimateJsProvider.$inject = ["$animateProvider"];
+export function $$AnimateJsProvider($animateProvider) {
+  this.$get = [
+    "$injector",
+    "$$AnimateRunner",
+    function ($injector, $$AnimateRunner) {
+      const applyAnimationClasses = applyAnimationClassesFactory();
+      // $animateJs(element, 'enter');
+      return function (element, event, classes, options) {
+        let animationClosed = false;
+
+        // the `classes` argument is optional and if it is not used
+        // then the classes will be resolved from the element's className
+        // property as well as options.addClass/options.removeClass.
+        if (arguments.length === 3 && isObject(classes)) {
+          options = classes;
+          classes = null;
+        }
 
-          options = prepareAnimationOptions(options);
-          if (!classes) {
-            classes = element.attr("class") || "";
-            if (options.addClass) {
-              classes += ` ${options.addClass}`;
-            }
-            if (options.removeClass) {
-              classes += ` ${options.removeClass}`;
-            }
+        options = prepareAnimationOptions(options);
+        if (!classes) {
+          classes = element.attr("class") || "";
+          if (options.addClass) {
+            classes += ` ${options.addClass}`;
           }
+          if (options.removeClass) {
+            classes += ` ${options.removeClass}`;
+          }
+        }
 
-          const classesToAdd = options.addClass;
-          const classesToRemove = options.removeClass;
-
-          // the lookupAnimations function returns a series of animation objects that are
-          // matched up with one or more of the CSS classes. These animation objects are
-          // defined via the module.animation factory function. If nothing is detected then
-          // we don't return anything which then makes $animation query the next driver.
-          const animations = lookupAnimations(classes);
-          let before;
-          let after;
-          if (animations.length) {
-            let afterFn;
-            let beforeFn;
-            if (event === "leave") {
-              beforeFn = "leave";
-              afterFn = "afterLeave"; // TODO(matsko): get rid of this
-            } else {
-              beforeFn = `before${event.charAt(0).toUpperCase()}${event.substr(1)}`;
-              afterFn = event;
-            }
+        const classesToAdd = options.addClass;
+        const classesToRemove = options.removeClass;
+
+        // the lookupAnimations function returns a series of animation objects that are
+        // matched up with one or more of the CSS classes. These animation objects are
+        // defined via the module.animation factory function. If nothing is detected then
+        // we don't return anything which then makes $animation query the next driver.
+        const animations = lookupAnimations(classes);
+        let before;
+        let after;
+        if (animations.length) {
+          let afterFn;
+          let beforeFn;
+          if (event === "leave") {
+            beforeFn = "leave";
+            afterFn = "afterLeave"; // TODO(matsko): get rid of this
+          } else {
+            beforeFn = `before${event.charAt(0).toUpperCase()}${event.substr(1)}`;
+            afterFn = event;
+          }
 
-            if (event !== "enter" && event !== "move") {
-              before = packageAnimations(
-                element,
-                event,
-                options,
-                animations,
-                beforeFn,
-              );
-            }
-            after = packageAnimations(
+          if (event !== "enter" && event !== "move") {
+            before = packageAnimations(
               element,
               event,
               options,
               animations,
-              afterFn,
+              beforeFn,
             );
           }
+          after = packageAnimations(
+            element,
+            event,
+            options,
+            animations,
+            afterFn,
+          );
+        }
 
-          // no matching animations
-          if (!before && !after) return;
+        // no matching animations
+        if (!before && !after) return;
 
-          function applyOptions() {
-            options.domOperation();
-            applyAnimationClasses(element, options);
-          }
+        function applyOptions() {
+          options.domOperation();
+          applyAnimationClasses(element, options);
+        }
 
-          function close() {
-            animationClosed = true;
-            applyOptions();
-            applyAnimationStyles(element, options);
-          }
+        function close() {
+          animationClosed = true;
+          applyOptions();
+          applyAnimationStyles(element, options);
+        }
 
-          let runner;
-
-          return {
-            $$willAnimate: true,
-            end() {
-              if (runner) {
-                runner.end();
-              } else {
-                close();
-                runner = new $$AnimateRunner();
-                runner.complete(true);
-              }
-              return runner;
-            },
-            start() {
-              if (runner) {
-                return runner;
-              }
+        let runner;
 
+        return {
+          $$willAnimate: true,
+          end() {
+            if (runner) {
+              runner.end();
+            } else {
+              close();
               runner = new $$AnimateRunner();
-              let closeActiveAnimations;
-              const chain = [];
+              runner.complete(true);
+            }
+            return runner;
+          },
+          start() {
+            if (runner) {
+              return runner;
+            }
 
-              if (before) {
-                chain.push((fn) => {
-                  closeActiveAnimations = before(fn);
-                });
-              }
+            runner = new $$AnimateRunner();
+            let closeActiveAnimations;
+            const chain = [];
 
-              if (chain.length) {
-                chain.push((fn) => {
-                  applyOptions();
-                  fn(true);
-                });
-              } else {
-                applyOptions();
-              }
+            if (before) {
+              chain.push((fn) => {
+                closeActiveAnimations = before(fn);
+              });
+            }
 
-              if (after) {
-                chain.push((fn) => {
-                  closeActiveAnimations = after(fn);
-                });
-              }
+            if (chain.length) {
+              chain.push((fn) => {
+                applyOptions();
+                fn(true);
+              });
+            } else {
+              applyOptions();
+            }
 
-              runner.setHost({
-                end() {
-                  endAnimations();
-                },
-                cancel() {
-                  endAnimations(true);
-                },
+            if (after) {
+              chain.push((fn) => {
+                closeActiveAnimations = after(fn);
               });
+            }
 
-              $$AnimateRunner.chain(chain, onComplete);
-              return runner;
+            runner.setHost({
+              end() {
+                endAnimations();
+              },
+              cancel() {
+                endAnimations(true);
+              },
+            });
 
-              function onComplete(success) {
-                close();
-                runner.complete(success);
-              }
+            $$AnimateRunner.chain(chain, onComplete);
+            return runner;
 
-              function endAnimations(cancelled) {
-                if (!animationClosed) {
-                  (closeActiveAnimations || (() => {}))(cancelled);
-                  onComplete(cancelled);
-                }
-              }
-            },
-          };
+            function onComplete(success) {
+              close();
+              runner.complete(success);
+            }
 
-          function executeAnimationFn(fn, element, event, options, onDone) {
-            let args;
-            switch (event) {
-              case "animate":
-                args = [element, options.from, options.to, onDone];
-                break;
+            function endAnimations(cancelled) {
+              if (!animationClosed) {
+                (closeActiveAnimations || (() => {}))(cancelled);
+                onComplete(cancelled);
+              }
+            }
+          },
+        };
 
-              case "setClass":
-                args = [element, classesToAdd, classesToRemove, onDone];
-                break;
+        function executeAnimationFn(fn, element, event, options, onDone) {
+          let args;
+          switch (event) {
+            case "animate":
+              args = [element, options.from, options.to, onDone];
+              break;
 
-              case "addClass":
-                args = [element, classesToAdd, onDone];
-                break;
+            case "setClass":
+              args = [element, classesToAdd, classesToRemove, onDone];
+              break;
 
-              case "removeClass":
-                args = [element, classesToRemove, onDone];
-                break;
+            case "addClass":
+              args = [element, classesToAdd, onDone];
+              break;
 
-              default:
-                args = [element, onDone];
-                break;
-            }
+            case "removeClass":
+              args = [element, classesToRemove, onDone];
+              break;
 
-            args.push(options);
+            default:
+              args = [element, onDone];
+              break;
+          }
 
-            let value = fn.apply(fn, args);
-            if (value) {
-              if (isFunction(value.start)) {
-                value = value.start();
-              }
+          args.push(options);
 
-              if (value instanceof $$AnimateRunner) {
-                value.done(onDone);
-              } else if (isFunction(value)) {
-                // optional onEnd / onCancel callback
-                return value;
-              }
+          let value = fn.apply(fn, args);
+          if (value) {
+            if (isFunction(value.start)) {
+              value = value.start();
             }
 
-            return () => {};
+            if (value instanceof $$AnimateRunner) {
+              value.done(onDone);
+            } else if (isFunction(value)) {
+              // optional onEnd / onCancel callback
+              return value;
+            }
           }
 
-          function groupEventedAnimations(
-            element,
-            event,
-            options,
-            animations,
-            fnName,
-          ) {
-            const operations = [];
-            forEach(animations, (ani) => {
-              const animation = ani[fnName];
-              if (!animation) return;
-
-              // note that all of these animations will run in parallel
-              operations.push(() => {
-                let runner;
-                let endProgressCb;
-
-                let resolved = false;
-                const onAnimationComplete = function (rejected) {
-                  if (!resolved) {
-                    resolved = true;
-                    (endProgressCb || (() => {}))(rejected);
-                    runner.complete(!rejected);
-                  }
-                };
-
-                runner = new $$AnimateRunner({
-                  end() {
-                    onAnimationComplete();
-                  },
-                  cancel() {
-                    onAnimationComplete(true);
-                  },
-                });
-
-                endProgressCb = executeAnimationFn(
-                  animation,
-                  element,
-                  event,
-                  options,
-                  (result) => {
-                    const cancelled = result === false;
-                    onAnimationComplete(cancelled);
-                  },
-                );
-
-                return runner;
+          return () => {};
+        }
+
+        function groupEventedAnimations(
+          element,
+          event,
+          options,
+          animations,
+          fnName,
+        ) {
+          const operations = [];
+          forEach(animations, (ani) => {
+            const animation = ani[fnName];
+            if (!animation) return;
+
+            // note that all of these animations will run in parallel
+            operations.push(() => {
+              let runner;
+              let endProgressCb;
+
+              let resolved = false;
+              const onAnimationComplete = function (rejected) {
+                if (!resolved) {
+                  resolved = true;
+                  (endProgressCb || (() => {}))(rejected);
+                  runner.complete(!rejected);
+                }
+              };
+
+              runner = new $$AnimateRunner({
+                end() {
+                  onAnimationComplete();
+                },
+                cancel() {
+                  onAnimationComplete(true);
+                },
               });
+
+              endProgressCb = executeAnimationFn(
+                animation,
+                element,
+                event,
+                options,
+                (result) => {
+                  const cancelled = result === false;
+                  onAnimationComplete(cancelled);
+                },
+              );
+
+              return runner;
             });
+          });
 
-            return operations;
-          }
+          return operations;
+        }
 
-          function packageAnimations(
+        function packageAnimations(
+          element,
+          event,
+          options,
+          animations,
+          fnName,
+        ) {
+          let operations = groupEventedAnimations(
             element,
             event,
             options,
             animations,
             fnName,
-          ) {
-            let operations = groupEventedAnimations(
-              element,
-              event,
-              options,
-              animations,
-              fnName,
-            );
-            if (operations.length === 0) {
-              let a;
-              let b;
-              if (fnName === "beforeSetClass") {
-                a = groupEventedAnimations(
-                  element,
-                  "removeClass",
-                  options,
-                  animations,
-                  "beforeRemoveClass",
-                );
-                b = groupEventedAnimations(
-                  element,
-                  "addClass",
-                  options,
-                  animations,
-                  "beforeAddClass",
-                );
-              } else if (fnName === "setClass") {
-                a = groupEventedAnimations(
-                  element,
-                  "removeClass",
-                  options,
-                  animations,
-                  "removeClass",
-                );
-                b = groupEventedAnimations(
-                  element,
-                  "addClass",
-                  options,
-                  animations,
-                  "addClass",
-                );
-              }
+          );
+          if (operations.length === 0) {
+            let a;
+            let b;
+            if (fnName === "beforeSetClass") {
+              a = groupEventedAnimations(
+                element,
+                "removeClass",
+                options,
+                animations,
+                "beforeRemoveClass",
+              );
+              b = groupEventedAnimations(
+                element,
+                "addClass",
+                options,
+                animations,
+                "beforeAddClass",
+              );
+            } else if (fnName === "setClass") {
+              a = groupEventedAnimations(
+                element,
+                "removeClass",
+                options,
+                animations,
+                "removeClass",
+              );
+              b = groupEventedAnimations(
+                element,
+                "addClass",
+                options,
+                animations,
+                "addClass",
+              );
+            }
 
-              if (a) {
-                operations = operations.concat(a);
-              }
-              if (b) {
-                operations = operations.concat(b);
-              }
+            if (a) {
+              operations = operations.concat(a);
             }
+            if (b) {
+              operations = operations.concat(b);
+            }
+          }
 
-            if (operations.length === 0) return;
+          if (operations.length === 0) return;
 
-            // TODO(matsko): add documentation
-            return function startAnimation(callback) {
-              const runners = [];
-              if (operations.length) {
-                forEach(operations, (animateFn) => {
-                  runners.push(animateFn());
-                });
-              }
+          // TODO(matsko): add documentation
+          return function startAnimation(callback) {
+            const runners = [];
+            if (operations.length) {
+              forEach(operations, (animateFn) => {
+                runners.push(animateFn());
+              });
+            }
 
-              if (runners.length) {
-                $$AnimateRunner.all(runners, callback);
-              } else {
-                callback();
-              }
+            if (runners.length) {
+              $$AnimateRunner.all(runners, callback);
+            } else {
+              callback();
+            }
 
-              return function endFn(reject) {
-                forEach(runners, (runner) => {
-                  if (reject) {
-                    runner.cancel();
-                  } else {
-                    runner.end();
-                  }
-                });
-              };
+            return function endFn(reject) {
+              forEach(runners, (runner) => {
+                if (reject) {
+                  runner.cancel();
+                } else {
+                  runner.end();
+                }
+              });
             };
+          };
+        }
+      };
+
+      function lookupAnimations(classes) {
+        classes = Array.isArray(classes) ? classes : classes.split(" ");
+        const matches = [];
+        const flagMap = {};
+        for (let i = 0; i < classes.length; i++) {
+          const klass = classes[i];
+          const animationFactory =
+            $animateProvider.$$registeredAnimations[klass];
+          if (animationFactory && !flagMap[klass]) {
+            matches.push($injector.get(animationFactory));
+            flagMap[klass] = true;
           }
-        };
-
-        function lookupAnimations(classes) {
-          classes = Array.isArray(classes) ? classes : classes.split(" ");
-          const matches = [];
-          const flagMap = {};
-          for (let i = 0; i < classes.length; i++) {
-            const klass = classes[i];
-            const animationFactory =
-              $animateProvider.$$registeredAnimations[klass];
-            if (animationFactory && !flagMap[klass]) {
-              matches.push($injector.get(animationFactory));
-              flagMap[klass] = true;
-            }
-          }
-          return matches;
         }
-      },
-    ];
-  },
-];
+        return matches;
+      }
+    },
+  ];
+}