Merge branch 'master' of github.com:gogf/gf into fix/4193-2

## 变更说明

本 PR 主要对代码库进行了重构，以提升类型安全性和优化连接管理实现。

### 详细变更

#### 1. 数据库连接管理优化
- 修改 `RegisterNilChecker`方法返回实例以支持链式调用，涉及
`KVMap`、`ListKVMap`、`TSet`、`AVLKVTree`、`BKVTree`、`RedBlackKVTree`
等多个容器类型
- 更新 `Core`结构体中 `links`字段类型为类型安全的 `KVMap[ConfigNode, *sql.DB]`
- 添加专门的链接检查器函数用于连接池管理
- 使用泛型 `KVMap`替代原始 map 类型提升类型安全性
- 简化连接关闭逻辑并移除不必要的类型断言
- 优化统计功能中的迭代器实现提高性能

#### 2. 数据库驱动类型安全增强
- 将 dm、gaussdb、mssql、oracle 驱动中的 `conflictKeySet` 从 `gset.New`修改为
`gset.NewStrSet`
- 统一使用字符串集合类型以提高类型安全性

#### 3. 配置文件适配器类型安全改进
- 将 `jsonMap`从 `StrAnyMap` 类型更改为泛型 `KVMap[string, *gjson.Json]` 类型
- 添加 `jsonMapChecker` 函数用于 JSON 对象验证
- 使用 `NewKVMapWithChecker` 替代 `NewStrAnyMap` 提高类型安全性
- 简化数据库链接关闭日志中的键值转换逻辑

## 影响范围

- 数据库连接管理模块
- 多个数据库驱动实现
- 配置文件管理系统

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: John Guo <john@johng.cn>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

GO_LIST_OPTIMIZATION.md

@@ -1,231 +0,0 @@
-# go list 性能优化 - 完成报告
-
-**日期**：2026-01-09  
-**优化目标**：减少 `go list` 调用次数，提升依赖分析性能  
-**优化结果**：✅ 从 3 次调用减少到 2 次调用 (-33%)
-
----
-
-## 问题分析
-
-### 原始问题
-在 `cmddep_analyzer.go` 的 `loadPackages()` 方法中存在 **3 次 `go list` 调用**：
-
-1. `go list -json %s` (行 158)
-   - 目标：获取指定的包信息
-   - 问题：只获取主包，不含依赖信息
-
-2. `go list -json -deps %s` (行 179)
-   - 目标：获取指定包及其所有依赖
-   - 问题：和第一次调用冗余，且可能因时间差而导致数据不一致
-
-3. `go list -json -m all` (行 198)
-   - 目标：获取所有模块信息（包括在 go.mod 中但代码未使用的模块）
-   - 问题：第三次调用导致性能开销
-
-### 性能影响
-- **频繁I/O**：每次 `go list` 都涉及 Go 工具链的启动和包元数据扫描
-- **时间累积**：大型项目中每次调用可能耗时 200-500ms，3 次调用总耗时可达 1-1.5s
-- **不一致风险**：连续调用可能因依赖版本变更而返回不同结果
-
----
-
-## 优化方案
-
-### 关键优化点
-
-**优化前的调用顺序**：
-```
-调用1: go list -json %s           (主包)
-      ↓
-调用2: go list -json -deps %s     (主包+依赖)
-      ↓
-调用3: go list -json -m all       (所有模块)
-```
-
-**优化后的调用顺序**：
-```
-调用1: go list -json -m all       (所有模块) - 快速
-      ↓ 用模块信息预填充 packages 集合
-调用2: go list -json -deps %s     (主包+依赖) - 覆盖/补充包信息
-```
-
-### 具体改进
-
-1. **取消第一次调用**
-   - 原因：`go list -json -deps` 已包含主包信息，第一次调用冗余
-   - 效果：减少 1 次调用 (-33%)
-
-2. **调整模块加载时机**
-   - 原因：模块信息加载应先执行，为包信息加载做准备
-   - 优势：支持 go.mod 中声明但未在代码中直接使用的模块出现在依赖图中
-
-3. **优化错误处理**
-   - 模块加载失败不中断：`if err != nil { moduleResult = "" }`
-   - 保证即使模块加载失败，包加载仍能继续
-
----
-
-## 实现细节
-
-### 改动代码 (cmddep_analyzer.go)
-
-```go
-// loadPackages loads package information using go list with optimized approach.
-// OPTIMIZATION: Reduced from 3 separate go list calls to 2 efficient calls:
-// Previously:
-//   1. go list -json %s                (target packages only)
-//   2. go list -json -deps %s          (with dependencies)
-//   3. go list -json -m all            (all modules)
-// Now (optimized):
-//   1. go list -json -m all            (all modules - fast, definitive)
-//   2. go list -json -deps ./...       (all packages with dependencies)
-func (a *analyzer) loadPackages(ctx context.Context, pkgPath string) error {
-	// First, load module information - fast, provides metadata
-	moduleCmd := "go list -json -m all"
-	moduleResult, err := gproc.ShellExec(ctx, moduleCmd)
-	if err != nil {
-		moduleResult = ""  // Module loading is optional
-	}
-
-	// Parse modules and pre-populate packages
-	if moduleResult != "" {
-		// ... decode modules ...
-	}
-
-	// Second, load package information with dependencies
-	cmd := fmt.Sprintf("go list -json -deps %s", pkgPath)
-	result, err := gproc.ShellExec(ctx, cmd)
-	if err != nil {
-		// ... error handling ...
-	}
-
-	// Parse packages
-	// ... decode packages ...
-
-	return nil
-}
-```
-
----
-
-## 验证结果
-
-### 编译检查
-✅ 编译成功，无编译错误
-
-### Lint 检查
-✅ 无 lint 警告或错误
-
-### 向后兼容性
-✅ **完全兼容**
-- `loadPackages()` 方法签名不变
-- 返回结果（`a.packages` 数据结构）不变
-- 所有调用者代码无需修改
-
-### 功能正确性
-✅ 功能保持一致
-- 获取相同的包和模块信息
-- 建立相同的依赖关系图
-- 支持所有原有的过滤和遍历操作
-
----
-
-## 性能指标
-
-### 理论改进
-| 指标 | 优化前 | 优化后 | 改进 |
-|------|------|------|------|
-| **go list 调用数** | 3 次 | 2 次 | -33% |
-| **预期执行时间** | ~600-1500ms | ~400-1000ms | -33% |
-
-### 说明
-- 假设每次调用 200-500ms
-- 模块加载（`go list -m all`）通常最快，因为不需要扫描代码
-- 包依赖加载（`go list -deps`）取决于项目复杂度
-
----
-
-## 设计决策
-
-### 为什么是 2 次而不是 1 次？
-
-虽然设计目标是"1 次调用"，但实际上 2 次调用是更合理的方案：
-
-**原因**：
-1. `go list -deps %s` 和 `go list -m all` 的 **命令标志组合不兼容**
-   - `-deps` 要求指定包/模块作为分析起点
-   - `-m` 要求以模块视图操作
-   - 两者不能在同一命令中有效结合
-
-2. 模块加载和包加载的 **职责不同**
-   - 模块加载：获取 go.mod 声明的完整依赖
-   - 包加载：获取代码中实际使用的包
-   - 两者信息互补
-
-3. **错误隔离**的好处
-   - 模块加载失败不影响包加载
-   - 提高系统鲁棒性
-
----
-
-## 后续优化机会
-
-### 1. 缓存层 (未来版本)
-```go
-// 缓存 go list 结果，支持增量更新
-type PackageCache struct {
-    modules  map[string]bool    // 缓存模块清单
-    packages map[string]*goPackage  // 缓存包信息
-    checksum string             // go.mod 校验和
-}
-```
-
-### 2. 并行加载 (未来版本)
-```go
-// 并行执行两次 go list 调用
-go func() { moduleResult = shell_exec(moduleCmd) }()
-result = shell_exec(packageCmd)  // 同时执行
-// 等待两者完成...
-```
-
-### 3. 按需加载 (未来版本)
-- 支持渐进式加载（只分析指定包及其直接依赖）
-- 支持深度控制（避免加载整个传递依赖树）
-
----
-
-## 代码变更统计
-
-| 指标 | 值 |
-|------|-----|
-| 修改文件 | 1 (`cmddep_analyzer.go`) |
-| 修改行数 | ~70 行 |
-| 删除行数 | 50+ 行 |
-| 净增加 | ~20 行 |
-| 编译错误 | 0 |
-| Lint 警告 | 0 |
-| 测试通过 | ✅ |
-
----
-
-## 总结
-
-✨ **性能优化完成** - 成功将 `go list` 调用从 3 次减少到 2 次，提升了依赖分析性能并改善了代码清晰度。
-
-### 主要成就
-- ✅ 减少 1/3 的 go list 调用
-- ✅ 改进代码结构（模块优先加载）
-- ✅ 增强错误隔离（模块加载失败不影响包加载）
-- ✅ 保持 100% 向后兼容
-- ✅ 零性能退化
-
-### 建议
-- 立即合并此优化
-- 后续考虑实现缓存和并行加载进一步改进
-
----
-
-**完成日期**：2026-01-09  
-**优化者**：AI Assistant  
-**状态**：✅ 完成并验证

MAINONLY_FIX.md

@@ -1,263 +0,0 @@
-# 修复报告 - MainModuleOnly 参数无效问题
-
-**日期**：2026-01-09  
-**优先级**：🔴 高 (功能缺陷)  
-**状态**：✅ 已修复
-
----
-
-## 问题描述
-
-`--main-only` (仅主模块) 参数在代码中定义但从未实际被使用，导致该参数完全无效。
-
-### 表现
-- 用户使用 `gf dep --main-only` 时，仍然显示所有包（包括子模块的包）
-- 参数被解析，但在过滤逻辑中被忽略
-
-### 根本原因
-虽然有定义 `MainModuleOnly` 字段在 `FilterOptions` 中，但：
-1. `ShouldInclude()` 方法从未检查这个参数
-2. `PackageInfo` 没有记录包是否属于主模块的信息
-3. 虽然有 `isMainModulePackage()` 方法可以判断，但它不被调用
-
----
-
-## 修复方案
-
-### 改动 1: 扩展 `PackageInfo` 结构
-
-**文件**：`cmddep_analyzer.go` (L51-60)
-
-```go
-type PackageInfo struct {
-    ImportPath   string       // Full import path
-    ModulePath   string       // Module path
-    Kind         PackageKind  // Package classification
-    Tier         int          // Package tier
-    Imports      []string     // Direct imports
-    IsStdLib     bool         // Standard library marker
-    IsModuleRoot bool         // Is this the root package of its module
-    IsMainModule bool         // ← NEW: Is this package from the main module
-}
-```
-
-**原因**：需要在包信息中记录"是否属于主模块"，以便在过滤时使用。
-
-### 改动 2: 更新 `buildPackageStore()` 方法
-
-**文件**：`cmddep_analyzer.go` (L636-653)
-
-```go
-func (a *analyzer) buildPackageStore() *PackageStore {
-    store := newPackageStore(a.modulePrefix)
-    
-    for path, goPkg := range a.packages {
-        pkgInfo := &PackageInfo{
-            ImportPath:   path,
-            ModulePath:   goPkg.Module.Path,
-            IsStdLib:     goPkg.Standard,
-            Imports:      goPkg.Imports,
-            IsMainModule: a.isMainModulePackage(path),  // ← NEW
-        }
-        pkgInfo.Kind = store.identifyPackageKind(pkgInfo)
-        store.packages[path] = pkgInfo
-    }
-    
-    return store
-}
-```
-
-**原因**：在构建 `PackageInfo` 时调用 `isMainModulePackage()` 来填充 `IsMainModule` 字段。
-
-### 改动 3: 修复 `ShouldInclude()` 方法
-
-**文件**：`cmddep_analyzer.go` (L325-346)
-
-```go
-func (opts *FilterOptions) ShouldInclude(pkg *PackageInfo) bool {
-    // ← NEW: Check main module filter first
-    if opts.MainModuleOnly && !pkg.IsMainModule {
-        return false
-    }
-    
-    // Filter by kind
-    switch pkg.Kind {
-    case KindStdLib:
-        if !opts.IncludeStdLib {
-            return false
-        }
-    case KindInternal:
-        if !opts.IncludeInternal {
-            return false
-        }
-    case KindExternal:
-        if !opts.IncludeExternal {
-            return false
-        }
-    }
-    
-    return true
-}
-```
-
-**原因**：在过滤逻辑中实际检查 `MainModuleOnly` 参数。
-
----
-
-## 影响范围
-
-### 受影响的功能
-- ✅ 命令行 `gf dep --main-only` 命令
-- ✅ Web UI "Main module only" 复选框
-- ✅ HTTP API `?main=true` 参数
-
-### 受影响的输出格式
-- ✅ Tree 格式
-- ✅ List 格式
-- ✅ JSON 格式
-- ✅ Mermaid 格式
-- ✅ Dot 格式
-- ✅ Reverse 格式
-- ✅ Group 格式
-
----
-
-## 验证结果
-
-### 编译检查
-✅ 编译成功，无编译错误
-
-### Lint 检查
-✅ 无 lint 警告或错误
-
-### 向后兼容性
-✅ **完全兼容**
-- 所有现有代码无需修改
-- API 签名不变
-
-### 功能正确性
-✅ 现在可以正确过滤子模块的包
-
----
-
-## 使用示例
-
-### 命令行
-```bash
-# 仅显示主模块的包
-gf dep --main-only
-
-# 结合其他参数
-gf dep --external --main-only
-```
-
-### Web UI
-- 勾选 "Main module only" 复选框来过滤掉子模块
-
-### HTTP API
-```
-GET /api/packages?main=true
-GET /api/tree?main=true
-```
-
----
-
-## 技术细节
-
-### `isMainModulePackage()` 工作原理
-
-位于 `cmddep_analyzer.go` (L381-408)：
-
-```go
-func (a *analyzer) isMainModulePackage(pkg string) bool {
-    // 没有模块前缀，认为所有包都在主模块中
-    if a.modulePrefix == "" {
-        return true
-    }
-    
-    // 包不在模块范围内
-    if !gstr.HasPrefix(pkg, a.modulePrefix) {
-        return false
-    }
-    
-    // 移除模块前缀得到相对路径
-    relativePath := gstr.TrimLeft(pkg[len(a.modulePrefix):], "/")
-    if relativePath == "" {
-        return true  // 这是模块根本身
-    }
-    
-    // 检查是否有子 go.mod 文件（表示子模块）
-    parts := gstr.Split(relativePath, "/")
-    for i := len(parts); i > 0; i-- {
-        subPath := gstr.Join(parts[:i], "/")
-        if subPath != "" && gfile.Exists(subPath+"/go.mod") {
-            return false  // 找到了子模块
-        }
-    }
-    
-    return true  // 这是主模块的一部分
-}
-```
-
-**工作流程**：
-1. 验证包在模块范围内
-2. 检查包相对路径中是否存在 `go.mod` 文件
-3. 如果存在子 `go.mod`，说明这是子模块，返回 `false`
-4. 否则是主模块的一部分，返回 `true`
-
----
-
-## 相关代码位置
-
-| 组件 | 文件 | 行号 | 用途 |
-|------|------|------|------|
-| PackageInfo | cmddep_analyzer.go | L51-60 | 数据模型 |
-| FilterOptions | cmddep_analyzer.go | L62-77 | 过滤参数 |
-| ShouldInclude() | cmddep_analyzer.go | L323-346 | 过滤决策 |
-| buildPackageStore() | cmddep_analyzer.go | L636-653 | 数据构建 |
-| isMainModulePackage() | cmddep_analyzer.go | L381-408 | 主模块检测 |
-
----
-
-## 测试建议
-
-### 手动测试
-```bash
-# 创建有子模块的项目或使用现有项目
-cd /path/to/project/with/submodule
-
-# 测试不带参数
-gf dep --tree
-
-# 测试只显示主模块
-gf dep --tree --main-only
-
-# 验证结果应该显著减少（子模块包被过滤）
-```
-
-### 自动测试
-建议添加单元测试验证：
-- `MainModuleOnly=true` 时 `ShouldInclude()` 正确返回 `false` 对于非主模块包
-- `buildPackageStore()` 正确设置 `IsMainModule` 字段
-- 各种输出格式都正确应用过滤
-
----
-
-## 总结
-
-✨ **功能修复完成**
-
-| 项 | 状态 |
-|----|------|
-| **编译** | ✅ 成功 |
-| **Lint** | ✅ 无错误 |
-| **功能** | ✅ 正常 |
-| **兼容性** | ✅ 100% |
-
-现在 `--main-only` 参数可以正确过滤掉子模块的包。
-
----
-
-**完成日期**：2026-01-09  
-**修复者**：AI Assistant  
-**状态**：✅ 完成并验证

cmd/gf/gfcmd/gfcmd.go

@@ -22,7 +22,6 @@ import (
 	"github.com/gogf/gf/v2/text/gstr"
 
 	"github.com/gogf/gf/cmd/gf/v2/internal/cmd"
-	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/cmddep"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/allyes"
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
@@ -90,7 +89,6 @@ func GetCommand(ctx context.Context) (*Command, error) {
 		cmd.Install,
 		cmd.Version,
 		cmd.Doc,
-		cmddep.Dep,
 	)
 	if err != nil {
 		return nil, err

cmd/gf/internal/cmd/cmd_z_unit_gen_service_test.go

@@ -238,3 +238,48 @@ func Test_Gen_Service_PackagesFilter(t *testing.T) {
 		t.Assert(files[0], dstFolder+filepath.FromSlash("/user.go"))
 	})
 }
+
+// https://github.com/gogf/gf/issues/4242
+// Test that versioned imports and aliased imports are correctly preserved.
+// The issue is that imports like "github.com/minio/minio-go/v7" were being
+// incorrectly handled because the package name (minio) differs from
+// the directory name (minio-go).
+func Test_Issue4242(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			path      = gfile.Temp(guid.S())
+			dstFolder = path + filepath.FromSlash("/service")
+			srvFolder = gtest.DataPath("issue", "4242", "logic")
+			in        = genservice.CGenServiceInput{
+				SrcFolder:       srvFolder,
+				DstFolder:       dstFolder,
+				DstFileNameCase: "Snake",
+				WatchFile:       "",
+				StPattern:       "",
+				Packages:        nil,
+				ImportPrefix:    "",
+				Clear:           false,
+			}
+		)
+		err := gutil.FillStructWithDefault(&in)
+		t.AssertNil(err)
+
+		err = gfile.Mkdir(path)
+		t.AssertNil(err)
+		defer gfile.Remove(path)
+
+		_, err = genservice.CGenService{}.Service(ctx, in)
+		t.AssertNil(err)
+
+		// Test versioned imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242.go")),
+		)
+		// Test aliased imports
+		t.Assert(
+			gfile.GetContents(dstFolder+filepath.FromSlash("/issue_4242_alias.go")),
+			gfile.GetContents(gtest.DataPath("issue", "4242", "service", "issue_4242_alias.go")),
+		)
+	})
+}

cmd/gf/internal/cmd/cmddep/cmddep.go

@@ -1,140 +0,0 @@
-// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package cmddep
-
-import (
-	"context"
-
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/util/gtag"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
-)
-
-var (
-	Dep = cDep{}
-)
-
-type cDep struct {
-	g.Meta `name:"dep" brief:"{cDepBrief}" eg:"{cDepEg}"`
-}
-
-const (
-	cDepBrief = `analyze and display Go package dependencies`
-	cDepEg    = `
-gf dep
-gf dep ./...
-gf dep ./internal/...
-gf dep -f list
-gf dep -f mermaid
-gf dep -f mermaid -g
-gf dep -f dot -d 5
-gf dep -f json -d 0
-gf dep -g
-gf dep -r
-gf dep -i=false
-gf dep -e
-gf dep -e -i=false
-gf dep -M
-gf dep -M -D
-gf dep -s
-gf dep -s -p 8080
-gf dep ./internal/... -f tree -d 2
-gf dep --external --group -f mermaid
-gf dep --module --direct -f json
-`
-)
-
-func init() {
-	gtag.Sets(g.MapStrStr{
-		`cDepBrief`: cDepBrief,
-		`cDepEg`:    cDepEg,
-	})
-}
-
-// Input defines the input parameters for dep command.
-type Input struct {
-	g.Meta   `name:"dep"`
-	Package  string `name:"PACKAGE" arg:"true" brief:"package path to analyze, default is ./..." d:"./..."`
-	Format   string `name:"format"   short:"f" brief:"output format: tree/list/mermaid/dot/json" d:"tree"`
-	Depth    int    `name:"depth"    short:"d" brief:"dependency depth limit, 0 means unlimited" d:"3"`
-	Group    bool   `name:"group"    short:"g" brief:"group by top-level directory" d:"false" orphan:"true"`
-	Internal bool   `name:"internal" short:"i" brief:"show only internal packages" d:"true" orphan:"true"`
-	External bool   `name:"external" short:"e" brief:"show external packages" d:"false" orphan:"true"`
-	Module   bool   `name:"module"   short:"M" brief:"show module-level dependencies (from go.mod)" d:"false" orphan:"true"`
-	Direct   bool   `name:"direct"   short:"D" brief:"show only direct dependencies (requires --module)" d:"false" orphan:"true"`
-	NoStd    bool   `name:"nostd"    short:"n" brief:"exclude standard library" d:"true" orphan:"true"`
-	Reverse  bool   `name:"reverse"  short:"r" brief:"show reverse dependencies" d:"false" orphan:"true"`
-	Serve    bool   `name:"serve"    short:"s" brief:"start HTTP server to view dependencies" d:"false" orphan:"true"`
-	Port     int    `name:"port"     short:"p" brief:"HTTP server port" d:"8888"`
-}
-
-// Output defines the output for dep command.
-type Output struct{}
-
-// Index is the main entry point for the dep command.
-func (c cDep) Index(ctx context.Context, in Input) (out *Output, err error) {
-	analyzer := newAnalyzer()
-
-	// Detect module prefix from go.mod
-	analyzer.modulePrefix = analyzer.detectModulePrefix()
-
-	// Module-level analysis mode (uses go mod graph)
-	if in.Module {
-		if in.Serve {
-			// Load module graph for server mode
-			if err := analyzer.loadModuleGraph(ctx); err != nil {
-				mlog.Print("Warning: Failed to load module graph: " + err.Error())
-			}
-			return nil, analyzer.startServer(in)
-		}
-
-		// Load module graph
-		if err := analyzer.loadModuleGraph(ctx); err != nil {
-			return nil, err
-		}
-
-		// Generate module-level output
-		output := analyzer.generateModuleOutput(in)
-		mlog.Print(output)
-		return
-	}
-
-	// Package-level analysis mode (original behavior)
-	loadErr := analyzer.loadPackages(ctx, in.Package)
-
-	// Start HTTP server if requested
-	// In server mode, allow starting even without local Go module
-	// because users may want to analyze remote modules
-	if in.Serve {
-		if loadErr != nil {
-			mlog.Print("Warning: No local Go module found, you can analyze remote modules in the web UI")
-		}
-		return nil, analyzer.startServer(in)
-	}
-
-	// For non-server mode, return error if loading failed
-	if loadErr != nil {
-		return nil, loadErr
-	}
-
-	if len(analyzer.packages) == 0 {
-		mlog.Print("No packages found")
-		return
-	}
-
-	// Generate output based on format
-	var output string
-	if in.Reverse {
-		output = analyzer.generateReverse(in)
-	} else {
-		output = analyzer.generate(in)
-	}
-
-	mlog.Print(output)
-	return
-}

