@angular-wave/angular.ts 0.7.5 → 0.7.8

package/src/directive/transclude/transclude.js

@@ -18,107 +18,105 @@ import { emptyElement, startingTag } from "../../shared/dom.js";
  *                                               or its value is the same as the name of the attribute then the default slot is used.
  */
 const ngTranscludeMinErr = minErr("ngTransclude");
-export const ngTranscludeDirective = [
-  "$compile",
 
-  /**
-   * @param {import("../../core/compile/compile.js").CompileFn} $compile
-   * @returns {import("../../interface.ts").Directive}
-   */
-  function ($compile) {
-    return {
-      compile: function ngTranscludeCompile(tElement) {
-        // Remove and cache any original content to act as a fallback
-        const fallbackLinkFn = $compile(tElement.childNodes);
-        emptyElement(tElement);
+ngTranscludeDirective.$inject = ["$compile"];
+/**
+ * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @returns {import("../../interface.ts").Directive}
+ */
+export function ngTranscludeDirective($compile) {
+  return {
+    compile: function ngTranscludeCompile(tElement) {
+      // Remove and cache any original content to act as a fallback
+      const fallbackLinkFn = $compile(tElement.childNodes);
+      emptyElement(tElement);
 
-        /**
-         *
-         * @param {import("../../core/scope/scope.js").Scope} $scope
-         * @param {Element} $element
-         * @param {import("../../core/compile/attributes.js").Attributes} $attrs
-         * @param {*} _controller
-         * @param {*} $transclude
-         */
-        function ngTranscludePostLink(
-          $scope,
-          $element,
-          $attrs,
-          _controller,
-          $transclude,
-        ) {
-          if (!$transclude) {
-            throw ngTranscludeMinErr(
-              "orphan",
-              "Illegal use of ngTransclude directive in the template! " +
-                "No parent directive that requires a transclusion found. " +
-                "Element: {0}",
-              startingTag($element),
-            );
-          }
+      /**
+       *
+       * @param {import("../../core/scope/scope.js").Scope} $scope
+       * @param {Element} $element
+       * @param {import("../../core/compile/attributes.js").Attributes} $attrs
+       * @param {*} _controller
+       * @param {*} $transclude
+       */
+      function ngTranscludePostLink(
+        $scope,
+        $element,
+        $attrs,
+        _controller,
+        $transclude,
+      ) {
+        if (!$transclude) {
+          throw ngTranscludeMinErr(
+            "orphan",
+            "Illegal use of ngTransclude directive in the template! " +
+              "No parent directive that requires a transclusion found. " +
+              "Element: {0}",
+            startingTag($element),
+          );
+        }
 
-          // If the attribute is of the form: `ng-transclude="ng-transclude"` then treat it like the default
-          if ($attrs["ngTransclude"] === $attrs.$attr.ngTransclude) {
-            $attrs["ngTransclude"] = "";
-          }
-          const slotName = $attrs["ngTransclude"] || $attrs["ngTranscludeSlot"];
+        // If the attribute is of the form: `ng-transclude="ng-transclude"` then treat it like the default
+        if ($attrs["ngTransclude"] === $attrs.$attr.ngTransclude) {
+          $attrs["ngTransclude"] = "";
+        }
+        const slotName = $attrs["ngTransclude"] || $attrs["ngTranscludeSlot"];
 
-          // If the slot is required and no transclusion content is provided then this call will throw an error
-          $transclude(ngTranscludeCloneAttachFn, null, slotName);
+        // If the slot is required and no transclusion content is provided then this call will throw an error
+        $transclude(ngTranscludeCloneAttachFn, null, slotName);
 
-          // If the slot is optional and no transclusion content is provided then use the fallback content
-          if (slotName && !$transclude.isSlotFilled(slotName)) {
-            useFallbackContent();
-          }
+        // If the slot is optional and no transclusion content is provided then use the fallback content
+        if (slotName && !$transclude.isSlotFilled(slotName)) {
+          useFallbackContent();
+        }
 
-          /**
-           * @param {NodeList | Node} clone
-           * @param {import("../../core/scope/scope.js").Scope} transcludedScope
-           */
-          function ngTranscludeCloneAttachFn(clone, transcludedScope) {
-            if (notWhitespace(clone)) {
-              if (clone instanceof NodeList) {
-                Array.from(clone).forEach((el) => {
-                  $element.append(el);
-                });
-              } else {
-                $element.append(/** @type {Node} */ (clone));
-              }
+        /**
+         * @param {NodeList | Node} clone
+         * @param {import("../../core/scope/scope.js").Scope} transcludedScope
+         */
+        function ngTranscludeCloneAttachFn(clone, transcludedScope) {
+          if (notWhitespace(clone)) {
+            if (clone instanceof NodeList) {
+              Array.from(clone).forEach((el) => {
+                $element.append(el);
+              });
             } else {
-              useFallbackContent();
-              // There is nothing linked against the transcluded scope since no content was available,
-              // so it should be safe to clean up the generated scope.
-              transcludedScope.$destroy();
+              $element.append(/** @type {Node} */ (clone));
             }
+          } else {
+            useFallbackContent();
+            // There is nothing linked against the transcluded scope since no content was available,
+            // so it should be safe to clean up the generated scope.
+            transcludedScope.$destroy();
           }
+        }
 
-          function useFallbackContent() {
-            // Since this is the fallback content rather than the transcluded content,
-            // we link against the scope of this directive rather than the transcluded scope
-            fallbackLinkFn(
-              $scope,
+        function useFallbackContent() {
+          // Since this is the fallback content rather than the transcluded content,
+          // we link against the scope of this directive rather than the transcluded scope
+          fallbackLinkFn(
+            $scope,
 
-              (clone) => {
-                // @ts-ignore
-                $element.append(clone);
-              },
-            );
-          }
+            (clone) => {
+              // @ts-ignore
+              $element.append(clone);
+            },
+          );
+        }
 
-          function notWhitespace(node) {
-            if (node instanceof Array) {
-              return false;
-            } else if (
-              node.nodeType !== Node.TEXT_NODE ||
-              node.nodeValue.trim()
-            ) {
-              return true;
-            }
+        function notWhitespace(node) {
+          if (node instanceof Array) {
+            return false;
+          } else if (
+            node.nodeType !== Node.TEXT_NODE ||
+            node.nodeValue.trim()
+          ) {
+            return true;
           }
         }
+      }
 
-        return ngTranscludePostLink;
-      },
-    };
-  },
-];
+      return ngTranscludePostLink;
+    },
+  };
+}

package/src/injection-tokens.js

@@ -30,7 +30,7 @@ export const $injectTokens = Object.freeze({
   $animate: "$animate",
   $animateCss: "$animateCss",
   $aria: "$aria",
-  $browser: "$browser",
+  $compile: "$compile",
   $controller: "$controller",
   $eventBus: "$eventBus",
   $exceptionHandler: "$exceptionHandler",

package/src/interface.ts

@@ -1,5 +1,6 @@
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
+export * from "./core/di/ng-module.js";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
@@ -62,47 +63,66 @@ export interface ServiceProvider {
  * services, factories, constants, values, decorators, etc.
  */
 export interface Provider {
+  /**
+   * Register a directive
+   * @param name - The name of the directive.
+   * @param provider - An object with a `$get` property that defines how the service is created.
+   */
+  directive(name: string, directive: DirectiveFactory): Provider;
+
+  /**
+   * Register multiple directives
+   * @param obj
+   */
+  directive(obj: Record<string, DirectiveFactory>): Provider;
+
   /**
    * Register a service provider.
    * @param name - The name of the service.
    * @param provider - An object with a `$get` property that defines how the service is created.
    */
-  provider(name: string, provider: ServiceProvider): ServiceProvider;
+  provider(name: string, provider: Function): Provider;
+
+  /**
+   * Register multiple service providers
+   * @param obj
+   */
+  provider(obj: Record<string, Function>): Provider;
 
   /**
    * Register a factory function to create a service.
    * @param name - The name of the service.
    * @param factoryFn - A function (or annotated array) that returns the service instance.
    */
-  factory(name: string, factoryFn: Injectable): ServiceProvider;
+  factory(name: string, factoryFn: Injectable): Provider;
 
   /**
    * Register a constructor function to create a service.
    * @param name - The name of the service.
    * @param constructor - A class or function to instantiate.
    */
-  service(name: string, constructor: Injectable): ServiceProvider;
+  service(name: string, constructor: Injectable): Provider;
 
   /**
    * Register a fixed value as a service.
    * @param name - The name of the service.
    * @param val - The value to use.
    */
-  value(name: string, val: any): ServiceProvider;
+  value(name: string, val: any): Provider;
 
   /**
    * Register a constant value (available during config).
    * @param name - The name of the constant.
    * @param val - The constant value.
    */
-  constant(name: string, val: any): void;
+  constant(name: string, val: any): Provider;
 
   /**
    * Register a decorator function to modify or replace an existing service.
    * @param name - The name of the service to decorate.
    * @param fn - A function that takes `$delegate` and returns a decorated service.
    */
-  decorator(name: string, fn: Injectable): void;
+  decorator(name: string, fn: Function): Provider;
 }
 
 /**
@@ -247,15 +267,19 @@ export interface Directive {
   /** Template URL for loading from server */
   templateUrl?: string | ((element: Element, attrs: Attributes) => string);
   /** Enables transclusion or configures named slots */
-  transclude?: boolean | "element" | Record<string, string>;
+  transclude?: boolean | string | Record<string, string>;
   /** Internal hook for directive compilation state */
   $$addStateInfo?: (...args: any[]) => any;
+  count?: number;
 }
 
-/**
- * A factory function returning a directive definition.
- */
-export type DirectiveFactory = (...args: any[]) => Directive | DirectiveLinkFn;
+export type DirectiveFactoryFn = (
+  ...args: any[]
+) => Directive | DirectiveLinkFn;
+
+export type AnnotatedDirectiveFactory = Array<string | DirectiveFactoryFn>;
+
+export type DirectiveFactory = DirectiveFactoryFn | AnnotatedDirectiveFactory;
 
 /**
  * Represents advanced transclusion functions used in directives.
@@ -339,14 +363,39 @@ export interface NgModelController {
   /** Current value shown in the view */
   $viewValue: any;
 }
-
 /**
  * Possible values for `data-swap` attribute
  */
-export type SwapInsertPosition =
-  | InsertPosition
-  | "textContent"
-  | "innerHTML"
-  | "outerHTML"
-  | "delete"
-  | "none";
+export const SwapMode = {
+  /** (default) Replaces the contents inside the element */
+  innerHTML: "innerHTML",
+
+  /** Replaces the entire element, including the tag itself */
+  outerHTML: "outerHTML",
+
+  /** Inserts plain text (without parsing HTML) */
+  textContent: "textContent",
+
+  /** Inserts HTML immediately before the element itself */
+  beforebegin: "beforebegin",
+
+  /** Inserts HTML inside the element, before its first child */
+  afterbegin: "afterbegin",
+
+  /** Inserts HTML inside the element, after its last child */
+  beforeend: "beforeend",
+
+  /** Inserts HTML immediately after the element itself */
+  afterend: "afterend",
+
+  /** Removes the element entirely */
+  delete: "delete",
+
+  /** Performs no insertion (no-op) */
+  none: "none",
+} as const;
+
+/**
+ * Union type representing all possible DOM insertion modes.
+ */
+export type SwapModeType = keyof typeof SwapMode;

package/src/loader.js

@@ -1,10 +1,10 @@
 import {
-  minErr,
-  getNgAttribute,
-  ngAttrPrefixes,
   assertNotHasOwnProperty,
   errorHandlingConfig,
+  getNgAttribute,
   hasOwn,
+  minErr,
+  ngAttrPrefixes,
 } from "./shared/utils.js";
 import {
   getController,
@@ -283,12 +283,7 @@ export class Angular {
           name,
         );
       }
-      const moduleInstance = new NgModule(
-        name,
-        requires,
-        /** @type {Function} */ (configFn),
-      );
-      return moduleInstance;
+      return new NgModule(name, requires, /** @type {Function} */ (configFn));
     });
   }
 }

package/src/public.js

@@ -1,12 +1,12 @@
 import { CompileProvider } from "./core/compile/compile.js";
 import {
+  hiddenInputBrowserCacheDirective,
   inputDirective,
   ngValueDirective,
-  hiddenInputBrowserCacheDirective,
 } from "./directive/input/input.js";
 import { formDirective, ngFormDirective } from "./directive/form/form.js";
 import { scriptDirective } from "./directive/script/script.js";
-import { selectDirective, optionDirective } from "./directive/select/select.js";
+import { optionDirective, selectDirective } from "./directive/select/select.js";
 import {
   ngBindDirective,
   ngBindHtmlDirective,
@@ -34,9 +34,9 @@ import { ngRefDirective } from "./directive/ref/ref.js";
 import { ngRepeatDirective } from "./directive/repeat/repeat.js";
 import { ngStyleDirective } from "./directive/style/style.js";
 import {
+  ngSwitchDefaultDirective,
   ngSwitchDirective,
   ngSwitchWhenDirective,
-  ngSwitchDefaultDirective,
 } from "./directive/switch/switch.js";
 import { ngOptionsDirective } from "./directive/options/options.js";
 import { ngTranscludeDirective } from "./directive/transclude/transclude.js";
@@ -52,27 +52,25 @@ import { ngAttributeAliasDirectives } from "./directive/attrs/attrs.js";
 import { ngEventDirectives } from "./directive/events/events.js";
 import { AnchorScrollProvider } from "./services/anchor-scroll.js";
 import { AnimateProvider } from "./animations/animate.js";
-import { BrowserProvider } from "./services/browser.js";
 import {
   AnimateAsyncRunFactoryProvider,
   AnimateRunnerFactoryProvider,
 } from "./animations/animate-runner.js";
 import { TemplateCacheProvider } from "./services/template-cache/template-cache.js";
 import { ControllerProvider } from "./core/controller/controller.js";
-import { ExceptionHandlerProvider } from "./core/exception-handler.js";
+import { ExceptionHandlerProvider } from "./services/exception/exception-handler.js";
 import { FilterProvider } from "./core/filter/filter.js";
 import { InterpolateProvider } from "./core/interpolate/interpolate.js";
 import {
-  HttpProvider,
   HttpParamSerializerProvider,
+  HttpProvider,
 } from "./services/http/http.js";
 import { HttpBackendProvider } from "./services/http-backend/http-backend.js";
-import { LocationProvider } from "./core/location/location.js";
+import { LocationProvider } from "./services/location/location.js";
 import { LogProvider } from "./services/log/log.js";
 import { ParseProvider } from "./core/parse/parse.js";
 import { RootScopeProvider } from "./core/scope/scope.js";
-import { SceProvider, SceDelegateProvider } from "./core/sce/sce.js";
-import { TaskTrackerFactoryProvider } from "./core/task-tracker-factory.js";
+import { SceDelegateProvider, SceProvider } from "./services/sce/sce.js";
 import { TemplateRequestProvider } from "./services/template-request.js";
 import { SanitizeUriProvider } from "./core/sanitize/sanitize-uri.js";
 import {
@@ -141,13 +139,13 @@ import {
  * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
  */
 export function registerNgModule(angular) {
-  const ng = angular
+  return angular
     .module(
       "ng",
       [],
       [
         "$provide",
-        /** @type {import('./interface.js').Provider} */
+        /** @param {import("./interface.js").Provider} $provide */
         ($provide) => {
           // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
           $provide.provider({
@@ -248,7 +246,6 @@ export function registerNgModule(angular) {
             $$animateQueue: AnimateQueueProvider,
             $$AnimateRunner: AnimateRunnerFactoryProvider,
             $$animateAsyncRun: AnimateAsyncRunFactoryProvider,
-            $browser: BrowserProvider,
             $controller: ControllerProvider,
             $exceptionHandler: ExceptionHandlerProvider,
             $filter: FilterProvider,
@@ -264,7 +261,6 @@ export function registerNgModule(angular) {
             $routerGlobals: RouterGlobals,
             $sce: SceProvider,
             $sceDelegate: SceDelegateProvider,
-            $$taskTrackerFactory: TaskTrackerFactoryProvider,
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $urlConfig: UrlConfigProvider,
@@ -291,6 +287,4 @@ export function registerNgModule(angular) {
       },
     ])
     .value("$trace", trace);
-
-  return ng;
 }

package/src/router/common/glob.js

@@ -83,6 +83,11 @@ export class Glob {
      */
     this.regexp = new RegExp("^" + regexpString + "$");
   }
+
+  /**
+   * @param {string} name
+   * @return {boolean}
+   */
   matches(name) {
     return this.regexp.test("." + name);
   }

package/src/router/directives/state-directives.js

@@ -382,12 +382,10 @@ export function $StateRefActiveDirective(
         const removeClasses = allClasses.filter(
           (cls) => !addClasses.includes(cls),
         );
-        $scope.$evalAsync(() => {
-          addClasses.forEach((className) => $element.classList.add(className));
-          removeClasses.forEach((className) =>
-            $element.classList.remove(className),
-          );
-        });
+        addClasses.forEach((className) => $element.classList.add(className));
+        removeClasses.forEach((className) =>
+          $element.classList.remove(className),
+        );
       }
       update();
     },

package/src/router/directives/state-directives.spec.js

@@ -26,7 +26,7 @@ describe("ngStateRef", () => {
     module.config(
       /**
        * @param $stateProvider
-       * @param {import('../../core/location/location.js').LocationProvider} $locationProvider
+       * @param {import('../../services/location/location.js').LocationProvider} $locationProvider
        */
       ($stateProvider, $locationProvider) => {
         _locationProvider = $locationProvider;

package/src/router/directives/view-directive.js

@@ -143,11 +143,20 @@ import { getLocals } from "../state/state-registry.js";
  * });
  * ```
  */
+
+/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
 export let ngView = [
   "$view",
   "$animate",
   "$ngViewScroll",
   "$interpolate",
+  /**
+   * @param {*} $view
+   * @param {*} $animate
+   * @param {*} $ngViewScroll
+   * @param {*} $interpolate
+   * @returns {import("../../interface.js").Directive}
+   */
   function $ViewDirective($view, $animate, $ngViewScroll, $interpolate) {
     function getRenderer() {
       return {
@@ -178,7 +187,6 @@ export let ngView = [
     };
     const directive = {
       count: 0,
-
       terminal: true,
       priority: 400,
       transclude: "element",

package/src/router/globals.js

@@ -8,7 +8,6 @@ import { Queue } from "./common/queue.js";
  *
  * This is where we hold the global mutable state such as current state, current
  * params, current transition, etc.
- * @implements {ServiceProvider}
  */
 export class RouterGlobals {
   constructor() {

package/src/router/state/state-registry.js

@@ -14,7 +14,6 @@ import { $injectTokens, provider } from "../../injection-tokens.js";
  *
  * This API is found at `$stateRegistry` ([[UIRouter.stateRegistry]])
  *
- * @implements {ServiceProvider}
  */
 export class StateRegistryProvider {
   static $inject = provider([

package/src/router/state-filters.js

@@ -16,7 +16,7 @@ export function $IsStateFilter($state) {
   const isFilter = function (state, params, options) {
     return $state.is(state, params, options);
   };
-  //isFilter.$stateful = true;
+  isFilter.$stateful = true;
   return isFilter;
 }
 /**
@@ -37,6 +37,6 @@ export function $IncludedByStateFilter($state) {
   const includesFilter = function (state, params, options) {
     return $state.includes(state, params, options);
   };
-  //includesFilter.$stateful = true;
+  includesFilter.$stateful = true;
   return includesFilter;
 }

package/src/router/url/url-service.js

@@ -12,6 +12,7 @@ import { stripLastPathElement } from "../../shared/strings.js";
 import { UrlMatcher } from "./url-matcher.js";
 import { ParamFactory } from "../params/param-factory.js";
 import { UrlRuleFactory } from "./url-rule.js";
+import { getBaseHref } from "../../shared/dom.js";
 
 /**
  * API for URL management
@@ -25,7 +26,7 @@ export class UrlService {
   ];
 
   /**
-   * @param {import("../../core/location/location").LocationProvider} $locationProvider
+   * @param {import("../../services/location/location").LocationProvider} $locationProvider
    * @param {import("../../router/state/state-service.js").StateProvider} stateService
    * @param globals
    * @param {import("../../router/url/url-config.js").UrlConfigProvider} urlConfigProvider
@@ -34,9 +35,7 @@ export class UrlService {
     this.stateService = stateService;
     this.stateService.urlService = this; // circular wiring
     this.$locationProvider = $locationProvider;
-
     this.$location = undefined;
-    this.$browser = undefined;
 
     /** Provides services related to the URL */
     this.urlRuleFactory = new UrlRuleFactory(this, this.stateService, globals);
@@ -89,18 +88,15 @@ export class UrlService {
 
   $get = [
     "$location",
-    "$browser",
     "$rootScope",
     /**
      *
-     * @param {import('../../core/location/location.js').Location} $location
-     * @param {import('../../services/browser.js').Browser} $browser
+     * @param {import('../../services/location/location.js').Location} $location
      * @param {import('../../core/scope/scope.js').Scope} $rootScope
      * @returns {UrlService}
      */
-    ($location, $browser, $rootScope) => {
+    ($location, $rootScope) => {
       this.$location = $location;
-      this.$browser = $browser;
       $rootScope.$on("$locationChangeSuccess", (evt) => {
         this._urlListeners.forEach((fn) => {
           fn(evt);
@@ -124,7 +120,7 @@ export class UrlService {
   baseHref() {
     return (
       this._baseHref ||
-      (this._baseHref = this.$browser.baseHref() || window.location.pathname)
+      (this._baseHref = getBaseHref() || window.location.pathname)
     );
   }
 

package/src/services/anchor-scroll.html

@@ -3,14 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <title>AngularTS Test Runner</title>
-
     <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
-
-    <!--     
-    <script src="https://cdn.jsdelivr.net/npm/angular@1.8.3/angular.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/angular-animate@1.8.3/angular-animate.js"></script>
-    <script>window.angular.module("test", [])</script> -->
-
     <script type="module" src="/src/index.js"></script>
     <script>
       document.addEventListener("DOMContentLoaded", () => {