@synnaxlabs/x 0.46.0 → 0.46.2

package/dist/src/math/round.d.ts

@@ -37,4 +37,14 @@ import { bounds } from '../spatial/bounds';
  * ```
  */
 export declare const roundBySpan: (value: number, b: bounds.Bounds<number>) => number;
+/**
+ * Intelligently rounds a number using span-based or significant figure logic.
+ * Designed for UI display where floating-point noise needs to be cleaned up.
+ *
+ * @param value - The number to be rounded.
+ * @param b - Optional bounds. Uses span-based rounding when span is significant,
+ * otherwise uses significant figures.
+ * @returns The rounded number.
+ */
+export declare const smartRound: (value: number, b?: bounds.Bounds<number>) => number;
 //# sourceMappingURL=round.d.ts.map

package/dist/src/math/round.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../src/math/round.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAG,MAarE,CAAC"}
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../../src/math/round.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAG,MAarE,CAAC;AAKF;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,EAAE,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAG,MAkCrE,CAAC"}

package/dist/src/status/status.d.ts

@@ -45,6 +45,7 @@ export type Crude<DetailsSchema = z.ZodNever, V extends Variant = Variant> = Opt
 });
 export declare const exceptionDetailsSchema: z.ZodObject<{
     stack: z.ZodString;
+    error: z.ZodCustom<Error, Error>;
 }, z.core.$strip>;
 export declare const fromException: (exc: unknown, message?: string) => Status<typeof exceptionDetailsSchema, "error">;
 export declare const create: <DetailsSchema = z.ZodNever, V extends Variant = Variant>(spec: Crude<DetailsSchema, V>) => Status<DetailsSchema, V>;

package/dist/src/status/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/status/status.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/status/status.ts"],"names":[],"mappings":"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"}

package/dist/src/strings/deduplicateFileName.d.ts

@@ -0,0 +1,2 @@
+export declare const deduplicateFileName: (name: string, existingNames: Set<string>) => string;
+//# sourceMappingURL=deduplicateFileName.d.ts.map

package/dist/src/strings/deduplicateFileName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicateFileName.d.ts","sourceRoot":"","sources":["../../../src/strings/deduplicateFileName.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,mBAAmB,GAC9B,MAAM,MAAM,EACZ,eAAe,GAAG,CAAC,MAAM,CAAC,KACzB,MAiBF,CAAC"}

package/dist/src/strings/deduplicateFileName.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deduplicateFileName.spec.d.ts.map

package/dist/src/strings/deduplicateFileName.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicateFileName.spec.d.ts","sourceRoot":"","sources":["../../../src/strings/deduplicateFileName.spec.ts"],"names":[],"mappings":""}

package/dist/src/strings/external.d.ts

@@ -0,0 +1,3 @@
+export * from './deduplicateFileName';
+export * from './strings';
+//# sourceMappingURL=external.d.ts.map

package/dist/src/strings/external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/strings/external.ts"],"names":[],"mappings":"AASA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mBAAmB,CAAC"}

package/dist/src/strings/index.d.ts

@@ -1,2 +1,2 @@
-export * as strings from './strings';
+export * as strings from './external';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/strings/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/strings/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/strings/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC"}

package/dist/src/strings/strings.d.ts

@@ -45,5 +45,4 @@ export declare const createShortIdentifiers: (name: string) => string[];
  * ```
  */
 export declare const trimPrefix: (str: string, prefix: string) => string;
-export declare const pluralName: (name: string) => string;
 //# sourceMappingURL=strings.d.ts.map

package/dist/src/strings/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../src/strings/strings.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,GAAG,MAAM,EAAE,EAC1B,aAAY,MAAW,KACtB,MAOF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,KAAG,MAAM,EAuC3D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,KAAG,MAGxD,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MAYzC,CAAC"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../../src/strings/strings.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,GAAG,MAAM,EAAE,EAC1B,aAAY,MAAW,KACtB,MAOF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,KAAG,MAAM,EAuC3D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,KAAG,MAGxD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/ts",

package/src/math/round.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-loss-of-precision */
 // Copyright 2025 Synnax Labs, Inc.
 //
 // Use of this software is governed by the Business Source License included in the file
@@ -79,3 +80,170 @@ describe("roundBySpan", () => {
     });
   });
 });
