goscript 0.1.3 → 0.2.0

package/gs/crypto/sha1/index.test.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
 
-import { New, Sum } from './index.js'
+import { New, Size, Sum } from './index.js'
 
 describe('crypto/sha1 override', () => {
   it('matches Node digest', async () => {
@@ -15,7 +16,23 @@ describe('crypto/sha1 override', () => {
     h.Write(new TextEncoder().encode('go'))
     h.Write(new TextEncoder().encode('script'))
 
-    expect(toHex(await h.Sum(null))).toBe(nodeHash(new TextEncoder().encode('goscript')))
+    expect(toHex(await h.Sum(null))).toBe(
+      nodeHash(new TextEncoder().encode('goscript')),
+    )
+  })
+
+  it('appends into spare byte-slice backing', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('abc'))
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await h.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(backing[0]).toBe(out[0])
+    expect(backing[Size - 1]).toBe(out[Size - 1])
+    expect(toHex($.bytesToUint8Array(backing))).toBe(
+      nodeHash(new TextEncoder().encode('abc')),
+    )
   })
 })
 

package/gs/crypto/sha1/index.ts

@@ -41,7 +41,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -92,11 +92,8 @@ async function sum(data: $.Bytes): Promise<Uint8Array> {
   return new Uint8Array(digest)
 }
 
-function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
-  const out = new Uint8Array(prefix.length + digest.length)
-  out.set(prefix)
-  out.set(digest, prefix.length)
-  return out
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
 }
 
 function createNodeHash(): NodeCryptoHash | null {

package/gs/crypto/sha256/index.test.ts

@@ -25,11 +25,23 @@ describe('crypto/sha256 override', () => {
     )
   })
 
+  test('streaming digest appends into spare byte-slice backing', async () => {
+    const digest = New()
+    expect(digest.Write($.stringToBytes('abc'))).toEqual([3, null])
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await digest.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(Array.from($.bytesToUint8Array(backing))).toEqual(
+      Array.from(await Sum256($.stringToBytes('abc'))),
+    )
+  })
+
   test('sums SHA-224 with host crypto', async () => {
     const sum = await Sum224($.stringToBytes('abc'))
     expect(Array.from(sum)).toEqual([
-      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179,
-      42, 173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
+      35, 9, 125, 34, 52, 5, 216, 34, 134, 66, 164, 119, 189, 162, 85, 179, 42,
+      173, 188, 228, 189, 160, 179, 247, 227, 108, 157, 167,
     ])
   })
 

package/gs/crypto/sha256/index.ts

@@ -44,7 +44,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.algorithm, this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -112,11 +112,8 @@ async function sum(
   return new Uint8Array(digest)
 }
 
