├── .github └── workflows │ └── ci.yml ├── .gitignore ├── .vscode ├── extensions.json └── settings.json ├── LICENSE ├── README.md ├── deno.json ├── iterable_weak_map.test.ts ├── iterable_weak_map.ts ├── iterable_weak_set.test.ts ├── iterable_weak_set.ts ├── mod.ts ├── scripts └── build_npm.ts ├── weak_value_map.test.ts └── weak_value_map.ts /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | branches: [ main ] 6 | pull_request: 7 | branches: [ main ] 8 | 9 | jobs: 10 | build: 11 | runs-on: ubuntu-latest 12 | strategy: 13 | matrix: 14 | deno-version: [v1.x] 15 | steps: 16 | - name: Git Checkout Deno Module 17 | uses: actions/checkout@v2 18 | - name: Use Deno Version ${{ matrix.deno-version }} 19 | uses: denoland/setup-deno@v1 20 | with: 21 | deno-version: ${{ matrix.deno-version }} 22 | - name: Format 23 | run: deno fmt --check 24 | - name: Lint 25 | run: deno lint 26 | - name: Unit Test 27 | run: deno test --coverage=coverage 28 | - name: Create coverage report 29 | run: deno coverage ./coverage --lcov > coverage.lcov 30 | - name: Collect coverage 31 | uses: codecov/codecov-action@v1.0.10 32 | with: 33 | file: ./coverage.lcov 34 | - name: Build Module 35 | run: deno task build:npm 36 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .npm 2 | deno.lock 3 | -------------------------------------------------------------------------------- /.vscode/extensions.json: -------------------------------------------------------------------------------- 1 | { 2 | "recommendations": [ 3 | "denoland.vscode-deno", 4 | "streetsidesoftware.code-spell-checker", 5 | "github.vscode-github-actions" 6 | ] 7 | } 8 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "deno.enable": true, 3 | "deno.lint": true, 4 | "editor.formatOnSave": true, 5 | "editor.defaultFormatter": "denoland.vscode-deno", 6 | "cSpell.words": [ 7 | "deno", 8 | "denostack", 9 | "iwset", 10 | "weakref", 11 | "wmap", 12 | "wset" 13 | ] 14 | } 15 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2022-2022 Changwan Jun 4 | 5 | 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: 6 | 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 8 | 9 | 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. 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # weakref 2 | 3 |

4 | Build 5 | Coverage 6 | License 7 | Language Typescript 8 |
9 | JSR version 10 | Deno version 11 | NPM Version 12 | Downloads 13 |

