goscript 0.0.25 → 0.0.28

package/gs/unsafe/unsafe.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest'
+import * as unsafe from './unsafe.js'
+
+describe('unsafe package', () => {
+  it('should throw error for Alignof', () => {
+    expect(() => unsafe.Alignof({})).toThrow(
+      'unsafe.Alignof is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for Offsetof', () => {
+    expect(() => unsafe.Offsetof({})).toThrow(
+      'unsafe.Offsetof is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for Sizeof', () => {
+    expect(() => unsafe.Sizeof({})).toThrow(
+      'unsafe.Sizeof is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for Add', () => {
+    expect(() => unsafe.Add(null, 1)).toThrow(
+      'unsafe.Add is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for Slice', () => {
+    expect(() => unsafe.Slice(null, 1)).toThrow(
+      'unsafe.Slice is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for SliceData', () => {
+    expect(() => unsafe.SliceData([])).toThrow(
+      'unsafe.SliceData is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for String', () => {
+    expect(() => unsafe.String(null, 1)).toThrow(
+      'unsafe.String is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should throw error for StringData', () => {
+    expect(() => unsafe.StringData('test')).toThrow(
+      'unsafe.StringData is not supported in JavaScript/TypeScript',
+    )
+  })
+
+  it('should export IntegerType as number type', () => {
+    // IntegerType is just a type alias, so we can't test it directly
+    // But we can verify it's exported and can be used as a type
+    const value: unsafe.IntegerType = 42
+    expect(typeof value).toBe('number')
+  })
+
+  it('should export ArbitraryType and Pointer types', () => {
+    // These are type aliases, so we can't test them directly
+    // But we can verify they can be used as types
+    const arbitrary: unsafe.ArbitraryType = 'anything'
+    const pointer: unsafe.Pointer = null
+    expect(arbitrary).toBe('anything')
+    expect(pointer).toBe(null)
+  })
+})

package/gs/unsafe/unsafe.ts

@@ -0,0 +1,77 @@
+// Package unsafe provides facilities for low-level programming including operations
+// that violate the type system. Most operations are not supported in JavaScript/TypeScript
+// and will throw errors when used.
+
+// ArbitraryType is a shorthand for an arbitrary Go type; it is not a real type
+export type ArbitraryType = any
+
+// Pointer is a pointer type but a Pointer value may not be dereferenced
+export type Pointer = any
+
+// IntegerType is a shorthand for an integer type; it is not a real type
+// This is the only type from unsafe that can be meaningfully implemented in JavaScript
+export type IntegerType = number
+
+// Alignof returns the alignment of the (type of the) variable in bytes
+// This operation is not meaningful in JavaScript/TypeScript
+export function Alignof(variable: ArbitraryType): number {
+  throw new Error(
+    'unsafe.Alignof is not supported in JavaScript/TypeScript: memory alignment is not a meaningful concept in JavaScript',
+  )
+}
+
+// Offsetof returns the field offset in bytes relative to the struct's address
+// This operation is not meaningful in JavaScript/TypeScript
+export function Offsetof(selector: ArbitraryType): number {
+  throw new Error(
+    'unsafe.Offsetof is not supported in JavaScript/TypeScript: memory layout and field offsets are not meaningful concepts in JavaScript',
+  )
+}
+
+// Sizeof returns the size of the (type of the) variable in bytes
+// This operation is not meaningful in JavaScript/TypeScript
+export function Sizeof(variable: ArbitraryType): number {
+  throw new Error(
+    'unsafe.Sizeof is not supported in JavaScript/TypeScript: memory size is not a meaningful concept in JavaScript',
+  )
+}
+
+// Add adds len to ptr and returns the updated pointer
+// Pointer arithmetic is not supported in JavaScript/TypeScript
+export function Add(ptr: Pointer, len: IntegerType): Pointer {
+  throw new Error(
+    'unsafe.Add is not supported in JavaScript/TypeScript: pointer arithmetic is not available in JavaScript',
+  )
+}
+
+// Slice returns a slice whose underlying array starts at ptr
+// This operation is not meaningful in JavaScript/TypeScript
+export function Slice(ptr: Pointer, len: IntegerType): any[] {
+  throw new Error(
+    'unsafe.Slice is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript',
+  )
+}
+
+// SliceData returns a pointer to the underlying array of the slice
+// This operation is not meaningful in JavaScript/TypeScript
+export function SliceData(slice: any[]): Pointer {
+  throw new Error(
+    'unsafe.SliceData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript',
+  )
+}
+
+// String returns a string value whose underlying bytes start at ptr
+// This operation is not meaningful in JavaScript/TypeScript
+export function String(ptr: Pointer, len: IntegerType): string {
+  throw new Error(
+    'unsafe.String is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript',
+  )
+}
+
+// StringData returns a pointer to the underlying bytes of the str
+// This operation is not meaningful in JavaScript/TypeScript
+export function StringData(str: string): Pointer {
+  throw new Error(
+    'unsafe.StringData is not supported in JavaScript/TypeScript: direct memory access is not available in JavaScript',
+  )
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "goscript",
   "description": "Go to TypeScript transpiler",
-  "version": "0.0.25",
+  "version": "0.0.28",
   "author": {
     "name": "Aperture Robotics LLC.",
     "email": "support@aperture.us",
@@ -42,13 +42,14 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "npm run build:updategover && tsc -p tsconfig.build.json",
+    "build:updategover": "node -e \"const fs = require('fs'); const { execSync } = require('child_process'); const goVersion = execSync('go mod edit -json', { encoding: 'utf8' }); const goData = JSON.parse(goVersion); const version = goData.Go; const runtimePath = 'gs/runtime/runtime.ts'; const content = fs.readFileSync(runtimePath, 'utf8'); const updatedContent = content.replace(/export const GOVERSION = 'go[^']*'/, \\`export const GOVERSION = 'go\\${version}'\\`); fs.writeFileSync(runtimePath, updatedContent);\"",
     "prepublishOnly": "npm run build",
     "example": "cd ./example/simple && bash run.bash",
     "test": "npm run test:go && npm run test:js",
     "test:go": "go test -v ./...",
     "test:js": "npm run typecheck && vitest run",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsgo --noEmit -p tsconfig.build.json",
     "format": "npm run format:go && npm run format:js && npm run format:config",
     "format:config": "prettier --write tsconfig.json package.json",
     "format:go": "gofumpt -w .",
@@ -70,7 +71,7 @@
     "dist",
     "cmd",
     "compiler",
-    "builtin",
+    "gs",
     "!compliance",
     "go.mod",
     "go.sum",
@@ -82,6 +83,7 @@
     "./{src,builtin,example}/**/(*.ts|*.tsx|*.html|*.css|*.scss)": "prettier --config .prettierrc.yaml --write"
   },
   "devDependencies": {
+    "@aptre/protobuf-es-lite": "^0.4.9",
     "@eslint/js": "^9.25.1",
     "@types/node": "^22.15.18",
     "@typescript-eslint/eslint-plugin": "^8.31.0",