goscript 0.1.0 → 0.1.1

package/gs/math/const.gs.ts

@@ -47,10 +47,10 @@ export let SmallestNonzeroFloat64: number = Number.MIN_VALUE
 let intSize: number = (32 << ((~(0 as number) >> 63)))
 
 // MaxInt32 or MaxInt64 depending on intSize.
-export let MaxInt: bigint = 9223372036854775807n
+export let MaxInt: number = 9223372036854775807
 
 // MinInt32 or MinInt64 depending on intSize.
-export let MinInt: bigint = -9223372036854775808n
+export let MinInt: number = -9223372036854775808
 
 // 127
 export let MaxInt8: number = 127
@@ -71,10 +71,10 @@ export let MaxInt32: number = 2147483647
 export let MinInt32: number = -2147483648
 
 // 9223372036854775807
-export let MaxInt64: bigint = 9223372036854775807n
+export let MaxInt64: number = 9223372036854775807
 
 // -9223372036854775808
-export let MinInt64: bigint = -9223372036854775808n
+export let MinInt64: number = -9223372036854775808
 
 // MaxUint32 or MaxUint64 depending on intSize.
 export let MaxUint: bigint = 0xFFFFFFFFFFFFFFFFn
@@ -89,5 +89,4 @@ export let MaxUint16: number = 65535
 export let MaxUint32: number = 4294967295
 
 // 18446744073709551615
-export let MaxUint64: bigint = 0xFFFFFFFFFFFFFFFFn
-
+export let MaxUint64: number | bigint = 0xFFFFFFFFFFFFFFFFn

package/gs/mime/index.ts

@@ -0,0 +1,54 @@
+export function FormatMediaType(t: string, param: Map<string, string> | Record<string, string> | null): string {
+  if (!isToken(t)) {
+    return ''
+  }
+  let out = t
+  const entries = param instanceof Map ? Array.from(param.entries()) : Object.entries(param ?? {})
+  entries.sort(([a], [b]) => a.localeCompare(b))
+  for (const [key, value] of entries) {
+    if (!isToken(key)) {
+      return ''
+    }
+    out += formatParam(key, String(value))
+  }
+  return out
+}
+
+function formatParam(key: string, value: string): string {
+  if (isToken(value)) {
+    return `; ${key}=${value}`
+  }
+  return `; ${key}*=utf-8''${percentEncode(value)}`
+}
+
+function isToken(value: string): boolean {
+  return /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value)
+}
+
+function percentEncode(value: string): string {
+  let out = ''
+  for (const byte of new TextEncoder().encode(value)) {
+    if (
+      (byte >= 0x30 && byte <= 0x39) ||
+      (byte >= 0x41 && byte <= 0x5a) ||
+      (byte >= 0x61 && byte <= 0x7a) ||
+      byte === 0x21 ||
+      byte === 0x23 ||
+      byte === 0x24 ||
+      byte === 0x26 ||
+      byte === 0x2b ||
+      byte === 0x2d ||
+      byte === 0x2e ||
+      byte === 0x5e ||
+      byte === 0x5f ||
+      byte === 0x60 ||
+      byte === 0x7c ||
+      byte === 0x7e
+    ) {
+      out += String.fromCharCode(byte)
+      continue
+    }
+    out += `%${byte.toString(16).toUpperCase().padStart(2, '0')}`
+  }
+  return out
+}

package/gs/net/http/httptest/index.ts

@@ -0,0 +1,25 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as http from '@goscript/net/http/index.js'
+
+export class ResponseRecorder implements http.ResponseWriter {
+  public Code = 200
+  public Body: $.Slice<number> = null
+  private headerMap = new http.Header()
+
+  public Header(): http.Header {
+    return this.headerMap
+  }
+
+  public Write(p: $.Slice<number>): [number, $.GoError] {
+    this.Body = $.append(this.Body, p)
+    return [$.len(p), null]
+  }
+
+  public WriteHeader(statusCode: number): void {
+    this.Code = statusCode
+  }
+}
+
+export function NewRecorder(): ResponseRecorder {
+  return new ResponseRecorder()
+}

