@daneren2005/shared-memory-objects 0.0.10 → 0.0.12

package/dist/src/memory-heap.d.ts

@@ -0,0 +1,34 @@
+import { default as AllocatedMemory, SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryBuffer } from './memory-buffer';
+export default class MemoryHeap {
+    buffers: Array<MemoryBuffer>;
+    private onGrowBufferHandlers;
+    isClone: boolean;
+    private memory;
+    get bufferSize(): number;
+    constructor(config?: MemoryHeapConfig | MemoryHeapMemory);
+    addSharedBuffer(data: GrowBufferData): void;
+    private growBuffer;
+    private createBuffer;
+    addOnGrowBufferHandlers(handler: OnGrowBuffer): void;
+    allocUI32(count: number): AllocatedMemory;
+    getSharedAlloc(shared: SharedAllocatedMemory): AllocatedMemory | undefined;
+    get currentUsed(): number;
+    get totalAllocated(): number;
+    prettyMemory(): string;
+    getSharedMemory(): MemoryHeapMemory;
+}
+type OnGrowBuffer = (newBuffer: GrowBufferData) => void;
+interface GrowBufferData {
+    bufferPosition: number;
+    buffer: SharedArrayBuffer;
+}
+interface MemoryHeapConfig {
+    bufferSize?: number;
+    initialBuffers?: number;
+    autoGrowSize?: number;
+}
+interface MemoryHeapMemory {
+    buffers: Array<SharedArrayBuffer>;
+}
+export type { MemoryHeapConfig, MemoryHeapMemory, GrowBufferData };

package/dist/src/serialize-object.d.ts

@@ -0,0 +1,5 @@
+import { default as AllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export declare function serializeObjectToMemory<T extends object>(heap: MemoryHeap, object: T): AllocatedMemory;
+export declare function createObjectFromPointer<T extends object>(heap: MemoryHeap, pointer: number): T;
+export declare function createObjectFromMemory<T extends object>(memory: AllocatedMemory): T;

package/dist/src/shared-list.d.ts

@@ -0,0 +1,44 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedList<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<SharedListIterable<T>> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    onDelete?: (data: T) => void;
+    get length(): number;
+    get type(): number;
+    private set type(value);
+    get dataLength(): number;
+    private set dataLength(value);
+    constructor(memory: MemoryHeap, config?: SharedListConfig<T> | SharedListMemory);
+    insert(values: number | Array<number>): void;
+    deleteMatch(callback: (values: T, index: number) => boolean): boolean;
+    deleteIndex(deleteIndex: number): boolean;
+    deleteValue(deleteValues: number | Array<number>): boolean;
+    clear(): void;
+    [Symbol.iterator](): Generator<{
+        data: T;
+        index: number;
+        deleteCurrent: () => void;
+    }, void, unknown>;
+    forEach(callback: (data: T) => void): void;
+    getSharedMemory(): SharedListMemory;
+    private getDataBlock;
+    free(): void;
+}
+interface SharedListConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    initWithBlock?: SharedAllocatedMemory;
+    type?: TypedArrayConstructor<T>;
+    dataLength?: number;
+}
+interface SharedListMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+interface SharedListIterable<T extends Uint32Array | Int32Array | Float32Array> {
+    data: T;
+    index: number;
+    deleteCurrent: () => void;
+}
+export { type SharedListMemory };

package/dist/src/shared-map.d.ts

@@ -0,0 +1,25 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedMap<K extends string | number> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private pointerMemory;
+    private lock;
+    private get hashMemory();
+    get length(): number;
+    get maxHash(): number;
+    constructor(memory: MemoryHeap, clone?: SharedMapMemory);
+    set(key: K, value: number): void;
+    private setHashKey;
+    get(key: K): number | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    private growHashTable;
+    private hash;
+    free(): void;
+    getSharedMemory(): SharedMapMemory;
+}
+interface SharedMapMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedMapMemory };

package/dist/src/shared-pointer-list.d.ts

