@angular-wave/angular.ts 0.8.4 → 0.9.1

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

@@ -2,7 +2,7 @@ import { createElementFromHTML, dealoc } from "../../shared/dom.js";
 import { Angular } from "../../angular.js";
 import { wait } from "../../shared/test-utils.js";
 
-fdescribe("ngView", () => {
+describe("ngView", () => {
   window.location.hash = "";
   let $stateProvider,
     scope,
@@ -799,7 +799,7 @@ fdescribe("ngView", () => {
   // });
 });
 
-fdescribe("ngView named", () => {
+describe("ngView named", () => {
   let $stateProvider,
     scope,
     $compile,
@@ -873,7 +873,7 @@ fdescribe("ngView named", () => {
   });
 });
 
-fdescribe("ngView transclusion", () => {
+describe("ngView transclusion", () => {
   let scope, $compile, elem, $injector, $rootScope, $state;
 
   beforeEach(() => {
@@ -929,7 +929,7 @@ fdescribe("ngView transclusion", () => {
   });
 });
 
-fdescribe("ngView controllers or onEnter handlers", () => {
+describe("ngView controllers or onEnter handlers", () => {
   let el, template, scope, count, $rootScope, $compile, $state, elem;
 
   beforeEach(() => {
@@ -1006,7 +1006,7 @@ fdescribe("ngView controllers or onEnter handlers", () => {
   });
 });
 
-fdescribe("angular 1.5+ style .component()", () => {
+describe("angular 1.5+ style .component()", () => {
   let el = document.getElementById("app"),
     app,
     scope,
@@ -1112,8 +1112,9 @@ fdescribe("angular 1.5+ style .component()", () => {
           };
         },
       })
-      .config(function (_$stateProvider_) {
+      .config(function (_$stateProvider_, $locationProvider) {
         $stateProvider = _$stateProvider_;
+        $locationProvider.html5ModeConf.enabled = false;
       });
 
     let $injector = window.angular.bootstrap(document.getElementById("app"), [
@@ -1835,9 +1836,9 @@ fdescribe("angular 1.5+ style .component()", () => {
         name: "ng12-dynamic-directive",
         url: "/ng12dynamicDirective/:type",
         componentProvider: [
-          "$router",
-          function ($router) {
-            return $router.params.type;
+          "$stateParams",
+          function ($stateParams) {
+            return $stateParams.type;
           },
         ],
       });

package/src/router/resolve/resolve-context.js

@@ -155,10 +155,6 @@ export class ResolveContext {
     return Promise.all(promises);
   }
 
-  injector() {
-    return this._injector || (this._injector = new UIInjectorImpl());
-  }
-
   findNode(resolvable) {
     return find(this._path, (node) => node.resolvables.includes(resolvable));
   }
@@ -192,18 +188,3 @@ export class ResolveContext {
     });
   }
 }
-
-class UIInjectorImpl {
-  constructor() {
-    this.native = window["angular"].$injector;
-  }
-  get(token) {
-    return window["angular"].$injector.get(token);
-  }
-  getAsync(token) {
-    return Promise.resolve(window["angular"].$injector.get(token));
-  }
-  getNative(token) {
-    return window["angular"].$injector.get(token);
-  }
-}

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

@@ -6,7 +6,7 @@ import { propEq } from "../../shared/hof.js";
 import { ResolveContext } from "../resolve/resolve-context.js";
 import { ng1ViewsBuilder } from "./views.js";
 import { isString } from "../../shared/utils.js";
-import { $injectTokens, provider } from "../../injection-tokens.js";
+import { $injectTokens as $t, provider } from "../../injection-tokens.js";
 
 /** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
 /**
@@ -16,12 +16,7 @@ import { $injectTokens, provider } from "../../injection-tokens.js";
  *
  */
 export class StateRegistryProvider {
-  /* @ignore */ static $inject = provider([
-    $injectTokens.$url,
-    $injectTokens.$state,
-    $injectTokens.$router,
-    $injectTokens.$view,
-  ]);
+  static $inject = provider([$t.$url, $t.$state, $t.$router, $t.$view]);
 
   /**
    * @param urlService
@@ -60,11 +55,9 @@ export class StateRegistryProvider {
     globals.current = globals.$current.self;
   }
 
-  /** @type {import('../../interface.ts').AnnotatedFactory} */
   $get = [
-    "$injector",
+    $t.$injector,
     /**
-     *
      * @param {import("../../core/di/internal-injector").InjectorService} $injector
      * @returns {StateRegistryProvider}
      */

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

@@ -14,7 +14,6 @@ import { Rejection, RejectType } from "../transition/reject-factory.js";
 import { TargetState } from "./target-state.js";
 import { Param } from "../params/param.js";
 import { Glob } from "../glob/glob.js";
-import { ResolveContext } from "../resolve/resolve-context.js";
 import { lazyLoadState } from "../hooks/lazy-load.js";
 import { val } from "../../shared/hof.js";
 import { EventBus } from "../../services/pubsub/pubsub.js";
@@ -52,19 +51,20 @@ export class StateProvider {
     return this.globals.$current;
   }
 
-  /* @ignore */ static $inject = ["$routerProvider", "$transitionsProvider"];
+  static $inject = ["$routerProvider", "$transitionsProvider"];
 
-  // Needs access to urlService, stateRegistry
   /**
    *
    * @param {import('../router.js').Router} globals
    * @param {*} transitionService
+   * @param {import('../../core/di/internal-injector.js').InjectorService} $injector
    */
-  constructor(globals, transitionService) {
+  constructor(globals, transitionService, $injector) {
     this.stateRegistry = undefined;
     this.urlService = undefined;
     this.globals = globals;
     this.transitionService = transitionService;
+    this.$injector = $injector;
     this.invalidCallbacks = [];
 
     this._defaultErrorHandler = function $defaultErrorHandler($error$) {
@@ -221,7 +221,7 @@ export class StateProvider {
     const latest = latestThing();
     /** @type {Queue<Function>} */
     const callbackQueue = new Queue(this.invalidCallbacks.slice());
-    const injector = new ResolveContext(fromPath).injector();
+    const injector = this.$injector;
     const checkForRedirect = (result) => {
       if (!(result instanceof TargetState)) {
         return;

package/src/router/transition/transition.js

@@ -8,8 +8,6 @@ import {
   arrayTuples,
   unnestR,
   anyTrueR,
-  flattenR,
-  uniqR,
 } from "../../shared/common.js";
 import { isUndefined, isObject, assert } from "../../shared/utils.js";
 import { propEq, val, is } from "../../shared/hof.js";
@@ -184,90 +182,7 @@ export class Transition {
         .reduce((acc, obj) => ({ ...acc, ...obj }), {}),
     );
   }
-  paramsChanged() {
-    const fromParams = this.params("from");
-    const toParams = this.params("to");
-    // All the parameters declared on both the "to" and "from" paths
-    const allParamDescriptors = []
-      .concat(this._treeChanges.to)
-      .concat(this._treeChanges.from)
-      .map((pathNode) => pathNode.paramSchema)
-      .reduce(flattenR, [])
-      .reduce(uniqR, []);
-    const changedParamDescriptors = Param.changed(
-      allParamDescriptors,
-      fromParams,
-      toParams,
-    );
-    return changedParamDescriptors.reduce((changedValues, descriptor) => {
-      changedValues[descriptor.id] = toParams[descriptor.id];
-      return changedValues;
-    }, {});
-  }
-  /**
-   * Creates a [[UIInjector]] Dependency Injector
-   *
-   * Returns a Dependency Injector for the Transition's target state (to state).
-   * The injector provides resolve values which the target state has access to.
-   *
-   * The `UIInjector` can also provide values from the native root/global injector (ng1/ng2).
-   *
-   * #### Example:
-   * ```js
-   * .onEnter({ entering: 'myState' }, trans => {
-   *   var myResolveValue = trans.injector().get('myResolve');
-   *   // Inject a global service from the global/native injector (if it exists)
-   *   var MyService = trans.injector().get('MyService');
-   * })
-   * ```
-   *
-   * In some cases (such as `onBefore`), you may need access to some resolve data but it has not yet been fetched.
-   * You can use [[UIInjector.getAsync]] to get a promise for the data.
-   * #### Example:
-   * ```js
-   * .onBefore({}, trans => {
-   *   return trans.injector().getAsync('myResolve').then(myResolveValue =>
-   *     return myResolveValue !== 'ABORT';
-   *   });
-   * });
-   * ```
-   *
-   * If a `state` is provided, the injector that is returned will be limited to resolve values that the provided state has access to.
-   * This can be useful if both a parent state `foo` and a child state `foo.bar` have both defined a resolve such as `data`.
-   * #### Example:
-   * ```js
-   * .onEnter({ to: 'foo.bar' }, trans => {
-   *   // returns result of `foo` state's `myResolve` resolve
-   *   // even though `foo.bar` also has a `myResolve` resolve
-   *   var fooData = trans.injector('foo').get('myResolve');
-   * });
-   * ```
-   *
-   * If you need resolve data from the exiting states, pass `'from'` as `pathName`.
-   * The resolve data from the `from` path will be returned.
-   * #### Example:
-   * ```js
-   * .onExit({ exiting: 'foo.bar' }, trans => {
-   *   // Gets the resolve value of `myResolve` from the state being exited
-   *   var fooData = trans.injector(null, 'from').get('myResolve');
-   * });
-   * ```
-   *
-   *
-   * @param state Limits the resolves provided to only the resolves the provided state has access to.
-   * @param pathName Default: `'to'`: Chooses the path for which to create the injector. Use this to access resolves for `exiting` states.
-   *
-   * @returns a [[UIInjector]]
-   */
-  injector(state, pathName = "to") {
-    let path = this._treeChanges[pathName];
-    if (state)
-      path = PathUtils.subPath(
-        path,
-        (node) => node.state === state || node.state.name === state,
-      );
-    return new ResolveContext(path).injector();
-  }
+
   /**
    * Gets all available resolve tokens (keys)
    *

package/src/router/view-hook.spec.js

@@ -174,7 +174,7 @@ describe("view hooks", () => {
       ctrl.prototype.uiCanExit = function (trans) {
         log += "canexit;";
         expect(typeof trans.treeChanges).toBe("function");
-        expect(trans.injector().get("$state")).toBe(_state);
+        // expect(trans.injector().get("$state")).toBe(_state);
       };
       await initial();
 

package/src/shared/interface.ts

@@ -1,2 +1,21 @@
 export type Predicate<X> = (x?: X) => boolean;
 export type PredicateBinary<X, Y> = (x?: X, y?: Y) => boolean;
+
+/**
+ * Error configuration object. May only contain the options that need to be updated.
+ */
+export interface ErrorHandlingConfig {
+  /**
+   * The max depth for stringifying objects.
+   * Setting to a non-positive or non-numeric value removes the max depth limit.
+   * Default: 5.
+   */
+  objectMaxDepth?: number;
+
+  /**
+   * Specifies whether the generated error URL will contain the parameters
+   * of the thrown error. Default: true.
+   * When used without argument, it returns the current value.
+   */
+  urlErrorParamsEnabled?: boolean;
+}

package/src/shared/utils.js

@@ -970,16 +970,7 @@ export function assertArgFn(arg, name, acceptArrayAnnotation) {
   return arg;
 }
 
-/**
- * @typedef {Object} ErrorHandlingConfig
- * Error configuration object. May only contain the options that need to be updated.
- * @property {number=} objectMaxDepth - The max depth for stringifying objects. Setting to a
- *   non-positive or non-numeric value removes the max depth limit. Default: 5.
- * @property {boolean=} urlErrorParamsEnabled - Specifies whether the generated error URL will
- *   contain the parameters of the thrown error. Default: true. When used without argument, it returns the current value.
- */
-
-/** @type {ErrorHandlingConfig} */
+/** @type {import("./interface.js").ErrorHandlingConfig} */
 const minErrConfig = {
   objectMaxDepth: 5,
   urlErrorParamsEnabled: true,
@@ -991,8 +982,8 @@ const minErrConfig = {
  *
  * Omitted or undefined options will leave the corresponding configuration values unchanged.
  *
- * @param {ErrorHandlingConfig} [config]
- * @returns {ErrorHandlingConfig}
+ * @param {import("./interface.ts").ErrorHandlingConfig} [config]
+ * @returns {import("./interface.ts").ErrorHandlingConfig}
  */
 export function errorHandlingConfig(config) {
   if (isObject(config)) {

package/tsconfig.types.json

@@ -9,6 +9,6 @@
     "outDir": "@types",
     "target": "ES2023"
   },
-  "include": ["src"],
-  "exclude": ["./node_modules/@types/**", "**/*.test.js", "**/*.spec.js"]
+  "include": ["src/interface.ts"],
+  "exclude": ["**/*.test.js", "**/*.spec.js"]
 }

package/@types/angular.d.ts

@@ -1,150 +0,0 @@
-/**
- * Configuration option for AngularTS bootstrap process.
- *
- * @typedef {Object} AngularBootstrapConfig
- * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
- */
-export class Angular {
-  $cache: Map<number, import("./interface.ts").ExpandoStore>;
-  /** @type {import('./services/pubsub/pubsub.js').PubSub} */
-  $eventBus: import("./services/pubsub/pubsub.js").PubSub;
-  /**
-   * @type {string} `version` from `package.json`
-   */
-  version: string;
-  /** @type {!Array<string|any>} */
-  bootsrappedModules: Array<string | any>;
-  getController: typeof getController;
-  getInjector: typeof getInjector;
-  getScope: typeof getScope;
-  errorHandlingConfig: typeof errorHandlingConfig;
-  $t: Readonly<Record<string, string>>;
-  /**
-   * Use this function to manually start up AngularTS application.
-   *
-   * AngularTS will detect if it has been loaded into the browser more than once and only allow the
-   * first loaded script to be bootstrapped and will report a warning to the browser console for
-   * each of the subsequent scripts. This prevents strange results in applications, where otherwise
-   * multiple instances of AngularTS try to work on the DOM.
-   *   *
-   * <div class="alert alert-warning">
-   * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
-   * such as {@link ng.ngIf `ngIf`}, {@link ng.ngInclude `ngInclude`} and {@link ngRoute.ngView `ngView`}.
-   * Doing this misplaces the app {@link ng.$rootElement `$rootElement`} and the app's {@link auto.$injector injector},
-   * causing animations to stop working and making the injector inaccessible from outside the app.
-   * </div>
-   *
-   * ```html
-   * <!doctype html>
-   * <html>
-   * <body>
-   * <div ng-controller="WelcomeController">
-   *   {{greeting}}
-   * </div>
-   *
-   * <script src="angular.js"></script>
-   * <script>
-   *   let app = angular.module('demo', [])
-   *   .controller('WelcomeController', function($scope) {
-   *       $scope.greeting = 'Welcome!';
-   *   });
-   *   angular.bootstrap(document, ['demo']);
-   * </script>
-   * </body>
-   * </html>
-   * ```
-   *
-   * @param {string | Element | Document} element DOM element which is the root of AngularTS application.
-   * @param {Array<String|any>} [modules] an array of modules to load into the application.
-   *     Each item in the array should be the name of a predefined module or a (DI annotated)
-   *     function that will be invoked by the injector as a `config` block.
-   *     See: {@link angular.module modules}
-   * @param {AngularBootstrapConfig} [config]
-   * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
-   */
-  bootstrap(
-    element: string | Element | Document,
-    modules?: Array<string | any>,
-    config?: AngularBootstrapConfig,
-  ): import("./core/di/internal-injector.js").InjectorService;
-  $injector: import("./core/di/internal-injector.js").InjectorService;
-  /**
-   * @param {any[]} modules
-   * @param {boolean?} strictDi
-   * @returns {import("./core/di/internal-injector.js").InjectorService}
-   */
-  injector(
-    modules: any[],
-    strictDi: boolean | null,
-  ): import("./core/di/internal-injector.js").InjectorService;
-  /**
-   * @param {Element|Document} element
-   */
-  init(element: Element | Document): void;
-  /**
-   *
-   * The `angular.module` is a global place for creating, registering and retrieving AngularTS
-   * modules.
-   * All modules (AngularTS core or 3rd party) that should be available to an application must be
-   * registered using this mechanism.
-   *
-   * Passing one argument retrieves an existing {@link import('./interface.ts').Module},
-   * whereas passing more than one argument creates a new {@link import('./interface.ts').Module}
-   *
-   *
-   * # Module
-   *
-   * A module is a collection of services, directives, controllers, filters, and configuration information.
-   * `angular.module` is used to configure the {@link auto.$injector $injector}.
-   *
-   * ```js
-   * // Create a new module
-   * let myModule = angular.module('myModule', []);
-   *
-   * // register a new service
-   * myModule.value('appName', 'MyCoolApp');
-   *
-   * // configure existing services inside initialization blocks.
-   * myModule.config(['$locationProvider', function($locationProvider) {
-   *   // Configure existing providers
-   *   $locationProvider.hashPrefix('!');
-   * }]);
-   * ```
-   *
-   * Then you can create an injector and load your modules like this:
-   *
-   * ```js
-   * let injector = angular.injector(['ng', 'myModule'])
-   * ```
-   *
-   * However it's more likely that you'll just use
-   * {@link ng.directive:ngApp ngApp} or
-   * {@link angular.bootstrap} to simplify this process for you.
-   *
-   * @param {string} name The name of the module to create or retrieve.
-   * @param {Array.<string>} [requires] If specified then new module is being created. If
-   *        unspecified then the module is being retrieved for further configuration.
-   * @param {import("./interface.js").Injectable} [configFn] Optional configuration function for the module that gets
-   *        passed to {@link NgModule.config NgModule.config()}.
-   * @returns {NgModule} A newly registered module.
-   */
-  module(
-    name: string,
-    requires?: Array<string>,
-    configFn?: import("./interface.js").Injectable,
-  ): NgModule;
-}
-/**
- * Configuration option for AngularTS bootstrap process.
- */
-export type AngularBootstrapConfig = {
-  /**
-   * - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
-   */
-  strictDi?: boolean;
-};
-import { getController } from "./shared/dom.js";
-import { getInjector } from "./shared/dom.js";
-import { getScope } from "./shared/dom.js";
-import { errorHandlingConfig } from "./shared/utils.js";
-import { NgModule } from "./core/di/ng-module.js";

package/@types/animations/animate-cache.d.ts

@@ -1,50 +0,0 @@
-export function animateCache(): {
-  /**
-   * Generates a unique cache key based on the node's parent and other parameters.
-   * @param {HTMLElement} node - The DOM node to generate the cache key for.
-   * @param {string} method - The animation method being applied.
-   * @param {string} [addClass] - Class to add during the animation.
-   * @param {string} [removeClass] - Class to remove during the animation.
-   * @returns {string} - The generated cache key.
-   */
-  cacheKey(
-    node: HTMLElement,
-    method: string,
-    addClass?: string,
-    removeClass?: string,
-  ): string;
-  /**
-   * Checks if a cached animation without a duration exists.
-   * @param {string} key - The cache key to check.
-   * @returns {boolean} - True if an invalid animation is cached, false otherwise.
-   */
-  containsCachedAnimationWithoutDuration(key: string): boolean;
-  /**
-   * Clears the cache.
-   * @returns {void}
-   */
-  flush(): void;
-  /**
-   * Gets the count of a specific cache entry.
-   * @param {string} key - The cache key to count.
-   * @returns {number} - The count of the cache entry.
-   */
-  count(key: string): number;
-  /**
-   * Retrieves a value associated with a specific cache key.
-   * @param {string} key - The cache key to retrieve.
-   * @returns {any} - The value associated with the cache key.
-   */
-  get(key: string): any;
-  /**
-   * Adds or updates a cache entry.
-   * @param {string} key - The cache key to add or update.
-   * @param {any} value - The value to store.
-   * @param {boolean} isValid - Whether the cache entry is valid.
-   */
-  put(key: string, value: any, isValid: boolean): void;
-};
-export function AnimateCacheProvider(): void;
-export class AnimateCacheProvider {
-  $get: (typeof animateCache)[];
-}

package/@types/animations/animate-children-directive.d.ts

@@ -1,10 +0,0 @@
-/**
- * @param {*} $interpolate
- * @returns {import("../interface.ts").Directive}
- */
-export function $$AnimateChildrenDirective(
-  $interpolate: any,
-): import("../interface.ts").Directive;
-export namespace $$AnimateChildrenDirective {
-  let $inject: string[];
-}

package/@types/animations/animate-css-driver.d.ts

@@ -1,18 +0,0 @@
-export function AnimateCssDriverProvider($$animationProvider: any): void;
-export class AnimateCssDriverProvider {
-  constructor($$animationProvider: any);
-  /**
-   * @returns {Function}
-   */
-  $get: (
-    | string
-    | ((
-        $animateCss: any,
-        $$AnimateRunner: typeof import("./animate-runner.js").AnimateRunner,
-        $rootElement: Element,
-      ) => (animationDetails: any) => any)
-  )[];
-}
-export namespace AnimateCssDriverProvider {
-  let $inject: string[];
-}

package/@types/animations/animate-css.d.ts

@@ -1,18 +0,0 @@
-export function AnimateCssProvider(): void;
-export class AnimateCssProvider {
-  $get: (
-    | string
-    | ((
-        $$AnimateRunner: any,
-        $$animateCache: any,
-        $$rAFScheduler: any,
-      ) => (
-        element: any,
-        initialOptions: any,
-      ) => {
-        $$willAnimate: boolean;
-        start(): any;
-        end: () => void;
-      })
-  )[];
-}

package/@types/animations/animate-js-driver.d.ts

@@ -1,14 +0,0 @@
-export function AnimateJsDriverProvider($$animationProvider: any): void;
-export class AnimateJsDriverProvider {
-  constructor($$animationProvider: any);
-  $get: (
-    | string
-    | ((
-        $$animateJs: any,
-        $$AnimateRunner: any,
-      ) => (animationDetails: any) => any)
-  )[];
-}
-export namespace AnimateJsDriverProvider {
-  let $inject: string[];
-}

package/@types/animations/animate-js.d.ts

@@ -1,23 +0,0 @@
-export function AnimateJsProvider($animateProvider: any): void;
-export class AnimateJsProvider {
-  constructor($animateProvider: any);
-  $get: (
-    | string
-    | ((
-        $injector: any,
-        $$AnimateRunner: any,
-      ) => (
-        element: any,
-        event: any,
-        classes: any,
-        options: any,
-      ) => {
-        $$willAnimate: boolean;
-        end(): any;
-        start(): any;
-      })
-  )[];
-}
-export namespace AnimateJsProvider {
-  let $inject: string[];
-}

package/@types/animations/animate-queue.d.ts

@@ -1,28 +0,0 @@
-export function AnimateQueueProvider($animateProvider: any): void;
-export class AnimateQueueProvider {
-  constructor($animateProvider: any);
-  rules: {
-    skip: any[];
-    cancel: any[];
-    join: any[];
-  };
-  $get: (
-    | string
-    | ((
-        $rootScope: import("../core/scope/scope.js").Scope,
-        $injector: any,
-        $$animation: any,
-        $$AnimateRunner: any,
-        $templateRequest: any,
-      ) => {
-        on(event: any, container: any, callback: any): void;
-        off(event: any, container: any, callback: any, ...args: any[]): void;
-        pin(element: any, parentElement: any): void;
-        push(element: any, event: any, options: any, domOperation: any): any;
-        enabled(element: any, bool: any, ...args: any[]): any;
-      })
-  )[];
-}
-export namespace AnimateQueueProvider {
-  let $inject: string[];
-}