goscript 0.0.81 → 0.0.83

package/gs/os/root_js.gs.ts

@@ -1,77 +1,116 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrUnimplemented } from "./error.gs.js";
+import { ErrInvalid } from "./error.gs.js";
+import { Create, Mkdir, Open, OpenFile, Remove } from "./file_js.gs.js";
+import { Lstat as lstatPath, Stat as statPath } from "./stat_js.gs.js";
 import { File } from "./types_js.gs.js";
 
 import * as fs from "@goscript/io/fs/index.js"
+import { ValidPath } from "@goscript/io/fs/index.js"
 
-// JavaScript-specific implementations for root filesystem operations
-// These functions stub operations that cannot be implemented in JavaScript
+function isValidRootName(name: string): boolean {
+	if (name === ".") {
+		return true
+	}
+	return ValidPath(name)
+}
+
+function joinRootPath(dir: string, name: string): [string, $.GoError] {
+	if (!isValidRootName(name)) {
+		return ["", ErrInvalid]
+	}
+	if (name === ".") {
+		return [dir, null]
+	}
+	return [dir.replace(/\/+$/, "") + "/" + name, null]
+}
 
-// OpenInRoot opens the file name in the directory dir - stub implementation
 export function OpenInRoot(dir: string, name: string): [File | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	const [path, err] = joinRootPath(dir, name)
+	if (err !== null) {
+		return [null, err]
+	}
+	return Open(path)
 }
 
-// Root represents a root filesystem - stub implementation
 export class Root {
-	constructor() {}
+	public name: string
+
+	constructor(init?: Partial<{name?: string}>) {
+		this.name = init?.name ?? "."
+	}
 
-	// Name returns the name of the directory presented to OpenRoot
 	public Name(): string {
-		return ""
+		return this.name
 	}
 
-	// Close closes the Root
 	public Close(): $.GoError {
-		return ErrUnimplemented
+		return null
 	}
 
-	// Open opens the named file in the root for reading
 	public Open(name: string): [File | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		return OpenInRoot(this.name, name)
 	}
 
-	// Create creates or truncates the named file in the root
 	public Create(name: string): [File | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return [null, err]
+		}
+		return Create(path)
 	}
 
-	// OpenFile opens the named file in the root
 	public OpenFile(name: string, flag: number, perm: number): [File | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return [null, err]
+		}
+		return OpenFile(path, flag, perm)
 	}
 
-	// OpenRoot opens the named directory in the root
 	public OpenRoot(name: string): [RootType | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return [null, err]
+		}
+		return OpenRoot(path)
 	}
 
-	// Mkdir creates a new directory in the root
 	public Mkdir(name: string, perm: number): $.GoError {
-		return ErrUnimplemented
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return err
+		}
+		return Mkdir(path, perm)
 	}
 
-	// Remove removes the named file or directory in the root
 	public Remove(name: string): $.GoError {
-		return ErrUnimplemented
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return err
+		}
+		return Remove(path)
 	}
 
-	// Stat returns a FileInfo describing the named file in the root
 	public Stat(name: string): [fs.FileInfo | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return [null, err]
+		}
+		return statPath(path)
 	}
 
-	// Lstat returns a FileInfo describing the named file in the root
 	public Lstat(name: string): [fs.FileInfo | null, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [path, err] = joinRootPath(this.name, name)
+		if (err !== null) {
+			return [null, err]
+		}
+		return lstatPath(path)
 	}
 
-	// FS returns a file system for the tree of files in the root
 	public FS(): fs.FS {
-		return new stubFS()
+		return new rootFS({ root: this })
 	}
 
-	// Register this type with the runtime type system
 	static __typeInfo = $.registerStructType(
 		'Root',
 		new Root(),
@@ -80,32 +119,45 @@ export class Root {
 			{ name: "Close", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
 		],
 		Root,
-		{}
+		{ "name": { kind: $.TypeKind.Basic, name: "string" } }
 	);
 }
 
-// Type alias to avoid conflicts
 export type RootType = Root
 
-// OpenRoot opens a root filesystem - stub implementation
 export function OpenRoot(name: string): [Root | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	const [info, err] = statPath(name)
+	if (err !== null) {
+		return [null, err]
+	}
+	if (!info?.IsDir()) {
+		return [null, ErrInvalid]
+	}
+	return [new Root({ name }), null]
 }
 
