1 package jspacker 2 3 import ( 4 "fmt" 5 "iter" 6 "net/url" 7 "os" 8 "path/filepath" 9 "strings" 10 "text/template" 11 12 "vimagination.zapto.org/javascript" 13 "vimagination.zapto.org/javascript/jsx" 14 "vimagination.zapto.org/parser" 15 ) 16 17 // Option in a type that can be passed to Package to set an option. 18 type Option func(*config) 19 20 // File is an Option that specifies a starting file for Package. 21 func File(url string) Option { 22 return func(c *config) { 23 c.filesToDo = append(c.filesToDo, url) 24 } 25 } 26 27 // NoExports disables the creation of exports for any potential plugins. 28 func NoExports(c *config) { 29 c.bare = true 30 } 31 32 // Loader sets the func that will take URLs and produce a parsed module. 33 func Loader(l func(string) (*javascript.Module, error)) Option { 34 return func(c *config) { 35 c.loader = l 36 } 37 } 38 39 // ParseDynamic turns on dynamic import/include parsing. 40 func ParseDynamic(c *config) { 41 c.parseDynamic = true 42 } 43 44 // PrimaryExports keeps the export statements from the passed files. 45 func PrimaryExports(c *config) { 46 c.primary = true 47 } 48 49 // ResolveURL allows for custom import URL resolution. 50 // 51 // The function inputs are the URL for the current module and the import URL 52 // that needs resolving. 53 func ResolveURL(fn func(from, to string) string) Option { 54 return func(c *config) { 55 c.resolveURL = fn 56 } 57 } 58 59 type loadOpts struct { 60 disableTS bool 61 jsx *template.Template 62 } 63 64 // LoadOpt represents an option for the OSLoad Option. 65 type LoadOpt func(*loadOpts) 66 67 // DisableTS disables Typescript loading in the OSLoad Option. 68 func DisableTS(l *loadOpts) { 69 l.disableTS = true 70 } 71 72 // EnableJSX enables JSX/TSX parsing and processing in the OSLoad Option. 73 // 74 // The supplied JSX template should follow the rules specified in the jsx 75 // package docs: 76 // 77 // https://pkg.go.dev/vimagination.zapto.org/javascript/jsx#Process 78 func EnableJSX(jsx *template.Template) LoadOpt { 79 return func(l *loadOpts) { 80 l.jsx = jsx 81 } 82 } 83 84 const ( 85 jsSuffix = ".js" 86 tsSuffix = ".ts" 87 jsxSuffix = ".jsx" 88 tsxSuffix = ".tsx" 89 ) 90 91 func loadFns(base, urlPath string, allowTS, allowJSX bool, ts, jsx *bool) iter.Seq[func() (*os.File, error)] { 92 return func(yield func(func() (*os.File, error)) bool) { 93 for _, fn := range [...]func() (*os.File, error){ 94 func() (*os.File, error) { // Assume that any TSX file will be more up-to-date by default 95 if allowTS && allowJSX && strings.HasSuffix(urlPath, jsSuffix) { 96 *ts = true 97 *jsx = true 98 99 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath[:len(urlPath)-3]+tsxSuffix))) 100 } 101 102 return nil, nil 103 }, 104 func() (*os.File, error) { // Assume that any JSX file will be more up-to-date by default 105 if allowJSX && strings.HasSuffix(urlPath, jsSuffix) { 106 *ts = false 107 *jsx = true 108 109 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath[:len(urlPath)-3]+jsxSuffix))) 110 } 111 112 return nil, nil 113 }, 114 func() (*os.File, error) { // Assume that any TS file will be more up-to-date by default 115 if allowTS && strings.HasSuffix(urlPath, jsSuffix) { 116 *ts = true 117 *jsx = false 118 119 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath[:len(urlPath)-3]+tsSuffix))) 120 } 121 122 return nil, nil 123 }, 124 func() (*os.File, error) { // Normal 125 f, err := os.Open(filepath.Join(base, filepath.FromSlash(urlPath))) 126 if err == nil { 127 *ts = allowTS && (strings.HasSuffix(urlPath, tsSuffix) || allowJSX && strings.HasSuffix(urlPath, jsxSuffix)) 128 *jsx = allowJSX && (strings.HasSuffix(urlPath, jsxSuffix) || allowTS && strings.HasSuffix(urlPath, tsxSuffix)) 129 } 130 131 return f, err 132 }, 133 func() (*os.File, error) { // As URL 134 if u, err := url.Parse(urlPath); err == nil && u.Path != urlPath { 135 f, err := os.Open(filepath.Join(base, filepath.FromSlash(u.Path))) 136 if err == nil { 137 *ts = allowTS && (strings.HasSuffix(urlPath, tsSuffix) || allowJSX && strings.HasSuffix(urlPath, jsxSuffix)) 138 *jsx = allowJSX && (strings.HasSuffix(urlPath, jsxSuffix) || allowTS && strings.HasSuffix(urlPath, tsxSuffix)) 139 } 140 141 return f, err 142 } 143 144 return nil, nil 145 }, 146 func() (*os.File, error) { // Add TSX extension 147 if allowTS && allowJSX && !strings.HasSuffix(urlPath, tsSuffix) { 148 *ts = true 149 *jsx = true 150 151 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath+tsxSuffix))) 152 } 153 154 return nil, nil 155 }, 156 func() (*os.File, error) { // Add JSX extension 157 if allowJSX && !strings.HasSuffix(urlPath, tsSuffix) { 158 *ts = false 159 *jsx = true 160 161 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath+jsxSuffix))) 162 } 163 164 return nil, nil 165 }, 166 func() (*os.File, error) { // Add TS extension 167 if allowTS && !strings.HasSuffix(urlPath, tsSuffix) { 168 *ts = true 169 *jsx = false 170 171 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath+tsSuffix))) 172 } 173 174 return nil, nil 175 }, 176 func() (*os.File, error) { // Add JS extension 177 if !strings.HasSuffix(urlPath, jsSuffix) { 178 *ts = false 179 *jsx = false 180 181 return os.Open(filepath.Join(base, filepath.FromSlash(urlPath+jsSuffix))) 182 } 183 184 return nil, nil 185 }, 186 } { 187 if !yield(fn) { 188 return 189 } 190 } 191 } 192 } 193 194 // OSLoad is the default loader for Package, with the base set to CWD. 195 // 196 // By default, it will prefer Typescript files over JavaScript files, replacing 197 // a '.js' extension, if it exists, or with '.ts', or adding it if it does not. 198 // This behaviour can be disabled by providing the DisableTS option. 199 // 200 // JSX support can be added by providing the EnableJSX support with a valid 201 // template. 202 func OSLoad(base string, opts ...LoadOpt) func(string) (*javascript.Module, error) { 203 var l loadOpts 204 205 for _, opt := range opts { 206 opt(&l) 207 } 208 209 return func(urlPath string) (*javascript.Module, error) { 210 var ( 211 f *os.File 212 err error 213 ) 214 isTSX := strings.HasSuffix(base, tsxSuffix) 215 isTS := isTSX || strings.HasSuffix(base, tsSuffix) 216 isJSX := isTSX || strings.HasSuffix(base, jsxSuffix) 217 218 for loader := range loadFns(base, urlPath, !l.disableTS, l.jsx != nil, &isTS, &isJSX) { 219 fb, errr := loader() 220 if fb != nil { 221 f = fb 222 223 break 224 } else if err == nil { 225 err = errr 226 } 227 } 228 229 if f == nil { 230 return nil, fmt.Errorf("error opening file (%s): %w", urlPath, err) 231 } 232 233 defer f.Close() 234 235 rt := parser.NewReaderTokeniser(f) 236 237 var tks javascript.Tokeniser = &rt 238 239 if isTS { 240 tks = javascript.AsTypescript(tks) 241 } 242 243 if isJSX { 244 tks = javascript.AsJSX(tks) 245 } 246 247 m, err := javascript.ParseModule(tks) 248 if err != nil { 249 return nil, fmt.Errorf("error parsing file (%s): %w", urlPath, err) 250 } 251 252 if isJSX { 253 if err = jsx.Process(m, l.jsx); err != nil { 254 return nil, fmt.Errorf("error processing file (%s) as JSX: %w", urlPath, err) 255 } 256 } 257 258 return m, nil 259 } 260 } 261