goscript 0.0.21 → 0.0.23

package/dist/builtin/builtin.d.ts

@@ -1,495 +0,0 @@
-/**
- * GoSliceObject contains metadata for complex slice views
- */
-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>;
-};
-/**
- * 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 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>;
-/**
- * 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 = unknown, V = unknown>(obj: string | Array<T> | Slice<T> | Map<T, V> | Set<T> | null | undefined) => number;
-/**
- * Returns the capacity of a slice.
- * @param obj The slice.
- * @returns The capacity of the slice.
- */
-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).
- */
-export type GoError = {
-    Error(): string;
-} | null;
-/**
- * Converts a string to an array of Unicode code points (runes).
- * @param str The input string.
- * @returns An array of numbers representing the Unicode code points.
- */
-export declare const stringToRunes: (str: string) => number[];
-/**
- * Converts an array of Unicode code points (runes) to a string.
- * @param runes The input array of numbers representing Unicode code points.
- * @returns The resulting 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.
- * @param key The key to get.
- * @param defaultValue The default value to return if the key doesn't exist (defaults to 0).
- * @returns The value for the key, or the default value if the key doesn't exist.
- */
-export declare const mapGet: <K, V>(map: Map<K, V>, key: K, defaultValue?: V | null) => V | null;
-/**
- * Sets a value in a map.
- * @param map The map to set in.
- * @param key The key to set.
- * @param value The value to set.
- */
-export declare const mapSet: <K, V>(map: Map<K, V>, key: K, value: V) => void;
-/**
- * Deletes a key from a map.
- * @param map The map to delete from.
- * @param key The key to delete.
- */
-export declare const deleteMapEntry: <K, V>(map: Map<K, V>, key: K) => void;
-/**
- * Checks if a key exists in a map.
- * @param map The map to check in.
- * @param key The key to check.
- * @returns True if the key exists, false otherwise.
- */
-export declare const mapHas: <K, V>(map: Map<K, V>, key: K) => boolean;
-/**
- * Represents the kinds of Go types that can be registered at runtime.
- */
-export declare enum TypeKind {
-    Basic = "basic",
-    Interface = "interface",
-    Struct = "struct",
-    Map = "map",
-    Slice = "slice",
-    Array = "array",
-    Pointer = "pointer",
-    Function = "function",
-    Channel = "channel"
-}
-/**
- * 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 BaseTypeInfo {
-    name?: string;
-    kind: TypeKind;
-    zeroValue?: any;
-}
-/**
- * Type information for struct types
- */
-export interface StructTypeInfo extends BaseTypeInfo {
-    kind: TypeKind.Struct;
-    methods: Set<string>;
-    ctor?: new (...args: any[]) => any;
-    fields: 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 zeroValue The zero value for the type.
- * @param methods Set of method names for the struct.
- * @param ctor Constructor for the struct.
- * @returns The struct type information object.
- */
-export declare const registerStructType: (name: string, zeroValue: any, methods: Set<string>, ctor: new (...args: any[]) => any, fields?: Record<string, TypeInfo | string>) => 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.
- */
-export interface TypeAssertResult<T> {
-    value: T;
-    ok: boolean;
-}
-export declare function typeAssert<T>(value: any, typeInfo: string | TypeInfo): TypeAssertResult<T>;
-/**
- * Represents the result of a channel receive operation with 'ok' value
- */
-export interface ChannelReceiveResult<T> {
-    value: T;
-    ok: boolean;
-}
-/**
- * Represents a result from a select operation
- */
-export interface SelectResult<T> {
-    value: T;
-    ok: boolean;
-    id: number;
-}
-/**
- * Represents a Go channel in TypeScript.
- * Supports asynchronous sending and receiving of values.
- */
-export interface Channel<T> {
-    /**
-     * Sends a value to the channel.
-     * Returns a promise that resolves when the value is accepted by the channel.
-     * @param value The value to send.
-     */
-    send(value: T): Promise<void>;
-    /**
-     * Receives a value from the channel.
-     * Returns a promise that resolves with the received value.
-     * If the channel is closed, it throws an error.
-     */
-    receive(): Promise<T>;
-    /**
-     * Receives a value from the channel along with a boolean indicating
-     * whether the channel is still open.
-     * Returns a promise that resolves with {value, ok}.
-     * - If channel is open and has data: {value: <data>, ok: true}
-     * - If channel is closed and empty: {value: <zero value>, ok: false}
-     * - If channel is closed but has remaining buffered data: {value: <data>, ok: true}
-     */
-    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
-    /**
-     * Closes the channel.
-     * No more values can be sent to a closed channel.
-     * Receive operations on a closed channel return the zero value and ok=false.
-     */
-    close(): void;
-    /**
-     * Used in select statements to create a receive operation promise.
-     * @param id An identifier for this case in the select statement
-     * @returns Promise that resolves when this case is selected
-     */
-    selectReceive(id: number): Promise<SelectResult<T>>;
-    /**
-     * Used in select statements to create a send operation promise.
-     * @param value The value to send
-     * @param id An identifier for this case in the select statement
-     * @returns Promise that resolves when this case is selected
-     */
-    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
-    /**
-     * Checks if the channel has data ready to be received without blocking.
-     * Used for non-blocking select operations.
-     */
-    canReceiveNonBlocking(): boolean;
-    /**
-     * Checks if the channel can accept a send operation without blocking.
-     * Used for non-blocking select operations.
-     */
-    canSendNonBlocking(): boolean;
-}
-/**
- * Represents a reference to a channel with a specific direction.
- */
-export interface ChannelRef<T> {
-    /**
-     * The underlying channel
-     */
-    channel: Channel<T>;
-    /**
-     * The direction of this channel reference
-     */
-    direction: 'send' | 'receive' | 'both';
-    send(value: T): Promise<void>;
-    receive(): Promise<T>;
-    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
-    close(): void;
-    canSendNonBlocking(): boolean;
-    canReceiveNonBlocking(): boolean;
-    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
-    selectReceive(id: number): Promise<SelectResult<T>>;
-}
-/**
- * A bidirectional channel reference.
- */
-export declare class BidirectionalChannelRef<T> implements ChannelRef<T> {
-    channel: Channel<T>;
-    direction: 'both';
-    constructor(channel: Channel<T>);
-    send(value: T): Promise<void>;
-    receive(): Promise<T>;
-    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
-    close(): void;
-    canSendNonBlocking(): boolean;
-    canReceiveNonBlocking(): boolean;
-    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
-    selectReceive(id: number): Promise<SelectResult<T>>;
-}
-/**
- * A send-only channel reference.
- */
-export declare class SendOnlyChannelRef<T> implements ChannelRef<T> {
-    channel: Channel<T>;
-    direction: 'send';
-    constructor(channel: Channel<T>);
-    send(value: T): Promise<void>;
-    close(): void;
-    canSendNonBlocking(): boolean;
-    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
-    receive(): Promise<T>;
-    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
-    canReceiveNonBlocking(): boolean;
-    selectReceive(id: number): Promise<SelectResult<T>>;
-}
-/**
- * A receive-only channel reference.
- */
-export declare class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
-    channel: Channel<T>;
-    direction: 'receive';
-    constructor(channel: Channel<T>);
-    receive(): Promise<T>;
-    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
-    canReceiveNonBlocking(): boolean;
-    selectReceive(id: number): Promise<SelectResult<T>>;
-    send(value: T): Promise<void>;
-    close(): void;
-    canSendNonBlocking(): boolean;
-    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
-}
-/**
- * Creates a new channel reference with the specified direction.
- */
-export declare function makeChannelRef<T>(channel: Channel<T>, direction: 'send' | 'receive' | 'both'): ChannelRef<T>;
-/**
- * Represents a case in a select statement.
- */
-export interface SelectCase<T> {
-    id: number;
-    isSend: boolean;
-    channel: Channel<any> | ChannelRef<any> | null;
-    value?: any;
-    onSelected?: (result: SelectResult<T>) => Promise<void>;
-}
-/**
- * Helper for 'select' statements. Takes an array of select cases
- * and resolves when one of them completes, following Go's select rules.
- *
- * @param cases Array of SelectCase objects
- * @param hasDefault Whether there is a default case
- * @returns A promise that resolves with the result of the selected case
- */
-export declare function selectStatement<T>(cases: SelectCase<T>[], hasDefault?: boolean): Promise<void>;
-/**
- * Creates a new channel with the specified buffer size and zero value.
- * @param bufferSize The size of the channel buffer. If 0, creates an unbuffered channel.
- * @param zeroValue The zero value for the channel's element type.
- * @param direction Optional direction for the channel. Default is 'both' (bidirectional).
- * @returns A new channel instance or channel reference.
- */
-export declare const makeChannel: <T>(bufferSize: number, zeroValue: T, direction?: "send" | "receive" | "both") => Channel<T> | ChannelRef<T>;
-/**
- * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.
- * Functions added via `defer` are executed in LIFO order when the stack is disposed.
- * Implements the `Disposable` interface for use with `using` declarations.
- */
-export declare class DisposableStack implements Disposable {
-    private stack;
-    /**
-     * Adds a function to be executed when the stack is disposed.
-     * @param fn The function to defer.
-     */
-    defer(fn: () => void): void;
-    /**
-     * Disposes of the resources in the stack by executing the deferred functions
-     * in Last-In, First-Out (LIFO) order.
-     * If a deferred function throws an error, disposal stops, and the error is rethrown,
-     * similar to Go's panic behavior during defer execution.
-     */
-    [Symbol.dispose](): void;
-}
-/**
- * AsyncDisposableStack manages asynchronous disposable resources, mimicking Go's defer behavior.
- * Functions added via `defer` are executed sequentially in LIFO order when the stack is disposed.
- * Implements the `AsyncDisposable` interface for use with `await using` declarations.
- */
-export declare class AsyncDisposableStack implements AsyncDisposable {
-    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>.
-     */
-    defer(fn: () => Promise<void> | void): void;
-    /**
-     * Asynchronously disposes of the resources in the stack by executing the deferred functions
-     * sequentially in Last-In, First-Out (LIFO) order. It awaits each function if it returns a promise.
-     */
-    [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 {};