-// splitPathInRoot splits a path in root - stub implementation
 export function splitPathInRoot(s: string, prefix: $.Slice<string> | null, suffix: $.Slice<string> | null): [$.Slice<string>, string, $.GoError] {
-	return [null, "", ErrUnimplemented]
+	if (!isValidRootName(s)) {
+		return [null, "", ErrInvalid]
+	}
+	const parts = s === "." ? [] : s.split("/").filter((part) => part !== "")
+	const head = $.arrayToSlice<string>(parts.slice(0, Math.max(0, parts.length - 1)))
+	const tail = parts.length === 0 ? "." : parts[parts.length - 1]
+	return [head, tail, null]
 }
 
-// isValidRootFSPath checks if a path is valid for root filesystem - stub implementation
 export function isValidRootFSPath(name: string): boolean {
-	return false
+	return isValidRootName(name)
 }
 
-// Internal stub filesystem
-class stubFS {
+class rootFS {
+	public root: Root
+
+	constructor(init?: Partial<{root?: Root}>) {
+		this.root = init?.root ?? new Root()
+	}
+
 	public Open(name: string): [fs.File, $.GoError] {
-		return [null, ErrUnimplemented]
+		return this.root.Open(name)
 	}
 }
-

package/gs/os/root_noopenat.gs.ts

@@ -1,45 +1,38 @@
 import * as $ from "@goscript/builtin/index.js";
-import { underlyingError, ErrUnimplemented } from "./error.gs.js";
-import { Root } from "./root_js.gs.js";
+import { Mkdir, OpenFile, Remove } from "./file_js.gs.js";
+import { Root, OpenRoot } from "./root_js.gs.js";
+import { Lstat, Stat } from "./stat_js.gs.js";
 import { File } from "./types_js.gs.js";
 
-import * as errors from "@goscript/errors/index.js"
 import * as fs from "@goscript/io/fs/index.js"
 
-// Stub functions for JavaScript environment - these operations cannot be implemented properly
-
-// openRootNolog is OpenRoot - stub implementation
 export function openRootNolog(name: string): [Root | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return OpenRoot(name)
 }
 
-// openRootInRoot is Root.OpenRoot - stub implementation  
 export function openRootInRoot(r: Root | null, name: string): [Root | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return r?.OpenRoot(name) ?? [null, null]
 }
 
-// newRoot returns a new Root - stub implementation
 export function newRoot(name: string): [Root | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return OpenRoot(name)
 }
 
-// rootOpenFileNolog is Root.OpenFile - stub implementation
 export function rootOpenFileNolog(r: Root | null, name: string, flag: number, perm: number): [File | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return r?.OpenFile(name, flag, perm) ?? OpenFile(name, flag, perm)
 }
 
-// rootStat - stub implementation
 export function rootStat(r: Root | null, name: string, lstat: boolean): [fs.FileInfo | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	if (r !== null) {
+		return lstat ? r.Lstat(name) : r.Stat(name)
+	}
+	return lstat ? Lstat(name) : Stat(name)
 }
 
-// rootMkdir - stub implementation  
 export function rootMkdir(r: Root | null, name: string, perm: number): $.GoError {
-	return ErrUnimplemented
+	return r?.Mkdir(name, perm) ?? Mkdir(name, perm)
 }
 
-// rootRemove - stub implementation
 export function rootRemove(r: Root | null, name: string): $.GoError {
-	return ErrUnimplemented
+	return r?.Remove(name) ?? Remove(name)
 }
-

package/gs/os/stat_js.gs.ts

@@ -1,13 +1,28 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
+import { createFileInfo, getDeno, getNodeFS, newHostError } from "./types_js.gs.js";
 
 import * as fs from "@goscript/io/fs/index.js"
 
-// JavaScript-specific stubs for stat operations
-
 // Stat returns a [FileInfo] describing the named file.
 // If there is an error, it will be of type [*PathError].
 export function Stat(name: string): [fs.FileInfo, $.GoError] {
+	const denoObj = getDeno()
+	if (denoObj?.statSync) {
+		try {
+			return [createFileInfo(name, denoObj.statSync(name)), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.statSync) {
+		try {
+			return [createFileInfo(name, nodeFS.statSync(name)), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
 	return [null, ErrUnimplemented]
 }
 
@@ -16,15 +31,31 @@ export function Stat(name: string): [fs.FileInfo, $.GoError] {
 // describes the symbolic link. Lstat makes no attempt to follow the link.
 // If there is an error, it will be of type [*PathError].
 export function Lstat(name: string): [fs.FileInfo, $.GoError] {
-	return [null, ErrUnimplemented]
+	const denoObj = getDeno()
+	if (denoObj?.lstatSync) {
+		try {
+			return [createFileInfo(name, denoObj.lstatSync(name)), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.lstatSync) {
+		try {
+			return [createFileInfo(name, nodeFS.lstatSync(name)), null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	return Stat(name)
 }
 
 // statNolog is the same as Stat, for use in DirFS.
 export function statNolog(name: string): [fs.FileInfo, $.GoError] {
-	return [null, ErrUnimplemented]
+	return Stat(name)
 }
 
 // lstatNolog is the same as Lstat, for use in DirFS.
 export function lstatNolog(name: string): [fs.FileInfo, $.GoError] {
-	return [null, ErrUnimplemented]
-} 
+	return Lstat(name)
+}

package/gs/os/stat_unix_js.gs.ts

@@ -1,27 +1,20 @@
 import * as $ from "@goscript/builtin/index.js";
-import { ErrUnimplemented } from "./error.gs.js";
+import { lstatNolog as lstatPath, statNolog as statPath } from "./stat_js.gs.js";
 
 import * as fs from "@goscript/io/fs/index.js"
 
-// JavaScript-specific stub implementations for Unix stat operations
-// These operations cannot be implemented in JavaScript environments
-
-// statNolog stats a file with no test logging - stub implementation
 export function statNolog(name: string): [fs.FileInfo | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return statPath(name)
 }
 
-// lstatNolog lstats a file with no test logging - stub implementation  
 export function lstatNolog(name: string): [fs.FileInfo | null, $.GoError] {
-	return [null, ErrUnimplemented]
+	return lstatPath(name)
 }
 
-// Additional compatibility exports
-export function fillFileStatFromSys(fs: any, name: string): void {
-	// No-op in JavaScript
+export function fillFileStatFromSys(fileInfo: any, name: string): void {
+	// No-op in JavaScript.
 }
 
-// fileStat stub for compatibility
 export interface fileStat {
 	sys: any
-} 
+}

package/gs/os/tempfile.gs.ts

@@ -1,8 +1,9 @@
 import * as $ from "@goscript/builtin/index.js";
 import { ErrUnimplemented } from "./error.gs.js";
-import { File } from "./types.gs.js";
+import { TempDir } from "./file_constants_js.gs.js";
+import { Create, Mkdir } from "./file_js.gs.js";
+import { File } from "./types_js.gs.js";
 
-// joinPath joins directory and file paths - simplified implementation for JavaScript
 export function joinPath(dir: string, file: string): string {
   if (dir === "" || dir === ".") {
     return file
@@ -10,25 +11,42 @@ export function joinPath(dir: string, file: string): string {
   if (file === "") {
     return dir
   }
-  // Remove trailing slash from dir if present
   if (dir.endsWith("/")) {
     dir = dir.slice(0, -1)
   }
-  // Remove leading slash from file if present  
   if (file.startsWith("/")) {
     file = file.slice(1)
   }
   return dir + "/" + file
 }
 
-// CreateTemp creates a new temporary file in the directory dir.
-// Stubbed implementation for JavaScript environment.
+function nextTempPath(dir: string, pattern: string): string {
+  const baseDir = dir === "" ? TempDir() : dir
+  const suffix = Math.random().toString(36).slice(2, 10) + Date.now().toString(36)
+  const name = pattern.includes("*") ? pattern.replace("*", suffix) : pattern + suffix
+  return joinPath(baseDir, name)
+}
+
 export function CreateTemp(dir: string, pattern: string): [File | null, $.GoError] {
+  const template = pattern === "" ? "tmp-*" : pattern
+  for (let i = 0; i < 16; i++) {
+    const path = nextTempPath(dir, template)
+    const [file, err] = Create(path)
+    if (err === null) {
+      return [file, null]
+    }
+  }
   return [null, ErrUnimplemented]
 }
 
-// MkdirTemp creates a new temporary directory.
-// Stubbed implementation for JavaScript environment.
 export function MkdirTemp(dir: string, pattern: string): [string, $.GoError] {
+  const template = pattern === "" ? "tmp-*" : pattern
+  for (let i = 0; i < 16; i++) {
+    const path = nextTempPath(dir, template)
+    const err = Mkdir(path, 0o700)
+    if (err === null) {
+      return [path, null]
+    }
+  }
   return ["", ErrUnimplemented]
-} 
+}