package/gs/net/http/index.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+
+import { Get, Response, StatusOK, StatusText } from './index.js'
+
+describe('net/http override', () => {
+  it('exports response status helpers', () => {
+    const resp = new Response({ StatusCode: StatusOK })
+
+    expect(resp.StatusCode).toBe(200)
+    expect(StatusText(resp.StatusCode)).toBe('OK')
+    expect(StatusText(599)).toBe('')
+  })
+
+  it('returns an explicit unsupported error for Get', () => {
+    const [resp, err] = Get('https://example.invalid')
+
+    expect(resp).toBeNull()
+    expect(err?.Error()).toBe('net/http: Get is not implemented in GoScript')
+  })
+})

package/gs/net/http/index.ts

@@ -0,0 +1,81 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+export const StatusOK = 200
+
+export function StatusText(code: number): string {
+  switch (code) {
+    case StatusOK:
+      return 'OK'
+    default:
+      return ''
+  }
+}
+
+export class Header extends Map<string, $.Slice<string>> {
+  public Add(key: string, value: string): void {
+    const values = Array.from(this.get(key) ?? [])
+    values.push(value)
+    this.set(key, $.arrayToSlice(values))
+  }
+
+  public Del(key: string): void {
+    this.delete(key)
+  }
+
+  public Get(key: string): string {
+    const values = this.get(key)
+    return values == null || values.length === 0 ? '' : String(values[0])
+  }
+
+  public Set(key: string, value: string): void {
+    this.set(key, $.arrayToSlice([value]))
+  }
+}
+
+export function Header_Add(h: Header, key: string, value: string): void {
+  h.Add(key, value)
+}
+
+export function Header_Del(h: Header, key: string): void {
+  h.Del(key)
+}
+
+export function Header_Get(h: Header, key: string): string {
+  return h.Get(key)
+}
+
+export function Header_Set(h: Header, key: string, value: string): void {
+  h.Set(key, value)
+}
+
+export interface ResponseWriter {
+  Header(): Header
+  Write(p: $.Slice<number>): [number, $.GoError]
+  WriteHeader(statusCode: number): void
+}
+
+export class Response {
+  public StatusCode: number
+  public Body: io.ReadCloser | null
+  public Header: Header
+
+  constructor(init?: Partial<Response>) {
+    this.StatusCode = init?.StatusCode ?? 0
+    this.Body = init?.Body ?? null
+    this.Header = init?.Header ?? new Header()
+  }
+
+  public clone(): Response {
+    return new Response({
+      Body: this.Body,
+      Header: this.Header,
+      StatusCode: this.StatusCode,
+    })
+  }
+}
+
+export function Get(_url: string): [Response | null, $.GoError] {
+  return [null, errors.New('net/http: Get is not implemented in GoScript')]
+}

package/gs/os/dir_unix.gs.ts

@@ -130,7 +130,7 @@ export function readIntBE(b: $.Bytes, size: uintptr): number {
 		case 4:
 			return (byteorder.BEUint32(b) as number)
 		case 8:
-			return (byteorder.BEUint64(b) as number)
+			return Number(byteorder.BEUint64(b))
 		default:
 			$.panic("syscall: readInt with unsupported size")
 			return 0 // This line will never be reached due to panic, but satisfies TypeScript
@@ -146,10 +146,9 @@ export function readIntLE(b: $.Bytes, size: uintptr): number {
 		case 4:
 			return (byteorder.LEUint32(b) as number)
 		case 8:
-			return (byteorder.LEUint64(b) as number)
+			return Number(byteorder.LEUint64(b))
 		default:
 			$.panic("syscall: readInt with unsupported size")
 			return 0 // This line will never be reached due to panic, but satisfies TypeScript
 	}
 }
-

package/gs/os/types_js.gs.ts

