feat: Switch case dependency to internal helper (#296)

* feat: Switch case dependency to internal helper

* Add better tests

* Fold eth2 case handling into strings object

* Update tests

* lint

packages/ssz/package.json

@@ -36,8 +36,7 @@
   "types": "lib/index.d.ts",
   "dependencies": {
     "@chainsafe/as-sha256": "^0.3.1",
-    "@chainsafe/persistent-merkle-tree": "^0.4.2",
-    "case": "^1.6.3"
+    "@chainsafe/persistent-merkle-tree": "^0.4.2"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",

packages/ssz/src/type/container.ts

@@ -8,7 +8,6 @@ import {
   concatGindices,
   getNode,
 } from "@chainsafe/persistent-merkle-tree";
-import Case from "case";
 import {maxChunksToDepth} from "../util/merkleize";
 import {Require} from "../util/types";
 import {namedClass} from "../util/named";
@@ -21,7 +20,7 @@ import {
   ContainerTreeViewDUType,
   ContainerTreeViewDUTypeConstructor,
 } from "../viewDU/container";
-
+import {Case} from "../util/strings";
 /* eslint-disable @typescript-eslint/member-ordering */
 
 type BytesRange = {start: number; end: number};
@@ -35,7 +34,7 @@ export type ContainerOptions<Fields extends Record<string, unknown>> = {
   getContainerTreeViewDUClass?: typeof getContainerTreeViewDUClass;
 };
 
-type KeyCase =
+export type KeyCase =
   | "eth2"
   | "snake"
   | "constant"
@@ -551,12 +550,7 @@ export function precomputeJsonKey<Fields extends Record<string, Type<unknown>>>(
     }
     return keyFromCaseMap as string;
   } else if (jsonCase) {
-    if (jsonCase === "eth2") {
-      const snake = Case.snake(fieldName as string);
-      return snake.replace(/(\d)$/, "_$1");
-    } else {
-      return Case[jsonCase](fieldName as string);
-    }
+    return Case[jsonCase](fieldName as string);
   } else {
     return fieldName as string;
   }

packages/ssz/src/util/strings.ts

@@ -0,0 +1,31 @@
+// Convert camelCase strings to various other formats  -- assumes input field is camelCase or camel1Case
+
+export const Case = {
+  snake: (field: string): string =>
+    field
+      .replaceAll(/[^0-z]/g, "")
+      .replaceAll(/[a-z][A-Z]|[0-9][A-Z]/g, (substr) => substr[0] + "_" + substr[1].toLowerCase()),
+  constant: (field: string): string =>
+    field
+      .replaceAll(/[^0-z]/g, "")
+      .replaceAll(/[a-z][A-Z]|[0-9][A-Z]/g, (substr) => substr[0] + "_" + substr[1])
+      .toUpperCase(),
+  pascal: (field: string): string => {
+    const first = field[0].toUpperCase();
+    return (first + field.slice(1)).replaceAll(/[^0-z]/g, "");
+  },
+  camel: (field: string): string => {
+    return field[0].toLowerCase() + field.slice(1);
+  },
+  header: (field: string): string => {
+    const first = field[0].toUpperCase();
+    return (
+      first +
+      field
+        .slice(1)
+        .replaceAll(/[^0-z]/g, "")
+        .replaceAll(/[a-z][A-Z]|[0-9][A-Z]/g, (substr) => substr[0] + "-" + substr[1])
+    );
+  },
+  eth2: (field: string): string => Case.snake(field).replace(/(\d)$/, "_$1"),
+};

packages/ssz/test/unit/strings.test.ts

@@ -0,0 +1,25 @@
+import {expect} from "chai";
+
+import {Case} from "../../src/util/strings";
+import {KeyCase} from "../../src/type/container";
+const testCases = ["fooBar", "foo1Bar", "fooBarBaz", "foo1Bar2Baz", "fooBar1"];
+const expectedResults: {[key in KeyCase]: string[]} = {
+  snake: ["foo_bar", "foo1_bar", "foo_bar_baz", "foo1_bar2_baz", "foo_bar1"],
+  eth2: ["foo_bar", "foo1_bar", "foo_bar_baz", "foo1_bar2_baz", "foo_bar_1"],
+  pascal: ["FooBar", "Foo1Bar", "FooBarBaz", "Foo1Bar2Baz", "FooBar1"],
+  camel: ["fooBar", "foo1Bar", "fooBarBaz", "foo1Bar2Baz", "fooBar1"],
+  constant: ["FOO_BAR", "FOO1_BAR", "FOO_BAR_BAZ", "FOO1_BAR2_BAZ", "FOO_BAR1"],
+  header: ["Foo-Bar", "Foo1-Bar", "Foo-Bar-Baz", "Foo1-Bar2-Baz", "Foo-Bar1"],
+};
+
+const keys = Object.keys(expectedResults) as KeyCase[];
+for (const key of keys) {
+  describe(`should convert string to ${key} case`, () => {
+    for (let x = 0; x < 5; x++) {
+      const field: string = Case[key as KeyCase](testCases[x]);
+      it(`should convert to ${expectedResults[key as KeyCase][x]}`, () => {
+        expect(field).to.equal(expectedResults[key][x]);
+      });
+    }
+  });
+}