diff options
author | Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com> | 2020-10-05 13:34:14 +0200 |
---|---|---|
committer | Bjørn Erik Pedersen <bjorn.erik.pedersen@gmail.com> | 2020-11-03 13:04:37 +0100 |
commit | 85e4dd7370eae97ae367e596aa6a10ba42fd4b7c (patch) | |
tree | 23e739edbed24a62f842c1a3ebc1d9cb706ea8b7 /resources/resource_transformers/js/options.go | |
parent | 3089fc0ba171be14670b19439bc2eab6b077b6c3 (diff) |
Make js.Build fully support modules
Fixes #7816
Fixes #7777
Fixes #7916
Diffstat (limited to 'resources/resource_transformers/js/options.go')
-rw-r--r-- | resources/resource_transformers/js/options.go | 353 |
1 files changed, 353 insertions, 0 deletions
diff --git a/resources/resource_transformers/js/options.go b/resources/resource_transformers/js/options.go new file mode 100644 index 000000000..5e74982d3 --- /dev/null +++ b/resources/resource_transformers/js/options.go @@ -0,0 +1,353 @@ +// Copyright 2020 The Hugo Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package js + +import ( + "encoding/json" + "fmt" + "path/filepath" + "strings" + "sync" + + "github.com/pkg/errors" + + "github.com/evanw/esbuild/pkg/api" + + "github.com/gohugoio/hugo/helpers" + "github.com/gohugoio/hugo/hugofs" + "github.com/gohugoio/hugo/media" + "github.com/mitchellh/mapstructure" + "github.com/spf13/cast" +) + +// Options esbuild configuration +type Options struct { + // If not set, the source path will be used as the base target path. + // Note that the target path's extension may change if the target MIME type + // is different, e.g. when the source is TypeScript. + TargetPath string + + // Whether to minify to output. + Minify bool + + // Whether to write mapfiles + SourceMap string + + // The language target. + // One of: es2015, es2016, es2017, es2018, es2019, es2020 or esnext. + // Default is esnext. + Target string + + // The output format. + // One of: iife, cjs, esm + // Default is to esm. + Format string + + // External dependencies, e.g. "react". + Externals []string `hash:"set"` + + // User defined symbols. + Defines map[string]interface{} + + // User defined params. Will be marshaled to JSON and available as "@params", e.g. + // import * as params from '@params'; + Params interface{} + + // What to use instead of React.createElement. + JSXFactory string + + // What to use instead of React.Fragment. + JSXFragment string + + mediaType media.Type + outDir string + contents string + sourcefile string + resolveDir string + workDir string + tsConfig string +} + +func decodeOptions(m map[string]interface{}) (Options, error) { + var opts Options + + if err := mapstructure.WeakDecode(m, &opts); err != nil { + return opts, err + } + + if opts.TargetPath != "" { + opts.TargetPath = helpers.ToSlashTrimLeading(opts.TargetPath) + } + + opts.Target = strings.ToLower(opts.Target) + opts.Format = strings.ToLower(opts.Format) + + return opts, nil +} + +type importCache struct { + sync.RWMutex + m map[string]api.OnResolveResult +} + +func createBuildPlugins(c *Client, opts Options) ([]api.Plugin, error) { + fs := c.rs.Assets + + cache := importCache{ + m: make(map[string]api.OnResolveResult), + } + + resolveImport := func(args api.OnResolveArgs) (api.OnResolveResult, error) { + relDir := fs.MakePathRelative(args.ResolveDir) + + if relDir == "" { + // Not in a Hugo Module, probably in node_modules. + return api.OnResolveResult{}, nil + } + + impPath := args.Path + + // stdin is the main entry file which already is at the relative root. + // Imports not starting with a "." is assumed to live relative to /assets. + // Hugo makes no assumptions about the directory structure below /assets. + if args.Importer != "<stdin>" && strings.HasPrefix(impPath, ".") { + impPath = filepath.Join(relDir, args.Path) + } + + findFirst := func(base string) hugofs.FileMeta { + // This is the most common sub-set of ESBuild's default extensions. + // We assume that imports of JSON, CSS etc. will be using their full + // name with extension. + for _, ext := range []string{".js", ".ts", ".tsx", ".jsx"} { + if fi, err := fs.Fs.Stat(base + ext); err == nil { + return fi.(hugofs.FileMetaInfo).Meta() + } + } + + // Not found. + return nil + } + + var m hugofs.FileMeta + + // First the path as is. + fi, err := fs.Fs.Stat(impPath) + + if err == nil { + if fi.IsDir() { + m = findFirst(filepath.Join(impPath, "index")) + } else { + m = fi.(hugofs.FileMetaInfo).Meta() + } + } else { + // It may be a regular file imported without an extension. + m = findFirst(impPath) + } + + if m != nil { + // Store the source root so we can create a jsconfig.json + // to help intellisense when the build is done. + // This should be a small number of elements, and when + // in server mode, we may get stale entries on renames etc., + // but that shouldn't matter too much. + c.rs.JSConfigBuilder.AddSourceRoot(m.SourceRoot()) + return api.OnResolveResult{Path: m.Filename(), Namespace: ""}, nil + } + + return api.OnResolveResult{}, nil + } + + importResolver := api.Plugin{ + Name: "hugo-import-resolver", + Setup: func(build api.PluginBuild) { + build.OnResolve(api.OnResolveOptions{Filter: `.*`}, + func(args api.OnResolveArgs) (api.OnResolveResult, error) { + // Try cache first. + cache.RLock() + v, found := cache.m[args.Path] + cache.RUnlock() + + if found { + return v, nil + } + + imp, err := resolveImport(args) + if err != nil { + return imp, err + } + + cache.Lock() + defer cache.Unlock() + + cache.m[args.Path] = imp + + return imp, nil + + }) + }, + } + + params := opts.Params + if params == nil { + // This way @params will always resolve to something. + params = make(map[string]interface{}) + } + + b, err := json.Marshal(params) + if err != nil { + return nil, errors.Wrap(err, "failed to marshal params") + } + bs := string(b) + paramsPlugin := api.Plugin{ + Name: "hugo-params-plugin", + Setup: func(build api.PluginBuild) { + build.OnResolve(api.OnResolveOptions{Filter: `^@params$`}, + func(args api.OnResolveArgs) (api.OnResolveResult, error) { + return api.OnResolveResult{ + Path: args.Path, + Namespace: "params", + }, nil + }) + build.OnLoad(api.OnLoadOptions{Filter: `.*`, Namespace: "params"}, + func(args api.OnLoadArgs) (api.OnLoadResult, error) { + return api.OnLoadResult{ + Contents: &bs, + Loader: api.LoaderJSON, + }, nil + }) + }, + } + + return []api.Plugin{importResolver, paramsPlugin}, nil + +} + +func toBuildOptions(opts Options) (buildOptions api.BuildOptions, err error) { + + var target api.Target + switch opts.Target { + case "", "esnext": + target = api.ESNext + case "es5": + target = api.ES5 + case "es6", "es2015": + target = api.ES2015 + case "es2016": + target = api.ES2016 + case "es2017": + target = api.ES2017 + case "es2018": + target = api.ES2018 + case "es2019": + target = api.ES2019 + case "es2020": + target = api.ES2020 + default: + err = fmt.Errorf("invalid target: %q", opts.Target) + return + } + + mediaType := opts.mediaType + if mediaType.IsZero() { + mediaType = media.JavascriptType + } + + var loader api.Loader + switch mediaType.SubType { + // TODO(bep) ESBuild support a set of other loaders, but I currently fail + // to see the relevance. That may change as we start using this. + case media.JavascriptType.SubType: + loader = api.LoaderJS + case media.TypeScriptType.SubType: + loader = api.LoaderTS + case media.TSXType.SubType: + loader = api.LoaderTSX + case media.JSXType.SubType: + loader = api.LoaderJSX + default: + err = fmt.Errorf("unsupported Media Type: %q", opts.mediaType) + return + } + + var format api.Format + // One of: iife, cjs, esm + switch opts.Format { + case "", "iife": + format = api.FormatIIFE + case "esm": + format = api.FormatESModule + case "cjs": + format = api.FormatCommonJS + default: + err = fmt.Errorf("unsupported script output format: %q", opts.Format) + return + } + + var defines map[string]string + if opts.Defines != nil { + defines = cast.ToStringMapString(opts.Defines) + } + + // By default we only need to specify outDir and no outFile + var outDir = opts.outDir + var outFile = "" + var sourceMap api.SourceMap + switch opts.SourceMap { + case "inline": + sourceMap = api.SourceMapInline + case "external": + // When doing external sourcemaps we should specify + // out file and no out dir + sourceMap = api.SourceMapExternal + outFile = filepath.Join(opts.workDir, opts.TargetPath) + outDir = "" + case "": + sourceMap = api.SourceMapNone + default: + err = fmt.Errorf("unsupported sourcemap type: %q", opts.SourceMap) + return + } + + buildOptions = api.BuildOptions{ + Outfile: outFile, + Bundle: true, + + Target: target, + Format: format, + Sourcemap: sourceMap, + + MinifyWhitespace: opts.Minify, + MinifyIdentifiers: opts.Minify, + MinifySyntax: opts.Minify, + + Outdir: outDir, + Define: defines, + + External: opts.Externals, + + JSXFactory: opts.JSXFactory, + JSXFragment: opts.JSXFragment, + + Tsconfig: opts.tsConfig, + + Stdin: &api.StdinOptions{ + Contents: opts.contents, + Sourcefile: opts.sourcefile, + ResolveDir: opts.resolveDir, + Loader: loader, + }, + } + return + +} |