@monstermann/dsp 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Michael Ostermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+<div align="center">
+
+<h1>dsp</h1>
+
+**Small & fast disposables.**
+
+[Documentation](https://MichaelOstermann.github.io/dsp)
+
+</div>

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+//#region src/Dsp/symbol.d.ts
+declare const symbol: unique symbol;
+//#endregion
+//#region src/Dsp/types.d.ts
+interface Dsp$1 {
+  [symbol]: boolean;
+  dsps: DspLink$1 | undefined;
+  vals: DspLink$1 | undefined;
+}
+interface DspLink$1 {
+  disposer: Dsp$1;
+  nextDsp: DspLink$1 | undefined;
+  nextVal: DspLink$1 | undefined;
+  prevDsp: DspLink$1 | undefined;
+  prevVal: DspLink$1 | undefined;
+  val: (() => void) | Dsp$1;
+}
+//#endregion
+//#region src/Dsp/add.d.ts
+declare function add(target: Dsp$1, value: (() => void) | Dsp$1): DspLink$1 | undefined;
+//#endregion
+//#region src/Dsp/create.d.ts
+declare function create(): Dsp$1;
+//#endregion
+//#region src/Dsp/dispose.d.ts
+declare function dispose(target: Dsp$1): void;
+//#endregion
+//#region src/Dsp/find.d.ts
+declare function find(target: Dsp$1, value: (() => void) | Dsp$1): DspLink$1 | undefined;
+//#endregion
+//#region src/Dsp/includes.d.ts
+declare function includes(target: Dsp$1, value: (() => void) | Dsp$1): boolean;
+//#endregion
+//#region src/Dsp/isDisposed.d.ts
+declare function isDisposed(target: Dsp$1): boolean;
+//#endregion
+//#region src/Dsp/isDsp.d.ts
+declare function isDsp(value: unknown): value is Dsp$1;
+//#endregion
+//#region src/Dsp/remove.d.ts
+declare function remove(disposer: Dsp$1, value: (() => void) | Dsp$1): void;
+//#endregion
+//#region src/Dsp/unlink.d.ts
+declare function unlink(link: DspLink$1 | undefined): void;
+//#endregion
+//#region src/Dsp/index.d.ts
+interface Dsp {
+  [symbol]: boolean;
+  dsps: DspLink | undefined;
+  vals: DspLink | undefined;
+}
+interface DspLink {
+  disposer: Dsp;
+  nextDsp: DspLink | undefined;
+  nextVal: DspLink | undefined;
+  prevDsp: DspLink | undefined;
+  prevVal: DspLink | undefined;
+  val: (() => void) | Dsp;
+}
+declare namespace Dsp {
+  export { add, create, dispose, find, includes, isDisposed, isDsp, remove, symbol, unlink };
+}
+//#endregion
+export { Dsp, DspLink };

package/dist/index.js

@@ -0,0 +1,165 @@
+//#region src/Dsp/symbol.ts
+const symbol = Symbol("Dsp");
+
+//#endregion
+//#region src/Dsp/internals.ts
+function createLink(disposer, val) {
+	return {
+		disposer,
+		nextDsp: void 0,
+		nextVal: void 0,
+		prevDsp: void 0,
+		prevVal: void 0,
+		val
+	};
+}
+function linkVal(disposer, link) {
+	link.prevVal = disposer.vals;
+	if (disposer.vals) disposer.vals.nextVal = link;
+	disposer.vals = link;
+	return link;
+}
+function linkDsp(disposer, link) {
+	link.prevDsp = disposer.dsps;
+	if (disposer.dsps) disposer.dsps.nextDsp = link;
+	disposer.dsps = link;
+	return link;
+}
+function unlinkVal(link) {
+	if (link.prevVal) link.prevVal.nextVal = link.nextVal;
+	if (link.nextVal) link.nextVal.prevVal = link.prevVal;
+	if (link.disposer.vals === link) link.disposer.vals = link.prevVal;
+	link.nextVal = link.prevVal = void 0;
+}
+function unlinkDsp(link) {
+	if (symbol in link.val) {
+		if (link.prevDsp) link.prevDsp.nextDsp = link.nextDsp;
+		if (link.nextDsp) link.nextDsp.prevDsp = link.prevDsp;
+		if (link.val.dsps === link) link.val.dsps = link.prevDsp;
+		link.nextDsp = link.prevDsp = void 0;
+	}
+}
+
+//#endregion
+//#region src/Dsp/dispose.ts
+function dispose(target) {
+	let errors;
+	let stack = {
+		dsp: target,
+		prev: void 0
+	};
+	let dsp = target;
+	while (dsp) {
+		dsp[symbol] = true;
+		while (dsp.dsps) {
+			unlinkVal(dsp.dsps);
+			dsp.dsps = dsp.dsps.prevDsp;
+		}
+		while (dsp.vals) {
+			const val = dsp.vals.val;
+			dsp.vals = dsp.vals.prevVal;
+			if (symbol in val) {
+				stack = {
+					dsp: val,
+					prev: stack
+				};
+				dsp = val;
+			} else try {
+				val();
+			} catch (err) {
+				errors ??= [];
+				errors.push(err);
+			}
+		}
+		stack = stack?.prev;
+		dsp = stack?.dsp;
+	}
+	if (!errors) return;
+	if (errors.length === 1) throw errors[0];
+	throw new AggregateError(errors, "DisposeError");
+}
+
+//#endregion
+//#region src/Dsp/add.ts
+function add(a, b) {
+	if (symbol in b) {
+		if (a === b) return;
+		if (b[symbol]) return;
+		if (a[symbol]) return dispose(b);
+		return linkDsp(b, linkVal(a, createLink(a, b)));
+	}
+	if (a[symbol]) return b();
+	return linkVal(a, createLink(a, b));
+}
+
+//#endregion
+//#region src/Dsp/create.ts
+function create() {
+	return {
+		dsps: void 0,
+		[symbol]: false,
+		vals: void 0
+	};
+}
+
+//#endregion
+//#region src/Dsp/find.ts
+function find(target, value) {
+	let link = target.vals;
+	while (link) {
+		if (link.val === value) return link;
+		link = link.prevVal;
+	}
+	return link;
+}
+
+//#endregion
+//#region src/Dsp/includes.ts
+function includes(target, value) {
+	return !!find(target, value);
+}
+
+//#endregion
+//#region src/Dsp/isDisposed.ts
+function isDisposed(target) {
+	return target[symbol];
+}
+
+//#endregion
+//#region src/Dsp/isDsp.ts
+function isDsp(value) {
+	return value != null && typeof value === "object" && symbol in value;
+}
+
+//#endregion
+//#region src/Dsp/unlink.ts
+function unlink(link) {
+	if (!link) return;
+	unlinkVal(link);
+	unlinkDsp(link);
+}
+
+//#endregion
+//#region src/Dsp/remove.ts
+function remove(disposer, value) {
+	const link = find(disposer, value);
+	if (link) unlink(link);
+}
+
+//#endregion
+//#region src/Dsp/index.js
+const Dsp = {
+	add,
+	create,
+	dispose,
+	find,
+	includes,
+	isDisposed,
+	isDsp,
+	remove,
+	symbol,
+	unlink
+};
+
+//#endregion
+export { Dsp };

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "@monstermann/dsp",
+    "type": "module",
+    "version": "0.2.0",
+    "description": "Small & fast disposables.",
+    "author": "Michael Ostermann <michaelostermann@me.com>",
+    "license": "MIT",
+    "homepage": "https://MichaelOstermann.github.io/dsp",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/MichaelOstermann/dsp.git"
+    },
+    "bugs": {
+        "url": "https://github.com/MichaelOstermann/dsp/issues"
+    },
+    "keywords": [],
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./*": "./dist/*"
+    },
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "bundle": "tsdown",
+        "release": "bun publish --access public"
+    },
+    "dependencies": {}
+}