+
+interface SmartRoundTestCase {
+  value: number;
+  bounds?: bounds.Bounds<number>;
+  expected: number;
+}
+
+describe("smartRound", () => {
+  describe("span-based rounding (significant span)", () => {
+    const cases: SmartRoundTestCase[] = [
+      { value: 1234.5678, bounds: { lower: 0, upper: 2000 }, expected: 1234.57 },
+      { value: -5432.987654, bounds: { lower: -6000, upper: 0 }, expected: -5432.99 },
+      { value: 1.23456, bounds: { lower: 0, upper: 2 }, expected: 1.235 },
+      { value: -15.6789, bounds: { lower: -20, upper: -10 }, expected: -15.679 },
+      { value: 0.123456, bounds: { lower: 0, upper: 0.2 }, expected: 0.123 },
+      { value: 0.0001234567, bounds: { lower: 0, upper: 0.001 }, expected: 0.00012 },
+      {
+        value: 0.00000123456789,
+        bounds: { lower: 0, upper: 0.00001 },
+        expected: 0.0000012,
+      },
+      { value: 999.9999, bounds: { lower: 0, upper: 1500 }, expected: 1000.0 },
+      { value: 0.99999, bounds: { lower: 0, upper: 1.5 }, expected: 1.0 },
+    ];
+    cases.forEach(({ value, bounds, expected }) => {
+      it(`${value} with span ${(bounds!.upper - bounds!.lower).toFixed(1)}`, () => {
+        expect(math.smartRound(value, bounds)).toBe(expected);
+      });
+    });
+  });
+
+  describe("zero or negligible span", () => {
+    const cases: SmartRoundTestCase[] = [
+      {
+        value: 71.60000610351562,
+        bounds: { lower: 71.6, upper: 71.6 },
+        expected: 71.6,
+      },
+      {
+        value: 1234567.89123456,
+        bounds: { lower: 1234567, upper: 1234567 },
+        expected: 1234567.89,
+      },
+      {
+        value: -9876543.21987654,
+        bounds: { lower: -9876543, upper: -9876543 },
+        expected: -9876543.22,
+      },
+      { value: 123.456789123, bounds: { lower: 123, upper: 123 }, expected: 123.457 },
+      {
+        value: -456.789123456,
+        bounds: { lower: -456, upper: -456 },
+        expected: -456.789,
+      },
+      {
+        value: 0.0001234567,
+        bounds: { lower: 0.00012, upper: 0.00012 },
+        expected: 0.00012346,
+      },
+      {
+        value: 0.00000987654321,
+        bounds: { lower: 0.0000099, upper: 0.0000099 },
+        expected: 0.0000098765,
+      },
+      { value: 1.00000123456, bounds: { lower: 1, upper: 1 }, expected: 1.0 },
+      {
+        value: 0.999999123456,
+        bounds: { lower: 0.999999, upper: 0.999999 },
+        expected: 1.0,
+      },
+      {
+        value: 1000.123456789,
+        bounds: { lower: 1000, upper: 1000 },
+        expected: 1000.12,
+      },
+      {
+        value: 1000000.5,
+        bounds: { lower: 1000000.499999, upper: 1000000.500001 },
+        expected: 1000000.5,
+      },
+    ];
+    cases.forEach(({ value, bounds, expected }) => {
+      it(`${value}`, () => expect(math.smartRound(value, bounds)).toBe(expected));
+    });
+  });
+
+  describe("no bounds", () => {
+    const cases: SmartRoundTestCase[] = [
+      { value: 123456.789123, expected: 123456.79 },
+      { value: 71.60000610351562, expected: 71.6 },
+      { value: 0.00012345678, expected: 0.00012346 },
+      { value: 9876543210.123456, expected: 9876543210.12 },
+      { value: 0.00000000123456789, expected: 0.0000000012346 },
+      { value: -987654.321987, expected: -987654.32 },
+      { value: -42.123456789, expected: -42.123 },
+      { value: -0.000456789123, expected: -0.00045679 },
+      { value: 999.9999, expected: 1000.0 },
+      { value: 0.9999999, expected: 1.0 },
+    ];
+    cases.forEach(({ value, expected }) => {
+      it(`${value}`, () => expect(math.smartRound(value)).toBe(expected));
+    });
+  });
+
+  describe("edge cases", () => {
+    it("NaN", () => expect(Number.isNaN(math.smartRound(NaN))).toBe(true));
+    it("NaN with bounds", () =>
+      expect(Number.isNaN(math.smartRound(NaN, { lower: 0, upper: 10 }))).toBe(true));
+    it("Infinity", () => expect(math.smartRound(Infinity)).toBe(Infinity));
+    it("-Infinity", () => expect(math.smartRound(-Infinity)).toBe(-Infinity));
+    it("Infinity with bounds", () =>
+      expect(math.smartRound(Infinity, { lower: 0, upper: 100 })).toBe(Infinity));
+    it("zero", () => expect(math.smartRound(0)).toBe(0));
+    it("zero with bounds", () =>
+      expect(math.smartRound(0, { lower: -10, upper: 10 })).toBe(0));
+    it("very small value", () => expect(math.smartRound(1e-15)).toBeCloseTo(1e-15, 17));
+    it("very large value", () => expect(math.smartRound(1e15)).toBe(1e15));
+    it("negative zero", () => expect(math.smartRound(-0)).toBe(0));
+  });
+  describe("boundary conditions", () => {
+    it("zero span", () =>
+      expect(math.smartRound(123.456789, { lower: 100, upper: 100 })).toBe(123.457));
+    it("span above threshold", () =>
+      expect(math.smartRound(1000, { lower: 999, upper: 1000 })).toBe(1000.0));
+    it("span below threshold", () =>
+      expect(math.smartRound(1000000, { lower: 1000000, upper: 1000000 + 1e-12 })).toBe(
+        1000000.0,
+      ));
+    it("1000 boundary", () => {
+      expect(math.smartRound(999.999)).toBe(999.999);
+      expect(math.smartRound(1000.001)).toBe(1000.0);
+    });
+    it("1 boundary", () => {
+      expect(math.smartRound(0.999999)).toBe(1.0);
+      expect(math.smartRound(1.000001)).toBe(1.0);
+    });
+  });
+  describe("precision preservation", () => {
+    it("no artificial precision", () =>
+      expect(math.smartRound(1.5, { lower: 1, upper: 2 })).toBe(1.5));
+    it("0.1 + 0.2", () => expect(math.smartRound(0.1 + 0.2)).toBe(0.3));
+    it("0.1 * 3", () => expect(math.smartRound(0.1 * 3)).toBe(0.3));
+    it("integer preservation", () =>
+      expect(math.smartRound(42, { lower: 0, upper: 100 })).toBe(42.0));
+    it("rounds to integer", () =>
+      expect(math.smartRound(42.0001, { lower: 42, upper: 42 })).toBe(42.0));
+  });
+  describe("stress tests", () => {
+    it("random values", () => {
+      for (let i = 0; i < 100; i++) {
+        const value = Math.random() * 1000000 - 500000;
+        expect(Number.isFinite(math.smartRound(value))).toBe(true);
+      }
+    });
+    it("random with bounds", () => {
+      for (let i = 0; i < 100; i++) {
+        const lower = Math.random() * 1000 - 500;
+        const upper = lower + Math.random() * 1000;
+        const value = lower + (upper - lower) * Math.random();
+        const result = math.smartRound(value, { lower, upper });
+        expect(Number.isFinite(result)).toBe(true);
+        expect(result).toBeGreaterThanOrEqual(lower - 1);
+        expect(result).toBeLessThanOrEqual(upper + 1);
+      }
+    });
+  });
+});

