goscript 0.0.25 → 0.0.28

package/gs/strings/builder.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest'
+import * as $ from '@goscript/builtin/builtin.js'
+import { Builder } from './builder.js'
+
+describe('strings/Builder', () => {
+  describe('Builder', () => {
+    it('should create empty builder', () => {
+      const b = new Builder()
+      expect(b.String()).toBe('')
+      expect(b.Len()).toBe(0)
+      expect(b.Cap()).toBe(0)
+    })
+
+    it('should write string', () => {
+      const b = new Builder()
+      const [n, err] = b.WriteString('hello')
+      expect(n).toBe(5)
+      expect(err).toBeNull()
+      expect(b.String()).toBe('hello')
+      expect(b.Len()).toBe(5)
+    })
+
+    it('should write bytes', () => {
+      const b = new Builder()
+      const bytes = new TextEncoder().encode('world')
+      const [n, err] = b.Write(bytes)
+      expect(n).toBe(bytes.length)
+      expect(err).toBeNull()
+      expect(b.String()).toBe('world')
+    })
+
+    it('should write byte', () => {
+      const b = new Builder()
+      const err = b.WriteByte(65) // 'A'
+      expect(err).toBeNull()
+      expect(b.String()).toBe('A')
+      expect(b.Len()).toBe(1)
+    })
+
+    it('should write rune', () => {
+      const b = new Builder()
+      const [n, err] = b.WriteRune(0x1f44d) // 👍
+      expect(err).toBeNull()
+      expect(n).toBeGreaterThan(0)
+      expect(b.String()).toBe('👍')
+    })
+
+    it('should grow capacity', () => {
+      const b = new Builder()
+      b.Grow(100)
+      // Should not throw - capacity is grown
+      expect(b.Cap()).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should throw on negative grow', () => {
+      const b = new Builder()
+      expect(() => b.Grow(-1)).toThrow()
+    })
+
+    it('should reset builder', () => {
+      const b = new Builder()
+      b.WriteString('hello')
+      expect(b.Len()).toBe(5)
+
+      b.Reset()
+      expect(b.String()).toBe('')
+      expect(b.Len()).toBe(0)
+    })
+
+    it('should clone builder', () => {
+      const b = new Builder()
+      b.WriteString('hello')
+
+      const cloned = b.clone()
+      expect(cloned.String()).toBe('hello')
+      expect(cloned.Len()).toBe(5)
+
+      // Modify original
+      b.WriteString(' world')
+      expect(b.String()).toBe('hello world')
+      expect(cloned.String()).toBe('hello') // Should not change
+    })
+
+    it('should handle multiple writes', () => {
+      const b = new Builder()
+      b.WriteString('hello')
+      b.WriteString(' ')
+      b.WriteString('world')
+      expect(b.String()).toBe('hello world')
+      expect(b.Len()).toBe(11)
+    })
+
+    it('should handle empty writes', () => {
+      const b = new Builder()
+      const [n, err] = b.WriteString('')
+      expect(n).toBe(0)
+      expect(err).toBeNull()
+      expect(b.String()).toBe('')
+    })
+
+    it('should handle unicode correctly', () => {
+      const b = new Builder()
+      b.WriteString('Hello 世界')
+      expect(b.String()).toBe('Hello 世界')
+
+      // Write individual runes
+      const b2 = new Builder()
+      b2.WriteRune(0x4e16) // 世
+      b2.WriteRune(0x754c) // 界
+      expect(b2.String()).toBe('世界')
+    })
+
+    it('should maintain proper length with unicode', () => {
+      const b = new Builder()
+      const text = 'Hello 🌟'
+      b.WriteString(text)
+      expect(b.String()).toBe(text)
+      expect(b.Len()).toBe(text.length)
+    })
+  })
+})

package/gs/strings/builder.ts

