@templmf/temp-solf-lmf 0.0.129 → 0.0.131

package/esm.sh/server/build_analyzer.go

@@ -1,210 +0,0 @@
-package server
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"strconv"
-	"strings"
-
-	"github.com/esm-dev/esm.sh/internal/npm"
-	"github.com/ije/gox/set"
-)
-
-type Ref struct {
-	entries   *set.Set[string]
-	importers *set.Set[string]
-}
-
-func (ctx *BuildContext) analyzeSplitting() (err error) {
-	exportNames := set.New[string]()
-
-	for _, exportName := range ctx.pkgJson.Exports.Keys() {
-		exportName := stripEntryModuleExt(exportName)
-		if (exportName == "." || (strings.HasPrefix(exportName, "./") && !strings.ContainsRune(exportName, '*'))) && !endsWith(exportName, ".json", ".css", ".wasm", ".d.ts", ".d.mts", ".d.cts") {
-			v, _ := ctx.pkgJson.Exports.Get(exportName)
-			if s, ok := v.(string); ok {
-				if endsWith(s, ".json", ".css", ".wasm", ".d.ts", ".d.mts", ".d.cts") {
-					continue
-				}
-			} else if obj, ok := v.(npm.JSONObject); ok {
-				// ignore types only exports
-				if keys := obj.Keys(); len(keys) == 1 && keys[0] == "types" {
-					continue
-				}
-			}
-			if exportName == "." {
-				exportNames.Add("")
-			} else if strings.HasPrefix(exportName, "./") {
-				exportNames.Add(exportName[2:])
-			}
-		}
-	}
-
-	if exportNames.Len() > 1 {
-		splittingTxtPath := path.Join(ctx.wd, "splitting.txt")
-		readSplittingTxt := func() bool {
-			f, err := os.Open(splittingTxtPath)
-			if err != nil {
-				return false
-			}
-			defer f.Close()
-
-			var a []string
-			var i int
-			var r = bufio.NewReader(f)
-			for {
-				line, readErr := r.ReadString('\n')
-				if readErr == nil || readErr == io.EOF {
-					line = strings.TrimSpace(line)
-					if line != "" {
-						if a == nil {
-							n, e := strconv.Atoi(line)
-							if e != nil {
-								break
-							}
-							a = make([]string, n+1)
-						}
-						a[i] = line
-						i++
-					}
-				}
-				if readErr != nil {
-					break
-				}
-			}
-			if len(a) > 0 {
-				n, e := strconv.Atoi(a[0])
-				if e == nil && n <= len(a)-1 {
-					ctx.splitting = set.NewReadOnly(a[1 : n+1]...)
-					if DEBUG {
-						ctx.logger.Debugf("build(%s): splitting.txt found with %d shared modules", ctx.esmPath.String(), ctx.splitting.Len())
-					}
-					return true
-				}
-			}
-			return false
-		}
-
-		// check if the splitting has been analyzed
-		if readSplittingTxt() {
-			return
-		}
-
-		// only one analyze process is allowed at the same time for the same package
-		unlock := installMutex.Lock(splittingTxtPath)
-		defer unlock()
-
-		// skip analyze if the package has been analyzed by another request
-		if readSplittingTxt() {
-			return
-		}
-
-		defer func() {
-			splitting := []string{}
-			if ctx.splitting != nil {
-				splitting = ctx.splitting.Values()
-			}
-			// write the splitting result to 'splitting.txt'
-			sizeStr := strconv.FormatUint(uint64(len(splitting)), 10)
-			bufSize := len(sizeStr) + 1
-			for _, s := range splitting {
-				bufSize += len(s) + 1
-			}
-			buf := make([]byte, bufSize)
-			i := copy(buf, sizeStr)
-			buf[i] = '\n'
-			i++
-			for _, s := range splitting {
-				i += copy(buf[i:], s)
-				buf[i] = '\n'
-				i++
-			}
-			os.WriteFile(splittingTxtPath, buf[0:bufSize-1], 0644)
-		}()
-
-		refs := map[string]Ref{}
-		for _, exportName := range exportNames.Values() {
-			esmPath := ctx.esmPath
-			esmPath.SubPath = exportName
-			b := &BuildContext{
-				npmrc:       ctx.npmrc,
-				logger:      ctx.logger,
-				metaDB:      ctx.metaDB,
-				storage:     ctx.storage,
-				esmPath:     esmPath,
-				args:        ctx.args,
-				externalAll: ctx.externalAll,
-				target:      ctx.target,
-				dev:         ctx.dev,
-				wd:          ctx.wd,
-				pkgJson:     ctx.pkgJson,
-				ctx:         ctx.ctx,
-			}
-			_, includes, err := b.buildModule(true)
-			if err != nil {
-				if err.Error() == "could not resolve build entry" {
-					continue // ignore non-existent exports
-				}
-				return fmt.Errorf("failed to analyze %s: %v", esmPath.String(), err)
-			}
-			for _, include := range includes {
-				module, importer := include[0], include[1]
-				ref, ok := refs[module]
-				if !ok {
-					ref = Ref{entries: set.New[string](), importers: set.New[string]()}
-					refs[module] = ref
-				}
-				ref.importers.Add(importer)
-				ref.entries.Add(exportName)
-			}
-		}
-		shared := set.New[string]()
-		for mod, ref := range refs {
-			if ref.entries.Len() > 1 && ref.importers.Len() > 1 {
-				shared.Add(mod)
-			}
-		}
-		var bubble func(modulePath string, f func(string), mark *set.Set[string])
-		bubble = func(modulePath string, f func(string), mark *set.Set[string]) {
-			hasMark := mark != nil
-			if !hasMark {
-				mark = set.New[string]()
-			} else if mark.Has(modulePath) {
-				return
-			}
-			mark.Add(modulePath)
-			ref, ok := refs[modulePath]
-			if ok {
-				if shared.Has(modulePath) && hasMark {
-					f(modulePath)
-					return
-				}
-				for _, importer := range ref.importers.Values() {
-					bubble(importer, f, mark)
-				}
-			} else {
-				// modulePath is an entry module
-				f(modulePath)
-			}
-		}
-		if shared.Len() > 0 {
-			splitting := set.New[string]()
-			for _, modulePath := range shared.Values() {
-				refBy := set.New[string]()
-				bubble(modulePath, func(importer string) { refBy.Add(importer) }, nil)
-				if refBy.Len() > 1 {
-					splitting.Add(modulePath)
-				}
-			}
-			ctx.splitting = splitting.ReadOnly()
-			if DEBUG {
-				ctx.logger.Debugf("build(%s): found %d shared modules from %d modules", ctx.esmPath.String(), shared.Len(), len(refs))
-			}
-		}
-	}
-
-	return
-}

