@synnaxlabs/x 0.46.1 → 0.46.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.46.1",
+  "version": "0.46.2",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/ts",
@@ -27,9 +27,9 @@
     "typescript": "^5.9.2",
     "vite": "^7.1.5",
     "vitest": "^3.2.4",
-    "eslint-config-synnaxlabs": "^0.43.0",
     "@synnaxlabs/tsconfig": "^0.43.0",
-    "@synnaxlabs/vite-plugin": "^0.43.0"
+    "@synnaxlabs/vite-plugin": "^0.43.0",
+    "eslint-config-synnaxlabs": "^0.43.0"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

package/src/strings/deduplicateFileName.spec.ts

@@ -0,0 +1,84 @@
+// Copyright 2025 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 { deduplicateFileName } from "@/strings/deduplicateFileName";
+
+describe("deduplicateFileName", () => {
+  it("should return the original name when it does not exist", () =>
+    expect(deduplicateFileName("Report", new Set(["Summary"]))).toBe("Report"));
+
+  it("should append (1) when a duplicate exists", () =>
+    expect(deduplicateFileName("Report", new Set(["Report"]))).toBe("Report (1)"));
+
+  it("should increment to the next available number", () =>
+    expect(
+      deduplicateFileName("Report", new Set(["Report", "Report (1)", "Report (2)"])),
+    ).toBe("Report (3)"));
+
+  it("should fill gaps in numbering", () =>
+    expect(
+      deduplicateFileName("Report", new Set(["Report", "Report (1)", "Report (3)"])),
+    ).toBe("Report (2)"));
+
+  it("should handle names already suffixed with a number", () =>
+    expect(deduplicateFileName("Report (2)", new Set(["Report (2)"]))).toBe(
+      "Report (3)",
+    ));
+
+  it("should not be confused by numbers elsewhere in the name", () =>
+    expect(
+      deduplicateFileName("Report 2024", new Set(["Report 2024", "Report 2024 (1)"])),
+    ).toBe("Report 2024 (2)"));
+
+  it("should handle names with non-numeric parentheses at the end", () =>
+    expect(deduplicateFileName("Report (draft)", new Set(["Report (draft)"]))).toBe(
+      "Report (draft) (1)",
+    ));
+
+  it("should escalate correctly when many duplicates exist", () => {
+    const existing = new Set<string>(["Report"]);
+    for (let i = 1; i <= 100; i++) existing.add(`Report (${i})`);
+    expect(deduplicateFileName("Report", existing)).toBe("Report (101)");
+  });
+
+  it("should return empty when empty name does not exist", () =>
+    expect(deduplicateFileName("", new Set(["Report"]))).toBe(""));
+
+  it("should append (1) to empty when empty name exists", () =>
+    expect(deduplicateFileName("", new Set([""]))).toBe(" (1)"));
+
+  // Edge cases
+  it("should keep unique names with trailing spaces unchanged", () =>
+    expect(deduplicateFileName("Report ", new Set(["Report"]))).toBe("Report "));
+
+  it("should normalize double spaces before numeric suffix when incrementing", () =>
+    expect(deduplicateFileName("Report  (1)", new Set(["Report  (1)"]))).toBe(
+      "Report (2)",
+    ));
+
+  it("should preserve multiple internal spaces when appending suffix", () =>
+    expect(deduplicateFileName("Annual   Report", new Set(["Annual   Report"]))).toBe(
+      "Annual   Report (1)",
+    ));
+
+  it("should handle unicode names when appending suffix", () =>
+    expect(deduplicateFileName("café", new Set(["café"]))).toBe("café (1)"));
+
+  it("should not treat fullwidth parentheses/digits as numeric suffix", () =>
+    expect(deduplicateFileName("Report（1）", new Set(["Report（1）"]))).toBe(
+      "Report（1） (1)",
+    ));
+
+  it("should handle emoji in names when appending suffix", () =>
+    expect(deduplicateFileName("Report 📄", new Set(["Report 📄"]))).toBe(
+      "Report 📄 (1)",
+    ));
+});

