@prisma/client-common 6.6.0-dev.59

package/dist/uniqueBy.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uniqueBy_exports = {};
+__export(uniqueBy_exports, {
+  uniqueBy: () => uniqueBy
+});
+module.exports = __toCommonJS(uniqueBy_exports);
+function uniqueBy(arr, callee) {
+  const result = {};
+  for (const value of arr) {
+    const hash = callee(value);
+    if (!result[hash]) {
+      result[hash] = value;
+    }
+  }
+  return Object.values(result);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uniqueBy
+});

package/dist/uniqueBy.mjs

@@ -0,0 +1,13 @@
+function uniqueBy(arr, callee) {
+  const result = {};
+  for (const value of arr) {
+    const hash = callee(value);
+    if (!result[hash]) {
+      result[hash] = value;
+    }
+  }
+  return Object.values(result);
+}
+export {
+  uniqueBy
+};

package/dist/uniqueBy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/uniqueBy.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_uniqueBy = require("./uniqueBy");
+(0, import_vitest.describe)("uniqueBy", () => {
+  (0, import_vitest.it)("should return an empty array when given an empty array", () => {
+    (0, import_vitest.expect)((0, import_uniqueBy.uniqueBy)([], (item) => item)).toEqual([]);
+  });
+  (0, import_vitest.it)("should return unique elements based on the hash function", () => {
+    const input = [1, 2, 3, 2, 1];
+    const result = (0, import_uniqueBy.uniqueBy)(input, (item) => item.toString());
+    (0, import_vitest.expect)(result).toEqual([1, 2, 3]);
+  });
+  (0, import_vitest.it)("should work with objects using custom hash functions", () => {
+    const input = [
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+      { id: 1, name: "Charlie" },
+      // Duplicate id
+      { id: 3, name: "Dave" }
+    ];
+    const result = (0, import_uniqueBy.uniqueBy)(input, (item) => item.id.toString());
+    (0, import_vitest.expect)(result).toEqual([
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+      { id: 3, name: "Dave" }
+    ]);
+  });
+  (0, import_vitest.it)("should handle string inputs", () => {
+    const input = ["a", "b", "a", "c", "b"];
+    const result = (0, import_uniqueBy.uniqueBy)(input, (item) => item);
+    (0, import_vitest.expect)(result).toEqual(["a", "b", "c"]);
+  });
+  (0, import_vitest.it)("should work with more complex hash functions", () => {
+    const input = [
+      { firstName: "John", lastName: "Doe" },
+      { firstName: "Jane", lastName: "Doe" },
+      { firstName: "John", lastName: "Smith" },
+      { firstName: "John", lastName: "Doe" }
+      // Duplicate
+    ];
+    const result = (0, import_uniqueBy.uniqueBy)(input, (item) => `${item.firstName}-${item.lastName}`);
+    (0, import_vitest.expect)(result).toEqual([
+      { firstName: "John", lastName: "Doe" },
+      { firstName: "Jane", lastName: "Doe" },
+      { firstName: "John", lastName: "Smith" }
+    ]);
+  });
+  (0, import_vitest.it)("should preserve the first occurrence when duplicates exist", () => {
+    const input = [
+      { id: 1, value: "first" },
+      { id: 2, value: "second" },
+      { id: 1, value: "duplicate" }
+    ];
+    const result = (0, import_uniqueBy.uniqueBy)(input, (item) => item.id.toString());
+    (0, import_vitest.expect)(result).toEqual([
+      { id: 1, value: "first" },
+      { id: 2, value: "second" }
+    ]);
+    (0, import_vitest.expect)(result[0].value).toBe("first");
+  });
+});

package/dist/uniqueBy.test.mjs

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { uniqueBy } from "./uniqueBy";
+describe("uniqueBy", () => {
+  it("should return an empty array when given an empty array", () => {
+    expect(uniqueBy([], (item) => item)).toEqual([]);
+  });
+  it("should return unique elements based on the hash function", () => {
+    const input = [1, 2, 3, 2, 1];
+    const result = uniqueBy(input, (item) => item.toString());
+    expect(result).toEqual([1, 2, 3]);
+  });
+  it("should work with objects using custom hash functions", () => {
+    const input = [
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+      { id: 1, name: "Charlie" },
+      // Duplicate id
+      { id: 3, name: "Dave" }
+    ];
+    const result = uniqueBy(input, (item) => item.id.toString());
+    expect(result).toEqual([
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+      { id: 3, name: "Dave" }
+    ]);
+  });
+  it("should handle string inputs", () => {
+    const input = ["a", "b", "a", "c", "b"];
+    const result = uniqueBy(input, (item) => item);
+    expect(result).toEqual(["a", "b", "c"]);
+  });
+  it("should work with more complex hash functions", () => {
+    const input = [
+      { firstName: "John", lastName: "Doe" },
+      { firstName: "Jane", lastName: "Doe" },
+      { firstName: "John", lastName: "Smith" },
+      { firstName: "John", lastName: "Doe" }
+      // Duplicate
+    ];
+    const result = uniqueBy(input, (item) => `${item.firstName}-${item.lastName}`);
+    expect(result).toEqual([
+      { firstName: "John", lastName: "Doe" },
+      { firstName: "Jane", lastName: "Doe" },
+      { firstName: "John", lastName: "Smith" }
+    ]);
+  });
+  it("should preserve the first occurrence when duplicates exist", () => {
+    const input = [
+      { id: 1, value: "first" },
+      { id: 2, value: "second" },
+      { id: 1, value: "duplicate" }
+    ];
+    const result = uniqueBy(input, (item) => item.id.toString());
+    expect(result).toEqual([
+      { id: 1, value: "first" },
+      { id: 2, value: "second" }
+    ]);
+    expect(result[0].value).toBe("first");
+  });
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@prisma/client-common",
+  "version": "6.6.0-dev.59",
+  "description": "This package is intended for Prisma's internal use",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma.git",
+    "directory": "packages/client-common"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@prisma/dmmf": "6.6.0-dev.59",
+    "@prisma/driver-adapter-utils": "6.6.0-dev.59",
+    "@prisma/internals": "6.6.0-dev.59",
+    "@prisma/generator": "6.6.0-dev.59"
+  },
+  "devDependencies": {
+    "vitest": "3.0.9"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "DEV=true tsx helpers/build.ts",
+    "build": "tsx helpers/build.ts",
+    "test": "vitest run"
+  }
+}