hope is coming

import {Type} from '../type';
import {stringify} from '../util';

//混合类型
//相当于可以是任意方法来实现这个接口
export interface ForwardRefFn { (): any; }

//forwardRefFn加入属性__forward_ref__
export function forwardRef(forwardRefFn: ForwardRefFn): Type<any> {
  (<any>forwardRefFn).__forward_ref__ = forwardRef;
  (<any>forwardRefFn).toString = function() { return stringify(this()); };
  return (<Type<any>><any>forwardRefFn);
  //TypeScript也使用尖括号来表示类型断言，JSX的语法带来了解析的困难。因此，TypeScript在 .tsx文件里禁用了使用尖括号的类型断言。
  //类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。 它没有运行时的影响，只是在编译阶段起作用。 TypeScript会假设你，程序员，已经进行了必须的检查。
}

//如果type是function 而且有__forward_ref__属性 且 __forward_ref__为forwardRef,那么就执行这个type
export function resolveForwardRef(type: any): any {
  if (typeof type === 'function' && type.hasOwnProperty('__forward_ref__') &&
      type.__forward_ref__ === forwardRef) {
    return (<ForwardRefFn>type)();
  } else {
    return type;
  }
}

export function forwardRef(forwardRefFn) {
  forwardRefFn.__forward_ref__ = forwardRef;
  forwardRefFn.toString = function () { return stringify(this()); };
  return forwardRefFn;
}

export function resolveForwardRef(type) {
    if (isFunction(type) && type.hasOwnProperty('__forward_ref__') &&
        type.__forward_ref__ === forwardRef) {
        return type();
    }
    else {
        return type;
    }
}

//const是对let的一个增强，它能阻止对一个变量再次赋值。
export const Type = Function;

export function isType(v: any): v is Type<any> {
return typeof v === 'function';
}

//类可以创建出类型，所以你能够在允许使用接口的地方使用类。
export interface Type<T> extends Function { new (...args: any[]): T; }

function Scope() {
}
var scope = new Scope();
scope.aProperty = 1;

function Scope() {
 this.$$watchers = [];
}

Scope.prototype.$watch = function(watchFn,listenerFn){
  var watcher = {
     watchFn: watchFn,
     listenerFn:listenerFn
  };
  this.$$watchers.push(watcher);
}

Scope.prototype.$digest = function(){
  _.foreach(this.$$watchers,function(watcher){
      watcher.listenerFn();
  });
};

function build(_styles) {
	var builder = function () {
		return applyStyle.apply(builder, arguments);
	};

	builder._styles = _styles;
	builder.enabled = this.enabled;
	// __proto__ is used because we must return a function, but there is
	// no way to create a function with a different prototype.
	/* eslint-disable no-proto */
	builder.__proto__ = proto;

	return builder;
}

var proto1 = defineProps(function chalk1() {}, {

	'ss':  {
				get: function () {
				return  "ssssss";
			}
		}
});

console.log(proto1.ss);
function build(_styles) {
	var builder = function () {

	};

	// __proto__ is used because we must return a function, but there is
	// no way to create a function with a different prototype.
	/* eslint-disable no-proto */
	builder.__proto__ = proto1;
	return builder;
}

var _b = build();
console.log(_b.ss);

ssssss
ssssss

function stringifyFn(fn) {
  // Support: Chrome 50-51 only
  // Creating a new string by adding `' '` at the end, to hack around some bug in Chrome v50/51
  // (See https://github.com/angular/angular.js/issues/14487.)
  // TODO (gkalpak): Remove workaround when Chrome v52 is released
  return Function.prototype.toString.call(fn) + ' ';
}
function isClass(func) {
    // IE 9-11 do not support classes and IE9 leaks with the code below.
    if (msie <= 11) {
      return false;
    }
    // Support: Edge 12-13 only
    // See: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/6156135/
    /*调用 stringifyFn字符串化后再用正则判断*/
    return typeof func === 'function'
      && /^(?:class\b|constructor\()/.test(stringifyFn(func));
  }

class Person {
  constructor(name) {
    this.name=name||"Default";
  }
}
console.log(stringifyFn(Person));
console.log(typeof Person === 'function');
console.log(isClass(Person));

class Person {
  constructor(name) {
    this.name=name||"Default";
  }
  // toString(){
  //   return 'Name:'+this.name;
  // }
}
true
true

injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
       function bootstrapApply(scope, element, compile, injector) {
        scope.$apply(function() { //rootScope
          element.data('$injector', injector);
          compile(element)(scope);
        });
      }]
    );

function Scope() {
   this.$id = nextUid();
   this.$$phase = this.$parent = this.$$watchers =
                  this.$$nextSibling = this.$$prevSibling =
                  this.$$childHead = this.$$childTail = null;
   this.$root = this;
   this.$$destroyed = false;
   this.$$listeners = {};
   this.$$listenerCount = {};
   this.$$watchersCount = 0;
   this.$$isolateBindings = null;
 }

 Scope.prototype = {
   constructor: Scope,
   $new: function(isolate, parent) {

   },
   //$apply方法就是在这定义的
     //expr 可以为function
   $apply: function(expr) {
     try {
              beginPhase('$apply');
              try {
                return this.$eval(expr);
              } finally {
                clearPhase();
              }
            } catch (e) {
              $exceptionHandler(e);
            } finally {
              try {
                $rootScope.$digest();
              } catch (e) {
                $exceptionHandler(e);
                throw e;
              }
            }
   }
   //省略
 };
    //定义了Scope对象
var $rootScope = new Scope();

 //The internal queues. Expose them on the $rootScope for debugging/testing purposes.
 var asyncQueue = $rootScope.$$asyncQueue = [];
 var postDigestQueue = $rootScope.$$postDigestQueue = [];
 var applyAsyncQueue = $rootScope.$$applyAsyncQueue = [];

 var postDigestQueuePosition = 0;

 return $rootScope;