package/src/strings/deduplicateFileName.ts

@@ -0,0 +1,32 @@
+// Copyright 2025 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.
+
+export const deduplicateFileName = (
+  name: string,
+  existingNames: Set<string>,
+): string => {
+  if (!existingNames.has(name)) return name;
+  let baseName = name;
+  let i = 1;
+  let currentName = name;
+  while (existingNames.has(currentName)) {
+    const match = currentName.match(filenameEndingRegex);
+    if (match) {
+      baseName = currentName.slice(0, match.index).trim();
+      i = parseInt(match[1]) + 1;
+    } else {
+      baseName = currentName;
+      i = 1;
+    }
+    currentName = `${baseName} (${i})`;
+  }
+  return currentName;
+};
+
+const filenameEndingRegex = /\((\d+)\)$/;

package/src/strings/external.ts

@@ -0,0 +1,11 @@
+// Copyright 2025 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.
+
+export * from "@/strings/deduplicateFileName";
+export * from "@/strings/strings";

package/src/strings/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 strings from "@/strings/strings";
+export * as strings from "@/strings/external";

package/src/strings/strings.spec.ts

@@ -103,45 +103,3 @@ describe("trimPrefix", () => {
   it("should handle numbers in prefix", () =>
     expect(strings.trimPrefix("123abc", "123")).toBe("abc"));
 });
-
-describe("pluralName", () => {
-  it("should handle empty string", () => expect(strings.pluralName("")).toBe(""));
-
-  it("should add 's' to regular words", () => {
-    expect(strings.pluralName("cat")).toBe("cats");
-    expect(strings.pluralName("dog")).toBe("dogs");
-    expect(strings.pluralName("regularType")).toBe("regularTypes");
-  });
-
-  it("should convert 'y' endings to 'ies'", () => {
-    expect(strings.pluralName("company")).toBe("companies");
-    expect(strings.pluralName("yEndingType")).toBe("yEndingTypes");
-    expect(strings.pluralName("baby")).toBe("babies");
-  });
-
-  it("should add 'es' to words ending in 's'", () => {
-    expect(strings.pluralName("class")).toBe("classes");
-    expect(strings.pluralName("bus")).toBe("buses");
-  });
-
-  it("should add 'es' to words ending in 'x'", () => {
-    expect(strings.pluralName("box")).toBe("boxes");
-    expect(strings.pluralName("fox")).toBe("foxes");
-  });
-
-  it("should add 'es' to words ending in 'ch'", () => {
-    expect(strings.pluralName("catch")).toBe("catches");
-    expect(strings.pluralName("church")).toBe("churches");
-  });
-
-  it("should add 'es' to words ending in 'sh'", () => {
-    expect(strings.pluralName("bush")).toBe("bushes");
-    expect(strings.pluralName("brush")).toBe("brushes");
-  });
-
-  it("should work with built-in type names", () => {
-    expect(strings.pluralName("string")).toBe("strings");
-    expect(strings.pluralName("number")).toBe("numbers");
-    expect(strings.pluralName("object")).toBe("objects");
-  });
-});

package/src/strings/strings.ts

@@ -108,17 +108,3 @@ export const trimPrefix = (str: string, prefix: string): string => {
   if (str.startsWith(prefix)) return str.slice(prefix.length);
   return str;
 };
-
-export const pluralName = (name: string): string => {
-  if (name.length === 0) return name;
-  if (name[name.length - 1] === "y") return `${name.slice(0, -1)}ies`;
-  if (
-    name[name.length - 1] === "s" ||
-    name[name.length - 1] === "x" ||
-    name[name.length - 1] === "z" ||
-    name.endsWith("ch") ||
-    name.endsWith("sh")
-  )
-    return `${name}es`;
-  return `${name}s`;
-};