@@ -0,0 +1,223 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+export class Builder {
+  private _content: string = ''
+  private _addr: Builder | null = null
+
+  constructor(init?: Partial<{}>) {
+    // Simple constructor - no complex initialization needed
+  }
+
+  public clone(): Builder {
+    const cloned = new Builder()
+    cloned._content = this._content
+    cloned._addr = this._addr
+    return cloned
+  }
+
+  private copyCheck(): void {
+    if (this._addr == null) {
+      this._addr = this
+    } else if (this._addr !== this) {
+      $.panic('strings: illegal use of non-zero Builder copied by value')
+    }
+  }
+
+  // String returns the accumulated string.
+  public String(): string {
+    return this._content
+  }
+
+  // Len returns the number of accumulated bytes; b.Len() == len(b.String()).
+  public Len(): number {
+    return this._content.length
+  }
+
+  // Cap returns the capacity of the builder's underlying byte slice. It is the
+  // total space allocated for the string being built and includes any bytes
+  // already written.
+  public Cap(): number {
+    // For simplicity, return the current length since JavaScript strings are dynamic
+    return this._content.length
+  }
+
+  // Reset resets the Builder to be empty.
+  public Reset(): void {
+    this._addr = null
+    this._content = ''
+  }
+
+  // Grow grows b's capacity, if necessary, to guarantee space for
+  // another n bytes. After Grow(n), at least n bytes can be written to b
+  // without another allocation. If n is negative, Grow panics.
+  public Grow(n: number): void {
+    this.copyCheck()
+    if (n < 0) {
+      $.panic('strings.Builder.Grow: negative count')
+    }
+    // JavaScript strings are dynamic, so no need to pre-allocate
+  }
+
+  // Write appends the contents of p to b's buffer.
+  // Write always returns len(p), nil.
+  public Write(p: Uint8Array): [number, $.GoError] {
+    this.copyCheck()
+    // Convert byte array to string
+    const str = new TextDecoder('utf-8').decode(p)
+    this._content += str
+    return [p.length, null]
+  }
+
+  // WriteByte appends the byte c to b's buffer.
+  // The returned error is always nil.
+  public WriteByte(c: number): $.GoError {
+    this.copyCheck()
+    this._content += String.fromCharCode(c)
+    return null
+  }
+
+  // WriteRune appends the UTF-8 encoding of Unicode code point r to b's buffer.
+  // It returns the length of r and a nil error.
+  public WriteRune(r: number): [number, $.GoError] {
+    this.copyCheck()
+    const str = String.fromCodePoint(r)
+    this._content += str
+    // Return the byte length of the UTF-8 encoding
+    const byteLength = new TextEncoder().encode(str).length
+    return [byteLength, null]
+  }
+
+  // WriteString appends the contents of s to b's buffer.
+  // It returns the length of s and a nil error.
+  public WriteString(s: string): [number, $.GoError] {
+    this.copyCheck()
+    this._content += s
+    return [s.length, null]
+  }
+
+  // Register this type with the runtime type system
+  static __typeInfo = $.registerStructType(
+    'Builder',
+    new Builder(),
+    [
+      {
+        name: 'String',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+      },
+      {
+        name: 'Len',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'number' } }],
+      },
+      {
+        name: 'Cap',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'number' } }],
+      },
+      { name: 'Reset', args: [], returns: [] },
+      {
+        name: 'Grow',
+        args: [{ name: 'n', type: { kind: $.TypeKind.Basic, name: 'number' } }],
+        returns: [],
+      },
+      {
+        name: 'Write',
+        args: [
+          {
+            name: 'p',
+            type: {
+              kind: $.TypeKind.Slice,
+              elemType: { kind: $.TypeKind.Basic, name: 'number' },
+            },
+          },
+        ],
+        returns: [
+          { type: { kind: $.TypeKind.Basic, name: 'number' } },
+          {
+            type: {
+              kind: $.TypeKind.Interface,
+              name: 'GoError',
+              methods: [
+                {
+                  name: 'Error',
+                  args: [],
+                  returns: [
+                    { type: { kind: $.TypeKind.Basic, name: 'string' } },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        name: 'WriteByte',
+        args: [{ name: 'c', type: { kind: $.TypeKind.Basic, name: 'number' } }],
+        returns: [
+          {
+            type: {
+              kind: $.TypeKind.Interface,
+              name: 'GoError',
+              methods: [
+                {
+                  name: 'Error',
+                  args: [],
+                  returns: [
+                    { type: { kind: $.TypeKind.Basic, name: 'string' } },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        name: 'WriteRune',
+        args: [{ name: 'r', type: { kind: $.TypeKind.Basic, name: 'number' } }],
+        returns: [
+          { type: { kind: $.TypeKind.Basic, name: 'number' } },
+          {
+            type: {
+              kind: $.TypeKind.Interface,
+              name: 'GoError',
+              methods: [
+                {
+                  name: 'Error',
+                  args: [],
+                  returns: [
+                    { type: { kind: $.TypeKind.Basic, name: 'string' } },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+      {
+        name: 'WriteString',
+        args: [{ name: 's', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+        returns: [
+          { type: { kind: $.TypeKind.Basic, name: 'number' } },
+          {
+            type: {
+              kind: $.TypeKind.Interface,
+              name: 'GoError',
+              methods: [
+                {
+                  name: 'Error',
+                  args: [],
+                  returns: [
+                    { type: { kind: $.TypeKind.Basic, name: 'string' } },
+                  ],
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ],
+    Builder,
+    {},
+  )
+}

package/gs/strings/clone.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest'
+import { Clone } from './clone.js'
+
+describe('strings/clone', () => {
+  describe('Clone', () => {
+    it('should return a copy of the string', () => {
+      expect(Clone('hello')).toBe('hello')
+      expect(Clone('world')).toBe('world')
+    })
+
+    it('should handle empty string', () => {
+      expect(Clone('')).toBe('')
+    })
+
+    it('should handle unicode strings', () => {
+      expect(Clone('Hello 世界')).toBe('Hello 世界')
+      expect(Clone('🌟⭐✨')).toBe('🌟⭐✨')
+    })
+
+    it('should handle strings with special characters', () => {
+      expect(Clone('Hello\nWorld\t!')).toBe('Hello\nWorld\t!')
+      expect(Clone('quotes"and\'stuff')).toBe('quotes"and\'stuff')
+    })
+
+    it('should handle long strings', () => {
+      const longString = 'a'.repeat(10000)
+      expect(Clone(longString)).toBe(longString)
+    })
+
+    it('should handle strings with null bytes', () => {
+      const stringWithNull = 'hello\0world'
+      expect(Clone(stringWithNull)).toBe(stringWithNull)
+    })
+
+    it('should create independent copy semantically', () => {
+      const original = 'test string'
+      const cloned = Clone(original)
+      expect(cloned).toBe(original)
+      // In JavaScript, strings are immutable, so this is the expected behavior
+      // The clone function maintains Go semantics where it guarantees a new allocation
+    })
+  })
+})

package/gs/strings/clone.ts

@@ -0,0 +1,17 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+// Clone returns a fresh copy of s.
+// It guarantees to make a copy of s into a new allocation,
+// which can be important when retaining only a small substring
+// of a much larger string. Using Clone can help such programs
+// use less memory. Of course, since using Clone makes a copy,
+// overuse of Clone can make programs use more memory.
+// Clone should typically be used only rarely, and only when
+// profiling indicates that it is needed.
+// For strings of length zero the string "" will be returned
+// and no allocation is made.
+export function Clone(s: string): string {
+  // In JavaScript, strings are immutable, so we can just return the string
+  // But to match Go semantics, we'll create a new string
+  return String(s)
+}

package/gs/strings/compare.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest'
+import { Compare } from './compare.js'
+
+describe('strings/compare', () => {
+  describe('Compare', () => {
+    it('should return 0 for equal strings', () => {
+      expect(Compare('hello', 'hello')).toBe(0)
+      expect(Compare('', '')).toBe(0)
+      expect(Compare('world', 'world')).toBe(0)
+    })
+
+    it('should return -1 when first string is lexicographically smaller', () => {
+      expect(Compare('a', 'b')).toBe(-1)
+      expect(Compare('abc', 'abd')).toBe(-1)
+      expect(Compare('hello', 'world')).toBe(-1)
+      expect(Compare('', 'a')).toBe(-1)
+    })
+
+    it('should return 1 when first string is lexicographically larger', () => {
+      expect(Compare('b', 'a')).toBe(1)
+      expect(Compare('abd', 'abc')).toBe(1)
+      expect(Compare('world', 'hello')).toBe(1)
+      expect(Compare('a', '')).toBe(1)
+    })
+
+    it('should handle strings of different lengths', () => {
+      expect(Compare('abc', 'abcd')).toBe(-1)
+      expect(Compare('abcd', 'abc')).toBe(1)
+      expect(Compare('ab', 'abc')).toBe(-1)
+      expect(Compare('abc', 'ab')).toBe(1)
+    })
+
+    it('should handle case sensitivity', () => {
+      expect(Compare('a', 'A')).toBe(1) // lowercase > uppercase
+      expect(Compare('A', 'a')).toBe(-1)
+      expect(Compare('Hello', 'hello')).toBe(-1)
+    })
+
+    it('should handle unicode strings', () => {
+      expect(Compare('世界', '世界')).toBe(0)
+      expect(Compare('世', '界')).toBeLessThan(0)
+      expect(Compare('🌟', '⭐')).toBeGreaterThan(0)
+    })
+
+    it('should handle special characters', () => {
+      expect(Compare('!', '@')).toBe(-1)
+      expect(Compare('@', '!')).toBe(1)
+      expect(Compare('123', '456')).toBe(-1)
+      expect(Compare('9', '10')).toBe(1) // string comparison, not numeric
+    })
+
+    it('should handle strings with spaces', () => {
+      expect(Compare(' ', '')).toBe(1)
+      expect(Compare('', ' ')).toBe(-1)
+      expect(Compare('a b', 'ab')).toBe(-1) // space < 'b'
+    })
+
+    it('should handle mixed content', () => {
+      expect(Compare('abc123', 'abc456')).toBe(-1)
+      expect(Compare('Hello World', 'Hello world')).toBe(-1) // 'W' < 'w'
+      expect(Compare('test\n', 'test\t')).toBe(1) // '\n' > '\t' (10 > 9)
+    })
+
+    it('should be consistent with built-in comparison', () => {
+      const testCases = [
+        ['hello', 'world'],
+        ['abc', 'abc'],
+        ['a', 'b'],
+        ['', ''],
+        ['longer', 'short'],
+        ['123', '45'],
+      ]
+
+      testCases.forEach(([a, b]) => {
+        const compareResult = Compare(a, b)
+        const builtinResult =
+          a < b ? -1
+          : a > b ? 1
+          : 0
+        expect(compareResult).toBe(builtinResult)
+      })
+    })
+  })
+})

package/gs/strings/compare.ts

@@ -0,0 +1,13 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+// Compare returns an integer comparing two strings lexicographically.
+// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
+//
+// Compare is included only for symmetry with package bytes.
+// It is usually clearer and always faster to use the built-in
+// string comparison operators ==, <, >, and so on.
+export function Compare(a: string, b: string): number {
+  if (a < b) return -1
+  if (a > b) return 1
+  return 0
+}

package/gs/strings/godoc.txt

@@ -0,0 +1,66 @@
+package strings // import "strings"
+
+Package strings implements simple functions to manipulate UTF-8 encoded strings.
+
+For information about UTF-8 strings in Go, see https://blog.golang.org/strings.
+
+func Clone(s string) string
+func Compare(a, b string) int
+func Contains(s, substr string) bool
+func ContainsAny(s, chars string) bool
+func ContainsFunc(s string, f func(rune) bool) bool
+func ContainsRune(s string, r rune) bool
+func Count(s, substr string) int
+func Cut(s, sep string) (before, after string, found bool)
+func CutPrefix(s, prefix string) (after string, found bool)
+func CutSuffix(s, suffix string) (before string, found bool)
+func EqualFold(s, t string) bool
+func Fields(s string) []string
+func FieldsFunc(s string, f func(rune) bool) []string
+func FieldsFuncSeq(s string, f func(rune) bool) iter.Seq[string]
+func FieldsSeq(s string) iter.Seq[string]
+func HasPrefix(s, prefix string) bool
+func HasSuffix(s, suffix string) bool
+func Index(s, substr string) int
+func IndexAny(s, chars string) int
+func IndexByte(s string, c byte) int
+func IndexFunc(s string, f func(rune) bool) int
+func IndexRune(s string, r rune) int
+func Join(elems []string, sep string) string
+func LastIndex(s, substr string) int
+func LastIndexAny(s, chars string) int
+func LastIndexByte(s string, c byte) int
+func LastIndexFunc(s string, f func(rune) bool) int
+func Lines(s string) iter.Seq[string]
+func Map(mapping func(rune) rune, s string) string
+func Repeat(s string, count int) string
+func Replace(s, old, new string, n int) string
+func ReplaceAll(s, old, new string) string
+func Split(s, sep string) []string
+func SplitAfter(s, sep string) []string
+func SplitAfterN(s, sep string, n int) []string
+func SplitAfterSeq(s, sep string) iter.Seq[string]
+func SplitN(s, sep string, n int) []string
+func SplitSeq(s, sep string) iter.Seq[string]
+func Title(s string) string
+func ToLower(s string) string
+func ToLowerSpecial(c unicode.SpecialCase, s string) string
+func ToTitle(s string) string
+func ToTitleSpecial(c unicode.SpecialCase, s string) string
+func ToUpper(s string) string
+func ToUpperSpecial(c unicode.SpecialCase, s string) string
+func ToValidUTF8(s, replacement string) string
+func Trim(s, cutset string) string
+func TrimFunc(s string, f func(rune) bool) string
+func TrimLeft(s, cutset string) string
+func TrimLeftFunc(s string, f func(rune) bool) string
+func TrimPrefix(s, prefix string) string
+func TrimRight(s, cutset string) string
+func TrimRightFunc(s string, f func(rune) bool) string
+func TrimSpace(s string) string
+func TrimSuffix(s, suffix string) string
+type Builder struct{ ... }
+type Reader struct{ ... }
+    func NewReader(s string) *Reader
+type Replacer struct{ ... }
+    func NewReplacer(oldnew ...string) *Replacer

package/gs/strings/index.ts

@@ -0,0 +1,2 @@
+export * from './builder.js'
+export * from './strings.js'