([[\"james\", 10]]);\n// [[\"james\", 10]]\nuserFollowers.delete(\"james\");\n// []\nuserFollowers.set(\"dude\", 12);\n// [[\"dude\", 12]]\nuserFollowers.set({\n james: 8,\n})\n// [[\"james\", 8]]\nuserFollowers.set({\n james: 6,\n dude: 10\n})\n// [[\"james\", 6], [\"dude\", 10]]\nuserFollowers.patch({\n dude: 12\n})\n// [[\"james\", 6], [\"dude\", 12]]\n```\n\n```tsx\nfunction UserFollowers(props: { userName: string }) {\n const followers = userFollowers.use(props.userName);\n\n return Followers: {followers || 0}
;\n}\n\nfunction TotalFollowers() {\n const totalFollowers = Array.from(userFollowers.use().entries()).reduce(\n (totalFollowers, [userName, followers]) => totalFollowers + followers,\n 0,\n );\n\n return Total followers: {totalFollowers || 0}
;\n}\n```\n\n## `AbonArray`\n\nA subscribable implementation of a normal array, with some additional methods.\n\n```typescript\nimport { AbonArray } from \"abon\";\n\nconst indexes = new AbonArray();\nindexes.push(2, 4, 5, 9);\nconst index = indexes.find(index => index > 5); // 9\n```\n\n## `AbonItems`\n\nAllows for dynamically setting, pushing, unshifting, and subscribing to property-identified values. \n\n```typescript\nimport { AbonItems } from \"abon\";\n\nconst items = new AbonItems<{ itemId: number; name: string; }, \"itemId\">(\"itemId\", [{ itemId: 5, name: \"Jason\" }]);\n\nitems.push({ itemId: 2, name: \"Luke\" })\n// items.ids.current: [5, 2]\nitems.unshift({ itemId: 3, name: \"Marie\" })\n// items.ids.current: [3, 5, 2]\nitems.set([{ itemId: 7, name: \"Mason\" }, { itemId: 1, name: \"Chlorine\" }])\n// items.ids.current: [7, 1]\nitems.delete(7)\n// items.ids.current: [1]\n// items.items: [{ itemId: 1, name: \"Chlorine\" }]\n// items.current: { 1: { itemId: 1, name: \"Chlorine\" } }\nitems.set(5, \"name\", \"Jake\")\n// does not make difference because an item where `itemId === 5` does not exist\nitems.set(7, \"name\", \"Charlotte\")\n// items.items: [{ itemId: 7, name: \"Charlotte\" }]\n\nitems.subscribe((current, items, ids) => {\n // items equal ids.map(id => current[id])\n})\n```\n\n## `AbonAsync`\n\nAllows for cancelling/overriding the process of setting values that are retrieved asynchronously by providing them as promises. For that purpose, the `set` methods accepts a promise whose value is to be set once it is resolved unless a different value is set during that time. Additionally, the `dispatch` method allows for handling promises unrelated to the value, meaning the passed handler is called if no new value is set during the time of the resolution of the passed promise.\n\n```typescript\nimport { AbonAsync } from \"abon\";\n\nconst name = new AbonAsync();\n\nconst namePromises = [\n new Promise((resolve) => setTimeout(() => resolve(\"Hjalmar\"), 100)),\n new Promise((resolve) => setTimeout(() => resolve(\"Sören\"), 400)),\n new Promise((resolve) => setTimeout(() => resolve(\"Rory\"), 300)),\n];\n\nname.set(namePromises[3] /** Promise<\"Rory\"> */);\nname.promise.then((currentName) => { /** \"Sören\", since it is set last. */ });\nname.dispatch(Promise.resolve(), () => { /** Never called, because the next line is set before `Promise.resolve()` has been resolved. */ })\nname.set(namePromises[2] /** Promise<\"Sören\"> */);\n\nname.promise.then((currentName) => { /** \"Sören\", too. */ \n name.set(namePromises[0] /** Promise<\"Hjalmar\"> */);\n name.promise.then((currentName) => { /** \"Joker\", since it is set last. */ });\n name.set(\"Joker\");\n});\n```\n\n## `AbonInheritedDown`\n\nImagine a tree of values, where all branches and sub-branches inherit from their parent, unless they have a value defined themselves. This is useful, for example, for having nodes that can inherit a status from their parents, such as a loading status for form fields in a form.\n\n```typescript\nimport { AbonInheritedDown } from \"abon\";\n\nconst value = new AbonInheritedDown(1);\nconst subValue = value.nest()\nconst subSubValue = subValue.nest()\n\nvalue.current // 1, from itself\nsubSubValue.current // 1, from `value`\nsubValue.set(2);\nsubSubValue.current // 2, from `subValue`\nsubValue.current // 2, from itself\nsubSubValue.set(3);\nsubSubValue.current // 3, from itself\nsubSubValue.set(undefined);\nsubSubValue.current // 2, from `subValue`\nsubValue.set(undefined);\nsubSubValue.current // 1, from `value`\nvalue.set(undefined)\nsubSubValue.current // undefined\nsubValue.current // undefined\nvalue.current // undefined\n```\n\n## `AbonInheritedUp`\n\nEvery branch looks to itself or to any of its children (added using the `addChild` method) for a defined value.\n\n```typescript\nimport { AbonInheritedDown } from \"abon\";\n\nconst name = new AbonInheritedUp();\nconst subName = name.addChild();\nconst subSubName = subName.addChild()\n\nname.current // undefined\nsubSubName.set(\"Mike\");\nname.current // \"Mike\", from `subSubName`\nsubName.current // \"Mike\", from `subSubName`\nsubSubName.current // \"Mike\", from itself\nsubName.set(\"Oprah\");\nname.current // \"Oprah\", from `subName`\nsubName.current // \"Oprah\", from itself\nsubSubName.current // \"Mike\", from itself\nsubSubName.set(undefined);\nname.current // \"Oprah\", from `subName`\nsubName.current // \"Oprah\", from itself\nsubSubName.current // undefined\nsubName.set(undefined);\nname.current // undefined\nsubName.current // undefined\nsubSubName.current // undefined\n```\n\n## Utility\n\nThe `Abon` class provides some static utility for composing and constructing the instances described above.\n\n### `Abon.useComposedValue`\n\nCreate an Abon with a value based on one or more subscriptions. Dependencies can be passed as a third argument, which means the value will be recalculated if either (1) the listener is notified or (2) the dependencies have changed. Changing the dependencies also re-subscribes (meaning you can change the subscriptions).\n\nThere is also `Abon.useComposedValueAsync`, which allows for returning a promise from the getter function, meaning the value returned from the hook will be undefined at first.\n\n```tsx\nimport { Abon, AbonDeep } from \"abon\";\n\nfunction PriceStatus() {\n const price = Abon.useRef(() => 10);\n const fullPrice = Abon.useRef(() => 100);\n\n // `0.1` initially, then updates whenever `price` or `fullPrice` change\n const priceFraction = Abon.useComposedValue(\n () => price.current / fullPrice.current,\n (listener) => [fullPrice.subscribe(listener), price.subscribe(listener)],\n [price, fullPrice]\n );\n\n if (priceFraction < 0.1) {\n return Good price!
;\n }\n\n return Bad price.
;\n}\n```\n\n### `Abon.resolve`\n\nReturns a promise resolved by the next value set to the provided Abon. You can also pass a function accepting a listener and returning a created subscription, which will resolve the promise with the value that is passed to the listener.\n\n```tsx\nimport { Abon } from \"abon\";\n\nconst value = new Abon(0);\n\nAbon.resolve(value).then((_value) => { /** 1 */ })\nvalue.set(1);\n```\n\n## Authors\n\n- Ludvig Aldén [@ludvigalden](https://github.com/ludvigalden)\n\n---\n\n[MIT License.](https://github.com/ludvigalden/abon/blob/master/LICENSE)\n","readmeFilename":"README.md"}![\"abon.js\"](\"https://user-images.githubusercontent.com/30798446/76517645-f433e800-645d-11ea-8d85-e83424827956.png\")
\n