function computeLinkToComponentTransitioningIn(this: any) {
   if (get(this, 'willBeActive') === true && !get(this, '_active')) {
     return 'ember-transitioning-in';
   } else {
     return false;
   }
 }

 function computeLinkToComponentTransitioningOut(this: any) {
   if (get(this, 'willBeActive') === false && get(this, '_active')) {
     return 'ember-transitioning-out';
   } else {
     return false;
   }
 }

    function computeLinkToComponentLoading(this: any) {
      let qualifiedRouteName = get(this, 'qualifiedRouteName');
      let modelsAreLoaded = get(this, '_modelsAreLoaded');

      if (!modelsAreLoaded || qualifiedRouteName === null || qualifiedRouteName === undefined) {
        return get(this, 'loadingClass');
      }
    }

  willBeActive: computed('_routing.targetState', function computeLinkToComponentWillBeActive(
    this: any
  ) {
    let routing = this._routing;
    let targetState = get(routing, 'targetState');
    if (get(routing, 'currentState') === targetState) {
      return;
    }

    return this._isActive(targetState);
  }),

 function computeLinkToComponentQualifiedRouteName(this: any) {
   let params = get(this, 'params');
   let paramsLength = params.length;
   let lastParam = params[paramsLength - 1];
   if (lastParam && lastParam.isQueryParams) {
     paramsLength--;
   }
   let onlyQueryParamsSupplied = this[HAS_BLOCK] ? paramsLength === 0 : paramsLength === 1;
   if (onlyQueryParamsSupplied) {
     return get(this, '_routing.currentRouteName');
   }
   return get(this, 'targetRouteName');
 }

  compute() {
    let { _parentReference, _parentObjectTag, _propertyKey } = this;

    let parentValue = _parentReference.value();

    _parentObjectTag.inner.update(tagForProperty(parentValue, _propertyKey));

    let parentValueType = typeof parentValue;

    if (parentValueType === 'string' && _propertyKey === 'length') {
      return parentValue.length;
    }

    if ((parentValueType === 'object' && parentValue !== null) || parentValueType === 'function') {
      if (DEBUG) {
        watchKey(parentValue, _propertyKey);
      }

      if (DEBUG) {
        (this.tag.inner as TwoWayFlushDetectionTag).didCompute(parentValue);
      }

      return get(parentValue, _propertyKey);
    } else {
      return undefined;
    }
  }

 function computeLinkToComponentActive(this: any) {
   let currentState = get(this, '_routing.currentState');
   if (!currentState) {
     return false;
   }
   return this._isActive(currentState);
 }

  compute() {
    let { _parentValue, _propertyKey } = this;

    if (DEBUG) {
      (this.tag.inner as TwoWayFlushDetectionTag).didCompute(_parentValue);
    }

    let parent: any;
    let tracker: any;

    if (EMBER_METAL_TRACKED_PROPERTIES) {
      parent = getCurrentTracker();
      tracker = setCurrentTracker();
    }

    let ret = get(_parentValue, _propertyKey);

    if (EMBER_METAL_TRACKED_PROPERTIES) {
      setCurrentTracker(parent!);
      let tag = tracker!.combine();
      if (parent) parent.add(tag);

      this._propertyTag.inner.update(tag);
    }

    return ret;
  }

  isActiveForRoute(
    contexts: {}[],
    queryParams: {},
    routeName: string,
    routerState: any,
    isCurrentWhenSpecified: any
  ) {
    let router = get(this, 'router');

    let handlers = router._routerMicrolib.recognizer.handlersFor(routeName);
    let leafName = handlers[handlers.length - 1].handler;
    let maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);

    // NOTE: any ugliness in the calculation of activeness is largely
    // due to the fact that we support automatic normalizing of
    // `resource` -> `resource.index`, even though there might be
    // dynamic segments / query params defined on `resource.index`
    // which complicates (and makes somewhat ambiguous) the calculation
    // of activeness for links that link to `resource` instead of
    // directly to `resource.index`.

    // if we don't have enough contexts revert back to full route name
    // this is because the leaf route will use one of the contexts
    if (contexts.length > maximumContexts) {
      routeName = leafName;
    }

    return routerState.isActiveIntent(routeName, contexts, queryParams, !isCurrentWhenSpecified);
  }

    readValue = (args: any) => {
      let valuePath = valuePathRef.value();

      if (valuePath && args.length > 0) {
        args[0] = get(args[0], valuePath as string);
      }

      return args;
    };