@synnaxlabs/x 0.16.1 → 0.24.0

package/src/runtime/index.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.

package/src/runtime/os.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -13,10 +13,17 @@ export const OPERATING_SYSTEMS = ["MacOS", "Windows", "Linux", "Docker"] as cons
 export const osZ = z.enum(OPERATING_SYSTEMS);
 export type OS = (typeof OPERATING_SYSTEMS)[number];
 
-export interface GetOSProps {
+export type RequiredGetOSProps = {
   force?: OS;
   default?: OS;
-}
+};
+
+export type OptionalGetOSProps = {
+  force?: OS | undefined;
+  default: OS;
+};
+
+export type GetOSProps = RequiredGetOSProps | OptionalGetOSProps;
 
 let os: OS | undefined;
 
@@ -29,10 +36,15 @@ const evalOS = (): OS | undefined => {
   return undefined;
 };
 
-export const getOS = (props: GetOSProps = {}): OS | undefined => {
+export interface GetOS {
+  (props?: RequiredGetOSProps): OS;
+  (props?: OptionalGetOSProps): OS | undefined;
+}
+
+export const getOS = ((props: GetOSProps = {}): OS | undefined => {
   const { force, default: default_ } = props;
   if (force != null) return force;
   if (os != null) return os;
   os = evalOS();
   return os ?? default_;
-};
+}) as unknown as GetOS;

package/src/search.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -28,12 +28,14 @@ export const Search = {
 };
 
 export interface TermSearcher<T, K extends Key, E extends Keyed<K>> {
+  readonly type: string;
   search: (term: T) => E[];
   retrieve: (keys: K[]) => E[];
   page: (offset: number, limit: number) => E[];
 }
 
 export interface AsyncTermSearcher<T, K extends Key, E extends Keyed<K>> {
+  readonly type: string;
   search: (term: T) => Promise<E[]>;
   retrieve: (keys: K[]) => Promise<E[]>;
   page: (offset: number, limit: number) => Promise<E[]>;

package/src/shallowCopy.ts

@@ -1,4 +1,3 @@
-
 // Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
@@ -8,8 +7,8 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export const shallowCopy = <T extends unknown>(obj: T): T => {
-    if (Array.isArray(obj)) return [...obj] as T;
-    if (typeof obj === "object" && obj !== null) return { ...obj } as T;
-    return obj;
-}
+export const shallowCopy = <T>(obj: T): T => {
+  if (Array.isArray(obj)) return [...obj] as T;
+  if (typeof obj === "object" && obj !== null) return { ...obj };
+  return obj;
+};

package/src/spatial/base.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -10,7 +10,8 @@
 import { z } from "zod";
 
 export const numberCouple = z.tuple([z.number(), z.number()]);
-export type NumberCouple = z.infer<typeof numberCouple>;
+export const bigNumberCouple = z.tuple([z.bigint(), z.bigint()]);
+export type NumberCouple<T extends number | bigint = number> = [T, T];
 
 // Dimensions
 
@@ -53,7 +54,7 @@ export const Y_LOCATIONS = ["top", "bottom"] as const;
 export const yLocation = z.enum(Y_LOCATIONS);
 export type YLocation = (typeof Y_LOCATIONS)[number];
 export const CENTER_LOCATIONS = ["center"] as const;
-export const centerlocation = z.enum(CENTER_LOCATIONS);
+export const centerLocation = z.enum(CENTER_LOCATIONS);
 export type CenterLocation = (typeof CENTER_LOCATIONS)[number];
 export const LOCATIONS = [...OUTER_LOCATIONS, ...CENTER_LOCATIONS] as const;
 export const location = z.enum(LOCATIONS);
@@ -70,10 +71,17 @@ export type Order = (typeof ORDERS)[number];
 // Bounds
 
 export const bounds = z.object({ lower: z.number(), upper: z.number() });
-export type Bounds = z.infer<typeof bounds>;
+export const bigBounds = z.object({ lower: z.bigint(), upper: z.bigint() });
+export interface Bounds<T extends number | bigint = number> {
+  lower: T;
+  upper: T;
+}
 
 export const crudeBounds = z.union([bounds, numberCouple]);
-export type CrudeBounds = z.infer<typeof crudeBounds>;
+export const bigCrudeBounds = z.union([bigBounds, numberCouple]);
+export type CrudeBounds<T extends number | bigint = number> =
+  | Bounds<T>
+  | NumberCouple<T>;
 export const crudeDirection = z.union([direction, location]);
 export type CrudeDirection = z.infer<typeof crudeDirection>;
 export const crudeLocation = z.union([direction, location, z.instanceof(String)]);

package/src/spatial/bounds/bounds.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2023 Synnax Labs, Inc.
+// Copyright 2024 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
 // licenses/BSL.txt.
@@ -9,6 +9,7 @@
 
 import { describe, expect, it, test } from "vitest";
 
+import { type NumberCouple } from "@/spatial/base";
 import * as bounds from "@/spatial/bounds/bounds";
 
 describe("Bounds", () => {
@@ -26,12 +27,32 @@ describe("Bounds", () => {
         expect(bound.upper).toEqual(2);
       });
     });
+    it("should accept two arguments", () => {
+      const bound = bounds.construct(1, 2);
+      expect(bound.lower).toEqual(1);
+      expect(bound.upper).toEqual(2);
+    });
     it("should consider a single argument as the upper bound", () => {
       const bound = bounds.construct(1);
       expect(bound.lower).toEqual(0);
       expect(bound.upper).toEqual(1);
     });
   });