package/src/math/round.ts

@@ -66,3 +66,51 @@ export const roundBySpan = (value: number, b: bounds.Bounds<number>): number =>
   const multiplier = 10 ** decimalPlaces;
   return Math.round(value * multiplier) / multiplier;
 };
+
+const SIGNIFICANT_FIGURES = 5;
+const MIN_SPAN_THRESHOLD = 1e-10;
+
+/**
+ * Intelligently rounds a number using span-based or significant figure logic.
+ * Designed for UI display where floating-point noise needs to be cleaned up.
+ *
+ * @param value - The number to be rounded.
+ * @param b - Optional bounds. Uses span-based rounding when span is significant,
+ * otherwise uses significant figures.
+ * @returns The rounded number.
+ */
+export const smartRound = (value: number, b?: bounds.Bounds<number>): number => {
+  if (Number.isNaN(value) || !Number.isFinite(value)) return value;
+  const absValue = Math.abs(value);
+  if (absValue === 0) return 0;
+  let useSpanBased = false;
+  let span = 0;
+  if (b != null) {
+    span = bounds.span(b);
+    const spanRatio = span / absValue;
+    useSpanBased = span > 0 && spanRatio > MIN_SPAN_THRESHOLD;
+  }
+  if (useSpanBased) {
+    let decimalPlaces: number;
+    if (span >= 1000) decimalPlaces = LARGE_SPAN_DECIMAL_PLACES;
+    else if (span >= 1) decimalPlaces = MEDIUM_SPAN_DECIMAL_PLACES;
+    else {
+      const decimalPlacesInSpan = Math.ceil(-Math.log10(span));
+      decimalPlaces = decimalPlacesInSpan + EXTRA_DECIMAL_PLACES;
+    }
+    const multiplier = 10 ** decimalPlaces;
+    return Math.round(value * multiplier) / multiplier;
+  }
+  if (absValue >= 1000) {
+    const multiplier = 10 ** LARGE_SPAN_DECIMAL_PLACES;
+    return Math.round(value * multiplier) / multiplier;
+  }
+  if (absValue >= 1) {
+    const multiplier = 10 ** MEDIUM_SPAN_DECIMAL_PLACES;
+    return Math.round(value * multiplier) / multiplier;
+  }
+  const magnitude = Math.floor(Math.log10(absValue));
+  const decimalPlaces = SIGNIFICANT_FIGURES - magnitude - 1;
+  const multiplier = 10 ** decimalPlaces;
+  return Math.round(value * multiplier) / multiplier;
+};

