@angular-wave/angular.ts 0.0.1

package/src/core/animateCss.js

@@ -0,0 +1,73 @@
+/**
+ * @ngdoc service
+ * @name $animateCss
+ * @kind object
+ *
+ *
+ * @description
+ * This is the core version of `$animateCss`. By default, only when the `ngAnimate` is included,
+ * then the `$animateCss` service will actually perform animations.
+ *
+ * Click here {@link ngAnimate.$animateCss to read the documentation for $animateCss}.
+ */
+export function CoreAnimateCssProvider() {
+  this.$get = [
+    "$$AnimateRunner",
+    ($$AnimateRunner) =>
+      function (element, initialOptions) {
+        // all of the animation functions should create
+        // a copy of the options data, however, if a
+        // parent service has already created a copy then
+        // we should stick to using that
+        let options = initialOptions || {};
+        if (!options.$$prepared) {
+          options = structuredClone(options);
+        }
+
+        // there is no point in applying the styles since
+        // there is no animation that goes on at all in
+        // this version of $animateCss.
+        if (options.cleanupStyles) {
+          options.from = options.to = null;
+        }
+
+        if (options.from) {
+          //element.css(options.from);
+          options.from = null;
+        }
+
+        let closed;
+        const runner = new $$AnimateRunner();
+        return {
+          start: run,
+          end: run,
+        };
+
+        function run() {
+          requestAnimationFrame(() => {
+            applyAnimationContents();
+            if (!closed) {
+              runner.complete();
+            }
+            closed = true;
+          });
+          return runner;
+        }
+
+        function applyAnimationContents() {
+          if (options.addClass) {
+            element[0].classList.add(options.addClass);
+            options.addClass = null;
+          }
+          if (options.removeClass) {
+            element[0].classList.remove(options.removeClass);
+            options.removeClass = null;
+          }
+          if (options.to) {
+            //element.css(options.to);
+            options.to = null;
+          }
+        }
+      },
+  ];
+}

package/src/core/animateRunner.js

@@ -0,0 +1,195 @@
+import { forEach } from "./utils";
+
+export function AnimateAsyncRunFactoryProvider() {
+  this.$get = [
+    function () {
+      var waitQueue = [];
+
+      function waitForTick(fn) {
+        waitQueue.push(fn);
+        if (waitQueue.length > 1) return;
+        window.requestAnimationFrame(function () {
+          for (var i = 0; i < waitQueue.length; i++) {
+            waitQueue[i]();
+          }
+          waitQueue = [];
+        });
+      }
+
+      return function () {
+        var passed = false;
+        waitForTick(function () {
+          passed = true;
+        });
+        return function (callback) {
+          if (passed) {
+            callback();
+          } else {
+            waitForTick(callback);
+          }
+        };
+      };
+    },
+  ];
+}
+
+export function AnimateRunnerFactoryProvider() {
+  this.$get = [
+    "$q",
+    "$$animateAsyncRun",
+    "$$isDocumentHidden",
+    "$timeout",
+    function ($q, $$animateAsyncRun, $$isDocumentHidden, $timeout) {
+      const INITIAL_STATE = 0;
+      const DONE_PENDING_STATE = 1;
+      const DONE_COMPLETE_STATE = 2;
+
+      AnimateRunner.chain = function (chain, callback) {
+        let index = 0;
+
+        next();
+        function next() {
+          if (index === chain.length) {
+            callback(true);
+            return;
+          }
+
+          chain[index]((response) => {
+            if (response === false) {
+              callback(false);
+              return;
+            }
+            index++;
+            next();
+          });
+        }
+      };
+
+      AnimateRunner.all = function (runners, callback) {
+        let count = 0;
+        let status = true;
+        forEach(runners, (runner) => {
+          runner.done(onProgress);
+        });
+
+        function onProgress(response) {
+          status = status && response;
+          if (++count === runners.length) {
+            callback(status);
+          }
+        }
+      };
+
+      function AnimateRunner(host) {
+        this.setHost(host);
+
+        const rafTick = $$animateAsyncRun();
+        const timeoutTick = function (fn) {
+          $timeout(fn, 0, false);
+        };
+
+        this._doneCallbacks = [];
+        this._tick = function (fn) {
+          if ($$isDocumentHidden()) {
+            timeoutTick(fn);
+          } else {
+            rafTick(fn);
+          }
+        };
+        this._state = 0;
+      }
+
+      AnimateRunner.prototype = {
+        setHost(host) {
+          this.host = host || {};
+        },
+
+        done(fn) {
+          if (this._state === DONE_COMPLETE_STATE) {
+            fn();
+          } else {
+            this._doneCallbacks.push(fn);
+          }
+        },
+
+        progress: () => {},
+
+        getPromise() {
+          if (!this.promise) {
+            const self = this;
+            this.promise = $q((resolve, reject) => {
+              self.done((status) => {
+                if (status === false) {
+                  reject();
+                } else {
+                  resolve();
+                }
+              });
+            });
+          }
+          return this.promise;
+        },
+
+        then(resolveHandler, rejectHandler) {
+          return this.getPromise().then(resolveHandler, rejectHandler);
+        },
+
+        catch(handler) {
+          return this.getPromise().catch(handler);
+        },
+
+        finally(handler) {
+          return this.getPromise().finally(handler);
+        },
+
+        pause() {
+          if (this.host.pause) {
+            this.host.pause();
+          }
+        },
+
+        resume() {
+          if (this.host.resume) {
+            this.host.resume();
+          }
+        },
+
+        end() {
+          if (this.host.end) {
+            this.host.end();
+          }
+          this._resolve(true);
+        },
+
+        cancel() {
+          if (this.host.cancel) {
+            this.host.cancel();
+          }
+          this._resolve(false);
+        },
+
+        complete(response) {
+          const self = this;
+          if (self._state === INITIAL_STATE) {
+            self._state = DONE_PENDING_STATE;
+            self._tick(() => {
+              self._resolve(response);
+            });
+          }
+        },
+
+        _resolve(response) {
+          if (this._state !== DONE_COMPLETE_STATE) {
+            forEach(this._doneCallbacks, (fn) => {
+              fn(response);
+            });
+            this._doneCallbacks.length = 0;
+            this._state = DONE_COMPLETE_STATE;
+          }
+        },
+      };
+
+      return AnimateRunner;
+    },
+  ];
+}