+  describe("equals", () => {
+    it("should return true if the bounds are equal", () => {
+      const a = bounds.construct([1, 2]);
+      const b = bounds.construct([1, 2]);
+      expect(bounds.equals(a, b)).toEqual(true);
+    });
+    it("should return true if both bounds are undefined", () => {
+      expect(bounds.equals(undefined, undefined)).toEqual(true);
+    });
+    it("should return false if the bounds are not equal", () => {
+      const a = bounds.construct([1, 2]);
+      const b = bounds.construct([1, 3]);
+      expect(bounds.equals(a, b)).toEqual(false);
+    });
+  });
   describe("contains", () => {
     it("should return true if the value is within the bounds", () => {
       const b = bounds.construct([1, 2]);
@@ -206,194 +227,252 @@ describe("Bounds", () => {
         [[[3, 7]], 8, { index: 1, position: 0 }],
       ];
     SPECS.forEach(([b, target, expected]) => {
-      test(`should return ${expected} for ${b} and ${target}`, () => {
+      test(`should return ${JSON.stringify(expected)} for ${JSON.stringify(b)} and ${target}`, () => {
         expect(bounds.findInsertPosition(b, target)).toEqual(expected);
       });
     });
   });
   describe("insert", () => {
     describe("formal cases", () => {
-      test("insert before adjacent upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 3],
-          [3, 4],
-          [5, 6],
-        ];
-        const v: bounds.Crude = [1, 2];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 1, upper: 2 },
-          { lower: 2, upper: 3 },
-          { lower: 3, upper: 4 },
-          { lower: 5, upper: 6 },
-        ]);
-      });
-      test("insert in-between with no overlap", () => {
-        const b: bounds.Crude[] = [
-          [2, 3],
-          [3, 4],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [5, 6];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 3 },
-          { lower: 3, upper: 4 },
-          { lower: 5, upper: 6 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert in-between adjacent lower and upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 3],
-          [3, 4],
-          [5, 6],
-        ];
-        const v: bounds.Crude = [4, 5];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 3 },
-          { lower: 3, upper: 4 },
-          { lower: 4, upper: 5 },
-          { lower: 5, upper: 6 },
-        ]);
-      });
-      test("insert in-between adjacent lower not upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 3],
-          [3, 4],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [4, 6];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 3 },
-          { lower: 3, upper: 4 },
-          { lower: 4, upper: 6 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert in-between overlap lower adjacent upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 4],
-          [5, 6],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [3, 5];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 4 },
-          { lower: 4, upper: 5 },
-          { lower: 5, upper: 6 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert in-between adjacent lower contain 1 adjacent upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 4],
-          [5, 6],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [4, 7];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 4 },
-          { lower: 4, upper: 7 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert in-between overlap lower consume 1 adjacent upper", () => {
-        const b: bounds.Crude[] = [
-          [2, 4],
-          [5, 6],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [3, 7];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 4 },
-          { lower: 4, upper: 7 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert in-between replace 1", () => {
-        const b: bounds.Crude[] = [
-          [2, 4],
-          [5, 6],
-          [7, 8],
-        ];
-        const v: bounds.Crude = [5, 6];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 2, upper: 4 },
-          { lower: 5, upper: 6 },
-          { lower: 7, upper: 8 },
-        ]);
-      });
-      test("insert before overlap first", () => {
-        const b: bounds.Crude[] = [[3, 7]];
-        const v: bounds.Crude = [1, 4];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 1, upper: 3 },
-          { lower: 3, upper: 7 },
-        ]);
-      });
-      test("insert before no adjacent", () => {
-        const b: bounds.Crude[] = [[3, 7]];
-        const v: bounds.Crude = [1, 2];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 1, upper: 2 },
-          { lower: 3, upper: 7 },
-        ]);
-      });
-      test("insert after no adjacent", () => {
-        const b: bounds.Crude[] = [[3, 7]];
-        const v: bounds.Crude = [8, 9];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 3, upper: 7 },
-          { lower: 8, upper: 9 },
-        ]);
-      });
-      test("insert after adjacent upper", () => {
-        const b: bounds.Crude[] = [[3, 7]];
-        const v: bounds.Crude = [7, 9];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 3, upper: 7 },
-          { lower: 7, upper: 9 },
-        ]);
+      interface Spec {
+        name: string;
+        b: Array<NumberCouple<bigint | number>>;
+        v: NumberCouple<bigint | number>;
+        result: Array<bounds.Bounds<bigint | number>>;
+        focus?: boolean;
+      }
+
+      const SPECS: Spec[] = [
+        {
+          name: "insert before adjacent upper",
+          b: [
+            [2, 3],
+            [3, 4],
+            [5, 6],
+          ],
+          v: [1, 2],
+          result: [
+            { lower: 1, upper: 2 },
+            { lower: 2, upper: 3 },
+            { lower: 3, upper: 4 },
+            { lower: 5, upper: 6 },
+          ],
+        },
+        {
+          name: "insert in-between with no overlap",
+          b: [
+            [2, 3],
+            [3, 4],
+            [7, 8],
+          ],
+          v: [5, 6],
+          result: [
+            { lower: 2, upper: 3 },
+            { lower: 3, upper: 4 },
+            { lower: 5, upper: 6 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert in-between adjacent lower and upper",
+          b: [
+            [2, 3],
+            [3, 4],
+            [5, 6],
+          ],
+          v: [4, 5],
+          result: [
+            { lower: 2, upper: 3 },
+            { lower: 3, upper: 4 },
+            { lower: 4, upper: 5 },
+            { lower: 5, upper: 6 },
+          ],
+        },
+        {
+          name: "insert in-between adjacent lower and upper",
+          b: [
+            [2, 3],
+            [3, 4],
+            [5, 6],
+          ],
+          v: [4, 5],
+          result: [
+            { lower: 2, upper: 3 },
+            { lower: 3, upper: 4 },
+            { lower: 4, upper: 5 },
+            { lower: 5, upper: 6 },
+          ],
+        },
+        {
+          name: "insert in-between adjacent lower not upper",
+          b: [
+            [2, 3],
+            [3, 4],
+            [7, 8],
+          ],
+          v: [4, 6],
+          result: [
+            { lower: 2, upper: 3 },
+            { lower: 3, upper: 4 },
+            { lower: 4, upper: 6 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert in-between overlap lower adjacent upper",
+          b: [
+            [2, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          v: [3, 5],
+          result: [
+            { lower: 2, upper: 4 },
+            { lower: 4, upper: 5 },
+            { lower: 5, upper: 6 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert in-between adjacent lower contain 1 adjacent upper",
+          b: [
+            [2, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          v: [4, 7],
+          result: [
+            { lower: 2, upper: 4 },
+            { lower: 4, upper: 7 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert in-between overlap lower consume 1 adjacent upper",
+          b: [
+            [2, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          v: [3, 7],
+          result: [
+            { lower: 2, upper: 4 },
+            { lower: 4, upper: 7 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert in-between replace 1",
+          b: [
+            [2, 4],
+            [5, 6],
+            [7, 8],
+          ],
+          v: [5, 6],
+          result: [
+            { lower: 2, upper: 4 },
+            { lower: 5, upper: 6 },
+            { lower: 7, upper: 8 },
+          ],
+        },
+        {
+          name: "insert before overlap first",
+          b: [[3, 7]],
+          v: [1, 4],
+          result: [
+            { lower: 1, upper: 3 },
+            { lower: 3, upper: 7 },
+          ],
+        },
+        {
+          name: "insert before no adjacent",
+          b: [[3, 7]],
+          v: [1, 2],
+          result: [
+            { lower: 1, upper: 2 },
+            { lower: 3, upper: 7 },
+          ],
+        },
+        {
+          name: "insert after no adjacent",
+          b: [[3, 7]],
+          v: [8, 9],
+          result: [
+            { lower: 3, upper: 7 },
+            { lower: 8, upper: 9 },
+          ],
+        },
+        {
+          name: "insert after adjacent upper",
+          b: [[3, 7]],
+          v: [7, 9],
+          result: [
+            { lower: 3, upper: 7 },
+            { lower: 7, upper: 9 },
+          ],
+        },
+        {
+          name: "insert after overlap last",
+          b: [[3, 7]],
+          v: [5, 9],
+          result: [
+            { lower: 3, upper: 7 },
+            { lower: 7, upper: 9 },
+          ],
+        },
+        {
+          name: "regression 1",
+          b: [
+            [0, 47040],
+            [47040, 47240],
+            [47240, 47280],
+            [47280, 47320],
+            [47320, 47400],
+          ],
+          v: [47066, 47066 + 354],
+          result: [
+            { lower: 0, upper: 47040 },
+            { lower: 47040, upper: 47240 },
+            { lower: 47240, upper: 47066 + 354 },
+          ],
+        },
+      ];
+
+      describe("number", () => {
+        SPECS.forEach(({ name, b, v, result, focus }) => {
+          (focus === true ? test.only : test)(name, () => {
+            expect(bounds.insert(b, v)).toEqual(result);
+          });
+        });
       });
-      test("insert after overlap last", () => {
-        const b: bounds.Crude[] = [[3, 7]];
-        const v: bounds.Crude = [5, 9];
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 3, upper: 7 },
-          { lower: 7, upper: 9 },
-        ]);
+      describe("bigint", () => {
+        SPECS.forEach(({ name, b, v, result, focus }) => {
+          (focus === true ? test.only : test)(name, () => {
+            b = b.map(([l, u]) => [BigInt(l), BigInt(u)]);
+            v = [BigInt(v[0]), BigInt(v[1])];
+            result = result.map(({ lower, upper }) => ({
+              lower: BigInt(lower),
+              upper: BigInt(upper),
+            }));
+            expect(bounds.insert(b, v)).toEqual(result);
+          });
+        });
       });
     });
-    describe("regressions", () => {
-      it("should insert a value into a sorted array of bounds", () => {
-        const b: bounds.Crude[] = [
-          { lower: 0, upper: 47040 },
-          { lower: 47040, upper: 47240 },
-          { lower: 47240, upper: 47280 },
-          { lower: 47280, upper: 47320 },
-          { lower: 47320, upper: 47400 },
-        ];
-        const v: bounds.Crude = { lower: 47066, upper: 47066 + 354 };
-        const result = bounds.insert(b, v);
-        expect(result).toEqual([
-          { lower: 0, upper: 47040 },
-          { lower: 47040, upper: 47240 },
-          { lower: 47240, upper: 47066 + 354 },
-        ]);
-      });
-      it("should insert a value into a sorted array of bounds", () => {});
+  });
+  describe("linspace", () => {
+    it("should generate the correct array", () => {
+      const b = bounds.construct([1, 3]);
+      const result = bounds.linspace(b);
+      expect(result).toEqual([1, 2]);
+    });
+  });
+  describe("clamp", () => {
+    it("should clamp the provided target to the bounds", () => {
+      const b = bounds.construct([1, 3]);
+      expect(bounds.clamp(b, 0)).toEqual(1);
+      expect(bounds.clamp(b, 2)).toEqual(2);
+      expect(bounds.clamp(b, 4)).toEqual(2);
     });
   });
 });