public static JsTypeFunction Define(string name, JsTypeFunction prototype) { JsTypeFunction typeFunction = null; // Create constructor function, which is a superconstructor that takes in the actual // constructor as the first argument, and the rest of the arguments are passed directly // to that constructor. These subconstructors are not Javascript constructors -- they // are not called via new, they exist for initialization only. typeFunction = Jsni.function(constructor => { if (constructor != null || !(Jsni.instanceof(Jsni.@this(), typeFunction))) { Jsni.invoke(Jsni.member(typeFunction, SpecialNames.StaticInitializer)); } if (constructor != null) { Jsni.apply(constructor, Jsni.@this(), Jsni.call(Jsni.reference("Array.prototype.slice"), Jsni.arguments(), 1.As < JsObject > ()).As <JsArray>()); } if (!Jsni.instanceof(Jsni.@this(), typeFunction)) { return(typeFunction); } else { return(Jsni.@this()); } }).As <JsTypeFunction>(); Jsni.memberset(typeFunction, "toString", Jsni.function(() => name.As <JsObject>())); Jsni.memberset(typeFunction, SpecialNames.TypeName, name.As <JsString>()); Jsni.memberset(typeFunction, "prototype", Jsni.@new(prototype)); return(typeFunction); }
public static JsFunction CreateDelegate(JsObject thisExpression, JsFunction lambda, JsTypeFunction delegateType = null, string delegateKey = null) { delegateType = delegateType ?? Jsni.reference("System.Delegate").As <JsTypeFunction>(); JsFunction delegateFunc = null; delegateFunc = Jsni.function(() => { return(lambda.apply(delegateFunc.As <Delegate>().Target.As <JsObject>(), Jsni.arguments().As <JsArray>())); }); delegateFunc.prototype = Jsni.@new(delegateType); delegateFunc.memberset("get_Target", Jsni.function(() => thisExpression)); delegateFunc.memberset("GetType", Jsni.function(() => delegateType.GetTypeFromType.invoke())); Jsni.memberset(delegateFunc, SpecialNames.TypeField, delegateType); Jsni.memberset(delegateFunc, "Invoke", delegateFunc); Jsni.memberset(delegateFunc, "DynamicInvoke", Jsni.function(args => delegateFunc.apply(delegateFunc, args.As <JsArray>()))); Jsni.memberset(delegateFunc, "GetHashCode", Jsni.function(() => lambda.toString().GetHashCode().As <JsObject>())); Jsni.memberset(delegateFunc, "lambda", lambda); Jsni.memberset(delegateFunc, "Equals", Jsni.function(x => x != null && lambda == x.member("lambda"))); return(delegateFunc); }
public static JsTypeFunction Define(JsFunction assembly, JsTypeFunction enclosingType, string name, bool isGenericType, JsArray typeParameters, JsObject prototype, JsFunction typeInitializer) { JsTypeFunction typeFunction = null; var isTypeInitialized = false; // Create constructor function, which is a superconstructor that takes in the actual // constructor as the first argument, and the rest of the arguments are passed directly // to that constructor. These subconstructors are not Javascript constructors -- they // are not called via new, they exist for initialization only. typeFunction = Jsni.function((constructor, args) => { if (constructor != null || !(Jsni.instanceof(Jsni.@this(), typeFunction))) { if (!isGenericType || typeFunction.UnconstructedType != null) { typeFunction.member(SpecialNames.StaticInitializer).invoke(); } } if (constructor != null) { constructor.apply(Jsni.@this(), args.As <JsArray>()); } if (!Jsni.instanceof(Jsni.@this(), typeFunction)) { return(typeFunction); } else { return(Jsni.@this()); } }).As <JsTypeFunction>(); typeFunction.GetAssembly = assembly; assembly.member(SpecialNames.AssemblyTypesArray).member("push").invoke(typeFunction); typeFunction.memberset("toString", Jsni.function(() => name.As <JsObject>())); typeFunction.EnclosingType = enclosingType; typeFunction.TypeName = name; typeFunction.prototype = Jsni.@new(prototype); typeFunction.IsPrototypeInitialized = false; typeFunction.TypeInitializer = Jsni.procedure((_t, p) => { var t = _t.As <JsTypeFunction>(); if (isGenericType) { var unconstructedType = t.UnconstructedType ?? t; t.GenericTypeFunction = Jsni.function(() => { return(Jsni.reference(SpecialNames.MakeGenericTypeConstructor).As <JsFunction>().call(unconstructedType, unconstructedType, Jsni.arguments()).As <JsFunction>().invoke()); }); } t.GetTypeFromType = Jsni.function(() => { return(Type._GetTypeFromTypeFunc(Jsni.@this().As <JsTypeFunction>()).As <JsObject>()); }); p.memberset(SpecialNames.TypeName, t.member(SpecialNames.TypeName)); p.___type = t; t.BaseType = prototype.As <JsTypeFunction>(); typeInitializer.apply(Jsni.@this(), Jsni.arguments().As <JsArray>()); }); typeFunction.CallTypeInitializer = Jsni.procedure(() => { typeFunction.TypeInitializer.apply(enclosingType, Jsni.array(typeFunction, typeFunction.prototype).concat(typeParameters)); }); return(typeFunction); }