@esportsplus/reactivity 0.20.2 → 0.22.0

package/build/reactive/array.d.ts

@@ -17,7 +17,9 @@ type Events<T> = {
     shift: {
         item: T;
     };
-    sort: undefined;
+    sort: {
+        order: number[];
+    };
     splice: {
         deleteCount: number;
         items: T[];

package/build/reactive/array.js

@@ -120,8 +120,32 @@ class ReactiveArray extends Array {
         return item;
     }
     sort(fn) {
+        let before = new Array(this.length);
+        for (let i = 0, n = before.length; i < n; i++) {
+            before[i] = this[i];
+        }
         super.sort(fn);
-        this.dispatch('sort');
+        let buckets = new Map(), cursors = new Map(), order = new Array(this.length);
+        for (let i = 0, n = before.length; i < n; i++) {
+            let value = before[i], list = buckets.get(value);
+            if (!list) {
+                buckets.set(value, [i]);
+            }
+            else {
+                list.push(i);
+            }
+        }
+        for (let i = 0, n = this.length; i < n; i++) {
+            let value = this[i], list = buckets.get(value);
+            if (!list) {
+                order[i] = i;
+                continue;
+            }
+            let cursor = cursors.get(value) || 0;
+            order[i] = list[cursor];
+            cursors.set(value, cursor + 1);
+        }
+        this.dispatch('sort', { order });
         return this;
     }
     splice(start, deleteCount = this.length, ...items) {

package/build/system.js

@@ -140,7 +140,7 @@ function recompute(computed, del) {
     depth++;
     version++;
     try {
-        value = computed.fn.call(computed, onCleanup);
+        value = computed.fn(onCleanup);
     }
     catch (e) {
         ok = false;

package/build/types.d.ts

@@ -5,7 +5,7 @@ interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (this: Computed<unknown>, onCleanup?: (fn: VoidFunction) => typeof fn) => T;
+    fn: (onCleanup?: (fn: VoidFunction) => typeof fn) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;

package/package.json

@@ -16,7 +16,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.20.2",
+  "version": "0.22.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/reactive/array.ts

@@ -22,7 +22,9 @@ type Events<T> = {
     shift: {
         item: T;
     };
-    sort: undefined;
+    sort: {
+        order: number[];
+    };
     splice: {
         deleteCount: number;
         items: T[];
@@ -200,8 +202,46 @@ class ReactiveArray<T> extends Array<T> {
     }
 
     sort(fn?: (a: T, b: T) => number) {
+        let before = new Array(this.length) as T[];
+
+        for (let i = 0, n = before.length; i < n; i++) {
+            before[i] = this[i];
+        }
+
         super.sort(fn);
-        this.dispatch('sort');
+
+        let buckets = new Map<any, number[]>(),
+            cursors = new Map<any, number>(),
+            order = new Array(this.length);
+
+        for (let i = 0, n = before.length; i < n; i++) {
+            let value = before[i],
+                list = buckets.get(value);
+
+            if (!list) {
+                buckets.set(value, [i]);
+            }
+            else {
+                list.push(i);
+            }
+        }
+
+        for (let i = 0, n = this.length; i < n; i++) {
+            let value = this[i],
+                list = buckets.get(value);
+
+            if (!list) {
+                order[i] = i;
+                continue;
+            }
+
+            let cursor = cursors.get(value) || 0;
+
+            order[i] = list[cursor];
+            cursors.set(value, cursor + 1);
+        }
+
+        this.dispatch('sort', { order });
 
         return this;
     }

package/src/system.ts

@@ -211,7 +211,7 @@ function recompute<T>(computed: Computed<T>, del: boolean) {
     version++;
 
     try {
-        value = computed.fn.call(computed, onCleanup);
+        value = computed.fn(onCleanup);
     }
     catch (e) {
         ok = false;

package/src/types.ts

@@ -7,7 +7,7 @@ interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
     depsTail: Link | null;
-    fn: (this: Computed<unknown>, onCleanup?: (fn: VoidFunction) => typeof fn) => T;
+    fn: (onCleanup?: (fn: VoidFunction) => typeof fn) => T;
     height: number;
     nextHeap: Computed<unknown> | undefined;
     prevHeap: Computed<unknown>;