@angular-wave/angular.ts 0.0.40 → 0.0.41

package/src/shared/jqlite/jqlite.spec.js

@@ -1,4 +1,11 @@
-import { JQLite, dealoc, kebabToCamel } from "./jqlite";
+import {
+  JQLite,
+  dealoc,
+  kebabToCamel,
+  cleanElementData,
+  getOrSetCacheData,
+  removeElementData,
+} from "./jqlite";
 import { angularInit } from "../../loader";
 import { createInjector } from "../../injector";
 import { publishExternalAPI } from "../../public";
@@ -474,61 +481,63 @@ describe("jqLite", () => {
       expect(elm.data("key2")).toBe("value2");
     });
 
-    it("should remove user data on cleanData()", () => {
-      const selected = JQLite([a, b, c]);
+    describe("cleanElementData helper", () => {
+      it("should remove user data on cleanElementData()", () => {
+        const selected = JQLite([a, b, c]);
 
-      selected.data("prop", "value");
-      JQLite(b).data("prop", "new value");
+        selected.data("prop", "value");
+        JQLite(b).data("prop", "new value");
 
-      JQLite.cleanData(selected);
+        cleanElementData(selected);
 
-      expect(JQLite(a).data("prop")).toBeUndefined();
-      expect(JQLite(b).data("prop")).toBeUndefined();
-      expect(JQLite(c).data("prop")).toBeUndefined();
-    });
-
-    it("should remove event handlers on cleanData()", () => {
-      const selected = JQLite([a, b, c]);
-
-      let log = "";
-      const elm = JQLite(b);
-      elm.on("click", () => {
-        log += "click;";
+        expect(JQLite(a).data("prop")).toBeUndefined();
+        expect(JQLite(b).data("prop")).toBeUndefined();
+        expect(JQLite(c).data("prop")).toBeUndefined();
       });
-      JQLite.cleanData(selected);
 
-      browserTrigger(b, "click");
-      expect(log).toBe("");
-    });
+      it("should remove event handlers on cleanElementData()", () => {
+        const selected = JQLite([a, b, c]);
 
-    it("should remove user data & event handlers on cleanData()", () => {
-      const selected = JQLite([a, b, c]);
+        let log = "";
+        const elm = JQLite(b);
+        elm.on("click", () => {
+          log += "click;";
+        });
+        cleanElementData(selected);
 
-      let log = "";
-      const elm = JQLite(b);
-      elm.on("click", () => {
-        log += "click;";
+        browserTrigger(b, "click");
+        expect(log).toBe("");
       });
 
-      selected.data("prop", "value");
-      JQLite(a).data("prop", "new value");
+      it("should remove user data & event handlers on cleanElementData()", () => {
+        const selected = JQLite([a, b, c]);
 
-      JQLite.cleanData(selected);
+        let log = "";
+        const elm = JQLite(b);
+        elm.on("click", () => {
+          log += "click;";
+        });
 
-      browserTrigger(b, "click");
-      expect(log).toBe("");
+        selected.data("prop", "value");
+        JQLite(a).data("prop", "new value");
 
-      expect(JQLite(a).data("prop")).toBeUndefined();
-      expect(JQLite(b).data("prop")).toBeUndefined();
-      expect(JQLite(c).data("prop")).toBeUndefined();
-    });
+        cleanElementData(selected);
 
-    it("should not break on cleanData(), if element has no data", () => {
-      const selected = JQLite([a, b, c]);
-      spyOn(CACHE, "get").and.returnValue(undefined);
-      expect(() => {
-        JQLite.cleanData(selected);
-      }).not.toThrow();
+        browserTrigger(b, "click");
+        expect(log).toBe("");
+
+        expect(JQLite(a).data("prop")).toBeUndefined();
+        expect(JQLite(b).data("prop")).toBeUndefined();
+        expect(JQLite(c).data("prop")).toBeUndefined();
+      });
+
+      it("should not break on cleanElementData(), if element has no data", () => {
+        const selected = JQLite([a, b, c]);
+        spyOn(CACHE, "get").and.returnValue(undefined);
+        expect(() => {
+          cleanElementData(selected);
+        }).not.toThrow();
+      });
     });
 
     it("should add and remove data on SVGs", () => {
@@ -553,32 +562,35 @@ describe("jqLite", () => {
       expect(CACHE.size).toEqual(initial);
     });
 
-    it("should provide the non-wrapped data calls", () => {
-      const node = document.createElement("div");
-      document.body.appendChild(node);
+    describe("removeElementData/getOrSetCacheData helpers", () => {
+      it("should provide the non-wrapped data calls", () => {
+        const node = document.createElement("div");
+        document.body.appendChild(node);
 
-      expect(CACHE.has(node[EXPANDO])).toBe(false);
-      expect(JQLite.data(node, "foo")).toBeUndefined();
-      expect(CACHE.has(node[EXPANDO])).toBe(false);
+        expect(CACHE.has(node[EXPANDO])).toBe(false);
+        debugger;
+        expect(getOrSetCacheData(node, "foo")).toBeUndefined();
+        expect(CACHE.has(node[EXPANDO])).toBe(false);
 
-      JQLite.data(node, "foo", "bar");
+        getOrSetCacheData(node, "foo", "bar");
 
-      expect(CACHE.has(node[EXPANDO])).toBe(true);
-      expect(JQLite.data(node, "foo")).toBe("bar");
-      expect(JQLite(node).data("foo")).toBe("bar");
+        expect(CACHE.has(node[EXPANDO])).toBe(true);
+        expect(getOrSetCacheData(node, "foo")).toBe("bar");
+        expect(JQLite(node).data("foo")).toBe("bar");
 
-      expect(JQLite.data(node)).toBe(JQLite(node).data());
+        expect(getOrSetCacheData(node)).toBe(JQLite(node).data());
 
-      JQLite.removeData(node, "foo");
-      expect(JQLite.data(node, "foo")).toBeUndefined();
+        removeElementData(node, "foo");
+        expect(getOrSetCacheData(node, "foo")).toBeUndefined();
 
-      JQLite.data(node, "bar", "baz");
-      JQLite.removeData(node);
-      JQLite.removeData(node);
-      expect(JQLite.data(node, "bar")).toBeUndefined();
+        getOrSetCacheData(node, "bar", "baz");
+        removeElementData(node);
+        removeElementData(node);
+        expect(getOrSetCacheData(node, "bar")).toBeUndefined();
 
-      JQLite(node).remove();
-      expect(CACHE.has(node[EXPANDO])).toBe(false);
+        JQLite(node).remove();
+        expect(CACHE.has(node[EXPANDO])).toBe(false);
+      });
     });
 
     it("should emit $destroy event if element removed via remove()", function () {
@@ -1274,26 +1286,6 @@ describe("jqLite", () => {
         expect(log).toEqual("childEnter;");
       });
     });
-
-    it("should throw an error if eventData or a selector is passed", () => {
-      const elm = JQLite(a);
-      const anObj = {};
-      const aString = "";
-      const aValue = 45;
-      const callback = () => {};
-
-      expect(() => {
-        elm.on("click", anObj, callback);
-      }).toThrow();
-
-      expect(() => {
-        elm.on("click", null, aString, callback);
-      }).toThrow();
-
-      expect(() => {
-        elm.on("click", aValue, callback);
-      }).toThrow();
-    });
   });
 
   describe("off", () => {

package/src/types.js

@@ -0,0 +1,13 @@
+/**
+ * @typedef {Object} angular.InjectorService
+ * @property {function(Function, boolean=): string[]} annotate Annotate a function or an array of inline annotations.
+ * @property {function(any[]): string[]} annotate Annotate an inline annotated function.
+ * @property {function(string, string=): T} get Get a service by name.
+ * @property {function(new (...args: any[]): T, any=): T} instantiate Instantiate a type constructor with optional locals.
+ * @property {function(Injectable<Function | ((...args: any[]) => T)>, any=, any=): T} invoke Invoke a function with optional context and locals.
+ * @property {function(Array<IModule | string | Injectable<(...args: any[]) => void>>): void} loadNewModules Add and load new modules to the injector.
+ * @property {Object.<string, IModule>} modules A map of all the modules loaded into the injector.
+ * @property {boolean} strictDi Indicates if strict dependency injection is enforced.
+ */
+
+export {};

package/types/animations/shared.d.ts

@@ -6,7 +6,11 @@ export function packageStyles(options: any): {
 };
 export function pendClasses(classes: any, fix: any, isPrefix: any): string;
 export function removeFromArray(arr: any, val: any): void;
-export function stripCommentsFromElement(element: any): any;
+export function stripCommentsFromElement(element: any): JQLite | {
+    toString(): string;
+    eq(index: any): JQLite;
+    length: number;
+};
 export function extractElementNode(element: any): any;
 export function applyAnimationClassesFactory(): (element: any, options: any) => void;
 export function prepareAnimationOptions(options: any): any;
@@ -48,3 +52,4 @@ export const ANIMATION_DURATION_PROP: string;
 export const TRANSITION_DELAY_PROP: string;
 export const TRANSITION_DURATION_PROP: string;
 export const ngMinErr: (arg0: string, arg1: string, ...arg2: any[]) => Error;
+import { JQLite } from "../shared/jqlite/jqlite";

package/types/core/compile/compile.d.ts

@@ -162,7 +162,7 @@ export class $CompileProvider {
      * @returns {object} `this` for chaining
      */
     addPropertySecurityContext: (elementName: string, propertyName: string, ctx: string) => object;
-    $get: (string | (($injector: any, $interpolate: any, $exceptionHandler: any, $templateRequest: any, $parse: any, $controller: any, $rootScope: any, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => any))[];
+    $get: (string | (($injector: any, $interpolate: any, $exceptionHandler: any, $templateRequest: any, $parse: any, $controller: any, $rootScope: any, $sce: any, $animate: any) => ($compileNodes: string | NodeList, transcludeFn: any, maxPriority: any, ignoreDirective: any, previousCompileContext: any) => (scope: any, cloneConnectFn: any, options: any) => string | NodeList | JQLite))[];
 }
 export namespace $CompileProvider {
     let $inject: string[];
@@ -171,3 +171,4 @@ export namespace $CompileProvider {
  * Function that aggregates all linking fns for a compilation root (nodeList)
  */
 export type CompositeLinkFn = Function;
+import { JQLite } from "../../shared/jqlite/jqlite";

package/types/directive/include/include.d.ts

@@ -4,11 +4,11 @@ export const ngIncludeDirective: (string | (($templateRequest: any, $anchorScrol
     terminal: boolean;
     transclude: string;
     controller: () => void;
-    compile(element: any, attr: any): (scope: any, $element: any, $attr: any, ctrl: any, $transclude: any) => void;
+    compile(_element: any, attr: any): (scope: any, $element: any, _$attr: any, ctrl: any, $transclude: any) => void;
 }))[];
 export const ngIncludeFillContentDirective: (string | (($compile: any) => {
     restrict: string;
     priority: number;
     require: string;
-    link(scope: any, $element: any, $attr: any, ctrl: any): void;
+    link(scope: any, $element: any, _$attr: any, ctrl: any): void;
 }))[];

package/types/services/document.d.ts

@@ -26,7 +26,7 @@
  */
 export function $DocumentProvider(this: import("../index").angular.ServiceProvider): void;
 export class $DocumentProvider {
-    $get: () => any;
+    $get: () => JQLite;
 }
 /**
  * @private
@@ -40,3 +40,4 @@ export class $$IsDocumentHiddenProvider {
 export namespace angular {
     type DocumentProvider = import("../index").angular.ServiceProvider;
 }
+import { JQLite } from "../shared/jqlite/jqlite";

package/types/shared/jqlite/jqlite.d.ts

@@ -11,35 +11,99 @@ export function kebabToCamel(name: string): string;
  */
 export function snakeToCamel(name: string): string;
 /**
- * Checks if the string contains HTML tags or entities.
- * @param {string} html
- * @returns {boolean}
+ * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+ * and execution of chain functions.
+ *
+ * @param {string|Element|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+ * @returns {JQLite}
  */
-export function isTextNode(html: string): boolean;
-export function JQLiteBuildFragment(html: any, context: any): any;
-export function JQLite(element: any): any;
+export function JQLite(element: string | Element | Document | Window | JQLite | ArrayLike<Element> | (() => void)): JQLite;
 export class JQLite {
-    constructor(element: any);
-    ready: typeof JQLiteReady;
+    /**
+     * JQLite both a function and an array-like data structure for manipulation of DOM, linking elements to expando cache,
+     * and execution of chain functions.
+     *
+     * @param {string|Element|Document|Window|JQLite|ArrayLike<Element>|(() => void)} element
+     * @returns {JQLite}
+     */
+    constructor(element: string | Element | Document | Window | JQLite | ArrayLike<Element> | (() => void));
+    /**
+     * Remove all child nodes of the set of matched elements from the DOM and clears CACHE data, associated with the node.
+     * @returns {JQLite} The current instance of JQLite.
+     */
+    empty(): JQLite;
+    /**
+     * Returns the `$scope` of the element.
+     * @returns {import("../../core/scope/scope").Scope}
+     */
+    scope(): import("../../core/scope/scope").Scope;
+    /**
+     * Returns the isolate `$scope` of the element.
+     * @returns {import("../../core/scope/scope").Scope}
+     */
+    isolateScope(): import("../../core/scope/scope").Scope;
+    /**
+     * Return instance of controller attached to element
+     * @param {string} [name] - Controller name
+     * @returns {any}
+     */
+    controller(name?: string): any;
+    /**
+     * Return instance of injector attached to element
+     * @returns {import('../../types').angular.InjectorService}
+     */
+    injector(): import("../../types").angular.InjectorService;
     toString(): string;
-    eq(index: any): any;
+    eq(index: any): JQLite;
     length: number;
-    push: (...items: undefined[]) => number;
-    sort: (compareFn?: (a: undefined, b: undefined) => number) => undefined[];
-    splice: {
-        (start: number, deleteCount?: number): undefined[];
-        (start: number, deleteCount: number, ...items: undefined[]): undefined[];
-    };
 }
+/**
+ * Removes expando data from this element. If key is provided, only
+ * its field is removed. If data is empty, also removes `ExpandoStore`
+ * from cache.
+ * @param {Element} element
+ * @param {string} [name] - key of field to remove
+ */
+export function removeElementData(element: Element, name?: string): void;
+/**
+ * Checks if the string contains HTML tags or entities.
+ * @param {string} html
+ * @returns {boolean} True if the string is plain text, false if it contains HTML tags or entities.
+ */
+export function isTextNode(html: string): boolean;
+/**
+ * @param {string} html
+ * @returns {DocumentFragment}
+ */
+export function buildFragment(html: string): DocumentFragment;
 /**
  * @param {Element} element
  * @param {boolean} [onlyDescendants]
  * @returns {void}
  */
 export function dealoc(element: Element, onlyDescendants?: boolean): void;
-export function JQLiteRemove(element: any, keepData: any): void;
+/**
+ * Gets or sets cache data for a given element.
+ *
+ * @param {Element} element - The DOM element to get or set data on.
+ * @param {string|Object} key - The key (as a string) to get/set or an object for mass-setting.
+ * @param {*} [value] - The value to set. If not provided, the function acts as a getter.
+ * @returns {*} - The retrieved data if acting as a getter. Otherwise, returns undefined.
+ */
+export function getOrSetCacheData(element: Element, key: string | any, value?: any): any;
+/**
+ *
+ * @param {Element} element
+ * @param {boolean} keepData
+ */
+export function removeElement(element: Element, keepData?: boolean): void;
 export function getBooleanAttrName(element: any, name: any): any;
-export function JQLiteCleanData(nodes: any): void;
+/**
+ * Takes an array of elements, calls any `$destroy` event handlers, removes any data in cache, and finally removes any
+ * listeners.
+ * @param {NodeListOf<Element>} nodes
+ */
+export function cleanElementData(nodes: NodeListOf<Element>): void;
 /**
  * @param {string} elementStr
  * @returns {string} Returns the string representation of the element.
@@ -48,9 +112,7 @@ export function startingTag(elementStr: string): string;
 /**
  * Return the DOM siblings between the first and last node in the given array.
  * @param {Array} nodes An array-like object
- * @returns {Array} the inputted object or a JQLite collection containing the nodes
+ * @returns {JQLite} the inputted object or a JQLite collection containing the nodes
  */
-export function getBlockNodes(nodes: any[]): any[];
+export function getBlockNodes(nodes: any[]): JQLite;
 export const BOOLEAN_ATTR: {};
-declare function JQLiteReady(fn: any): void;
-export {};

package/types/types.d.ts

@@ -0,0 +1,34 @@
+export namespace angular {
+    type InjectorService = {
+        /**
+         * Annotate a function or an array of inline annotations.
+         */
+        annotate: (arg0: Function, arg1: boolean | undefined) => string[];
+        /**
+         * Get a service by name.
+         */
+        get: (arg0: string, arg1: string | undefined) => T;
+        /**
+         * , any=): T} instantiate Instantiate a type constructor with optional locals.
+         */
+        "": new () => (...args: any[]) => any;
+        /**
+         * Invoke a function with optional context and locals.
+         */
+        invoke: (arg0: Injectable<Function | ((...args: any[]) => T)>, arg1: any | undefined, arg2: any | undefined) => T;
+        /**
+         * Add and load new modules to the injector.
+         */
+        loadNewModules: (arg0: Array<IModule | string | Injectable<(...args: any[]) => void>>) => void;
+        /**
+         * A map of all the modules loaded into the injector.
+         */
+        modules: {
+            [x: string]: IModule;
+        };
+        /**
+         * Indicates if strict dependency injection is enforced.
+         */
+        strictDi: boolean;
+    };
+}

package/types-back/index.d.ts

@@ -2121,62 +2121,6 @@ declare namespace angular {
   // AUTO module (angular.js)
   ///////////////////////////////////////////////////////////////////////////
   namespace auto {
-    ///////////////////////////////////////////////////////////////////////
-    // InjectorService
-    // see http://docs.angularjs.org/api/AUTO.$injector
-    ///////////////////////////////////////////////////////////////////////
-    interface IInjectorService {
-      annotate(fn: Function, strictDi?: boolean): string[];
-      annotate(inlineAnnotatedFunction: any[]): string[];
-      get<T>(name: string, caller?: string): T;
-      get(name: "$anchorScroll"): IAnchorScrollService;
-      get(name: "$cacheFactory"): ICacheFactoryService;
-      get(name: "$compile"): ICompileService;
-      get(name: "$controller"): IControllerService;
-      get(name: "$document"): IDocumentService;
-      get(name: "$exceptionHandler"): IExceptionHandlerService;
-      get(name: "$filter"): IFilterService;
-      get(name: "$http"): IHttpService;
-      get(name: "$httpBackend"): IHttpBackendService;
-      get(name: "$httpParamSerializer"): IHttpParamSerializer;
-      get(name: "$httpParamSerializerJQLike"): IHttpParamSerializer;
-      get(name: "$interpolate"): IInterpolateService;
-      get(name: "$interval"): IIntervalService;
-      get(name: "$location"): ILocationService;
-      get(name: "$log"): LogService;
-      get(name: "$parse"): IParseService;
-      get(name: "$q"): IQService;
-      get(name: "$rootElement"): IRootElementService;
-      get(name: "$rootScope"): IRootScopeService;
-      get(name: "$sce"): ISCEService;
-      get(name: "$sceDelegate"): ISCEDelegateService;
-      get(name: "$templateCache"): ITemplateCacheService;
-      get(name: "$templateRequest"): ITemplateRequestService;
-      get(name: "$timeout"): ITimeoutService;
-      get(name: "$window"): IWindowService;
-      get<T>(name: "$xhrFactory"): IXhrFactory<T>;
-      has(name: string): boolean;
-      instantiate<T>(
-        typeConstructor: { new (...args: any[]): T },
-        locals?: any,
-      ): T;
-      invoke<T = any>(
-        func: Injectable<Function | ((...args: any[]) => T)>,
-        context?: any,
-        locals?: any,
-      ): T;
-      /**
-       * Add the specified modules to the current injector.
-       * This method will add each of the injectables to the injector and execute all of the config and run blocks for each module passed to the method.
-       * @param modules A module, module name or annotated injection function.
-       */
-      loadNewModules(
-        modules: Array<IModule | string | Injectable<(...args: any[]) => void>>,
-      ): void;
-      /** An object map of all the modules that have been loaded into the injector. */
-      modules: { [moduleName: string]: IModule };
-      strictDi: boolean;
-    }
 
     ///////////////////////////////////////////////////////////////////////
     // ProvideService

package/types-back/jqlite.d.ts

@@ -105,13 +105,7 @@ interface JQLite {
    */
   detach(selector?: string): this;
 
-  /**
-   * Remove all child nodes of the set of matched elements from the DOM.
-   * @see {@link https://api.jquery.com/empty/}
-   */
-  empty(): this;
-
-  /**
+ /**
    * Reduce the set of matched elements to the one at the specified index.
    *
    * @param index An integer indicating the 0-based position of the element. OR An integer indicating the position of the element, counting backwards from the last element in the set.
@@ -149,13 +143,6 @@ interface JQLite {
    */
   html(func: (index: number, oldhtml: string) => string): this;
 
-  /**
-   * Get the immediately following sibling of each element in the set of matched elements. If a selector is provided, it retrieves the next sibling only if it matches that selector.
-   *
-   * @see {@link https://api.jquery.com/next/}
-   */
-  next(): this;
-
   /**
    * Attach an event handler function for one or more events to the selected elements.
    *
@@ -451,21 +438,8 @@ interface JQLite {
    */
   wrap(wrappingElement: JQLite | Element | string): this;
 
-  // Undocumented
   length: number;
 
-  // TODO: events, how to define?
-  // $destroy
-  controller(name?: string): any;
-  injector(): ng.auto.IInjectorService;
-  /**
-   * Returns the `$scope` of the element.
-   *
-   * **IMPORTANT**: Requires `debugInfoEnabled` to be true.
-   *
-   * See https://docs.angularjs.org/guide/production#disabling-debug-data for more information.
-   */
-  scope<T extends ng.IScope>(): T;
   /**
    * Returns the `$scope` of the element.
    *
@@ -479,16 +453,3 @@ interface JQLite {
   inheritedData(obj: { [key: string]: any }): this;
   inheritedData(key?: string): any;
 }
-
-interface JQueryStatic {
-  (
-    element:
-      | string
-      | Element
-      | Document
-      | Window
-      | JQLite
-      | ArrayLike<Element>
-      | (() => void),
-  ): JQLite;
-}