private static void GenerateNamedParametersValue(ActionModel action, FunctionMember method)
{
var namedParameters = action.Parameters.Where(x => !x.IsUrlParam && !x.IsData).ToArray();
if (namedParameters.Length == 0)
{
method.Body.Statements.Add("{}");
return;
}
//this optimalization cannot be done due to renaming params signature=>urlName
//if (namedParameters.All(p => p.IsOptional))
//{
// method.Body.Statements.Add("opt");
// return;
//}
var pilist = new List <string>();
foreach (var p in namedParameters)
{
var pinvoke = "'" + (p.UrlName ?? p.Name) + "': ";
pinvoke += p.IsOptional ? ("opt['" + p.Name + "']") : p.Name;
pilist.Add(pinvoke);
}
method.Body.Statements.Add("{ ");
method.Body.Statements.Add(String.Join(", ", pilist));
method.Body.Statements.Add(" }");
}
public virtual void VisitFunctionMember(FunctionMember fn)
{
VisitFunctionMemberBase(fn);
if (fn.Body != null)
{
VisitRaw(fn.Body);
}
}
public virtual FunctionMember RewriteFunctionMember(FunctionMember fn)
{
var result = new FunctionMember(fn.Name, RewriteRaw(fn.Body))
{
Accessibility = RewriteAccessibility(fn.Accessibility),
Comment = RewriteComment(fn.Comment),
ExtraData = RewriteExtraData(fn),
ResultType = RewriteTypeReference(fn.ResultType),
};
result.GenericParameters.AddRange(fn.GenericParameters.Select(RewriteGenericParameter).Where(x => x != null));
result.Parameters.AddRange(fn.Parameters.Select(RewriteFunctionParameter).Where(x => x != null));
return(result);
}
private static void GenerateUrlParametersValue(ActionModel action, FunctionMember method)
{
var urlVar = "'" + action.UrlTemplate.TrimEnd('/') + "'";
foreach (var p in action.Parameters.Where(x => x.IsUrlParam))
{
var paramName = p.UrlName ?? p.Name;
urlVar = urlVar.Replace("{" + paramName + "}", "' + " + p.Name + " + '");
}
var EMPTYJS = " + ''";
while (urlVar.EndsWith(EMPTYJS, StringComparison.InvariantCulture))
{
urlVar = urlVar.Substring(0, urlVar.Length - EMPTYJS.Length);
}
method.Body.Statements.Add(urlVar);
}
private static void GenerateMethodParametersSignature(ActionModel action, FunctionMember method, ReflectionGeneratorBase reflectionGenerator)
{
method.Parameters.AddRange(action.Parameters
.Where(p => !p.IsOptional)
.Select(p => new FunctionParameter(p.Name)
{
ParameterType = reflectionGenerator.GenerateFromType(p.Type),
IsOptional = false
}));
//consider:
// if there is only one optional parameter, or all opt. parameters are last (it must be in c# decl),
// we can generate myMethod(p1,p2,..., po1:string? = null, po2:number? = null)
// but, it is needed then to call it with positional params (TypeScript doesn't know named params)
// xxx.myMethod("asd","qwe",...,null, 42)
//compare to: call via optional properties of anonymous object
// xxx.myMethod("asd","qwe",..., { po2: 42} )
// BUT, it can be called with any object, because all positional parameters are optional, so any object will match
// xxx.myMethod("asd","qwe",..., "nonsense" )
// partially solved:
// positional parameters are unions of non-nullable parameter objects (see code)
// but this approach will still validate only one of parameters, others are than ignored (because at least one matched)
if (action.Parameters.Any(p => p.IsOptional))
{
var optParams = action.Parameters
.Where(p => p.IsOptional)
.Select(p => new RawStatements("{ ", p.Name, ": ", reflectionGenerator.GenerateFromType(p.Type), " }"))
.ToArray();
var raw = new RawStatements();
foreach (var item in optParams)
{
raw.Add(item);
if (item != optParams.Last())
{
raw.Add(" | ");
}
raw.Add(" ");
}
raw.Add(" = <any>{}");
method.Parameters.Add(new FunctionParameter("opt")
{
ParameterType = new TypescriptTypeReference(raw)
});
}
}
private FunctionMember GenerateAction(ActionModel action, ReflectionGeneratorBase reflectionGenerator)
{
var method = new FunctionMember(action.Name + "Async", null)
{
Accessibility = AccessibilityEnum.Public,
Comment = GenerateActionComment(action)
};
GenerateMethodParametersSignature(action, method, reflectionGenerator);
if (action.ResultType != null)
{
method.ResultType = new TypescriptTypeReference(PromiseTypeName)
{
GenericParameters = { reflectionGenerator.GenerateFromType(action.ResultType) }
};
}
else
{
method.ResultType = new TypescriptTypeReference(PromiseTypeName)
{
GenericParameters = { PrimitiveType.Void }
};
}
method.Body = new RawStatements();
method.Body.Statements.Add("return this._parent.call" + action.HttpMethod + "(");
GenerateUrlParametersValue(action, method);
method.Body.Statements.Add(", ");
GenerateNamedParametersValue(action, method);
var dataParam = action.Parameters.FirstOrDefault(p => p.IsData);
if (dataParam != null)
{
method.Body.Statements.Add(", " + dataParam.Name);
if (dataParam.IsData)
{
method.Body.Statements.Add("/* DATA */");
}
}
method.Body.Statements.Add(");");
return(method);
}
public object GetValue(object[] args = null)
{
if (FieldMember != null)
{
return(FieldMember.GetValue(ReferencedObject));
}
if (PropertyMember != null)
{
return(PropertyMember.GetValue(ReferencedObject, null));
}
if (FunctionMember != null)
{
return(FunctionMember.Invoke(FunctionMember.IsStatic ? null : ReferencedObject, args));
}
if (FunctionOverloads != null)
{
throw new Exception("!!");
}
return(ReferencedObject);
}
public void TestFunctions()
{
var cls = new ClassType("testFunctions");
{
var fn = new FunctionDeclarationMember("fn1");
cls.Members.Add(fn);
}
{
var fn = new FunctionDeclarationMember("fn2")
{
ResultType = new ArrayType(cls)
};
cls.Members.Add(fn);
}
{
var fn = new FunctionDeclarationMember("fn3")
{
Parameters =
{
new FunctionParameter("a")
{
ParameterType = PrimitiveType.Number
},
new FunctionParameter("b")
{
ParameterType = PrimitiveType.Boolean, IsOptional = true
},
new FunctionParameter("c"),
new FunctionParameter("d")
{
IsRest = true, ParameterType = new ArrayType(PrimitiveType.String)
},
}
};
cls.Members.Add(fn);
}
{
var fn = new FunctionDeclarationMember("fn4")
{
GenericParameters =
{
new GenericParameter("T"),
new GenericParameter("T2")
{
Constraint = cls
},
},
Parameters =
{
new FunctionParameter("p1")
{
ParameterType = new TypescriptTypeReference("T2")
},
}
};
cls.Members.Add(fn);
}
{
var fn = new FunctionMember("fn5", new RawStatements("return true;"))
{
Parameters = { new FunctionParameter("arg")
{
ParameterType = PrimitiveType.Boolean
} },
};
cls.Members.Add(fn);
}
{
var fn = new FunctionMember("fn6", null)
{
Parameters = { new FunctionParameter("arg")
{
ParameterType = PrimitiveType.String, DefaultValue = new RawStatements("'42'")
} },
};
cls.Members.Add(fn);
}
Assert.AreEqual(@"
class testFunctions {
fn1();
fn2(): testFunctions[];
fn3(a: number, b?: boolean, c, ...d: string[]);
fn4<T, T2 extends testFunctions>(p1: T2);
fn5(arg: boolean) {
return true;
}
fn6(arg: string = '42') {
}
}
".Trim(), testGen(cls));
}
