goscript 0.0.13 → 0.0.16

package/dist/builtin/builtin.d.ts

@@ -1,45 +1,82 @@
 /**
- * Creates a new slice (TypeScript array) with the specified length and capacity.
- * @param len The length of the slice.
- * @param cap The capacity of the slice (optional).
- * @returns A new TypeScript array representing the slice.
+ * GoSliceObject contains metadata for complex slice views
  */
-export declare const makeSlice: <T>(len: number, cap?: number) => Array<T> & {
-    __capacity?: number;
+interface GoSliceObject<T> {
+    backing: T[];
+    offset: number;
+    length: number;
+    capacity: number;
+}
+/**
+ * SliceProxy is a proxy object for complex slices
+ */
+export type SliceProxy<T> = T[] & {
+    __meta__: GoSliceObject<T>;
 };
 /**
- * Creates a new slice header that shares the backing array.
+ * Slice<T> is a union type that is either a plain array or a proxy
+ * null represents the nil state.
+ */
+export type Slice<T> = T[] | SliceProxy<T> | null;
+export declare function asArray<T>(slice: Slice<T>): T[];
+/**
+ * Creates a new slice with the specified length and capacity.
+ * @param length The length of the slice.
+ * @param capacity The capacity of the slice (optional).
+ * @returns A new slice.
+ */
+export declare const makeSlice: <T>(length: number, capacity?: number) => Slice<T>;
+/**
+ * goSlice creates a slice from s[low:high:max]
  * Arguments mirror Go semantics; omitted indices are undefined.
  *
- * @param arr  The original slice/array produced by makeSlice or another slice
- * @param low  Starting index (defaults to 0)
- * @param high Ending index (defaults to arr.length)
- * @param max  Capacity limit (defaults to original capacity)
- */
-export declare const slice: <T>(arr: Array<T> & {
-    __capacity?: number;
-}, low?: number, high?: number, max?: number) => Array<T> & {
-    __capacity?: number;
-};
+ * @param s The original slice
+ * @param low Starting index (defaults to 0)
+ * @param high Ending index (defaults to s.length)
+ * @param max Capacity limit (defaults to original capacity)
+ */
+export declare const goSlice: <T>(s: Slice<T>, low?: number, high?: number, max?: number) => Slice<T>;
 /**
  * Creates a new map (TypeScript Map).
  * @returns A new TypeScript Map.
  */
 export declare const makeMap: <K, V>() => Map<K, V>;
 /**
- * Returns the length of a collection (string, array, or map).
- * @param collection The collection to get the length of.
+ * Converts a JavaScript array to a Go slice.
+ * For multi-dimensional arrays, recursively converts nested arrays to slices.
+ * @param arr The JavaScript array to convert
+ * @param depth How many levels of nesting to convert (default: 1, use Infinity for all levels)
+ * @returns A Go slice containing the same elements
+ */
+export declare const arrayToSlice: <T>(arr: T[] | null | undefined, depth?: number) => T[];
+/**
+ * Returns the length of a collection (string, array, slice, map, or set).
+ * @param obj The collection to get the length of.
  * @returns The length of the collection.
  */
-export declare const len: <T>(collection: string | Array<T> | Map<unknown, unknown>) => number;
+export declare const len: <T = unknown, V = unknown>(obj: string | Array<T> | Slice<T> | Map<T, V> | Set<T> | null | undefined) => number;
 /**
- * Returns the capacity of a slice (TypeScript array).
- * @param slice The slice (TypeScript array).
+ * Returns the capacity of a slice.
+ * @param obj The slice.
  * @returns The capacity of the slice.
  */
-export declare const cap: <T>(slice: Array<T> & {
-    __capacity?: number;
-}) => number;
+export declare const cap: <T>(obj: Slice<T>) => number;
+/**
+ * Appends elements to a slice.
+ * Note: In Go, append can return a new slice if the underlying array is reallocated.
+ * This helper emulates that by returning the modified or new slice.
+ * @param slice The slice to append to.
+ * @param elements The elements to append.
+ * @returns The modified or new slice.
+ */
+export declare const append: <T>(slice: Slice<T>, ...elements: T[]) => T[];
+/**
+ * Copies elements from src to dst.
+ * @param dst The destination slice.
+ * @param src The source slice.
+ * @returns The number of elements copied.
+ */
+export declare const copy: <T>(dst: Slice<T>, src: Slice<T>) => number;
 /**
  * Represents the Go error type (interface).
  */
@@ -57,7 +94,27 @@ export declare const stringToRunes: (str: string) => number[];
  * @param runes The input array of numbers representing Unicode code points.
  * @returns The resulting string.
  */
-export declare const runesToString: (runes: number[]) => string;
+export declare const runesToString: (runes: Slice<number>) => string;
+/**
+ * Converts a number to a byte (uint8) by truncating to the range 0-255.
+ * Equivalent to Go's byte() conversion.
+ * @param n The number to convert to a byte.
+ * @returns The byte value (0-255).
+ */
+export declare const byte: (n: number) => number;
+/** Box represents a Go variable which can be referred to by other variables.
+ *
+ * For example:
+ *   var myVariable int
+ *
+ */
+export type Box<T> = {
+    value: T;
+};
+/** Wrap a non-null T in a pointer‐box. */
+export declare function box<T>(v: T): Box<T>;
+/** Dereference a pointer‐box, throws on null → simulates Go panic. */
+export declare function unbox<T>(b: Box<T>): T;
 /**
  * Gets a value from a map, with a default value if the key doesn't exist.
  * @param map The map to get from.
@@ -86,53 +143,134 @@ export declare const deleteMapEntry: <K, V>(map: Map<K, V>, key: K) => void;
  * @returns True if the key exists, false otherwise.
  */
 export declare const mapHas: <K, V>(map: Map<K, V>, key: K) => boolean;
-/**
- * Appends elements to a slice (TypeScript array).
- * Note: In Go, append can return a new slice if the underlying array is reallocated.
- * This helper emulates that by returning the modified array.
- * @param slice The slice (TypeScript array) to append to.
- * @param elements The elements to append.
- * @returns The modified slice (TypeScript array).
- */
-export declare const append: <T>(slice: Array<T> & {
-    __capacity?: number;
-}, ...elements: T[]) => Array<T> & {
-    __capacity?: number;
-};
 /**
  * Represents the kinds of Go types that can be registered at runtime.
  */
 export declare enum TypeKind {
-    Struct = "struct",
-    Interface = "interface",
     Basic = "basic",
-    Pointer = "pointer",
-    Slice = "slice",
+    Interface = "interface",
+    Struct = "struct",
     Map = "map",
-    Channel = "channel",
-    Function = "function"
+    Slice = "slice",
+    Array = "array",
+    Pointer = "pointer",
+    Function = "function",
+    Channel = "channel"
 }
 /**
- * Represents type information for a Go type in the runtime.
+ * TypeInfo is used for runtime type checking.
+ * Can be a registered type (from typeRegistry) or an ad-hoc type description.
+ * When used as input to typeAssert, it can be a string (type name) or a structured description.
+ */
+/**
+ * Base type information shared by all type kinds
  */
-export interface TypeInfo {
-    name: string;
+export interface BaseTypeInfo {
+    name?: string;
     kind: TypeKind;
-    zeroValue: any;
-    methods?: Set<string>;
-    constructor?: new (...args: any[]) => any;
+    zeroValue?: any;
 }
 /**
- * Registers a type with the runtime type system.
+ * Type information for struct types
+ */
+export interface StructTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Struct;
+    methods: Set<string>;
+    ctor?: new (...args: any[]) => any;
+    fields?: Set<string>;
+    fieldTypes?: Record<string, TypeInfo | string>;
+}
+/**
+ * Type information for interface types
+ */
+export interface InterfaceTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Interface;
+    methods: Set<string>;
+}
+/**
+ * Type information for basic types (string, number, boolean)
+ */
+export interface BasicTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Basic;
+}
+/**
+ * Type information for map types
+ */
+export interface MapTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Map;
+    keyType?: string | TypeInfo;
+    elemType?: string | TypeInfo;
+}
+/**
+ * Type information for slice types
+ */
+export interface SliceTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Slice;
+    elemType?: string | TypeInfo;
+}
+/**
+ * Type information for array types
+ */
+export interface ArrayTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Array;
+    elemType?: string | TypeInfo;
+    length: number;
+}
+/**
+ * Type information for pointer types
+ */
+export interface PointerTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Pointer;
+    elemType?: string | TypeInfo;
+}
+/**
+ * Type information for function types
+ */
+export interface FunctionTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Function;
+    params?: (string | TypeInfo)[];
+    results?: (string | TypeInfo)[];
+}
+/**
+ * Type information for channel types
+ */
+export interface ChannelTypeInfo extends BaseTypeInfo {
+    kind: TypeKind.Channel;
+    elemType?: string | TypeInfo;
+    direction?: 'send' | 'receive' | 'both';
+}
+/**
+ * Union type representing all possible TypeInfo variants
+ */
+export type TypeInfo = StructTypeInfo | InterfaceTypeInfo | BasicTypeInfo | MapTypeInfo | SliceTypeInfo | ArrayTypeInfo | PointerTypeInfo | FunctionTypeInfo | ChannelTypeInfo;
+export declare function isStructTypeInfo(info: TypeInfo): info is StructTypeInfo;
+export declare function isInterfaceTypeInfo(info: TypeInfo): info is InterfaceTypeInfo;
+export declare function isBasicTypeInfo(info: TypeInfo): info is BasicTypeInfo;
+export declare function isMapTypeInfo(info: TypeInfo): info is MapTypeInfo;
+export declare function isSliceTypeInfo(info: TypeInfo): info is SliceTypeInfo;
+export declare function isArrayTypeInfo(info: TypeInfo): info is ArrayTypeInfo;
+export declare function isPointerTypeInfo(info: TypeInfo): info is PointerTypeInfo;
+export declare function isFunctionTypeInfo(info: TypeInfo): info is FunctionTypeInfo;
+export declare function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeInfo;
+/**
+ * Registers a struct type with the runtime type system.
  *
  * @param name The name of the type.
- * @param kind The kind of the type.
  * @param zeroValue The zero value for the type.
- * @param methods Optional set of method names for interfaces.
- * @param constructor Optional constructor for structs.
- * @returns The type information object for chaining.
+ * @param methods Set of method names for the struct.
+ * @param ctor Constructor for the struct.
+ * @returns The struct type information object.
  */