cmd/gf/internal/cmd/cmddep/cmddep_external_test.go

@@ -1,107 +0,0 @@
-// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package cmddep
-
-import (
-	"testing"
-
-	"github.com/gogf/gf/v2/test/gtest"
-)
-
-func TestExternalDependencyAnalysis(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		analyzer := newAnalyzer()
-		analyzer.modulePrefix = "github.com/gogf/gf/cmd/gf/v2"
-		analyzer.packages = map[string]*goPackage{
-			"github.com/other/package": {
-				ImportPath: "github.com/other/package",
-				Standard:   false,
-			},
-			"github.com/gogf/gf/cmd/gf/v2/internal": {
-				ImportPath: "github.com/gogf/gf/cmd/gf/v2/internal",
-				Standard:   false,
-			},
-			"fmt": {
-				ImportPath: "fmt",
-				Standard:   true,
-			},
-		}
-
-		// Test using new FilterOptions system
-		in := Input{
-			Internal: false,
-			External: true,
-			NoStd:    true,
-		}
-
-		opts := analyzer.convertInputToFilterOptions(in)
-		opts.Normalize(analyzer.modulePrefix)
-		store := analyzer.buildPackageStore()
-
-		// Test external package (should be included)
-		externalPkg, ok := store.packages["github.com/other/package"]
-		t.Assert(ok, true)
-		t.Assert(opts.ShouldInclude(externalPkg), true)
-
-		// Test internal package (should not be included)
-		internalPkg, ok := store.packages["github.com/gogf/gf/cmd/gf/v2/internal"]
-		t.Assert(ok, true)
-		t.Assert(opts.ShouldInclude(internalPkg), false)
-
-		// Test standard library (should not be included due to NoStd)
-		stdPkg, ok := store.packages["fmt"]
-		t.Assert(ok, true)
-		t.Assert(opts.ShouldInclude(stdPkg), false)
-	})
-}
-
-func TestExternalGrouping(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		analyzer := newAnalyzer()
-
-		// Test external group extraction using shortName
-		t.Assert(analyzer.shortName("github.com/user/repo", false), "github.com/user/repo")
-		t.Assert(analyzer.shortName("golang.org/x/tools", false), "golang.org/x/tools")
-		t.Assert(analyzer.shortName("fmt", false), "fmt")
-		t.Assert(analyzer.shortName("simple", false), "simple")
-	})
-}
-
-func TestDependencyStats(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		analyzer := newAnalyzer()
-		analyzer.modulePrefix = "github.com/gogf/gf/cmd/gf/v2"
-
-		// Add test packages
-		analyzer.packages = map[string]*goPackage{
-			"github.com/gogf/gf/cmd/gf/v2/internal": {
-				ImportPath: "github.com/gogf/gf/cmd/gf/v2/internal",
-				Standard:   false,
-			},
-			"github.com/external/package": {
-				ImportPath: "github.com/external/package",
-				Standard:   false,
-			},
-			"fmt": {
-				ImportPath: "fmt",
-				Standard:   true,
-			},
-		}
-
-		in := Input{
-			Internal: true,
-			External: true,
-			NoStd:    false,
-		}
-
-		stats := analyzer.getDependencyStats(in)
-		t.Assert(stats["total"], 3)
-		t.Assert(stats["internal"], 1)
-		t.Assert(stats["external"], 1)
-		t.Assert(stats["stdlib"], 1)
-	})
-}

cmd/gf/internal/cmd/cmddep/cmddep_output.go

@@ -1,403 +0,0 @@
-// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package cmddep
-
-import (
-	"encoding/json"
-	"fmt"
-	"sort"
-	"strings"
-)
-
-// generate creates output based on format.
-func (a *analyzer) generate(in Input) string {
-	switch in.Format {
-	case "tree":
-		return a.generateTree(in)
-	case "list":
-		return a.generateList(in)
-	case "mermaid":
-		return a.generateMermaid(in)
-	case "dot":
-		return a.generateDot(in)
-	case "json":
-		return a.generateJSON(in)
-	default:
-		// Default to tree format
-		return a.generateTree(in)
-	}
-}
-
-// generateTree generates ASCII tree output using new traversal system.
-func (a *analyzer) generateTree(in Input) string {
-	var sb strings.Builder
-
-	// Prepare options
-	opts := a.convertInputToFilterOptions(in)
-	opts.Normalize(a.modulePrefix)
-
-	// Add statistics header if showing external dependencies
-	if in.External {
-		stats := a.getDependencyStats(in)
-		sb.WriteString("Dependency Statistics:\n")
-		fmt.Fprintf(&sb, "  Total packages: %v\n", stats["total"])
-		fmt.Fprintf(&sb, "  Internal: %v\n", stats["internal"])
-		fmt.Fprintf(&sb, "  External: %v\n", stats["external"])
-		fmt.Fprintf(&sb, "  Standard library: %v\n", stats["stdlib"])
-
-		if groups, ok := stats["external_groups"].(map[string]int); ok && len(groups) > 0 {
-			sb.WriteString("  External groups:\n")
-			for group, count := range groups {
-				fmt.Fprintf(&sb, "    %s: %d\n", group, count)
-			}
-		}
-		sb.WriteString("\nDependency Tree:\n")
-	}
-
-	// Build package store
-	store := a.buildPackageStore()
-
-	// Find root packages (packages that are not imported by any other package)
-	rootPkgs := a.findRootPackages()
-
-	// Create traversal context
-	ctx := &TraversalContext{
-		visited:  make(map[string]bool),
-		options:  opts,
-		store:    store,
-		maxDepth: opts.Depth,
-	}
-
-	for _, pkgPath := range rootPkgs {
-		pkgInfo, ok := store.packages[pkgPath]
-		if !ok || !opts.ShouldInclude(pkgInfo) {
-			continue
-		}
-
-		shortName := a.shortName(pkgPath, in.Group)
-		sb.WriteString(shortName + "\n")
-
-		// Use new traversal system
-		a.printTreeNodeNew(&sb, pkgPath, "", in, ctx, 0)
-	}
-	return sb.String()
-}
-
-// findRootPackages finds packages that are not imported by any other internal package.
-func (a *analyzer) findRootPackages() []string {
-	// Build a set of all imported packages
-	imported := make(map[string]bool)
-	for _, pkg := range a.packages {
-		for _, dep := range pkg.Imports {
-			imported[dep] = true
-		}
-	}
-
-	// Find packages that are not imported by others
-	roots := make([]string, 0)
-	for pkgPath := range a.packages {
-		if !imported[pkgPath] {
-			roots = append(roots, pkgPath)
-		}
-	}
-
-	// If no roots found (circular dependencies), use all packages
-	if len(roots) == 0 {
-		roots = a.getSortedPackages()
-	}
-
-	sort.Strings(roots)
-	return roots
-}
-
-// printTreeNodeNew prints tree node using new traversal system.
-func (a *analyzer) printTreeNodeNew(sb *strings.Builder, pkgPath string, prefix string, in Input, ctx *TraversalContext, depth int) {
-	if ctx.maxDepth > 0 && depth >= ctx.maxDepth {
-		return
-	}
-
-	_, ok := ctx.store.packages[pkgPath]
-	if !ok {
-		return
-	}
-
-	// Get filtered dependencies
-	deps := ctx.GetDependencies(pkgPath)
-	sort.Strings(deps)
-
-	for i, dep := range deps {
-		// Check if already visited
-		if ctx.Visit(dep) {
-			continue
-		}
-
-		isLast := i == len(deps)-1
-		connector := "├── "
-		if isLast {
-			connector = "└── "
-		}
-
-		shortName := a.shortName(dep, in.Group)
-		sb.WriteString(prefix + connector + shortName + "\n")
-
-		newPrefix := prefix
-		if isLast {
-			newPrefix += "    "
-		} else {
-			newPrefix += "│   "
-		}
-
-		// Recursively print dependencies
-		ctx.depth++
-		a.printTreeNodeNew(sb, dep, newPrefix, in, ctx, depth+1)
-		ctx.depth--
-	}
-}
-
-// generateList generates simple list output using new traversal system.
-func (a *analyzer) generateList(in Input) string {
-	var sb strings.Builder
-
-	// Prepare options
-	opts := a.convertInputToFilterOptions(in)
-	opts.Normalize(a.modulePrefix)
-
-	// Add statistics header if showing external dependencies
-	if in.External {
-		stats := a.getDependencyStats(in)
-		sb.WriteString("# Dependency Statistics\n")
-		fmt.Fprintf(&sb, "# Total: %v, Internal: %v, External: %v, Stdlib: %v\n",
-			stats["total"], stats["internal"], stats["external"], stats["stdlib"])
-		sb.WriteString("\n")
-	}
-
-	// Build package store
-	store := a.buildPackageStore()
-
-	allDeps := make(map[string]bool)
-
-	// Collect dependencies from packages that should be included
-	for pkgPath, pkgInfo := range store.packages {
-		if !opts.ShouldInclude(pkgInfo) {
-			continue
-		}
-
-		// Get filtered dependencies for this package
-		for _, dep := range store.packages[pkgPath].Imports {
-			depInfo, ok := store.packages[dep]
-			if ok && opts.ShouldInclude(depInfo) {
-				allDeps[dep] = true
-			}
-		}
-	}
-
-	deps := make([]string, 0, len(allDeps))
-	for dep := range allDeps {
-		deps = append(deps, a.shortName(dep, in.Group))
-	}
-	sort.Strings(deps)
-
-	for _, dep := range deps {
-		sb.WriteString(dep + "\n")
-	}
-	return sb.String()
-}
-
-// generateMermaid generates Mermaid diagram output.
-func (a *analyzer) generateMermaid(in Input) string {
-	var sb strings.Builder
-	sb.WriteString("```mermaid\n")
-	sb.WriteString("graph TD\n")
-
-	edges := a.collectEdges(in)
-	sortedEdges := make([]string, 0, len(edges))
-	for edge := range edges {
-		sortedEdges = append(sortedEdges, edge)
-	}
-	sort.Strings(sortedEdges)
-
-	for _, edge := range sortedEdges {
-		sb.WriteString("    " + edge + "\n")
-	}
-	sb.WriteString("```\n")
-	return sb.String()
-}
-
-// generateMermaidRaw generates Mermaid code without markdown wrapper.
-func (a *analyzer) generateMermaidRaw(in Input) string {
-	var sb strings.Builder
-	sb.WriteString("graph TD\n")
-
-	edges := a.collectEdges(in)
-	sortedEdges := make([]string, 0, len(edges))
-	for edge := range edges {
-		sortedEdges = append(sortedEdges, edge)
-	}
-	sort.Strings(sortedEdges)
-
-	for _, edge := range sortedEdges {
-		sb.WriteString("    " + edge + "\n")
-	}
-	return sb.String()
-}
-
-// generateDot generates Graphviz DOT output.
-func (a *analyzer) generateDot(in Input) string {
-	var sb strings.Builder
-	sb.WriteString("digraph deps {\n")
-	sb.WriteString("    rankdir=TB;\n")
-	sb.WriteString("    node [shape=box];\n")
-
-	edges := a.collectEdges(in)
-	sortedEdges := make([]string, 0, len(edges))
-	for edge := range edges {
-		sortedEdges = append(sortedEdges, edge)
-	}
-	sort.Strings(sortedEdges)
-
-	for _, edge := range sortedEdges {
-		parts := strings.Split(edge, " --> ")
-		if len(parts) == 2 {
-			fmt.Fprintf(&sb, "    \"%s\" -> \"%s\";\n", parts[0], parts[1])
-		}
-	}
-	sb.WriteString("}\n")
-	return sb.String()
-}
-
-// generateJSON generates JSON output using new traversal system.
-func (a *analyzer) generateJSON(in Input) string {
-	opts := a.convertInputToFilterOptions(in)
-	opts.Normalize(a.modulePrefix)
-	store := a.buildPackageStore()
-
-	result := make(map[string]any)
-
-	// Add dependency nodes
-	nodes := make([]*depNode, 0)
-	for _, pkgPath := range a.getSortedPackages() {
-		pkgInfo, ok := store.packages[pkgPath]
-		if !ok || !opts.ShouldInclude(pkgInfo) {
-			continue
-		}
-
-		pkg := a.packages[pkgPath]
-		a.visited = make(map[string]bool)
-		node := a.buildDepNode(pkg, in, 0)
-		nodes = append(nodes, node)
-	}
-	result["dependencies"] = nodes
-
-	// Add statistics
-	result["statistics"] = a.getDependencyStats(in)
-
-	// Add metadata
-	result["metadata"] = map[string]any{
-		"module":   a.modulePrefix,
-		"format":   in.Format,
-		"depth":    in.Depth,
-		"group":    in.Group,
-		"internal": in.Internal,
-		"external": in.External,
-		"nostd":    in.NoStd,
-	}
-
-	data, err := json.MarshalIndent(result, "", "  ")
-	if err != nil {
-		return fmt.Sprintf("Error: %v", err)
-	}
-	return string(data)
-}
-
-func (a *analyzer) buildDepNode(pkg *goPackage, in Input, depth int) *depNode {
-	opts := a.convertInputToFilterOptions(in)
-	opts.Normalize(a.modulePrefix)
-	store := a.buildPackageStore()
-
-	node := &depNode{
-		Package: a.shortName(pkg.ImportPath, in.Group),
-	}
-
-	if in.Depth > 0 && depth >= in.Depth {
-		return node
-	}
-
-	pkgInfo, ok := store.packages[pkg.ImportPath]
-	if !ok {
-		return node
-	}
-
-	// Track visited packages to avoid cycles
-	if !a.visited[pkg.ImportPath] {
-		a.visited[pkg.ImportPath] = true
-
-		for _, dep := range pkgInfo.Imports {
-			depInfo, ok := store.packages[dep]
-			if !ok || !opts.ShouldInclude(depInfo) {
-				continue
-			}
-
-			if depPkg, ok := a.packages[dep]; ok {
-				childNode := a.buildDepNode(depPkg, in, depth+1)
-				node.Dependencies = append(node.Dependencies, childNode)
-			} else {
-				node.Dependencies = append(node.Dependencies, &depNode{
-					Package: a.shortName(dep, in.Group),
-				})
-			}
-		}
-	}
-
-	return node
-}
-
-// generateReverse generates reverse dependency output using new system.
-func (a *analyzer) generateReverse(in Input) string {
-	opts := a.convertInputToFilterOptions(in)
-	opts.Normalize(a.modulePrefix)
-
-	store := a.buildPackageStore()
-
-	// Build reverse dependency map
-	reverseDeps := make(map[string][]string)
-	for pkgPath, pkgInfo := range store.packages {
-		for _, dep := range pkgInfo.Imports {
-			depInfo, ok := store.packages[dep]
-			if ok && opts.ShouldInclude(depInfo) {
-				reverseDeps[dep] = append(reverseDeps[dep], pkgPath)
-			}
-		}
-	}
-
-	var sb strings.Builder
-	targets := a.getSortedPackages()
-
-	for _, target := range targets {
-		deps := reverseDeps[target]
-		if len(deps) == 0 {
-			continue
-		}
-
-		sort.Strings(deps)
-		shortTarget := a.shortName(target, in.Group)
-		if shortTarget == "" {
-			continue
-		}
-		fmt.Fprintf(&sb, "%s (used by %d packages):\n", shortTarget, len(deps))
-
-		for i, dep := range deps {
-			isLast := i == len(deps)-1
-			connector := "├── "
-			if isLast {
-				connector = "└── "
-			}
-			sb.WriteString(connector + a.shortName(dep, in.Group) + "\n")
-		}
-		sb.WriteString("\n")
-	}
-	return sb.String()
-}

cmd/gf/internal/cmd/cmddep/cmddep_z_unit_test.go

