goscript 0.0.39 → 0.0.41

package/gs/path/filepath/path.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest'
+import {
+  Base,
+  Dir,
+  Ext,
+  Clean,
+  Join,
+  Split,
+  IsAbs,
+  ToSlash,
+  FromSlash,
+  VolumeName,
+  IsLocal,
+  SplitList,
+  HasPrefix,
+  Abs,
+  Rel,
+  EvalSymlinks,
+  Separator,
+  ListSeparator,
+} from './path.js'
+
+describe('path/filepath - Path manipulation functions', () => {
+  describe('Base', () => {
+    it('should return the last element of path', () => {
+      expect(Base('dir/subdir/file.txt')).toBe('file.txt')
+      expect(Base('/usr/bin/ls')).toBe('ls')
+      expect(Base('file.txt')).toBe('file.txt')
+      expect(Base('/')).toBe('/')
+      expect(Base('')).toBe('.')
+      expect(Base('//')).toBe('/')
+      expect(Base('dir/')).toBe('dir')
+      expect(Base('dir//')).toBe('dir')
+    })
+  })
+
+  describe('Dir', () => {
+    it('should return directory portion of path', () => {
+      expect(Dir('dir/subdir/file.txt')).toBe('dir/subdir')
+      expect(Dir('/usr/bin/ls')).toBe('/usr/bin')
+      expect(Dir('file.txt')).toBe('.')
+      expect(Dir('/')).toBe('/')
+      expect(Dir('')).toBe('.')
+      expect(Dir('/file')).toBe('/')
+      expect(Dir('dir/')).toBe('.')
+    })
+  })
+
+  describe('Ext', () => {
+    it('should return file extension', () => {
+      expect(Ext('file.txt')).toBe('.txt')
+      expect(Ext('file.tar.gz')).toBe('.gz')
+      expect(Ext('file')).toBe('')
+      expect(Ext('.hidden')).toBe('')
+      expect(Ext('dir/file.txt')).toBe('.txt')
+      expect(Ext('')).toBe('')
+    })
+  })
+
+  describe('Clean', () => {
+    it('should clean up path by resolving . and .. elements', () => {
+      expect(Clean('dir//subdir/../subdir/./file.txt')).toBe(
+        'dir/subdir/file.txt',
+      )
+      expect(Clean('/dir/../file')).toBe('/file')
+      expect(Clean('./file')).toBe('file')
+      expect(Clean('../file')).toBe('../file')
+      expect(Clean('dir/..')).toBe('.')
+      expect(Clean('/dir/..')).toBe('/')
+      expect(Clean('')).toBe('.')
+      expect(Clean('/')).toBe('/')
+      expect(Clean('///')).toBe('/')
+    })
+  })
+
+  describe('Join', () => {
+    it('should join path elements with separator', () => {
+      expect(Join('dir', 'subdir', 'file.txt')).toBe('dir/subdir/file.txt')
+      expect(Join('/usr', 'bin', 'ls')).toBe('/usr/bin/ls')
+      expect(Join('', 'file')).toBe('file')
+      expect(Join('dir', '', 'file')).toBe('dir/file')
+      expect(Join()).toBe('')
+      expect(Join('', '', '')).toBe('')
+    })
+  })
+
+  describe('Split', () => {
+    it('should split path into directory and file', () => {
+      expect(Split('dir/subdir/file.txt')).toEqual(['dir/subdir/', 'file.txt'])
+      expect(Split('/usr/bin/ls')).toEqual(['/usr/bin/', 'ls'])
+      expect(Split('file.txt')).toEqual(['', 'file.txt'])
+      expect(Split('/')).toEqual(['/', ''])
+      expect(Split('')).toEqual(['', ''])
+    })
+  })
+
+  describe('IsAbs', () => {
+    it('should check if path is absolute', () => {
+      expect(IsAbs('/absolute/path')).toBe(true)
+      expect(IsAbs('relative/path')).toBe(false)
+      expect(IsAbs('/')).toBe(true)
+      expect(IsAbs('')).toBe(false)
+      expect(IsAbs('./relative')).toBe(false)
+    })
+  })
+
+  describe('ToSlash', () => {
+    it('should preserve path on Unix systems (backslashes are regular chars)', () => {
+      // On Unix systems, ToSlash doesn't convert backslashes because they're not separators
+      expect(ToSlash('dir\\subdir\\file.txt')).toBe('dir\\subdir\\file.txt')
+      expect(ToSlash('dir/subdir/file.txt')).toBe('dir/subdir/file.txt')
+      expect(ToSlash('')).toBe('')
+    })
+  })
+
+  describe('FromSlash', () => {
+    it('should preserve path on Unix systems', () => {
+      // On Unix systems, FromSlash doesn't change anything because separator is already '/'
+      expect(FromSlash('dir/subdir/file.txt')).toBe('dir/subdir/file.txt')
+      expect(FromSlash('')).toBe('')
+    })
+  })
+
+  describe('VolumeName', () => {
+    it('should return empty string on Unix systems', () => {
+      expect(VolumeName('C:\\Windows\\System32')).toBe('')
+      expect(VolumeName('/usr/local')).toBe('')
+      expect(VolumeName('')).toBe('')
+    })
+  })
+
+  describe('IsLocal', () => {
+    it('should check if path is local (not escaping)', () => {
+      expect(IsLocal('file.txt')).toBe(true)
+      expect(IsLocal('dir/file.txt')).toBe(true)
+      expect(IsLocal('../file.txt')).toBe(false)
+      expect(IsLocal('/absolute/path')).toBe(false)
+      expect(IsLocal('')).toBe(false)
+      expect(IsLocal('dir/../file')).toBe(true)
+      expect(IsLocal('dir/../../file')).toBe(false)
+    })
+  })
+
+  describe('SplitList', () => {
+    it('should split PATH-style lists', () => {
+      expect(SplitList('/usr/bin:/usr/local/bin:/bin')).toEqual([
+        '/usr/bin',
+        '/usr/local/bin',
+        '/bin',
+      ])
+      expect(SplitList('')).toEqual([])
+      expect(SplitList('/single/path')).toEqual(['/single/path'])
+      expect(SplitList('a:b:c')).toEqual(['a', 'b', 'c'])
+    })
+  })
+
+  describe('HasPrefix', () => {
+    it('should check if path has prefix', () => {
+      expect(HasPrefix('/usr/local/bin', '/usr/local')).toBe(true)
+      expect(HasPrefix('/usr/local', '/usr/local')).toBe(true)
+      expect(HasPrefix('/usr/local/bin', '/usr/bin')).toBe(false)
+      expect(HasPrefix('relative/path', 'relative')).toBe(true)
+      expect(HasPrefix('file.txt', '')).toBe(true)
+      expect(HasPrefix('', 'prefix')).toBe(false)
+    })
+  })
+
+  describe('Abs', () => {
+    it('should handle absolute paths', () => {
+      const [result1, err1] = Abs('/absolute/path')
+      expect(err1).toBeNull()
+      expect(result1).toBe('/absolute/path')
+
+      const [result2, err2] = Abs('relative/path')
+      expect(err2).toBeNull()
+      expect(result2).toBe('/relative/path')
+    })
+  })
+
+  describe('Rel', () => {
+    it('should calculate relative path', () => {
+      const [result1, err1] = Rel('/usr/local', '/usr/local')
+      expect(err1).toBeNull()
+      expect(result1).toBe('.')
+
+      const [result2, err2] = Rel('/usr/local', '/usr/local/bin')
+      expect(err2).toBeNull()
+      expect(result2).toBe('bin')
+
+      const [result3, err3] = Rel('/usr/local', '/other/path')
+      expect(err3).toBeNull()
+      expect(result3).toBe('/other/path')
+    })
+  })
+
+  describe('EvalSymlinks', () => {
+    it('should return cleaned path (stubbed)', () => {
+      const [result, err] = EvalSymlinks('/path/with/../dots')
+      expect(err).toBeNull()
+      expect(result).toBe('/path/dots')
+    })
+  })
+
+  describe('Constants', () => {
+    it('should have correct separator constants', () => {
+      expect(Separator).toBe('/')
+      expect(ListSeparator).toBe(':')
+    })
+  })
+})
+
+describe('Complex path operations', () => {
+  it('should handle edge cases correctly', () => {
+    // Test Clean with complex paths
+    expect(Clean('/a/b/../c/./d/')).toBe('/a/c/d')
+    expect(Clean('a/b/../../c')).toBe('c')
+    expect(Clean('../../a/b')).toBe('../../a/b')
+
+    // Test Join with various inputs
+    expect(Join('/a', '../b', 'c')).toBe('/b/c')
+    expect(Join('a', '/b', 'c')).toBe('/b/c')
+
+    // Test Split edge cases
+    expect(Split('/a/')).toEqual(['/a/', ''])
+    expect(Split('//a')).toEqual(['//', 'a'])
+  })
+
+  it('should maintain path consistency', () => {
+    const testPaths = [
+      'simple/path',
+      '/absolute/path',
+      'path/with/../dots',
+      './relative/path',
+      '../../parent/path',
+    ]
+
+    for (const path of testPaths) {
+      const cleaned = Clean(path)
+      const [dir, file] = Split(cleaned)
+      const rejoined = dir + file
+
+      // Split and rejoin should preserve the cleaned path
+      expect(rejoined).toBe(cleaned)
+    }
+  })
+})

