goscript 0.1.0 → 0.1.2

package/gs/runtime/trace/index.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import * as context from '@goscript/context/index.js'
+
+import { IsEnabled, Log, NewTask, Start, StartRegion, Stop, WithRegion } from './index.js'
+
+describe('runtime/trace override', () => {
+  it('creates no-op tasks from nil context', () => {
+    const [ctx, task] = NewTask(null, 'task')
+
+    expect(ctx).not.toBeNull()
+    expect(task).not.toBeNull()
+    task.End()
+    Log(ctx, 'category', 'message')
+    expect(IsEnabled()).toBe(false)
+  })
+
+  it('runs no-op regions', () => {
+    const [ctx] = NewTask(context.Background(), 'task')
+    const called = { value: false }
+
+    WithRegion(ctx, 'region', () => {
+      called.value = true
+    })
+    StartRegion(ctx, 'region').End()
+
+    expect(called.value).toBe(true)
+  })
+
+  it('writes deterministic trace bytes', () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(new Uint8Array(p))
+        return [p.length, null]
+      },
+    }
+
+    expect(Start(writer)).toBeNull()
+    Log(context.Background(), 'category', 'message')
+    Stop()
+
+    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+  })
+})

package/gs/runtime/trace/index.ts

@@ -0,0 +1,97 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as context from '@goscript/context/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+class traceContextKey {}
+
+const traceState = {
+  activeWriter: null as io.Writer | null,
+  nextTaskID: 0,
+}
+
+export class Task {
+  public id: number
+
+  constructor(id = 0) {
+    this.id = id
+  }
+
+  public End(): void {}
+}
+
+export class Region {
+  public End(): void {}
+}
+
+export function NewTask(
+  pctx: context.Context | null,
+  _taskType: string,
+): [context.Context | null, Task] {
+  const parent = pctx ?? context.Background()
+  const task = new Task(++traceState.nextTaskID)
+  return [
+    context.WithValue(
+      parent,
+      $.interfaceValue(new traceContextKey(), 'trace.traceContextKey'),
+      $.interfaceValue(task, '*trace.Task'),
+    ),
+    task,
+  ]
+}
+
+export function Log(_ctx: context.Context | null, category: string, message: string): void {
+  writeTrace(`log ${category} ${message}\n`)
+}
+
+export function Logf(
+  _ctx: context.Context | null,
+  _category: string,
+  _format: string,
+  ..._args: unknown[]
+): void {}
+
+export function WithRegion(
+  _ctx: context.Context | null,
+  _regionType: string,
+  fn: (() => void) | null,
+): void {
+  fn?.()
+}
+
+export function StartRegion(
+  _ctx: context.Context | null,
+  _regionType: string,
+): Region {
+  return new Region()
+}
+
+export function IsEnabled(): boolean {
+  return false
+}
+
+export function Start(w: io.Writer | $.VarRef<io.Writer> | null): $.GoError {
+  const writer = $.pointerValueOrNil(w)
+  if (writer == null) {
+    return errors.New('runtime/trace: nil trace writer')
+  }
+  if (traceState.activeWriter != null) {
+    return errors.New('runtime/trace: trace already active')
+  }
+  traceState.activeWriter = writer
+  return writeTrace('goscript trace start\n')
+}
+
+export function Stop(): void {
+  writeTrace('goscript trace stop\n')
+  traceState.activeWriter = null
+}
+
+function writeTrace(text: string): $.GoError {
+  const writer = traceState.activeWriter
+  if (writer == null) {
+    return null
+  }
+  const [, err] = writer.Write($.stringToBytes(text))
+  return err
+}

package/gs/runtime/trace/meta.json

@@ -0,0 +1,7 @@
+{
+  "dependencies": [
+    "context",
+    "errors",
+    "io"
+  ]
+}

package/gs/slices/meta.json

@@ -1,5 +1,6 @@
 {
   "dependencies": [
-    "cmp"
+    "cmp",
+    "iter"
   ]
 }

