public FigmaCodeNode(FigmaNode node, string name = null, bool isClass = false, FigmaCodeNode parent = null)
{
Node = node;
Name = name;
IsClass = isClass;
Parent = parent;
}
internal virtual FigmaNode[] GetChildrenToRender(FigmaCodeNode node)
{
if (node.Node is IFigmaNodeContainer nodeContainer)
{
return(nodeContainer.children);
}
return(new FigmaNode[0]);
}
public bool NodeRendersVar(FigmaCodeNode currentNode, FigmaCodeNode parentNode)
{
if (currentNode.Node.GetNodeTypeName() == "mastercontent")
{
return(false);
}
return(!currentNode.Node.TryGetNodeCustomName(out var _));
}
FigmaViewConverter GetConverter(FigmaCodeNode node, FigmaViewConverter[] converters)
{
foreach (var customViewConverter in converters)
{
if (customViewConverter.CanConvert(node.Node))
{
return(customViewConverter);
}
}
return(null);
}
internal virtual bool NeedsRenderConstructor(FigmaCodeNode node, FigmaCodeNode parent)
{
if (parent != null &&
IsMainNode(parent.Node) &&
(CurrentRendererOptions?.RendersConstructorFirstElement ?? false)
)
{
return(false);
}
else
{
return(true);
}
}
protected virtual bool TryGetCodeViewName(FigmaCodeNode node, FigmaCodeNode parent, FigmaViewConverter converter, out string identifier)
{
try {
identifier = converter.GetType().Name;
if (identifier.StartsWith(init))
{
identifier = identifier.Substring(init.Length);
}
if (identifier.EndsWith(end))
{
identifier = identifier.Substring(0, identifier.Length - end.Length);
}
identifier = char.ToLower(identifier[0]) + identifier.Substring(1) + ViewIdentifier;
return(true);
} catch (Exception) {
identifier = null;
return(false);
}
}
public void GetCode(StringBuilder builder, FigmaCodeNode node, FigmaCodeNode parent = null, FigmaCodeRendererServiceOptions currentRendererOptions = null)
{
//in first level we clear all identifiers
if (parent == null)
{
if (MainNode == null)
{
//clear all nodes
Nodes.Clear();
identifiers.Clear();
OnStartGetCode();
//we initialize
CurrentRendererOptions = currentRendererOptions ?? new FigmaCodeRendererServiceOptions();
//we store our main node
MainNode = node;
ParentMainNode = parent;
}
}
if (node != null)
{
Nodes.Add(node);
}
FigmaCodeNode calculatedParentNode = null;
FigmaViewConverter converter = null;
var isNodeSkipped = IsNodeSkipped(node);
//on node skipped we don't render
if (!isNodeSkipped)
{
//if (figmaProvider.RendersProperties (node)) {
converter = GetConverter(node, customConverters);
//bool navigateChild = true;
if (converter == null)
{
converter = GetConverter(node, figmaConverters);
}
if (converter != null)
{
if (!node.HasName)
{
if (!TryGetCodeViewName(node, parent, converter, out string identifier))
{
identifier = DefaultViewName;
}
//we store our name to don't generate dupplicates
var lastIndex = GetLastInsertedIndex(identifier);
if (lastIndex >= 0)
{
identifiers.Remove(identifier);
}
lastIndex++;
node.Name = identifier;
if (lastIndex > 0)
{
node.Name += lastIndex;
}
identifiers.Add(identifier, lastIndex);
}
builder.AppendLine();
builder.AppendLine($"// View: {node.Name}");
builder.AppendLine($"// NodeName: {node.Node.name}");
builder.AppendLine($"// NodeType: {node.Node.type}");
builder.AppendLine($"// NodeId: {node.Node.id}");
OnPreConvertToCode(builder, node, parent, converter, codePropertyConverter);
//we generate our code and replace node name
var code = converter.ConvertToCode(node, parent, this);
builder.AppendLineIfValue(code.Replace(Resources.Ids.Conversion.NameIdentifier, node.Name));
OnPostConvertToCode(builder, node, parent, converter, codePropertyConverter);
if (RendersAddChild(node, parent, this))
{
builder.AppendLineIfValue(codePropertyConverter.ConvertToCode(CodeProperties.AddChild, node, parent, this));
OnChildAdded(builder, node, parent, converter, codePropertyConverter);
}
if (RendersSize(node, parent, this))
{
builder.AppendLineIfValue(codePropertyConverter.ConvertToCode(CodeProperties.Frame, node, parent, this));
OnFrameSet(builder, node, parent, converter, codePropertyConverter);
}
if (RendersConstraints(node, parent, this))
{
builder.AppendLineIfValue(codePropertyConverter.ConvertToCode(CodeProperties.Constraints, node, parent, this));
}
calculatedParentNode = node;
}
else
{
//without a converter we don't have any view created, we need to attach to the parent view
calculatedParentNode = parent;
}
}
//without converter we scan the children automatically
var navigateChild = converter?.ScanChildren(node.Node) ?? true;
if (navigateChild && HasChildrenToRender(node))
{
foreach (var item in GetChildrenToRender(node))
{
var figmaNode = new FigmaCodeNode(item, parent: node);
GetCode(builder, figmaNode, calculatedParentNode);
}
}
if (MainNode == node)
{
//first loop
Clear();
}
}
public virtual void Clear()
{
CurrentRendererOptions = null;
ParentMainNode = null;
MainNode = null;
}
internal virtual bool IsNodeSkipped(FigmaCodeNode node)
{
return(false);
}
internal virtual bool HasChildrenToRender(FigmaCodeNode node)
{
return(node.Node is IFigmaNodeContainer);
}
internal virtual bool IsMainViewContainer(FigmaCodeNode node)
{
return(true);
}
protected virtual void OnFrameSet(StringBuilder builder, FigmaCodeNode node, FigmaCodeNode parent, FigmaViewConverter converter, FigmaCodePropertyConverterBase codePropertyConverter)
{
}
protected virtual bool RendersAddChild(FigmaCodeNode node, FigmaCodeNode parent, FigmaCodeRendererService figmaCodeRendererService)
{
return(true);
}
protected virtual bool RendersConstraints(FigmaCodeNode node, FigmaCodeNode parent, FigmaCodeRendererService figmaCodeRendererService)
{
return(!((node != null && node == MainNode) || node.Node is FigmaCanvas || node.Node.Parent is FigmaCanvas));
}