package/gs/path/filepath/path.ts

@@ -0,0 +1,329 @@
+// Package filepath implements utility routines for manipulating filename paths
+// in a way compatible with the target operating system-defined file paths.
+import * as $ from "@goscript/builtin/index.js"
+
+// Path separator constants
+export const Separator = '/'
+export const ListSeparator = ':'
+
+// Error constants
+export const SkipDir = $.newError('skip this directory')
+export const SkipAll = $.newError('skip everything and stop the walk')
+
+// Base returns the last element of path.
+// Trailing path separators are removed before extracting the last element.
+// If the path is empty, Base returns ".".
+// If the path consists entirely of separators, Base returns a single separator.
+export function Base(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  // Strip trailing slashes
+  path = path.replace(/\/+$/, '')
+
+  if (path === '') {
+    return '/'
+  }
+
+  // Find the last slash
+  const i = path.lastIndexOf('/')
+  if (i >= 0) {
+    return path.substring(i + 1)
+  }
+
+  return path
+}
+
+// Dir returns all but the last element of path, typically the path's directory.
+// After dropping the final element, Dir calls Clean on the path and trailing
+// slashes are removed. If the path is empty, Dir returns ".".
+// If the path consists entirely of separators, Dir returns a single separator.
+export function Dir(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  // Strip trailing slashes
+  path = path.replace(/\/+$/, '')
+
+  if (path === '') {
+    return '/'
+  }
+
+  // Find the last slash
+  const i = path.lastIndexOf('/')
+  if (i >= 0) {
+    const dir = path.substring(0, i)
+    return Clean(dir === '' ? '/' : dir)
+  }
+
+  return '.'
+}
+
+// Ext returns the file name extension used by path.
+// The extension is the suffix beginning at the final dot
+// in the final element of path; it is empty if there is no dot.
+export function Ext(path: string): string {
+  const base = Base(path)
+
+  // Handle special case: if the base starts with a dot and has no other dots,
+  // it's a hidden file with no extension
+  if (base.startsWith('.') && base.indexOf('.', 1) === -1) {
+    return ''
+  }
+
+  const i = base.lastIndexOf('.')
+  if (i >= 0) {
+    return base.substring(i)
+  }
+  return ''
+}
+
+// Clean returns the shortest path name equivalent to path
+// by purely lexical processing.
+export function Clean(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  const isAbs = path.startsWith('/')
+  const segments = path
+    .split('/')
+    .filter((segment) => segment !== '' && segment !== '.')
+  const result: string[] = []
+
+  for (const segment of segments) {
+    if (segment === '..') {
+      if (result.length > 0 && result[result.length - 1] !== '..') {
+        result.pop()
+      } else if (!isAbs) {
+        result.push('..')
+      }
+    } else {
+      result.push(segment)
+    }
+  }
+
+  let cleaned = result.join('/')
+  if (isAbs) {
+    cleaned = '/' + cleaned
+  }
+
+  return (
+    cleaned === '' ?
+      isAbs ? '/'
+      : '.'
+    : cleaned
+  )
+}
+
+// Join joins any number of path elements into a single path,
+// separating them with an OS specific Separator. Empty elements
+// are ignored. The result is Cleaned. However, if the argument
+// list is empty or all its elements are empty, Join returns
+// an empty string.
+export function Join(...elem: string[]): string {
+  if (elem.length === 0) {
+    return ''
+  }
+
+  // Filter out empty elements but handle absolute paths
+  const parts: string[] = []
+
+  for (const e of elem) {
+    if (e === '') {
+      continue
+    }
+
+    // If this element is absolute, start over from here
+    if (IsAbs(e)) {
+      parts.length = 0 // Clear previous parts
+      parts.push(e)
+    } else {
+      parts.push(e)
+    }
+  }
+
+  if (parts.length === 0) {
+    return ''
+  }
+
+  return Clean(parts.join('/'))
+}
+
+// Split splits path immediately following the final Separator,
+// separating it into a directory and file name component.
+// If there is no Separator in path, Split returns an empty dir
+// and file set to path. The returned values have the property
+// that path = dir+file.
+export function Split(path: string): [string, string] {
+  const i = path.lastIndexOf('/')
+  if (i < 0) {
+    return ['', path]
+  }
+  return [path.substring(0, i + 1), path.substring(i + 1)]
+}
+
+// IsAbs reports whether the path is absolute.
+export function IsAbs(path: string): boolean {
+  return path.startsWith('/')
+}
+
+// ToSlash returns the result of replacing each separator character
+// in path with a slash ('/') character. Multiple separators are
+// replaced by multiple slashes.
+export function ToSlash(path: string): string {
+  // On Unix-like systems (including our JS environment), the separator is already '/'
+  // so backslashes are just regular characters and should not be converted
+  // This matches Go's behavior on Unix systems
+  return path
+}
+
+// FromSlash returns the result of replacing each slash ('/') character
+// in path with a separator character. Multiple slashes are replaced
+// by multiple separators.
+export function FromSlash(path: string): string {
+  // On Unix-like systems (including our JS environment), separator is '/'
+  // so no conversion needed
+  return path
+}
+
+// VolumeName returns leading volume name.
+// Given "C:\foo\bar" it returns "C:" on Windows.
+// Given "\\host\share\foo" it returns "\\host\share".
+// On other systems, it returns "".
+export function VolumeName(_path: string): string {
+  // In our JS environment, we don't have volume names
+  return ''
+}
+
+// IsLocal reports whether path, using lexical analysis only,
+// has all of these properties:
+//   - is within the subtree rooted at the directory in which path is evaluated
+//   - is not an absolute path
+//   - is not empty
+//   - on Windows, is not a reserved name such as "NUL"
+export function IsLocal(path: string): boolean {
+  if (path === '' || IsAbs(path)) {
+    return false
+  }
+
+  // Check for .. components that would escape
+  const segments = path.split('/')
+  let depth = 0
+
+  for (const segment of segments) {
+    if (segment === '..') {
+      depth--
+      if (depth < 0) {
+        return false
+      }
+    } else if (segment !== '.' && segment !== '') {
+      depth++
+    }
+  }
+
+  return true
+}
+
+// SplitList splits a list of paths joined by the OS-specific ListSeparator,
+// usually found in PATH or GOPATH environment variables.
+// Unlike strings.Split, SplitList returns an empty slice when passed an empty string.
+export function SplitList(path: string): string[] {
+  if (path === '') {
+    return []
+  }
+  return path.split(ListSeparator)
+}
+
+// HasPrefix tests whether the path p begins with prefix.
+export function HasPrefix(p: string, prefix: string): boolean {
+  if (prefix === '') {
+    return true
+  }
+
+  // Normalize both paths
+  const normalP = Clean(p)
+  const normalPrefix = Clean(prefix)
+
+  if (normalP === normalPrefix) {
+    return true
+  }
+
+  // Check if p starts with prefix followed by a separator
+  if (normalP.startsWith(normalPrefix)) {
+    const remaining = normalP.substring(normalPrefix.length)
+    return remaining.startsWith('/')
+  }
+
+  return false
+}
+
+// Stubs for functions that require filesystem operations
+// These are simplified implementations for compatibility
+
+export function Abs(path: string): [string, $.GoError] {
+  if (IsAbs(path)) {
+    return [Clean(path), null]
+  }
+  // In a real implementation, this would resolve relative to current working directory
+  // For our purposes, we'll just prepend a fake absolute path
+  return ['/' + Clean(path), null]
+}
+
+export function Rel(
+  basepath: string,
+  targpath: string,
+): [string, $.GoError] {
+  // Simplified implementation - in reality this is much more complex
+  const base = Clean(basepath)
+  const targ = Clean(targpath)
+
+  if (base === targ) {
+    return ['.', null]
+  }
+
+  // Very basic relative path calculation
+  if (targ.startsWith(base + '/')) {
+    return [targ.substring(base.length + 1), null]
+  }
+
+  return [targ, null]
+}
+
+export function EvalSymlinks(path: string): [string, $.GoError] {
+  // No filesystem support, just return the cleaned path
+  return [Clean(path), null]
+}
+
+export function Glob(_pattern: string): [string[], $.GoError] {
+  // No filesystem support, return empty array
+  return [[], null]
+}
+
+// WalkFunc is the type of the function called for each file or directory
+// visited by Walk. The path argument contains the argument to Walk as a
+// prefix; that is, if Walk is called with "dir" and finds a file "a"
+// in that directory, the walk function will be called with argument
+// "dir/a". The info argument is the fs.FileInfo for the named path.
+export type WalkFunc = (
+  path: string,
+  info: any,
+  err: $.GoError,
+) => $.GoError
+
+export function Walk(root: string, walkFn: WalkFunc): $.GoError {
+  // No filesystem support, just call the function with the root
+  return walkFn(root, null, $.newError('filesystem not supported'))
+}
+
+export function WalkDir(_root: string, _walkFn: any): $.GoError {
+  // No filesystem support
+  return $.newError('filesystem not supported')
+}
+
+// Localize is a stub - in Go it's used for Windows path localization
+export function Localize(path: string): [string, $.GoError] {
+  return [path, null]
+}