@@ -0,0 +1,21 @@
+import { default as AllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+import { SharedListMemory } from './shared-list';
+export default abstract class SharedPointerList<T extends PointerItem> implements Iterable<T> {
+    private memory;
+    private list;
+    constructor(heap: MemoryHeap, memory?: SharedListMemory);
+    get length(): number;
+    insert(item: T): void;
+    delete(item: T): boolean;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    forEach(callback: (item: T) => void): void;
+    find(callback: (item: T) => boolean): T | undefined;
+    getSharedMemory(): SharedListMemory;
+    protected abstract createItem(allocatedMemory: AllocatedMemory): T;
+    free(): void;
+}
+interface PointerItem {
+    readonly memory: AllocatedMemory;
+}
+export {};

package/dist/src/shared-pool.d.ts

@@ -0,0 +1,39 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedPool<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {
+    static readonly ALLOCATE_COUNT: number;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    private pointerVector;
+    private recycleVector;
+    private cachedFullDataBlock;
+    get length(): number;
+    get maxChunkSize(): number;
+    private set maxChunkSize(value);
+    get type(): number;
+    private set type(value);
+    get dataLength(): number;
+    private set dataLength(value);
+    constructor(memory: MemoryHeap, config?: SharedPoolConfig<T> | SharedPoolMemory);
+    at(index: number): T;
+    get(index: number, dataIndex?: number): number;
+    push(values: number | Array<number>): number;
+    deleteIndex(index: number): void;
+    clear(): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    private getFullDataBlock;
+    private getDataBlock;
+    free(): void;
+    getSharedMemory(): SharedPoolMemory;
+}
+interface SharedPoolConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    maxChunkSize?: number;
+    type?: TypedArrayConstructor<T>;
+    dataLength?: number;
+}
+interface SharedPoolMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedPoolConfig, SharedPoolMemory };

package/dist/src/shared-string.d.ts

@@ -0,0 +1,23 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedString {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private allocatedMemory;
+    private lock;
+    private cachedPointer?;
+    private cachedString?;
+    constructor(memory: MemoryHeap, value: string | SharedStringConfig | SharedStringMemory);
+    private updateString;
+    private createString;
+    get value(): string;
+    set value(value: string);
+    getSharedMemory(): SharedStringMemory;
+    get pointer(): number;
+    free(): void;
+}
+interface SharedStringConfig extends SharedStringMemory {
+    value: string;
+}
+type SharedStringMemory = SharedAllocatedMemory;
+export {};

package/dist/src/shared-vector.d.ts

@@ -0,0 +1,41 @@
+import { SharedAllocatedMemory } from './allocated-memory';
+import { TypedArrayConstructor } from './interfaces/typed-array-constructor';
+import { default as MemoryHeap } from './memory-heap';
+export default class SharedVector<T extends Uint32Array | Int32Array | Float32Array = Uint32Array> implements Iterable<T> {
+    static readonly ALLOCATE_COUNT = 4;
+    private memory;
+    private firstBlock;
+    private uint16Array;
+    get length(): number;
+    get type(): number;
+    private set type(value);
+    get dataLength(): number;
+    private set dataLength(value);
+    get bufferLength(): number;
+    private set bufferLength(value);
+    get pointer(): number;
+    private cachedFullDataBlock?;
+    private cachedPointer;
+    constructor(memory: MemoryHeap, config?: SharedVectorConfig<T> | SharedVectorMemory | SharedVectorMemory & SharedVectorConfig<T>);
+    at(index: number): T;
+    get(index: number, dataIndex?: number): number;
+    push(values: number | Array<number>): number;
+    pop(): T;
+    deleteIndex(index: number): void;
+    clear(): void;
+    [Symbol.iterator](): Generator<T, void, unknown>;
+    private getFullDataBlock;
+    private getDataBlock;
+    private growBuffer;
+    free(): void;
+    getSharedMemory(): SharedVectorMemory;
+}
+interface SharedVectorConfig<T extends Uint32Array | Int32Array | Float32Array> {
+    type?: TypedArrayConstructor<T>;
+    dataLength?: number;
+    bufferLength?: number;
+}
+interface SharedVectorMemory {
+    firstBlock: SharedAllocatedMemory;
+}
+export type { SharedVectorConfig, SharedVectorMemory };

