@angular-wave/angular.ts 0.0.72 → 0.1.0

package/src/directive/switch/switch.js

@@ -90,8 +90,8 @@ export function ngSwitchWhenDirective() {
         );
 
       cases.forEach((whenCase) => {
-        ctrl.cases[`!${whenCase}`] = ctrl.cases[`!${whenCase}`] || [];
-        ctrl.cases[`!${whenCase}`].push({
+        ctrl["cases"][`!${whenCase}`] = ctrl["cases"][`!${whenCase}`] || [];
+        ctrl["cases"][`!${whenCase}`].push({
           transclude: $transclude,
           element,
         });
@@ -111,8 +111,8 @@ export function ngSwitchDefaultDirective() {
     require: "^ngSwitch",
     multiElement: true,
     link(_scope, element, _attr, ctrl, $transclude) {
-      ctrl.cases["?"] = ctrl.cases["?"] || [];
-      ctrl.cases["?"].push({ transclude: $transclude, element });
+      ctrl["cases"]["?"] = ctrl["cases"]["?"] || [];
+      ctrl["cases"]["?"].push({ transclude: $transclude, element });
     },
   };
 }

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

@@ -1,11 +1,4 @@
-import {
-  forEach,
-  tail,
-  unnestR,
-  uniqR,
-  inArray,
-  removeFrom,
-} from "../../shared/common";
+import { forEach, tail, unnestR, uniqR, removeFrom } from "../../shared/common";
 import { isString, isObject } from "../../shared/utils";
 
 import { parse } from "../../shared/hof";
@@ -362,7 +355,7 @@ export function $StateRefActiveDirective(
           : [];
         const addClasses = fuzzyClasses.concat(exactClasses).reduce(uniqR, []);
         const removeClasses = allClasses.filter(
-          (cls) => !inArray(addClasses, cls),
+          (cls) => !addClasses.includes(cls),
         );
         $scope.$evalAsync(() => {
           addClasses.forEach((className) =>

package/src/router/hooks/core-resolvables.js

@@ -1,6 +1,6 @@
 import { Transition } from "../transition/transition";
 import { Resolvable } from "../resolve/resolvable";
-import { inArray, uniqR, unnestR } from "../../shared/common";
+import { uniqR, unnestR } from "../../shared/common";
 
 export function registerAddCoreResolvables(transitionService) {
   transitionService.onCreate({}, function addCoreResolvables(trans) {
@@ -17,7 +17,7 @@ export function registerAddCoreResolvables(transitionService) {
 }
 
 const TRANSITION_TOKENS = ["$transition$", Transition];
-const isTransition = inArray(TRANSITION_TOKENS);
+
 // References to Transition in the treeChanges pathnodes makes all
 // previous Transitions reachable in memory, causing a memory leak
 // This function removes resolves for '$transition$' and `Transition` from the treeChanges.
@@ -28,7 +28,9 @@ export function treeChangesCleanup(trans) {
     .reduce(uniqR, []);
   // If the resolvable is a Transition, return a new resolvable with null data
   const replaceTransitionWithNull = (r) => {
-    return isTransition(r.token) ? Resolvable.fromData(r.token, null) : r;
+    return TRANSITION_TOKENS.includes(r.token)
+      ? Resolvable.fromData(r.token, null)
+      : r;
   };
   nodes.forEach((node) => {
     node.resolvables = node.resolvables.map(replaceTransitionWithNull);

package/src/router/path/path-utils.js

@@ -5,7 +5,6 @@ import {
   tail,
   mergeR,
   unnestR,
-  inArray,
   arrayTuples,
 } from "../../shared/common";
 import { prop, propEq } from "../../shared/hof";
@@ -51,7 +50,7 @@ export class PathUtils {
   static applyViewConfigs($view, path, states) {
     // Only apply the viewConfigs to the nodes for the given states
     path
-      .filter((node) => inArray(states, node.state))
+      .filter((node) => states.includes(node.state))
       .forEach((node) => {
         const viewDecls = Object.values(node.state.views || {});
         const subPath = PathUtils.subPath(path, (n) => n === node);

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

@@ -1,5 +1,5 @@
-import { find, tail, uniqR, unnestR, inArray } from "../../shared/common";
-import { propEq, not } from "../../shared/hof";
+import { find, tail, uniqR, unnestR } from "../../shared/common";
+import { propEq } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { services } from "../common/coreservices";
 import { Resolvable } from "./resolvable";
@@ -61,7 +61,7 @@ export class ResolveContext {
   /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
   getPolicy(resolvable) {
     const node = this.findNode(resolvable);
-    return resolvable.getPolicy(node.state);
+    return resolvable.getPolicy(node);
   }
   /**
    * Returns a ResolveContext that includes a portion of this one
@@ -107,6 +107,7 @@ export class ResolveContext {
    * @param state Used to find the node to put the resolvable on
    */
   addResolvables(newResolvables, state) {
+    /** @type {import('../path/path-node').PathNode} */
     const node = find(this._path, propEq("state", state));
     const keys = newResolvables.map((r) => r.token);
     node.resolvables = node.resolvables
@@ -122,7 +123,7 @@ export class ResolveContext {
    */
   resolvePath(when = "LAZY", trans) {
     // This option determines which 'when' policy Resolvables we are about to fetch.
-    const whenOption = inArray(ALL_WHENS, when) ? when : "LAZY";
+    const whenOption = ALL_WHENS.includes(when) ? when : "LAZY";
     // If the caller specified EAGER, only the EAGER Resolvables are fetched.
     // if the caller specified LAZY, both EAGER and LAZY Resolvables are fetched.`
     const matchedWhens =
@@ -130,7 +131,7 @@ export class ResolveContext {
     // get the subpath to the state argument, if provided
     trace.traceResolvePath(this._path, when, trans);
     const matchesPolicy = (acceptedVals, whenOrAsync) => (resolvable) =>
-      inArray(acceptedVals, this.getPolicy(resolvable)[whenOrAsync]);
+      acceptedVals.includes(this.getPolicy(resolvable)[whenOrAsync]);
     // Trigger all the (matching) Resolvables in the path
     // Reduce all the "WAIT" Resolvables into an array
     const promises = this._path.reduce((acc, node) => {
@@ -139,7 +140,7 @@ export class ResolveContext {
       );
       const nowait = nodeResolvables.filter(matchesPolicy(["NOWAIT"], "async"));
       const wait = nodeResolvables.filter(
-        not(matchesPolicy(["NOWAIT"], "async")),
+        (x) => !matchesPolicy(["NOWAIT"], "async")(x),
       );
       // For the matching Resolvables, start their async fetch process.
       const subContext = this.subContext(node.state);
@@ -155,10 +156,10 @@ export class ResolveContext {
     return services.$q.all(promises);
   }
   injector() {
-    return this._injector || (this._injector = new UIInjectorImpl(this));
+    return this._injector || (this._injector = new UIInjectorImpl());
   }
   findNode(resolvable) {
-    return find(this._path, (node) => inArray(node.resolvables, resolvable));
+    return find(this._path, (node) => node.resolvables.includes(resolvable));
   }
   /**
    * Gets the async dependencies of a Resolvable
@@ -177,7 +178,7 @@ export class ResolveContext {
     const getDependency = (token) => {
       const matching = availableResolvables.filter((r) => r.token === token);
       if (matching.length) return tail(matching);
-      const fromInjector = this.injector().getNative(token);
+      const fromInjector = services.$injector.get(token);
       if (isUndefined(fromInjector)) {
         throw new Error(
           "Could not find Dependency Injection token: " + stringify(token),
@@ -190,31 +191,16 @@ export class ResolveContext {
 }
 
 class UIInjectorImpl {
-  constructor(context) {
-    this.context = context;
-    this.native = this.get(NATIVE_INJECTOR_TOKEN) || services.$injector;
+  constructor() {
+    this.native = services.$injector;
   }
   get(token) {
-    const resolvable = this.context.getResolvable(token);
-    if (resolvable) {
-      if (this.context.getPolicy(resolvable).async === "NOWAIT") {
-        return resolvable.get(this.context);
-      }
-      if (!resolvable.resolved) {
-        throw new Error(
-          "Resolvable async .get() not complete:" + stringify(resolvable.token),
-        );
-      }
-      return resolvable.data;
-    }
-    return this.getNative(token);
+    return services.$injector.get(token);
   }
   getAsync(token) {
-    const resolvable = this.context.getResolvable(token);
-    if (resolvable) return resolvable.get(this.context);
-    return services.$q.when(this.native.get(token));
+    return services.$q.when(services.$injector.get(token));
   }
   getNative(token) {
-    return this.native && this.native.get(token);
+    return services.$injector.get(token);
   }
 }

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

@@ -172,7 +172,7 @@ export function resolvablesBuilder(state) {
     );
   /** extracts the token from a Provider or provide literal */
   const getToken = (p) => p.provide || p.token;
-  // prettier-ignore: Given a literal resolve or provider object, returns a Resolvable
+  // Given a literal resolve or provider object, returns a Resolvable
   const literal2Resolvable = pattern([
     [
       prop("resolveFn"),
@@ -202,20 +202,45 @@ export function resolvablesBuilder(state) {
       (p) => new Resolvable(getToken(p), (x) => x, [p.useExisting], p.policy),
     ],
   ]);
-  // prettier-ignore
   const tuple2Resolvable = pattern([
-        [pipe(prop('val'), isString), (tuple) => new Resolvable(tuple.token, ((x) => x), [tuple.val], tuple.policy)],
-        [pipe(prop('val'), Array.isArray), (tuple) => new Resolvable(tuple.token, tail(tuple.val), tuple.val.slice(0, -1), tuple.policy)],
-        [pipe(prop('val'), isFunction), (tuple) => new Resolvable(tuple.token, tuple.val, annotateFn(tuple.val), tuple.policy)],
-    ]);
-  // prettier-ignore
+    [
+      pipe(prop("val"), isString),
+      (tuple) =>
+        new Resolvable(tuple.token, (x) => x, [tuple.val], tuple.policy),
+    ],
+    [
+      pipe(prop("val"), Array.isArray),
+      (tuple) =>
+        new Resolvable(
+          tuple.token,
+          tail(tuple.val),
+          tuple.val.slice(0, -1),
+          tuple.policy,
+        ),
+    ],
+    [
+      pipe(prop("val"), isFunction),
+      (tuple) =>
+        new Resolvable(
+          tuple.token,
+          tuple.val,
+          annotateFn(tuple.val),
+          tuple.policy,
+        ),
+    ],
+  ]);
   const item2Resolvable = pattern([
-        [is(Resolvable), (r) => r],
-        [isResolveLiteral, literal2Resolvable],
-        [isLikeNg2Provider, literal2Resolvable],
-        [isTupleFromObj, tuple2Resolvable],
-        [val(true), (obj) => { throw new Error('Invalid resolve value: ' + stringify(obj)); },],
-    ]);
+    [is(Resolvable), (r) => r],
+    [isResolveLiteral, literal2Resolvable],
+    [isLikeNg2Provider, literal2Resolvable],
+    [isTupleFromObj, tuple2Resolvable],
+    [
+      val(true),
+      (obj) => {
+        throw new Error("Invalid resolve value: " + stringify(obj));
+      },
+    ],
+  ]);
   // If resolveBlock is already an array, use it as-is.
   // Otherwise, assume it's an object and convert to an Array of tuples
   const decl = state.resolve;

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

@@ -13,29 +13,19 @@ import { isFunction, isObject } from "../../shared/utils";
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
  */
 export class StateObject {
-  /**
-   * Create a state object to put the private/internal implementation details onto.
-   * The object's prototype chain looks like:
-   * (Internal State Object) -> (Copy of State.prototype) -> (State Declaration object) -> (State Declaration's prototype...)
-   *
-   * @param stateDecl the user-supplied State Declaration
-   * @returns {StateObject} an internal State object
-   */
-  static create(stateDecl) {
-    const state = Object.setPrototypeOf(
-      Object.assign({}, stateDecl),
-      StateObject.prototype,
-    );
-    stateDecl.$$state = () => state;
-    state.self = stateDecl;
-    state.__stateObjectCache = {
-      nameGlob: Glob.fromString(state.name), // might return null
-    };
-    return state;
-  }
-  // /** @deprecated use State.create() */
+  name = undefined;
+  navigable = undefined;
+  /** @type {?StateObject} */
+  parent = undefined;
+  params = undefined;
+  url = undefined;
+
   constructor(config) {
-    return StateObject.create(config || {});
+    Object.assign(this, config);
+    this.$$state = () => this;
+    this.self = config;
+    const nameGlob = this.name ? Glob.fromString(this.name) : null;
+    this.__stateObjectCache = { nameGlob };
   }
   /**
    * Returns true if the provided parameter is the same state.

package/src/router/state/state-queue-manager.js

@@ -1,4 +1,3 @@
-import { inArray } from "../../shared/common";
 import { prop } from "../../shared/hof";
 import { isString } from "../../shared/utils";
 import { StateObject } from "./state-object";
@@ -14,12 +13,12 @@ export class StateQueueManager {
   }
   register(stateDecl) {
     const queue = this.queue;
-    const state = StateObject.create(stateDecl);
+    const state = new StateObject(stateDecl);
     const name = state.name;
     if (!isString(name)) throw new Error("State must have a valid name");
     if (
       Object.prototype.hasOwnProperty.call(this.states, name) ||
-      inArray(queue.map(prop("name")), name)
+      queue.map(prop("name")).includes(name)
     )
       throw new Error(`State '${name}' is already defined`);
     queue.push(state);

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

@@ -6,6 +6,7 @@ import { propEq } from "../../shared/hof";
 import { ResolveContext } from "../resolve/resolve-context";
 import { ng1ViewsBuilder } from "./views";
 import { isString } from "../../shared/utils";
+
 /**
  * A registry for all of the application's [[StateDeclaration]]s
  *
@@ -196,7 +197,7 @@ export class StateRegistry {
    * If the state has children, they are are also removed from the registry.
    *
    * @param stateOrName the state's name or object representation
-   * @returns {StateObject[]} a list of removed states
+   * @returns {import('./state-object').StateObject[]} a list of removed states
    */
   deregister(stateOrName) {
     const _state = this.get(stateOrName);

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

@@ -1,7 +1,6 @@
 import {
   createProxyFunctions,
   defaults,
-  inArray,
   removeFrom,
   silenceUncaughtInPromise,
   silentRejection,
@@ -18,7 +17,7 @@ import { Param } from "../params/param";
 import { Glob } from "../common/glob";
 import { ResolveContext } from "../resolve/resolve-context";
 import { lazyLoadState } from "../hooks/lazy-load";
-import { not, val } from "../../shared/hof";
+import { val } from "../../shared/hof";
 import { EventBus } from "../../core/pubsub/pubsub";
 
 const err = minErr("$stateProvider");
@@ -75,7 +74,7 @@ export class StateService {
     };
     const getters = ["current", "$current", "params", "transition"];
     const boundFns = Object.keys(StateService.prototype).filter(
-      not(inArray(getters)),
+      (x) => !getters.includes(x),
     );
     createProxyFunctions(
       val(StateService.prototype),

package/src/router/transition/transition.js

@@ -14,7 +14,7 @@ import {
   uniqR,
 } from "../../shared/common";
 import { isUndefined, isObject } from "../../shared/utils";
-import { prop, propEq, val, not, is } from "../../shared/hof";
+import { prop, propEq, val, is } from "../../shared/hof";
 import { TransitionHookPhase } from "./interface"; // has or is using
 import { TransitionHook } from "./transition-hook";
 import { matchState, makeEvent } from "./hook-registry";
@@ -323,12 +323,14 @@ export class Transition {
    * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
    * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
    */
-  addResolvable(resolvable, state = "") {
+  addResolvable(resolvable, state) {
     resolvable = is(Resolvable)(resolvable)
       ? resolvable
       : new Resolvable(resolvable);
+
     const stateName = typeof state === "string" ? state : state.name;
     const topath = this._treeChanges.to;
+    /** @type {import('../path/path-node').PathNode} */
     const targetNode = find(topath, (node) => {
       return node.state.name === stateName;
     });
@@ -500,7 +502,7 @@ export class Transition {
       redirectEnteringNodes,
       originalEnteringNodes,
       PathUtils.nonDynamicParams,
-    ).filter(not(nodeIsReloading(targetState.options().reloadState)));
+    ).filter((x) => !nodeIsReloading(targetState.options().reloadState)(x));
     // Use the existing (possibly pre-resolved) resolvables for the matching entering nodes.
     matchingEnteringNodes.forEach((node, idx) => {
       node.resolvables = originalEnteringNodes[idx].resolvables;

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

@@ -1,5 +1,11 @@
 import { UrlMatcher } from "./url-matcher";
-import { isString, isFunction, isDefined } from "../../shared/utils";
+import {
+  isString,
+  isFunction,
+  isDefined,
+  isUndefined,
+  assert,
+} from "../../shared/utils";
 import { is, or, pattern } from "../../shared/hof";
 import { StateObject } from "../state/state-object";
 /**
@@ -207,7 +213,13 @@ export class BaseUrlRule {
     this.handler = handler || ((x) => x);
   }
 
-  matchPriority() {
+  /**
+   * This function should be overridden
+   * @param {*} [params]
+   * @returns {number}
+   */
+  matchPriority(params) {
+    assert(isUndefined(params));
     return 0 - this.$id;
   }
 }

package/src/router/view/view.js

@@ -1,10 +1,4 @@
-import {
-  equals,
-  applyPairs,
-  removeFrom,
-  inArray,
-  find,
-} from "../../shared/common";
+import { equals, applyPairs, removeFrom, find } from "../../shared/common";
 import { curry, prop } from "../../shared/hof";
 import { trace } from "../common/trace";
 import { getNg1ViewConfigFactory } from "../state/views";
@@ -133,7 +127,7 @@ export class ViewService {
       .map(matchingConfigPair);
     const matchedViewConfigs = ngViewTuples.map((tuple) => tuple.viewConfig);
     const unmatchedConfigTuples = this._viewConfigs
-      .filter((config) => !inArray(matchedViewConfigs, config))
+      .filter((config) => !matchedViewConfigs.includes(config))
       .map((viewConfig) => ({ ngView: undefined, viewConfig }));
     ngViewTuples.forEach(configureUIView);
     const allTuples = ngViewTuples.concat(unmatchedConfigTuples);

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

@@ -61,7 +61,7 @@ describe("view", () => {
 
   let register;
   const registerState = curry(function (_states, stateBuilder, config) {
-    const state = StateObject.create(config);
+    const state = new StateObject(config);
     const built = stateBuilder.build(state);
     return (_states[built.name] = built);
   });

package/src/shared/common.js

@@ -1,5 +1,5 @@
 import { isDate, isFunction, isRegExp, isString } from "./utils";
-import { all, any, prop, curry, not } from "./hof";
+import { all, any, prop, curry } from "./hof";
 import { services } from "../router/common/coreservices";
 export const fromJson = JSON.parse.bind(JSON);
 export const toJson = JSON.stringify.bind(JSON);
@@ -101,11 +101,6 @@ export function inherit(parent, extra) {
   return newObj;
 }
 
-/** Given an array, returns true if the object is found in the array, (using includes) */
-export const inArray = curry(_inArray);
-export function _inArray(array, obj) {
-  return array.includes(obj);
-}
 /**
  * Given an array, and an item, if the item is found in the array, it removes it (in-place).
  * The same array is returned
@@ -188,7 +183,7 @@ export function pick(obj, propNames) {
  */
 export function omit(obj, propNames) {
   return Object.keys(obj)
-    .filter(not(inArray(propNames)))
+    .filter((x) => !propNames.includes(x))
     .reduce((acc, key) => ((acc[key] = obj[key]), acc), {});
 }
 /**
@@ -287,7 +282,7 @@ export function pushR(arr, obj) {
 }
 /** Reduce function that filters out duplicates */
 export const uniqR = (acc, token) =>
-  inArray(acc, token) ? acc : pushR(acc, token);
+  acc.includes(token) ? acc : pushR(acc, token);
 /**
  * Return a new array with a single level of arrays unnested.
  *

package/src/shared/common.spec.js

@@ -1,5 +1,5 @@
 import { defaults, filter, map, mapObj, pick } from "./common";
-import { is, eq, not, pattern, val } from "./hof";
+import { is, eq, pattern, val } from "./hof";
 import { isInjectable } from "./predicates";
 import { Queue } from "../router/common/queue";
 
@@ -58,24 +58,6 @@ describe("common", function () {
     });
   });
 
-  describe("not", function () {
-    it("should allow double-negatives", function () {
-      function T() {
-        return true;
-      }
-      function F() {
-        return false;
-      }
-      function empty() {
-        return "";
-      }
-
-      expect(not(not(T))()).toBe(true);
-      expect(not(not(F))()).toBe(false);
-      expect(not(not(empty))()).toBe(false);
-    });
-  });
-
   describe("val", function () {
     it("should return identity", function () {
       const f = function () {},

package/src/shared/hof.js

@@ -104,14 +104,7 @@ export const propEq = curry((name, _val, obj) => obj && obj[name] === _val);
  * propNotFound(obj) === undefined
  */
 export const parse = (name) => pipe.apply(null, name.split(".").map(prop));
-/**
- * Given a function that returns a truthy or falsey value, returns a
- * function that returns the opposite (falsey or truthy) value given the same inputs
- */
-export const not =
-  (fn) =>
-  (...args) =>
-    !fn.apply(null, args);
+
 /**
  * Given two functions that return truthy or falsey values, returns a function that returns truthy
  * if both functions return truthy for the given arguments

package/src/shared/jqlite/jqlite.js

@@ -1123,7 +1123,7 @@ function specialMouseHandlerWrapper(target, event, handler) {
 }
 
 /**
- * @param {string} elementStr
+ * @param {string|JQLite} elementStr
  * @returns {string} Returns the string representation of the element.
  */
 export function startingTag(elementStr) {

package/src/shared/predicates.js

@@ -6,7 +6,7 @@
  *
  * @packageDocumentation
  */
-import { and, not, pipe, prop, or } from "./hof";
+import { and, pipe, prop, or } from "./hof";
 import { isFunction, isObject, isString, isUndefined } from "./utils";
 export const isNull = (o) => o === null;
 export const isNullOrUndefined = or(isNull, isUndefined);
@@ -15,13 +15,17 @@ export const isNullOrUndefined = or(isNull, isUndefined);
  *
  * A value is "injectable" if it is a function, or if it is an ng1 array-notation-style array
  * where all the elements in the array are Strings, except the last one, which is a Function
+ * @param {*} val
+ * @returns {boolean}
  */
 export function isInjectable(val) {
   if (Array.isArray(val) && val.length) {
     const head = val.slice(0, -1),
       tail = val.slice(-1);
+
     return !(
-      head.filter(not(isString)).length || tail.filter(not(isFunction)).length
+      head.filter((x) => !isString(x)).length ||
+      tail.filter((x) => !isFunction(x)).length
     );
   }
   return isFunction(val);

package/src/types.js

@@ -68,9 +68,8 @@
 
 /**
  * @typedef {Object} Controller
+ * @property {string} name
  * @description Interface representing the lifecycle hooks for AngularJS directive controllers.
- * @see {@link https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks}
- * @see {@link https://docs.angularjs.org/guide/component}
  *
  * @property {function(): void} [$onInit]
  * Called on each controller after all the controllers on an element have been constructed and had their bindings
@@ -147,7 +146,7 @@
  */
 
 /**
- * @typedef {DirectiveController} TController
+ * @typedef {DirectiveController|NgModelController} TController
  */
 
 /**

package/tsconfig.json

@@ -13,5 +13,5 @@
     "typeRoots": ["node_modules/@types"]
   },
   "include": ["./src/*.js", "./**/*.ts"],
-  "exclude": ["./types-back/**",  "./types/**", "**/*.test.js", "**/*.spec.js"]
+  "exclude": ["./node_modules/**",  "./types/**", "**/*.test.js", "**/*.spec.js"]
 }

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

@@ -6,7 +6,7 @@ export class $$AnimateQueueProvider {
         cancel: any[];
         join: any[];
     };
-    $get: (string | (($rootScope: any, $injector: any, $$animation: any, $$AnimateRunner: any, $templateRequest: any) => {
+    $get: (string | (($rootScope: import("../core/scope/scope").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;

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

@@ -1,6 +1,12 @@
+/**
+ * @typedef {Object} AttributeLike
+ * @property {Object} $attr
+ */
+/**
+ * @extends {AttributeLike}
+ */
 export class Attributes {
     /**
-     *
      * @param {import('../scope/scope').Scope} $rootScope
      * @param {*} $animate
      * @param {import("../exception-handler").ExceptionHandlerProvider} $exceptionHandler
@@ -98,4 +104,7 @@ export class Attributes {
     sanitizeSrcset(value: any, invokeType: any): any;
     srcset: any;
 }
+export type AttributeLike = {
+    $attr: any;
+};
 import { directiveNormalize } from "../../shared/utils";