package/gs/path/match.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 import * as errors from '@goscript/errors/index.js'
 

package/gs/path/metadata.go

@@ -0,0 +1,8 @@
+package path
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"errors",
+	"unicode/utf8",
+}

package/gs/path/path.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 class lazybuf {
   public get s(): string {

package/gs/reflect/metadata.go

@@ -0,0 +1,7 @@
+package reflect
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"iter",
+}

package/gs/reflect/value.ts

@@ -26,7 +26,7 @@ import {
   Invalid,
 } from './type.js'
 import { ReflectValue, SelectCase, SelectRecv, SelectDefault } from './types.js'
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 interface ChannelObject {
   _sendQueue?: unknown[]
@@ -210,11 +210,19 @@ export function MakeChan(typ: Type, buffer: number): Value {
 export function Select(cases: $.Slice<SelectCase>): [number, Value, boolean] {
   // Extract the backing array from the GoScript slice
   let selectCases: SelectCase[] = []
-  if (cases && typeof cases === 'object' && '__meta__' in cases) {
-    // This is a GoScript slice, extract the backing array
-    const meta = (cases as { __meta__?: { backing?: SelectCase[] } }).__meta__
-    if (meta && meta.backing) {
-      selectCases = meta.backing
+  
+  if (cases && typeof cases === 'object') {
+    if ('__meta__' in cases) {
+      // This is a GoScript SliceProxy, extract the backing array
+      const meta = (cases as { __meta__?: { backing?: SelectCase[], offset?: number, length?: number } }).__meta__
+      if (meta && meta.backing) {
+        const offset = meta.offset ?? 0
+        const length = meta.length ?? meta.backing.length
+        selectCases = meta.backing.slice(offset, offset + length)
+      }
+    } else if (globalThis.Array.isArray(cases)) {
+      // This is a plain array (optimized case where offset=0 and length=capacity)
+      selectCases = cases as SelectCase[]
     }
   }
 

package/gs/reflect/visiblefields.ts

@@ -1,4 +1,4 @@
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 import { Type, Ptr, Struct } from './type.js'
 import { StructField } from './types.js'
 

package/gs/slices/slices.ts

@@ -1,5 +1,5 @@
 // TypeScript implementation of Go's slices package
-import * as $ from '@goscript/builtin/builtin.js'
+import * as $ from '@goscript/builtin/index.js'
 
 /**
  * All returns an iterator over index-value pairs in the slice.

package/gs/sort/godoc.txt

@@ -0,0 +1,27 @@
+package sort // import "sort"
+
+Package sort provides primitives for sorting slices and user-defined
+collections.
+
+func Find(n int, cmp func(int) int) (i int, found bool)
+func Float64s(x []float64)
+func Float64sAreSorted(x []float64) bool
+func Ints(x []int)
+func IntsAreSorted(x []int) bool
+func IsSorted(data Interface) bool
+func Search(n int, f func(int) bool) int
+func SearchFloat64s(a []float64, x float64) int
+func SearchInts(a []int, x int) int
+func SearchStrings(a []string, x string) int
+func Slice(x any, less func(i, j int) bool)
+func SliceIsSorted(x any, less func(i, j int) bool) bool
+func SliceStable(x any, less func(i, j int) bool)
+func Sort(data Interface)
+func Stable(data Interface)
+func Strings(x []string)
+func StringsAreSorted(x []string) bool
+type Float64Slice []float64
+type IntSlice []int
+type Interface interface{ ... }
+    func Reverse(data Interface) Interface
+type StringSlice []string