@@ -1,255 +0,0 @@
-// Copyright GoFrame gf Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package cmddep
-
-import (
-	"testing"
-
-	"github.com/gogf/gf/v2/os/gctx"
-	"github.com/gogf/gf/v2/test/gtest"
-)
-
-// Test data model creation and classification
-func Test_PackageInfo_Creation(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		pkg := &PackageInfo{
-			ImportPath:   "github.com/gogf/gf/v2/os/gfile",
-			ModulePath:   "github.com/gogf/gf/v2",
-			Kind:         KindInternal,
-			Tier:         2,
-			Imports:      []string{"fmt", "os"},
-			IsStdLib:     false,
-			IsModuleRoot: false,
-		}
-		t.Assert(pkg != nil, true)
-		t.Assert(pkg.Kind, KindInternal)
-		t.Assert(pkg.Tier, 2)
-		t.Assert(len(pkg.Imports), 2)
-	})
-}
-
-// Test FilterOptions normalization
-func Test_FilterOptions_Normalize(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		opts := &FilterOptions{
-			IncludeInternal: false,
-			IncludeExternal: false,
-			IncludeStdLib:   false,
-		}
-		opts.Normalize("github.com/gogf/gf/v2")
-
-		// After normalization, internal should be included by default
-		t.Assert(opts.IncludeInternal, true)
-		t.Assert(opts.IncludeExternal, false)
-	})
-}
-
-// Test ShouldInclude decision logic
-func Test_FilterOptions_ShouldInclude(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		// Test internal package inclusion
-		opts := &FilterOptions{
-			IncludeInternal: true,
-			IncludeExternal: false,
-			IncludeStdLib:   true,
-		}
-
-		internalPkg := &PackageInfo{
-			Kind:     KindInternal,
-			IsStdLib: false,
-		}
-		externalPkg := &PackageInfo{
-			Kind:     KindExternal,
-			IsStdLib: false,
-		}
-		stdlibPkg := &PackageInfo{
-			Kind:     KindStdLib,
-			IsStdLib: true,
-		}
-
-		t.Assert(opts.ShouldInclude(internalPkg), true)
-		t.Assert(opts.ShouldInclude(externalPkg), false)
-		t.Assert(opts.ShouldInclude(stdlibPkg), true)
-	})
-}
-
-// Test TraversalContext Visit tracking
-func Test_TraversalContext_Visit(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := &TraversalContext{
-			visited: make(map[string]bool),
-		}
-
-		// First visit should return false
-		t.Assert(ctx.Visit("pkg1"), false)
-		// Second visit should return true
-		t.Assert(ctx.Visit("pkg1"), true)
-		// New package should return false
-		t.Assert(ctx.Visit("pkg2"), false)
-	})
-}
-
-// Test guessModuleRoot function
-func Test_GuessModuleRoot(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		tests := []struct {
-			input  string
-			expect string
-		}{
-			{"github.com/gogf/gf", "github.com/gogf/gf"},
-			{"github.com/gogf/gf/v2", "github.com/gogf/gf/v2"},
-			{"github.com/gogf/gf/v2/os/gfile", "github.com/gogf/gf/v2"},
-			{"github.com/gogf/gf/v2/os", "github.com/gogf/gf/v2"},
-		}
-
-		for _, test := range tests {
-			result := guessModuleRoot(test.input)
-			t.AssertEQ(result, test.expect)
-		}
-	})
-}
-
-// Test input to filter options conversion
-func Test_ConvertInputToFilterOptions(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		a := newAnalyzer()
-
-		input := Input{
-			Internal: true,
-			External: false,
-			NoStd:    true,
-			Module:   false,
-			Direct:   false,
-			Depth:    3,
-		}
-
-		opts := a.convertInputToFilterOptions(input)
-
-		t.Assert(opts.IncludeInternal, true)
-		t.Assert(opts.IncludeExternal, false)
-		t.Assert(opts.IncludeStdLib, false) // NoStd=true means !IncludeStdLib
-		t.Assert(opts.Depth, 3)
-	})
-}
-
-func Test_Dep_Tree(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "tree",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_List(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "list",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_Mermaid(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "mermaid",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_Dot(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "dot",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_JSON(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "json",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_Reverse(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "tree",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-			Reverse:  true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_Dep_Group(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-		_, err := Dep.Index(ctx, Input{
-			Package:  "./",
-			Format:   "mermaid",
-			Depth:    1,
-			Internal: true,
-			NoStd:    true,
-			Group:    true,
-		})
-		t.AssertNil(err)
-	})
-}
-
-func Test_ModuleLevel_Direct(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		ctx := gctx.New()
-
-		// Test module level with direct only
-		in := Input{
-			Module: true,
-			Direct: true,
-			Format: "list",
-		}
-
-		t.Logf("Input.Module: %v, Input.Direct: %v", in.Module, in.Direct)
-
-		_, err := Dep.Index(ctx, in)
-		t.AssertNil(err)
-	})
-}

cmd/gf/internal/cmd/cmddep/static/app.js

@@ -1,946 +0,0 @@
-// Main Application Module
-let currentZoom = 1;
-let currentView = 'graph';
-let currentLayout = 'TD';
-let selectedPackage = null;
-let allPackages = [];
-let isRemoteMode = false;
-let currentRemoteModule = '';
-let packageListMode = 'tree'; // 'flat' or 'tree'
-let expandedNodes = new Set(); // Track expanded tree nodes
-
-// Pan and Zoom state
-let panX = 0;
-let panY = 0;
-let isPanning = false;
-let startPanX = 0;
-let startPanY = 0;
-let zoomIndicatorTimeout = null;
-
-const MIN_ZOOM = 0.1;
-const MAX_ZOOM = 10;
-const ZOOM_STEP = 0.1;
-
-// Theme Management
-const theme = {
-    current: 'light',
-    
-    init() {
-        const savedTheme = localStorage.getItem('dep-viewer-theme');
-        if (savedTheme) {
-            this.current = savedTheme;
-        } else {
-            if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
-                this.current = 'dark';
-            }
-        }
-        this.apply();
-        
-        window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
-            if (!localStorage.getItem('dep-viewer-theme')) {
-                this.current = e.matches ? 'dark' : 'light';
-                this.apply();
-            }
-        });
-        
-        const toggleBtn = document.getElementById('themeToggle');
-        if (toggleBtn) {
-            toggleBtn.addEventListener('click', () => this.toggle());
-        }
-    },
-    
-    toggle() {
-        this.current = this.current === 'dark' ? 'light' : 'dark';
-        localStorage.setItem('dep-viewer-theme', this.current);
-        this.apply();
-    },
-    
-    apply() {
-        if (this.current === 'dark') {
-            document.body.setAttribute('data-theme', 'dark');
-        } else {
-            document.body.removeAttribute('data-theme');
-        }
-        
-        mermaid.initialize({
-            startOnLoad: false,
-            theme: this.current === 'dark' ? 'dark' : 'default',
-            maxEdges: 2000,  // Increase edge limit for large dependency graphs
-            flowchart: {
-                useMaxWidth: false,
-                htmlLabels: true,
-                curve: 'basis'
-            }
-        });
-        
-        if (currentView === 'graph') {
-            refresh();
-        }
-    }
-};
-
-// Initialize mermaid
-mermaid.initialize({
-    startOnLoad: false,
-    theme: 'default',
-    maxEdges: 2000,  // Increase edge limit for large dependency graphs
-    flowchart: {
-        useMaxWidth: false,
-        htmlLabels: true,
-        curve: 'basis'
-    }
-});
-
-// Initialize application
-async function init() {
-    theme.init();
-    initPanZoom();
-    initRemoteModuleInput();
-    const hasLocalModule = await loadModuleName();
-    if (hasLocalModule) {
-        await loadPackages();
-        await refresh();
-    }
-}
-
-// Initialize remote module input
-function initRemoteModuleInput() {
-    const input = document.getElementById('remoteModuleInput');
-    if (input) {
-        // Fetch versions when input loses focus or Enter is pressed
-        input.addEventListener('blur', fetchVersions);
-        input.addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') {
-                fetchVersions();
-            }
-        });
-    }
-}
-
-// Fetch versions for a module from Go proxy
-async function fetchVersions() {
-    const input = document.getElementById('remoteModuleInput');
-    const versionSelect = document.getElementById('versionSelect');
-    const spinner = document.getElementById('loadingSpinner');
-    
-    let modulePath = input.value.trim();
-    // Remove http:// or https:// prefix if present
-    modulePath = modulePath.replace(/^https?:\/\//, '');
-    input.value = modulePath;
-    
-    if (!modulePath) {
-        versionSelect.disabled = true;
-        versionSelect.innerHTML = `<option value="">${i18n.t('selectVersion')}</option>`;
-        return;
-    }
-    
-    spinner.classList.remove('hidden');
-    versionSelect.disabled = true;
-    
-    try {
-        const response = await fetch('/api/versions?module=' + encodeURIComponent(modulePath));
-        const data = await response.json();
-        
-        if (data.error) {
-            versionSelect.innerHTML = `<option value="">${i18n.t('errorFetchVersions')}</option>`;
-        } else if (data.versions && data.versions.length > 0) {
-            versionSelect.innerHTML = data.versions.map((v, i) => {
-                const label = i === 0 ? `${v} (${i18n.t('latestVersion')})` : v;
-                return `<option value="${v}">${label}</option>`;
-            }).join('');
-            versionSelect.disabled = false;
-        } else {
-            versionSelect.innerHTML = `<option value="">${i18n.t('noVersions')}</option>`;
-        }
-    } catch (e) {
-        console.error('Failed to fetch versions:', e);
-        versionSelect.innerHTML = `<option value="">${i18n.t('errorFetchVersions')}</option>`;
-    } finally {
-        spinner.classList.add('hidden');
-    }
-}
-
-// Analyze remote module
-async function analyzeRemoteModule() {
-    const input = document.getElementById('remoteModuleInput');
-    const versionSelect = document.getElementById('versionSelect');
-    const spinner = document.getElementById('loadingSpinner');
-    const analyzeBtn = document.getElementById('analyzeBtn');
-    
-    let modulePath = input.value.trim();
-    // Remove http:// or https:// prefix if present
-    modulePath = modulePath.replace(/^https?:\/\//, '');
-    input.value = modulePath;
-    
-    const version = versionSelect.value;
-    
-    if (!modulePath) {
-        alert('Please enter a module path');
-        return;
-    }
-    
-    spinner.classList.remove('hidden');
-    analyzeBtn.disabled = true;
-    analyzeBtn.textContent = i18n.t('analyzing');
-    
-    try {
-        const url = `/api/analyze?module=${encodeURIComponent(modulePath)}${version ? '&version=' + encodeURIComponent(version) : ''}`;
-        const response = await fetch(url);
-        const data = await response.json();
-        
-        if (data.error) {
-            alert(data.error);
-            return;
-        }
-        
-        // Switch to remote mode
-        isRemoteMode = true;
-        currentRemoteModule = modulePath + (version ? '@' + version : '');
-        document.getElementById('moduleName').textContent = currentRemoteModule;
-        
-        // Clear selection and reload
-        selectedPackage = null;
-        await loadPackages();
-        await refresh();
-    } catch (e) {
-        console.error('Failed to analyze module:', e);
-        alert(i18n.t('errorAnalyze'));
-    } finally {
-        spinner.classList.add('hidden');
-        analyzeBtn.disabled = false;
-        analyzeBtn.textContent = i18n.t('analyze');
-    }
-}
-
-// Reset to local module
-async function resetToLocal() {
-    const spinner = document.getElementById('loadingSpinner');
-    spinner.classList.remove('hidden');
-    
-    try {
-        await fetch('/api/reset');
-        
-        isRemoteMode = false;
-        currentRemoteModule = '';
-        document.getElementById('remoteModuleInput').value = '';
-        document.getElementById('versionSelect').innerHTML = `<option value="">${i18n.t('selectVersion')}</option>`;
-        document.getElementById('versionSelect').disabled = true;
-        
-        selectedPackage = null;
-        await loadModuleName();
-        await loadPackages();
-        await refresh();
-    } catch (e) {
-        console.error('Failed to reset:', e);
-    } finally {
-        spinner.classList.add('hidden');
-    }
-}
-
-// Initialize pan and zoom functionality
-function initPanZoom() {
-    const viewport = document.getElementById('graphView');
-    if (!viewport) return;
-
-    // Mouse wheel zoom
-    viewport.addEventListener('wheel', (e) => {
-        if (currentView !== 'graph') return;
-        e.preventDefault();
-        
-        const rect = viewport.getBoundingClientRect();
-        const mouseX = e.clientX - rect.left;
-        const mouseY = e.clientY - rect.top;
-        
-        // Calculate zoom
-        const delta = e.deltaY > 0 ? -ZOOM_STEP : ZOOM_STEP;
-        const newZoom = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, currentZoom + delta * currentZoom));
-        
-        if (newZoom !== currentZoom) {
-            // Zoom towards mouse position
-            const scale = newZoom / currentZoom;
-            panX = mouseX - (mouseX - panX) * scale;
-            panY = mouseY - (mouseY - panY) * scale;
-            currentZoom = newZoom;
-            applyTransform();
-            showZoomIndicator();
-        }
-    }, { passive: false });
-
-    // Pan with mouse drag
-    viewport.addEventListener('mousedown', (e) => {
-        if (currentView !== 'graph') return;
-        if (e.button !== 0) return; // Only left click
-        
-        isPanning = true;
-        startPanX = e.clientX - panX;
-        startPanY = e.clientY - panY;
-        viewport.style.cursor = 'grabbing';
-    });
-
-    document.addEventListener('mousemove', (e) => {
-        if (!isPanning) return;
-        
-        panX = e.clientX - startPanX;
-        panY = e.clientY - startPanY;
-        applyTransform();
-    });
-
-    document.addEventListener('mouseup', () => {
-        if (isPanning) {
-            isPanning = false;
-            const viewport = document.getElementById('graphViewport');
-            if (viewport) viewport.style.cursor = 'grab';
-        }
-    });
-
-    // Touch support for mobile
-    let lastTouchDistance = 0;
-    let lastTouchCenter = { x: 0, y: 0 };
-
-    viewport.addEventListener('touchstart', (e) => {
-        if (currentView !== 'graph') return;
-        
-        if (e.touches.length === 1) {
-            isPanning = true;
-            startPanX = e.touches[0].clientX - panX;
-            startPanY = e.touches[0].clientY - panY;
-        } else if (e.touches.length === 2) {
-            isPanning = false;
-            lastTouchDistance = getTouchDistance(e.touches);
-            lastTouchCenter = getTouchCenter(e.touches);
-        }
-    }, { passive: true });
-
-    viewport.addEventListener('touchmove', (e) => {
-        if (currentView !== 'graph') return;
-        e.preventDefault();
-        
-        if (e.touches.length === 1 && isPanning) {
-            panX = e.touches[0].clientX - startPanX;
-            panY = e.touches[0].clientY - startPanY;
-            applyTransform();
-        } else if (e.touches.length === 2) {
-            const distance = getTouchDistance(e.touches);
-            const center = getTouchCenter(e.touches);
-            
-            if (lastTouchDistance > 0) {
-                const scale = distance / lastTouchDistance;
-                const newZoom = Math.min(MAX_ZOOM, Math.max(MIN_ZOOM, currentZoom * scale));
-                
-                if (newZoom !== currentZoom) {
-                    const rect = viewport.getBoundingClientRect();
-                    const centerX = center.x - rect.left;
-                    const centerY = center.y - rect.top;
-                    
-                    const zoomScale = newZoom / currentZoom;
-                    panX = centerX - (centerX - panX) * zoomScale;
-                    panY = centerY - (centerY - panY) * zoomScale;
-                    currentZoom = newZoom;
-                    applyTransform();
-                    showZoomIndicator();
-                }
-            }
-            
-            lastTouchDistance = distance;
-            lastTouchCenter = center;
-        }
-    }, { passive: false });
-
-    viewport.addEventListener('touchend', () => {
-        isPanning = false;
-        lastTouchDistance = 0;
-    });
-}
-
-function getTouchDistance(touches) {
-    const dx = touches[0].clientX - touches[1].clientX;
-    const dy = touches[0].clientY - touches[1].clientY;
-    return Math.sqrt(dx * dx + dy * dy);
-}
-
-function getTouchCenter(touches) {
-    return {
-        x: (touches[0].clientX + touches[1].clientX) / 2,
-        y: (touches[0].clientY + touches[1].clientY) / 2
-    };
-}
-
-function applyTransform() {
-    const container = document.getElementById('mermaidContainer');
-    if (container) {
-        container.style.transform = `translate(${panX}px, ${panY}px) scale(${currentZoom})`;
-    }
-}
-
-function showZoomIndicator() {
-    const indicator = document.getElementById('zoomIndicator');
-    if (indicator) {
-        indicator.textContent = `${Math.round(currentZoom * 100)}%`;
-        indicator.classList.add('visible');
-        
-        if (zoomIndicatorTimeout) {
-            clearTimeout(zoomIndicatorTimeout);
-        }
-        zoomIndicatorTimeout = setTimeout(() => {
-            indicator.classList.remove('visible');
-        }, 1500);
-    }
-}
-
-// Load module name from server
-// Returns true if local module exists, false otherwise
-async function loadModuleName() {
-    try {
-        const response = await fetch('/api/module');
-        const data = await response.json();
-        document.getElementById('moduleName').textContent = data.name || '';
-        
-        // If no local module, set default value and auto-analyze
-        if (!data.name) {
-            const input = document.getElementById('remoteModuleInput');
-            if (input && !input.value) {
-                input.value = 'github.com/gogf/gf/v2';
-                // Fetch versions first, then auto-analyze
-                await fetchVersions();
-                analyzeRemoteModule();
-            }
-            return false;
-        }
-        return true;
-    } catch (e) {
-        console.error('Failed to load module name:', e);
-        return false;
-    }
-}
-
-// Load packages list
-async function loadPackages() {
-    try {
-        const internal = document.getElementById('internal').checked;
-        const external = document.getElementById('external') ? document.getElementById('external').checked : false;
-        const moduleLevel = document.getElementById('moduleLevel') ? document.getElementById('moduleLevel').checked : false;
-        const directOnly = document.getElementById('directOnly') ? document.getElementById('directOnly').checked : false;
-        const response = await fetch(`/api/packages?internal=${internal}&external=${external}&module=${moduleLevel}&direct=${directOnly}`);
-        const data = await response.json();
-        
-        // Handle new API response format with packages and statistics
-        if (data.packages && Array.isArray(data.packages)) {
-            allPackages = data.packages;
-            // Update statistics display if available
-            if (data.statistics) {
-                updateStatisticsDisplay(data.statistics);
-            }
-        } else if (Array.isArray(data)) {
-            // Fallback for old format
-            allPackages = data;
-        } else {
-            console.error('Unexpected API response format:', data);
-            allPackages = [];
-        }
-        
-        document.getElementById('packageCount').textContent = allPackages.length;
-        renderPackageList(allPackages);
-    } catch (e) {
-        console.error('Failed to load packages:', e);
-    }
-}
-
-// Update statistics display
-function updateStatisticsDisplay(statistics) {
-    if (statistics) {
-        document.getElementById('internalCount').textContent = statistics.internal || 0;
-        document.getElementById('externalCount').textContent = statistics.external || 0;
-        document.getElementById('stdlibCount').textContent = statistics.stdlib || 0;
-        
-        // Update total count
-        const totalCount = statistics.total || (statistics.internal + statistics.external + statistics.stdlib);
-        document.getElementById('nodeCount').textContent = totalCount;
-    }
-}
-
-// Get package name from package object or string
-function getPkgName(pkg) {
-    return typeof pkg === 'object' ? pkg.name : pkg;
-}
-
-// Set package list display mode
-function setPackageListMode(mode) {
-    packageListMode = mode;
-    document.getElementById('modeFlat').classList.toggle('active', mode === 'flat');
-    document.getElementById('modeTree').classList.toggle('active', mode === 'tree');
-    
-    const query = document.getElementById('searchInput').value.toLowerCase();
-    const filtered = query ? allPackages.filter(pkg => getPkgName(pkg).toLowerCase().includes(query)) : allPackages;
-    renderPackageList(filtered);
-}
-
-// Render package list in sidebar
-function renderPackageList(packages) {
-    const list = document.getElementById('packageList');
-    if (packages.length === 0) {
-        list.innerHTML = '<div class="loading">' + i18n.t('noPackages') + '</div>';
-        return;
-    }
-    
-    if (packageListMode === 'tree') {
-        renderPackageTree(packages, list);
-    } else {
-        renderPackageFlat(packages, list);
-    }
-}
-
-// Render flat package list
-function renderPackageFlat(packages, container) {
-    container.innerHTML = packages.map(pkg => {
-        const name = getPkgName(pkg);
-        const isActive = name === selectedPackage ? ' active' : '';
-        const escaped = name.replace(/'/g, "\\'");
-        
-        // Build stats display
-        let statsHtml = '';
-        if (typeof pkg === 'object') {
-            statsHtml = `<span class="pkg-stats-inline">
-                <span class="dep-count" title="${i18n.t('dependencies')}">→${pkg.depCount}</span>
-                <span class="used-count" title="${i18n.t('usedBy')}">←${pkg.usedByCount}</span>
-            </span>`;
-        }
-        
-        return `<div class="package-item${isActive}" onclick="selectPackage('${escaped}')" title="${name}">
-            <span class="pkg-name-text">${name}</span>${statsHtml}
-        </div>`;
-    }).join('');
-}
-
-// Build tree structure from package paths
-function buildPackageTree(packages) {
-    const root = { children: {}, packages: [] };
-    
-    packages.forEach(pkg => {
-        const name = getPkgName(pkg);
-        const parts = name.split('/');
-        let current = root;
-        
-        parts.forEach((part, index) => {
-            if (!current.children[part]) {
-                current.children[part] = { children: {}, packages: [], path: parts.slice(0, index + 1).join('/') };
-            }
-            current = current.children[part];
-        });
-        current.isPackage = true;
-        current.fullPath = name;
-        // Store stats if available
-        if (typeof pkg === 'object') {
-            current.depCount = pkg.depCount;
-            current.usedByCount = pkg.usedByCount;
-        }
-    });
-    
-    return root;
-}
-
-// Render package tree
-function renderPackageTree(packages, container) {
-    const tree = buildPackageTree(packages);
-    container.innerHTML = renderTreeNode(tree, '');
-}
-
-// Render a tree node recursively
-function renderTreeNode(node, path) {
-    const children = Object.keys(node.children).sort();
-    if (children.length === 0) return '';
-    
-    return children.map(name => {
-        const child = node.children[name];
-        const childPath = path ? `${path}/${name}` : name;
-        const hasChildren = Object.keys(child.children).length > 0;
-        const isExpanded = expandedNodes.has(childPath);
-        const isActive = child.fullPath === selectedPackage;
-        const isPackage = child.isPackage;
-        
-        const toggleClass = hasChildren ? (isExpanded ? 'expanded' : '') : 'empty';
-        const activeClass = isActive ? ' active' : '';
-        const nameClass = isPackage ? ' package' : '';
-        const icon = isPackage ? '📦' : '📁';
-        
-        // Build stats for packages
-        let statsHtml = '';
-        if (isPackage && child.depCount !== undefined) {
-            statsHtml = `<span class="pkg-stats-inline">
-                <span class="dep-count" title="${i18n.t('dependencies')}">→${child.depCount}</span>
-                <span class="used-count" title="${i18n.t('usedBy')}">←${child.usedByCount}</span>
-            </span>`;
-        }
-        
-        let html = `
-            <div class="tree-node" data-path="${childPath}">
-                <div class="tree-node-header${activeClass}">
-                    <span class="tree-node-toggle ${toggleClass}" onclick="handleToggleClick(event, '${childPath.replace(/'/g, "\\'")}', ${hasChildren})">▶</span>
-                    <span class="tree-node-icon">${icon}</span>
-                    <span class="tree-node-name${nameClass}" onclick="handleNameClick(event, '${childPath.replace(/'/g, "\\'")}', ${isPackage}, ${hasChildren})">${name}</span>
-                    ${statsHtml}
-                </div>`;
-        
-        if (hasChildren) {
-            const childrenHtml = renderTreeNode(child, childPath);
-            html += `<div class="tree-node-children${isExpanded ? ' expanded' : ''}">${childrenHtml}</div>`;
-        }
-        
-        html += '</div>';
-        return html;
-    }).join('');
-}
-
-// Handle toggle arrow click - expand/collapse
-function handleToggleClick(event, path, hasChildren) {
-    event.stopPropagation();
-    if (hasChildren) {
-        toggleTreeNode(path);
-    }
-}
-
-// Handle name click - select package or toggle if folder
-function handleNameClick(event, path, isPackage, hasChildren) {
-    event.stopPropagation();
-    if (isPackage) {
-        selectPackage(path);
-    } else if (hasChildren) {
-        toggleTreeNode(path);
-    }
-}
-
-// Toggle tree node expansion
-function toggleTreeNode(path) {
-    if (expandedNodes.has(path)) {
-        expandedNodes.delete(path);
-    } else {
-        expandedNodes.add(path);
-    }
-    
-    // Re-render with current filter
-    const query = document.getElementById('searchInput').value.toLowerCase();
-    const filtered = query ? allPackages.filter(pkg => getPkgName(pkg).toLowerCase().includes(query)) : allPackages;
-    renderPackageList(filtered);
-}
-
-// Filter packages by search query
-function filterPackages() {
-    const query = document.getElementById('searchInput').value.toLowerCase();
-    const filtered = allPackages.filter(pkg => getPkgName(pkg).toLowerCase().includes(query));
-    renderPackageList(filtered);
-}
-
-// Select a package
-async function selectPackage(pkg) {
-    selectedPackage = pkg;
-    
-    // Update flat list items
-    document.querySelectorAll('.package-item').forEach(el => {
-        el.classList.toggle('active', el.textContent === pkg);
-    });
-    
-    // Update tree items
-    document.querySelectorAll('.tree-node-header').forEach(el => {
-        const node = el.closest('.tree-node');
-        el.classList.toggle('active', node && node.dataset.path === pkg);
-    });
-    
-    await refresh();
-}
-
-// Clear package selection
-function clearSelection() {
-    selectedPackage = null;
-    document.querySelectorAll('.package-item').forEach(el => el.classList.remove('active'));
-    document.querySelectorAll('.tree-node-header').forEach(el => el.classList.remove('active'));
-    closePackageInfo();
-    refresh();
-}
-
-// Close package info sidebar
-function closePackageInfo() {
-    document.getElementById('packageInfo').classList.remove('visible');
-}
-
-// Set layout direction
-function setLayout(layout) {
-    currentLayout = layout;
-    document.getElementById('layoutTD').classList.toggle('active', layout === 'TD');
-    document.getElementById('layoutLR').classList.toggle('active', layout === 'LR');
-    refresh();
-}
-
-// Set view mode
-function setView(view) {
-    currentView = view;
-    document.getElementById('btnGraph').classList.toggle('active', view === 'graph');
-    document.getElementById('btnTree').classList.toggle('active', view === 'tree');
-    document.getElementById('btnList').classList.toggle('active', view === 'list');
-    document.getElementById('zoomControls').classList.toggle('hidden', view !== 'graph');
-    document.getElementById('layoutGroup').classList.toggle('hidden', view !== 'graph');
-    refresh();
-}
-
-// Main refresh function
-async function refresh() {
-    const depth = document.getElementById('depth').value;
-    const group = document.getElementById('group').checked;
-    const reverse = document.getElementById('reverse').checked;
-    const internal = document.getElementById('internal').checked;
-    const external = document.getElementById('external') ? document.getElementById('external').checked : false;
-    const moduleLevel = document.getElementById('moduleLevel') ? document.getElementById('moduleLevel').checked : false;
-    const directOnly = document.getElementById('directOnly') ? document.getElementById('directOnly').checked : false;
-
-    if (selectedPackage) {
-        await showPackageInfo(selectedPackage);
-    } else {
-        closePackageInfo();
-    }
-
-    if (currentView === 'graph') {
-        await refreshGraph(depth, group, reverse, internal, external, moduleLevel, directOnly);
-    } else if (currentView === 'tree') {
-        await refreshTree(depth, internal, external, moduleLevel, directOnly);
-    } else {
-        await refreshList(internal, external, moduleLevel, directOnly);
-    }
-}
-
-// Show package info panel
-async function showPackageInfo(pkg) {
-    try {
-        const response = await fetch('/api/package?name=' + encodeURIComponent(pkg));
-        const info = await response.json();
-        
-        const infoDiv = document.getElementById('packageInfo');
-        const contentDiv = document.getElementById('packageInfoContent');
-        
-        infoDiv.classList.add('visible');
-        contentDiv.innerHTML = `
-            <span class="pkg-name" title="${info.name}">${info.name}</span>
-            <div class="pkg-stats">
-                <div class="pkg-stat">
-                    <span class="pkg-stat-label">${i18n.t('dependencies')}:</span>
-                    <span class="pkg-stat-value">${info.dependencies.length}</span>
-                </div>
-                <div class="pkg-stat">
-                    <span class="pkg-stat-label">${i18n.t('usedBy')}:</span>
-                    <span class="pkg-stat-value">${info.usedBy.length}</span>
-                </div>
-            </div>
-        `;
-    } catch (e) {
-        console.error('Failed to load package info:', e);
-    }
-}
-
-// Refresh graph view
-async function refreshGraph(depth, group, reverse, internal, external, moduleLevel, directOnly) {
-    document.getElementById('graphView').classList.remove('hidden');
-    document.getElementById('textView').classList.add('hidden');
-
-    // Reset pan/zoom on refresh
-    currentZoom = 1;
-    panX = 0;
-    panY = 0;
-    applyTransform();
-
-    let url = `/api/graph?depth=${depth}&group=${group}&reverse=${reverse}&internal=${internal}`;
-    if (external !== undefined) {
-        url += `&external=${external}`;
-    }
-    if (moduleLevel !== undefined) {
-        url += `&module=${moduleLevel}`;
-    }
-    if (directOnly !== undefined) {
-        url += `&direct=${directOnly}`;
-    }
-    if (selectedPackage) {
-        url += '&package=' + encodeURIComponent(selectedPackage);
-    }
-
-    try {
-        const response = await fetch(url);
-        const data = await response.json();
-
-        document.getElementById('nodeCount').textContent = data.nodes.length;
-        document.getElementById('edgeCount').textContent = data.edges.length;
-
-        // Generate mermaid code
-        // Build node id to label map
-        const nodeLabels = {};
-        data.nodes.forEach(node => {
-            nodeLabels[node.id] = node.label;
-        });
-
-        // Use current layout direction
-        let mermaidCode = `graph ${currentLayout}\n`;
-        // First define all nodes with labels
-        data.nodes.forEach(node => {
-            mermaidCode += `    ${node.id}["${node.label}"]\n`;
-        });
-        // Then add edges
-        data.edges.forEach(edge => {
-            mermaidCode += `    ${edge.from} --> ${edge.to}\n`;
-        });
-
-        const container = document.getElementById('mermaidGraph');
-        container.innerHTML = mermaidCode;
-        container.removeAttribute('data-processed');
-        
-        await mermaid.run({ nodes: [container] });
-        
-        // Auto-fit if graph is large
-        setTimeout(() => {
-            autoFitGraph();
-        }, 100);
-    } catch (e) {
-        console.error('Failed to render graph:', e);
-        document.getElementById('mermaidGraph').innerHTML = 
-            `<div class="loading">${i18n.t('renderError')}</div>`;
-    }
-}
-
-// Auto-fit graph to viewport
-function autoFitGraph() {
-    const viewport = document.getElementById('graphView');
-    const svg = document.querySelector('.mermaid svg');
-    
-    if (!viewport || !svg) return;
-    
-    const viewportRect = viewport.getBoundingClientRect();
-    const svgRect = svg.getBoundingClientRect();
-    
-    if (svgRect.width === 0 || svgRect.height === 0) return;
-    
-    // Calculate scale to fit
-    const scaleX = (viewportRect.width - 40) / svgRect.width;
-    const scaleY = (viewportRect.height - 40) / svgRect.height;
-    const scale = Math.min(scaleX, scaleY, 1); // Don't zoom in beyond 100%
-    
-    if (scale < 1) {
-        currentZoom = scale;
-        // Center the graph
-        panX = (viewportRect.width - svgRect.width * scale) / 2;
-        panY = 20;
-        applyTransform();
-        showZoomIndicator();
-    }
-}
-
-// Refresh tree view
-async function refreshTree(depth, internal, external, moduleLevel, directOnly) {
-    document.getElementById('graphView').classList.add('hidden');
-    document.getElementById('textView').classList.remove('hidden');
-
-    let url = `/api/tree?depth=${depth}&internal=${internal}`;
-    if (external !== undefined) {
-        url += `&external=${external}`;
-    }
-    if (moduleLevel !== undefined) {
-        url += `&module=${moduleLevel}`;
-    }
-    if (directOnly !== undefined) {
-        url += `&direct=${directOnly}`;
-    }
-    if (selectedPackage) {
-        url += '&package=' + encodeURIComponent(selectedPackage);
-    }
-
-    try {
-        const response = await fetch(url);
-        const text = await response.text();
-        document.getElementById('textView').textContent = text;
-
-        const lines = text.split('\n').filter(l => l.trim());
-        document.getElementById('nodeCount').textContent = lines.length;
-        document.getElementById('edgeCount').textContent = '-';
-    } catch (e) {
-        console.error('Failed to load tree:', e);
-    }
-}
-
-// Refresh list view
-async function refreshList(internal, external, moduleLevel, directOnly) {
-    document.getElementById('graphView').classList.add('hidden');
-    document.getElementById('textView').classList.remove('hidden');
-
-    let url = `/api/list?internal=${internal}`;
-    if (external !== undefined) {
-        url += `&external=${external}`;
-    }
-    if (moduleLevel !== undefined) {
-        url += `&module=${moduleLevel}`;
-    }
-    if (directOnly !== undefined) {
-        url += `&direct=${directOnly}`;
-    }
-    if (selectedPackage) {
-        url += '&package=' + encodeURIComponent(selectedPackage);
-    }
-
-    try {
-        const response = await fetch(url);
-        const text = await response.text();
-        document.getElementById('textView').textContent = text;
-
-        const lines = text.split('\n').filter(l => l.trim());
-        document.getElementById('nodeCount').textContent = lines.length;
-        document.getElementById('edgeCount').textContent = '-';
-    } catch (e) {
-        console.error('Failed to load list:', e);
-    }
-}
-
-// Zoom functions
-function zoomIn() {
-    const viewport = document.getElementById('graphView');
-    if (!viewport) return;
-    
-    const rect = viewport.getBoundingClientRect();
-    const centerX = rect.width / 2;
-    const centerY = rect.height / 2;
-    
-    const newZoom = Math.min(MAX_ZOOM, currentZoom * 1.2);
-    const scale = newZoom / currentZoom;
-    
-    panX = centerX - (centerX - panX) * scale;
-    panY = centerY - (centerY - panY) * scale;
-    currentZoom = newZoom;
-    
-    applyTransform();
-    showZoomIndicator();
-}
-
-function zoomOut() {
-    const viewport = document.getElementById('graphView');
-    if (!viewport) return;
-    
-    const rect = viewport.getBoundingClientRect();
-    const centerX = rect.width / 2;
-    const centerY = rect.height / 2;
-    
-    const newZoom = Math.max(MIN_ZOOM, currentZoom / 1.2);
-    const scale = newZoom / currentZoom;
-    
-    panX = centerX - (centerX - panX) * scale;
-    panY = centerY - (centerY - panY) * scale;
-    currentZoom = newZoom;
-    
-    applyTransform();
-    showZoomIndicator();
-}
-
-function resetZoom() {
-    currentZoom = 1;
-    panX = 0;
-    panY = 0;
-    applyTransform();
-    showZoomIndicator();
-}
-
-function fitToScreen() {
-    autoFitGraph();
-}
-
-// Initialize when DOM is ready
-document.addEventListener('DOMContentLoaded', init);

cmd/gf/internal/cmd/cmddep/static/i18n.js

@@ -1,228 +0,0 @@
-// Internationalization (i18n) Module
-const i18n = {
-    currentLang: 'en',
-    
-    translations: {
-        en: {
-            title: 'Go Package Dependencies',
-            pageTitle: 'Package Dependency Viewer',
-            currentModule: 'Current:',
-            remoteModuleLabel: 'Analyze Module:',
-            remoteModulePlaceholder: 'e.g. github.com/gogf/gf/v2',
-            selectVersion: 'Version',
-            analyze: 'Analyze',
-            resetLocal: 'Reset',
-            fetchingVersions: 'Fetching...',
-            analyzing: 'Analyzing...',
-            viewLabel: 'View:',
-            viewGraph: 'Graph',
-            viewTree: 'Tree',
-            viewList: 'List',
-            depthLabel: 'Depth:',
-            depthUnlimited: 'Unlimited',
-            reverseLabel: 'Reverse (show who uses)',
-            groupLabel: 'Group by directory',
-            internalLabel: 'Internal only',
-            externalLabel: 'External packages',
-            moduleLevelLabel: 'Module level',
-            directOnlyLabel: 'Direct only',
-            statsInternal: 'Internal',
-            statsExternal: 'External',
-            statsStdlib: 'Stdlib',
-            layoutLabel: 'Layout:',
-            layoutTD: 'Top-Down',
-            layoutLR: 'Left-Right',
-            showAll: 'Show All',
-            packagesTitle: 'Packages',
-            searchPlaceholder: 'Search packages...',
-            flatMode: 'Flat list',
-            treeMode: 'Tree view',
-            statsPackages: 'Packages',
-            statsDependencies: 'Dependencies',
-            dependencies: 'Dependencies',
-            usedBy: 'Used by',
-            noPackages: 'No packages found',
-            renderError: 'Unable to render graph. Try reducing depth or selecting a specific package.',
-            packageNotFound: 'Package not found',
-            zoomIn: 'Zoom in',
-            zoomOut: 'Zoom out',
-            fitToScreen: 'Fit to screen',
-            resetZoom: 'Reset zoom',
-            dragToMove: 'Drag to move, scroll to zoom',
-            noVersions: 'No versions found',
-            latestVersion: 'Latest',
-            errorFetchVersions: 'Failed to fetch versions',
-            errorAnalyze: 'Failed to analyze module',
-            packageDetails: 'Package Details',
-            viewGraphTooltip: 'Visualize dependencies as a directed graph',
-            viewTreeTooltip: 'Show dependencies in a hierarchical tree structure',
-            viewListTooltip: 'Display dependencies as a text list',
-            depthTooltip: 'Limit dependency traversal depth',
-            reverseTooltip: 'Show reverse dependencies (who uses the selected package)',
-            groupTooltip: 'Group packages by directory structure',
-            internalTooltip: 'Show only internal packages from current module',
-            externalTooltip: 'Include external dependency packages',
-            moduleLevelTooltip: 'Show module-level dependencies (from go.mod)',
-            directOnlyTooltip: 'Show only direct dependencies (requires module level)',
-            layoutTDTooltip: 'Top-down layout for dependency graph',
-            layoutLRTooltip: 'Left-right layout for dependency graph',
-            showAllTooltip: 'Clear package selection and show all packages',
-            analyzeTooltip: 'Analyze remote Go module dependencies',
-            resetTooltip: 'Reset to local module analysis',
-            themeTooltip: 'Toggle light/dark theme',
-            langTooltip: 'Select language',
-            flatModeTooltip: 'Flat list view',
-            treeModeTooltip: 'Tree view',
-            zoomInTooltip: 'Zoom in',
-            zoomOutTooltip: 'Zoom out',
-            fitToScreenTooltip: 'Fit to screen',
-            resetZoomTooltip: 'Reset zoom',
-            remoteModuleTooltip: 'Enter a remote Go module path to analyze',
-            versionSelectTooltip: 'Select module version (optional)',
-            searchTooltip: 'Search packages by name'
-        },
-        zh: {
-            title: 'Go 包依赖分析',
-            pageTitle: '包依赖查看器',
-            currentModule: '当前模块:',
-            remoteModuleLabel: '分析模块:',
-            remoteModulePlaceholder: '例如 github.com/gogf/gf/v2',
-            selectVersion: '版本',
-            analyze: '分析',
-            resetLocal: '重置',
-            fetchingVersions: '获取中...',
-            analyzing: '分析中...',
-            viewLabel: '视图:',
-            viewGraph: '图表',
-            viewTree: '树形',
-            viewList: '列表',
-            depthLabel: '深度:',
-            depthUnlimited: '无限制',
-            reverseLabel: '反向依赖 (谁引用了它)',
-            groupLabel: '按目录分组',
-            internalLabel: '仅内部包',
-            externalLabel: '外部依赖包',
-            moduleLevelLabel: '模块级别',
-            directOnlyLabel: '仅直接依赖',
-            statsInternal: '内部',
-            statsExternal: '外部',
-            statsStdlib: '标准库',
-            layoutLabel: '布局:',
-            layoutTD: '从上到下',
-            layoutLR: '从左到右',
-            showAll: '显示全部',
-            packagesTitle: '包列表',
-            searchPlaceholder: '搜索包...',
-            flatMode: '平铺列表',
-            treeMode: '目录树',
-            statsPackages: '包数量',
-            statsDependencies: '依赖数',
-            dependencies: '依赖',
-            usedBy: '被引用',
-            noPackages: '未找到包',
-            renderError: '无法渲染图表。请尝试减少深度或选择特定的包。',
-            packageNotFound: '未找到包',
-            zoomIn: '放大',
-            zoomOut: '缩小',
-            fitToScreen: '适应屏幕',
-            resetZoom: '重置缩放',
-            dragToMove: '拖拽移动，滚轮缩放',
-            noVersions: '未找到版本',
-            latestVersion: '最新版本',
-            errorFetchVersions: '获取版本失败',
-            errorAnalyze: '分析模块失败',
-            packageDetails: '包详情',
-            viewGraphTooltip: '以有向图形式可视化依赖关系',
-            viewTreeTooltip: '以层次树结构显示依赖关系',
-            viewListTooltip: '以文本列表形式显示依赖关系',
-            depthTooltip: '限制依赖遍历的深度',
-            reverseTooltip: '显示反向依赖（谁引用了选中的包）',
-            groupTooltip: '按目录结构分组显示包',
-            internalTooltip: '仅显示当前模块的内部包',
-            externalTooltip: '包含外部依赖包',
-            moduleLevelTooltip: '显示模块级别依赖（来自go.mod）',
-            directOnlyTooltip: '仅显示直接依赖（需要启用模块级别）',
-            layoutTDTooltip: '依赖图从上到下布局',
-            layoutLRTooltip: '依赖图从左到右布局',
-            showAllTooltip: '清除包选择，显示所有包',
-            analyzeTooltip: '分析远程Go模块依赖',
-            resetTooltip: '重置为本地模块分析',
-            themeTooltip: '切换明暗主题',
-            langTooltip: '选择语言',
-            flatModeTooltip: '平铺列表视图',
-            treeModeTooltip: '树形视图',
-            zoomInTooltip: '放大',
-            zoomOutTooltip: '缩小',
-            fitToScreenTooltip: '适应屏幕',
-            resetZoomTooltip: '重置缩放',
-            remoteModuleTooltip: '输入远程Go模块路径进行分析',
-            versionSelectTooltip: '选择模块版本（可选）',
-            searchTooltip: '按名称搜索包'
-        }
-    },
-    
-    init() {
-        // Load saved language preference
-        const savedLang = localStorage.getItem('dep-viewer-lang');
-        if (savedLang && this.translations[savedLang]) {
-            this.currentLang = savedLang;
-        } else {
-            // Detect browser language
-            const browserLang = navigator.language.toLowerCase();
-            if (browserLang.startsWith('zh')) {
-                this.currentLang = 'zh';
-            }
-        }
-        
-        // Set select value
-        const langSelect = document.getElementById('langSelect');
-        if (langSelect) {
-            langSelect.value = this.currentLang;
-            langSelect.addEventListener('change', (e) => {
-                this.setLanguage(e.target.value);
-            });
-        }
-        
-        this.applyTranslations();
-    },
-    
-    setLanguage(lang) {
-        if (this.translations[lang]) {
-            this.currentLang = lang;
-            localStorage.setItem('dep-viewer-lang', lang);
-            this.applyTranslations();
-        }
-    },
-    
-    t(key) {
-        return this.translations[this.currentLang][key] || this.translations['en'][key] || key;
-    },
-    
-    applyTranslations() {
-        // Update elements with data-i18n attribute
-        document.querySelectorAll('[data-i18n]').forEach(el => {
-            const key = el.getAttribute('data-i18n');
-            el.textContent = this.t(key);
-        });
-        
-        // Update placeholders
-        document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
-            const key = el.getAttribute('data-i18n-placeholder');
-            el.placeholder = this.t(key);
-        });
-        
-        // Update title attributes
-        document.querySelectorAll('[data-i18n-title]').forEach(el => {
-            const key = el.getAttribute('data-i18n-title');
-            el.title = this.t(key);
-        });
-        
-        // Update page title
-        document.title = this.t('title');
-    }
-};
-
-// Initialize i18n when DOM is ready
-document.addEventListener('DOMContentLoaded', () => {
-    i18n.init();
-});

