private static void WriteObjectInitializer(CodeTextBuilder code, ObjectInitializerExpression expression)
{
if (expression.PropertyValues == null || expression.PropertyValues.Count == 0)
{
code.Write("{ }");
return;
}
code.WriteListStart(opener: "{", closer: "}", separator: ",", newLine: true);
foreach (var keyValue in expression.PropertyValues)
{
code.WriteListItem();
code.Write(keyValue.Name.GetSealedOrCased(CasingStyle.Camel, sealLanguage: LanguageInfo.Entries.JavaScript()));
if (keyValue.Value is IAssignable assignable && assignable.Name == keyValue.Name)
{
continue;
}
code.Write(": ");
WriteExpression(code, keyValue.Value);
}
code.WriteListEnd();
}
public static void WriteLiteral(CodeTextBuilder code, object value)
{
if (value == null)
{
code.Write("null");
}
else if (value is string @string)
{
WriteString(code, @string);
}
else if (value is bool @bool)
{
WriteBool(code, @bool);
}
else if (value is int @int)
{
WriteInteger(code, @int);
}
else if (value is float @float)
{
WriteFloat(code, @float);
}
else if (value is double @double)
{
WriteNumber(code, @double);
}
else if (value is Array @array)
{
WriteArray(code, @array);
}
else
{
throw new NotSupportedException($"Literal of type '{value.GetType().Name}' is not supported.");
}
}
private static void WriteBlock(CodeTextBuilder code, BlockStatement block)
{
foreach (var statement in block.Statements)
{
WriteStatementLine(code, statement);
}
}
public static void WriteImport(CodeTextBuilder code, ImportDirective import)
{
code.Write("import ");
if (import.AsDefault != null)
{
code.Write(import.AsDefault.Name);
}
else if (import.AsNamespace != null)
{
code.Write($"* as {import.AsNamespace.Name}");
}
else if (import.AsTuple != null)
{
JavaScriptExpressionWriter.WriteTuple(code, import.AsTuple);
}
if (import.From != null)
{
code.Write($" from '{import.From.GetModulePath()}'");
}
else if (import.What != null)
{
code.Write($"'{import.What.GetModulePath()}'");
}
code.WriteLine(";");
}
public static void WriteMember(CodeTextBuilder code, AbstractMember member)
{
WriteExportModifiers(code, member);
if (member is TypeMember type && type.TypeKind == TypeMemberKind.Class)
{
JavaScriptClassWriter.WriteClass(code, type);
}
public static void WriteStatementLine(CodeTextBuilder code, AbstractStatement statement)
{
WriteStatement(code, statement);
if (!(statement is BlockStatement))
{
code.WriteLine(";");
}
}
private static void WriteMember(CodeTextBuilder code, MemberExpression expression)
{
if (expression.Target != null)
{
WriteExpression(code, expression.Target);
code.Write(".");
}
code.Write(ToCamelCase(expression.MemberName ?? expression.Member.Name));
}
private static void WriteReturn(CodeTextBuilder code, ReturnStatement statement)
{
code.Write("return");
if (statement.Expression != null)
{
code.Write(" ");
JavaScriptExpressionWriter.WriteExpression(code, statement.Expression);
}
}
private static void WriteConditional(CodeTextBuilder code, ConditionalExpression expression)
{
code.Write("(");
WriteExpression(code, expression.Condition);
code.Write(" ? ");
WriteExpression(code, expression.WhenTrue);
code.Write(" : ");
WriteExpression(code, expression.WhenFalse);
code.Write(")");
}
public static void WriteParameter(CodeTextBuilder code, ParameterExpression expression)
{
if (expression.Parameter.Tuple != null)
{
WriteTuple(code, expression.Parameter.Tuple);
}
else
{
code.Write(ToCamelCase(expression.Parameter.Name));
}
}
private static void WriteBlockInsideBraces(CodeTextBuilder code, BlockStatement block)
{
code.WriteListStart(opener: "{", closer: "}", separator: "", newLine: true);
if (block != null)
{
WriteBlock(code, block);
}
code.WriteListEnd();
}
private static void WriteVariableDeclaration(CodeTextBuilder code, VariableDeclarationStatement statement)
{
code.Write(statement.Variable.IsFinal ? "const " : "let ");
code.Write(statement.Variable.Name);
if (statement.InitialValue != null)
{
code.Write(" = ");
JavaScriptExpressionWriter.WriteExpression(code, statement.InitialValue);
}
}
public static void WriteFunction(CodeTextBuilder code, MethodMember method)
{
WriteModifiers(code, method);
code.Write(method.Name.GetSealedOrCased(
CasingStyle.Camel,
sealOrigin: IdentifierName.OriginKind.Generator,
sealLanguage: LanguageInfo.Entries.JavaScript()));
WriteParameters(code, method.Signature);
WriteBody(code, method.Body);
code.WriteLine();
}
public static void WriteStatement(CodeTextBuilder code, AbstractStatement statement)
{
if (WriterByStatementType.TryGetValue(statement.GetType(), out var writer))
{
writer(code, statement);
}
else
{
throw new NotSupportedException(
$"Statement of type '{statement.GetType().Name}' is not supported by {nameof(JavaScriptStatementWriter)}.");
}
}
public static void WriteExpression(CodeTextBuilder code, AbstractExpression expression)
{
if (WriterByExpressionType.TryGetValue(expression.GetType(), out var writer))
{
writer(code, expression);
}
else
{
throw new NotSupportedException(
$"Expression of type '{expression.GetType().Name}' is not supported by {nameof(JavaScriptExpressionWriter)}.");
}
}
private static void WriteArray(CodeTextBuilder code, Array array)
{
code.WriteListStart(opener: "[", closer: "]", separator: ",");
foreach (var item in array)
{
code.WriteListItem();
WriteLiteral(code, item);
}
code.WriteListEnd();
}
private static void WriteBody(CodeTextBuilder code, BlockStatement body)
{
code.WriteLine("{");
code.Indent(1);
foreach (var statement in body.Statements)
{
JavaScriptStatementWriter.WriteStatementLine(code, statement);
}
code.Indent(-1);
code.Write("}");
}
private static void WriteIf(CodeTextBuilder code, IfStatement statement)
{
code.Write("if (");
JavaScriptExpressionWriter.WriteExpression(code, statement.Condition);
code.WriteLine(") ");
WriteBlockInsideBraces(code, statement.ThenBlock);
if (statement.ElseBlock != null)
{
WriteBlockInsideBraces(code, statement.ElseBlock);
}
}
private static void WriteDelegateInvocation(CodeTextBuilder code, DelegateInvocationExpression expression)
{
WriteExpression(code, expression.Delegate);
code.WriteListStart(opener: "(", separator: ", ", closer: ")");
foreach (var argument in expression.Arguments)
{
code.WriteListItem();
WriteExpression(code, argument.Expression);
}
code.WriteListEnd();
}
private static void WriteNewArray(CodeTextBuilder code, NewArrayExpression expression)
{
code.WriteListStart(opener: "[", closer: "]", separator: ",", newLine: true);
if (expression.DimensionInitializerValues != null)
{
foreach (var item in expression.DimensionInitializerValues.SelectMany(x => x))
{
code.WriteListItem();
WriteExpression(code, item);
}
}
code.WriteListEnd();
}
public static void WriteArrowFunction(CodeTextBuilder code, MethodSignature signature, BlockStatement body)
{
if (signature.IsAsync)
{
code.Write("async ");
}
if (signature.Parameters.Count != 1)
{
WriteParameters(code, signature);
}
else
{
code.Write($"{signature.Parameters[0].Name} ");
}
code.Write("=> ");
switch (body.Statements.Count)
{
case 0:
code.Write("{ }");
break;
case 1:
if (body.Statements[0] is ReturnStatement @return)
{
var needParentheses = (@return.Expression is ObjectInitializerExpression init && init.PropertyValues.Count > 1);
code.WriteIf(needParentheses, "(");
JavaScriptExpressionWriter.WriteExpression(code, @return.Expression);
code.WriteIf(needParentheses, ")");
}
else
{
// code.WriteLine();
// code.Indent(1);
JavaScriptStatementWriter.WriteStatement(code, body.Statements[0]);
// code.WriteLine();
// code.Indent(-1);
}
break;
default:
WriteBody(code, body);
break;
}
}
private static void WriteModifiers(CodeTextBuilder code, MethodMember method)
{
if (method.Modifier == MemberModifier.Static)
{
code.Write("static ");
}
if (method.IsAsync)
{
code.Write("async ");
}
if (method.DeclaringType == null)
{
code.Write("function ");
}
}
public static void WriteClass(CodeTextBuilder code, TypeMember type)
{
code.WriteLine($"class {type.Name} {{");
code.Indent(1);
type.Members.ForEach((member, index) => {
if (index > 0)
{
code.WriteLine();
}
JavaScriptMemberWriter.WriteMember(code, member);
});
code.Indent(-1);
code.WriteLine("}");
}
private static void WriteJsx(CodeTextBuilder code, XmlExpression expression)
{
if (expression.Xml == null)
{
code.Write("null");
return;
}
var xmlText = new StringBuilder();
var jsxWriter = new JsxCodeWriter(code);
code.WriteListStart(opener: "(", separator: "", closer: ")", newLine: true);
code.WriteListItem();
jsxWriter.Write(expression.Xml);
code.WriteListEnd();
}
private static void WriteMethodCall(CodeTextBuilder code, MethodCallExpression call)
{
if (call.Target != null)
{
WriteExpression(code, call.Target);
code.Write(".");
}
code.Write(ToCamelCase(call.MethodName ?? call.Method.Name));
code.WriteListStart(opener: "(", separator: ", ", closer: ")");
foreach (var argument in call.Arguments)
{
code.WriteListItem();
WriteExpression(code, argument.Expression);
}
code.WriteListEnd();
}
private static void WriteParameters(CodeTextBuilder code, MethodSignature signature)
{
code.WriteListStart(opener: "(", separator: ", ", closer: ") ");
signature.Parameters.ForEach(parameter => {
code.WriteListItem();
if (parameter.Tuple != null)
{
JavaScriptExpressionWriter.WriteTuple(code, parameter.Tuple);
}
else
{
code.Write(parameter.Name);
}
});
code.WriteListEnd();
}
private static void WriteString(CodeTextBuilder code, string s)
{
var result = new StringBuilder(capacity: s.Length + 4);
result.Append("\"");
for (int i = 0; i < s.Length; i++)
{
if (CharacterEscapes.TryGetValue(s[i], out var escape))
{
result.Append(escape);
}
else
{
result.Append(s[i]);
}
}
result.Append("\"");
code.Write(result.ToString());
}
public void WriteModule(ModuleMember module, bool privateScope = false)
{
_code = new CodeTextBuilder(_output.TextOptions);
WriteImports(module);
if (privateScope)
{
_code.WriteLine("(function() {");
_code.Indent(1);
}
WriteMembers(module);
WriteGlobalBlock(module);
if (privateScope)
{
_code.Indent(-1);
_code.WriteLine("}());");
}
_output.AddSourceFile(module.FolderPath, $"{module.Name.ToString(CasingStyle.Kebab)}.js", _code.ToString());
}
private static void WriteInterpolatedString(CodeTextBuilder code, InterpolatedStringExpression expression)
{
code.Write("`");
foreach (var part in expression.Parts)
{
switch (part)
{
case InterpolatedStringExpression.TextPart text:
WriteTextPart(text.Text);
break;
case InterpolatedStringExpression.InterpolationPart interpolation:
WriteInterpolationPart(interpolation);
break;
}
}
code.Write("`");
void WriteTextPart(string s)
{
for (int i = 0; i < s.Length; i++)
{
code.Write(InterpolatedEscapes.TryGetValue(s[i], out var escape)
? escape
: string.Empty + s[i]);
}
}
void WriteInterpolationPart(InterpolatedStringExpression.InterpolationPart interpolation)
{
code.Write("${");
WriteExpression(code, interpolation.Value);
code.Write("}");
}
}
private static void WriteNumber(CodeTextBuilder code, double value)
{
code.Write(value.ToString(CultureInfo.InvariantCulture));
}