-export declare const registerType: (name: string, kind: TypeKind, zeroValue: any, methods?: Set<string>, constructor?: new (...args: any[]) => any) => TypeInfo;
+export declare const registerStructType: (name: string, zeroValue: any, methods: Set<string>, ctor: new (...args: any[]) => any) => StructTypeInfo;
+/**
+ * Registers an interface type with the runtime type system.
+ *
+ * @param name The name of the type.
+ * @param zeroValue The zero value for the type (usually null).
+ * @param methods Set of method names the interface requires.
+ * @returns The interface type information object.
+ */
+export declare const registerInterfaceType: (name: string, zeroValue: any, methods: Set<string>) => InterfaceTypeInfo;
 /**
  * Represents the result of a type assertion.
  */
@@ -140,14 +278,7 @@ export interface TypeAssertResult<T> {
     value: T;
     ok: boolean;
 }
-/**
- * Performs a type assertion at runtime.
- *
- * @param value The value to assert.
- * @param typeName The name of the target type.
- * @returns An object with the asserted value and whether the assertion succeeded.
- */
-export declare function typeAssert<T>(value: any, typeName: string): TypeAssertResult<T>;
+export declare function typeAssert<T>(value: any, typeInfo: string | TypeInfo): TypeAssertResult<T>;
 /**
  * Represents the result of a channel receive operation with 'ok' value
  */
@@ -251,7 +382,7 @@ export declare const makeChannel: <T>(bufferSize: number, zeroValue: T) => Chann
  * Implements the `Disposable` interface for use with `using` declarations.
  */
 export declare class DisposableStack implements Disposable {
-    #private;
+    private stack;
     /**
      * Adds a function to be executed when the stack is disposed.
      * @param fn The function to defer.
@@ -271,7 +402,7 @@ export declare class DisposableStack implements Disposable {
  * Implements the `AsyncDisposable` interface for use with `await using` declarations.
  */
 export declare class AsyncDisposableStack implements AsyncDisposable {
-    #private;
+    private stack;
     /**
      * Adds a synchronous or asynchronous function to be executed when the stack is disposed.
      * @param fn The function to defer. Can return void or a Promise<void>.
@@ -283,3 +414,9 @@ export declare class AsyncDisposableStack implements AsyncDisposable {
      */
     [Symbol.asyncDispose](): Promise<void>;
 }
+/**
+ * Implementation of Go's built-in println function
+ * @param args Arguments to print
+ */
+export declare function println(...args: any[]): void;
+export {};