@daneren2005/shared-memory-objects 0.0.10 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daneren2005/shared-memory-objects",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "author": "daneren2005@gmail.com",
   "description": "Creating objects with a SharedArrayBuffer",
   "homepage": "https://github.com/daneren2005/shared-memory-objects#readme",
@@ -17,14 +17,24 @@
   },
   "type": "module",
   "files": [
-    "src/",
-    "!__tests__"
+    "dist/"
   ],
-  "main": "./src/main.ts",
+  "main": "./dist/shared-memory-objects.js",
   "exports": {
-    ".": "./src/main.ts"
+    ".": {
+      "import": {
+        "default": "./dist/shared-memory-objects.js",
+        "types": "./dist/src/main.d.ts"
+      },
+      "require": {
+        "default": "./dist/shared-memory-objects.js",
+        "types": "./dist/src/main.d.ts"
+      }
+    }
   },
+  "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",
     "preview": "vite preview",
@@ -38,6 +48,7 @@
     "prepare": "husky"
   },
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.53.2",
     "@rushstack/eslint-patch": "^1.10.1",
     "@tsconfig/node18": "^18.2.4",
     "@types/jsdom": "^21.1.6",
@@ -51,6 +62,7 @@
     "lint-staged": "^15.2.2",
     "typescript": "^5.4.3",
     "typescript-eslint": "^7.5.0",
+    "unplugin-dts": "^1.0.0-beta.0",
     "vite": "^5.2.0",
     "vitest": "^1.4.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;

package/src/main.ts

@@ -1,40 +0,0 @@
-import AllocatedMemory, { type SharedAllocatedMemory } from './allocated-memory';
-import MemoryBuffer from './memory-buffer';
-import MemoryHeap, { type MemoryHeapMemory, type GrowBufferData } from './memory-heap';
-
-import SharedList, { type SharedListMemory } from './shared-list';
-import SharedMap, { type SharedMapMemory } from './shared-map';
-import SharedPointerList from './shared-pointer-list';
-import SharedString from './shared-string';
-import SharedVector, { type SharedVectorMemory } from './shared-vector';
-import CachedItemList, { type CachedListConfig } from './cached-item-list';
-
-export * from './interfaces/typed-array';
-export * from './interfaces/typed-array-constructor';
-
-export * from './utils/16-from-32-array';
-export * from './utils/16-from-64-array';
-export * from './utils/float32-atomics';
-export * from './utils/pointer';
-export * from './lock/simple-lock';
-export * from './lock/read-write-lock';
-
-export {
-	AllocatedMemory,
-	type SharedAllocatedMemory,
-	MemoryBuffer,
-	MemoryHeap,
-	type MemoryHeapMemory,
-	type GrowBufferData,
-
-	SharedList,
-	type SharedListMemory,
-	SharedMap,
-	type SharedMapMemory,
-	SharedPointerList,
-	SharedString,
-	SharedVector,
-	type SharedVectorMemory,
-	CachedItemList,
-	type CachedListConfig
-};