refactor: reduce bundle size

Author: crimx

mangle-cache.json

@@ -1,5 +1,6 @@
 {
   "addDep_": "d",
+  "batching_": "c",
   "data_": "a",
   "delete_": "l",
   "dependents_": "n",
@@ -10,5 +11,6 @@
   "onReaction_": "o",
   "single_": "s",
   "task_": "k",
+  "tasks_": "t",
   "upsert_": "u"
 }

src/collections/reactiveMap.ts

@@ -1,7 +1,7 @@
 import { batchFlush, batchStart, type BatchTask, tasks } from "../batch";
-import { type EventObject, on, send, size } from "../event";
+import { type EventObject, on, type RemoveListener, send, size } from "../event";
 import { writable } from "../readable";
-import { type Disposer, type OwnedWritable, type Readable } from "../typings";
+import { type OwnedWritable, type Readable } from "../typings";
 import { strictEqual } from "../utils";
 
 export interface ReactiveMapChanged<K, V> {
@@ -32,7 +32,7 @@ export class OwnedReactiveMap<K, V> extends Map<K, V> {
    * @param fn - The function to call when the map is changed.
    * @returns A disposer function to unsubscribe from the event.
    */
-  public onChanged(fn: (changed: ReactiveMapChanged<K, V>) => void): Disposer {
+  public onChanged(fn: (changed: ReactiveMapChanged<K, V>) => void): RemoveListener {
     return on(
       (this._onChanged_ ??= {
         delete_: new Set<K>(),
@@ -72,7 +72,7 @@ export class OwnedReactiveMap<K, V> extends Map<K, V> {
    * @param fn - The function to call when a value is needed to be disposed.
    * @returns A disposer function to unsubscribe from the event.
    */
-  public onDisposeValue(fn: (value: V) => void): Disposer {
+  public onDisposeValue(fn: (value: V) => void): RemoveListener {
     return on(
       (this._onDisposeValue_ ??= {
         delete_: new Set<V>(),

src/event.ts

@@ -1,9 +1,13 @@
-import { type Disposer } from "./typings";
 import { invokeEach } from "./utils";
 
-export interface Listener<T = any> {
-  (data: T): void;
-}
+export type Listener<T = any> = (data: T) => void;
+
+/**
+ * Unsubscribes the bound listener.
+ * @returns Returns true if the listener existed and has been removed,
+ *          or false if the listener does not exist.
+ */
+export type RemoveListener = () => boolean;
 
 export interface EventObject<T = any> {
   /** @internal */
@@ -12,23 +16,20 @@ export interface EventObject<T = any> {
   single_?: Listener<T> | null;
 }
 
-export function send<T = any>(eventObject: EventObject<T>, data: T): void {
+export const send = <T = any>(eventObject: EventObject<T>, data: T): void =>
   eventObject.multi_ ? invokeEach(eventObject.multi_, data) : eventObject.single_?.(data);
-}
 
-export function size(eventObject: EventObject): number {
-  return eventObject.multi_ ? eventObject.multi_.size : eventObject.single_ ? 1 : 0;
-}
+export const size = (eventObject: EventObject): number =>
+  eventObject.multi_ ? eventObject.multi_.size : eventObject.single_ ? 1 : 0;
 
-export function on(eventObject: EventObject, listener: Listener): Disposer {
+export const on = (eventObject: EventObject, listener: Listener): RemoveListener => (
   eventObject.single_ || eventObject.multi_
     ? (eventObject.multi_ ??= new Set<Listener>().add(eventObject.single_!)).add(listener)
-    : (eventObject.single_ = listener);
-  return off.bind(null, eventObject, listener);
-}
+    : (eventObject.single_ = listener),
+  off.bind(null, eventObject, listener)
+);
 
-export function off(eventObject: EventObject, listener: Listener): void {
+export const off = (eventObject: EventObject, listener: Listener): boolean =>
   eventObject.multi_
     ? eventObject.multi_.delete(listener)
-    : eventObject.single_ === listener && (eventObject.single_ = null);
-}
+    : eventObject.single_ === listener && !(eventObject.single_ = null);

src/index.ts

@@ -1,7 +1,3 @@
-export { batch, batchFlush, batchStart } from "./batch";
-
-export { compute, type ComputeFn } from "./compute";
-
 export type {
   Flatten,
   Get,
@@ -16,6 +12,12 @@ export type {
   Version,
 } from "./typings";
 
+export { type Listener, type RemoveListener } from "./event";
+
+export { batch, batchFlush, batchStart } from "./batch";
+
+export { compute, type ComputeFn } from "./compute";
+
 export { readable, writable, toWritable } from "./readable";
 export { watch, type WatchEffect } from "./watch";
 

src/readable.ts

@@ -1,5 +1,4 @@
 import { batchFlush, batchStart, type BatchTask, tasks } from "./batch";
-import { off, on, send, size, type EventObject } from "./event";
 import {
   type OwnedReadable,
   type OwnedWritable,
@@ -11,7 +10,7 @@ import {
   type Version,
   type Writable,
 } from "./typings";
-import { BRAND, strictEqual, UNIQUE_VALUE } from "./utils";
+import { BRAND, invokeEach, strictEqual, UNIQUE_VALUE } from "./utils";
 
 export type Deps = Map<ReadableImpl, Version>;
 
@@ -86,7 +85,7 @@ export class ReadableImpl<TValue = any> implements BatchTask {
   /**
    * @internal
    */
-  private _subs_?: EventObject<TValue> | null;
+  private _subs_?: Set<Subscriber<TValue>>;
 
   public get $version(): Version {
     this.get();
@@ -154,9 +153,9 @@ export class ReadableImpl<TValue = any> implements BatchTask {
 
   /** @internal */
   public task_(): void {
-    if (this._subs_ && size(this._subs_) && this._lastSubInvokeVersion_ !== this.$version) {
+    if (this._subs_?.size && this._lastSubInvokeVersion_ !== this.$version) {
       this._lastSubInvokeVersion_ = this.$version;
-      send(this._subs_, this.get());
+      invokeEach(this._subs_, this.get());
     }
   }
 
@@ -262,11 +261,11 @@ export class ReadableImpl<TValue = any> implements BatchTask {
 
   /** @internal */
   public onReaction_(subscriber: Subscriber<TValue>): void {
-    if (!this._subs_ || !size(this._subs_)) {
+    if (!this._subs_?.size) {
       // start tracking last first on first subscription
       this._lastSubInvokeVersion_ = this.$version;
     }
-    on((this._subs_ ??= {}), subscriber);
+    (this._subs_ ??= new Set()).add(subscriber);
   }
 
   public reaction(subscriber: Subscriber<TValue>): Disposer {
@@ -315,11 +314,11 @@ export class ReadableImpl<TValue = any> implements BatchTask {
   }
 
   public unsubscribe(subscriber: (...args: any[]) => any): void {
-    this._subs_ && off(this._subs_, subscriber);
+    this._subs_?.delete(subscriber);
   }
 
   public unsubscribeAll(): void {
-    this._subs_ = null;
+    this._subs_?.clear();
   }
 
   public valueOf(): TValue {