14 | 15 | This library provides three iterable weak data structures for JavaScript, 16 | IterableWeakSet, IterableWeakMap, and WeakValueMap. These data structures are 17 | designed to work with objects as keys or values, and are useful when you need to 18 | store a collection of objects that may be garbage collected. 19 | 20 | ## Usage 21 | 22 | ### with Deno 23 | 24 | ```ts 25 | import { 26 | IterableWeakMap, 27 | IterableWeakSet, 28 | WeakValueMap, 29 | } from "@denostack/weakref"; 30 | 31 | const set = new IterableWeakSet(); 32 | const map = new IterableWeakMap(); 33 | 34 | const weakValueMap = new WeakValueMap(); 35 | ``` 36 | 37 | ### with Node.js & Browser 38 | 39 | **Install** 40 | 41 | ```bash 42 | npm install weakref 43 | ``` 44 | 45 | ```ts 46 | import { IterableWeakMap, IterableWeakSet } from "weakref"; 47 | ``` 48 | 49 | ## Features 50 | 51 | ### IterableWeakSet 52 | 53 | IterableWeakSet is a class that extends the WeakSet and Set classes in 54 | JavaScript, allowing you to create a set of objects that can be iterated over. 55 | Objects in the set are stored using weak references, which means that they can 56 | be garbage collected if they are no longer referenced elsewhere in the program. 57 | 58 | **Interface** 59 | 60 | ```ts 61 | class IterableWeakSet implements WeakSet, Set { 62 | constructor(values?: readonly T[] | null); 63 | constructor(iterable: Iterable); 64 | } 65 | ``` 66 | 67 | **Example** 68 | 69 | ```ts 70 | const set = new IterableWeakSet(); 71 | 72 | // create an object with a weak reference 73 | { 74 | const user = { id: 1, email: "hey@wan2.land" }; 75 | set.add(user); 76 | } 77 | // end of scope, user will be garbage collected 78 | 79 | // force garbage collection 80 | if (global.gc) { 81 | global.gc(); 82 | } 83 | 84 | // check the set size 85 | console.log(set.size); // output: 0 86 | ``` 87 | 88 | ### IterableWeakMap 89 | 90 | IterableWeakMap is a class that extends the WeakMap and Map classes in 91 | JavaScript, allowing you to create a map of objects that can be iterated over. 92 | Keys in the map are stored using weak references, which means that they can be 93 | garbage collected if they are no longer referenced elsewhere in the program. 94 | 95 | **Interface** 96 | 97 | ```ts 98 | class IterableWeakMap implements WeakMap, Map { 99 | constructor(entries?: readonly (readonly [K, V])[] | null); 100 | constructor(iterable: Iterable); 101 | } 102 | ``` 103 | 104 | **Example** 105 | 106 | ```ts 107 | const map = new IterableWeakMap(); 108 | 109 | // create an object with a weak reference 110 | { 111 | const user = { id: 1, email: "hey@wan2.land" }; 112 | const metadata = { created: new Date() }; 113 | map.set(user, metadata); 114 | } 115 | // end of scope, user will be garbage collected 116 | 117 | // force garbage collection 118 | if (global.gc) { 119 | global.gc(); 120 | } 121 | 122 | // check the map size 123 | console.log(map.size); // output: 0 124 | ``` 125 | 126 | ### WeakValueMap 127 | 128 | WeakValueMap is a class that allows you to create a map of non-object keys with 129 | weak references to object values. This is useful when you have a collection of 130 | non-object keys that you want to use to look up objects, and those objects may 131 | be garbage collected. 132 | 133 | **Interface** 134 | 135 | ```ts 136 | class WeakValueMap implements Map { 137 | constructor(entries?: readonly (readonly [K, V])[] | null); 138 | constructor(iterable: Iterable); 139 | } 140 | ``` 141 | 142 | **Example** 143 | 144 | ```ts 145 | const map = new WeakValueMap(); 146 | 147 | // create an object with a weak reference 148 | { 149 | const user = { id: 1, email: "hey@wan2.land" }; 150 | map.set(user.id, user); 151 | } 152 | // end of scope, user will be garbage collected 153 | 154 | // force garbage collection 155 | if (global.gc) { 156 | global.gc(); 157 | } 158 | 159 | // check the map size 160 | console.log(map.size); // output: 0 161 | ``` 162 | 163 | ## See Also 164 | 165 | - [Python weakref](https://docs.python.org/3/library/weakref.html) my library is 166 | inspired by this library. 167 | - [MDN - JS WeakMap](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) 168 | - [MDN - JS WeakSet](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) 169 | - [MDN - JS WeakRef](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef) 170 | - [MDN - JS FinalizationRegistry](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry) 171 | -------------------------------------------------------------------------------- /deno.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "@denostack/weakref", 3 | "version": "0.2.1", 4 | "tasks": { 5 | "test": "deno task test:unit && deno task test:lint && deno task test:format && deno task test:types", 6 | "test:format": "deno fmt --check", 7 | "test:lint": "deno lint", 8 | "test:unit": "deno test -A", 9 | "test:types": "deno check mod.ts", 10 | "build:npm": "deno run --allow-sys --allow-env --allow-read --allow-write --allow-net --allow-run scripts/build_npm.ts" 11 | }, 12 | "imports": { 13 | "@deno/dnt": "jsr:@deno/dnt@^0.41.1", 14 | "@std/assert": "jsr:@std/assert@^0.221.0", 15 | "@std/fmt": "jsr:@std/fmt@^0.221.0" 16 | }, 17 | "exports": { 18 | ".": "./mod.ts", 19 | "./iterable_weak_map": "./iterable_weak_map.ts", 20 | "./iterable_weak_set": "./iterable_weak_set.ts", 21 | "./weak_value_map": "./weak_value_map.ts" 22 | }, 23 | "lint": { 24 | "exclude": [".npm"] 25 | }, 26 | "fmt": { 27 | "exclude": [".npm"] 28 | }, 29 | "lock": false 30 | } 31 | -------------------------------------------------------------------------------- /iterable_weak_map.test.ts: -------------------------------------------------------------------------------- 1 | import { assert, assertEquals, assertFalse } from "@std/assert"; 2 | import { IterableWeakMap } from "./iterable_weak_map.ts"; 3 | 4 | function* iterate(items: T[]): IterableIterator { 5 | for (const item of items) { 6 | yield item; 7 | } 8 | } 9 | 10 | Deno.test("IterableWeakMap, constructor", () => { 11 | assertEquals(new IterableWeakMap().size, 0); 12 | assertEquals(new IterableWeakMap(undefined).size, 0); 13 | assertEquals(new IterableWeakMap(null).size, 0); 14 | 15 | assertEquals(new IterableWeakMap([]).size, 0); 16 | assertEquals(new IterableWeakMap(iterate([])).size, 0); 17 | 18 | assertEquals(new IterableWeakMap([[{}, 1]]).size, 1); 19 | assertEquals(new IterableWeakMap(iterate([[{}, 1] as const])).size, 1); 20 | }); 21 | 22 | Deno.test("IterableWeakMap, comparison Map, WeakMap", () => { 23 | const map = new Map(); 24 | const wmap = new WeakMap(); 25 | const iwmap = new IterableWeakMap(); 26 | 27 | assertEquals(map.size, 0); 28 | // assertEquals(wmap.size, 0); 29 | assertEquals(iwmap.size, 0); 30 | 31 | const obj1 = {}; 32 | const obj2 = {}; 33 | 34 | assertEquals(map.get(obj1), undefined); 35 | assertEquals(wmap.get(obj1), undefined); 36 | assertEquals(iwmap.get(obj1), undefined); 37 | 38 | assertEquals(map.set(obj1, "1"), map); 39 | assertEquals(wmap.set(obj1, "1"), wmap); 40 | assertEquals(iwmap.set(obj1, "1"), iwmap); 41 | 42 | assertEquals(map.get(obj1), "1"); 43 | assertEquals(wmap.get(obj1), "1"); 44 | assertEquals(iwmap.get(obj1), "1"); 45 | 46 | assertEquals(map.size, 1); 47 | // assertEquals(wmap.size, 0); 48 | assertEquals(iwmap.size, 1); 49 | 50 | // add the same object again 51 | assertEquals(map.set(obj1, "2"), map); 52 | assertEquals(wmap.set(obj1, "2"), wmap); 53 | assertEquals(iwmap.set(obj1, "2"), iwmap); 54 | 55 | assertEquals(map.get(obj1), "2"); 56 | assertEquals(wmap.get(obj1), "2"); 57 | assertEquals(iwmap.get(obj1), "2"); 58 | 59 | assertEquals(map.size, 1); 60 | // assertEquals(wmap.size, 0); 61 | assertEquals(iwmap.size, 1); 62 | 63 | assertEquals(map.set(obj2, true), map); 64 | assertEquals(wmap.set(obj2, true), wmap); 65 | assertEquals(iwmap.set(obj2, true), iwmap); 66 | 67 | assertEquals(map.size, 2); 68 | // assertEquals(wmap.size, 0); 69 | assertEquals(iwmap.size, 2); 70 | 71 | assert(map.has(obj1)); 72 | assert(wmap.has(obj1)); 73 | assert(iwmap.has(obj1)); 74 | 75 | // delete the object 76 | assert(map.delete(obj1)); 77 | assert(wmap.delete(obj1)); 78 | assert(iwmap.delete(obj1)); 79 | 80 | assertEquals(map.size, 1); 81 | // assertEquals(wmap.size, 0); 82 | assertEquals(iwmap.size, 1); 83 | 84 | assertFalse(map.delete(obj1)); 85 | assertFalse(wmap.delete(obj1)); 86 | assertFalse(iwmap.delete(obj1)); 87 | 88 | assertEquals(map.size, 1); 89 | // assertEquals(wmap.size, 0); 90 | assertEquals(iwmap.size, 1); 91 | 92 | assertFalse(map.has(obj1)); 93 | assertFalse(wmap.has(obj1)); 94 | assertFalse(iwmap.has(obj1)); 95 | 96 | assertEquals(map.get(obj1), undefined); 97 | assertEquals(wmap.get(obj1), undefined); 98 | assertEquals(iwmap.get(obj1), undefined); 99 | 100 | assertFalse(map.clear()); 101 | // assertFalse(wmap.clear()); 102 | assertFalse(iwmap.clear()); 103 | 104 | assertEquals(map.size, 0); 105 | // assertEquals(wmap.size, 0); 106 | assertEquals(iwmap.size, 0); 107 | 108 | assertEquals(map.toString(), "[object Map]"); 109 | assertEquals(wmap.toString(), "[object WeakMap]"); 110 | assertEquals(iwmap.toString(), "[object IterableWeakMap]"); 111 | }); 112 | 113 | Deno.test("IterableWeakMap, iterable", () => { 114 | const tuples: [Record, number][] = [[{}, 1], [{}, 2], [ 115 | {}, 116 | 3, 117 | ]]; 118 | 119 | const maps = [ 120 | new Map(tuples), 121 | new IterableWeakMap(tuples), 122 | ]; 123 | 124 | for (const map of maps) { 125 | assertEquals(map.size, 3); 126 | 127 | { 128 | let i = 0; 129 | map.forEach(function (this: unknown, k, v, s) { 130 | assert(this === undefined); 131 | assert(k === tuples[i][1]); 132 | assert(v === tuples[i][0]); 133 | assert(s === map); 134 | i++; 135 | }); 136 | assertFalse(i === 0); 137 | } 138 | { 139 | let i = 0; 140 | map.forEach(function (this: unknown, k, v, s) { 141 | assert(this === ":D"); 142 | assert(k === tuples[i][1]); 143 | assert(v === tuples[i][0]); 144 | assert(s === map); 145 | i++; 146 | }, ":D"); 147 | assertFalse(i === 0); 148 | } 149 | { 150 | let i = 0; 151 | for (const [k, v] of map) { 152 | assert(k === tuples[i][0]); 153 | assert(v === tuples[i++][1]); 154 | } 155 | assertFalse(i === 0); 156 | } 157 | { 158 | let i = 0; 159 | for (const k of map.keys()) { 160 | assert(k === tuples[i++][0]); 161 | } 162 | assertFalse(i === 0); 163 | } 164 | { 165 | let i = 0; 166 | for (const v of map.values()) { 167 | assert(v === tuples[i++][1]); 168 | } 169 | assertFalse(i === 0); 170 | } 171 | { 172 | let i = 0; 173 | for (const [k, v] of map.entries()) { 174 | assert(k === tuples[i][0]); 175 | assert(v === tuples[i++][1]); 176 | } 177 | assertFalse(i === 0); 178 | } 179 | } 180 | }); 181 | 182 | Deno.test("IterableWeakMap, garbage collect", async () => { 183 | let removedCount = 0; 184 | let insertedCount = 0; 185 | const register = new FinalizationRegistry(() => { 186 | removedCount++; 187 | }); 188 | 189 | const map = new IterableWeakMap(); 190 | for (let i = 0; removedCount < 100; i++) { 191 | await new Promise((resolve) => setTimeout(resolve, 16)); 192 | const data = {}; 193 | map.set(data, i); 194 | register.register(data, i); 195 | insertedCount++; 196 | } 197 | 198 | assertEquals(insertedCount - removedCount, map.size); 199 | assertEquals([...map].length, map.size); 200 | }); 201 | -------------------------------------------------------------------------------- /iterable_weak_map.ts: -------------------------------------------------------------------------------- 1 | import { IterableWeakSet } from "./iterable_weak_set.ts"; 2 | 3 | export class IterableWeakMap 4 | implements WeakMap, Map { 5 | #weakMap = new WeakMap(); 6 | #set = new IterableWeakSet(); 7 | 8 | constructor(entries?: readonly (readonly [K, V])[] | null); 9 | constructor(iterable: Iterable); 10 | constructor(iterable?: Iterable | null) { 11 | for (const [key, value] of iterable ?? []) { 12 | this.set(key, value); 13 | } 14 | } 15 | 16 | get size(): number { 17 | return this.#set.size; 18 | } 19 | 20 | clear(): void { 21 | for (const key of this.#set) { 22 | this.delete(key); 23 | } 24 | } 25 | 26 | delete(key: K): boolean { 27 | const ref = this.#weakMap.get(key); 28 | if (ref) { 29 | this.#weakMap.delete(key); 30 | this.#set.delete(key); 31 | return true; 32 | } 33 | return false; 34 | } 35 | 36 | get(key: K): V | undefined { 37 | return this.#weakMap.get(key); 38 | } 39 | 40 | has(key: K): boolean { 41 | return this.#weakMap.has(key); 42 | } 43 | 44 | set(key: K, value: V): this { 45 | this.#weakMap.set(key, value); 46 | this.#set.add(key); 47 | return this; 48 | } 49 | 50 | get [Symbol.toStringTag](): string { 51 | return "IterableWeakMap"; 52 | } 53 | 54 | forEach( 55 | callbackfn: (value: V, key: K, map: Map) => void, 56 | thisArg?: unknown, 57 | ): void { 58 | for (const [key, value] of this[Symbol.iterator]()) { 59 | callbackfn.call(thisArg, value, key, this); 60 | } 61 | } 62 | 63 | *[Symbol.iterator](): IterableIterator<[K, V]> { 64 | for (const key of this.#set) { 65 | yield [key, this.#weakMap.get(key)!]; 66 | } 67 | } 68 | 69 | entries(): IterableIterator<[K, V]> { 70 | return this[Symbol.iterator](); 71 | } 72 | 73 | keys(): IterableIterator { 74 | return this.#set[Symbol.iterator](); 75 | } 76 | 77 | *values(): IterableIterator { 78 | for (const key of this.#set) { 79 | yield this.#weakMap.get(key)!; 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /iterable_weak_set.test.ts: -------------------------------------------------------------------------------- 1 | import { assert, assertEquals, assertFalse } from "@std/assert"; 2 | import { IterableWeakSet } from "./iterable_weak_set.ts"; 3 | 4 | function* iterate(items: T[]): IterableIterator { 5 | for (const item of items) { 6 | yield item; 7 | } 8 | } 9 | 10 | Deno.test("IterableWeakSet, constructor", () => { 11 | assertEquals(new IterableWeakSet().size, 0); 12 | assertEquals(new IterableWeakSet(undefined).size, 0); 13 | assertEquals(new IterableWeakSet(null).size, 0); 14 | 15 | assertEquals(new IterableWeakSet([]).size, 0); 16 | assertEquals(new IterableWeakSet(iterate([])).size, 0); 17 | 18 | assertEquals(new IterableWeakSet([{}]).size, 1); 19 | assertEquals(new IterableWeakSet(iterate([{}])).size, 1); 20 | }); 21 | 22 | Deno.test("IterableWeakSet, comparison Set, WeakSet", () => { 23 | const set = new Set(); 24 | const wset = new WeakSet(); 25 | const iwset = new IterableWeakSet(); 26 | 27 | assertEquals(set.size, 0); 28 | // assertEquals(wset.size, 0); 29 | assertEquals(iwset.size, 0); 30 | 31 | const obj1 = {}; 32 | const obj2 = {}; 33 | 34 | assertEquals(set.add(obj1), set); 35 | assertEquals(wset.add(obj1), wset); 36 | assertEquals(iwset.add(obj1), iwset); 37 | 38 | assertEquals(set.size, 1); 39 | // assertEquals(wset.size, 0); 40 | assertEquals(iwset.size, 1); 41 | 42 | // add the same object again 43 | assertEquals(set.add(obj1), set); 44 | assertEquals(wset.add(obj1), wset); 45 | assertEquals(iwset.add(obj1), iwset); 46 | 47 | assertEquals(set.size, 1); 48 | // assertEquals(wset.size, 0); 49 | assertEquals(iwset.size, 1); 50 | 51 | assertEquals(set.add(obj2), set); 52 | assertEquals(wset.add(obj2), wset); 53 | assertEquals(iwset.add(obj2), iwset); 54 | 55 | assertEquals(set.size, 2); 56 | // assertEquals(wset.size, 0); 57 | assertEquals(iwset.size, 2); 58 | 59 | assert(set.has(obj1)); 60 | assert(wset.has(obj1)); 61 | assert(iwset.has(obj1)); 62 | 63 | // delete the object 64 | assert(set.delete(obj1)); 65 | assert(wset.delete(obj1)); 66 | assert(iwset.delete(obj1)); 67 | 68 | assertEquals(set.size, 1); 69 | // assertEquals(wset.size, 0); 70 | assertEquals(iwset.size, 1); 71 | 72 | assertFalse(set.delete(obj1)); 73 | assertFalse(wset.delete(obj1)); 74 | assertFalse(iwset.delete(obj1)); 75 | 76 | assertEquals(set.size, 1); 77 | // assertEquals(wset.size, 0); 78 | assertEquals(iwset.size, 1); 79 | 80 | assertFalse(set.has(obj1)); 81 | assertFalse(wset.has(obj1)); 82 | assertFalse(iwset.has(obj1)); 83 | 84 | assertFalse(set.clear()); 85 | // assertFalse(wset.clear()); 86 | assertFalse(iwset.clear()); 87 | 88 | assertEquals(set.size, 0); 89 | // assertEquals(wset.size, 0); 90 | assertEquals(iwset.size, 0); 91 | 92 | assertEquals(set.toString(), "[object Set]"); 93 | assertEquals(wset.toString(), "[object WeakSet]"); 94 | assertEquals(iwset.toString(), "[object IterableWeakSet]"); 95 | }); 96 | 97 | Deno.test("IterableWeakSet, iterable", () => { 98 | const objs = [{}, {}, {}]; 99 | 100 | const sets = [ 101 | new Set(objs), 102 | new IterableWeakSet(objs), 103 | ]; 104 | 105 | for (const set of sets) { 106 | assertEquals(set.size, 3); 107 | 108 | { 109 | let i = 0; 110 | set.forEach(function (this: unknown, v1, v2, s) { 111 | assert(this === undefined); 112 | assert(v1 === objs[i]); 113 | assert(v2 === objs[i]); 114 | assert(s === set); 115 | i++; 116 | }); 117 | assertFalse(i === 0); 118 | } 119 | { 120 | let i = 0; 121 | set.forEach(function (this: unknown, v1, v2, s) { 122 | assert(this === ":D"); 123 | assert(v1 === objs[i]); 124 | assert(v2 === objs[i]); 125 | assert(s === set); 126 | i++; 127 | }, ":D"); 128 | assertFalse(i === 0); 129 | } 130 | { 131 | let i = 0; 132 | for (const obj of set) { 133 | assert(obj === objs[i++]); 134 | } 135 | assertFalse(i === 0); 136 | } 137 | { 138 | let i = 0; 139 | for (const obj of set.keys()) { 140 | assert(obj === objs[i++]); 141 | } 142 | assertFalse(i === 0); 143 | } 144 | { 145 | let i = 0; 146 | for (const obj of set.values()) { 147 | assert(obj === objs[i++]); 148 | } 149 | assertFalse(i === 0); 150 | } 151 | { 152 | let i = 0; 153 | for (const tuple of set.entries()) { 154 | assert(tuple[0] === objs[i]); 155 | assert(tuple[1] === objs[i++]); 156 | } 157 | assertFalse(i === 0); 158 | } 159 | } 160 | }); 161 | 162 | Deno.test("IterableWeakSet, garbage collect", async () => { 163 | let removedCount = 0; 164 | let insertedCount = 0; 165 | const register = new FinalizationRegistry(() => { 166 | removedCount++; 167 | }); 168 | 169 | const set = new IterableWeakSet(); 170 | for (let i = 0; removedCount < 100; i++) { 171 | await new Promise((resolve) => setTimeout(resolve, 16)); 172 | const data = {}; 173 | set.add(data); 174 | register.register(data, i); 175 | insertedCount++; 176 | } 177 | 178 | assertEquals(insertedCount - removedCount, set.size); 179 | assertEquals([...set].length, set.size); 180 | }); 181 | -------------------------------------------------------------------------------- /iterable_weak_set.ts: -------------------------------------------------------------------------------- 1 | export class IterableWeakSet implements 2 | WeakSet, 3 | Omit< 4 | Set, 5 | | "add" // override to return this 6 | | "forEach" // override to call callbackfn with IterableWeakSet 7 | | "union" // not implemented 8 | | "intersection" // not implemented 9 | | "difference" // not implemented 10 | | "symmetricDifference" // not implemented 11 | | "isSubsetOf" // not implemented 12 | | "isSupersetOf" // not implemented 13 | | "isDisjointFrom" // not implemented 14 | > { 15 | #weakMap = new WeakMap>(); 16 | #set = new Set>(); 17 | #registry = new FinalizationRegistry>( 18 | this.#set.delete.bind(this.#set), 19 | ); 20 | 21 | constructor(values?: readonly T[] | null); 22 | constructor(iterable: Iterable); 23 | constructor(iterable: Iterable | null = null) { 24 | for (const value of iterable ?? []) { 25 | this.add(value); 26 | } 27 | } 28 | 29 | get size(): number { 30 | return this.#set.size; 31 | } 32 | 33 | add(value: T): this { 34 | if (this.has(value)) { 35 | return this; 36 | } 37 | const ref = new WeakRef(value); 38 | this.#weakMap.set(value, ref); 39 | this.#set.add(ref); 40 | this.#registry.register(value, ref, ref); 41 | return this; 42 | } 43 | 44 | clear(): void { 45 | for (const value of this.#set) { 46 | this.delete(value.deref()!); 47 | } 48 | } 49 | 50 | delete(value: T): boolean { 51 | const ref = this.#weakMap.get(value); 52 | if (ref) { 53 | this.#set.delete(ref); 54 | this.#weakMap.delete(value); 55 | this.#registry.unregister(ref); 56 | return true; 57 | } 58 | return false; 59 | } 60 | 61 | has(value: T): boolean { 62 | return this.#weakMap.has(value); 63 | } 64 | 65 | forEach( 66 | callbackfn: (value: T, value2: T, set: IterableWeakSet) => void, 67 | thisArg?: unknown, 68 | ): void { 69 | for (const tuple of this.entries()) { 70 | callbackfn.call(thisArg, tuple[0], tuple[1], this); 71 | } 72 | } 73 | 74 | get [Symbol.toStringTag](): string { 75 | return "IterableWeakSet"; 76 | } 77 | 78 | *[Symbol.iterator](): IterableIterator { 79 | for (const ref of this.#set) { 80 | yield ref.deref()!; 81 | } 82 | } 83 | 84 | *entries(): IterableIterator<[T, T]> { 85 | for (const ref of this.#set) { 86 | const value = ref.deref()!; 87 | yield [value, value]; 88 | } 89 | } 90 | 91 | keys(): IterableIterator { 92 | return this[Symbol.iterator](); 93 | } 94 | 95 | values(): IterableIterator { 96 | return this[Symbol.iterator](); 97 | } 98 | } 99 | -------------------------------------------------------------------------------- /mod.ts: -------------------------------------------------------------------------------- 1 | export { IterableWeakSet } from "./iterable_weak_set.ts"; 2 | export { IterableWeakMap } from "./iterable_weak_map.ts"; 3 | 4 | export { WeakValueMap } from "./weak_value_map.ts"; 5 | -------------------------------------------------------------------------------- /scripts/build_npm.ts: -------------------------------------------------------------------------------- 1 | import { build, emptyDir } from "@deno/dnt"; 2 | import { bgGreen } from "@std/fmt/colors"; 3 | 4 | const denoInfo = JSON.parse( 5 | Deno.readTextFileSync(new URL("../deno.json", import.meta.url)), 6 | ); 7 | const version = denoInfo.version; 8 | 9 | console.log(bgGreen(`version: ${version}`)); 10 | 11 | await emptyDir("./.npm"); 12 | 13 | await build({ 14 | entryPoints: [ 15 | "./mod.ts", 16 | ], 17 | outDir: "./.npm", 18 | test: false, 19 | compilerOptions: { 20 | lib: ["ES2022"], 21 | }, 22 | shims: { 23 | deno: false, 24 | }, 25 | package: { 26 | name: "weakref", 27 | version, 28 | description: 29 | "Extend built-in collections with weak references for efficient garbage collection and optimal performance in memory-intensive applications with IterableWeakSet, IterableWeakMap, and WeakValueMap.", 30 | keywords: [ 31 | "weakref", 32 | "weakset", 33 | "weakmap", 34 | "weak", 35 | "iterable", 36 | "weak references", 37 | ], 38 | license: "MIT", 39 | repository: { 40 | type: "git", 41 | url: "git+https://github.com/denostack/weakref.git", 42 | }, 43 | bugs: { 44 | url: "https://github.com/denostack/weakref/issues", 45 | }, 46 | }, 47 | }); 48 | 49 | // post build steps 50 | Deno.copyFileSync("README.md", ".npm/README.md"); 51 | -------------------------------------------------------------------------------- /weak_value_map.test.ts: -------------------------------------------------------------------------------- 1 | import { assert, assertEquals, assertFalse } from "@std/assert"; 2 | import { WeakValueMap } from "./weak_value_map.ts"; 3 | 4 | function* iterate(items: T[]): IterableIterator { 5 | for (const item of items) { 6 | yield item; 7 | } 8 | } 9 | 10 | Deno.test("WeakValueMap, constructor", () => { 11 | assertEquals(new WeakValueMap().size, 0); 12 | assertEquals(new WeakValueMap(undefined).size, 0); 13 | assertEquals(new WeakValueMap(null).size, 0); 14 | 15 | assertEquals(new WeakValueMap([]).size, 0); 16 | assertEquals(new WeakValueMap(iterate([])).size, 0); 17 | 18 | assertEquals(new WeakValueMap([[1, {}]]).size, 1); 19 | assertEquals(new WeakValueMap(iterate([[1, {}] as const])).size, 1); 20 | }); 21 | 22 | Deno.test("WeakValueMap, comparison Map, WeakMap", () => { 23 | const map = new Map(); 24 | const iwmap = new WeakValueMap(); 25 | 26 | assertEquals(map.size, 0); 27 | assertEquals(iwmap.size, 0); 28 | 29 | const obj1 = {}; 30 | const obj2 = {}; 31 | 32 | assertEquals(map.get("1"), undefined); 33 | assertEquals(iwmap.get("1"), undefined); 34 | 35 | assertEquals(map.set("1", obj1), map); 36 | assertEquals(iwmap.set("1", obj1), iwmap); 37 | 38 | assertEquals(map.get("1"), obj1); 39 | assertEquals(iwmap.get("1"), obj1); 40 | 41 | assertEquals(map.size, 1); 42 | assertEquals(iwmap.size, 1); 43 | 44 | // add the same object again 45 | assertEquals(map.set("1", obj2), map); 46 | assertEquals(iwmap.set("1", obj2), iwmap); 47 | 48 | assertEquals(map.get("1"), obj2); 49 | assertEquals(iwmap.get("1"), obj2); 50 | 51 | assertEquals(map.size, 1); 52 | assertEquals(iwmap.size, 1); 53 | 54 | assertEquals(map.set(2, obj1), map); 55 | assertEquals(iwmap.set(2, obj1), iwmap); 56 | 57 | assertEquals(map.size, 2); 58 | assertEquals(iwmap.size, 2); 59 | 60 | assert(map.has(2)); 61 | assert(iwmap.has(2)); 62 | 63 | // delete the object 64 | assert(map.delete("1")); 65 | assert(iwmap.delete("1")); 66 | 67 | assertEquals(map.size, 1); 68 | assertEquals(iwmap.size, 1); 69 | 70 | assertFalse(map.delete("1")); 71 | assertFalse(iwmap.delete("1")); 72 | 73 | assertEquals(map.size, 1); 74 | assertEquals(iwmap.size, 1); 75 | 76 | assertFalse(map.has("1")); 77 | assertFalse(iwmap.has("1")); 78 | 79 | assertEquals(map.get("1"), undefined); 80 | assertEquals(iwmap.get("1"), undefined); 81 | 82 | assertFalse(map.clear()); 83 | assertFalse(iwmap.clear()); 84 | 85 | assertEquals(map.size, 0); 86 | assertEquals(iwmap.size, 0); 87 | 88 | assertEquals(map.toString(), "[object Map]"); 89 | assertEquals(iwmap.toString(), "[object WeakValueMap]"); 90 | }); 91 | 92 | Deno.test("WeakValueMap, iterable", () => { 93 | const tuples: [number | string | boolean, Record][] = [ 94 | [1, {}], 95 | ["2", {}], 96 | [ 97 | false, 98 | {}, 99 | ], 100 | ]; 101 | 102 | const maps = [ 103 | new Map(tuples), 104 | new WeakValueMap(tuples), 105 | ]; 106 | 107 | for (const map of maps) { 108 | assertEquals(map.size, 3); 109 | 110 | { 111 | let i = 0; 112 | map.forEach(function (this: unknown, k, v, s) { 113 | assert(this === undefined); 114 | assert(k === tuples[i][1]); 115 | assert(v === tuples[i][0]); 116 | assert(s === map); 117 | i++; 118 | }); 119 | assertFalse(i === 0); 120 | } 121 | { 122 | let i = 0; 123 | map.forEach(function (this: unknown, k, v, s) { 124 | assert(this === ":D"); 125 | assert(k === tuples[i][1]); 126 | assert(v === tuples[i][0]); 127 | assert(s === map); 128 | i++; 129 | }, ":D"); 130 | assertFalse(i === 0); 131 | } 132 | { 133 | let i = 0; 134 | for (const [k, v] of map) { 135 | assert(k === tuples[i][0]); 136 | assert(v === tuples[i++][1]); 137 | } 138 | assertFalse(i === 0); 139 | } 140 | { 141 | let i = 0; 142 | for (const k of map.keys()) { 143 | assert(k === tuples[i++][0]); 144 | } 145 | assertFalse(i === 0); 146 | } 147 | { 148 | let i = 0; 149 | for (const v of map.values()) { 150 | assert(v === tuples[i++][1]); 151 | } 152 | assertFalse(i === 0); 153 | } 154 | { 155 | let i = 0; 156 | for (const [k, v] of map.entries()) { 157 | assert(k === tuples[i][0]); 158 | assert(v === tuples[i++][1]); 159 | } 160 | assertFalse(i === 0); 161 | } 162 | } 163 | }); 164 | 165 | Deno.test("WeakValueMap, garbage collect", async () => { 166 | let removedCount = 0; 167 | let insertedCount = 0; 168 | const register = new FinalizationRegistry(() => { 169 | removedCount++; 170 | }); 171 | 172 | const map = new WeakValueMap(); 173 | for (let i = 0; removedCount < 100; i++) { 174 | await new Promise((resolve) => setTimeout(resolve, 16)); 175 | const data = {}; 176 | map.set(i, data); 177 | register.register(data, i); 178 | insertedCount++; 179 | } 180 | 181 | assertEquals(insertedCount - removedCount, map.size); 182 | assertEquals([...map].length, map.size); 183 | }); 184 | -------------------------------------------------------------------------------- /weak_value_map.ts: -------------------------------------------------------------------------------- 1 | export class WeakValueMap implements Map { 2 | #map = new Map>(); 3 | #registry = new FinalizationRegistry(this.#map.delete.bind(this.#map)); 4 | 5 | constructor(entries?: readonly (readonly [K, V])[] | null); 6 | constructor(iterable: Iterable); 7 | constructor(iterable?: Iterable | null) { 8 | for (const [key, value] of iterable ?? []) { 9 | this.set(key, value); 10 | } 11 | } 12 | 13 | get size(): number { 14 | return this.#map.size; 15 | } 16 | 17 | clear(): void { 18 | for (const key of this.#map.keys()) { 19 | this.delete(key); 20 | } 21 | } 22 | 23 | delete(key: K): boolean { 24 | const ref = this.#map.get(key); 25 | if (ref) { 26 | this.#map.delete(key); 27 | this.#registry.unregister(ref); 28 | return true; 29 | } 30 | return false; 31 | } 32 | 33 | get(key: K): V | undefined { 34 | return this.#map.get(key)?.deref(); 35 | } 36 | 37 | has(key: K): boolean { 38 | return this.#map.has(key); 39 | } 40 | 41 | set(key: K, value: V): this { 42 | const ref = new WeakRef(value); 43 | this.#map.set(key, ref); 44 | this.#registry.register(value, key, ref); 45 | return this; 46 | } 47 | 48 | get [Symbol.toStringTag](): string { 49 | return "WeakValueMap"; 50 | } 51 | 52 | forEach( 53 | callbackfn: (value: V, key: K, map: Map) => void, 54 | thisArg?: unknown, 55 | ): void { 56 | for (const [key, value] of this[Symbol.iterator]()) { 57 | callbackfn.call(thisArg, value, key, this); 58 | } 59 | } 60 | 61 | *[Symbol.iterator](): IterableIterator<[K, V]> { 62 | for (const [key, ref] of this.#map) { 63 | yield [key, ref.deref()!]; 64 | } 65 | } 66 | 67 | entries(): IterableIterator<[K, V]> { 68 | return this[Symbol.iterator](); 69 | } 70 | 71 | keys(): IterableIterator { 72 | return this.#map.keys(); 73 | } 74 | 75 | *values(): IterableIterator { 76 | for (const ref of this.#map.values()) { 77 | yield ref.deref()!; 78 | } 79 | } 80 | } 81 | --------------------------------------------------------------------------------