package/dist/src/utils/16-from-32-array.d.ts

@@ -0,0 +1,4 @@
+export declare function load16From32(data: Uint32Array, index: number): [number, number];
+export declare function store16In32(data: Uint32Array, index: number, value1: number, value2: number): void;
+export declare function convert32To16(value: number): [number, number];
+export declare function convert16To32(value1: number, value2: number): number;

package/dist/src/utils/16-from-64-array.d.ts

@@ -0,0 +1,2 @@
+export declare function load16From64(data: BigUint64Array, index: number): [number, number, number, number];
+export declare function store16In64(data: BigUint64Array, index: number, value1: number, value2: number, value3: number, value4?: number): void;

package/dist/src/utils/float32-atomics.d.ts

@@ -0,0 +1,5 @@
+export declare function loadFloat32(data: Int32Array | Uint32Array, index: number): number;
+export declare function storeFloat32(data: Int32Array | Uint32Array, index: number, value: number): void;
+export declare function convertInt32ToFloat32(value: number): number;
+export declare function convertFloat32ToInt32(value: number): number;
+export declare function exchangeFloat32(data: Int32Array | Uint32Array, index: number, value: number): number;

package/dist/src/utils/pointer.d.ts

@@ -0,0 +1,19 @@
+declare const BYTE_OFFSET_BIT_COUNT = 20;
+declare const POSITION_BIT_COUNT: number;
+declare const MAX_BYTE_OFFSET_LENGTH: number;
+declare const MAX_POSITION_LENGTH: number;
+export declare function loadPointer(data: Uint32Array, index?: number): {
+    bufferPosition: number;
+    bufferByteOffset: number;
+};
+export declare function loadRawPointer(data: Uint32Array, index?: number): number;
+export declare function storePointer(data: Uint32Array, index: number | undefined, bufferPosition: number, bufferByteOffset: number): void;
+export declare function storeRawPointer(data: Uint32Array, index: number | undefined, pointer: number): void;
+export declare function replacePointer(data: Uint32Array, index: number, newBufferPosition: number, newBufferByteOffset: number, oldBufferPosition: number, oldBufferByteOffset: number): boolean;
+export declare function replaceRawPointer(data: Uint32Array, index: number, newPointer: number, oldPointer: number): boolean;
+export declare function getPointer(value: number): {
+    bufferPosition: number;
+    bufferByteOffset: number;
+};
+export declare function createPointer(bufferPosition: number, bufferByteOffset: number): number;
+export { BYTE_OFFSET_BIT_COUNT, POSITION_BIT_COUNT, MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daneren2005/shared-memory-objects",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "author": "daneren2005@gmail.com",
   "description": "Creating objects with a SharedArrayBuffer",
   "homepage": "https://github.com/daneren2005/shared-memory-objects#readme",
@@ -17,16 +17,27 @@
   },
   "type": "module",
   "files": [
-    "src/",
-    "!__tests__"
+    "dist/"
   ],
-  "main": "./src/main.ts",
+  "main": "./dist/shared-memory-objects.js",
   "exports": {
-    ".": "./src/main.ts"
+    ".": {
+      "import": {
+        "types": "./dist/src/main.d.ts",
+        "default": "./dist/shared-memory-objects.js"
+      },
+      "require": {
+        "types": "./dist/src/main.d.ts",
+        "default": "./dist/shared-memory-objects.js"
+      }
+    }
   },
