signame -> sigid function done with tests

Author: eeen17

package.json

@@ -77,7 +77,7 @@
     "typescript": "^5.5.4",
     "typescript-eslint": "^8.0.1",
     "vite-tsconfig-paths": "^5.0.1",
-    "vitest": "^2.0.5",
+    "vitest": "^3.1.2",
     "yarn-upgrade-all": "^0.7.4"
   },
   "resolutions": {

src/common/utils.ts

@@ -12,3 +12,48 @@ export function transformCommaSeperatedName(name: string) {
   }
   return name;
 }
+
+const notUnreservedCharsRegex = /[^a-zA-Z0-9\-._~]/g;
+const reservedCharsRegex = /[:\/?#\[\]@!$&'()*+,;=]/g;
+/**
+ * Transforms an organization name (sig lead) into a URI-friendly format.
+ * The function performs the following transformations:
+ * - Removes characters that are reserved or not unreserved.
+ * - Adds spaces between camel case words.
+ * - Converts reserved characters to spaces.
+ * - Converts all characters to lowercase and replaces all types of whitespace with hyphens.
+ * - Replaces any sequence of repeated hyphens with a single hyphen.
+ * - Refer to RFC 3986 https://datatracker.ietf.org/doc/html/rfc3986#section-2.3
+ *
+ * @param {string} org - The organization (sig lead) name to be transformed.
+ * @returns {string} - The transformed organization name, ready for use as a URL.
+ */
+export function transformSigLeadToURI(org: string) {
+  console.log(`org\t${org}`)
+  org = org
+    // change not reserved chars to spaces
+    .trim()
+    .replace(notUnreservedCharsRegex, " ")
+    .trim()
+    .replace(/\s/g, "-")
+
+    // remove all that is reserved or not unreserved
+    .replace(reservedCharsRegex, "")
+
+    // convert SIG -> sig for camel case
+    .replace(/SIG/g, "sig")
+
+    // add hyphen for camel case
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+
+    // lower
+    .toLowerCase()
+    
+    // add spaces between chars and numbers (seq2seq -> seq-2-seq)
+    .replace(/(?<=[a-z])([0-9]+)(?=[a-z])/g, "-$1-")
+
+    // remove duplicate hyphens
+    .replace(/-{2,}/g, "-");
+
+  return org === "-" ? "" : org;
+}

tests/unit/common/utils.test.ts

@@ -1,5 +1,5 @@
 import { expect, test, describe } from "vitest";
-import { transformCommaSeperatedName } from "../../../src/common/utils.js";
+import { transformCommaSeperatedName, transformSigLeadToURI } from "../../../src/common/utils.js";
 
 describe("Comma-seperated name transformer tests", () => {
   test("Already-transformed names are returned as-is", () => {
@@ -27,3 +27,146 @@ describe("Comma-seperated name transformer tests", () => {
     expect(output).toEqual(", Test");
   });
 });
+
+describe("transformSigLeadToURI tests", () => {
+
+  // Basic Functionality Tests
+  test("should convert simple names with spaces to lowercase hyphenated", () => {
+    const output = transformSigLeadToURI("SIG Network");
+    expect(output).toEqual("sig-network");
+  });
+
+  test("should convert simple names to lowercase", () => {
+    const output = transformSigLeadToURI("Testing");
+    expect(output).toEqual("testing");
+  });
+
+  test("should handle names already in the desired format", () => {
+    const output = transformSigLeadToURI("already-transformed-name");
+    expect(output).toEqual("already-transformed-name");
+  });
+
+  // Camel Case Tests
+  test("should add hyphens between camelCase words", () => {
+    const output = transformSigLeadToURI("SIGAuth");
+    expect(output).toEqual("sig-auth");
+  });
+
+  test("should handle multiple camelCase words", () => {
+    const output = transformSigLeadToURI("SuperCamelCaseProject");
+    expect(output).toEqual("super-camel-case-project");
+  });
+
+  test("should handle mixed camelCase and spaces", () => {
+    const output = transformSigLeadToURI("SIG ContribEx"); // SIG Contributor Experience
+    expect(output).toEqual("sig-contrib-ex");
+  });
+
+  test("should handle camelCase starting with lowercase", () => {
+    const output = transformSigLeadToURI("myCamelCaseName");
+    expect(output).toEqual("my-camel-case-name");
+  });
+
+  // Reserved Character Tests (RFC 3986 gen-delims and sub-delims)
+  test("should convert reserved characters like & to hyphens", () => {
+    const output = transformSigLeadToURI("SIG Storage & Backup");
+    expect(output).toEqual("sig-storage-backup"); // & -> space -> hyphen
+  });
+
+  test("should convert reserved characters like / and : to hyphens", () => {
+    const output = transformSigLeadToURI("Project:Alpha/Beta");
+    expect(output).toEqual("project-alpha-beta"); // : -> space, / -> space, space+space -> hyphen
+  });
+
+  test("should convert reserved characters like () and + to hyphens", () => {
+    const output = transformSigLeadToURI("My Project (Test+Alpha)");
+    expect(output).toEqual("my-project-test-alpha");
+  });
+
+  test("should convert various reserved characters #[]@?$, to hyphens", () => {
+    const output = transformSigLeadToURI("Special#Chars[Test]?@Value,$");
+    expect(output).toEqual("special-chars-test-value");
+  });
+
+  // Non-Allowed Character Removal Tests
+  test("should remove characters not unreserved or reserved (e.g., ™, ©)", () => {
+    const output = transformSigLeadToURI("MyOrg™ With © Symbols");
+    expect(output).toEqual("my-org-with-symbols");
+  });
+
+  test("should remove emoji", () => {
+    const output = transformSigLeadToURI("Project ✨ Fun");
+    expect(output).toEqual("project-fun");
+  });
+
+
+  // Whitespace and Hyphen Collapsing Tests
+  test("should handle multiple spaces between words", () => {
+    const output = transformSigLeadToURI("SIG   UI   Project");
+    expect(output).toEqual("sig-ui-project");
+  });
+
+  test("should handle leading/trailing whitespace", () => {
+    const output = transformSigLeadToURI("  Leading and Trailing  ");
+    expect(output).toEqual("leading-and-trailing");
+  });
+
+  test("should handle mixed whitespace (tabs, newlines)", () => {
+    const output = transformSigLeadToURI("Mix\tOf\nWhite Space");
+    expect(output).toEqual("mix-of-white-space");
+  });
+
+  test("should collapse multiple hyphens resulting from transformations", () => {
+    const output = transformSigLeadToURI("Test--Multiple / Spaces");
+    expect(output).toEqual("test-multiple-spaces");
+  });
+
+  test("should collapse hyphens from start/end after transformations", () => {
+    const output = transformSigLeadToURI("&Another Test!");
+    expect(output).toEqual("another-test");
+  });
+
+  // Unreserved Character Tests (RFC 3986)
+  test("should keep unreserved characters: hyphen, period, underscore, tilde", () => {
+    const output = transformSigLeadToURI("Keep.These-Chars_Okay~123");
+    expect(output).toEqual("keep.these-chars_okay~123");
+  });
+
+  test("should handle unreserved chars next to reserved chars", () => {
+    const output = transformSigLeadToURI("Test._~&Stuff");
+    expect(output).toEqual("test._~-stuff");
+  });
+
+
+  // Edge Case Tests
+  test("should return an empty string for an empty input", () => {
+    const output = transformSigLeadToURI("");
+    expect(output).toEqual("");
+  });
+
+  test("should return an empty string for input with only spaces", () => {
+    const output = transformSigLeadToURI("   ");
+    expect(output).toEqual("");
+  });
+
+  test("should return an empty string for input with only reserved/non-allowed chars and spaces", () => {
+    const output = transformSigLeadToURI("  & / # ™ ©   ");
+    expect(output).toEqual("");
+  });
+
+  test("should handle numbers correctly", () => {
+    const output = transformSigLeadToURI("ProjectApollo11");
+    expect(output).toEqual("project-apollo11"); // Number doesn't trigger camel case break after letter
+  });
+
+  test("should handle numbers triggering camel case break", () => {
+    const output = transformSigLeadToURI("Project11Apollo");
+    expect(output).toEqual("project-11-apollo"); // Letter after number triggers camel case break
+  });
+
+  test("should handle names starting with lowercase", () => {
+    const output = transformSigLeadToURI("myOrg");
+    expect(output).toEqual("my-org");
+  });
+
+});