package/esm.sh/server/build_args.go

@@ -1,294 +0,0 @@
-package server
-
-import (
-	"fmt"
-	"maps"
-	"path"
-	"slices"
-	"sort"
-	"strings"
-
-	"github.com/esm-dev/esm.sh/internal/npm"
-	"github.com/ije/gox/set"
-	"github.com/ije/gox/utils"
-)
-
-type BuildArgs struct {
-	Alias             map[string]string
-	Deps              map[string]string
-	External          set.ReadOnlySet[string]
-	Conditions        []string
-	KeepNames         bool
-	IgnoreAnnotations bool
-	ExternalRequire   bool
-}
-
-func decodeBuildArgs(argsString string) (args BuildArgs, err error) {
-	s, err := atobUrl(strings.TrimPrefix(argsString, "X-"))
-	if err == nil {
-		args = BuildArgs{}
-		for p := range strings.SplitSeq(s, "\n") {
-			if strings.HasPrefix(p, "a") {
-				args.Alias = map[string]string{}
-				for p := range strings.SplitSeq(p[1:], ",") {
-					name, to := utils.SplitByFirstByte(p, ':')
-					name = strings.TrimSpace(name)
-					to = strings.TrimSpace(to)
-					if name != "" && to != "" {
-						args.Alias[name] = to
-					}
-				}
-			} else if strings.HasPrefix(p, "d") {
-				deps := map[string]string{}
-				for p := range strings.SplitSeq(p[1:], ",") {
-					pkgName, pkgVersion, _ := splitEsmPath(p)
-					deps[pkgName] = pkgVersion
-				}
-				args.Deps = deps
-			} else if strings.HasPrefix(p, "e") {
-				args.External = *set.NewReadOnly(strings.Split(p[1:], ",")...)
-			} else if strings.HasPrefix(p, "c") {
-				args.Conditions = append(args.Conditions, strings.Split(p[1:], ",")...)
-			} else {
-				switch p {
-				case "r":
-					args.ExternalRequire = true
-				case "k":
-					args.KeepNames = true
-				case "i":
-					args.IgnoreAnnotations = true
-
-				}
-			}
-		}
-	}
-	return
-}
-
-func encodeBuildArgs(args BuildArgs, isDts bool) string {
-	lines := []string{}
-	if len(args.Alias) > 0 {
-		var ss sort.StringSlice
-		for from, to := range args.Alias {
-			ss = append(ss, fmt.Sprintf("%s:%s", from, to))
-		}
-		if len(ss) > 0 {
-			ss.Sort()
-			lines = append(lines, fmt.Sprintf("a%s", strings.Join(ss, ",")))
-		}
-	}
-	if len(args.Deps) > 0 {
-		var ss sort.StringSlice
-		for name, version := range args.Deps {
-			ss = append(ss, fmt.Sprintf("%s@%s", name, version))
-		}
-		if len(ss) > 0 {
-			ss.Sort()
-			lines = append(lines, fmt.Sprintf("d%s", strings.Join(ss, ",")))
-		}
-	}
-	if args.External.Len() > 0 {
-		var ss sort.StringSlice
-		for _, name := range args.External.Values() {
-			ss = append(ss, name)
-		}
-		if len(ss) > 0 {
-			ss.Sort()
-			lines = append(lines, fmt.Sprintf("e%s", strings.Join(ss, ",")))
-		}
-	}
-	if len(args.Conditions) > 0 {
-		var ss sort.StringSlice
-		for _, name := range args.Conditions {
-			ss = append(ss, name)
-		}
-		if len(ss) > 0 {
-			ss.Sort()
-			lines = append(lines, fmt.Sprintf("c%s", strings.Join(ss, ",")))
-		}
-	}
-	if !isDts {
-		if args.ExternalRequire {
-			lines = append(lines, "r")
-		}
-		if args.KeepNames {
-			lines = append(lines, "k")
-		}
-		if args.IgnoreAnnotations {
-			lines = append(lines, "i")
-		}
-	}
-	if len(lines) > 0 {
-		return btoaUrl(strings.Join(lines, "\n"))
-	}
-	return ""
-}
-
-// resolveBuildArgs resolves `alias`, `deps`, `external` of the build args
-func resolveBuildArgs(npmrc *NpmRC, installDir string, args *BuildArgs, esm EsmPath) error {
-	if len(args.Alias) > 0 || len(args.Deps) > 0 || args.External.Len() > 0 {
-		// quick check if the alias, deps, external are all in dependencies of the package
-		deps, ok, err := func() (deps *set.Set[string], ok bool, err error) {
-			var p *npm.PackageJSON
-			pkgJsonPath := path.Join(installDir, "node_modules", esm.PkgName, "package.json")
-			if existsFile(pkgJsonPath) {
-				var raw npm.PackageJSONRaw
-				err = utils.ParseJSONFile(pkgJsonPath, &raw)
-				if err == nil {
-					p = raw.ToNpmPackage()
-				}
-			} else if esm.GhPrefix || esm.PrPrefix {
-				p, err = npmrc.installPackage(esm.Package())
-			} else {
-				p, err = npmrc.getPackageInfo(esm.PkgName, esm.PkgVersion)
-			}
-			if err != nil {
-				return
-			}
-			deps = set.New[string]()
-			for name := range p.Dependencies {
-				deps.Add(name)
-			}
-			for name := range p.PeerDependencies {
-				deps.Add(name)
-			}
-			if len(args.Alias) > 0 {
-				for from := range args.Alias {
-					if !deps.Has(from) {
-						return nil, false, nil
-					}
-				}
-			}
-			if len(args.Deps) > 0 {
-				for name := range args.Deps {
-					if !deps.Has(name) {
-						return nil, false, nil
-					}
-				}
-			}
-			if args.External.Len() > 0 {
-				for _, name := range args.External.Values() {
-					if !deps.Has(name) {
-						return nil, false, nil
-					}
-				}
-			}
-			return deps, true, nil
-		}()
-		if err != nil {
-			return err
-		}
-		if !ok {
-			deps = set.New[string]()
-			err = walkDeps(npmrc, installDir, esm.Package(), deps)
-			if err != nil {
-				return err
-			}
-		}
-		if len(args.Alias) > 0 {
-			alias := map[string]string{}
-			for from, to := range args.Alias {
-				if deps.Has(from) {
-					alias[from] = to
-				}
-			}
-			for from, to := range alias {
-				pkgName := toPackageName(to)
-				if pkgName == esm.PkgName {
-					delete(alias, from)
-				} else {
-					deps.Add(pkgName)
-				}
-			}
-			args.Alias = alias
-		}
-		if len(args.Deps) > 0 {
-			depsArg := map[string]string{}
-			for name, version := range args.Deps {
-				if name != esm.PkgName && deps.Has(name) {
-					depsArg[name] = version
-					continue
-				}
-				// fix some edge cases
-				// for example, the package "htm" doesn't declare 'preact' as a dependency explicitly
-				// as a workaround, we check if the package name is in the subPath of the package
-				if esm.SubPath != "" && slices.Contains(strings.Split(esm.SubPath, "/"), name) {
-					depsArg[name] = version
-				}
-			}
-			args.Deps = depsArg
-		}
-		if args.External.Len() > 0 {
-			external := make([]string, 0, args.External.Len())
-			for _, name := range args.External.Values() {
-				if strings.HasPrefix(name, "node:") {
-					if nodeBuiltinModules[name[5:]] {
-						external = append(external, name)
-					}
-					continue
-				}
-				// Check if this is a namespace pattern (e.g., @radix-ui)
-				isNamespace := strings.HasPrefix(name, "@") && !strings.Contains(name[1:], "/")
-				if isNamespace {
-					// Add all packages from this namespace that are in deps
-					for _, dep := range deps.Values() {
-						if strings.HasPrefix(dep, name+"/") {
-							external = append(external, dep)
-						}
-					}
-					// Also keep the namespace itself in external for pattern matching
-					external = append(external, name)
-					continue
-				}
-				// if the subModule externalizes the package entry
-				if name == esm.PkgName && esm.SubPath != "" {
-					external = append(external, name)
-					continue
-				}
-				if name != esm.PkgName && deps.Has(name) {
-					external = append(external, name)
-				}
-			}
-			args.External = *set.NewReadOnly(external...)
-		}
-	}
-	return nil
-}
-
-func walkDeps(npmrc *NpmRC, installDir string, pkg npm.Package, mark *set.Set[string]) (err error) {
-	if mark.Has(pkg.Name) {
-		return
-	}
-	mark.Add(pkg.Name)
-	var p *npm.PackageJSON
-	pkgJsonPath := path.Join(installDir, "node_modules", pkg.Name, "package.json")
-	if existsFile(pkgJsonPath) {
-		var raw npm.PackageJSONRaw
-		err = utils.ParseJSONFile(pkgJsonPath, &raw)
-		if err == nil {
-			p = raw.ToNpmPackage()
-		}
-	} else if pkg.Github || pkg.PkgPrNew {
-		p, err = npmrc.installPackage(pkg)
-	} else {
-		p, err = npmrc.getPackageInfo(pkg.Name, pkg.Version)
-	}
-	if err != nil {
-		return
-	}
-	pkgDeps := map[string]string{}
-	maps.Copy(pkgDeps, p.Dependencies)
-	maps.Copy(pkgDeps, p.PeerDependencies)
-	for name, version := range pkgDeps {
-		depPkg := npm.Package{Name: name, Version: version}
-		p, e := npm.ResolveDependencyVersion(version)
-		if e == nil && p.Name != "" {
-			depPkg = p
-		}
-		err := walkDeps(npmrc, installDir, depPkg, mark)
-		if err != nil {
-			return err
-		}
-	}
-	return
-}

