sharedthread 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,272 @@
+import { Transferable, Worker, MessagePort, WorkerOptions } from 'node:worker_threads';
+export { isMainThread } from 'node:worker_threads';
+import { EventEmitter } from 'node:events';
+
+declare class SharedHeap {
+    private static heaps;
+    static getHeapByID(i: number): SharedHeap;
+    private readonly _heapID;
+    private readonly _heapSize;
+    private readonly _buffer;
+    private readonly _view;
+    private static readonly SHIFT_TYPEID;
+    private static readonly SHIFT_ARRAY;
+    private static readonly SHIFT_PTR;
+    private static readonly SHIFT_ALLOC;
+    private static readonly MASK_TYPEID;
+    private static readonly MASK_ARRAY;
+    private static readonly MASK_PTR;
+    private static readonly MASK_ALLOC;
+    constructor(b: number | SharedArrayBuffer, heapID?: number);
+    get heapID(): number;
+    get view(): DataView;
+    get heapSize(): number;
+    get buffer(): SharedArrayBuffer;
+    get listHead(): number;
+    set listHead(offset: number);
+    private getHeaderSize;
+    getHeaderAllocated(offset: number): number;
+    private writeHeader;
+    syncFreeList(): void;
+    allocate(requestedSize: number, typeID: number, isPtr?: boolean, isArray?: boolean): number;
+    free(ptr: number): void;
+    private addFreeNodeToFront;
+    getTypeIDAt(ptr: number): number;
+    getAllocAt(ptr: number): number;
+    getPtrAt(ptr: number): number;
+    getArrayAt(ptr: number): number;
+    private removeFreeNode;
+    private replaceFreeNode;
+}
+
+interface SharedPrimitiveStatic<T> {
+    typeID: number;
+    byteSize: number;
+    isPtr: boolean;
+    isArr: boolean;
+    fromData(heap: SharedHeap, v: any): SharedPrimitive<T>;
+    new (heap: SharedHeap, addr: number): SharedPrimitive<T>;
+}
+declare abstract class SharedPrimitive<T> extends SharedType {
+    static typeID: number;
+    static readonly byteSize: number;
+    static readonly isPtr: boolean;
+    static readonly isArr: boolean;
+    abstract set value(v: T);
+    abstract get value(): T;
+}
+type SharedPrimitiveClass<T> = SharedPrimitiveStatic<T>;
+
+interface SharedReferenceStatic {
+    typeID: number;
+    isPtr: boolean;
+    isArr: boolean;
+    readonly byteSize: number;
+    fromData<T extends SharedReference>(heap: SharedHeap, v: any): T;
+    new (heap: SharedHeap, addr: number): SharedReference;
+}
+declare abstract class SharedReference extends SharedType {
+    static typeID: number;
+    static readonly isPtr: boolean;
+    static readonly isArr: boolean;
+    abstract get byteSize(): number;
+}
+type SharedReferenceClass = SharedReferenceStatic;
+
+interface SharedType {
+    typeID: number;
+}
+declare abstract class SharedType {
+    protected _addr: number;
+    protected _heap: SharedHeap;
+    constructor(heap: SharedHeap, addr: number);
+    get addr(): number;
+    get heap(): SharedHeap;
+}
+type SharedTypeClass = SharedReferenceClass | SharedPrimitiveClass<any>;
+
+declare class TypeRegistry {
+    private static indexToType;
+    private static typeToIndex;
+    private static hashToType;
+    private static typeToHash;
+    private static indexToHash;
+    static fnv1(str: string): number;
+    static registerType(dataType: SharedTypeClass): number;
+    static getTypeBuffer(): ArrayBuffer;
+    static verifyTypeBuffer(typeBuffer: ArrayBuffer): void;
+    static getTypeByIndex(index: number): SharedTypeClass;
+    static getTypeByHash(hash: number): SharedTypeClass;
+    static getIndexByType(type: SharedTypeClass): number;
+    static getHashByType(type: SharedTypeClass): number;
+    private constructor();
+}
+
+type VariableDeclaration = {
+    type: SharedPrimitiveClass<any>;
+    param?: any;
+} | {
+    type: SharedReferenceClass;
+    param: any;
+};
+declare class SharedStruct extends SharedReference {
+    static fromData<T extends SharedStruct>(this: (new (heap: SharedHeap, addr: number) => T) & SharedReferenceStatic, heap: SharedHeap, param: any): T;
+    static readonly properties: Record<string, VariableDeclaration>;
+    protected _byteSize: number;
+    protected properties: Record<string, SharedType>;
+    constructor(heap: SharedHeap, addr: number);
+    imprint(obj?: Record<string, any>): void;
+    static get byteSize(): number;
+    get byteSize(): number;
+}
+
+declare class SharedArray<T extends SharedType> extends SharedReference {
+    static readonly isArr: boolean;
+    static readonly properties: Record<string, VariableDeclaration>;
+    static fromData<U extends SharedReference>(heap: SharedHeap, v: any): U;
+    protected readonly _heldType: SharedTypeClass;
+    protected readonly _elementType: SharedTypeClass;
+    protected readonly _elementSize: number;
+    protected readonly _byteSize: number;
+    protected readonly _length: number;
+    protected readonly elements: T[];
+    constructor(heap: SharedHeap, addr: number);
+    get addr(): number;
+    get heap(): SharedHeap;
+    get heldType(): SharedTypeClass;
+    get elementType(): SharedTypeClass;
+    get elementSize(): number;
+    static get byteSize(): number;
+    get byteSize(): number;
+    get length(): number;
+}
+
+interface PointerDefinition {
+    type: SharedTypeClass;
+    addr?: number;
+}
+declare class SharedPointer<T extends SharedType> extends SharedPrimitive<any> {
+    static readonly byteSize: number;
+    static readonly isPtr: boolean;
+    static fromData(heap: SharedHeap, v: PointerDefinition): SharedPointer<SharedType>;
+    protected readonly _heldType: SharedTypeClass;
+    protected _deref: SharedType | null;
+    constructor(heap: SharedHeap, addr: number, dataType?: SharedTypeClass);
+    get heldType(): SharedTypeClass;
+    get addr(): number;
+    get heap(): SharedHeap;
+    set value(p: number);
+    get value(): number;
+    set deref(v: T);
+    get deref(): T;
+}
+
+type int32 = number & {
+    __brand: "int32";
+};
+declare function Int32(value: number): int32;
+declare class SharedInt32 extends SharedPrimitive<int32> {
+    static readonly byteSize: number;
+    static fromData(heap: SharedHeap, v: int32): SharedInt32;
+    set value(v: int32);
+    get value(): int32;
+}
+
+type uint32 = number & {
+    __brand: "uint32";
+};
+declare function Uint32(value: number): uint32;
+declare class SharedUint32 extends SharedPrimitive<uint32> {
+    static readonly byteSize: number;
+    static fromData(heap: SharedHeap, v: uint32): SharedUint32;
+    set value(v: uint32);
+    get value(): uint32;
+}
+
+interface WorkerMessageData {
+    tag: "message";
+    label: string;
+    data: any;
+}
+interface WorkerMessageSync {
+    tag: "sync";
+    name: string;
+    buffer: SharedArrayBuffer | null;
+    heapID: number;
+    rebound: boolean;
+}
+interface WorkerMessageAllocate {
+    tag: "assign";
+    name: string;
+    heapID: number;
+    addr: number;
+    rebound: boolean;
+}
+type WorkerMessage = WorkerMessageData | WorkerMessageSync | WorkerMessageAllocate;
+type ThreadEvent = {
+    internalmessage: [WorkerMessage];
+    message: [data: any, label: string];
+    sync: [name: string, buffer: SharedArrayBuffer | null, heapID: number, rebound: boolean];
+    assign: [name: string, heapID: number, addr: number, rebound: boolean];
+    error: [err: Error];
+    messageerror: [err: Error];
+    online: [];
+    exit: [exitCode: number];
+};
+interface ThreadStatic {
+    sendToThread(threadId: number, data: any, label: string | null): void;
+    transferToThread(threadId: number, data: any, transferList: Transferable[], label: string | null): void;
+}
+interface UnifiedPort {
+    postMessage(value: any, transferList?: ReadonlyArray<any>): void;
+}
+type PortHandle = (Worker | MessagePort) & EventEmitter & UnifiedPort;
+interface ThreadConfig {
+    transient?: boolean;
+    logLevel?: 0 | 1 | 2;
+    timeout?: number | undefined;
+    useTypescript?: boolean;
+    workerOptions?: WorkerOptions;
+}
+declare abstract class Thread extends EventEmitter<ThreadEvent> {
+    static sendToThread(threadId: number, data: any, label?: string | null): Promise<void>;
+    static transferToThread(threadId: number, data: any, transferList: Transferable[], label?: string | null): Promise<void>;
+    protected port: PortHandle;
+    protected config: ThreadConfig;
+    constructor(port: PortHandle, config?: ThreadConfig);
+    send(data: any, label?: string | null): void;
+    sendWithTransfer(data: any, transferList: Transferable[], label?: string | null): void;
+    request(data: any, label?: string | null): Promise<any>;
+    listenOnce(cb: Function, label?: string | null): void;
+    listenAll(cb: Function, label?: string | null): void;
+    respondOnce(cb: Function, label?: string | null): void;
+    respondAll(cb: Function, label?: string | null): void;
+    addHeap(heap: SharedHeap | SharedArrayBuffer, name: string): Promise<void>;
+    syncHeap(name: string): Promise<SharedHeap>;
+    addVar(data: SharedType, name: string): Promise<void>;
+    syncVar(name: string): Promise<SharedType>;
+}
+
+declare class MainThread extends Thread {
+    static get optimalTypeRegistrys(): number;
+    private worker;
+    private active;
+    constructor(path: string | Function, config?: ThreadConfig);
+    ready(): Promise<void>;
+    terminate(): Promise<number>;
+    private err;
+    get isActive(): boolean;
+    ref(): void;
+    unref(): void;
+}
+
+declare class WorkerThread extends Thread {
+    private _workerData;
+    constructor();
+    get workerData(): any;
+    private err;
+}
+
+declare const WorkerThreadExport: WorkerThread;
+
+export { Int32, MainThread, type PortHandle, SharedArray, SharedHeap, SharedInt32, SharedPointer, SharedPrimitive, type SharedPrimitiveClass, type SharedPrimitiveStatic, SharedReference, type SharedReferenceClass, type SharedReferenceStatic, SharedStruct, SharedType, type SharedTypeClass, SharedUint32, Thread, type ThreadConfig, type ThreadEvent, type ThreadStatic, TypeRegistry, Uint32, type VariableDeclaration, type WorkerMessage, WorkerThreadExport as WorkerThread, type int32, type uint32 };

