javascript - jsx.go

     1  package jsx
     2  
     3  import (
     4  	"errors"
     5  	"slices"
     6  	"strconv"
     7  	"strings"
     8  	"text/template"
     9  
    10  	"vimagination.zapto.org/javascript"
    11  	"vimagination.zapto.org/javascript/scope"
    12  	"vimagination.zapto.org/javascript/walk"
    13  	"vimagination.zapto.org/parser"
    14  )
    15  
    16  const (
    17  	tagName  = "TAG_NAME"
    18  	children = "CHILDREN"
    19  	params   = "PARAMS"
    20  )
    21  
    22  type jsxTransformer struct {
    23  	identifiers map[string]map[string][]scope.Binding
    24  	tmpl        *template.Template
    25  	namespace   string
    26  }
    27  
    28  func (j *jsxTransformer) Handle(t javascript.Type) error {
    29  	ns := j.namespace
    30  
    31  	if err := walk.Walk(t, j); err != nil {
    32  		return err
    33  	}
    34  
    35  	j.namespace = ns
    36  
    37  	switch t := t.(type) {
    38  	case *javascript.JSXAttribute:
    39  		if t.JSXElement != nil {
    40  			pe, err := j.transform(t.JSXElement)
    41  			if err != nil {
    42  				return err
    43  			}
    44  
    45  			t.AssignmentExpression = &javascript.AssignmentExpression{
    46  				ConditionalExpression: javascript.WrapConditional(pe),
    47  			}
    48  			t.JSXElement = nil
    49  		} else if t.JSXFragment != nil {
    50  			t.AssignmentExpression = &javascript.AssignmentExpression{
    51  				ConditionalExpression: javascript.WrapConditional(childrenToArray(t.JSXFragment.Children)),
    52  			}
    53  			t.JSXFragment = nil
    54  		} else if t.JSXString != nil {
    55  			str, err := javascript.UnescapeJSXString(t.JSXString.Data)
    56  			if err != nil {
    57  				return err
    58  			}
    59  
    60  			t.AssignmentExpression = &javascript.AssignmentExpression{
    61  				ConditionalExpression: javascript.WrapConditional(&javascript.PrimaryExpression{
    62  					Literal: &javascript.Token{
    63  						Token: parser.Token{
    64  							Data: strconv.Quote(str),
    65  							Type: javascript.TokenStringLiteral,
    66  						},
    67  						Pos:     t.JSXString.Pos,
    68  						Line:    t.JSXString.Line,
    69  						LinePos: t.JSXString.LinePos,
    70  					},
    71  				}),
    72  			}
    73  			t.JSXString = nil
    74  		} else if t.AssignmentExpression == nil {
    75  			return javascript.ErrInvalidAssignment
    76  		}
    77  	case *javascript.JSXChild:
    78  		if t.JSXElement != nil {
    79  			pe, err := j.transform(t.JSXElement)
    80  			if err != nil {
    81  				return err
    82  			}
    83  
    84  			t.JSXChildExpression = &javascript.AssignmentExpression{
    85  				ConditionalExpression: javascript.WrapConditional(pe),
    86  			}
    87  			t.JSXElement = nil
    88  		} else if t.JSXFragment != nil {
    89  			t.JSXChildExpression = &javascript.AssignmentExpression{
    90  				ConditionalExpression: javascript.WrapConditional(childrenToArray(t.JSXFragment.Children)),
    91  			}
    92  			t.JSXFragment = nil
    93  		}
    94  	case *javascript.PrimaryExpression:
    95  		if t.JSXElement != nil {
    96  			pe, err := j.transform(t.JSXElement)
    97  			if err != nil {
    98  				return err
    99  			}
   100  
   101  			*t = *pe
   102  		} else if t.JSXFragment != nil {
   103  			t.ArrayLiteral = childrenToArray(t.JSXFragment.Children)
   104  			t.JSXFragment = nil
   105  		}
   106  	}
   107  
   108  	return nil
   109  }
   110  
   111  func childrenToArray(children []javascript.JSXChild) *javascript.ArrayLiteral {
   112  	al := &javascript.ArrayLiteral{
   113  		ElementList: make([]javascript.ArrayElement, 0, len(children)),
   114  	}
   115  
   116  	for _, child := range children {
   117  		al.ElementList = append(al.ElementList, javascript.ArrayElement{
   118  			Spread:               child.Spread,
   119  			AssignmentExpression: *child.JSXChildExpression,
   120  		})
   121  	}
   122  
   123  	return al
   124  }
   125  
   126  var (
   127  	htmlElements = [...]string{"a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "link", "main", "map", "mark", "menu", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "search", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr"}
   128  	svgElements  = [...]string{"a", "animate", "animateMotion", "animateTransform", "circle", "clipPath", "defs", "desc", "ellipse", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "filter", "foreignObject", "g", "image", "line", "linearGradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "script", "set", "stop", "style", "svg", "switch", "symbol", "text", "textPath", "title", "tspan", "use", "view"}
   129  )
   130  
   131  type templateVars struct {
   132  	Namespace     string
   133  	InHTML, InSVG bool
   134  }
   135  
   136  func (j *jsxTransformer) transform(e *javascript.JSXElement) (*javascript.PrimaryExpression, error) {
   137  	name := e.ElementName.Identifier
   138  	if name == nil {
   139  		return nil, javascript.ErrInvalidAssignment
   140  	}
   141  
   142  	inHTML, inSVG := slices.Contains(htmlElements[:], name.Data), slices.Contains(svgElements[:], name.Data)
   143  	if inHTML && !inSVG {
   144  		j.namespace = "html"
   145  	} else if inSVG && !inHTML {
   146  		j.namespace = "svg"
   147  	}
   148  
   149  	var sb strings.Builder
   150  
   151  	if err := j.tmpl.Execute(&sb, templateVars{
   152  		Namespace: j.namespace,
   153  		InHTML:    inHTML,
   154  		InSVG:     inSVG,
   155  	}); err != nil {
   156  		return nil, err
   157  	}
   158  
   159  	tk := parser.NewStringTokeniser(sb.String())
   160  
   161  	m, err := javascript.ParseModule(&tk)
   162  	if err != nil {
   163  		return nil, err
   164  	}
   165  
   166  	return j.process(e, m)
   167  }
   168  
   169  func (j *jsxTransformer) process(e *javascript.JSXElement, m *javascript.Module) (*javascript.PrimaryExpression, error) {
   170  	replaceTagName(m, e.ElementName.Identifier.Data)
   171  
   172  	s, err := scope.ModuleScope(m, nil)
   173  	if err != nil {
   174  		return nil, err
   175  	}
   176  
   177  	delete(s.Bindings, params)
   178  	delete(s.Bindings, children)
   179  
   180  	replaceParamsAndChildren(m, e)
   181  	j.gatherIdentifiers(m, s)
   182  
   183  	var expression *javascript.Expression
   184  
   185  	for _, mi := range m.ModuleListItems {
   186  		if mi.ImportDeclaration != nil {
   187  			continue
   188  		} else if expression != nil {
   189  			return nil, ErrTooManyStatements
   190  		} else if mi.StatementListItem != nil && mi.StatementListItem.Statement != nil && mi.StatementListItem.Statement.ExpressionStatement != nil {
   191  			expression = mi.StatementListItem.Statement.ExpressionStatement
   192  		} else {
   193  			return nil, ErrInvalidTransformation
   194  		}
   195  	}
   196  
   197  	return &javascript.PrimaryExpression{
   198  		ParenthesizedExpression: &javascript.ParenthesizedExpression{
   199  			Expressions: expression.Expressions,
   200  		},
   201  	}, nil
   202  }
   203  
   204  func replaceTagName(m *javascript.Module, name string) {
   205  	var h walk.Handler
   206  
   207  	h = walk.HandlerFunc(func(t javascript.Type) error {
   208  		walk.Walk(t, h)
   209  
   210  		switch t := t.(type) {
   211  		case *javascript.PrimaryExpression:
   212  			if t.Literal != nil && t.Literal.Type == javascript.TokenStringLiteral {
   213  				if str, _ := javascript.Unquote(t.Literal.Data); str == tagName {
   214  					t.Literal.Data = strconv.Quote(name)
   215  				}
   216  			} else if t.IdentifierReference != nil && t.IdentifierReference.Data == tagName {
   217  				t.IdentifierReference.Data = name
   218  			}
   219  		case *javascript.ImportClause:
   220  			if t.ImportedDefaultBinding != nil && t.ImportedDefaultBinding.Data == tagName {
   221  				t.ImportedDefaultBinding.Data = name
   222  			} else if t.NameSpaceImport != nil && t.NameSpaceImport.Data == tagName {
   223  				t.NameSpaceImport.Data = name
   224  			}
   225  		case *javascript.ImportSpecifier:
   226  			if t.IdentifierName != nil && t.IdentifierName.Data == tagName {
   227  				t.IdentifierName.Data = name
   228  			}
   229  		}
   230  
   231  		return nil
   232  	})
   233  
   234  	walk.Walk(m, h)
   235  }
   236  
   237  func replaceParamsAndChildren(m *javascript.Module, e *javascript.JSXElement) {
   238  	var h walk.Handler
   239  
   240  	h = walk.HandlerFunc(func(t javascript.Type) error {
   241  		walk.Walk(t, h)
   242  
   243  		switch t := t.(type) {
   244  		case *javascript.PrimaryExpression:
   245  			if t.IdentifierReference != nil {
   246  				switch t.IdentifierReference.Data {
   247  				case "PARAMS":
   248  					t.IdentifierReference = nil
   249  					t.ObjectLiteral = paramsToObject(e.Attributes)
   250  				case "CHILDREN":
   251  					t.IdentifierReference = nil
   252  					t.ArrayLiteral = childrenToArray(e.Children)
   253  				}
   254  			}
   255  		}
   256  
   257  		return nil
   258  	})
   259  
   260  	walk.Walk(m, h)
   261  }
   262  
   263  type importIdent struct {
   264  	tk       *javascript.Token
   265  	contains bool
   266  }
   267  
   268  func (i *importIdent) Handle(t javascript.Type) error {
   269  	switch t := t.(type) {
   270  	case *javascript.ImportClause:
   271  		if t.ImportedDefaultBinding == i.tk || t.NameSpaceImport == i.tk {
   272  			i.contains = true
   273  		}
   274  	case *javascript.ImportSpecifier:
   275  		if t.IdentifierName == i.tk {
   276  			i.contains = true
   277  		}
   278  	default:
   279  		walk.Walk(t, i)
   280  	}
   281  
   282  	return nil
   283  }
   284  
   285  func (j *jsxTransformer) gatherIdentifiers(m *javascript.Module, s *scope.Scope) {
   286  	imports := make(map[*javascript.Token]string)
   287  
   288  	for _, b := range s.Bindings {
   289  		if b[0].BindingType == scope.BindingImport {
   290  			for _, mi := range m.ModuleListItems {
   291  				if mi.ImportDeclaration != nil {
   292  					ii := importIdent{tk: b[0].Token}
   293  
   294  					walk.Walk(mi, &ii)
   295  
   296  					if ii.contains {
   297  						imports[b[0].Token] = mi.ImportDeclaration.FromClause.ModuleSpecifier.Data
   298  
   299  						break
   300  					}
   301  				}
   302  			}
   303  		}
   304  	}
   305  
   306  	for _, b := range s.Bindings {
   307  		is := imports[b[0].Token]
   308  		ident := b[0].Token.Data
   309  
   310  		imp, ok := j.identifiers[ident]
   311  		if !ok {
   312  			imp = make(map[string][]scope.Binding)
   313  			j.identifiers[ident] = imp
   314  		}
   315  
   316  		imp[is] = append(imp[is], b[1:]...)
   317  	}
   318  }
   319  
   320  func paramsToObject(attrs []javascript.JSXAttribute) *javascript.ObjectLiteral {
   321  	ol := &javascript.ObjectLiteral{
   322  		PropertyDefinitionList: make([]javascript.PropertyDefinition, 0, len(attrs)),
   323  	}
   324  
   325  	for _, attr := range attrs {
   326  		if attr.Identifier == nil {
   327  			if attr.AssignmentExpression == nil {
   328  				return nil
   329  			}
   330  
   331  			ol.PropertyDefinitionList = append(ol.PropertyDefinitionList, javascript.PropertyDefinition{
   332  				AssignmentExpression: attr.AssignmentExpression,
   333  			})
   334  		} else {
   335  			ol.PropertyDefinitionList = append(ol.PropertyDefinitionList, javascript.PropertyDefinition{
   336  				PropertyName: &javascript.PropertyName{
   337  					LiteralPropertyName: attr.Identifier,
   338  				},
   339  				AssignmentExpression: attr.AssignmentExpression,
   340  			})
   341  		}
   342  	}
   343  
   344  	return ol
   345  }
   346  
   347  func Process(m *javascript.Module, tmpl *template.Template) error {
   348  	j := &jsxTransformer{
   349  		identifiers: make(map[string]map[string][]scope.Binding),
   350  		tmpl:        tmpl,
   351  	}
   352  
   353  	if err := walk.Walk(m, j); err != nil {
   354  		return err
   355  	}
   356  
   357  	return nil
   358  }
   359  
   360  var (
   361  	ErrInvalidTransformation = errors.New("invalid transformation")
   362  	ErrTooManyStatements     = errors.New("too many statments")
   363  )
   364