@angular-wave/angular.ts 0.0.1

package/src/public.js

@@ -0,0 +1,215 @@
+import { $CompileProvider } from "./core/compile";
+import { htmlAnchorDirective } from "./directive/a";
+import {
+  inputDirective,
+  ngValueDirective,
+  hiddenInputBrowserCacheDirective,
+} from "./directive/input";
+import { formDirective, ngFormDirective } from "./directive/form";
+import { scriptDirective } from "./directive/script";
+import { selectDirective, optionDirective } from "./directive/select";
+import {
+  ngBindDirective,
+  ngBindHtmlDirective,
+  ngBindTemplateDirective,
+} from "./directive/bind";
+import {
+  ngClassDirective,
+  ngClassEvenDirective,
+  ngClassOddDirective,
+} from "./directive/ngClass";
+import { ngCloakDirective } from "./directive/cloak";
+import { ngControllerDirective } from "./directive/ngController";
+import { ngHideDirective, ngShowDirective } from "./directive/ngShowHide";
+import { ngIfDirective } from "./directive/ngIf";
+import {
+  ngIncludeDirective,
+  ngIncludeFillContentDirective,
+} from "./directive/ngInclude";
+import { ngInitDirective } from "./directive/init";
+import { ngNonBindableDirective } from "./directive/non-bindable";
+import { ngRefDirective } from "./directive/ngRef";
+import { ngRepeatDirective } from "./directive/ngRepeat";
+import { ngStyleDirective } from "./directive/style";
+import {
+  ngSwitchDirective,
+  ngSwitchWhenDirective,
+  ngSwitchDefaultDirective,
+} from "./directive/ngSwitch";
+import { ngOptionsDirective } from "./directive/ngOptions";
+import { ngTranscludeDirective } from "./directive/ngTransclude";
+import { ngModelDirective } from "./directive/ngModel";
+import { ngListDirective } from "./directive/list";
+import { ngChangeDirective } from "./directive/change";
+import {
+  maxlengthDirective,
+  minlengthDirective,
+  patternDirective,
+  requiredDirective,
+} from "./directive/validators";
+import { ngModelOptionsDirective } from "./directive/ngModelOptions";
+import { ngAttributeAliasDirectives } from "./directive/attrs";
+import { ngEventDirectives } from "./directive/events";
+import { AnchorScrollProvider } from "./services/anchorScroll";
+import {
+  AnimateProvider,
+  CoreAnimateJsProvider,
+  CoreAnimateQueueProvider,
+} from "./core/animate";
+import { BrowserProvider } from "./services/browser";
+import { CoreAnimateCssProvider } from "./core/animateCss";
+import { CookieReaderProvider } from "./services/cookieReader";
+import {
+  AnimateAsyncRunFactoryProvider,
+  AnimateRunnerFactoryProvider,
+} from "./core/animateRunner";
+import {
+  CacheFactoryProvider,
+  TemplateCacheProvider,
+} from "./services/cacheFactory";
+import { $ControllerProvider } from "./core/controller";
+import {
+  $DocumentProvider,
+  $$IsDocumentHiddenProvider,
+} from "./services/document";
+import { $ExceptionHandlerProvider } from "./core/exceptionHandler";
+import { $FilterProvider } from "./core/filter";
+import { $IntervalProvider } from "./core/interval";
+import { $InterpolateProvider } from "./core/interpolate";
+import { $$IntervalFactoryProvider } from "./core/intervalFactory";
+import {
+  $HttpProvider,
+  $HttpParamSerializerProvider,
+  $HttpParamSerializerJQLikeProvider,
+} from "./services/http";
+import {
+  $HttpBackendProvider,
+  $xhrFactoryProvider,
+} from "./services/httpBackend";
+import { $LocationProvider } from "./core/location";
+import { $LogProvider } from "./services/log";
+import { $ParseProvider } from "./core/parser/parse";
+import { $RootScopeProvider } from "./core/rootScope";
+import { $QProvider, $$QProvider } from "./core/q";
+import { $SceProvider, $SceDelegateProvider } from "./core/sce";
+import { $$TaskTrackerFactoryProvider } from "./core/taskTrackerFactory";
+import { TemplateRequestProvider } from "./services/templateRequest";
+import { $TimeoutProvider } from "./core/timeout";
+import { SanitizeUriProvider } from "./core/sanitizeUri";
+import { setupModuleLoader } from "./loader";
+import { initAnimateModule } from "./animations/module";
+import { initMessageModule } from "./exts/messages";
+import { initAriaModule } from "./exts/aria";
+
+export function publishExternalAPI() {
+  const module = setupModuleLoader(window);
+  const ng = module(
+    "ng",
+    [],
+    [
+      "$provide",
+      function ngModule($provide) {
+        // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
+        $provide.provider({
+          $$sanitizeUri: SanitizeUriProvider,
+        });
+        $provide
+          .provider("$compile", $CompileProvider)
+          .directive({
+            a: htmlAnchorDirective,
+            input: inputDirective,
+            textarea: inputDirective,
+            form: formDirective,
+            script: scriptDirective,
+            select: selectDirective,
+            option: optionDirective,
+            ngBind: ngBindDirective,
+            ngBindHtml: ngBindHtmlDirective,
+            ngBindTemplate: ngBindTemplateDirective,
+            ngClass: ngClassDirective,
+            ngClassEven: ngClassEvenDirective,
+            ngClassOdd: ngClassOddDirective,
+            ngCloak: ngCloakDirective,
+            ngController: ngControllerDirective,
+            ngForm: ngFormDirective,
+            ngHide: ngHideDirective,
+            ngIf: ngIfDirective,
+            ngInclude: ngIncludeDirective,
+            ngInit: ngInitDirective,
+            ngNonBindable: ngNonBindableDirective,
+            ngRef: ngRefDirective,
+            ngRepeat: ngRepeatDirective,
+            ngShow: ngShowDirective,
+            ngStyle: ngStyleDirective,
+            ngSwitch: ngSwitchDirective,
+            ngSwitchWhen: ngSwitchWhenDirective,
+            ngSwitchDefault: ngSwitchDefaultDirective,
+            ngOptions: ngOptionsDirective,
+            ngTransclude: ngTranscludeDirective,
+            ngModel: ngModelDirective,
+            ngList: ngListDirective,
+            ngChange: ngChangeDirective,
+            pattern: patternDirective,
+            ngPattern: patternDirective,
+            required: requiredDirective,
+            ngRequired: requiredDirective,
+            ngMinlength: minlengthDirective,
+            minlength: minlengthDirective,
+            ngMaxlength: maxlengthDirective,
+            maxlength: maxlengthDirective,
+            ngValue: ngValueDirective,
+            ngModelOptions: ngModelOptionsDirective,
+          })
+          .directive({
+            ngInclude: ngIncludeFillContentDirective,
+            input: hiddenInputBrowserCacheDirective,
+          })
+          .directive(ngAttributeAliasDirectives)
+          .directive(ngEventDirectives);
+        $provide.provider({
+          $anchorScroll: AnchorScrollProvider,
+          $animate: AnimateProvider,
+          $animateCss: CoreAnimateCssProvider,
+          $$animateJs: CoreAnimateJsProvider,
+          $$animateQueue: CoreAnimateQueueProvider,
+          $$AnimateRunner: AnimateRunnerFactoryProvider,
+          $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
+          $browser: BrowserProvider,
+          $cacheFactory: CacheFactoryProvider,
+          $controller: $ControllerProvider,
+          $document: $DocumentProvider,
+          $$isDocumentHidden: $$IsDocumentHiddenProvider,
+          $exceptionHandler: $ExceptionHandlerProvider,
+          $filter: $FilterProvider,
+          $interpolate: $InterpolateProvider,
+          $interval: $IntervalProvider,
+          $$intervalFactory: $$IntervalFactoryProvider,
+          $http: $HttpProvider,
+          $httpParamSerializer: $HttpParamSerializerProvider,
+          $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
+          $httpBackend: $HttpBackendProvider,
+          $xhrFactory: $xhrFactoryProvider,
+          $location: $LocationProvider,
+          $log: $LogProvider,
+          $parse: $ParseProvider,
+          $rootScope: $RootScopeProvider,
+          $q: $QProvider,
+          $$q: $$QProvider,
+          $sce: $SceProvider,
+          $sceDelegate: $SceDelegateProvider,
+          $$taskTrackerFactory: $$TaskTrackerFactoryProvider,
+          $templateCache: TemplateCacheProvider,
+          $templateRequest: TemplateRequestProvider,
+          $timeout: $TimeoutProvider,
+          $$cookieReader: CookieReaderProvider,
+        });
+      },
+    ],
+  ).info({ angularVersion: '"NG_VERSION_FULL"' });
+
+  initAnimateModule();
+  initMessageModule();
+  initAriaModule();
+
+  return ng;
+}

