fix(compat/toPath): keep empty segments for consecutive and trailing dots

src/compat/array/invokeMap.spec.ts

@@ -28,7 +28,7 @@
 
     const actual = invokeMap(
       array,
       function (this: any, left: string, right: string) {
         return left + this.toUpperCase() + right;
       },
       '(',
@@ -162,7 +162,7 @@
     };
 
     const aEmptyDotC = invokeMap([objectWithEmptyPart], 'a..c');
-    expect(aEmptyDotC[0]).toBeUndefined();
+    expect(aEmptyDotC[0]).toBe(objectWithEmptyPart.a['']);
   });
 
   it('should match the type of lodash', () => {

src/compat/object/get.spec.ts

@@ -49,7 +49,7 @@
 
   it(`should get symbol keyed property values`, () => {
     const symbol = Symbol('a');
     const object: any = {};
     object[symbol] = 1;
 
     expect(get(object, symbol)).toBe(1);
@@ -157,11 +157,15 @@
   it('should prevent prototype pollution by returning defaultValue for __proto__ access', () => {
     expect(get({ ['__proto__']: {} }, '__proto__', 'defaultValue')).toBe('defaultValue');
     expect(get({ ['__proto__']: {} }, ['__proto__'], 'defaultValue')).toBe('defaultValue');
     expect(get({ ['__proto__']: {} }, { toString: () => '__proto__' } as any, 'defaultValue')).toBe('defaultValue');
   });
 
   it('should return defaultValue when property value is undefined', () => {
     const object = { '-0': undefined };
     expect(get(object, Object(-0), 'defaultValue')).toBe('defaultValue');
   });
+
+  it('should read empty-string keys produced by consecutive dots', () => {
+    expect(get({ a: { '': { b: 1 } } }, 'a..b')).toBe(1);
+  });
 });

src/compat/util/toPath.spec.ts

@@ -48,6 +48,18 @@ describe('toPath function', () => {
     expect(result).toEqual(['a', '', 'b']);
   });
 
+  it('keeps empty segments for consecutive dots', () => {
+    expect(toPath('a..b')).toEqual(['a', '', 'b']);
+    expect(toPath('a...b')).toEqual(['a', '', '', 'b']);
+    expect(toPath('..a')).toEqual(['', '', 'a']);
+    expect(toPath('a.b..c.d')).toEqual(['a', 'b', '', 'c', 'd']);
+  });
+
+  it('keeps a trailing empty segment for a trailing dot', () => {
+    expect(toPath('a.')).toEqual(['a', '']);
+    expect(toPath('a.b.')).toEqual(['a', 'b', '']);
+  });
+
   it('should match the type of lodash', () => {
     expectTypeOf(toPath).toEqualTypeOf<typeof toPathLodash>();
   });

src/compat/util/toPath.ts

@@ -18,7 +18,7 @@
  * toPath('') // Returns []
  * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
  */
 export function toPath(deepKey: any): string[] {
   if (Array.isArray(deepKey)) {
     // @types/lodash defines this as string[], but lodash itself returns (string | symbol)[]
     return deepKey.map(toKey) as string[];
@@ -40,10 +40,10 @@
   let quoteChar = '';
   let bracket = false;
 
-  // Leading dot
+  // Leading dot. Record the empty segment that precedes it, but leave the dot for the
+  // main loop so it is still treated as a separator (e.g. '..a' -> ['', '', 'a']).
   if (deepKey.charCodeAt(0) === 46) {
     result.push('');
-    index++;
   }
 
   while (index < length) {
@@ -85,6 +85,13 @@
           result.push(key);
           key = '';
         }
+        // A dot that is directly followed by another dot or the end of the string
+        // separates an empty segment, matching lodash (e.g. 'a..b' -> ['a', '', 'b'],
+        // 'a.' -> ['a', '']).
+        const next = deepKey[index + 1];
+        if (next === undefined || next === '.') {
+          result.push('');
+        }
       } else {
         key += char;
       }