+  "types": "./dist/src/main.d.ts",
   "scripts": {
+    "build": "vite build",
     "dev": "vite",
-    "lint": "eslint src/ --ext .js,.cjs,.mjs,.ts,.cts,.mts --ignore-path .gitignore",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
     "preview": "vite preview",
     "publish": "npm publish --access public",
     "start": "npm run dev",
@@ -38,23 +49,24 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@rushstack/eslint-patch": "^1.10.1",
-    "@tsconfig/node18": "^18.2.4",
-    "@types/jsdom": "^21.1.6",
-    "@types/node": "^20.12.2",
-    "@vitest/coverage-v8": "^1.4.0",
-    "@vitest/ui": "^1.4.0",
-    "eslint": "^8.57.0",
-    "eslint-plugin-vitest": "^0.4.1",
-    "husky": "^9.0.11",
-    "jsdom": "^24.0.0",
-    "lint-staged": "^15.2.2",
-    "typescript": "^5.4.3",
-    "typescript-eslint": "^7.5.0",
-    "vite": "^5.2.0",
-    "vitest": "^1.4.0"
+    "@microsoft/api-extractor": "^7.53.2",
+    "@tsconfig/node24": "^24.0.1",
+    "@types/jsdom": "^27.0.0",
+    "@types/node": "^24.9.1",
+    "@vitest/coverage-v8": "^4.0.1",
+    "@vitest/eslint-plugin": "^1.3.23",
+    "@vitest/ui": "^4.0.1",
+    "eslint": "^9.38.0",
+    "husky": "^9.1.7",
+    "jsdom": "^27.0.1",
+    "lint-staged": "^16.2.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2",
+    "unplugin-dts": "^1.0.0-beta.6",
+    "vite": "^7.1.11",
+    "vitest": "^4.0.1"
   },
   "dependencies": {
-    "pretty-bytes": "^6.1.1"
+    "pretty-bytes": "^7.1.0"
   }
 }

package/src/allocated-memory.ts

@@ -1,89 +0,0 @@
-import type { TypedArray } from './interfaces/typed-array';
-import type { TypedArrayConstructor } from './interfaces/typed-array-constructor';
-import type MemoryBuffer from './memory-buffer';
-import type MemoryHeap from './memory-heap';
-import { createPointer } from './utils/pointer';
-
-export default class AllocatedMemory {
-	private readonly memory: MemoryHeap;
-
-	readonly bufferPosition: number;
-	get bufferByteOffset(): number {
-		return this.data.byteOffset;
-	}
-	get pointer(): number {
-		return createPointer(this.bufferPosition, this.bufferByteOffset);
-	}
-	private buffer: MemoryBuffer;
-	data: Uint32Array;
-
-	constructor(memory: MemoryHeap, config: AllocatedMemoryConfig | SharedAllocatedMemory) {
-		this.memory = memory;
-
-		if('buffer' in config) {
-			this.data = config.data;
-			this.buffer = config.buffer;
-			this.bufferPosition = this.memory.buffers.indexOf(config.buffer);
-		} else {
-			this.bufferPosition = config.bufferPosition;
-			this.buffer = memory.buffers[config.bufferPosition];
-
-			// Making sure these are the correct size is slow but in dev we want to make sure we aren't allowing to go out of bounds
-			if(import.meta.env.MODE === 'production') {
-				this.data = new Uint32Array(this.buffer.buf, config.bufferByteOffset);
-			} else {
-				this.data = new Uint32Array(this.buffer.buf, config.bufferByteOffset, this.buffer.lengthOf(config.bufferByteOffset));
-			}
-		}
-	}
-
-	getArray<T extends TypedArray>(type: TypedArrayConstructor<T>, offset: number, length: number): T {
-		if(import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test') {
-			if((offset + length) * type.BYTES_PER_ELEMENT > this.data.byteLength) {
-				const message = `Trying to grab more memory from AllocatedMemory.getArray then we have: ${offset * type.BYTES_PER_ELEMENT} + ${length * type.BYTES_PER_ELEMENT} > ${this.data.byteLength}`;
-				if(import.meta.env.MODE === 'test') {
-					throw new Error(message);
-				} else {
-					console.warn(message);
-				}
-			}
-		}
-
-		return new type(this.data.buffer, this.data.byteOffset + offset * type.BYTES_PER_ELEMENT, length);
-	}
-	getArrayMemory(offset: number, length: number): SharedAllocatedMemory {
-		if(import.meta.env.MODE === 'development') {
-			if(offset + length > this.data.length) {
-				console.warn(`Trying to grab more memory from AllocatedMemory.getArrayMemory then we have: ${offset} + ${length} > ${this.data.length}`);
-			}
-		}
-
-		return {
-			bufferPosition: this.bufferPosition,
-			bufferByteOffset: this.bufferByteOffset + offset * this.data.BYTES_PER_ELEMENT
-		};
-	}
-
-	free() {
-		// NOTE: From worker thread you can't pass the array, you have to pass an explicit address to free
-		this.buffer.free(this.data.byteOffset);
-	}
-
-	getSharedMemory(): SharedAllocatedMemory {
-		return {
-			bufferPosition: this.bufferPosition,
-			bufferByteOffset: this.bufferByteOffset
-		};
-	}
-}
-
-interface AllocatedMemoryConfig {
-	data: Uint32Array
-	buffer: MemoryBuffer
-}
-
-interface SharedAllocatedMemory {
-	bufferPosition: number
-	bufferByteOffset: number
-}
-export type { SharedAllocatedMemory };