package/src/routeToRegExp.js

@@ -0,0 +1,41 @@
+/**
+ * @param {string} path - The path to parse. (It is assumed to have query and hash stripped off.)
+ * @param {Object} opts - Options.
+ * @return {Object} - An object containing an array of path parameter names (`keys`) and a regular
+ *     expression (`regexp`) that can be used to identify a matching URL and extract the path
+ *     parameter values.
+ *
+ * @description
+ * Parses the given path, extracting path parameter names and a regular expression to match URLs.
+ *
+ * Originally inspired by `pathRexp` in `visionmedia/express/lib/utils.js`.
+ */
+export function routeToRegExp(path, opts) {
+  const keys = [];
+
+  let pattern = path
+    .replace(/([().])/g, "\\$1")
+    .replace(/(\/)?:(\w+)(\*\?|[?*])?/g, (_, slash, key, option) => {
+      const optional = option === "?" || option === "*?";
+      const star = option === "*" || option === "*?";
+      keys.push({ name: key, optional });
+      return (
+        (optional ? `(?:${slash || ""}` : `${slash || ""}(?:`) +
+        (star ? "(.+?)" : "([^/]+)") +
+        (optional ? "?)?" : ")")
+      );
+    })
+    .replace(/([/$*])/g, "\\$1");
+
+  if (opts.ignoreTrailingSlashes) {
+    pattern = `${pattern.replace(/\/+$/, "")}/*`;
+  }
+
+  return {
+    keys,
+    regexp: new RegExp(
+      `^${pattern}(?:[?#]|$)`,
+      opts.caseInsensitiveMatch ? "i" : "",
+    ),
+  };
+}