@@ -312,7 +312,7 @@ export class File {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(this, r)
+		return io.Copy(this, r) as any
 	}
 
 	public Write(b: $.Bytes): [number, $.GoError] {
@@ -349,7 +349,7 @@ export class File {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(w, this)
+		return io.Copy(w, this) as any
 	}
 
 	public Seek(offset: number, whence: number): [number, $.GoError] {

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

@@ -1,4 +1,7 @@
 import { describe, it, expect } from 'vitest'
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import { Match, Glob, ErrBadPattern } from './match.js'
 
 describe('path/filepath - Pattern matching functions', () => {
@@ -216,20 +219,36 @@ describe('path/filepath - Pattern matching functions', () => {
   })
 
   describe('Glob', () => {
-    it('should validate patterns but return empty results (no filesystem)', () => {
-      // Valid patterns should not error
-      const [files1, err1] = Glob('*.txt')
-      expect(err1).toBeNull()
-      expect(files1).toEqual([])
+    it('should read host filesystem matches', () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-glob-'))
+      const oldwd = process.cwd()
+      try {
+        mkdirSync(join(root, 'a', 'b', 'c.d', 'e.f'), { recursive: true })
+        process.chdir(root)
+
+        const [files1, err1] = Glob('./*/*/*.d')
+        expect(err1).toBeNull()
+        expect(files1).toEqual(['a/b/c.d'])
 
-      const [files2, err2] = Glob('dir/*')
-      expect(err2).toBeNull()
-      expect(files2).toEqual([])
+        const [files2, err2] = Glob('a/b/c.d/e.*')
+        expect(err2).toBeNull()
+        expect(files2).toEqual(['a/b/c.d/e.f'])
+      } finally {
+        process.chdir(oldwd)
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
 
-      // Invalid patterns should error
-      const [files3, err3] = Glob('[unclosed')
-      expect(err3).toBe(ErrBadPattern)
-      expect(files3).toEqual([])
+    it('should validate bad patterns', () => {
+      const [files1, err1] = Glob('[unclosed')
+      expect(err1).toBe(ErrBadPattern)
+      expect(files1).toEqual([])
+    })
+
+    it('should return empty results for unmatched valid patterns', () => {
+      const [files1, err1] = Glob('missing-*.txt')
+      expect(err1).toBeNull()
+      expect(files1).toEqual([])
     })
   })
 

package/gs/path/filepath/match.ts

@@ -1,4 +1,5 @@
 import * as $ from '@goscript/builtin/index.js'
+import { getHostRuntime, type NodeFSModule } from '@goscript/builtin/hostio.js'
 
 export const ErrBadPattern = $.newError('syntax error in pattern')
 
@@ -238,12 +239,186 @@ function matchCharClass(
 // The only possible returned error is ErrBadPattern, when pattern is malformed.
 export function Glob(pattern: string): [string[], $.GoError] {
   try {
-    // Validate the pattern using the same logic as Match
     validatePattern(pattern)
-    // We don't have filesystem access, so return empty array
-    return [[], null]
+    return [globHost(pattern), null]
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (err) {
     return [[], ErrBadPattern]
   }
 }
+
+function hasMeta(path: string): boolean {
+  return /[*?[\\]/.test(path)
+}
+
+function splitPattern(pattern: string): { absolute: boolean; segments: string[] } {
+  const absolute = pattern.startsWith('/')
+  const segments = pattern.split('/').filter((segment, index) => {
+    if (index === 0 && segment === '') {
+      return false
+    }
+    return segment !== '' && segment !== '.'
+  })
+  return { absolute, segments }
+}
+
+function cleanMatch(path: string): string {
+  const absolute = path.startsWith('/')
+  const parts: string[] = []
+  for (const part of path.split('/')) {
+    if (part === '' || part === '.') {
+      continue
+    }
+    if (part === '..') {
+      if (parts.length > 0 && parts[parts.length - 1] !== '..') {
+        parts.pop()
+      } else if (!absolute) {
+        parts.push(part)
+      }
+      continue
+    }
+    parts.push(part)
+  }
+  const out = parts.join('/')
+  if (absolute) {
+    return '/' + out
+  }
+  return out === '' ? '.' : out
+}
+
+function joinPath(dir: string, name: string): string {
+  if (dir === '' || dir === '.') {
+    return name
+  }
+  if (dir === '/') {
+    return '/' + name
+  }
+  return dir.replace(/\/+$/, '') + '/' + name
+}
+
+type HostDirEntry = { name: string; isDir: boolean }
+
+function readDir(path: string): HostDirEntry[] | null {
+  const runtime = getHostRuntime()
+  const denoObj = runtime.deno
+  if (denoObj?.readDirSync) {
+    try {
+      const entries: HostDirEntry[] = []
+      for (const entry of denoObj.readDirSync(path)) {
+        entries.push({ name: entry.name, isDir: !!entry.isDirectory })
+      }
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return entries
+    } catch {
+      return null
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.readdirSync) {
+    try {
+      const entries = nodeFS
+        .readdirSync(path, { withFileTypes: true })
+        .map((entry: any) => ({
+          name: String(entry.name),
+          isDir:
+            typeof entry.isDirectory === 'function' ?
+              entry.isDirectory()
+            : false,
+        }))
+      entries.sort((a, b) => a.name.localeCompare(b.name))
+      return entries
+    } catch {
+      return null
+    }
+  }
+
+  return null
+}
+
+function exists(path: string): boolean {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.statSync) {
+    try {
+      runtime.deno.statSync(path)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  const nodeFS = runtime.nodeFS
+  if (nodeFS?.statSync) {
+    try {
+      nodeFS.statSync(path)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+function isDir(path: string, nodeFS?: NodeFSModule | null): boolean {
+  const runtime = getHostRuntime()
+  if (runtime.deno?.statSync) {
+    try {
+      return !!runtime.deno.statSync(path).isDirectory
+    } catch {
+      return false
+    }
+  }
+
+  const fs = nodeFS ?? runtime.nodeFS
+  if (fs?.statSync) {
+    try {
+      const stat = fs.statSync(path)
+      return typeof stat.isDirectory === 'function' ? stat.isDirectory() : false
+    } catch {
+      return false
+    }
+  }
+
+  return false
+}
+
+function globHost(pattern: string): string[] {
+  const { absolute, segments } = splitPattern(pattern)
+  if (!hasMeta(pattern)) {
+    return exists(pattern) ? [cleanMatch(pattern)] : []
+  }
+
+  let prefixes = [absolute ? '/' : '.']
+  for (const [index, segment] of segments.entries()) {
+    const next: string[] = []
+    const last = index === segments.length - 1
+    const segmentHasMeta = hasMeta(segment)
+    for (const prefix of prefixes) {
+      if (!segmentHasMeta) {
+        const candidate = joinPath(prefix, segment)
+        if (last || isDir(candidate)) {
+          next.push(candidate)
+        }
+        continue
+      }
+
+      const entries = readDir(prefix)
+      if (entries === null) {
+        continue
+      }
+      for (const entry of entries) {
+        const [matched, err] = Match(segment, entry.name)
+        if (err !== null || !matched) {
+          continue
+        }
+        if (last || entry.isDir) {
+          next.push(joinPath(prefix, entry.name))
+        }
+      }
+    }
+    prefixes = next
+  }
+
+  return prefixes.map(cleanMatch).sort()
+}

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

@@ -1,4 +1,7 @@
 import { describe, it, expect } from 'vitest'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import {
   Base,
   Dir,
@@ -16,6 +19,7 @@ import {
   Abs,
   Rel,
   EvalSymlinks,
+  Walk,
   Separator,
   ListSeparator,
 } from './path.js'
@@ -201,6 +205,27 @@ describe('path/filepath - Path manipulation functions', () => {
     })
   })
 
+  describe('Walk', () => {
+    it('should visit host filesystem paths in lexical order', () => {
+      const root = mkdtempSync(join(tmpdir(), 'goscript-filepath-walk-'))
+      try {
+        mkdirSync(join(root, 'a', 'b'), { recursive: true })
+        writeFileSync(join(root, 'a', 'b', 'file.txt'), 'ok')
+
+        const visited: string[] = []
+        const err = Walk(root, (path) => {
+          visited.push(path.slice(root.length).replace(/^\/?/, '') || '.')
+          return null
+        })
+
+        expect(err).toBeNull()
+        expect(visited).toEqual(['.', 'a', 'a/b', 'a/b/file.txt'])
+      } finally {
+        rmSync(root, { force: true, recursive: true })
+      }
+    })
+  })
+
   describe('Constants', () => {
     it('should have correct separator constants', () => {
       expect(Separator).toBe(47)