cmd/gf/internal/cmd/cmddep/static/index.html

@@ -1,161 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title data-i18n="title">Go Package Dependencies</title>
-    <link rel="stylesheet" href="/static/style.css">
-    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
-</head>
-<body>
-    <div class="header">
-        <div class="header-left">
-            <h1 data-i18n="pageTitle">Package Dependency Viewer</h1>
-            <div class="module-info">
-                <span data-i18n="currentModule">Current:</span>
-                <span class="module" id="moduleName"></span>
-            </div>
-        </div>
-        <div class="header-center">
-            <div class="remote-input-group">
-                <label for="remoteModuleInput" data-i18n="remoteModuleLabel">Module:</label>
-                <input type="text" id="remoteModuleInput" data-i18n-placeholder="remoteModulePlaceholder" placeholder="e.g. github.com/gogf/gf/v2" data-i18n-title="remoteModuleTooltip">
-                <select id="versionSelect" disabled data-i18n-title="versionSelectTooltip">
-                    <option value="" data-i18n="selectVersion">Select version</option>
-                </select>
-                <button class="btn btn-sm" id="analyzeBtn" onclick="analyzeRemoteModule()" data-i18n="analyze" data-i18n-title="analyzeTooltip">Analyze</button>
-                <button class="btn btn-sm btn-secondary" id="resetBtn" onclick="resetToLocal()" data-i18n="resetLocal" data-i18n-title="resetTooltip">Reset</button>
-                <span class="loading-spinner hidden" id="loadingSpinner"></span>
-            </div>
-        </div>
-        <div class="header-right">
-            <div class="theme-switch">
-                <button class="icon-btn" id="themeToggle" data-i18n-title="themeTooltip">
-                    <span class="icon-sun">☀️</span>
-                    <span class="icon-moon">🌙</span>
-                </button>
-            </div>
-            <div class="lang-switch">
-                <select id="langSelect" data-i18n-title="langTooltip">
-                    <option value="en">English</option>
-                    <option value="zh">中文</option>
-                </select>
-            </div>
-        </div>
-    </div>
-    <div class="controls">
-        <div class="control-group">
-            <label data-i18n="viewLabel">View:</label>
-            <div class="btn-group">
-                <button class="btn active" id="btnGraph" onclick="setView('graph')" data-i18n="viewGraph" data-i18n-title="viewGraphTooltip">Graph</button>
-                <button class="btn" id="btnTree" onclick="setView('tree')" data-i18n="viewTree" data-i18n-title="viewTreeTooltip">Tree</button>
-                <button class="btn" id="btnList" onclick="setView('list')" data-i18n="viewList" data-i18n-title="viewListTooltip">List</button>
-            </div>
-        </div>
-        <div class="control-group">
-            <label data-i18n="depthLabel">Depth:</label>
-            <select id="depth" onchange="refresh()" data-i18n-title="depthTooltip">
-                <option value="1">1</option>
-                <option value="2">2</option>
-                <option value="3" selected>3</option>
-                <option value="5">5</option>
-                <option value="0" data-i18n="depthUnlimited">Unlimited</option>
-            </select>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="reverse" onchange="refresh()" data-i18n-title="reverseTooltip">
-            <label for="reverse" data-i18n="reverseLabel">Reverse (show who uses)</label>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="group" onchange="refresh()" data-i18n-title="groupTooltip">
-            <label for="group" data-i18n="groupLabel">Group by directory</label>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="internal" checked onchange="refresh()" data-i18n-title="internalTooltip">
-            <label for="internal" data-i18n="internalLabel">Internal only</label>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="external" onchange="refresh()" data-i18n-title="externalTooltip">
-            <label for="external" data-i18n="externalLabel">External packages</label>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="moduleLevel" onchange="refresh()" data-i18n-title="moduleLevelTooltip">
-            <label for="moduleLevel" data-i18n="moduleLevelLabel">Module level</label>
-        </div>
-        <div class="control-group">
-            <input type="checkbox" id="directOnly" onchange="refresh()" data-i18n-title="directOnlyTooltip">
-            <label for="directOnly" data-i18n="directOnlyLabel">Direct only</label>
-        </div>
-        <div class="control-group graph-only" id="layoutGroup">
-            <label data-i18n="layoutLabel">Layout:</label>
-            <div class="btn-group">
-                <button class="btn active" id="layoutTD" onclick="setLayout('TD')" data-i18n="layoutTD" data-i18n-title="layoutTDTooltip">Top-Down</button>
-                <button class="btn" id="layoutLR" onclick="setLayout('LR')" data-i18n="layoutLR" data-i18n-title="layoutLRTooltip">Left-Right</button>
-            </div>
-        </div>
-        <button class="btn btn-secondary" onclick="clearSelection()" data-i18n="showAll" data-i18n-title="showAllTooltip">Show All</button>
-    </div>
-    <div class="main-content">
-        <div class="sidebar">
-            <div class="sidebar-header">
-                <div class="sidebar-title">
-                    <h3 data-i18n="packagesTitle">Packages</h3>
-                    <span class="count" id="packageCount">0</span>
-                </div>
-                <div class="sidebar-mode">
-                    <button class="mode-btn" id="modeFlat" onclick="setPackageListMode('flat')" data-i18n-title="flatModeTooltip">☰</button>
-                    <button class="mode-btn active" id="modeTree" onclick="setPackageListMode('tree')" data-i18n-title="treeModeTooltip">🌲</button>
-                </div>
-            </div>
-            <div class="search-box">
-                <input type="text" id="searchInput" data-i18n-placeholder="searchPlaceholder" placeholder="Search packages..." oninput="filterPackages()" data-i18n-title="searchTooltip">
-            </div>
-            <div class="package-list" id="packageList"></div>
-        </div>
-        <div class="content-area">
-            <div class="stats">
-                <div class="stat-card">
-                    <div class="value" id="nodeCount">0</div>
-                    <div class="label" data-i18n="statsPackages">Packages</div>
-                </div>
-                <div class="stat-card">
-                    <div class="value" id="edgeCount">0</div>
-                    <div class="label" data-i18n="statsDependencies">Dependencies</div>
-                </div>
-                <div class="stat-card">
-                    <div class="value" id="internalCount">0</div>
-                    <div class="label" data-i18n="statsInternal">Internal</div>
-                </div>
-                <div class="stat-card">
-                    <div class="value" id="externalCount">0</div>
-                    <div class="label" data-i18n="statsExternal">External</div>
-                </div>
-                <div class="stat-card">
-                    <div class="value" id="stdlibCount">0</div>
-                    <div class="label" data-i18n="statsStdlib">Stdlib</div>
-                </div>
-                <div class="package-info" id="packageInfo">
-                    <div class="package-info-content" id="packageInfoContent"></div>
-                </div>
-            </div>
-            <div class="graph-container" id="graphContainer">
-                <div id="graphView" class="graph-viewport">
-                    <div class="mermaid-container" id="mermaidContainer">
-                        <div class="mermaid" id="mermaidGraph"></div>
-                    </div>
-                    <div class="zoom-indicator" id="zoomIndicator">100%</div>
-                </div>
-                <div id="textView" class="text-output hidden"></div>
-            </div>
-        </div>
-    </div>
-    <div class="zoom-controls" id="zoomControls">
-        <button class="zoom-btn" onclick="zoomIn()" data-i18n-title="zoomInTooltip">+</button>
-        <button class="zoom-btn" onclick="zoomOut()" data-i18n-title="zoomOutTooltip">−</button>
-        <button class="zoom-btn" onclick="fitToScreen()" data-i18n-title="fitToScreenTooltip">⊡</button>
-        <button class="zoom-btn" onclick="resetZoom()" data-i18n-title="resetZoomTooltip">⟲</button>
-    </div>
-    <script src="/static/i18n.js"></script>
-    <script src="/static/app.js"></script>
-</body>
-</html>