package/src/services/anchorScroll.js

@@ -0,0 +1,135 @@
+import {
+  isElement,
+  isFunction,
+  isNumber,
+  isString,
+  nodeName_,
+} from "../core/utils";
+
+export function AnchorScrollProvider() {
+  let autoScrollingEnabled = true;
+
+  this.disableAutoScrolling = () => {
+    autoScrollingEnabled = false;
+  };
+
+  this.$get = [
+    "$location",
+    "$rootScope",
+    /**
+     *
+     * @param {angular.IRootScopeService} $location
+     * @param {*} $rootScope
+     * @returns
+     */
+    function ($location, $rootScope) {
+      const { document } = window;
+
+      // Helper function to get first anchor from a NodeList
+      // (using `Array#some()` instead of `angular#forEach()` since it's more performant
+      //  and working in all supported browsers.)
+      function getFirstAnchor(list) {
+        let result = null;
+        Array.prototype.some.call(list, (element) => {
+          if (nodeName_(element) === "a") {
+            result = element;
+            return true;
+          }
+        });
+        return result;
+      }
+
+      function getYOffset() {
+        let offset = scroll.yOffset;
+
+        if (isFunction(offset)) {
+          offset = offset();
+        } else if (isElement(offset)) {
+          const elem = offset[0];
+          const style = window.getComputedStyle(elem);
+          if (style.position !== "fixed") {
+            offset = 0;
+          } else {
+            offset = elem.getBoundingClientRect().bottom;
+          }
+        } else if (!isNumber(offset)) {
+          offset = 0;
+        }
+
+        return offset;
+      }
+
+      function scrollTo(elem) {
+        if (elem) {
+          elem.scrollIntoView();
+
+          const offset = getYOffset();
+
+          if (offset) {
+            // `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
+            // This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
+            // top of the viewport.
+            //
+            // IF the number of pixels from the top of `elem` to the end of the page's content is less
+            // than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
+            // way down the page.
+            //
+            // This is often the case for elements near the bottom of the page.
+            //
+            // In such cases we do not need to scroll the whole `offset` up, just the difference between
+            // the top of the element and the offset, which is enough to align the top of `elem` at the
+            // desired position.
+            const elemTop = elem.getBoundingClientRect().top;
+            window.scrollBy(0, elemTop - offset);
+          }
+        } else {
+          window.scrollTo(0, 0);
+        }
+      }
+
+      function scroll(hash) {
+        // Allow numeric hashes
+        hash = isString(hash)
+          ? hash
+          : isNumber(hash)
+            ? hash.toString()
+            : $location.hash();
+        let elm;
+
+        // empty hash, scroll to the top of the page
+        if (!hash) scrollTo(null);
+        // element with given id
+        else if ((elm = document.getElementById(hash))) scrollTo(elm);
+        // first anchor with given name :-D
+        else if ((elm = getFirstAnchor(document.getElementsByName(hash))))
+          scrollTo(elm);
+        // no element and hash === 'top', scroll to the top of the page
+        else if (hash === "top") scrollTo(null);
+      }
+
+      // does not scroll when user clicks on anchor link that is currently on
+      // (no url change, no $location.hash() change), browser native does scroll
+      if (autoScrollingEnabled) {
+        $rootScope.$watch(
+          () => $location.hash(),
+          (newVal, oldVal) => {
+            // skip the initial scroll if $location.hash is empty
+            if (newVal === oldVal && newVal === "") return;
+
+            const action = () => $rootScope.$evalAsync(scroll);
+            if (window.document.readyState === "complete") {
+              // Force the action to be run async for consistent behavior
+              // from the action's point of view
+              // i.e. it will definitely not be in a $apply
+              window.setTimeout(() => action());
+            } else {
+              window.addEventListener("load", () => action());
+            }
+          },
+        );
+      }
+
+      return scroll;
+    },
+  ];
+}