Use deno.json(c) on /gh/* pattern (#1085)

Author: ije

server/build.go

@@ -460,9 +460,22 @@ func (ctx *BuildContext) buildModule(analyzeMode bool) (meta *BuildMeta, include
 						}
 					}
 
-					// resolve specifier using the `imports` field of package.json
+					// resolve specifier using the `imports` field of package.json/deno.json
 					if len(pkgJson.Imports) > 0 {
-						if v, ok := pkgJson.Imports[specifier]; ok {
+						var v any
+						var ok bool
+						v, ok = pkgJson.Imports[specifier]
+						if !ok {
+							// check tailing slash
+							pkgName, _, subPath, _ := splitEsmPath(specifier)
+							v, ok = pkgJson.Imports[pkgName]
+							if ok && subPath != "" {
+								if s, ok := v.(string); ok {
+									v = s + "/" + subPath
+								}
+							}
+						}
+						if ok {
 							if s, ok := v.(string); ok {
 								specifier = s
 							} else if m, ok := v.(map[string]interface{}); ok {

server/build_resolver.go

@@ -3,6 +3,7 @@ package server
 import (
 	"crypto/sha1"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"path"
 	"sort"
@@ -715,25 +716,37 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind api.Resolv
 		return
 	}
 
-	// common npm dependency
-	pkgName, version, subPath, _ := splitEsmPath(specifier)
-	if version == "" {
+	var pkgName, pkgVersion, subPath string
+
+	// jsr dependency
+	if strings.HasPrefix(specifier, "jsr:") {
+		pkgName, pkgVersion, subPath, _ = splitEsmPath(specifier[4:])
+		if !strings.HasPrefix(pkgName, "@") || !strings.ContainsRune(pkgName, '/') {
+			return specifier, errors.New("invalid `jsr:` dependency:" + specifier)
+		}
+		scope, name := utils.SplitByFirstByte(pkgName, '/')
+		pkgName = "@jsr/" + scope[1:] + "__" + name
+	} else {
+		pkgName, pkgVersion, subPath, _ = splitEsmPath(specifier)
+	}
+
+	if pkgVersion == "" {
 		if pkgName == ctx.esm.PkgName {
-			version = ctx.esm.PkgVersion
+			pkgVersion = ctx.esm.PkgVersion
 		} else if pkgVerson, ok := ctx.args.deps[pkgName]; ok {
-			version = pkgVerson
+			pkgVersion = pkgVerson
 		} else if v, ok := ctx.pkgJson.Dependencies[pkgName]; ok {
-			version = strings.TrimSpace(v)
+			pkgVersion = strings.TrimSpace(v)
 		} else if v, ok := ctx.pkgJson.PeerDependencies[pkgName]; ok {
-			version = strings.TrimSpace(v)
+			pkgVersion = strings.TrimSpace(v)
 		} else {
-			version = "latest"
+			pkgVersion = "latest"
 		}
 	}
 
 	dep := EsmPath{
 		PkgName:       pkgName,
-		PkgVersion:    version,
+		PkgVersion:    pkgVersion,
 		SubPath:       subPath,
 		SubModuleName: stripEntryModuleExt(subPath),
 	}
@@ -742,7 +755,7 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind api.Resolv
 	// e.g. "@mark/html": "npm:@jsr/mark__html@^1.0.0"
 	// e.g. "tslib": "git+https://github.com/microsoft/tslib.git#v2.3.0"
 	// e.g. "react": "github:facebook/react#v18.2.0"
-	p, err := resolveDependencyVersion(version)
+	p, err := resolveDependencyVersion(pkgVersion)
 	if err != nil {
 		resolvedPath = fmt.Sprintf("/error.js?type=%s&name=%s&importer=%s", strings.ReplaceAll(err.Error(), " ", "-"), pkgName, ctx.esm.Specifier())
 		return
@@ -825,7 +838,7 @@ func (ctx *BuildContext) resolveExternalModule(specifier string, kind api.Resolv
 	if strings.ContainsRune(dep.PkgVersion, '|') || strings.ContainsRune(dep.PkgVersion, ' ') {
 		// fetch the latest version of the package based on the semver range
 		var p *PackageJSON
-		_, p, err = ctx.lookupDep(pkgName+"@"+version, false)
+		_, p, err = ctx.lookupDep(pkgName+"@"+pkgVersion, false)
 		if err != nil {
 			return
 		}

server/common/jsonc.go

@@ -0,0 +1,85 @@
+package common
+
+// StripJSONC strips out comments and trailing commas and convert the input to a
+// valid JSON per the official spec: https://tools.ietf.org/html/rfc8259
+//
+// The resulting JSON will always be the same length as the input and it will
+// include all of the same line breaks at matching offsets. This is to ensure
+// the result can be later processed by a external parser and that that
+// parser will report messages or errors with the correct offsets.
+//
+// The MIT License (MIT)
+// Copyright (c) 2021 Josh Baker
+func StripJSONC(src []byte) []byte {
+	return toJSON(src, nil)
+}
+
+func toJSON(src, dst []byte) []byte {
+	dst = dst[:0]
+	for i := 0; i < len(src); i++ {
+		if src[i] == '/' {
+			if i < len(src)-1 {
+				if src[i+1] == '/' {
+					dst = append(dst, ' ', ' ')
+					i += 2
+					for ; i < len(src); i++ {
+						if src[i] == '\n' {
+							dst = append(dst, '\n')
+							break
+						} else if src[i] == '\t' || src[i] == '\r' {
+							dst = append(dst, src[i])
+						} else {
+							dst = append(dst, ' ')
+						}
+					}
+					continue
+				}
+				if src[i+1] == '*' {
+					dst = append(dst, ' ', ' ')
+					i += 2
+					for ; i < len(src)-1; i++ {
+						if src[i] == '*' && src[i+1] == '/' {
+							dst = append(dst, ' ', ' ')
+							i++
+							break
+						} else if src[i] == '\n' || src[i] == '\t' ||
+							src[i] == '\r' {
+							dst = append(dst, src[i])
+						} else {
+							dst = append(dst, ' ')
+						}
+					}
+					continue
+				}
+			}
+		}
+		dst = append(dst, src[i])
+		if src[i] == '"' {
+			for i = i + 1; i < len(src); i++ {
+				dst = append(dst, src[i])
+				if src[i] == '"' {
+					j := i - 1
+					for ; ; j-- {
+						if src[j] != '\\' {
+							break
+						}
+					}
+					if (j-i)%2 != 0 {
+						break
+					}
+				}
+			}
+		} else if src[i] == '}' || src[i] == ']' {
+			for j := len(dst) - 2; j >= 0; j-- {
+				if dst[j] <= ' ' {
+					continue
+				}
+				if dst[j] == ',' {
+					dst[j] = ' '
+				}
+				break
+			}
+		}
+	}
+	return dst
+}

server/npm.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"archive/tar"
+	"bytes"
 	"compress/gzip"
 	"encoding/base64"
 	"encoding/json"
@@ -18,6 +19,7 @@ import (
 	"time"
 
 	"github.com/Masterminds/semver/v3"
+	"github.com/esm-dev/esm.sh/server/common"
 	"github.com/ije/gox/set"
 	syncx "github.com/ije/gox/sync"
 	"github.com/ije/gox/utils"
@@ -502,13 +504,52 @@ func (npmrc *NpmRC) installPackage(pkg Package) (packageJson *PackageJSON, err e
 		err = ghInstall(installDir, pkg.Name, pkg.Version)
 		// ensure 'package.json' file if not exists after installing from github
 		if err == nil && !existsFile(packageJsonPath) {
-			var f *os.File
-			f, err = os.Create(packageJsonPath)
+			buf := bytes.NewBuffer(nil)
+			buf.WriteString(`{"name":"` + pkg.Name + `","version":"` + pkg.Version + `"`)
+			var denoJson *PackageJSON
+			if deonJsonPath := path.Join(installDir, "node_modules", pkg.Name, "deno.json"); existsFile(deonJsonPath) {
+				var raw PackageJSONRaw
+				if utils.ParseJSONFile(deonJsonPath, &raw) == nil {
+					denoJson = raw.ToNpmPackage()
+				}
+			} else if deonJsoncPath := path.Join(installDir, "node_modules", pkg.Name, "deno.jsonc"); existsFile(deonJsoncPath) {
+				data, err := os.ReadFile(deonJsoncPath)
+				if err == nil {
+					var raw PackageJSONRaw
+					if json.Unmarshal(common.StripJSONC(data), &raw) == nil {
+						denoJson = raw.ToNpmPackage()
+					}
+				}
+			}
+			if denoJson != nil {
+				if len(denoJson.Imports) > 0 {
+					buf.WriteString(`,"imports":{`)
+					for k, v := range denoJson.Imports {
+						if s, ok := v.(string); ok {
+							buf.WriteString(`"` + k + `":"` + s + `",`)
+						}
+					}
+					buf.Truncate(buf.Len() - 1)
+					buf.WriteByte('}')
+				}
+				if denoJson.Exports.Len() > 0 {
+					buf.WriteString(`,"exports":{`)
+					for _, k := range denoJson.Exports.keys {
+						if v, ok := denoJson.Exports.Get(k); ok {
+							if s, ok := v.(string); ok {
+								buf.WriteString(`"` + k + `":"` + s + `",`)
+							}
+						}
+					}
+					buf.Truncate(buf.Len() - 1)
+					buf.WriteByte('}')
+				}
+			}
+			buf.WriteByte('}')
+			err = os.WriteFile(packageJsonPath, buf.Bytes(), 0644)
 			if err != nil {
 				return
 			}
-			defer f.Close()
-			fmt.Fprintf(f, `{"name":"%s","version":"%s"}`, pkg.Name, pkg.Version)
 		}
 	} else if pkg.PkgPrNew {
 		err = fetchPackageTarball(&NpmRegistry{}, installDir, pkg.Name, "https://pkg.pr.new/"+pkg.Name+"@"+pkg.Version)

test/gh/jsr.test.ts

@@ -0,0 +1,8 @@
+import { assertEquals } from "jsr:@std/assert";
+
+import $ from "http://localhost:8080/gh/dsherret/dax";
+
+Deno.test("jsr package from github", async () => {
+  assertEquals(typeof $, "function");
+  assertEquals(await $`echo 42`.text(), "42");
+});