cmd/gf/internal/cmd/cmddep/static/style.css

@@ -1,811 +0,0 @@
-/* CSS Variables for Theming */
-:root {
-    /* Light Theme (Default) */
-    --bg-primary: #f8fafc;
-    --bg-secondary: #ffffff;
-    --bg-tertiary: #f1f5f9;
-    --bg-hover: #e2e8f0;
-    --text-primary: #1e293b;
-    --text-secondary: #475569;
-    --text-muted: #94a3b8;
-    --border-color: #e2e8f0;
-    --accent-color: #3b82f6;
-    --accent-hover: #2563eb;
-    --accent-light: #dbeafe;
-    --success-color: #10b981;
-    --card-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-    --input-bg: #ffffff;
-    --input-border: #cbd5e1;
-}
-
-[data-theme="dark"] {
-    --bg-primary: #0f172a;
-    --bg-secondary: #1e293b;
-    --bg-tertiary: #334155;
-    --bg-hover: #475569;
-    --text-primary: #f1f5f9;
-    --text-secondary: #cbd5e1;
-    --text-muted: #64748b;
-    --border-color: #334155;
-    --accent-color: #60a5fa;
-    --accent-hover: #3b82f6;
-    --accent-light: #1e3a5f;
-    --success-color: #34d399;
-    --card-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
-    --input-bg: #1e293b;
-    --input-border: #475569;
-}
-
-/* Reset & Base */
-* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-}
-
-html, body {
-    height: 100%;
-    overflow: hidden;
-}
-
-body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
-    background: var(--bg-primary);
-    color: var(--text-primary);
-    display: flex;
-    flex-direction: column;
-    transition: background-color 0.3s, color 0.3s;
-}
-
-/* Header */
-.header {
-    background: var(--bg-secondary);
-    padding: 12px 24px;
-    border-bottom: 1px solid var(--border-color);
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    gap: 20px;
-    box-shadow: var(--card-shadow);
-    flex-shrink: 0;
-}
-
-.header-left {
-    flex-shrink: 0;
-}
-
-.header-left h1 {
-    font-size: 18px;
-    font-weight: 600;
-    color: var(--text-primary);
-}
-
-.header-left .module-info {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    color: var(--text-muted);
-    font-size: 12px;
-    margin-top: 2px;
-}
-
-.header-left .module {
-    color: var(--accent-color);
-    font-weight: 500;
-    max-width: 200px;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-}
-
-/* Header Center - Remote Module Input */
-.header-center {
-    flex: 1;
-    display: flex;
-    justify-content: center;
-}
-
-.remote-input-group {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-}
-
-.remote-input-group input[type="text"] {
-    width: 320px;
-    background: var(--input-bg);
-    border: 1px solid var(--input-border);
-    color: var(--text-primary);
-    padding: 6px 12px;
-    border-radius: 6px;
-    font-size: 13px;
-    transition: border-color 0.2s;
-}
-
-.remote-input-group input[type="text"]:focus {
-    outline: none;
-    border-color: var(--accent-color);
-}
-
-.remote-input-group select {
-    width: 160px;
-    background: var(--input-bg);
-    border: 1px solid var(--input-border);
-    color: var(--text-primary);
-    padding: 6px 10px;
-    border-radius: 6px;
-    font-size: 13px;
-    cursor: pointer;
-}
-
-.remote-input-group select:disabled {
-    opacity: 0.6;
-    cursor: not-allowed;
-}
-
-.btn-sm {
-    padding: 6px 12px;
-    font-size: 12px;
-}
-
-.loading-spinner {
-    width: 18px;
-    height: 18px;
-    border: 2px solid var(--border-color);
-    border-top-color: var(--accent-color);
-    border-radius: 50%;
-    animation: spin 0.8s linear infinite;
-}
-
-@keyframes spin {
-    to { transform: rotate(360deg); }
-}
-
-.header-right {
-    display: flex;
-    align-items: center;
-    gap: 12px;
-}
-
-.icon-btn {
-    background: var(--bg-tertiary);
-    border: 1px solid var(--border-color);
-    border-radius: 8px;
-    padding: 8px 12px;
-    cursor: pointer;
-    font-size: 16px;
-    transition: all 0.2s;
-}
-
-.icon-btn:hover {
-    background: var(--bg-hover);
-}
-
-.icon-sun, .icon-moon {
-    display: none;
-}
-
-body:not([data-theme="dark"]) .icon-moon {
-    display: inline;
-}
-
-[data-theme="dark"] .icon-sun {
-    display: inline;
-}
-
-.lang-switch select {
-    background: var(--bg-tertiary);
-    border: 1px solid var(--border-color);
-    color: var(--text-primary);
-    padding: 8px 12px;
-    border-radius: 8px;
-    font-size: 13px;
-    cursor: pointer;
-}
-
-/* Controls */
-.controls {
-    background: var(--bg-secondary);
-    padding: 12px 24px;
-    display: flex;
-    gap: 20px;
-    flex-wrap: wrap;
-    align-items: center;
-    border-bottom: 1px solid var(--border-color);
-}
-
-.control-group {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-}
-
-.control-group label {
-    font-size: 13px;
-    color: var(--text-secondary);
-    font-weight: 500;
-}
-
-.control-group select {
-    background: var(--input-bg);
-    border: 1px solid var(--input-border);
-    color: var(--text-primary);
-    padding: 6px 12px;
-    border-radius: 6px;
-    font-size: 13px;
-    cursor: pointer;
-}
-
-.control-group input[type="checkbox"] {
-    width: 16px;
-    height: 16px;
-    accent-color: var(--accent-color);
-}
-
-/* Buttons */
-.btn {
-    background: var(--accent-color);
-    color: white;
-    border: none;
-    padding: 8px 16px;
-    border-radius: 6px;
-    cursor: pointer;
-    font-size: 13px;
-    font-weight: 500;
-    transition: all 0.2s;
-}
-
-.btn:hover {
-    background: var(--accent-hover);
-}
-
-.btn.active {
-    background: var(--accent-color);
-    box-shadow: 0 0 0 2px var(--accent-light);
-}
-
-.btn-secondary {
-    background: var(--bg-tertiary);
-    color: var(--text-primary);
-    border: 1px solid var(--border-color);
-}
-
-.btn-secondary:hover {
-    background: var(--bg-hover);
-}
-
-.btn-group {
-    display: flex;
-    gap: 0;
-}
-
-.btn-group .btn {
-    border-radius: 0;
-    border-right: 1px solid rgba(255, 255, 255, 0.2);
-}
-
-.btn-group .btn:first-child {
-    border-radius: 6px 0 0 6px;
-}
-
-.btn-group .btn:last-child {
-    border-radius: 0 6px 6px 0;
-    border-right: none;
-}
-
-.btn-group .btn:not(.active) {
-    background: var(--bg-tertiary);
-    color: var(--text-primary);
-}
-
-.btn-group .btn:not(.active):hover {
-    background: var(--bg-hover);
-}
-
-/* Main Content */
-.main-content {
-    display: flex;
-    flex: 1;
-    overflow: hidden;
-    min-height: 0; /* Important for flex children to respect overflow */
-}
-
-/* Sidebar */
-.sidebar {
-    width: 280px;
-    min-width: 280px;
-    background: var(--bg-secondary);
-    border-right: 1px solid var(--border-color);
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-    height: 100%; /* Ensure sidebar takes full height */
-}
-
-.sidebar-header {
-    padding: 10px 16px;
-    border-bottom: 1px solid var(--border-color);
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    flex-shrink: 0; /* Prevent shrinking */
-}
-
-.sidebar-title {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-}
-
-.sidebar-title h3 {
-    font-size: 14px;
-    font-weight: 600;
-    color: var(--text-secondary);
-}
-
-.sidebar-title .count {
-    background: var(--accent-color);
-    color: white;
-    padding: 2px 10px;
-    border-radius: 12px;
-    font-size: 12px;
-    font-weight: 500;
-}
-
-.sidebar-mode {
-    display: flex;
-    gap: 4px;
-}
-
-.mode-btn {
-    width: 28px;
-    height: 28px;
-    border: 1px solid var(--border-color);
-    background: var(--bg-tertiary);
-    border-radius: 6px;
-    cursor: pointer;
-    font-size: 12px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    transition: all 0.2s;
-}
-
-.mode-btn:hover {
-    background: var(--bg-hover);
-}
-
-.mode-btn.active {
-    background: var(--accent-color);
-    border-color: var(--accent-color);
-    color: white;
-}
-
-.search-box {
-    padding: 12px 16px;
-    border-bottom: 1px solid var(--border-color);
-    flex-shrink: 0; /* Prevent shrinking */
-}
-
-.search-box input {
-    width: 100%;
-    background: var(--input-bg);
-    border: 1px solid var(--input-border);
-    color: var(--text-primary);
-    padding: 10px 14px;
-    border-radius: 8px;
-    font-size: 13px;
-    transition: border-color 0.2s;
-}
-
-.search-box input:focus {
-    outline: none;
-    border-color: var(--accent-color);
-}
-
-.search-box input::placeholder {
-    color: var(--text-muted);
-}
-
-.package-list {
-    flex: 1;
-    overflow-y: auto;
-    overflow-x: hidden;
-    padding: 8px 0;
-    min-height: 0; /* Important for flex overflow to work */
-}
-
-.package-item {
-    padding: 10px 16px;
-    cursor: pointer;
-    font-size: 13px;
-    color: var(--text-secondary);
-    border-left: 3px solid transparent;
-    transition: all 0.15s;
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-}
-
-.package-item .pkg-name-text {
-    overflow: hidden;
-    text-overflow: ellipsis;
-    flex: 1;
-    min-width: 0;
-}
-
-.pkg-stats-inline {
-    display: flex;
-    gap: 6px;
-    font-size: 11px;
-    margin-left: 8px;
-    flex-shrink: 0;
-}
-
-.pkg-stats-inline .dep-count {
-    color: var(--accent-color);
-    opacity: 0.8;
-}
-
-.pkg-stats-inline .used-count {
-    color: #10b981;
-    opacity: 0.8;
-}
-
-.package-item:hover {
-    background: var(--bg-hover);
-    color: var(--text-primary);
-}
-
-.package-item.active {
-    background: var(--accent-light);
-    border-left-color: var(--accent-color);
-    color: var(--accent-color);
-    font-weight: 500;
-}
-
-/* Tree View Styles */
-.tree-node {
-    user-select: none;
-}
-
-.tree-node-header {
-    display: flex;
-    align-items: center;
-    padding: 6px 12px;
-    cursor: pointer;
-    font-size: 13px;
-    color: var(--text-secondary);
-    transition: all 0.15s;
-}
-
-.tree-node-header .pkg-stats-inline {
-    margin-left: auto;
-    padding-left: 8px;
-}
-
-.tree-node-header:hover {
-    background: var(--bg-hover);
-    color: var(--text-primary);
-}
-
-.tree-node-toggle {
-    width: 20px;
-    height: 20px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    margin-right: 2px;
-    font-size: 10px;
-    color: var(--text-muted);
-    transition: transform 0.2s;
-    cursor: pointer;
-    border-radius: 4px;
-}
-
-.tree-node-toggle:hover {
-    background: var(--bg-hover);
-    color: var(--text-primary);
-}
-
-.tree-node-toggle.expanded {
-    transform: rotate(90deg);
-}
-
-.tree-node-toggle.empty {
-    visibility: hidden;
-}
-
-.tree-node-icon {
-    margin-right: 6px;
-    font-size: 12px;
-}
-
-.tree-node-name {
-    flex: 1;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    cursor: pointer;
-    padding: 2px 4px;
-    border-radius: 4px;
-}
-
-.tree-node-name:hover {
-    background: var(--bg-hover);
-}
-
-.tree-node-name.package {
-    color: var(--accent-color);
-}
-
-.tree-node-children {
-    padding-left: 16px;
-    display: none;
-}
-
-.tree-node-children.expanded {
-    display: block;
-}
-
-.tree-node-header.active {
-    background: var(--accent-light);
-    color: var(--accent-color);
-}
-
-.tree-node-header.active .tree-node-name {
-    font-weight: 500;
-}
-
-/* Content Area */
-.content-area {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    overflow: hidden;
-}
-
-/* Stats */
-.stats {
-    display: flex;
-    align-items: center;
-    gap: 16px;
-    padding: 12px 24px;
-    background: var(--bg-secondary);
-    border-bottom: 1px solid var(--border-color);
-}
-
-.stat-card {
-    background: var(--bg-tertiary);
-    padding: 10px 20px;
-    border-radius: 10px;
-    text-align: center;
-    min-width: 90px;
-}
-
-.stat-card .value {
-    font-size: 20px;
-    font-weight: 700;
-    color: var(--accent-color);
-}
-
-.stat-card .label {
-    font-size: 11px;
-    color: var(--text-muted);
-    margin-top: 2px;
-    text-transform: uppercase;
-    letter-spacing: 0.5px;
-}
-
-/* Package Info - in stats bar */
-.package-info {
-    display: none;
-    align-items: center;
-    gap: 16px;
-    background: var(--bg-tertiary);
-    padding: 8px 16px;
-    border-radius: 10px;
-}
-
-.package-info.visible {
-    display: flex;
-}
-
-.package-info-content {
-    display: flex;
-    align-items: center;
-    gap: 20px;
-}
-
-.package-info-content .pkg-name {
-    font-size: 14px;
-    font-weight: 600;
-    color: var(--accent-color);
-    max-width: 300px;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-}
-
-.package-info-content .pkg-stats {
-    display: flex;
-    gap: 16px;
-}
-
-.package-info-content .pkg-stat {
-    display: flex;
-    align-items: center;
-    gap: 6px;
-    font-size: 13px;
-}
-
-.package-info-content .pkg-stat-label {
-    color: var(--text-muted);
-}
-
-.package-info-content .pkg-stat-value {
-    color: var(--text-primary);
-    font-weight: 600;
-}
-
-/* Graph Container */
-.graph-container {
-    flex: 1;
-    padding: 24px;
-    overflow: hidden;
-    background: var(--bg-primary);
-    position: relative;
-    display: flex;
-    flex-direction: column;
-    min-height: 0; /* Important for flex overflow */
-}
-
-.graph-viewport {
-    flex: 1;
-    width: 100%;
-    overflow: hidden;
-    position: relative;
-    cursor: grab;
-    min-height: 0; /* Important for flex overflow */
-}
-
-.graph-viewport:active {
-    cursor: grabbing;
-}
-
-.mermaid-container {
-    display: inline-block;
-    min-width: 100%;
-    min-height: 100%;
-    transform-origin: 0 0;
-    transition: none;
-}
-
-.mermaid {
-    display: inline-block;
-    padding: 20px;
-}
-
-.mermaid svg {
-    display: block;
-    max-width: none !important;
-    height: auto;
-}
-
-.zoom-indicator {
-    position: absolute;
-    bottom: 16px;
-    left: 16px;
-    background: var(--bg-secondary);
-    border: 1px solid var(--border-color);
-    padding: 6px 12px;
-    border-radius: 6px;
-    font-size: 12px;
-    color: var(--text-secondary);
-    box-shadow: var(--card-shadow);
-    pointer-events: none;
-    opacity: 0;
-    transition: opacity 0.3s;
-}
-
-.zoom-indicator.visible {
-    opacity: 1;
-}
-
-.text-output {
-    flex: 1;
-    background: var(--bg-secondary);
-    border: 1px solid var(--border-color);
-    border-radius: 10px;
-    padding: 20px;
-    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', monospace;
-    font-size: 13px;
-    line-height: 1.7;
-    white-space: pre;
-    overflow: auto;
-    min-height: 0; /* Important for flex overflow */
-    color: var(--text-primary);
-}
-
-/* Zoom Controls */
-.zoom-controls {
-    position: fixed;
-    bottom: 24px;
-    right: 24px;
-    display: flex;
-    gap: 8px;
-}
-
-.zoom-btn {
-    width: 40px;
-    height: 40px;
-    border-radius: 10px;
-    background: var(--bg-secondary);
-    color: var(--text-primary);
-    border: 1px solid var(--border-color);
-    font-size: 18px;
-    cursor: pointer;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    transition: all 0.2s;
-    box-shadow: var(--card-shadow);
-}
-
-.zoom-btn:hover {
-    background: var(--accent-color);
-    color: white;
-    border-color: var(--accent-color);
-}
-
-/* Utility Classes */
-.hidden {
-    display: none !important;
-}
-
-.loading {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    height: 200px;
-    color: var(--text-muted);
-    font-size: 14px;
-}
-
-/* Scrollbar Styling */
-::-webkit-scrollbar {
-    width: 8px;
-    height: 8px;
-}
-
-::-webkit-scrollbar-track {
-    background: var(--bg-tertiary);
-}
-
-::-webkit-scrollbar-thumb {
-    background: var(--text-muted);
-    border-radius: 4px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-    background: var(--text-secondary);
-}
-
-/* Responsive */
-@media (max-width: 768px) {
-    .sidebar {
-        width: 220px;
-    }
-    
-    .controls {
-        padding: 10px 16px;
-        gap: 12px;
-    }
-    
-    .header {
-        padding: 12px 16px;
-    }
-}

cmd/gf/internal/cmd/genservice/genservice_calculate.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
-	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
 
@@ -37,21 +36,14 @@ func (c CGenService) calculateImportedItems(
 	}
 
 	for _, item := range pkgItems {
-		alias := item.Alias
-
-		// If the alias is _, it means that the package is not generated.
-		if alias == "_" {
+		// Skip anonymous imports
+		if item.Alias == "_" {
 			mlog.Debugf(`ignore anonymous package: %s`, item.RawImport)
 			continue
 		}
-		// If the alias is empty, it will use the package name as the alias.
-		if alias == "" {
-			alias = gfile.Basename(gstr.Trim(item.Path, `"`))
-		}
-		if !gstr.Contains(allFuncParamType.String(), alias) {
-			mlog.Debugf(`ignore unused package: %s`, item.RawImport)
-			continue
-		}
+		// Keep all imports, let gofmt clean up unused ones.
+		// We cannot accurately infer package name from import path
+		// (e.g., path "minio-go" but package name is "minio").
 		srcImportedPackages.Add(item.RawImport)
 	}
 	return nil

cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242/issue4242.go

@@ -0,0 +1,34 @@
+package issue4242
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242(New())
+}
+
+type sIssue4242 struct {
+}
+
+func New() *sIssue4242 {
+	return &sIssue4242{}
+}
+
+// GetDriver tests versioned import path is preserved.
+func (s *sIssue4242) GetDriver(ctx context.Context) (d mysql.Driver, err error) {
+	return mysql.Driver{}, nil
+}
+
+// GetRequest tests another versioned import.
+func (s *sIssue4242) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	g.Log().Info(ctx, "getting request")
+	return nil, nil
+}

cmd/gf/internal/cmd/testdata/issue/4242/logic/issue4242alias/issue4242alias.go

@@ -0,0 +1,37 @@
+package issue4242alias
+
+import (
+	"context"
+
+	// Anonymous import (should be skipped)
+	_ "github.com/gogf/gf/v2/os/gres"
+
+	// Versioned import without alias
+	"github.com/gogf/gf/v2/net/ghttp"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/service"
+
+	// Explicit alias import
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+)
+
+func init() {
+	service.RegisterIssue4242Alias(New())
+}
+
+type sIssue4242Alias struct {
+}
+
+func New() *sIssue4242Alias {
+	return &sIssue4242Alias{}
+}
+
+// GetDriver tests explicit alias import.
+func (s *sIssue4242Alias) GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error) {
+	return mysqlDriver.Driver{}, nil
+}
+
+// GetRequest tests versioned import.
+func (s *sIssue4242Alias) GetRequest(ctx context.Context) (*ghttp.Request, error) {
+	return nil, nil
+}

cmd/gf/internal/cmd/testdata/issue/4242/logic/logic.go

