Adding unflatten to objects

src/index.ts

@@ -3,3 +3,4 @@ export * as maths from './maths';
 export * as strings from './strings';
 export * as arrays from './arrays';
 export * as shell from './shell';
+export * as types from './types';

src/objects/flatten.ts

@@ -1,4 +1,4 @@
-function _flatten<Result extends object>(
+function _flatten<Result extends Record<string, unknown>>(
   obj: Record<string, unknown>,
   recursiveContext?: { parentKey: string; result: Result }
 ): Result {
@@ -17,7 +17,9 @@ function _flatten<Result extends object>(
   }, initialResult);
 }
 
-function flatten<Result extends object>(obj: Record<string, unknown>): Result {
+function flatten<Result extends Record<string, unknown>>(
+  obj: Record<string, unknown>
+): Result {
   return _flatten(obj);
 }
 

src/objects/index.ts

@@ -1,3 +1,4 @@
 export * from './omit';
 export * from './omitBy';
 export * from './flatten';
+export * from './unflatten';

src/objects/unflatten.test.ts

@@ -0,0 +1,25 @@
+import unflatten from './unflatten';
+
+describe('unflatten', () => {
+  it('unflatten the given object', () => {
+    const flatObject = {
+      'hello.yes': 'true',
+      flat: 'yes',
+      'nested.array': [1, 2],
+      'furthernested.yes.no': false,
+    };
+
+    const result = unflatten(flatObject, '.');
+
+    expect(result).toEqual({
+      hello: {
+        yes: 'true',
+      },
+      flat: 'yes',
+      nested: {
+        array: [1, 2],
+      },
+      furthernested: { yes: { no: false } },
+    });
+  });
+});

src/objects/unflatten.ts

@@ -0,0 +1,33 @@
+import type { NonEmptyArray } from '../types/arrays';
+import type { Character } from '../types/strings';
+
+function setNestedValue<Result extends object>(
+  obj: Result,
+  keys: NonEmptyArray<string>,
+  value: unknown
+): Result {
+  const [first, ...rest] = keys;
+  if (rest.length === 0) return { ...obj, [first]: value };
+
+  const nestedObject = (obj as Record<string, unknown>)[first] ?? {};
+
+  return {
+    ...obj,
+    [first]: setNestedValue(nestedObject, rest as NonEmptyArray<string>, value),
+  };
+}
+
+function unflatten<Result extends object, Delimiter extends string>(
+  data: object,
+  delimiter: Character<Delimiter>
+): Result {
+  const initialResult = {} as unknown as Result;
+
+  return Object.entries(data).reduce<Result>((acc, [key, value]) => {
+    const keys = key.split(delimiter) as NonEmptyArray<string>;
+
+    return setNestedValue(acc, keys, value);
+  }, initialResult);
+}
+
+export default unflatten;

src/types/arrays.ts

@@ -0,0 +1 @@
+export type NonEmptyArray<TargetArray> = [TargetArray, ...TargetArray[]];

src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './strings';
+export * from './arrays';

src/types/strings.ts

@@ -0,0 +1,7 @@
+type OnlyFirstCharacter<TargetString extends string> =
+  TargetString extends `${infer $TFirstChar}${string}` ? $TFirstChar : string;
+
+export type Character<TargetString extends string> =
+  TargetString extends TargetString & OnlyFirstCharacter<TargetString>
+    ? TargetString & OnlyFirstCharacter<TargetString>
+    : string & { length: 1 };