package/dist/index.d.ts

@@ -0,0 +1,272 @@
+import { Transferable, Worker, MessagePort, WorkerOptions } from 'node:worker_threads';
+export { isMainThread } from 'node:worker_threads';
+import { EventEmitter } from 'node:events';
+
+declare class SharedHeap {
+    private static heaps;
+    static getHeapByID(i: number): SharedHeap;
+    private readonly _heapID;
+    private readonly _heapSize;
+    private readonly _buffer;
+    private readonly _view;
+    private static readonly SHIFT_TYPEID;
+    private static readonly SHIFT_ARRAY;
+    private static readonly SHIFT_PTR;
+    private static readonly SHIFT_ALLOC;
+    private static readonly MASK_TYPEID;
+    private static readonly MASK_ARRAY;
+    private static readonly MASK_PTR;
+    private static readonly MASK_ALLOC;
+    constructor(b: number | SharedArrayBuffer, heapID?: number);
+    get heapID(): number;
+    get view(): DataView;
+    get heapSize(): number;
+    get buffer(): SharedArrayBuffer;
+    get listHead(): number;
+    set listHead(offset: number);
+    private getHeaderSize;
+    getHeaderAllocated(offset: number): number;
+    private writeHeader;
+    syncFreeList(): void;
+    allocate(requestedSize: number, typeID: number, isPtr?: boolean, isArray?: boolean): number;
+    free(ptr: number): void;
+    private addFreeNodeToFront;
+    getTypeIDAt(ptr: number): number;
+    getAllocAt(ptr: number): number;
+    getPtrAt(ptr: number): number;
+    getArrayAt(ptr: number): number;
+    private removeFreeNode;
+    private replaceFreeNode;
+}
+
+interface SharedPrimitiveStatic<T> {
+    typeID: number;
+    byteSize: number;
+    isPtr: boolean;
+    isArr: boolean;
+    fromData(heap: SharedHeap, v: any): SharedPrimitive<T>;
+    new (heap: SharedHeap, addr: number): SharedPrimitive<T>;
+}
+declare abstract class SharedPrimitive<T> extends SharedType {
+    static typeID: number;
+    static readonly byteSize: number;
+    static readonly isPtr: boolean;
+    static readonly isArr: boolean;
+    abstract set value(v: T);
+    abstract get value(): T;
+}
+type SharedPrimitiveClass<T> = SharedPrimitiveStatic<T>;
+
+interface SharedReferenceStatic {
+    typeID: number;
+    isPtr: boolean;
+    isArr: boolean;
+    readonly byteSize: number;
+    fromData<T extends SharedReference>(heap: SharedHeap, v: any): T;
+    new (heap: SharedHeap, addr: number): SharedReference;
+}
+declare abstract class SharedReference extends SharedType {
+    static typeID: number;
+    static readonly isPtr: boolean;
+    static readonly isArr: boolean;
+    abstract get byteSize(): number;
+}
+type SharedReferenceClass = SharedReferenceStatic;
+
+interface SharedType {
+    typeID: number;
+}
+declare abstract class SharedType {
+    protected _addr: number;
+    protected _heap: SharedHeap;
+    constructor(heap: SharedHeap, addr: number);
+    get addr(): number;
+    get heap(): SharedHeap;
+}
+type SharedTypeClass = SharedReferenceClass | SharedPrimitiveClass<any>;
+
+declare class TypeRegistry {
+    private static indexToType;
+    private static typeToIndex;
+    private static hashToType;
+    private static typeToHash;
+    private static indexToHash;
+    static fnv1(str: string): number;
+    static registerType(dataType: SharedTypeClass): number;
+    static getTypeBuffer(): ArrayBuffer;
+    static verifyTypeBuffer(typeBuffer: ArrayBuffer): void;
+    static getTypeByIndex(index: number): SharedTypeClass;
+    static getTypeByHash(hash: number): SharedTypeClass;
+    static getIndexByType(type: SharedTypeClass): number;
+    static getHashByType(type: SharedTypeClass): number;
+    private constructor();
+}
+
+type VariableDeclaration = {
+    type: SharedPrimitiveClass<any>;
+    param?: any;
+} | {
+    type: SharedReferenceClass;
+    param: any;
+};
+declare class SharedStruct extends SharedReference {
+    static fromData<T extends SharedStruct>(this: (new (heap: SharedHeap, addr: number) => T) & SharedReferenceStatic, heap: SharedHeap, param: any): T;
+    static readonly properties: Record<string, VariableDeclaration>;
+    protected _byteSize: number;
+    protected properties: Record<string, SharedType>;
+    constructor(heap: SharedHeap, addr: number);
+    imprint(obj?: Record<string, any>): void;
+    static get byteSize(): number;
+    get byteSize(): number;
+}
+
+declare class SharedArray<T extends SharedType> extends SharedReference {
+    static readonly isArr: boolean;
+    static readonly properties: Record<string, VariableDeclaration>;
+    static fromData<U extends SharedReference>(heap: SharedHeap, v: any): U;
+    protected readonly _heldType: SharedTypeClass;
+    protected readonly _elementType: SharedTypeClass;
+    protected readonly _elementSize: number;
+    protected readonly _byteSize: number;
+    protected readonly _length: number;
+    protected readonly elements: T[];
+    constructor(heap: SharedHeap, addr: number);
+    get addr(): number;
+    get heap(): SharedHeap;
+    get heldType(): SharedTypeClass;
+    get elementType(): SharedTypeClass;
+    get elementSize(): number;
+    static get byteSize(): number;
+    get byteSize(): number;
+    get length(): number;
+}
+
+interface PointerDefinition {
+    type: SharedTypeClass;
+    addr?: number;
+}
+declare class SharedPointer<T extends SharedType> extends SharedPrimitive<any> {
+    static readonly byteSize: number;
+    static readonly isPtr: boolean;
+    static fromData(heap: SharedHeap, v: PointerDefinition): SharedPointer<SharedType>;
+    protected readonly _heldType: SharedTypeClass;
+    protected _deref: SharedType | null;
+    constructor(heap: SharedHeap, addr: number, dataType?: SharedTypeClass);
+    get heldType(): SharedTypeClass;
+    get addr(): number;
+    get heap(): SharedHeap;
+    set value(p: number);
+    get value(): number;
+    set deref(v: T);
+    get deref(): T;
+}
+
+type int32 = number & {
+    __brand: "int32";
+};
+declare function Int32(value: number): int32;
+declare class SharedInt32 extends SharedPrimitive<int32> {
+    static readonly byteSize: number;
+    static fromData(heap: SharedHeap, v: int32): SharedInt32;
+    set value(v: int32);
+    get value(): int32;
+}
+
+type uint32 = number & {
+    __brand: "uint32";
+};
+declare function Uint32(value: number): uint32;
+declare class SharedUint32 extends SharedPrimitive<uint32> {
+    static readonly byteSize: number;
+    static fromData(heap: SharedHeap, v: uint32): SharedUint32;
+    set value(v: uint32);
+    get value(): uint32;
+}
+
+interface WorkerMessageData {
+    tag: "message";
+    label: string;
+    data: any;
+}
+interface WorkerMessageSync {
+    tag: "sync";
+    name: string;
+    buffer: SharedArrayBuffer | null;
+    heapID: number;
+    rebound: boolean;
+}
+interface WorkerMessageAllocate {
+    tag: "assign";
+    name: string;
+    heapID: number;
+    addr: number;
+    rebound: boolean;
+}
+type WorkerMessage = WorkerMessageData | WorkerMessageSync | WorkerMessageAllocate;
+type ThreadEvent = {
+    internalmessage: [WorkerMessage];
+    message: [data: any, label: string];
+    sync: [name: string, buffer: SharedArrayBuffer | null, heapID: number, rebound: boolean];
+    assign: [name: string, heapID: number, addr: number, rebound: boolean];
+    error: [err: Error];
+    messageerror: [err: Error];
+    online: [];
+    exit: [exitCode: number];
+};
+interface ThreadStatic {
+    sendToThread(threadId: number, data: any, label: string | null): void;
+    transferToThread(threadId: number, data: any, transferList: Transferable[], label: string | null): void;
+}
+interface UnifiedPort {
+    postMessage(value: any, transferList?: ReadonlyArray<any>): void;
+}
+type PortHandle = (Worker | MessagePort) & EventEmitter & UnifiedPort;
+interface ThreadConfig {
+    transient?: boolean;
+    logLevel?: 0 | 1 | 2;
+    timeout?: number | undefined;
+    useTypescript?: boolean;
+    workerOptions?: WorkerOptions;
+}
+declare abstract class Thread extends EventEmitter<ThreadEvent> {
+    static sendToThread(threadId: number, data: any, label?: string | null): Promise<void>;
+    static transferToThread(threadId: number, data: any, transferList: Transferable[], label?: string | null): Promise<void>;
+    protected port: PortHandle;
+    protected config: ThreadConfig;
+    constructor(port: PortHandle, config?: ThreadConfig);
+    send(data: any, label?: string | null): void;
+    sendWithTransfer(data: any, transferList: Transferable[], label?: string | null): void;
+    request(data: any, label?: string | null): Promise<any>;
+    listenOnce(cb: Function, label?: string | null): void;
+    listenAll(cb: Function, label?: string | null): void;
+    respondOnce(cb: Function, label?: string | null): void;
+    respondAll(cb: Function, label?: string | null): void;
+    addHeap(heap: SharedHeap | SharedArrayBuffer, name: string): Promise<void>;
+    syncHeap(name: string): Promise<SharedHeap>;
+    addVar(data: SharedType, name: string): Promise<void>;
+    syncVar(name: string): Promise<SharedType>;
+}
+
+declare class MainThread extends Thread {
+    static get optimalTypeRegistrys(): number;
+    private worker;
+    private active;
+    constructor(path: string | Function, config?: ThreadConfig);
+    ready(): Promise<void>;
+    terminate(): Promise<number>;
+    private err;
+    get isActive(): boolean;
+    ref(): void;
+    unref(): void;
+}
+
+declare class WorkerThread extends Thread {
+    private _workerData;
+    constructor();
+    get workerData(): any;
+    private err;
+}
+
+declare const WorkerThreadExport: WorkerThread;
+
+export { Int32, MainThread, type PortHandle, SharedArray, SharedHeap, SharedInt32, SharedPointer, SharedPrimitive, type SharedPrimitiveClass, type SharedPrimitiveStatic, SharedReference, type SharedReferenceClass, type SharedReferenceStatic, SharedStruct, SharedType, type SharedTypeClass, SharedUint32, Thread, type ThreadConfig, type ThreadEvent, type ThreadStatic, TypeRegistry, Uint32, type VariableDeclaration, type WorkerMessage, WorkerThreadExport as WorkerThread, type int32, type uint32 };