package/src/cached-item-list.ts

@@ -1,143 +0,0 @@
-import type { SharedAllocatedMemory } from './allocated-memory';
-import type MemoryHeap from './memory-heap';
-import SharedList, { type SharedListMemory } from './shared-list';
-
-export default abstract class CachedItemList<T extends Item> implements Iterable<{ item: T, deleteCurrent: () => void }> {
-	static readonly ALLOCATE_COUNT = SharedList.ALLOCATE_COUNT;
-
-	protected heap: MemoryHeap;
-	protected list: SharedList;
-	protected cache: Map<number, T> = new Map();
-
-	constructor(heap: MemoryHeap, config?: CachedListConfig | SharedListMemory) {
-		if(config) {
-			this.list = new SharedList(heap, config);
-		} else {
-			this.list = new SharedList(heap);
-		}
-		this.heap = heap;
-
-		this.list.onDelete = (pointerData: Uint32Array) => {
-			let pointer = Atomics.load(pointerData, 0);
-			if(pointer) {
-				let item = this.cache.get(pointer);
-				if(!item) {
-					item = this.initItem(pointer);
-				}
-
-				if(item) {
-					item.free();
-					this.cache.delete(pointer);
-				}
-			}
-		};
-	}
-
-	get length() {
-		return this.list.length;
-	}
-
-	clear() {
-		this.list.clear();
-		this.cache.clear();
-	}
-
-	insert(item: T) {
-		this.list.insert(item.pointer);
-		this.cache.set(item.pointer, item);
-	}
-	delete(item: T) {
-		this.cache.delete(item.pointer);
-		return this.list.deleteValue(item.pointer);
-	}
-
-	getByPointer(pointer: number): T | undefined {
-		let item = this.cache.get(pointer);
-		if(!item) {
-			item = this.initItem(pointer);
-			if(item) {
-				this.cache.set(pointer, item);
-			}
-		}
-
-		return item;
-	}
-	protected abstract initItem(pointer: number): T | undefined
-
-	*[Symbol.iterator]() {
-		let iterator = this.list[Symbol.iterator]();
-
-		for(let { data: pointerData, deleteCurrent } of iterator) {
-			let pointer = Atomics.load(pointerData, 0);
-			if(!pointer) {
-				continue;
-			}
-
-			let item = this.cache.get(pointer);
-			if(!item) {
-				item = this.initItem(pointer);
-				if(item) {
-					this.cache.set(pointer, item);
-				}
-			}
-
-			if(item) {
-				yield {
-					item,
-					deleteCurrent
-				};
-			}
-		}
-	}
-	forEach(callback: (item: T) => void, filter?: (item: T) => boolean) {
-		for(let { item } of this) {
-			if(!filter || filter(item)) {
-				callback(item);
-			}
-		}
-	}
-
-	find(callback: (item: T) => boolean): T | undefined {
-		for(let { item } of this) {
-			if(callback(item)) {
-				return item;
-			}
-		}
-	}
-	filter(callback: (entity: T) => boolean): Array<T> {
-		let items = [];
-		for(let { item } of this) {
-			if(callback(item)) {
-				items.push(item);
-			}
-		}
-
-		return items;
-	}
-	map<X>(callback: (item: T) => X): Array<X> {
-		const array: Array<X> = [];
-		for(let { item } of this) {
-			array.push(callback(item));
-		}
-
-		return array;
-	}
-
-	getSharedMemory() {
-		return this.list.getSharedMemory();
-	}
-
-	free() {
-		this.list.free();
-		this.cache.clear();
-	}
-}
-
-export interface CachedListConfig {
-	initWithBlock: SharedAllocatedMemory
-}
-
-interface Item {
-	pointer: number
-	free: () => void
-}