@@ -0,0 +1,10 @@
+// ==========================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// ==========================================================================
+
+package logic
+
+import (
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242"
+	_ "github.com/gogf/gf/cmd/gf/v2/internal/cmd/testdata/issue/4242/logic/issue4242alias"
+)

cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242.go

@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	"github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242 interface {
+		// GetDriver tests versioned import path is preserved.
+		GetDriver(ctx context.Context) (d mysql.Driver, err error)
+		// GetRequest tests another versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242 IIssue4242
+)
+
+func Issue4242() IIssue4242 {
+	if localIssue4242 == nil {
+		panic("implement not found for interface IIssue4242, forgot register?")
+	}
+	return localIssue4242
+}
+
+func RegisterIssue4242(i IIssue4242) {
+	localIssue4242 = i
+}

cmd/gf/internal/cmd/testdata/issue/4242/service/issue_4242_alias.go

@@ -0,0 +1,37 @@
+// ================================================================================
+// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.
+// You can delete these comments if you wish manually maintain this interface file.
+// ================================================================================
+
+package service
+
+import (
+	"context"
+
+	mysqlDriver "github.com/gogf/gf/contrib/drivers/mysql/v2"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+type (
+	IIssue4242Alias interface {
+		// GetDriver tests explicit alias import.
+		GetDriver(ctx context.Context) (d mysqlDriver.Driver, err error)
+		// GetRequest tests versioned import.
+		GetRequest(ctx context.Context) (*ghttp.Request, error)
+	}
+)
+
+var (
+	localIssue4242Alias IIssue4242Alias
+)
+
+func Issue4242Alias() IIssue4242Alias {
+	if localIssue4242Alias == nil {
+		panic("implement not found for interface IIssue4242Alias, forgot register?")
+	}
+	return localIssue4242Alias
+}
+
+func RegisterIssue4242Alias(i IIssue4242Alias) {
+	localIssue4242Alias = i
+}

container/garray/garray_normal_t.go

@@ -749,7 +749,9 @@ func (a *TArray[T]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a TArray[int]
+// Please refer to corresponding tests for more details.
 func (a TArray[T]) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()

container/garray/garray_sorted_t.go

@@ -46,7 +46,7 @@ func NewSortedTArray[T comparable](comparator func(a, b T) int, safe ...bool) *S
 	return NewSortedTArraySize(0, comparator, safe...)
 }
 
-// NewSortedTArraySize create and returns an sorted array with given size and cap.
+// NewSortedTArraySize create and returns a sorted array with given size and cap.
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedTArraySize[T comparable](cap int, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
@@ -718,7 +718,9 @@ func (a *SortedTArray[T]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-// Note that do not use pointer as its receiver here.
+// DO NOT change this receiver to pointer type, as the TArray can be used as a var defined variable, like:
+// var a SortedTArray[int]
+// Please refer to corresponding tests for more details.
 func (a SortedTArray[T]) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()

container/gmap/gmap_hash_k_v_map.go

@@ -22,8 +22,11 @@ type NilChecker[V any] func(V) bool
 
 // KVMap wraps map type `map[K]V` and provides more map features.
 type KVMap[K comparable, V any] struct {
-	mu         rwmutex.RWMutex
-	data       map[K]V
+	mu   rwmutex.RWMutex
+	data map[K]V
+
+	// nilChecker is the custom nil checker function.
+	// It uses empty.IsNil if it's nil.
 	nilChecker NilChecker[V]
 }
 
@@ -58,15 +61,15 @@ func NewKVMapFrom[K comparable, V any](data map[K]V, safe ...bool) *KVMap[K, V]
 // The parameter `safe` is used to specify whether to use the map in concurrent-safety mode, which is false by default.
 func NewKVMapWithCheckerFrom[K comparable, V any](data map[K]V, checker NilChecker[V], safe ...bool) *KVMap[K, V] {
 	m := NewKVMapFrom[K, V](data, safe...)
-	m.RegisterNilChecker(checker)
+	m.SetNilChecker(checker)
 	return m
 }
 
-// RegisterNilChecker registers a custom nil checker function for the map values.
+// SetNilChecker registers a custom nil checker function for the map values.
 // This function is used to determine if a value should be considered as nil.
 // The nil checker function takes a value of type V and returns a boolean indicating
 // whether the value should be treated as nil.
-func (m *KVMap[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
+func (m *KVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.nilChecker = nilChecker
@@ -74,12 +77,12 @@ func (m *KVMap[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
+// otherwise it falls back to the default empty.IsNil function.
 func (m *KVMap[K, V]) isNil(v V) bool {
 	if m.nilChecker != nil {
 		return m.nilChecker(v)
 	}
-	return any(v) == nil
+	return empty.IsNil(v)
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
@@ -242,11 +245,12 @@ func (m *KVMap[K, V]) Pops(size int) map[K]V {
 	return newMap
 }
 
-// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
-// if not exists, set value to the map with given `key`,
-// or else just return the existing value.
+// doSetWithLockCheck sets value with given `value` if it does not exist,
+// and then returns this value and whether it exists.
 //
-// It returns value with given `key`.
+// It is a helper function for GetOrSet* functions.
+//
+// Note that, it does not add the value to the map if the given `value` is nil.
 func (m *KVMap[K, V]) doSetWithLockCheck(key K, value V) (val V, ok bool) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -274,6 +278,8 @@ func (m *KVMap[K, V]) GetOrSet(key K, value V) V {
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *KVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
 	v, _ := m.doSetWithLockCheck(key, f())
 	return v
@@ -285,6 +291,8 @@ func (m *KVMap[K, V]) GetOrSetFunc(key K, f func() V) V {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *KVMap[K, V]) GetOrSetFuncLock(key K, f func() V) V {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -524,6 +532,9 @@ func (m *KVMap[K, V]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the KVMap can be used as a var defined variable, like:
+// var m gmap.KVMap[int, string]
+// Please refer to corresponding tests for more details.
 func (m KVMap[K, V]) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))
 }

container/gmap/gmap_list_k_v_map.go

@@ -56,7 +56,7 @@ func NewListKVMap[K comparable, V any](safe ...bool) *ListKVMap[K, V] {
 // which is false by default.
 func NewListKVMapWithChecker[K comparable, V any](checker NilChecker[V], safe ...bool) *ListKVMap[K, V] {
 	m := NewListKVMap[K, V](safe...)
-	m.RegisterNilChecker(checker)
+	m.SetNilChecker(checker)
 	return m
 }
 
@@ -81,11 +81,11 @@ func NewListKVMapWithCheckerFrom[K comparable, V any](data map[K]V, nilChecker N
 	return m
 }
 
-// RegisterNilChecker registers a custom nil checker function for the map values.
+// SetNilChecker registers a custom nil checker function for the map values.
 // This function is used to determine if a value should be considered as nil.
 // The nil checker function takes a value of type V and returns a boolean indicating
 // whether the value should be treated as nil.
-func (m *ListKVMap[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
+func (m *ListKVMap[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.nilChecker = nilChecker
@@ -93,12 +93,12 @@ func (m *ListKVMap[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
+// otherwise it falls back to the default empty.IsNil function.
 func (m *ListKVMap[K, V]) isNil(v V) bool {
 	if m.nilChecker != nil {
 		return m.nilChecker(v)
 	}
-	return any(v) == nil
+	return empty.IsNil(v)
 }
 
 // Iterator is alias of IteratorAsc.
@@ -402,6 +402,8 @@ func (m *ListKVMap[K, V]) GetVarOrSetFuncLock(key K, f func() V) *gvar.Var {
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that it does not add the value to the map if `value` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -421,6 +423,8 @@ func (m *ListKVMap[K, V]) SetIfNotExist(key K, value V) bool {
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -444,6 +448,8 @@ func (m *ListKVMap[K, V]) SetIfNotExistFunc(key K, f func() V) bool {
 //
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the map.
+//
+// Note that, it does not add the value to the map if the returned value of `f` is nil.
 func (m *ListKVMap[K, V]) SetIfNotExistFuncLock(key K, f func() V) bool {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -609,6 +615,9 @@ func (m *ListKVMap[K, V]) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// DO NOT change this receiver to pointer type, as the ListKVMap can be used as a var defined variable, like:
+// var m gmap.ListKVMap[string]string
+// Please refer to corresponding tests for more details.
 func (m ListKVMap[K, V]) MarshalJSON() (jsonBytes []byte, err error) {
 	if m.data == nil {
 		return []byte("{}"), nil

container/gmap/gmap_z_unit_k_v_map_test.go

@@ -774,6 +774,13 @@ func Test_KVMap_MarshalJSON(t *testing.T) {
 		t.Assert(data["a"], 1)
 		t.Assert(data["b"], 2)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.KVMap[int, int]
+		m.Set(1, 10)
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(string(b), `{"1":10}`)
+	})
 }
 
 func Test_KVMap_UnmarshalJSON(t *testing.T) {
@@ -1647,9 +1654,10 @@ func Test_KVMap_TypedNil(t *testing.T) {
 				return nil
 			})
 		}
-		t.Assert(m1.Size(), 10)
+		t.Assert(m1.Size(), 5)
+
 		m2 := gmap.NewKVMap[int, *Student](true)
-		m2.RegisterNilChecker(func(student *Student) bool {
+		m2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		for i := 0; i < 10; i++ {
@@ -1679,7 +1687,8 @@ func Test_NewKVMapWithChecker_TypedNil(t *testing.T) {
 				return nil
 			})
 		}
-		t.Assert(m1.Size(), 10)
+		t.Assert(m1.Size(), 5)
+
 		m2 := gmap.NewKVMapWithChecker[int, *Student](func(student *Student) bool {
 			return student == nil
 		}, true)

container/gmap/gmap_z_unit_list_k_v_map_race_test.go

@@ -183,77 +183,6 @@ func Test_ListKVMap_SetIfNotExistFuncLock_MultipleKeys(t *testing.T) {
 	})
 }
 
-// Test_ListKVMap_GetOrSetFuncLock_NilValue tests that nil values are handled correctly.
-func Test_ListKVMap_GetOrSetFuncLock_NilValue(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		m := gmap.NewListKVMap[string, *int](true)
-		key := "nilKey"
-		callCount := int32(0)
-
-		var wg sync.WaitGroup
-		goroutines := 50
-		wg.Add(goroutines)
-
-		for i := 0; i < goroutines; i++ {
-			go func() {
-				defer wg.Done()
-				m.GetOrSetFuncLock(key, func() *int {
-					atomic.AddInt32(&callCount, 1)
-					return nil
-				})
-			}()
-		}
-
-		wg.Wait()
-
-		// Callback should be called once
-		t.Assert(atomic.LoadInt32(&callCount), 1)
-		// Typed nil pointer (*int)(nil) is stored because any(value) != nil for typed nil
-		// This is a Go language feature: typed nil is not the same as interface nil
-		t.Assert(m.Contains(key), true)
-		t.Assert(m.Get(key), (*int)(nil))
-		t.Assert(m.Size(), 1)
-	})
-}
-
-// Test_ListKVMap_SetIfNotExistFuncLock_NilValue tests that nil values are handled correctly.
-func Test_ListKVMap_SetIfNotExistFuncLock_NilValue(t *testing.T) {
-	gtest.C(t, func(t *gtest.T) {
-		m := gmap.NewListKVMap[string, *string](true)
-		key := "nilKey"
-		callCount := int32(0)
-		successCount := int32(0)
-
-		var wg sync.WaitGroup
-		goroutines := 50
-		wg.Add(goroutines)
-
-		for i := 0; i < goroutines; i++ {
-			go func() {
-				defer wg.Done()
-				success := m.SetIfNotExistFuncLock(key, func() *string {
-					atomic.AddInt32(&callCount, 1)
-					return nil
-				})
-				if success {
-					atomic.AddInt32(&successCount, 1)
-				}
-			}()
-		}
-
-		wg.Wait()
-
-		// Callback should be called once
-		t.Assert(atomic.LoadInt32(&callCount), 1)
-		// Should report success once
-		t.Assert(atomic.LoadInt32(&successCount), 1)
-		// Typed nil pointer (*string)(nil) is stored because any(value) != nil for typed nil
-		t.Assert(m.Contains(key), true)
-		t.Assert(m.Get(key), (*string)(nil))
-		t.Assert(m.Size(), 1)
-	})
-}
-
 // Test_ListKVMap_GetOrSetFuncLock_ExistingKey tests behavior when key already exists.
 func Test_ListKVMap_GetOrSetFuncLock_ExistingKey(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {

container/gmap/gmap_z_unit_list_k_v_map_test.go

@@ -1159,6 +1159,13 @@ func Test_ListKVMap_MarshalJSON_Error(t *testing.T) {
 		t.AssertNil(err)
 		t.Assert(string(b), `{"a":"1"}`)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		var m gmap.ListKVMap[int, int]
+		m.Set(1, 10)
+		b, err := json.Marshal(m)
+		t.AssertNil(err)
+		t.Assert(string(b), `{"1":10}`)
+	})
 }
 
 // Test empty map operations
@@ -1358,9 +1365,10 @@ func Test_ListKVMap_TypedNil(t *testing.T) {
 				return nil
 			})
 		}
-		t.Assert(m1.Size(), 10)
+		t.Assert(m1.Size(), 5)
+
 		m2 := gmap.NewListKVMap[int, *Student](true)
-		m2.RegisterNilChecker(func(student *Student) bool {
+		m2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		for i := 0; i < 10; i++ {
@@ -1390,7 +1398,8 @@ func Test_NewListKVMapWithChecker_TypedNil(t *testing.T) {
 				return nil
 			})
 		}
-		t.Assert(m1.Size(), 10)
+		t.Assert(m1.Size(), 5)
+
 		m2 := gmap.NewListKVMapWithChecker[int, *Student](func(student *Student) bool {
 			return student == nil
 		}, true)

container/gset/gset_t_set.go

@@ -9,6 +9,7 @@ package gset
 import (
 	"bytes"
 
+	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -39,7 +40,7 @@ func NewTSet[T comparable](safe ...bool) *TSet[T] {
 // The parameter `safe` is used to specify whether using set in concurrent-safety mode.
 func NewTSetWithChecker[T comparable](checker NilChecker[T], safe ...bool) *TSet[T] {
 	s := NewTSet[T](safe...)
-	s.RegisterNilChecker(checker)
+	s.SetNilChecker(checker)
 	return s
 }
 
@@ -66,11 +67,11 @@ func NewTSetWithCheckerFrom[T comparable](items []T, checker NilChecker[T], safe
 	return set
 }
 
-// RegisterNilChecker registers a custom nil checker function for the set elements.
+// SetNilChecker registers a custom nil checker function for the set elements.
 // This function is used to determine if an element should be considered as nil.
 // The nil checker function takes an element of type T and returns a boolean indicating
 // whether the element should be treated as nil.
-func (set *TSet[T]) RegisterNilChecker(nilChecker NilChecker[T]) {
+func (set *TSet[T]) SetNilChecker(nilChecker NilChecker[T]) {
 	set.mu.Lock()
 	defer set.mu.Unlock()
 	set.nilChecker = nilChecker
@@ -78,12 +79,12 @@ func (set *TSet[T]) RegisterNilChecker(nilChecker NilChecker[T]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
+// otherwise it falls back to the default empty.IsNil function.
 func (set *TSet[T]) isNil(v T) bool {
 	if set.nilChecker != nil {
 		return set.nilChecker(v)
 	}
-	return any(v) == nil
+	return empty.IsNil(v)
 }
 
 // Iterator iterates the set readonly with given callback function `f`,
@@ -109,7 +110,7 @@ func (set *TSet[T]) Add(items ...T) {
 }
 
 // AddIfNotExist checks whether item exists in the set,
-// it adds the item to set and returns true if it does not exists in the set,
+// it adds the item to set and returns true if it does not exist in the set,
 // or else it does nothing and returns false.
 //
 // Note that, if `item` is nil, it does nothing and returns false.

container/gset/gset_z_unit_t_set_test.go

@@ -601,10 +601,10 @@ func Test_TSet_TypedNil(t *testing.T) {
 		set := gset.NewTSet[*Student](true)
 		var s *Student = nil
 		exist := set.AddIfNotExist(s)
-		t.Assert(exist, true)
+		t.Assert(exist, false)
 
 		set2 := gset.NewTSet[*Student](true)
-		set2.RegisterNilChecker(func(student *Student) bool {
+		set2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		exist2 := set2.AddIfNotExist(s)
@@ -621,7 +621,7 @@ func Test_NewTSetWithChecker_TypedNil(t *testing.T) {
 		set := gset.NewTSet[*Student](true)
 		var s *Student = nil
 		exist := set.AddIfNotExist(s)
-		t.Assert(exist, true)
+		t.Assert(exist, false)
 
 		set2 := gset.NewTSetWithChecker[*Student](func(student *Student) bool {
 			return student == nil

container/gtree/gtree_k_v_avltree.go

@@ -12,6 +12,7 @@ import (
 	"github.com/emirpasic/gods/v2/trees/avltree"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -52,7 +53,7 @@ func NewAVLKVTree[K comparable, V any](comparator func(v1, v2 K) int, safe ...bo
 // The parameter `checker` is used to specify whether the given value is nil.
 func NewAVLKVTreeWithChecker[K comparable, V any](comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *AVLKVTree[K, V] {
 	t := NewAVLKVTree[K, V](comparator, safe...)
-	t.RegisterNilChecker(checker)
+	t.SetNilChecker(checker)
 	return t
 }
 
@@ -78,11 +79,11 @@ func NewAVLKVTreeWithCheckerFrom[K comparable, V any](comparator func(v1, v2 K)
 	return tree
 }
 
-// RegisterNilChecker registers a custom nil checker function for the map values.
+// SetNilChecker registers a custom nil checker function for the map values.
 // This function is used to determine if a value should be considered as nil.
 // The nil checker function takes a value of type V and returns a boolean indicating
 // whether the value should be treated as nil.
-func (tree *AVLKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
+func (tree *AVLKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
 	tree.mu.Lock()
 	defer tree.mu.Unlock()
 	tree.nilChecker = nilChecker
@@ -90,12 +91,12 @@ func (tree *AVLKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
-func (tree *AVLKVTree[K, V]) isNil(value V) bool {
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *AVLKVTree[K, V]) isNil(v V) bool {
 	if tree.nilChecker != nil {
-		return tree.nilChecker(value)
+		return tree.nilChecker(v)
 	}
-	return any(value) == nil
+	return empty.IsNil(v)
 }
 
 // Clone clones and returns a new tree from current tree.

container/gtree/gtree_k_v_btree.go

@@ -12,6 +12,7 @@ import (
 	"github.com/emirpasic/gods/v2/trees/btree"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -51,7 +52,7 @@ func NewBKVTree[K comparable, V any](m int, comparator func(v1, v2 K) int, safe
 // The parameter `checker` is used to specify whether the given value is nil.
 func NewBKVTreeWithChecker[K comparable, V any](m int, comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *BKVTree[K, V] {
 	t := NewBKVTree[K, V](m, comparator, safe...)
-	t.RegisterNilChecker(checker)
+	t.SetNilChecker(checker)
 	return t
 }
 
@@ -77,11 +78,11 @@ func NewBKVTreeWithCheckerFrom[K comparable, V any](m int, comparator func(v1, v
 	return tree
 }
 
-// RegisterNilChecker registers a custom nil checker function for the map values.
+// SetNilChecker registers a custom nil checker function for the map values.
 // This function is used to determine if a value should be considered as nil.
 // The nil checker function takes a value of type V and returns a boolean indicating
 // whether the value should be treated as nil.
-func (tree *BKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
+func (tree *BKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
 	tree.mu.Lock()
 	defer tree.mu.Unlock()
 	tree.nilChecker = nilChecker
@@ -89,12 +90,12 @@ func (tree *BKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
-func (tree *BKVTree[K, V]) isNil(value V) bool {
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *BKVTree[K, V]) isNil(v V) bool {
 	if tree.nilChecker != nil {
-		return tree.nilChecker(value)
+		return tree.nilChecker(v)
 	}
-	return any(value) == nil
+	return empty.IsNil(v)
 }
 
 // Clone clones and returns a new tree from current tree.

container/gtree/gtree_k_v_redblacktree.go

@@ -12,6 +12,7 @@ import (
 	"github.com/emirpasic/gods/v2/trees/redblacktree"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -47,7 +48,7 @@ func NewRedBlackKVTree[K comparable, V any](comparator func(v1, v2 K) int, safe
 // The parameter `checker` is used to specify whether the given value is nil.
 func NewRedBlackKVTreeWithChecker[K comparable, V any](comparator func(v1, v2 K) int, checker NilChecker[V], safe ...bool) *RedBlackKVTree[K, V] {
 	t := NewRedBlackKVTree[K, V](comparator, safe...)
-	t.RegisterNilChecker(checker)
+	t.SetNilChecker(checker)
 	return t
 }
 
@@ -96,11 +97,11 @@ func RedBlackKVTreeInitFrom[K comparable, V any](tree *RedBlackKVTree[K, V], com
 	}
 }
 
-// RegisterNilChecker registers a custom nil checker function for the map values.
+// SetNilChecker registers a custom nil checker function for the map values.
 // This function is used to determine if a value should be considered as nil.
 // The nil checker function takes a value of type V and returns a boolean indicating
 // whether the value should be treated as nil.
-func (tree *RedBlackKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
+func (tree *RedBlackKVTree[K, V]) SetNilChecker(nilChecker NilChecker[V]) {
 	tree.mu.Lock()
 	defer tree.mu.Unlock()
 	tree.nilChecker = nilChecker
@@ -108,12 +109,12 @@ func (tree *RedBlackKVTree[K, V]) RegisterNilChecker(nilChecker NilChecker[V]) {
 
 // isNil checks whether the given value is nil.
 // It first checks if a custom nil checker function is registered and uses it if available,
-// otherwise it performs a standard nil check using any(v) == nil.
-func (tree *RedBlackKVTree[K, V]) isNil(value V) bool {
+// otherwise it falls back to the default empty.IsNil function.
+func (tree *RedBlackKVTree[K, V]) isNil(v V) bool {
 	if tree.nilChecker != nil {
-		return tree.nilChecker(value)
+		return tree.nilChecker(v)
 	}
-	return any(value) == nil
+	return empty.IsNil(v)
 }
 
 // SetComparator sets/changes the comparator for sorting.

container/gtree/gtree_z_k_v_tree_test.go

@@ -29,9 +29,10 @@ func Test_KVAVLTree_TypedNil(t *testing.T) {
 				avlTree.Set(i, s)
 			}
 		}
-		t.Assert(avlTree.Size(), 10)
+		t.Assert(avlTree.Size(), 5)
+
 		avlTree2 := gtree.NewAVLKVTree[int, *Student](gutil.ComparatorTStr[int], true)
-		avlTree2.RegisterNilChecker(func(student *Student) bool {
+		avlTree2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		for i := 0; i < 10; i++ {
@@ -62,9 +63,10 @@ func Test_KVBTree_TypedNil(t *testing.T) {
 				btree.Set(i, s)
 			}
 		}
-		t.Assert(btree.Size(), 10)
+		t.Assert(btree.Size(), 5)
+
 		btree2 := gtree.NewBKVTree[int, *Student](100, gutil.ComparatorTStr[int], true)
-		btree2.RegisterNilChecker(func(student *Student) bool {
+		btree2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		for i := 0; i < 10; i++ {
@@ -95,10 +97,10 @@ func Test_KVRedBlackTree_TypedNil(t *testing.T) {
 				redBlackTree.Set(i, s)
 			}
 		}
-		t.Assert(redBlackTree.Size(), 10)
-		redBlackTree2 := gtree.NewRedBlackKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		t.Assert(redBlackTree.Size(), 5)
 
-		redBlackTree2.RegisterNilChecker(func(student *Student) bool {
+		redBlackTree2 := gtree.NewRedBlackKVTree[int, *Student](gutil.ComparatorTStr[int], true)
+		redBlackTree2.SetNilChecker(func(student *Student) bool {
 			return student == nil
 		})
 		for i := 0; i < 10; i++ {
@@ -128,7 +130,8 @@ func Test_NewKVAVLTreeWithChecker_TypedNil(t *testing.T) {
 				avlTree.Set(i, s)
 			}
 		}
-		t.Assert(avlTree.Size(), 10)
+		t.Assert(avlTree.Size(), 5)
+
 		avlTree2 := gtree.NewAVLKVTreeWithChecker[int, *Student](gutil.ComparatorTStr[int], func(student *Student) bool {
 			return student == nil
 		}, true)
@@ -160,7 +163,8 @@ func Test_NewKVBTreeWithChecker_TypedNil(t *testing.T) {
 				btree.Set(i, s)
 			}
 		}
-		t.Assert(btree.Size(), 10)
+		t.Assert(btree.Size(), 5)
+
 		btree2 := gtree.NewBKVTreeWithChecker[int, *Student](100, gutil.ComparatorTStr[int], func(student *Student) bool {
 			return student == nil
 		}, true)
@@ -192,7 +196,8 @@ func Test_NewRedBlackKVTreeWithChecker_TypedNil(t *testing.T) {
 				redBlackTree.Set(i, s)
 			}
 		}
-		t.Assert(redBlackTree.Size(), 10)
+		t.Assert(redBlackTree.Size(), 5)
+
 		redBlackTree2 := gtree.NewRedBlackKVTreeWithChecker[int, *Student](gutil.ComparatorTStr[int], func(student *Student) bool {
 			return student == nil
 		}, true)

contrib/config/apollo/apollo.go

@@ -179,7 +179,7 @@ func (c *Client) updateLocalValue(ctx context.Context) (err error) {
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
 	c.watchers.Add(name, f)
 }
 
@@ -193,6 +193,11 @@ func (c *Client) GetWatcherNames() []string {
 	return c.watchers.GetNames()
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (c *Client) notifyWatchers(ctx context.Context) {
 	c.watchers.Notify(ctx)

contrib/config/consul/consul.go

@@ -207,7 +207,7 @@ func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
 	c.watchers.Add(name, f)
 }
 
@@ -221,6 +221,11 @@ func (c *Client) GetWatcherNames() []string {
 	return c.watchers.GetNames()
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (c *Client) notifyWatchers(ctx context.Context) {
 	c.watchers.Notify(ctx)

contrib/config/kubecm/kubecm.go

@@ -199,7 +199,7 @@ func (c *Client) startAsynchronousWatch(ctx context.Context, namespace string, w
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
 	c.watchers.Add(name, f)
 }
 
@@ -213,6 +213,11 @@ func (c *Client) GetWatcherNames() []string {
 	return c.watchers.GetNames()
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (c *Client) notifyWatchers(ctx context.Context) {
 	c.watchers.Notify(ctx)

contrib/config/nacos/nacos.go

@@ -152,7 +152,7 @@ func (c *Client) addWatcher() error {
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
 	c.watchers.Add(name, f)
 }
 
@@ -166,6 +166,11 @@ func (c *Client) GetWatcherNames() []string {
 	return c.watchers.GetNames()
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (c *Client) notifyWatchers(ctx context.Context) {
 	c.watchers.Notify(ctx)

contrib/config/polaris/polaris.go

@@ -187,7 +187,7 @@ func (c *Client) startAsynchronousWatch(ctx context.Context, changeChan <-chan m
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+func (c *Client) AddWatcher(name string, f gcfg.WatcherFunc) {
 	c.watchers.Add(name, f)
 }
 
@@ -201,6 +201,11 @@ func (c *Client) GetWatcherNames() []string {
 	return c.watchers.GetNames()
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (c *Client) IsWatching(name string) bool {
+	return c.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (c *Client) notifyWatchers(ctx context.Context) {
 	c.watchers.Notify(ctx)

contrib/drivers/dm/dm_do_insert.go

@@ -108,7 +108,7 @@ func (d *Driver) doMergeInsert(
 		one            = list[0]
 		oneLen         = len(one)
 		charL, charR   = d.GetChars()
-		conflictKeySet = gset.New(false)
+		conflictKeySet = gset.NewStrSet(false)
 
 		// queryHolders:	Handle data with Holder that need to be merged
 		// queryValues:		Handle data that need to be merged

contrib/drivers/gaussdb/gaussdb_do_insert.go

@@ -307,7 +307,7 @@ func (d *Driver) doMergeInsert(
 		one            = list[0]
 		oneLen         = len(one)
 		charL, charR   = d.GetChars()
-		conflictKeySet = gset.New(false)
+		conflictKeySet = gset.NewStrSet(false)
 
 		// queryHolders:	Handle data with Holder that need to be merged
 		// queryValues:		Handle data that need to be merged

contrib/drivers/mssql/mssql_do_insert.go

@@ -102,7 +102,7 @@ func (d *Driver) doMergeInsert(
 		one            = list[0]
 		oneLen         = len(one)
 		charL, charR   = d.GetChars()
-		conflictKeySet = gset.New(false)
+		conflictKeySet = gset.NewStrSet(false)
 
 		// queryHolders:	Handle data with Holder that need to be merged
 		// queryValues:		Handle data that need to be merged

contrib/drivers/oracle/oracle_do_insert.go

@@ -181,7 +181,7 @@ func (d *Driver) doMergeInsert(
 		one            = list[0]
 		oneLen         = len(one)
 		charL, charR   = d.GetChars()
-		conflictKeySet = gset.New(false)
+		conflictKeySet = gset.NewStrSet(false)
 
 		// queryHolders:	Handle data with Holder that need to be upsert
 		// queryValues:		Handle data that need to be upsert

contrib/registry/nacos/README.MD

@@ -1,24 +1,25 @@
 # GoFrame Nacos Registry
 
-
 Use `nacos` as service registration and discovery management.
 
-
 ## Installation
+
 ```
 go get -u -v github.com/gogf/gf/contrib/registry/nacos/v2
 ```
+
 suggested using `go.mod`:
+
 ```
 require github.com/gogf/gf/contrib/registry/nacos/v2 latest
 ```
 
-
 ## Example
 
 ### Reference example
 
 [server](../../../example/registry/nacos/http/server/main.go)
+
 ```go
 package main
 
@@ -44,6 +45,7 @@ func main() {
 ```
 
 [client](../../../example/registry/nacos/http/client/main.go)
+
 ```go
 package main
 
@@ -78,4 +80,3 @@ func main() {
 ## License
 
 `GoFrame Nacos` is licensed under the [MIT License](../../../LICENSE), 100% free and open-source, forever.
-

contrib/registry/nacos/go.mod

@@ -4,7 +4,7 @@ go 1.23.0
 
 require (
 	github.com/gogf/gf/v2 v2.9.8
-	github.com/nacos-group/nacos-sdk-go/v2 v2.3.3
+	github.com/nacos-group/nacos-sdk-go/v2 v2.3.5
 )
 
 require (

contrib/registry/nacos/go.sum

@@ -267,8 +267,8 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nacos-group/nacos-sdk-go/v2 v2.3.3 h1:lvkBZcYkKENLVR1ubO+vGxTP2L4VtVSArLvYZKuu4Pk=
-github.com/nacos-group/nacos-sdk-go/v2 v2.3.3/go.mod h1:ygUBdt7eGeYBt6Lz2HO3wx7crKXk25Mp80568emGMWU=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.5 h1:Hux7C4N4rWhwBF5Zm4yyYskrs9VTgrRTA8DZjoEhQTs=
+github.com/nacos-group/nacos-sdk-go/v2 v2.3.5/go.mod h1:ygUBdt7eGeYBt6Lz2HO3wx7crKXk25Mp80568emGMWU=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=

contrib/registry/nacos/nacos.go

@@ -82,7 +82,7 @@ func New(address string, opts ...constant.ClientOption) (reg *Registry) {
 	return
 }
 
-// New creates and returns registry with Config.
+// NewWithConfig creates and returns registry with Config.
 func NewWithConfig(ctx context.Context, config Config) (reg *Registry, err error) {
 	// Data validation.
 	err = g.Validator().Data(config).Run(ctx)

contrib/registry/nacos/nacos_discovery.go

@@ -19,7 +19,7 @@ import (
 )
 
 // Search searches and returns services with specified condition.
-func (reg *Registry) Search(ctx context.Context, in gsvc.SearchInput) (result []gsvc.Service, err error) {
+func (reg *Registry) Search(_ context.Context, in gsvc.SearchInput) (result []gsvc.Service, err error) {
 	if in.Prefix == "" && in.Name != "" {
 		in.Prefix = gsvc.NewServiceWithName(in.Name).GetPrefix()
 	}

contrib/registry/nacos/nacos_register.go

@@ -17,7 +17,7 @@ import (
 
 // Register registers `service` to Registry.
 // Note that it returns a new Service if it changes the input Service with custom one.
-func (reg *Registry) Register(ctx context.Context, service gsvc.Service) (registered gsvc.Service, err error) {
+func (reg *Registry) Register(_ context.Context, service gsvc.Service) (registered gsvc.Service, err error) {
 	metadata := map[string]string{}
 	endpoints := service.GetEndpoints()
 
@@ -67,7 +67,7 @@ func (reg *Registry) Register(ctx context.Context, service gsvc.Service) (regist
 }
 
 // Deregister off-lines and removes `service` from the Registry.
-func (reg *Registry) Deregister(ctx context.Context, service gsvc.Service) (err error) {
+func (reg *Registry) Deregister(_ context.Context, service gsvc.Service) (err error) {
 	c := reg.client
 
 	for _, endpoint := range service.GetEndpoints() {

database/gdb/gdb.go

@@ -513,18 +513,18 @@ type StatsItem interface {
 
 // Core is the base struct for database management.
 type Core struct {
-	db            DB              // DB interface object.
-	ctx           context.Context // Context for chaining operation only. Do not set a default value in Core initialization.
-	group         string          // Configuration group name.
-	schema        string          // Custom schema for this object.
-	debug         *gtype.Bool     // Enable debug mode for the database, which can be changed in runtime.
-	cache         *gcache.Cache   // Cache manager, SQL result cache only.
-	links         *gmap.Map       // links caches all created links by node.
-	logger        glog.ILogger    // Logger for logging functionality.
-	config        *ConfigNode     // Current config node.
-	localTypeMap  *gmap.StrAnyMap // Local type map for database field type conversion.
-	dynamicConfig dynamicConfig   // Dynamic configurations, which can be changed in runtime.
-	innerMemCache *gcache.Cache   // Internal memory cache for storing temporary data.
+	db            DB                               // DB interface object.
+	ctx           context.Context                  // Context for chaining operation only. Do not set a default value in Core initialization.
+	group         string                           // Configuration group name.
+	schema        string                           // Custom schema for this object.
+	debug         *gtype.Bool                      // Enable debug mode for the database, which can be changed in runtime.
+	cache         *gcache.Cache                    // Cache manager, SQL result cache only.
+	links         *gmap.KVMap[ConfigNode, *sql.DB] // links caches all created links by node.
+	logger        glog.ILogger                     // Logger for logging functionality.
+	config        *ConfigNode                      // Current config node.
+	localTypeMap  *gmap.StrAnyMap                  // Local type map for database field type conversion.
+	dynamicConfig dynamicConfig                    // Dynamic configurations, which can be changed in runtime.
+	innerMemCache *gcache.Cache                    // Internal memory cache for storing temporary data.
 }
 
 type dynamicConfig struct {
@@ -944,6 +944,9 @@ func NewByGroup(group ...string) (db DB, err error) {
 	)
 }
 
+// linksChecker is the checker function for links map.
+var linksChecker = func(v *sql.DB) bool { return v == nil }
+
 // newDBByConfigNode creates and returns an ORM object with given configuration node and group name.
 //
 // Very Note:
@@ -960,7 +963,7 @@ func newDBByConfigNode(node *ConfigNode, group string) (db DB, err error) {
 		group:         group,
 		debug:         gtype.NewBool(),
 		cache:         gcache.New(),
-		links:         gmap.New(true),
+		links:         gmap.NewKVMapWithChecker[ConfigNode, *sql.DB](linksChecker, true),
 		logger:        glog.New(),
 		config:        node,
 		localTypeMap:  gmap.NewStrAnyMap(true),
@@ -1127,7 +1130,7 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 
 	// Cache the underlying connection pool object by node.
 	var (
-		instanceCacheFunc = func() any {
+		instanceCacheFunc = func() *sql.DB {
 			if sqlDb, err = c.db.Open(node); err != nil {
 				return nil
 			}
@@ -1159,7 +1162,7 @@ func (c *Core) getSqlDb(master bool, schema ...string) (sqlDb *sql.DB, err error
 	)
 	if instanceValue != nil && sqlDb == nil {
 		// It reads from instance map.
-		sqlDb = instanceValue.(*sql.DB)
+		sqlDb = instanceValue
 	}
 	if node.Debug {
 		c.db.SetDebug(node.Debug)

database/gdb/gdb_core.go

@@ -113,19 +113,17 @@ func (c *Core) Close(ctx context.Context) (err error) {
 	if err = c.cache.Close(ctx); err != nil {
 		return err
 	}
-	c.links.LockFunc(func(m map[any]any) {
+	c.links.LockFunc(func(m map[ConfigNode]*sql.DB) {
 		for k, v := range m {
-			if db, ok := v.(*sql.DB); ok {
-				err = db.Close()
-				if err != nil {
-					err = gerror.WrapCode(gcode.CodeDbOperationError, err, `db.Close failed`)
-				}
-				intlog.Printf(ctx, `close link: %s, err: %v`, k, err)
-				if err != nil {
-					return
-				}
-				delete(m, k)
+			err = v.Close()
+			if err != nil {
+				err = gerror.WrapCode(gcode.CodeDbOperationError, err, `db.Close failed`)
 			}
+			intlog.Printf(ctx, `close link: %s, err: %v`, gconv.String(k), err)
+			if err != nil {
+				return
+			}
+			delete(m, k)
 		}
 	})
 	return

database/gdb/gdb_core_stats.go

@@ -30,14 +30,14 @@ func (item *localStatsItem) Stats() sql.DBStats {
 // Stats retrieves and returns the pool stat for all nodes that have been established.
 func (c *Core) Stats(ctx context.Context) []StatsItem {
 	var items = make([]StatsItem, 0)
-	c.links.Iterator(func(k, v any) bool {
-		var (
-			node  = k.(ConfigNode)
-			sqlDB = v.(*sql.DB)
-		)
+	c.links.Iterator(func(k ConfigNode, v *sql.DB) bool {
+		// Create a local copy of k to avoid loop variable address re-use issue
+		// In Go, loop variables are re-used with the same memory address across iterations,
+		// directly using &k would cause all localStatsItem instances to share the same address
+		node := k
 		items = append(items, &localStatsItem{
 			node:  &node,
-			stats: sqlDB.Stats(),
+			stats: v.Stats(),
 		})
 		return true
 	})

net/ghttp/ghttp_z_unit_issue_test.go

@@ -727,6 +727,36 @@ func Test_Issue4093(t *testing.T) {
 	})
 }
 
+// https://github.com/gogf/gf/issues/4193
+func Test_Issue4193(t *testing.T) {
+	type Req struct {
+		g.Meta `method:"post" mime:"multipart/form-data"`
+		File   *ghttp.UploadFile `v:"required" type:"file"` // File is required
+	}
+	type Res struct{}
+
+	s := g.Server(guid.S())
+	s.BindMiddlewareDefault(ghttp.MiddlewareHandlerResponse)
+	s.BindHandler("/upload", func(ctx context.Context, req *Req) (res *Res, err error) {
+		return
+	})
+	s.SetDumpRouterMap(false)
+	s.SetAccessLogEnabled(false)
+	s.SetErrorLogEnabled(false)
+	s.Start()
+	defer s.Shutdown()
+	time.Sleep(100 * time.Millisecond)
+
+	gtest.C(t, func(t *gtest.T) {
+		client := g.Client()
+		client.SetPrefix(fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort()))
+		content := client.PostContent(ctx, "/upload", g.Map{
+			"file": "",
+		})
+		t.Assert(content, `{"code":51,"message":"The File field is required","data":null}`)
+	})
+}
+
 // Issue4227Req
 type Issue4227Req struct {
 	g.Meta      `path:"/hello/:path_param" method:"post"`

os/gcfg/gcfg_adaper.go

@@ -29,12 +29,17 @@ type Adapter interface {
 	Data(ctx context.Context) (data map[string]any, err error)
 }
 
+// WatcherFunc is the callback function type for configuration watchers.
+type WatcherFunc = func(context.Context)
+
 // WatcherAdapter is the interface for configuration watcher.
 type WatcherAdapter interface {
 	// AddWatcher adds a watcher function for specified `pattern` and `resource`.
-	AddWatcher(name string, fn func(ctx context.Context))
+	AddWatcher(name string, fn WatcherFunc)
 	// RemoveWatcher removes the watcher function for specified `pattern` and `resource`.
 	RemoveWatcher(name string)
 	// GetWatcherNames returns all watcher names.
 	GetWatcherNames() []string
+	// IsWatching checks and returns whether the specified `pattern` is watching.
+	IsWatching(name string) bool
 }

os/gcfg/gcfg_adapter_content.go

@@ -86,7 +86,7 @@ func (a *AdapterContent) Data(ctx context.Context) (data map[string]any, err err
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (a *AdapterContent) AddWatcher(name string, fn func(ctx context.Context)) {
+func (a *AdapterContent) AddWatcher(name string, fn WatcherFunc) {
 	a.watchers.Add(name, fn)
 }
 
@@ -100,6 +100,11 @@ func (a *AdapterContent) GetWatcherNames() []string {
 	return a.watchers.GetNames()
 }
 
+// IsWatching checks and returns whether the specified `name` is watching.
+func (a *AdapterContent) IsWatching(name string) bool {
+	return a.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (a *AdapterContent) notifyWatchers(ctx context.Context) {
 	a.watchers.Notify(ctx)

os/gcfg/gcfg_adapter_file.go

@@ -32,11 +32,11 @@ var (
 
 // AdapterFile implements interface Adapter using file.
 type AdapterFile struct {
-	defaultFileNameOrPath *gtype.String    // Default configuration file name or file path.
-	searchPaths           *garray.StrArray // Searching the path array.
-	jsonMap               *gmap.StrAnyMap  // The pared JSON objects for configuration files.
-	violenceCheck         bool             // Whether it does violence check in value index searching. It affects the performance when set true(false in default).
-	watchers              *WatcherRegistry // Watchers for watching file changes.
+	defaultFileNameOrPath *gtype.String                    // Default configuration file name or file path.
+	searchPaths           *garray.StrArray                 // Searching the path array.
+	jsonMap               *gmap.KVMap[string, *gjson.Json] // The parsed JSON objects for configuration files.
+	violenceCheck         bool                             // Whether it does violence check in value index searching. It affects the performance when set true(false in default).
+	watchers              *WatcherRegistry                 // Watchers for watching file changes.
 }
 
 const (
@@ -58,6 +58,9 @@ var (
 
 	// Prefix array for trying searching in the local system.
 	localSystemTryFolders = []string{"", "config/", "manifest/config"}
+
+	// jsonMapChecker is the checker for JSON map.
+	jsonMapChecker = func(v *gjson.Json) bool { return v == nil }
 )
 
 // NewAdapterFile returns a new configuration management object.
@@ -78,7 +81,7 @@ func NewAdapterFile(fileNameOrPath ...string) (*AdapterFile, error) {
 	config := &AdapterFile{
 		defaultFileNameOrPath: gtype.NewString(usedFileNameOrPath),
 		searchPaths:           garray.NewStrArray(true),
-		jsonMap:               gmap.NewStrAnyMap(true),
+		jsonMap:               gmap.NewKVMapWithChecker[string, *gjson.Json](jsonMapChecker, true),
 		watchers:              NewWatcherRegistry(),
 	}
 	// Customized dir path from env/cmd.
@@ -257,7 +260,7 @@ func (a *AdapterFile) getJson(fileNameOrPath ...string) (configJson *gjson.Json,
 		usedFileNameOrPath = fileNameOrPath[0]
 	}
 	// It uses JSON map to cache specified configuration file content.
-	result := a.jsonMap.GetOrSetFuncLock(usedFileNameOrPath, func() any {
+	result := a.jsonMap.GetOrSetFuncLock(usedFileNameOrPath, func() *gjson.Json {
 		var (
 			content  string
 			filePath string
@@ -326,13 +329,13 @@ func (a *AdapterFile) getJson(fileNameOrPath ...string) (configJson *gjson.Json,
 		return configJson
 	})
 	if result != nil {
-		return result.(*gjson.Json), err
+		return result, err
 	}
 	return
 }
 
 // AddWatcher adds a watcher for the specified configuration file.
-func (a *AdapterFile) AddWatcher(name string, fn func(ctx context.Context)) {
+func (a *AdapterFile) AddWatcher(name string, fn WatcherFunc) {
 	a.watchers.Add(name, fn)
 }
 
@@ -346,6 +349,11 @@ func (a *AdapterFile) GetWatcherNames() []string {
 	return a.watchers.GetNames()
 }
 
+// IsWatching checks and returns whether the specified `name` is watching.
+func (a *AdapterFile) IsWatching(name string) bool {
+	return a.watchers.IsWatching(name)
+}
+
 // notifyWatchers notifies all watchers.
 func (a *AdapterFile) notifyWatchers(ctx context.Context) {
 	a.watchers.Notify(ctx)

os/gcfg/gcfg_loader.go

@@ -0,0 +1,253 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gcfg
+
+import (
+	"context"
+	"sync"
+
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/intlog"
+)
+
+// Loader is a generic configuration manager that provides
+// configuration loading, watching and management similar to Spring Boot's @ConfigurationProperties
+type Loader[T any] struct {
+	config         *Config                              // The configuration instance to watch
+	propertyKey    string                               // The property key pattern to watch
+	targetStruct   *T                                   // The target struct pointer to bind configuration to
+	mutex          sync.RWMutex                         // Mutex for thread-safe operations
+	onChange       func(T) error                        // Callback function when configuration changes
+	converter      func(data any, target *T) error      // Optional custom converter function
+	watchErrorFunc func(ctx context.Context, err error) // Optional error handling function for watch operations
+	reuse          bool                                 // reuse the same target struct, default is false to avoid data race
+	watcherName    string                               // watcher name
+}
+
+// NewLoader creates a new Loader instance
+// config: the configuration instance to watch for changes
+// propertyKey: the property key pattern to watch (use "" or "." to watch all configuration)
+// targetStruct: pointer to the struct that will receive the configuration values
+func NewLoader[T any](config *Config, propertyKey string, targetStruct ...*T) *Loader[T] {
+	if len(targetStruct) > 0 {
+		return &Loader[T]{
+			config:       config,
+			propertyKey:  propertyKey,
+			targetStruct: targetStruct[0],
+			reuse:        false,
+		}
+	}
+	return &Loader[T]{
+		config:       config,
+		propertyKey:  propertyKey,
+		targetStruct: new(T),
+		reuse:        false,
+	}
+}
+
+// NewLoaderWithAdapter creates a new Loader instance
+// adapter: the adapter instance to use for loading and watching configuration
+// propertyKey: the property key pattern to watch (use "" or "." to watch all configuration)
+// targetStruct: pointer to the struct that will receive the configuration values
+func NewLoaderWithAdapter[T any](adapter Adapter, propertyKey string, targetStruct ...*T) *Loader[T] {
+	return NewLoader(NewWithAdapter(adapter), propertyKey, targetStruct...)
+}
+
+// OnChange sets the callback function that will be called when configuration changes
+// The callback function receives the updated configuration struct and can return an error
+func (l *Loader[T]) OnChange(fn func(updated T) error) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.onChange = fn
+	return l
+}
+
+// Load loads configuration from the config instance and binds it to the target struct
+// The context is passed to the underlying configuration adapter
+func (l *Loader[T]) Load(ctx context.Context) error {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	// Get configuration data
+	var data *gvar.Var
+	if l.propertyKey == "" || l.propertyKey == "." {
+		// Get all configuration data
+		configData, err := l.config.Data(ctx)
+		if err != nil {
+			return err
+		}
+		data = gvar.New(configData)
+	} else {
+		// Get specific property
+		configValue, err := l.config.Get(ctx, l.propertyKey)
+		if err != nil {
+			return err
+		}
+		if configValue != nil {
+			data = configValue
+		} else {
+			data = gvar.New(nil)
+		}
+	}
+
+	// Use custom converter if provided, otherwise use default gconv.Scan
+	if l.converter != nil && data != nil {
+		if l.reuse {
+			if err := l.converter(data.Val(), l.targetStruct); err != nil {
+				return err
+			}
+		} else {
+			var newConfig T
+			if err := l.converter(data.Val(), &newConfig); err != nil {
+				return err
+			}
+			l.targetStruct = &newConfig
+		}
+	} else {
+		if data != nil {
+			if l.reuse {
+				if err := data.Scan(l.targetStruct); err != nil {
+					return err
+				}
+			} else {
+				var newConfig T
+				if err := data.Scan(&newConfig); err != nil {
+					return err
+				}
+				l.targetStruct = &newConfig
+			}
+		}
+	}
+
+	// Call change callback if exists
+	if l.onChange != nil {
+		return l.onChange(*l.targetStruct)
+	}
+
+	return nil
+}
+
+// MustLoad is like Load but panics if there is an error
+func (l *Loader[T]) MustLoad(ctx context.Context) {
+	if err := l.Load(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// Watch starts watching for configuration changes and automatically updates the target struct
+// name: the name of the watcher, which is used to identify this watcher
+// This method sets up a watcher that will call Load() when configuration changes are detected
+func (l *Loader[T]) Watch(ctx context.Context, name string) error {
+	if name == "" {
+		return gerror.New("Watcher name cannot be empty")
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		watcherAdapter.AddWatcher(name, func(ctx context.Context) {
+			// Reload configuration when change is detected
+			if err := l.Load(ctx); err != nil {
+				// Use the configured error handler if available, otherwise execute default logging
+				if l.watchErrorFunc != nil {
+					l.watchErrorFunc(ctx, err)
+				} else {
+					// Default logging using intlog (internal logging for development)
+					intlog.Errorf(ctx, "Configuration load failed in watcher %s: %v", name, err)
+				}
+			}
+		})
+		l.watcherName = name
+		return nil
+	}
+	return gerror.New("Watcher adapter not found")
+}
+
+// MustWatch is like Watch but panics if there is an error
+func (l *Loader[T]) MustWatch(ctx context.Context, name string) {
+	if err := l.Watch(ctx, name); err != nil {
+		panic(err)
+	}
+}
+
+// MustLoadAndWatch is a convenience method that calls MustLoad and MustWatch
+func (l *Loader[T]) MustLoadAndWatch(ctx context.Context, name string) {
+	l.MustLoad(ctx)
+	l.MustWatch(ctx, name)
+}
+
+// Get returns the current configuration struct
+// This method is thread-safe and returns a copy of the current configuration
+func (l *Loader[T]) Get() T {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	return *l.targetStruct
+}
+
+// GetPointer returns a pointer to the current configuration struct
+// This method is thread-safe and returns a pointer to the current configuration
+// The returned pointer is safe for read operations but should not be modified
+func (l *Loader[T]) GetPointer() *T {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	return l.targetStruct
+}
+
+// SetConverter sets a custom converter function that will be used during Load operations
+// The converter function receives the source data and the target struct pointer
+func (l *Loader[T]) SetConverter(converter func(data any, target *T) error) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.converter = converter
+	return l
+}
+
+// SetWatchErrorHandler sets an error handling function that will be called when Load operations fail during Watch
+func (l *Loader[T]) SetWatchErrorHandler(errorFunc func(ctx context.Context, err error)) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.watchErrorFunc = errorFunc
+	return l
+}
+
+// SetReuseTargetStruct sets whether to reuse the same target struct or create a new one on updates
+func (l *Loader[T]) SetReuseTargetStruct(reuse bool) *Loader[T] {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+	l.reuse = reuse
+	return l
+}
+
+// StopWatch stops watching for configuration changes and removes the associated watcher
+func (l *Loader[T]) StopWatch(ctx context.Context) (bool, error) {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.watcherName == "" {
+		return false, gerror.New("No watcher name specified")
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		watcherAdapter.RemoveWatcher(l.watcherName)
+		l.watcherName = ""
+		return true, nil
+	}
+	return false, gerror.New("Watcher adapter not found")
+}
+
+// IsWatching returns true if the loader is currently watching for configuration changes
+func (l *Loader[T]) IsWatching() bool {
+	l.mutex.RLock()
+	defer l.mutex.RUnlock()
+	if l.watcherName == "" {
+		return false
+	}
+	adapter := l.config.GetAdapter()
+	if watcherAdapter, ok := adapter.(WatcherAdapter); ok {
+		return watcherAdapter.IsWatching(l.watcherName)
+	}
+	return false
+}

os/gcfg/gcfg_watcher_registry.go

@@ -17,18 +17,23 @@ import (
 // It provides a unified implementation of watcher management to avoid code duplication
 // across different adapter implementations.
 type WatcherRegistry struct {
-	watchers *gmap.StrAnyMap // Watchers map storing watcher callbacks.
+	watchers *gmap.KVMap[string, WatcherFunc] // Watchers map storing watcher callbacks.
 }
 
 // NewWatcherRegistry creates and returns a new WatcherRegistry instance.
 func NewWatcherRegistry() *WatcherRegistry {
 	return &WatcherRegistry{
-		watchers: gmap.NewStrAnyMap(true),
+		watchers: gmap.NewKVMap[string, WatcherFunc](true),
 	}
 }
 
+// IsWatching checks whether the watcher with the specified name is registered.
+func (r *WatcherRegistry) IsWatching(name string) bool {
+	return r.watchers.Contains(name)
+}
+
 // Add adds a watcher with the specified name and callback function.
-func (r *WatcherRegistry) Add(name string, fn func(ctx context.Context)) {
+func (r *WatcherRegistry) Add(name string, fn WatcherFunc) {
 	r.watchers.Set(name, fn)
 }
 
@@ -46,17 +51,15 @@ func (r *WatcherRegistry) GetNames() []string {
 // Each callback is executed in a separate goroutine with panic recovery to prevent
 // one watcher's panic from affecting others.
 func (r *WatcherRegistry) Notify(ctx context.Context) {
-	r.watchers.Iterator(func(k string, v any) bool {
-		if fn, ok := v.(func(ctx context.Context)); ok {
-			go func(k string, fn func(ctx context.Context), ctx context.Context) {
-				defer func() {
-					if r := recover(); r != nil {
-						intlog.Errorf(ctx, "watcher %s panic: %v", k, r)
-					}
-				}()
-				fn(ctx)
-			}(k, fn, ctx)
-		}
+	r.watchers.Iterator(func(k string, fn WatcherFunc) bool {
+		go func(k string, fn WatcherFunc, ctx context.Context) {
+			defer func() {
+				if r := recover(); r != nil {
+					intlog.Errorf(ctx, "watcher %s panic: %v", k, r)
+				}
+			}()
+			fn(ctx)
+		}(k, fn, ctx)
 		return true
 	})
 }

os/gcfg/gcfg_z_unit_loader_test.go

@@ -0,0 +1,345 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gcfg_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/guid"
+)
+
+// TestConfig is a test struct for configuration binding
+type TestConfig struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features []string     `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+}
+
+// TestConfig2 is a test struct for configuration binding
+type TestConfig2 struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features string       `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+}
+
+// TestConfig3 is a test struct for configuration binding
+type TestConfig3 struct {
+	Name     string       `json:"name" yaml:"name"`
+	Age      int          `json:"age" yaml:"age"`
+	Enabled  bool         `json:"enabled" yaml:"enabled"`
+	Features []string     `json:"features" yaml:"features"`
+	Server   ServerConfig `json:"server" yaml:"server"`
+	Other    string       `json:"other" yaml:"other"`
+}
+
+type ServerConfig struct {
+	Host string `json:"host" yaml:"host"`
+	Port int    `json:"port" yaml:"port"`
+}
+
+var configContent = `
+name: "test-app"
+age: 25
+enabled: true
+features: ["feature1", "feature2", "feature3"]
+server:
+  host: "localhost"
+  port: 8080
+`
+
+func TestLoader_Load(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		t.Assert(v.Enabled, true)
+		t.Assert(v.Server.Host, "localhost")
+		t.Assert(v.Server.Port, 8080)
+		t.Assert(len(v.Features), 3)
+	})
+}
+
+func TestLoader_LoadWithDefaultValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create target struct
+		var targetConfig TestConfig3
+		targetConfig.Other = "other"
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter(cfg, "", &targetConfig)
+		loader.SetReuseTargetStruct(true)
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		t.Assert(v.Enabled, true)
+		t.Assert(v.Server.Host, "localhost")
+		t.Assert(v.Server.Port, 8080)
+		t.Assert(len(v.Features), 3)
+		t.Assert(v.Other, "other")
+	})
+}
+
+func TestLoader_LoadWithPropertyKey(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader with specific property key
+		loader := gcfg.NewLoaderWithAdapter[ServerConfig](cfg, "server")
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check loaded values - only the app section should be loaded
+		t.Assert(v.Host, "localhost")
+		t.Assert(v.Port, 8080)
+	})
+}
+
+func TestLoader_WatchAndOnChange(t *testing.T) {
+	var configContent2 = `
+name: test-app-2
+age: 200
+enabled: true
+features: ["feature1", "feature2", "feature3"]
+server:
+  host: localhost
+  port: 8080
+`
+
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Variable to track if callback was called
+		callbackCalled := gtype.NewBool(false)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Set change callback
+		loader.OnChange(func(updated TestConfig) error {
+			callbackCalled.Set(true)
+			return nil
+		})
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		err = loader.Watch(context.Background(), "test-watcher")
+		t.AssertNil(err)
+		v := loader.Get()
+		t.Assert(v.Name, "test-app")
+		t.Assert(v.Age, 25)
+		err = cfg.SetContent(configContent2)
+		t.AssertNil(err)
+		time.Sleep(2 * time.Second)
+		v2 := loader.Get()
+		t.Assert(v2.Name, "test-app-2")
+		t.Assert(v2.Age, 200)
+		t.Assert(callbackCalled.Val(), true)
+	})
+}
+
+func TestLoader_SetConverter(t *testing.T) {
+	var configContent2 = `
+name: test-app-2
+age: 200
+enabled: true
+features: ["feature", "feature", "feature"]
+server:
+  host: localhost
+  port: 8080
+`
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			configFile = "./" + guid.S() + ".yaml"
+			err        = gfile.PutContents(configFile, configContent2)
+		)
+		t.AssertNil(err)
+		defer gfile.RemoveFile(configFile)
+
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterFile(configFile)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig2](cfg, "features")
+
+		// Set custom converter
+		loader.SetConverter(func(data any, target *TestConfig2) error {
+			s := gconv.Strings(data)
+			target.Features = strings.Join(s, ",")
+			return nil
+		})
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+		v := loader.Get()
+
+		// Check converted values
+		t.Assert(v.Features, "feature,feature,feature")
+	})
+}
+
+func TestLoader_SetWatchErrorHandler(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance with content that will cause converter error
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Set error handler for watch operations
+		errorHandled := gtype.NewBool(false)
+		loader.SetWatchErrorHandler(func(ctx context.Context, err error) {
+			errorHandled.Set(true)
+		})
+
+		// Set a converter that will fail
+		loader.SetConverter(func(data any, target *TestConfig) error {
+			return errors.New("converter error")
+		})
+
+		// Load initially - this should return error without calling error handler
+		err = loader.Load(context.Background())
+		t.AssertNE(err, nil)
+		t.Assert(err.Error(), "converter error")
+		// Error handler should NOT be called during direct Load
+		t.Assert(errorHandled.Val(), false)
+
+		// Start watching - now errors during Load should trigger the error handler
+		err = loader.Watch(context.Background(), "test-error-handler")
+		t.AssertNil(err)
+		// Reset
+		errorHandled.Set(false)
+		// Trigger a config change - this will call Load internally and should trigger error handler
+		err = cfg.SetContent(configContent)
+		t.AssertNil(err)
+
+		// Wait for watcher to process the change
+		time.Sleep(1 * time.Second)
+
+		// Error handler should be called during Watch's Load
+		t.Assert(errorHandled.Val(), true)
+	})
+}
+
+func TestLoader_IsWatchingAndStopWatch(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Initially, should not be watching
+		t.Assert(loader.IsWatching(), false)
+
+		// Load configuration
+		err = loader.Load(context.Background())
+		t.AssertNil(err)
+
+		// Start watching
+		err = loader.Watch(context.Background(), "test-stopwatch-watcher")
+		t.AssertNil(err)
+
+		// Now should be watching
+		t.Assert(loader.IsWatching(), true)
+
+		// Stop watching
+		stopped, err := loader.StopWatch(context.Background())
+		t.AssertNil(err)
+		t.Assert(stopped, true)
+
+		// Should not be watching anymore
+		t.Assert(loader.IsWatching(), false)
+	})
+}
+
+func TestLoader_StopWatchWithoutWatcher(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Create a new config instance
+		cfg, err := gcfg.NewAdapterContent(configContent)
+		t.AssertNil(err)
+
+		// Create loader without starting to watch
+		loader := gcfg.NewLoaderWithAdapter[TestConfig](cfg, "")
+
+		// Initially, should not be watching
+		t.Assert(loader.IsWatching(), false)
+
+		// Try to stop watching when not watching
+		stopped, err := loader.StopWatch(context.Background())
+		t.AssertNE(err, nil)
+		t.Assert(stopped, false)
+		t.Assert(err.Error(), "No watcher name specified")
+	})
+}

util/gconv/gconv_scan.go

@@ -18,7 +18,7 @@ package gconv
 // TODO: change `paramKeyToAttrMap` to `ScanOption` to be more scalable; add `DeepCopy` option for `ScanOption`.
 func Scan(srcValue any, dstPointer any, paramKeyToAttrMap ...map[string]string) (err error) {
 	option := ScanOption{
-		ContinueOnError: true,
+		ContinueOnError: false,
 	}
 	if len(paramKeyToAttrMap) > 0 {
 		option.ParamKeyToAttrMap = paramKeyToAttrMap[0]

util/gconv/internal/converter/converter_convert.go

@@ -395,7 +395,11 @@ func (c *Converter) doConvertForDefault(in doConvertInput, option ConvertOption)
 		}
 
 		// custom converter.
-		dstReflectValue, ok, err := c.callCustomConverterWithRefer(fromReflectValue, referReflectValue)
+		var (
+			ok              bool
+			dstReflectValue reflect.Value
+		)
+		dstReflectValue, ok, err = c.callCustomConverterWithRefer(fromReflectValue, referReflectValue)
 		if err != nil {
 			return nil, err
 		}
@@ -415,7 +419,7 @@ func (c *Converter) doConvertForDefault(in doConvertInput, option ConvertOption)
 		switch referReflectValue.Kind() {
 		case reflect.Pointer:
 			// Type converting for custom type pointers.
-			// Eg:
+			// Example:
 			// type PayMode int
 			// type Req struct{
 			//     Mode *PayMode

util/gconv/internal/converter/converter_float.go

@@ -45,7 +45,11 @@ func (c *Converter) Float32(anyInput any) (float32, error) {
 			}
 			return 0, nil
 		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 32)
+			s := rv.String()
+			if s == "" {
+				return 0, nil
+			}
+			f, err := strconv.ParseFloat(s, 32)
 			if err != nil {
 				return 0, gerror.WrapCodef(
 					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", anyInput,
@@ -68,6 +72,9 @@ func (c *Converter) Float32(anyInput any) (float32, error) {
 			if err != nil {
 				return 0, err
 			}
+			if s == "" {
+				return 0, nil
+			}
 			v, err := strconv.ParseFloat(s, 32)
 			if err != nil {
 				return 0, gerror.WrapCodef(
@@ -112,7 +119,11 @@ func (c *Converter) Float64(anyInput any) (float64, error) {
 			}
 			return 0, nil
 		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 64)
+			s := rv.String()
+			if s == "" {
+				return 0, nil
+			}
+			f, err := strconv.ParseFloat(s, 64)
 			if err != nil {
 				return 0, gerror.WrapCodef(
 					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", anyInput,
@@ -135,6 +146,9 @@ func (c *Converter) Float64(anyInput any) (float64, error) {
 			if err != nil {
 				return 0, err
 			}
+			if s == "" {
+				return 0, nil
+			}
 			v, err := strconv.ParseFloat(s, 64)
 			if err != nil {
 				return 0, gerror.WrapCodef(

util/gconv/internal/converter/converter_map.go

@@ -88,6 +88,9 @@ func (c *Converter) doMapConvert(
 	value any, recursive RecursiveType, mustMapReturn bool, option MapOption,
 ) (map[string]any, error) {
 	if value == nil {
+		if mustMapReturn {
+			return map[string]any{}, nil
+		}
 		return nil, nil
 	}
 	// It redirects to its underlying value if it has implemented interface iVal.
@@ -119,6 +122,10 @@ func (c *Converter) doMapConvert(
 				return nil, err
 			}
 		} else {
+			if len(r) == 0 && mustMapReturn {
+				return map[string]any{}, nil
+			}
+			// if r is not empty, which means it fails converting to map.
 			return nil, nil
 		}
 	case []byte:
@@ -128,6 +135,10 @@ func (c *Converter) doMapConvert(
 				return nil, err
 			}
 		} else {
+			if len(r) == 0 && mustMapReturn {
+				return map[string]any{}, nil
+			}
+			// if r is not empty, which means it fails converting to map.
 			return nil, nil
 		}
 	case map[any]any:
@@ -328,6 +339,7 @@ func (c *Converter) doMapConvert(
 				return m, nil
 			}
 			return nil, nil
+
 		default:
 			return nil, nil
 		}

util/gconv/internal/converter/converter_struct.go

@@ -169,10 +169,11 @@ func (c *Converter) Struct(params, pointer any, option ...StructOption) (err err
 			return err
 		}
 		if paramsMap == nil {
+			// fails converting params to map, so it cannot be converted to struct pointer.
 			return gerror.NewCodef(
 				gcode.CodeInvalidParameter,
-				`convert params from "%#v" to "map[string]any" failed`,
-				params,
+				`convert params "%v" to "%s" failed`,
+				params, pointerReflectValue.Type(),
 			)
 		}
 	}
@@ -521,8 +522,7 @@ func (c *Converter) bindVarToReflectValue(structFieldValue reflect.Value, value
 	case reflect.Struct:
 		// Recursively converting for struct attribute.
 		if err = c.Struct(value, structFieldValue, option); err != nil {
-			// Note there's reflect conversion mechanism here.
-			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
+			return err
 		}
 
 	// Note that the slice element might be type of struct,
@@ -653,6 +653,8 @@ func (c *Converter) bindVarToReflectValue(structFieldValue reflect.Value, value
 			elem := item.Elem()
 			if err = c.bindVarToReflectValue(elem, value, option); err == nil {
 				structFieldValue.Set(elem.Addr())
+			} else {
+				return err
 			}
 		} else {
 			// Not empty pointer, it assigns values to it.