@synnaxlabs/x 0.37.0 → 0.38.0

package/src/unique/unique.spec.ts

@@ -0,0 +1,192 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { describe, expect, it } from "vitest";
+
+import { unique } from "@/unique";
+
+describe("unique", () => {
+  it("removes duplicate primitive values", () => {
+    const result = unique.unique([1, 2, 2, 3, 4, 4, 5]);
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it("works with strings", () => {
+    const result = unique.unique(["a", "b", "a", "c", "b"]);
+    expect(result).toEqual(["a", "b", "c"]);
+  });
+
+  it("works with mixed types", () => {
+    const result = unique.unique([1, "1", 2, "2", 1, "1"]);
+    expect(result).toEqual([1, "1", 2, "2"]);
+  });
+
+  it("handles an empty array", () => {
+    const result = unique.unique([]);
+    expect(result).toEqual([]);
+  });
+
+  it("works with readonly arrays", () => {
+    const values: readonly number[] = [1, 1, 2, 3];
+    const result = unique.unique(values);
+    expect(result).toEqual([1, 2, 3]);
+  });
+});
+
+describe("by", () => {
+  interface IDTestCase {
+    id: number;
+  }
+
+  it("removes duplicates based on a key function and keeps the first instance by default", () => {
+    const result = unique.by(
+      [
+        { id: 1, name: "A" },
+        { id: 2, name: "B" },
+        { id: 1, name: "C" },
+      ],
+      (value: IDTestCase) => value.id,
+    );
+    expect(result).toEqual([
+      { id: 1, name: "A" },
+      { id: 2, name: "B" },
+    ]);
+  });
+
+  it("removes duplicates based on a key function and keeps the first instance when keepFirst is true", () => {
+    const result = unique.by(
+      [
+        { id: 1, name: "A" },
+        { id: 2, name: "B" },
+        { id: 1, name: "C" },
+      ],
+      (value: IDTestCase) => value.id,
+      true,
+    );
+    expect(result).toEqual([
+      { id: 1, name: "A" },
+      { id: 2, name: "B" },
+    ]);
+  });
+
+  it("removes duplicates based on a key function and keeps the last instance when keepFirst is false", () => {
+    const result = unique.by(
+      [
+        { id: 1, name: "A" },
+        { id: 2, name: "B" },
+        { id: 1, name: "C" },
+      ],
+      (value: IDTestCase) => value.id,
+      false,
+    );
+    expect(result).toEqual([
+      { id: 2, name: "B" },
+      { id: 1, name: "C" },
+    ]);
+  });
+
+  interface ValueTestCase {
+    value: string;
+  }
+
+  it("works with a custom key function", () => {
+    const result = unique.by(
+      [{ value: "apple" }, { value: "banana" }, { value: "apple" }],
+      (v: ValueTestCase) => v.value,
+    );
+    expect(result).toEqual([{ value: "apple" }, { value: "banana" }]);
+  });
+
+  it("handles an empty array", () => {
+    const result = unique.by([], (v: unknown) => v);
+    expect(result).toEqual([]);
+  });
+
+  it("works with readonly arrays and keeps the first instance by default", () => {
+    const values: readonly { id: number; name: string }[] = [
+      { id: 1, name: "A" },
+      { id: 1, name: "B" },
+    ];
+    const result = unique.by(values, (v: IDTestCase) => v.id);
+    expect(result).toEqual([{ id: 1, name: "A" }]);
+  });
+
+  it("works with readonly arrays and keeps the last instance when keepFirst is false", () => {
+    const values: readonly { id: number; name: string }[] = [
+      { id: 1, name: "A" },
+      { id: 1, name: "B" },
+    ];
+    const result = unique.by(values, (v: IDTestCase) => v.id, false);
+    expect(result).toEqual([{ id: 1, name: "B" }]);
+  });
+
+  interface ComplexTestCase {
+    id: number;
+    nested: { value: string };
+  }
+
+  it("works with complex keys and keeps the first instance by default", () => {
+    const result = unique.by(
+      [
+        { id: 1, nested: { value: "A" } },
+        { id: 1, nested: { value: "B" } },
+        { id: 1, nested: { value: "A", otherKey: "4" } },
+      ],
+      (v: ComplexTestCase) => `${v.id}-${v.nested.value}`,
+    );
+    expect(result).toEqual([
+      { id: 1, nested: { value: "A" } },
+      { id: 1, nested: { value: "B" } },
+    ]);
+  });
+
+  it("works with complex keys and keeps the last instance when keepFirst is false", () => {
+    const result = unique.by(
+      [
+        { id: 1, nested: { value: "A" } },
+        { id: 1, nested: { value: "B" } },
+        { id: 1, nested: { value: "A", otherKey: "4" } },
+      ],
+      (v: ComplexTestCase) => `${v.id}-${v.nested.value}`,
+      false,
+    );
+    expect(result).toEqual([
+      { id: 1, nested: { value: "B" } },
+      { id: 1, nested: { value: "A", otherKey: "4" } },
+    ]);
+  });
+
+  it("handles cases where all keys are unique", () => {
+    const result = unique.by(
+      [
+        { id: 1, name: "A" },
+        { id: 2, name: "B" },
+        { id: 3, name: "C" },
+      ],
+      (v: IDTestCase) => v.id,
+    );
+    expect(result).toEqual([
+      { id: 1, name: "A" },
+      { id: 2, name: "B" },
+      { id: 3, name: "C" },
+    ]);
+  });
+
+  it("handles cases where all values are identical", () => {
+    const result = unique.by(
+      [
+        { id: 1, name: "A" },
+        { id: 1, name: "A" },
+        { id: 1, name: "A" },
+      ],
+      (v: IDTestCase) => v.id,
+    );
+    expect(result).toEqual([{ id: 1, name: "A" }]);
+  });
+});

package/src/unique/unique.ts

@@ -0,0 +1,67 @@
+// Copyright 2024 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+/**
+ * Removes duplicate values from an array, preserving the order of the first occurrence
+ * of each unique value.
+ *
+ * @param values - An array or readonly array of values to deduplicate.
+ * @returns A new array containing only unique values.
+ *
+ * @example
+ * ```typescript
+ * unique([1, 2, 2, 3, 4, 4, 5]); // [1, 2, 3, 4, 5]
+ * ```
+ */
+export const unique = <V>(values: V[] | readonly V[]): V[] => [...new Set(values)];
+
+/**
+ * Removes duplicate values from an array based on a key function, preserving either
+ * the first or last occurrence of each unique key. If
+ *
+ * @param values - An array or readonly array of values to deduplicate.
+ * @param key - A function that generates a unique key for each value.
+ * @param keepFirst - An optional boolean indicating whether to keep the first instance
+ *                    (`true`, default) or the last instance (`false`) of each unique key.
+ * @returns A new array containing only unique values based on the generated keys.
+ *
+ * @example
+ * // Default behavior (keep first instance):
+ * by(
+ *   [{ id: 1, name: "A" }, { id: 2, name: "B" }, { id: 1, name: "C" }],
+ *   (value) => value.id
+ * );
+ * // Result: [{ id: 1, name: "A" }, { id: 2, name: "B" }]
+ *
+ * @example
+ * // Keep last instance:
+ * by(
+ *   [{ id: 1, name: "A" }, { id: 2, name: "B" }, { id: 1, name: "C" }],
+ *   (value) => value.id,
+ *   false
+ * );
+ * // Result: [{ id: 2, name: "B" }, { id: 1, name: "C" }]
+ */
+export const by = <V>(
+  values: V[] | readonly V[],
+  key: (value: V) => unknown,
+  keepFirst: boolean = true,
+): V[] => {
+  const map = new Map<unknown, V>();
+  values.forEach((v) => {
+    const k = key(v);
+    if (map.has(k)) {
+      if (keepFirst) return;
+      map.delete(k);
+    }
+    // different delete and set operations for keepLast so order is preserved
+    map.set(k, v);
+  });
+  return Array.from(map.values());
+};

package/src/zodutil/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as zodutil from "./zodutil";
+export * as zodutil from "@/zodutil/zodutil";

package/src/zodutil/zodutil.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z, type ZodSchema } from "zod";
+import { z } from "zod";
 
 import { deep } from "@/deep";
 import { type UnknownRecord } from "@/record";
@@ -43,32 +43,4 @@ export const getFieldSchema: deep.TypedGet<z.ZodTypeAny, z.ZodTypeAny> = ((
     { ...options, getter: sourceTypeGetter } as deep.GetOptions<boolean | undefined>,
   ) as z.ZodTypeAny | null) as deep.TypedGet<z.ZodTypeAny, z.ZodTypeAny>;
 
-/**
- * Creates a transformer function that validates and transforms input values based on
- * provided schemas. The first schema to successfully validate the input value is used
- * in the transformation. If no schema is found that validates the input, the
- * transformer function returns null.
- *
- * @template Input - The type of the input value.
- * @template Output - The type of the output value.
- * @param transform - The function to transform the input value to the output value.
- * @param schemas - An array of Zod schemas to validate the input value against.
- * @returns A function that takes an unknown value, validates it against the schemas,
- * and uses the first valid schema to transform the input type. If no schema can
- * validate the input, the function returns null.
- */
-export const transformer =
-  <Input, Output>(
-    transform: (input: Input) => Output,
-    schemas: ZodSchema<Input>[],
-  ): ((value: unknown) => Output | null) =>
-  (value) => {
-    const matchingSchema = schemas.find((schema) => {
-      const res = schema.safeParse(value);
-      return res.success;
-    });
-    if (matchingSchema == null) return null;
-    return transform(matchingSchema.parse(value));
-  };
-
 export const bigInt = z.bigint().or(z.string().transform(BigInt));