-function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
-  const out = new Uint8Array(prefix.length + digest.length)
-  out.set(prefix)
-  out.set(digest, prefix.length)
-  return out
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
 }
 
 function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {

package/gs/crypto/sha512/index.test.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto'
 import { describe, expect, it } from 'vitest'
+import * as $ from '@goscript/builtin/index.js'
 
-import { New, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
+import { New, Size, Sum384, Sum512, Sum512_224, Sum512_256 } from './index.js'
 
 describe('crypto/sha512 override', () => {
   it('matches Node digests', async () => {
@@ -18,7 +19,21 @@ describe('crypto/sha512 override', () => {
     h.Write(new TextEncoder().encode('go'))
     h.Write(new TextEncoder().encode('script'))
 
-    expect(toHex(await h.Sum(null))).toBe(nodeHash('sha512', new TextEncoder().encode('goscript')))
+    expect(toHex(await h.Sum(null))).toBe(
+      nodeHash('sha512', new TextEncoder().encode('goscript')),
+    )
+  })
+
+  it('appends into spare byte-slice backing', async () => {
+    const h = New()
+    h.Write(new TextEncoder().encode('abc'))
+
+    const backing = $.makeSlice<number>(Size, undefined, 'byte')
+    const out = await h.Sum($.goSlice(backing, 0, 0))
+    expect(out.length).toBe(Size)
+    expect(toHex($.bytesToUint8Array(backing))).toBe(
+      nodeHash('sha512', new TextEncoder().encode('abc')),
+    )
   })
 })
 

package/gs/crypto/sha512/index.ts

@@ -38,7 +38,7 @@ class Digest {
       this.canCopyHash ?
         new Uint8Array(this.hash!.copy!().digest())
       : await sum(this.algorithm, this.snapshotBytes())
-    return appendDigest($.bytesToUint8Array(b), digest)
+    return appendDigest(b, digest)
   }
 
   Reset(): void {
@@ -123,11 +123,8 @@ async function sum(
   return new Uint8Array(digest)
 }
 
-function appendDigest(prefix: Uint8Array, digest: Uint8Array): Uint8Array {
-  const out = new Uint8Array(prefix.length + digest.length)
-  out.set(prefix)
-  out.set(digest, prefix.length)
-  return out
+function appendDigest(prefix: $.Bytes, digest: Uint8Array): $.Bytes {
+  return $.append(prefix as any, ...digest) as $.Bytes
 }
 
 function createNodeHash(algorithm: ShaAlgorithm): NodeCryptoHash | null {

package/gs/embed/index.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest'
+
+import { cloneStructValue, markAsStructValue } from '@goscript/builtin/index.js'
+import { EOF } from '@goscript/io/index.js'
+import { ReadDir, ReadFile, Stat } from '@goscript/io/fs/index.js'
+
+import { FS } from './index.js'
+
+describe('embed.FS', () => {
+  it('clones embedded files as Go struct values', () => {
+    const original = markAsStructValue(
+      new FS(new Map([['config-set.bin', new Uint8Array([1, 2, 3])]])),
+    )
+
+    const cloned = cloneStructValue(original)
+    const [data, err] = cloned.ReadFile('config-set.bin')
+
+    expect(err).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+  })
+
+  it('supports io/fs read, stat, and directory APIs', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [data, readErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readErr).toBeNull()
+    expect(Array.from(data)).toEqual([1, 2, 3])
+    data[0] = 9
+    const [dataAgain, readAgainErr] = ReadFile(fsys, 'config-set.bin')
+    expect(readAgainErr).toBeNull()
+    expect(Array.from(dataAgain)).toEqual([1, 2, 3])
+
+    const [rootEntries, rootErr] = ReadDir(fsys, '.')
+    expect(rootErr).toBeNull()
+    expect(rootEntries!.map((entry) => entry!.Name())).toEqual([
+      'assets',
+      'config-set.bin',
+    ])
+
+    const [assetInfo, statErr] = Stat(fsys, 'assets')
+    expect(statErr).toBeNull()
+    expect(assetInfo!.IsDir()).toBe(true)
+
+    const [assetEntries, assetErr] = ReadDir(fsys, 'assets')
+    expect(assetErr).toBeNull()
+    expect(assetEntries!.map((entry) => entry!.Name())).toEqual(['config.json'])
+  })
+
+  it('supports Open file reads and directory iteration', () => {
+    const fsys = markAsStructValue(
+      new FS(
+        new Map([
+          ['config-set.bin', new Uint8Array([1, 2, 3])],
+          ['assets/config.json', new Uint8Array([4])],
+        ]),
+      ),
+    )
+
+    const [file, openErr] = fsys.Open('config-set.bin')
+    expect(openErr).toBeNull()
+    const buffer = new Uint8Array(2)
+    const [firstRead, firstErr] = file!.Read(buffer)
+    expect(firstErr).toBeNull()
+    expect(firstRead).toBe(2)
+    expect(Array.from(buffer)).toEqual([1, 2])
+    const [secondRead, secondErr] = file!.Read(buffer)
+    expect(secondErr).toBeNull()
+    expect(secondRead).toBe(1)
+    expect(Array.from(buffer)).toEqual([3, 2])
+    const [eofRead, eofErr] = file!.Read(buffer)
+    expect(eofRead).toBe(0)
+    expect(eofErr).toBe(EOF)
+
+    const [dir, dirOpenErr] = fsys.Open('.')
+    expect(dirOpenErr).toBeNull()
+    const [entries, readDirErr] = dir!.ReadDir(1)
+    expect(readDirErr).toBeNull()
+    expect(entries!.map((entry) => entry!.Name())).toEqual(['assets'])
+  })
+})

package/gs/embed/index.ts

@@ -1,20 +1,244 @@
 import * as $ from '@goscript/builtin/index.js'
+import * as io from '@goscript/io/index.js'
 import * as fs from '@goscript/io/fs/index.js'
+import * as time from '@goscript/time/index.js'
 
 export class FS {
+  private files: Map<string, Uint8Array>
+
+  constructor(files?: Map<string, Uint8Array>) {
+    this.files = files ?? new Map()
+  }
+
+  clone(): FS {
+    const files = new Map<string, Uint8Array>()
+    for (const [name, data] of this.files) {
+      files.set(name, data.slice())
+    }
+    return $.markAsStructValue(new FS(files))
+  }
+
   Open(name: string): [fs.File, $.GoError] {
-    return [null, pathError('open', name)]
+    const err = validatePath('open', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const data = this.files.get(name)
+    if (data !== undefined) {
+      return [new embedFile(name, data), null]
+    }
+    const entries = this.dirEntries(name)
+    if (entries === null) {
+      return [null, pathError('open', name, fs.ErrNotExist)]
+    }
+    return [new embedFile(name, null, entries), null]
   }
 
   ReadDir(name: string): [$.Slice<fs.DirEntry>, $.GoError] {
-    return [null, pathError('read', name)]
+    const err = validatePath('read', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const entries = this.dirEntries(name)
+    if (entries === null) {
+      return [null, pathError('read', name, fs.ErrNotExist)]
+    }
+    return [entries, null]
   }
 
   ReadFile(name: string): [Uint8Array, $.GoError] {
-    return [new Uint8Array(0), pathError('read', name)]
+    const err = validatePath('read', name)
+    if (err != null) {
+      return [new Uint8Array(0), err]
+    }
+    const data = this.files.get(name)
+    if (data === undefined) {
+      const err = this.dirExists(name) ? fs.ErrInvalid : fs.ErrNotExist
+      return [new Uint8Array(0), pathError('read', name, err)]
+    }
+    return [data.slice(), null]
+  }
+
+  Stat(name: string): [fs.FileInfo, $.GoError] {
+    const err = validatePath('stat', name)
+    if (err != null) {
+      return [null, err]
+    }
+    const data = this.files.get(name)
+    if (data !== undefined) {
+      return [new embedFileInfo(baseName(name), data.byteLength, 0o444), null]
+    }
+    if (!this.dirExists(name)) {
+      return [null, pathError('stat', name, fs.ErrNotExist)]
+    }
+    return [new embedFileInfo(baseName(name), 0, fs.ModeDir | 0o555), null]
+  }
+
+  private dirEntries(name: string): $.Slice<fs.DirEntry> | null {
+    if (!this.dirExists(name)) {
+      return null
+    }
+    const prefix = name === '.' ? '' : name + '/'
+    const entries = new Map<string, fs.DirEntry>()
+    for (const [filePath, data] of this.files) {
+      if (prefix !== '' && !filePath.startsWith(prefix)) {
+        continue
+      }
+      const rest = prefix === '' ? filePath : filePath.slice(prefix.length)
+      if (rest === '') {
+        continue
+      }
+      const slash = rest.indexOf('/')
+      const childName = slash === -1 ? rest : rest.slice(0, slash)
+      if (entries.has(childName)) {
+        continue
+      }
+      const isDir = slash !== -1
+      const info =
+        isDir ?
+          new embedFileInfo(childName, 0, fs.ModeDir | 0o555)
+        : new embedFileInfo(childName, data.byteLength, 0o444)
+      entries.set(childName, new embedDirEntry(info))
+    }
+    return Array.from(entries.values()).sort((a, b) =>
+      a!.Name().localeCompare(b!.Name()),
+    )
+  }
+
+  private dirExists(name: string): boolean {
+    if (name === '.') {
+      return true
+    }
+    const prefix = name + '/'
+    for (const path of this.files.keys()) {
+      if (path.startsWith(prefix)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+
+class embedFile {
+  private offset = 0
+  private dirOffset = 0
+
+  constructor(
+    private readonly name: string,
+    private readonly data: Uint8Array | null,
+    private readonly entries: $.Slice<fs.DirEntry> = [],
+  ) {}
+
+  Close(): $.GoError {
+    return null
+  }
+
+  Read(buffer: Uint8Array): [number, $.GoError] {
+    if (this.data === null) {
+      return [0, pathError('read', this.name, fs.ErrInvalid)]
+    }
+    if (this.offset >= this.data.byteLength) {
+      return [0, io.EOF]
+    }
+    const n = Math.min(buffer.byteLength, this.data.byteLength - this.offset)
+    buffer.set(this.data.subarray(this.offset, this.offset + n))
+    this.offset += n
+    return [n, null]
+  }
+
+  ReadDir(n: number): [$.Slice<fs.DirEntry>, $.GoError] {
+    if (this.data !== null) {
+      return [null, pathError('readdir', this.name, fs.ErrInvalid)]
+    }
+    const allEntries = this.entries ?? []
+    if (n <= 0) {
+      const entries = allEntries.slice(this.dirOffset)
+      this.dirOffset = allEntries.length
+      return [entries, null]
+    }
+    if (this.dirOffset >= allEntries.length) {
+      return [[], io.EOF]
+    }
+    const entries = allEntries.slice(this.dirOffset, this.dirOffset + n)
+    this.dirOffset += entries.length
+    return [entries, null]
+  }
+
+  Stat(): [fs.FileInfo, $.GoError] {
+    if (this.data === null) {
+      return [new embedFileInfo(baseName(this.name), 0, fs.ModeDir | 0o555), null]
+    }
+    return [new embedFileInfo(baseName(this.name), this.data.byteLength, 0o444), null]
+  }
+}
+
+class embedFileInfo {
+  constructor(
+    private readonly name: string,
+    private readonly size: number,
+    private readonly mode: fs.FileMode,
+  ) {}
+
+  IsDir(): boolean {
+    return fs.FileMode_IsDir(this.mode)
+  }
+
+  ModTime(): time.Time {
+    return new time.Time()
+  }
+
+  Mode(): fs.FileMode {
+    return this.mode
+  }
+
+  Name(): string {
+    return this.name
+  }
+
+  Size(): number {
+    return this.size
+  }
+
+  Sys(): null {
+    return null
+  }
+}
+
+class embedDirEntry {
+  constructor(private readonly info: fs.FileInfo) {}
+
+  Info(): [fs.FileInfo, $.GoError] {
+    return [this.info, null]
+  }
+
+  IsDir(): boolean {
+    return this.info!.IsDir()
+  }
+
+  Name(): string {
+    return this.info!.Name()
+  }
+
+  Type(): fs.FileMode {
+    return fs.fileModeType(this.info!.Mode())
   }
 }
 
-function pathError(op: string, name: string): $.GoError {
-  return new fs.PathError({ Op: op, Path: name, Err: fs.ErrNotExist })
+function validatePath(op: string, name: string): $.GoError {
+  if (!fs.ValidPath(name)) {
+    return pathError(op, name, fs.ErrInvalid)
+  }
+  return null
+}
+
+function pathError(op: string, name: string, err: $.GoError): $.GoError {
+  return new fs.PathError({ Op: op, Path: name, Err: err })
+}
+
+function baseName(name: string): string {
+  const idx = name.lastIndexOf('/')
+  if (idx === -1) {
+    return name
+  }
+  return name.slice(idx + 1)
 }