package/esm.sh/server/build_args_test.go

@@ -1,52 +0,0 @@
-package server
-
-import (
-	"testing"
-
-	"github.com/ije/gox/set"
-)
-
-func TestEncodeBuildArgs(t *testing.T) {
-	conditions := []string{"react-server"}
-	buildArgsString := encodeBuildArgs(
-		BuildArgs{
-			Alias: map[string]string{"a": "b"},
-			Deps: map[string]string{
-				"c": "1.0.0",
-				"d": "1.0.0",
-				"e": "1.0.0",
-			},
-			External:          *set.NewReadOnly("baz", "bar"),
-			Conditions:        conditions,
-			ExternalRequire:   true,
-			KeepNames:         true,
-			IgnoreAnnotations: true,
-		},
-		false,
-	)
-	args, err := decodeBuildArgs(buildArgsString)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(args.Alias) != 1 || args.Alias["a"] != "b" {
-		t.Fatal("invalid alias")
-	}
-	if len(args.Deps) != 3 {
-		t.Fatal("invalid deps")
-	}
-	if args.External.Len() != 2 {
-		t.Fatal("invalid external")
-	}
-	if len(args.Conditions) != 1 || args.Conditions[0] != "react-server" {
-		t.Fatal("invalid conditions")
-	}
-	if !args.ExternalRequire {
-		t.Fatal("ignoreRequire should be true")
-	}
-	if !args.KeepNames {
-		t.Fatal("keepNames should be true")
-	}
-	if !args.IgnoreAnnotations {
-		t.Fatal("ignoreAnnotations should be true")
-	}
-}