package/src/status/status.spec.ts

@@ -74,4 +74,59 @@ describe("status", () => {
       expect(status.removeVariants("success", [])).toBe("success");
     });
   });
+
+  describe("fromException", () => {
+    it("should create an error status from an Error instance", () => {
+      const error = new Error("Something went wrong");
+      const s = status.fromException(error);
+
+      expect(s.variant).toBe("error");
+      expect(s.message).toBe("Something went wrong");
+      expect(s.description).toBeUndefined();
+      expect(s.details.error).toBe(error);
+      expect(s.details.stack).toBe(error.stack ?? "");
+    });
+
+    it("should use custom message and move error message to description", () => {
+      const error = new Error("Original error");
+      const s = status.fromException(error, "Custom message");
+
+      expect(s.variant).toBe("error");
+      expect(s.message).toBe("Custom message");
+      expect(s.description).toBe("Original error");
+      expect(s.details.error).toBe(error);
+      expect(s.details.stack).toBe(error.stack ?? "");
+    });
+
+    it("should handle errors without stack trace", () => {
+      const error = new Error("No stack");
+      error.stack = undefined;
+      const s = status.fromException(error);
+
+      expect(s.details.stack).toBe("");
+      expect(s.details.error).toBe(error);
+    });
+
+    it("should throw when exception is not an Error instance", () => {
+      const notAnError = "just a string";
+      expect(() => status.fromException(notAnError)).toThrow("just a string");
+    });
+
+    it("should include valid key and timestamp", () => {
+      const error = new Error("Test error");
+      const s = status.fromException(error);
+
+      expect(s.key).toHaveLength(id.LENGTH);
+      expect(s.time).toBeInstanceOf(TimeStamp);
+      expect(s.time.beforeEq(TimeStamp.now())).toBe(true);
+    });
+
+    it("should conform to exceptionDetailsSchema", () => {
+      const error = new Error("Test error");
+      const s = status.fromException(error);
+
+      const result = status.exceptionDetailsSchema.safeParse(s.details);
+      expect(result.success).toBe(true);
+    });
+  });
 });

package/src/status/status.ts

@@ -83,6 +83,7 @@ export type Crude<DetailsSchema = z.ZodNever, V extends Variant = Variant> = Opt
 
 export const exceptionDetailsSchema = z.object({
   stack: z.string(),
+  error: z.instanceof(Error),
 });
 
 export const fromException = (
@@ -94,9 +95,7 @@ export const fromException = (
     variant: "error",
     message: message ?? exc.message,
     description: message != null ? exc.message : undefined,
-    details: {
-      stack: exc.stack ?? "",
-    },
+    details: { stack: exc.stack ?? "", error: exc },
   });
 };
 

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`;
-};