@angular-wave/angular.ts 0.7.7 → 0.8.0

package/src/core/location/location.md

@@ -1,114 +0,0 @@
-/\*\*
-
-- The $location service parses the URL in the browser address bar (based on the
-- [window.location](https://developer.mozilla.org/en/window.location)) and makes the URL
-- available to your application. Changes to the URL in the address bar are reflected into
-- $location service and changes to $location are reflected into the browser address bar.
--
-- **The $location service:**
--
-- - Exposes the current URL in the browser address bar, so you can
-- - Watch and observe the URL.
-- - Change the URL.
-- - Synchronizes the URL with the browser when the user
-- - Changes the address bar.
-- - Clicks the back or forward button (or clicks a History link).
-- - Clicks on a link.
-- - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
--
-- For more information see {@link guide/$location Developer Guide: Using $location}
-  \*/
-
-/\*\*
-
-- Use the `$locationProvider` to configure how the application deep linking paths are stored.
-  \*/
-
-/\*\*
-
-- @ngdoc event
-- @name $location#$locationChangeStart
-- @eventType broadcast on root scope
-- @description
-- Broadcasted before a URL will change.
--
-- This change can be prevented by calling
-- `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
-- details about event object. Upon successful change
-- {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
--
-- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-- the browser supports the HTML5 History API.
--
-- @param {Object} angularEvent Synthetic event object.
-- @param {string} newUrl New URL
-- @param {string=} oldUrl URL that was before it was changed.
-- @param {string=} newState New history state object
-- @param {string=} oldState History state object that was before it was changed.
-  \*/
-
-/\*\*
-
-- @ngdoc event
-- @name $location#$locationChangeSuccess
-- @eventType broadcast on root scope
-- @description
-- Broadcasted after a URL was changed.
--
-- The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
-- the browser supports the HTML5 History API.
--
-- @param {Object} angularEvent Synthetic event object.
-- @param {string} newUrl New URL
-- @param {string=} oldUrl URL that was before it was changed.
-- @param {string=} newState New history state object
-- @param {string=} oldState History state object that was before it was changed.
-  \*/
-
-  /\*\*
-
-  - This method is getter / setter.
-  -
-  - Return search part (as object) of current URL when called without any parameter.
-  -
-  - Change search part when called with parameter and return `$location`.
-  -
-  -
-  - ```js
-
-    ```
-
-  - // given URL http://example.com/#/some/path?foo=bar&baz=xoxo
-  - let searchObject = $location.search();
-  - // => {foo: 'bar', baz: 'xoxo'}
-  -
-  - // set foo to 'yipee'
-  - $location.search('foo', 'yipee');
-  - // $location.search() => {foo: 'yipee', baz: 'xoxo'}
-  - ```
-
-    ```
-
-  -
-  - @param {string|Object} search New search params - string or hash object.
-  -
-  - When called with a single argument the method acts as a setter, setting the `search` component
-  - of `$location` to the specified value.
-  -
-  - If the argument is a hash object containing an array of values, these values will be encoded
-  - as duplicate search parameters in the URL.
-  -
-  - @param {(string|Number|Array<string>|boolean)=} paramValue If `search` is a string or number, then `paramValue`
-  - will override only a single search property.
-  -
-  - If `paramValue` is an array, it will override the property of the `search` component of
-  - `$location` specified via the first argument.
-  -
-  - If `paramValue` is `null`, the property specified via the first argument will be deleted.
-  -
-  - If `paramValue` is `true`, the property specified via the first argument will be added with no
-  - value nor trailing equal sign.
-  -
-  - @return {Object} If called with no arguments returns the parsed `search` object. If called with
-  - one or more arguments returns `$location` object itself.
-    \*/

package/src/core/task-tracker-factory.js

@@ -1,145 +0,0 @@
-/** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider */
-/** @typedef {import('../interface.ts').AnnotatedFactory} AnnotatedFactory */
-
-/**
- * @implements {ServiceProvider}
- */
-export class TaskTrackerFactoryProvider {
-  /** @type {AnnotatedFactory} */
-  $get = [
-    "$log",
-    /**
-     * Creates a new `TaskTracker` instance.
-     *
-     * @param {import('../services/log/interface.ts').LogService} log - The logging service.
-     * @returns {TaskTracker} A new `TaskTracker` instance.
-     */
-    (log) => new TaskTracker(log),
-  ];
-}
-
-/**
- * A factory function to create `TaskTracker` instances.
- *
- * A `TaskTracker` tracks pending tasks (grouped by type) and notifies interested
- * parties when all pending tasks (or tasks of a specific type) have been completed.
- */
-export class TaskTracker {
-  /**
-   * @param {import('../services/log/interface.ts').LogService} log - The logging service.
-   */
-  constructor(log) {
-    /** @private */
-    this.log = log;
-
-    /** @private */
-    this.taskCounts = {};
-
-    /** @private */
-    this.taskCallbacks = [];
-
-    /**
-     * Special task types used for tracking all tasks and default tasks.
-     * @type {string}
-     */
-    this.ALL_TASKS_TYPE = "$$all$$";
-
-    /**
-     * Default task type.
-     * @type {string}
-     */
-    this.DEFAULT_TASK_TYPE = "$$default$$";
-  }
-
-  /**
-   * Completes a task and decrements the associated task counter.
-   * If the counter reaches 0, all corresponding callbacks are executed.
-   *
-   * @param {Function} fn - The function to execute when completing the task.
-   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task being completed.
-   */
-  completeTask(fn, taskType = this.DEFAULT_TASK_TYPE) {
-    try {
-      fn();
-    } finally {
-      if (this.taskCounts[taskType]) {
-        this.taskCounts[taskType]--;
-        this.taskCounts[this.ALL_TASKS_TYPE]--;
-      }
-
-      const countForType = this.taskCounts[taskType];
-      const countForAll = this.taskCounts[this.ALL_TASKS_TYPE];
-
-      // If either the overall task queue or the specific task type queue is empty, run callbacks.
-      if (!countForAll || !countForType) {
-        const getNextCallback = !countForAll
-          ? this.getLastCallback.bind(this)
-          : () => this.getLastCallbackForType(taskType);
-
-        let nextCb;
-        while ((nextCb = getNextCallback())) {
-          try {
-            nextCb();
-          } catch (e) {
-            this.log.error(e);
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Increments the task count for the specified task type.
-   *
-   * @param {string} [taskType=this.DEFAULT_TASK_TYPE] - The type of task whose count will be increased.
-   */
-  incTaskCount(taskType = this.DEFAULT_TASK_TYPE) {
-    this.taskCounts[taskType] = (this.taskCounts[taskType] || 0) + 1;
-    this.taskCounts[this.ALL_TASKS_TYPE] =
-      (this.taskCounts[this.ALL_TASKS_TYPE] || 0) + 1;
-  }
-
-  /**
-   * Registers a callback to be executed when all pending tasks of the specified type are completed.
-   * If there are no pending tasks of the specified type, the callback is executed immediately.
-   *
-   * @param {Function} callback - The function to execute when no pending tasks remain.
-   * @param {string} [taskType=this.ALL_TASKS_TYPE] - The type of tasks to wait for completion.
-   */
-  notifyWhenNoPendingTasks(callback, taskType = this.ALL_TASKS_TYPE) {
-    if (!this.taskCounts[taskType]) {
-      callback();
-    } else {
-      this.taskCallbacks.push({ type: taskType, cb: callback });
-    }
-  }
-
-  /**
-   * Retrieves and removes the last registered callback from the queue.
-   *
-   * @private
-   * @returns {Function|undefined} The last callback function or undefined if none exist.
-   */
-  getLastCallback() {
-    const cbInfo = this.taskCallbacks.pop();
-    return cbInfo ? cbInfo.cb : undefined;
-  }
-
-  /**
-   * Retrieves and removes the last registered callback for the specified task type.
-   *
-   * @private
-   * @param {string} taskType - The type of task for which the callback was registered.
-   * @returns {Function|undefined} The last callback function for the task type, or undefined if none exist.
-   */
-  getLastCallbackForType(taskType) {
-    for (let i = this.taskCallbacks.length - 1; i >= 0; --i) {
-      const cbInfo = this.taskCallbacks[i];
-      if (cbInfo.type === taskType) {
-        this.taskCallbacks.splice(i, 1);
-        return cbInfo.cb;
-      }
-    }
-    return undefined;
-  }
-}

package/src/core/url-utils/url-utils.md

@@ -1,46 +0,0 @@
-/\*\*
-
--
-- Implementation Notes for non-IE browsers
-- ***
-- Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
-- results both in the normalizing and parsing of the URL. Normalizing means that a relative
-- URL will be resolved into an absolute URL in the context of the application document.
-- Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
-- properties are all populated to reflect the normalized URL. This approach has wide
-- compatibility - Safari 1+, Mozilla 1+ etc. See
-- http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
--
-- Implementation Notes for IE
-- ***
-- IE <= 10 normalizes the URL when assigned to the anchor node similar to the other
-- browsers. However, the parsed components will not be set if the URL assigned did not specify
-- them. (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.) We
-- work around that by performing the parsing in a 2nd step by taking a previously normalized
-- URL (e.g. by assigning to a.href) and assigning it a.href again. This correctly populates the
-- properties such as protocol, hostname, port, etc.
--
-- References:
-- http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
-- http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
-- http://url.spec.whatwg.org/#urlutils
-- https://github.com/angular/angular.js/pull/2902
-- http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
--
-- @kind function
-- @param {string|object} url The URL to be parsed. If `url` is not a string, it will be returned
--     unchanged.
-- @description Normalizes and parses a URL.
-- @returns {object} Returns the normalized URL as a dictionary.
--
-- | member name | Description |
-- |---------------|------------------------------------------------------------------------|
-- | href | A normalized version of the provided URL if it was not an absolute URL |
-- | protocol | The protocol without the trailing colon |
-- | host | The host and port (if the port is non-default) of the normalizedUrl |
-- | search | The search params, minus the question mark |
-- | hash | The hash string, minus the hash symbol |
-- | hostname | The hostname |
-- | port | The port, without ":" |
-- | pathname | The pathname, beginning with "/" |
-- \*/

package/src/directive/non-bindable/non-bindable.md

@@ -1,17 +0,0 @@
-## `ngNonBindable` Directive
-
-### Restrict
-
-`AC`
-
-### Priority
-
-1000
-
-### Element
-
-`ANY`
-
-### Description
-
-The `ngNonBindable` directive tells AngularTS not to compile or bind the contents of the current DOM element, including directives on the element itself that have a lower priority than `ngNonBindable`. This is useful if the element contains what appears to be AngularTS directives and bindings but which should be ignored by AngularTS. This could be the case if you have a site that displays snippets of code, for instance.

package/src/loader.spec.js

@@ -1,169 +0,0 @@
-import { Angular } from "./loader.js";
-import { createInjector } from "./core/di/injector.js";
-
-describe("module loader", () => {
-  let angular;
-  beforeEach(() => {
-    angular = window.angular = new Angular();
-  });
-
-  it("allows registering a module", () => {
-    const myModule = angular.module("myModule", []);
-    expect(myModule).toBeDefined();
-    expect(myModule.name).toEqual("myModule");
-  });
-
-  it("allows getting a module", () => {
-    const myModule = angular.module("myModule", []);
-    const gotModule = angular.module("myModule");
-    expect(gotModule).toBeDefined();
-    expect(gotModule).toBe(myModule);
-  });
-
-  it("throws when trying to get a nonexistent module", () => {
-    expect(() => {
-      angular.module("nonexistent");
-    }).toThrow();
-  });
-
-  it("does not allow a module to be called hasOwnProperty", () => {
-    expect(() => {
-      angular.module("hasOwnProperty", []);
-    }).toThrow();
-  });
-
-  it("attaches the requires array to the registered module", () => {
-    const myModule = angular.module("myModule", ["myOtherModule"]);
-    expect(myModule.requires).toEqual(["myOtherModule"]);
-  });
-
-  it("replaces a module when registered with same name again", () => {
-    const myModule = angular.module("myModule", []);
-    const myNewModule = angular.module("myModule", []);
-    expect(myNewModule).not.toBe(myModule);
-  });
-
-  it("should record calls", () => {
-    const otherModule = angular.module("other", []);
-    otherModule.config("otherInit");
-
-    const myModule = angular.module("my", ["other"], "config");
-
-    expect(
-      myModule
-        .decorator("dk", "dv")
-        .provider("sk", "sv")
-        .factory("fk", "fv")
-        .service("a", "aa")
-        .value("k", "v")
-        .filter("f", "ff")
-        .directive("d", "dd")
-        .component("c", "cc")
-        .controller("ctrl", "ccc")
-        .config("init2")
-        .constant("abc", 123)
-        .run("runBlock"),
-    ).toBe(myModule);
-
-    expect(myModule.requires).toEqual(["other"]);
-    expect(myModule.invokeQueue).toEqual([
-      ["$provide", "constant", jasmine.objectContaining(["abc", 123])],
-      ["$provide", "provider", jasmine.objectContaining(["sk", "sv"])],
-      ["$provide", "factory", jasmine.objectContaining(["fk", "fv"])],
-      ["$provide", "service", jasmine.objectContaining(["a", "aa"])],
-      ["$provide", "value", jasmine.objectContaining(["k", "v"])],
-      ["$filterProvider", "register", jasmine.objectContaining(["f", "ff"])],
-      ["$compileProvider", "directive", jasmine.objectContaining(["d", "dd"])],
-      ["$compileProvider", "component", jasmine.objectContaining(["c", "cc"])],
-      [
-        "$controllerProvider",
-        "register",
-        jasmine.objectContaining(["ctrl", "ccc"]),
-      ],
-    ]);
-    expect(myModule.configBlocks).toEqual([
-      ["$injector", "invoke", jasmine.objectContaining(["config"])],
-      ["$provide", "decorator", jasmine.objectContaining(["dk", "dv"])],
-      ["$injector", "invoke", jasmine.objectContaining(["init2"])],
-    ]);
-    expect(myModule.runBlocks).toEqual(["runBlock"]);
-  });
-
-  it("should not throw error when `module.decorator` is declared before provider that it decorates", () => {
-    angular
-      .module("theModule", [])
-      .decorator("theProvider", ($delegate) => $delegate)
-      .factory("theProvider", () => ({}));
-
-    expect(() => {
-      createInjector(["theModule"]);
-    }).not.toThrow();
-  });
-
-  it("should run decorators in order of declaration, even when mixed with provider.decorator", () => {
-    let log = "";
-
-    angular
-      .module("theModule", [])
-      .factory("theProvider", () => ({ api: "provider" }))
-      .decorator("theProvider", ($delegate) => {
-        $delegate.api += "-first";
-        return $delegate;
-      })
-      .config(($provide) => {
-        $provide.decorator("theProvider", ($delegate) => {
-          $delegate.api += "-second";
-          return $delegate;
-        });
-      })
-      .decorator("theProvider", ($delegate) => {
-        $delegate.api += "-third";
-        return $delegate;
-      })
-      .run((theProvider) => {
-        log = theProvider.api;
-      });
-
-    createInjector(["theModule"]);
-    expect(log).toBe("provider-first-second-third");
-  });
-
-  it("should decorate the last declared provider if multiple have been declared", () => {
-    let log = "";
-
-    angular
-      .module("theModule", [])
-      .factory("theProvider", () => ({
-        api: "firstProvider",
-      }))
-      .decorator("theProvider", ($delegate) => {
-        $delegate.api += "-decorator";
-        return $delegate;
-      })
-      .factory("theProvider", () => ({
-        api: "secondProvider",
-      }))
-      .run((theProvider) => {
-        log = theProvider.api;
-      });
-
-    createInjector(["theModule"]);
-    expect(log).toBe("secondProvider-decorator");
-  });
-
-  it("should allow module redefinition", () => {
-    expect(angular.module("a", [])).not.toBe(angular.module("a", []));
-  });
-
-  it("should complain of no module", () => {
-    expect(() => {
-      angular.module("dontExist");
-    }).toThrow();
-  });
-
-  it('should complain if a module is called "hasOwnProperty', () => {
-    expect(() => {
-      angular.module("hasOwnProperty", []);
-    }).toThrow();
-  });
-});

package/src/router/state-provider.js

@@ -1,146 +0,0 @@
-import { val } from "../shared/hof.js";
-import { createProxyFunctions } from "../shared/common.js";
-import { minErr } from "../shared/utils.js";
-
-const err = minErr("$stateProvider");
-
-/**
- * The Angular 1 `StateProvider`
- *
- * The `$stateProvider` works similar to Angular's v1 router, but it focuses purely
- * on state.
- *
- * A state corresponds to a "place" in the application in terms of the overall UI and
- * navigation. A state describes (via the controller / template / view properties) what
- * the UI looks like and does at that place.
- *
- * States often have things in common, and the primary way of factoring out these
- * commonalities in this model is via the state hierarchy, i.e. parent/child states aka
- * nested states.
- *
- * The `$stateProvider` provides interfaces to declare these states for your app.
- */
-export class StateProvider {
-  constructor(stateRegistry, stateService) {
-    this.stateRegistry = stateRegistry;
-    this.stateService = stateService;
-    createProxyFunctions(val(StateProvider.prototype), this, val(this));
-  }
-  /**
-   * Decorates states when they are registered
-   *
-   * Allows you to extend (carefully) or override (at your own peril) the
-   * `stateBuilder` object used internally by [[StateRegistry]].
-   * This can be used to add custom functionality to ng-router,
-   * for example inferring templateUrl based on the state name.
-   *
-   * When passing only a name, it returns the current (original or decorated) builder
-   * function that matches `name`.
-   *
-   * The builder functions that can be decorated are listed below. Though not all
-   * necessarily have a good use case for decoration, that is up to you to decide.
-   *
-   * In addition, users can attach custom decorators, which will generate new
-   * properties within the state's internal definition. There is currently no clear
-   * use-case for this beyond accessing internal states (i.e. $state.$current),
-   * however, expect this to become increasingly relevant as we introduce additional
-   * meta-programming features.
-   *
-   * **Warning**: Decorators should not be interdependent because the order of
-   * execution of the builder functions in non-deterministic. Builder functions
-   * should only be dependent on the state definition object and super function.
-   *
-   *
-   * Existing builder functions and current return values:
-   *
-   * - **parent** `{object}` - returns the parent state object.
-   * - **data** `{object}` - returns state data, including any inherited data that is not
-   *   overridden by own values (if any).
-   * - **url** `{object}` - returns a {@link ui.router.util.type:UrlMatcher UrlMatcher}
-   *   or `null`.
-   * - **navigable** `{object}` - returns closest ancestor state that has a URL (aka is
-   *   navigable).
-   * - **params** `{object}` - returns an array of state params that are ensured to
-   *   be a super-set of parent's params.
-   * - **views** `{object}` - returns a views object where each key is an absolute view
-   *   name (i.e. "viewName@stateName") and each value is the config object
-   *   (template, controller) for the view. Even when you don't use the views object
-   *   explicitly on a state config, one is still created for you internally.
-   *   So by decorating this builder function you have access to decorating template
-   *   and controller properties.
-   * - **ownParams** `{object}` - returns an array of params that belong to the state,
-   *   not including any params defined by ancestor states.
-   * - **path** `{string}` - returns the full path from the root down to this state.
-   *   Needed for state activation.
-   * - **includes** `{object}` - returns an object that includes every state that
-   *   would pass a `$state.includes()` test.
-   *
-   * #### Example:
-   * Override the internal 'views' builder with a function that takes the state
-   * definition, and a reference to the internal function being overridden:
-   * ```js
-   * $stateProvider.decorator('views', function (state, parent) {
-   *   let result = {},
-   *       views = parent(state);
-   *
-   *   forEach(views, function (config, name) {
-   *     let autoName = (state.name + '.' + name).replace('.', '/');
-   *     config.templateUrl = config.templateUrl || '/partials/' + autoName + '.html';
-   *     result[name] = config;
-   *   });
-   *   return result;
-   * });
-   *
-   * $stateProvider.state('home', {
-   *   views: {
-   *     'contact.list': { controller: 'ListController' },
-   *     'contact.item': { controller: 'ItemController' }
-   *   }
-   * });
-   * ```
-   *
-   *
-   * ```js
-   * // Auto-populates list and item views with /partials/home/contact/list.html,
-   * // and /partials/home/contact/item.html, respectively.
-   * $state.go('home');
-   * ```
-   *
-   * @param {string} name The name of the builder function to decorate.
-   * @param {object} func A function that is responsible for decorating the original
-   * builder function. The function receives two parameters:
-   *
-   *   - `{object}` - state - The state config object.
-   *   - `{object}` - super - The original builder function.
-   *
-   * @return {object} $stateProvider - $stateProvider instance
-   */
-  decorator(name, func) {
-    return this.stateRegistry.decorator(name, func) || this;
-  }
-
-  /**
-   *
-   * @param {*} definition
-   * @returns {StateProvider}
-   */
-  state(definition) {
-    if (!definition.name) {
-      throw err("stateinvalid", `'name' required`);
-    }
-    try {
-      this.stateRegistry.register(definition);
-    } catch (e) {
-      throw err("stateinvalid", e.message);
-    }
-    return this;
-  }
-  /**
-   * Registers an invalid state handler
-   *
-   * This is a passthrough to [[StateService.onInvalid]] for ng1.
-   */
-  onInvalid(callback) {
-    return this.stateService.onInvalid(callback);
-  }
-}