package/src/interfaces/typed-array-constructor.ts

@@ -1,6 +0,0 @@
-interface TypedArrayConstructor<T> {
-	new(buffer: ArrayBufferLike, byteOffset: number, length: number): T
-	BYTES_PER_ELEMENT: number
-}
-
-export type { TypedArrayConstructor };

package/src/lock/read-write-lock.ts

@@ -1,41 +0,0 @@
-const UNLOCKED = 0;
-const READ_LOCKED = 1;
-const WRITE_LOCKED = 2;
-
-export function readLock(data: Int32Array, index: number = 0) {
-	// Wait over and over again until we get that it was unlocked or read locked
-	while(Atomics.compareExchange(data, index, UNLOCKED, READ_LOCKED) === WRITE_LOCKED) {
-		Atomics.wait(data, index, WRITE_LOCKED);
-	}
-
-	Atomics.add(data, index + 1, 1);
-}
-export function writeLock(data: Int32Array, index: number = 0) {
-	// Write lock needs to be exclusive - wait until we were in UNLOCKED to proceed
-	let oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);
-	while(oldValue !== UNLOCKED) {
-		Atomics.wait(data, index, oldValue);
-		oldValue = Atomics.compareExchange(data, index, UNLOCKED, WRITE_LOCKED);
-	}
-}
-
-export function readUnlock(data: Int32Array, index: number = 0) {
-	let readCount = Atomics.sub(data, index + 1, 1) - 1;
-
-	if(readCount <= 0) {
-		if(Atomics.compareExchange(data, index, READ_LOCKED, UNLOCKED) !== READ_LOCKED) {
-			console.warn('We are unlocking when it was not read locked!');
-		}
-
-		Atomics.notify(data, index);
-	}
-}
-export function writeUnlock(data: Int32Array, index: number = 0) {
-	if(Atomics.compareExchange(data, index, WRITE_LOCKED, UNLOCKED) !== WRITE_LOCKED) {
-		console.warn('We are unlocking when it was not write locked!');
-	}
-
-	Atomics.notify(data, index);
-}
-
-export const READ_WRITE_LOCK_ALLOCATE_COUNT = 2;

package/src/lock/simple-lock.ts

@@ -1,21 +0,0 @@
-const UNLOCKED = 0;
-const LOCKED = 1;
-export function lock(data: Int32Array, index: number = 0) {
-	// Wait over and over again until we are one who set this from UNLOCKED to LOCKED
-	while(Atomics.compareExchange(data, index, UNLOCKED, LOCKED) !== UNLOCKED) {
-		if('WorkerGlobalScope' in self) {
-			Atomics.wait(data, index, LOCKED);
-		} else {
-			// TODO: Spin-locks suck....
-		}
-	}
-}
-export function unlock(data: Int32Array, index: number = 0) {
-	if(Atomics.compareExchange(data, index, LOCKED, UNLOCKED) !== LOCKED) {
-		console.warn('We are unlocking when it was not locked!');
-	}
-
-	Atomics.notify(data, index);
-}
-
-export const SIMPLE_LOCK_ALLOCATE_COUNT = 1;