package/gs/slices/slices.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import {
+  All,
+  Backward,
+  BinarySearch,
+  Clip,
+  Compact,
+  CompactFunc,
+  CompareFunc,
+  Concat,
+  DeleteFunc,
+  EqualFunc,
+  IndexFunc,
+  IsSorted,
+  IsSortedFunc,
+  Max,
+  MaxFunc,
+  Min,
+  MinFunc,
+  Replace,
+  Sorted,
+  SortStableFunc,
+} from './slices.js'
+
+describe('slices.SortStableFunc', () => {
+  it('preserves original order for equal elements', () => {
+    const values = $.arrayToSlice([
+      { group: 2, label: 'a' },
+      { group: 1, label: 'b' },
+      { group: 2, label: 'c' },
+      { group: 1, label: 'd' },
+    ])
+
+    SortStableFunc(values, (a, b) => a.group - b.group)
+
+    expect(values?.map((value) => value.label)).toEqual(['b', 'd', 'a', 'c'])
+  })
+})
+
+describe('slices compatibility helpers', () => {
+  it('implements comparison, min/max, compact, replace, clip, and search helpers', () => {
+    expect(
+      CompareFunc($.arrayToSlice(['a', 'c']), $.arrayToSlice(['a', 'b']), (a, b) =>
+        a.localeCompare(b),
+      ),
+    ).toBeGreaterThan(0)
+    expect(Min($.arrayToSlice([3, 1, 2]))).toBe(1)
+    expect(MaxFunc($.arrayToSlice([{ v: 1 }, { v: 4 }]), (a, b) => a.v - b.v).v).toBe(4)
+    expect(MinFunc($.arrayToSlice([{ v: 3 }, { v: 2 }]), (a, b) => a.v - b.v).v).toBe(2)
+    expect(Array.from(Compact($.arrayToSlice([1, 1, 2, 2, 3])) ?? [])).toEqual([1, 2, 3])
+    expect(
+      Array.from(
+        CompactFunc(
+          $.arrayToSlice(['a', 'A', 'b']),
+          (a, b) => a.toLowerCase() === b.toLowerCase(),
+        ) ?? [],
+      ),
+    ).toEqual(['a', 'b'])
+    expect(Array.from(Replace($.arrayToSlice([1, 2, 3, 4]), 1, 3, 9, 8)) ?? []).toEqual([
+      1, 9, 8, 4,
+    ])
+    expect(Array.from(Clip($.arrayToSlice([1, 2])) ?? [])).toEqual([1, 2])
+    expect(BinarySearch($.arrayToSlice([1, 3, 5]), 3)).toEqual([1, true])
+  })
+
+  it('concatenates slices and preserves empty concat nilness', () => {
+    expect(Concat()).toBeNull()
+    expect(Concat($.arrayToSlice<number>([]))).toBeNull()
+    expect(Array.from(Concat($.arrayToSlice([1]), null, $.arrayToSlice([2, 3])) ?? [])).toEqual([
+      1, 2, 3,
+    ])
+    expect(Array.from(Concat(new Uint8Array([1, 2]), new Uint8Array([3])) ?? [])).toEqual([
+      1, 2, 3,
+    ])
+  })
+
+  it('accepts generated possibly-async callback types for sync helpers', () => {
+    const compare: (a: number, b: number) => number | Promise<number> = (a, b) => a - b
+    const keepOdd: (v: number) => boolean | Promise<boolean> = (v) => v % 2 === 0
+    const equal: (a: string, b: string) => boolean | Promise<boolean> = (a, b) => a === b
+
+    expect(CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), compare)).toBeLessThan(0)
+    expect(Array.from(DeleteFunc($.arrayToSlice([1, 2, 3]), keepOdd) ?? [])).toEqual([1, 3])
+    expect(EqualFunc($.arrayToSlice(['a']), $.arrayToSlice(['a']), equal)).toBe(true)
+    expect(IndexFunc($.arrayToSlice([1, 2, 3]), keepOdd)).toBe(1)
+    expect(IsSortedFunc($.arrayToSlice([1, 2, 3]), compare)).toBe(true)
+    expect(BinarySearch($.arrayToSlice([1, 2, 3]), 2)).toEqual([1, true])
+  })
+
+  it('rejects actual async callback results in sync helpers', () => {
+    expect(() =>
+      CompareFunc($.arrayToSlice([1]), $.arrayToSlice([2]), async (a, b) => a - b),
+    ).toThrow('slices: asynchronous callback result is not supported')
+  })
+})
+
+describe('slices.Sorted', () => {
+  it('collects and sorts iterator values', () => {
+    const values = Sorted<string>((yieldValue) => {
+      yieldValue('c')
+      yieldValue('a')
+      yieldValue('b')
+    })
+
+    expect(values).toEqual(['a', 'b', 'c'])
+  })
+})
+
+describe('slices.Backward', () => {
+  it('yields index-value pairs from the end', () => {
+    const visited: Array<[number, string]> = []
+    Backward($.arrayToSlice(['a', 'b', 'c']))((index, value) => {
+      visited.push([index, value])
+      return true
+    })
+
+    expect(visited).toEqual([
+      [2, 'c'],
+      [1, 'b'],
+      [0, 'a'],
+    ])
+  })
+
+  it('accepts async yield callbacks', async () => {
+    const visited: Array<[number, string]> = []
+    await Backward($.arrayToSlice(['a', 'b', 'c']))(async (index, value) => {
+      visited.push([index, value])
+      return index > 1
+    })
+
+    expect(visited).toEqual([
+      [2, 'c'],
+      [1, 'b'],
+    ])
+  })
+})
+
+describe('slices.All', () => {
+  it('accepts async yield callbacks', async () => {
+    const visited: Array<[number, string]> = []
+    await All($.arrayToSlice(['a', 'b', 'c']))(async (index, value) => {
+      visited.push([index, value])
+      return index < 1
+    })
+
+    expect(visited).toEqual([
+      [0, 'a'],
+      [1, 'b'],
+    ])
+  })
+})
+
+describe('slices.IsSorted', () => {
+  it('reports ordered and unordered slices', () => {
+    expect(IsSorted($.arrayToSlice([1, 2, 3]))).toBe(true)
+    expect(IsSorted($.arrayToSlice([1, 3, 2]))).toBe(false)
+    expect(
+      IsSortedFunc($.arrayToSlice(['aa', 'b']), (a, b) => a.length - b.length),
+    ).toBe(false)
+    expect(
+      IsSortedFunc($.arrayToSlice(['b', 'aa']), (a, b) => a.length - b.length),
+    ).toBe(true)
+  })
+})
+
+describe('slices.Max', () => {
+  it('returns the greatest ordered value', () => {
+    expect(Max($.arrayToSlice([3, 1, 4, 2]))).toBe(4)
+    expect(Max($.arrayToSlice(['beta', 'alpha', 'gamma']))).toBe('gamma')
+  })
+
+  it('panics for empty slices', () => {
+    expect(() => Max($.arrayToSlice<number>([]))).toThrow(
+      'slices.Max: empty list',
+    )
+  })
+})