package/esm.sh/server/build_meta.go

@@ -1,168 +0,0 @@
-package server
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"io"
-
-	"github.com/esm-dev/esm.sh/internal/storage"
-	lru "github.com/hashicorp/golang-lru/v2"
-)
-
-type BuildMeta struct {
-	CJS           bool
-	CSSInJS       bool
-	TypesOnly     bool
-	ExportDefault bool
-	CSSEntry      string
-	Dts           string
-	Imports       []string
-	Integrity     string
-}
-
-func encodeBuildMeta(meta *BuildMeta) []byte {
-	buf := bytes.NewBuffer(nil)
-	buf.Write([]byte{'E', 'S', 'M', '\r', '\n'})
-	if meta.CJS {
-		buf.Write([]byte{'j', '\n'})
-	}
-	if meta.CSSInJS {
-		buf.Write([]byte{'c', '\n'})
-	}
-	if meta.TypesOnly {
-		buf.Write([]byte{'t', '\n'})
-	}
-	if meta.ExportDefault {
-		buf.Write([]byte{'e', '\n'})
-	}
-	if meta.CSSEntry != "" {
-		buf.Write([]byte{'.', ':'})
-		buf.WriteString(meta.CSSEntry)
-		buf.WriteByte('\n')
-	}
-	if meta.Dts != "" {
-		buf.Write([]byte{'d', ':'})
-		buf.WriteString(meta.Dts)
-		buf.WriteByte('\n')
-	}
-	if len(meta.Imports) > 0 {
-		for _, path := range meta.Imports {
-			buf.Write([]byte{'i', ':'})
-			buf.WriteString(path)
-			buf.WriteByte('\n')
-		}
-	}
-	if len(meta.Integrity) > 0 {
-		buf.Write([]byte{'s', ':'})
-		buf.WriteString(meta.Integrity)
-		buf.WriteByte('\n')
-	}
-	return buf.Bytes()
-}
-
-func decodeBuildMeta(data []byte) (*BuildMeta, error) {
-	meta := &BuildMeta{}
-	if len(data) < 5 || !bytes.Equal(data[:5], []byte{'E', 'S', 'M', '\r', '\n'}) {
-		return nil, errors.New("invalid build meta")
-	}
-	for line := range bytes.SplitSeq(data[5:], []byte{'\n'}) {
-		switch len(line) {
-		case 0:
-			// ignore empty line
-		case 1:
-			switch line[0] {
-			case 'j':
-				meta.CJS = true
-			case 'c':
-				meta.CSSInJS = true
-			case 't':
-				meta.TypesOnly = true
-			case 'e':
-				meta.ExportDefault = true
-			}
-		default:
-			if line[1] == ':' {
-				value := string(line[2:])
-				switch line[0] {
-				case '.':
-					meta.CSSEntry = value
-				case 'd':
-					meta.Dts = value
-				case 'i':
-					meta.Imports = append(meta.Imports, value)
-				case 's':
-					meta.Integrity = value
-				}
-			}
-		}
-	}
-	return meta, nil
-}
-
-type BuildMetaDB struct {
-	cache   *lru.Cache[string, []byte]
-	storage storage.Storage
-	oldDB   Database
-}
-
-func NewBuildMetaDB(backStorage storage.Storage) *BuildMetaDB {
-	cache, err := lru.New[string, []byte](lruCacheCapacity)
-	if err != nil {
-		panic(err)
-	}
-	return &BuildMetaDB{cache: cache, storage: backStorage}
-}
-
-func (db *BuildMetaDB) Get(key string) (value []byte, err error) {
-	var cached bool
-	value, cached = db.cache.Get(key)
-	if cached {
-		return
-	}
-	r, _, err := db.storage.Get(normalizeMetaStoreKey(key))
-	if err != nil {
-		if err == storage.ErrNotFound && db.oldDB != nil {
-			value, err := db.oldDB.Get(key)
-			if err == nil {
-				go doOnce("copy-meta:"+key, func() error {
-					err := db.Put(key, value)
-					if err == nil {
-						db.cache.Add(key, value)
-					}
-					return err
-				})
-				return value, nil
-			}
-		}
-		return
-	}
-	defer r.Close()
-	value, err = io.ReadAll(r)
-	if err == nil {
-		db.cache.Add(key, value)
-	}
-	return
-}
-
-func (storage *BuildMetaDB) Put(key string, value []byte) (err error) {
-	err = storage.storage.Put(normalizeMetaStoreKey(key), bytes.NewReader(value))
-	if err == nil {
-		storage.cache.Add(key, value)
-	}
-	return
-}
-
-func (storage *BuildMetaDB) Delete(key string) (err error) {
-	err = storage.storage.Delete(normalizeMetaStoreKey(key))
-	if err == nil {
-		storage.cache.Remove(key)
-	}
-	return
-}
-
-func normalizeMetaStoreKey(key string) string {
-	data := sha256.Sum256([]byte(key))
-	return "meta/" + hex.EncodeToString(data[:])
-}