createIntervalCache: Remove comparePoints param (#29)

packages/suspense-website/src/examples/index.ts

@@ -97,12 +97,6 @@ const createIntervalCache = {
   cache: processExample(
     readFileSync(join(__dirname, "createIntervalCache", "cache.ts"), "utf8")
   ),
-  cacheWithBigIntInterval: processExample(
-    readFileSync(
-      join(__dirname, "createIntervalCache", "cacheWithBigIntInterval.ts"),
-      "utf8"
-    )
-  ),
   cacheWithPartialResults: processExample(
     readFileSync(
       join(__dirname, "createIntervalCache", "cacheWithPartialResults.ts"),

packages/suspense-website/src/routes/api/createIntervalCache.tsx

@@ -16,10 +16,17 @@ export default function Route() {
       <Block>
         <p>
           An "interval cache" is a specialized cache that incrementally loads
-          and merges sets of values over time.
+          and merges sets of values over time. Values are loaded for "intervals"
+          which are a range of either numbers (or{" "}
+          <code>
+            <ExternalLink to="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt">
+              BigInts
+            </ExternalLink>
+          </code>
+          )
         </p>
         <p>
-          An example of this is{" "}
+          An example of an interval cache can be found in{" "}
           <ExternalLink to="https://replay.io">Replay.io</ExternalLink> which
           fetches console logs for the region of a recording a user has
           "focused" on. If the user changes the focused region, additional logs
@@ -41,29 +48,6 @@ export default function Route() {
         </p>
         <Code code={createIntervalCache.cache} />
       </Block>
-      <Block>
-        <SubHeading title="Custom comparisons" />
-        <p>
-          Points in an interval are typically numbers (e.g. 1, 3.5) but they can
-          also be{" "}
-          <code>
-            <ExternalLink to="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt">
-              BigInts
-            </ExternalLink>
-          </code>
-          . In that case a custom comparison function should be provided.
-        </p>
-        <p>
-          Here is an example using the NPM package{" "}
-          <code>
-            <ExternalLink to="https://www.npmjs.com/package/extra-bigint">
-              extra-bigint
-            </ExternalLink>
-          </code>
-          :
-        </p>
-        <Code code={createIntervalCache.cacheWithBigIntInterval} />
-      </Block>
       <Block>
         <SubHeading title="Aborting requests" />
         <p>

packages/suspense/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.0.36
+* `createIntervalCache` removes `comparePoints` param (as it is no longer needed).
+
 ## 0.0.35
 * `createIntervalCache` supports partial results via new options parameter `options.returnAsPartial(resultsArray)`.
 * `createIntervalCache` methods `getValue` and `getStatus` better handle sub-regions of already-loaded intervals.

packages/suspense/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suspense",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "description": "Utilities for working with React suspense",
   "author": "Brian Vaughn <[email protected]>",
   "license": "MIT",

packages/suspense/src/cache/createIntervalCache/createIntervalCache.test.ts

@@ -126,37 +126,40 @@ describe("createIntervalCache", () => {
   });
 
   describe("configuration", () => {
-    it("should support bigint points via a custom comparePoints", async () => {
-      const comparePoints = jest.fn(compareBigInt);
-
+    it("should support bigint points", async () => {
       const load = jest.fn();
       load.mockImplementation((start: number, end: number, id: string) => [
         start,
       ]);
 
       const bigIntCache = createIntervalCache<bigint, [id: string], bigint>({
-        comparePoints,
         getPointForValue: (value) => value,
         load,
       });
 
-      await bigIntCache.readAsync(BigInt("2"), BigInt("4"), "test");
-
-      expect(comparePoints).toHaveBeenCalled();
+      await bigIntCache.readAsync(
+        BigInt("10000000000000000000000000000000002"),
+        BigInt("10000000000000000000000000000000004"),
+        "test"
+      );
 
       expect(load).toHaveBeenCalledTimes(1);
       expect(load).toHaveBeenCalledWith(
-        BigInt("2"),
-        BigInt("4"),
+        BigInt("10000000000000000000000000000000002"),
+        BigInt("10000000000000000000000000000000004"),
         "test",
         expect.anything()
       );
 
-      await bigIntCache.readAsync(BigInt("3"), BigInt("7"), "test");
+      await bigIntCache.readAsync(
+        BigInt("10000000000000000000000000000000003"),
+        BigInt("10000000000000000000000000000000007"),
+        "test"
+      );
       expect(load).toHaveBeenCalledTimes(2);
       expect(load).toHaveBeenCalledWith(
-        BigInt("4"),
-        BigInt("7"),
+        BigInt("10000000000000000000000000000000004"),
+        BigInt("10000000000000000000000000000000007"),
         "test",
         expect.anything()
       );

packages/suspense/src/cache/createIntervalCache/createIntervalCache.ts

@@ -14,7 +14,6 @@ import {
 } from "../../constants";
 import {
   IntervalCacheLoadOptions,
-  ComparisonFunction,
   GetPointForValue,
   PendingRecord,
   IntervalCache,
@@ -72,7 +71,6 @@ export function createIntervalCache<
   Params extends Array<any>,
   Value
 >(options: {
-  comparePoints?: ComparisonFunction<Point>;
   debugLabel?: string;
   getKey?: (...params: Params) => string;
   getPointForValue: GetPointForValue<Point, Value>;
@@ -83,7 +81,6 @@ export function createIntervalCache<
   ) => PromiseLike<ValuesArray<Value>> | ValuesArray<Value>;
 }): IntervalCache<Point, Params, Value> {
   const {
-    comparePoints = defaultComparePoints,
     debugLabel,
     getKey = defaultGetKey,
     getPointForValue,
@@ -766,6 +763,6 @@ export function createIntervalCache<
   };
 }
 
-function defaultComparePoints(a: any, b: any): number {
-  return a - b;
+function comparePoints(a: any, b: any): number {
+  return Number(a - b);
 }