package/src/core/attributes.js

@@ -0,0 +1,199 @@
+export class Attributes {
+  constructor(element, attributesToCopy) {
+    if (attributesToCopy) {
+      const keys = Object.keys(attributesToCopy);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        this[key] = attributesToCopy[key];
+      }
+    } else {
+      this.$attr = {};
+    }
+
+    this.$$element = element;
+  }
+
+  /**
+   * @ngdoc method
+   * @name $compile.directive.Attributes#$normalize
+   * @kind function
+   *
+   * @description
+   * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
+   * `data-`) to its normalized, camelCase form.
+   *
+   * Also there is special case for Moz prefix starting with upper case letter.
+   *
+   * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
+   *
+   * @param {string} name Name to normalize
+   */
+  $normalize(name) {
+    return directiveNormalize(name);
+  }
+
+  /**
+   * @ngdoc method
+   * @name $compile.directive.Attributes#$addClass
+   * @kind function
+   *
+   * @description
+   * Adds the CSS class value specified by the classVal parameter to the element. If animations
+   * are enabled then an animation will be triggered for the class addition.
+   *
+   * @param {string} classVal The className value that will be added to the element
+   */
+  $addClass(classVal) {
+    if (classVal && classVal.length > 0) {
+      $animate.addClass(this.$$element, classVal);
+    }
+  }
+
+  /**
+   * @ngdoc method
+   * @name $compile.directive.Attributes#$removeClass
+   * @kind function
+   *
+   * @description
+   * Removes the CSS class value specified by the classVal parameter from the element. If
+   * animations are enabled then an animation will be triggered for the class removal.
+   *
+   * @param {string} classVal The className value that will be removed from the element
+   */
+  $removeClass(classVal) {
+    if (classVal && classVal.length > 0) {
+      $animate.removeClass(this.$$element, classVal);
+    }
+  }
+
+  /**
+   * @ngdoc method
+   * @name $compile.directive.Attributes#$updateClass
+   * @kind function
+   *
+   * @description
+   * Adds and removes the appropriate CSS class values to the element based on the difference
+   * between the new and old CSS class values (specified as newClasses and oldClasses).
+   *
+   * @param {string} newClasses The current CSS className value
+   * @param {string} oldClasses The former CSS className value
+   */
+  $updateClass(newClasses, oldClasses) {
+    const toAdd = tokenDifference(newClasses, oldClasses);
+    if (toAdd && toAdd.length) {
+      $animate.addClass(this.$$element, toAdd);
+    }
+
+    const toRemove = tokenDifference(oldClasses, newClasses);
+    if (toRemove && toRemove.length) {
+      $animate.removeClass(this.$$element, toRemove);
+    }
+  }
+
+  /**
+   * Set a normalized attribute on the element in a way such that all directives
+   * can share the attribute. This function properly handles boolean attributes.
+   * @param {string} key Normalized key. (ie ngAttribute)
+   * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+   * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
+   *     Defaults to true.
+   * @param {string=} attrName Optional none normalized name. Defaults to key.
+   */
+  $set(key, value, writeAttr = true, attrName) {
+    const node = this.$$element[0];
+    const booleanKey = getBooleanAttrName(node, key);
+    const aliasedKey = ALIASED_ATTR[key];
+    let observer = key;
+    let nodeName;
+
+    if (booleanKey) {
+      this.$$element.prop(key, value);
+      attrName = booleanKey;
+    } else if (aliasedKey) {
+      this[aliasedKey] = value;
+      observer = aliasedKey;
+    }
+
+    this[key] = value;
+
+    if (attrName) {
+      this.$attr[key] = attrName;
+    } else {
+      attrName = this.$attr[key];
+      if (!attrName) {
+        this.$attr[key] = attrName = snakeCase(key, "-");
+      }
+    }
+
+    nodeName = nodeName_(this.$$element);
+
+    if (nodeName === "img" && key === "srcset") {
+      this[key] = value = sanitizeSrcset(value, "$set('srcset', value)");
+    }
+
+    if (writeAttr !== false) {
+      if (value === null || isUndefined(value)) {
+        this.$$element[0].removeAttribute(attrName);
+      } else if (SIMPLE_ATTR_NAME.test(attrName)) {
+        if (booleanKey && value === false) {
+          this.$$element[0].removeAttribute(attrName);
+        } else {
+          this.$$element.attr(attrName, value);
+        }
+      } else {
+        setSpecialAttr(this.$$element[0], attrName, value);
+      }
+    }
+
+    const { $$observers } = this;
+    if ($$observers) {
+      forEach($$observers[observer], (fn) => {
+        try {
+          fn(value);
+        } catch (e) {
+          $exceptionHandler(e);
+        }
+      });
+    }
+  }
+
+  /**
+     * @ngdoc method
+     * @name $compile.directive.Attributes#$observe
+     * @kind function
+     *
+     * @description
+     * Observes an interpolated attribute.
+     *
+     * The observer function will be invoked once during the next `$digest` following
+     * compilation. The observer is then invoked whenever the interpolated value
+     * changes.
+     *
+     * @param {string} key Normalized key. (ie ngAttribute) .
+     * @param {function(interpolatedValue)} fn Function that will be called whenever
+              the interpolated value of the attribute changes.
+     *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
+     *        guide} for more info.
+     * @returns {function()} Returns a deregistration function for this observer.
+     */
+  $observe(key, fn) {
+    const attrs = this;
+    const $$observers = attrs.$$observers || (attrs.$$observers = createMap());
+    const listeners = $$observers[key] || ($$observers[key] = []);
+
+    listeners.push(fn);
+    $rootScope.$evalAsync(() => {
+      if (
+        !listeners.$$inter &&
+        Object.prototype.hasOwnProperty.call(attrs, key) &&
+        !isUndefined(attrs[key])
+      ) {
+        fn(attrs[key]);
+      }
+    });
+
+    return function () {
+      arrayRemove(listeners, fn);
+    };
+  }
+}

package/src/core/cache.js

@@ -0,0 +1,45 @@
+/**
+ * @typedef {Object} ExpandoStore
+ *
+ * @property {!Object<string, any>} data
+ * @property {!Object} events
+ * @property {?Function} handle
+ *
+ */
+
+/**
+ * Expando cache for adding properties to DOM nodes with JavaScript.
+ * This used to be an Object in JQLite decorator, but swapped out for a Map
+ * for performance reasons and convenience methods. A proxy is available for
+ * additional logic handling.
+ *
+ * @type {Map<number, ExpandoStore>}
+ */
+export const CACHE = new Proxy(new Map(), {
+  get(target, prop, receiver) {
+    if (prop === "size") {
+      return target.size;
+    }
+    if (typeof target[prop] === "function") {
+      return function (...args) {
+        return target[prop].apply(target, args);
+      };
+    }
+    return Reflect.get(target, prop, receiver);
+  },
+  set(target, prop, value, receiver) {
+    return Reflect.set(target, prop, value, receiver);
+  },
+  deleteProperty(target, prop) {
+    return Reflect.deleteProperty(target, prop);
+  },
+  has(target, prop) {
+    return Reflect.has(target, prop);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    return Reflect.getOwnPropertyDescriptor(target, prop);
+  },
+});