@angular-wave/angular.ts 0.4.3 → 0.4.4

package/types/core/parse/parse.d.ts

@@ -4,10 +4,19 @@
  * @property {boolean} constant - Indicates if the expression is constant.
  * @property {boolean} [isPure]
  * @property {boolean} oneTime
+ * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
  * @property {function(import('../scope/scope').Scope, import('../scope/scope').WatchListener, boolean, CompiledExpression, string | ((scope:  import('../scope/scope').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
  * @property {any[]|Function} inputs
  * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
  */
+/**
+ * @typedef {Object} CompiledExpressionHandlerMap
+ * @property {boolean} literal - Indicates if the expression is a literal.
+ * @property {boolean} constant - Indicates if the expression is constant.
+ * @property {boolean} [isPure]
+ * @property {boolean} oneTime
+ * @property {Map<string, Function>} keyMap - property keys to observe
+ */
 /**
  * @typedef {Function} CompiledExpressionFunction
  * @param {import('../scope/scope').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
@@ -61,6 +70,7 @@ export type CompiledExpressionProps = {
     constant: boolean;
     isPure?: boolean;
     oneTime: boolean;
+    decoratedNode: import("./interpreter.js").DecoratedASTNode;
     $$watchDelegate?: (arg0: import("../scope/scope").Scope, arg1: import("../scope/scope").WatchListener, arg2: boolean, arg3: CompiledExpression, arg4: string | ((scope: import("../scope/scope").Scope) => any) | CompiledExpression) => any;
     inputs: any[] | Function;
     /**
@@ -68,6 +78,22 @@ export type CompiledExpressionProps = {
      */
     assign?: (arg0: any, arg1: any) => any;
 };
+export type CompiledExpressionHandlerMap = {
+    /**
+     * - Indicates if the expression is a literal.
+     */
+    literal: boolean;
+    /**
+     * - Indicates if the expression is constant.
+     */
+    constant: boolean;
+    isPure?: boolean;
+    oneTime: boolean;
+    /**
+     * - property keys to observe
+     */
+    keyMap: Map<string, Function>;
+};
 export type CompiledExpressionFunction = Function;
 export type CompiledExpression = CompiledExpressionFunction & CompiledExpressionProps;
 export type ParseService = (arg0: CompiledExpression | string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => CompiledExpression;

package/types/core/scope/scope.d.ts

@@ -56,7 +56,7 @@ export type TTL = number;
 export const TTL: TTL;
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue: AsyncQueueTask[];
-export const $$postDigestQueue: any[];
+export const $postUpdateQueue: any[];
 /**
  * @type {Function[]}
  */
@@ -158,10 +158,6 @@ export class Scope {
     /** @type {number} */
     $$watchersCount: number;
     $$isolateBindings: any;
-    /**
-     * @type {?Scope}
-     */
-    $$ChildScope: Scope | null;
     /**
      * Creates a new child {@link Scope}.
      *
@@ -177,16 +173,21 @@ export class Scope {
      *         When creating widgets, it is useful for the widget to not accidentally read parent
      *         state.
      *
-     * @param {?Scope} [parent=this] The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
-     *                              of the newly created scope. Defaults to `this` scope if not provided.
-     *                              This is used when creating a transclude scope to correctly place it
-     *                              in the scope hierarchy while maintaining the correct prototypical
-     *                              inheritance.
      *
      * @returns {Scope} The newly created child scope.
      *
      */
-    $new(isolate: boolean | null, parent?: Scope | null): Scope;
+    $new(isolate: boolean | null): Scope;
+    /**
+     * Creates a transcluded scope
+     * @param {Scope} parent The {@link ng.$rootScope.Scope `Scope`} that will be the `$parent`
+     * of the newly created scope. This is used when creating a transclude scope to correctly place it
+     *  in the scope hierarchy while maintaining the correct prototypical inheritance.
+     *
+     * @returns {Scope} The newly created child scope.
+     *
+     */
+    $transcluded(parent: Scope): Scope;
     /**
    * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
    *
@@ -239,16 +240,16 @@ export class Scope {
        });
        expect(scope.counter).toEqual(0);
   
-       scope.$digest();
+       ;
        // the listener is always called during the first $digest loop after it was registered
        expect(scope.counter).toEqual(1);
   
-       scope.$digest();
+       ;
        // but now it will not be called unless the value changes
        expect(scope.counter).toEqual(1);
   
        scope.name = 'adam';
-       scope.$digest();
+       ;
        expect(scope.counter).toEqual(2);
   
        // Using a function as a watchExpression
@@ -270,12 +271,12 @@ export class Scope {
        expect(scope.foodCounter).toEqual(0);
   
        // Run the digest but since food has not changed count will still be zero
-       scope.$digest();
+       ;
        expect(scope.foodCounter).toEqual(0);
   
        // Update food and run digest.  Now the counter will increment
        food = 'cheeseburger';
-       scope.$digest();
+       ;
        expect(scope.foodCounter).toEqual(1);
   
    * ```
@@ -377,16 +378,16 @@ export class Scope {
        });
        expect(scope.counter).toEqual(0);
   
-       scope.$digest();
+       ;
        // the listener is always called during the first $digest loop after it was registered
        expect(scope.counter).toEqual(1);
   
-       scope.$digest();
+       ;
        // but now it will not be called unless the value changes
        expect(scope.counter).toEqual(1);
   
        scope.name = 'adam';
-       scope.$digest();
+       ;
        expect(scope.counter).toEqual(2);
    * ```
    *
@@ -411,7 +412,7 @@ export class Scope {
      * Some of the things to consider are:
      *
      * * Any external event on a directive/component will not trigger a digest while the hosting
-     *   scope is suspended - even if the event handler calls `$apply()` or `$rootScope.$digest()`.
+     *   scope is suspended - even if the event handler calls `$apply()` or ``.
      * * Transcluded content exists on a scope that inherits from outside a directive but exists
      *   as a child of the directive's containing scope. If the containing scope is suspended the
      *   transcluded scope will also be suspended, even if the scope from which the transcluded
@@ -614,7 +615,7 @@ export class Scope {
    * @returns {*} The result of evaluating the expression.
    */
     $eval(expr?: string | ((arg0: Scope) => any), locals?: (object) | undefined): any;
-    $$postDigest(fn: any): void;
+    $postUpdate(fn: any): void;
     /**
      * @private
      */

package/types/directive/channel/channel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dynamically updates an element's content based on events published on a specified channel.
+ * When the directive is applied, it listens for data sent via `EventBus` and
+ * updates the inner HTML of the element accordingly.
+ *
+ * When the scope is destroyed, the directive automatically unsubscribes from the channel.
+ *
+ *
+ * @returns {import("../../types").Directive}
+ */
+export function ngChannelDirective(): import("../../types").Directive;

package/src/core/interval/interval-factory.js

@@ -1,50 +0,0 @@
-import { isDefined, sliceArgs } from "../../shared/utils";
-
-export function $IntervalFactoryProvider() {
-  this.$get = [
-    "$q",
-    "$rootScope",
-    /**
-     * @param {*} $q
-     * @param {import('../scope/scope').Scope} $rootScope
-     * @returns
-     */
-    function ($q, $rootScope) {
-      return function intervalFactory(setIntervalFn, clearIntervalFn) {
-        return function intervalFn(fn, delay, count) {
-          const hasParams = arguments.length > 4;
-          const args = hasParams ? sliceArgs(arguments, 4) : [];
-          let iteration = 0;
-          const deferred = $q.defer();
-          const { promise } = deferred;
-
-          count = isDefined(count) ? count : 0;
-
-          function callback() {
-            if (!hasParams) {
-              fn(iteration);
-            } else {
-              fn.apply(null, args);
-            }
-          }
-
-          function tick() {
-            $rootScope.$evalAsync(callback);
-
-            iteration++;
-
-            if (count > 0 && iteration >= count) {
-              deferred.resolve(iteration);
-              clearIntervalFn(promise.$$intervalId);
-            }
-            $rootScope.$apply();
-          }
-
-          promise.$$intervalId = setIntervalFn(tick, delay, deferred);
-
-          return promise;
-        };
-      };
-    },
-  ];
-}

package/src/core/interval/interval.html

@@ -1,18 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>AngularTS Test Runner</title>
-
-    <link rel="shortcut icon" type="image/png" href="/images/favicon.ico" />
-    <link rel="stylesheet" href="/jasmine/jasmine-5.1.2/jasmine.css" />
-    <script src="/jasmine/jasmine-5.1.2/jasmine.js"></script>
-    <script src="/jasmine/jasmine-5.1.2/jasmine-html.js"></script>
-    <script src="/jasmine/jasmine-5.1.2/boot0.js"></script>
-    <script src="/jasmine/jasmine-5.1.2/boot1.js"></script>
-    <script type="module" src="/src/core/interval/interval.spec.js"></script>
-  </head>
-  <body>
-    <div id="dummy"></div>
-  </body>
-</html>

package/src/core/interval/interval.js

@@ -1,77 +0,0 @@
-import { markQExceptionHandled } from "../q/q";
-import { minErr } from "../../shared/utils";
-
-const $intervalMinErr = minErr("$interval");
-
-/**
- * @typedef {number} IntervalId
- * Interval ID which uniquely identifies the interval and can be used to cancel it
- */
-
-/**
- * @type {Map<IntervalId, import("../q/q").Deferred<any>>}
- */
-const intervals = new Map();
-
-export function IntervalProvider() {
-  this.$get = [
-    "$$intervalFactory",
-    // TODO Add type
-    function ($$intervalFactory) {
-      /**
-       * @param {TimerHandler} tick
-       * @param {number} delay
-       * @param {import("../q/q").Deferred<any>} deferred
-       * @returns {IntervalId} - This method returns an interval ID which uniquely identifies the interval
-       */
-      function setIntervalFn(tick, delay, deferred) {
-        const id = window.setInterval(tick, delay);
-        intervals.set(id, deferred);
-        return id;
-      }
-
-      /**s
-       * @param {IntervalId} id
-       */
-      function clearIntervalFn(id) {
-        window.clearInterval(id);
-        intervals.delete(id);
-      }
-
-      const interval = $$intervalFactory(setIntervalFn, clearIntervalFn);
-
-      /**
-       * Cancels a task associated with the `promise`.
-       *
-       * @param {!import("../q/q").QPromise<any>} promise returned by the `$interval` function.
-       * @returns {boolean} Returns `true` if the task was successfully canceled.
-       */
-      interval.cancel = function (promise) {
-        if (!promise) return false;
-
-        if (!Object.prototype.hasOwnProperty.call(promise, "$$intervalId")) {
-          throw $intervalMinErr(
-            "badprom",
-            "`$interval.cancel()` called with a promise that was not generated by `$interval()`.",
-          );
-        }
-
-        if (!intervals.has(promise.$$intervalId)) {
-          return false;
-        }
-
-        const id = promise.$$intervalId;
-        const deferred = intervals.get(id);
-
-        // Interval cancels should not report an unhandled promise.
-        markQExceptionHandled(deferred.promise);
-        deferred.reject("canceled");
-        clearIntervalFn(id);
-
-        return true;
-      };
-
-      return interval;
-    },
-  ];
-}

package/src/core/interval/interval.md

@@ -1,123 +0,0 @@
-/**
-_ @ngdoc service
-_ @name $interval
-       *
-       * @description
-       * AngularJS's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
-       * milliseconds.
-       *
-       * The return value of registering an interval function is a promise. This promise will be
-       * notified upon each tick of the interval, and will be resolved after `count` iterations, or
-       * run indefinitely if `count` is not defined. The value of the notification will be the
-       * number of iterations that have run.
-       * To cancel an interval, call `$interval.cancel(promise)`.
-       *
-       * In tests you can use {@link ngMock.$interval#flush `$interval.flush(millis)`} to
-       * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
-_ time.
-_
-_ <div class="alert alert-warning">
-_ **Note\*_: Intervals created by this service must be explicitly destroyed when you are finished
-_ with them. In particular they are not automatically destroyed when a controller's scope or a
-_ directive's element are destroyed.
-_ You should take this into consideration and make sure to always cancel the interval at the
-_ appropriate moment. See the example below for more details on how and when to do this.
-_ </div> \*
-_ @param {function()} fn A function that should be called repeatedly. If no additional arguments
-_ are passed (see below), the function is called with the current iteration count.
-_ @param {number} delay Number of milliseconds between each function call.
-_ @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
-_ indefinitely.
-_ @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
-_ will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
-_ @param {..._=} Pass additional parameters to the executed function.
-_ @returns {promise} A promise which will be notified on each iteration. It will resolve once all iterations of the interval complete. \*
-_ @example
-_ <example module="intervalExample" name="interval-service">
-_ <file name="index.html">
-_ <script>
-_ angular.module('intervalExample', [])
-_ .controller('ExampleController', ['$scope', '$interval',
-
-- function($scope, $interval) {
-- $scope.format = 'M/d/yy h:mm:ss a';
-- $scope.blood_1 = 100;
-- $scope.blood_2 = 120;
--
-- let stop;
-- $scope.fight = function() {
-- // Don't start a new fight if we are already fighting
-- if ( angular.isDefined(stop) ) return;
--
-- stop = $interval(function() {
-- if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
-- $scope.blood_1 = $scope.blood_1 - 3;
-- $scope.blood_2 = $scope.blood_2 - 4;
-- } else {
-- $scope.stopFight();
-- }
-- }, 100);
-- };
--
-- $scope.stopFight = function() {
-- if (angular.isDefined(stop)) {
-- $interval.cancel(stop);
-- stop = undefined;
-- }
-- };
--
-- $scope.resetFight = function() {
-- $scope.blood_1 = 100;
-- $scope.blood_2 = 120;
-- };
--
-- $scope.$on('$destroy', function() {
-- // Make sure that the interval is destroyed too
-- $scope.stopFight();
-- });
-- }])
-  _ // Register the 'myCurrentTime' directive factory method.
-  _ // We inject $interval and dateFilter service since the factory method is DI.
-       *       .directive('myCurrentTime', ['$interval', 'dateFilter',
-  _ function($interval, dateFilter) {
-  _ // return the directive link function. (compile function not needed)
-  _ return function(scope, element, attrs) {
-  _ let format, // date format
-  _ stopTime; // so that we can cancel the time updates
-  _
-  _ // used to update the UI
-  _ function updateTime() {
-  _ element.text(dateFilter(new Date(), format));
-  _ } \*
-  _ // watch the expression, and update the UI on change.
-  _ scope.$watch(attrs.myCurrentTime, function(value) {
-       *               format = value;
-       *               updateTime();
-       *             });
-       *
-       *             stopTime = $interval(updateTime, 1000);
-       *
-       *             // listen on DOM destroy (removal) event, and cancel the next UI update
-       *             // to prevent updating time after the DOM element was removed.
-       *             element.on('$destroy', function() {
-  _ $interval.cancel(stopTime);
-  _ });
-  _ }
-  _ }]);
-  _ </script>
-  _
-  _ <div>
-  _ <div ng-controller="ExampleController">
-  _ <label>Date format: <input ng-model="format"></label> <hr/>
-  _ Current time is: <span my-current-time="format"></span>
-  _ <hr/>
-  _ Blood 1 : <font color='red'>{{blood_1}}</font>
-  _ Blood 2 : <font color='red'>{{blood_2}}</font>
-  _ <button type="button" data-ng-click="fight()">Fight</button>
-  _ <button type="button" data-ng-click="stopFight()">StopFight</button>
-  _ <button type="button" data-ng-click="resetFight()">resetFight</button>
-  _ </div>
-  _ </div> \*
-  _ </file>
-  _ </example>
-  \*/