@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/test/requests/{ConfigRequest.test.js → ConfigRequest.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import WorkerFarm from '@atlaspack/workers';
 import path from 'path';
 import assert from 'assert';
@@ -12,25 +10,35 @@ import type {
   ConfigRequestResult,
 } from '../../src/requests/ConfigRequest';
 import type {RunAPI} from '../../src/RequestTracker';
-import {runConfigRequest} from '../../src/requests/ConfigRequest';
+import {
+  getValueAtPath,
+  runConfigRequest,
+} from '../../src/requests/ConfigRequest';
 import {toProjectPath} from '../../src/projectPath';
 
-// $FlowFixMe unclear-type forgive me
 const mockCast = (f: any): any => f;
 
 describe('ConfigRequest tests', () => {
   const projectRoot = 'project_root';
-  const farm = new WorkerFarm({
-    workerPath: require.resolve('../../src/worker'),
-    maxConcurrentWorkers: 1,
+  let farm: any;
+  let fs: any;
+  before(() => {
+    farm = new WorkerFarm({
+      workerPath: require.resolve('../../src/worker'),
+      maxConcurrentWorkers: 1,
+    });
   });
-  let fs = new MemoryFS(farm);
+
   beforeEach(() => {
     fs = new MemoryFS(farm);
   });
 
+  after(() => {
+    farm.end();
+  });
+
   const getMockRunApi = (
-    options: mixed = {projectRoot, inputFS: fs},
+    options: unknown = {projectRoot, inputFS: fs},
   ): RunAPI<ConfigRequestResult> => {
     const mockRunApi = {
       storeResult: sinon.spy(),
@@ -48,13 +56,13 @@ describe('ConfigRequest tests', () => {
       invalidateOnFileUpdate: sinon.spy(),
       invalidateOnOptionChange: sinon.spy(),
       invalidateOnStartup: sinon.spy(),
-      runRequest: sinon.spy((request) => {
+      runRequest: sinon.spy((request: any) => {
         return request.run({
           api: mockRunApi,
           options,
         });
       }),
-    };
+    } as const;
     return mockRunApi;
   };
 
@@ -228,7 +236,7 @@ describe('ConfigRequest tests', () => {
       ...baseRequest,
       invalidateOnConfigKeyChange: [
         {
-          configKey: 'key1',
+          configKey: ['key1'],
           filePath: toProjectPath(projectRoot, 'config.json'),
         },
       ],
@@ -244,8 +252,189 @@ describe('ConfigRequest tests', () => {
     const call = mockCast(mockRunApi.invalidateOnConfigKeyChange).getCall(0);
     assert.deepEqual(
       call.args,
-      ['config.json', 'key1', hashString('"value1"')],
+      ['config.json', ['key1'], hashString('"value1"')],
       'Invalidate was called for key1',
     );
   });
 });
+
+describe('getValueAtPath', () => {
+  it('can get a key from an object', () => {
+    const obj = {a: {b: {c: 'd'}}} as const;
+    assert.equal(getValueAtPath(obj, ['a', 'b', 'c']), 'd');
+  });
+
+  it('returns the original object when key array is empty', () => {
+    const obj = {a: 1, b: 2} as const;
+    assert.deepEqual(getValueAtPath(obj, []), obj);
+  });
+
+  it('can access single-level properties', () => {
+    const obj = {name: 'test', age: 25} as const;
+    assert.equal(getValueAtPath(obj, ['name']), 'test');
+    assert.equal(getValueAtPath(obj, ['age']), 25);
+  });
+
+  it('returns undefined for non-existent keys', () => {
+    const obj = {a: {b: 'value'}} as const;
+    assert.equal(getValueAtPath(obj, ['nonexistent']), undefined);
+    assert.equal(getValueAtPath(obj, ['a', 'nonexistent']), undefined);
+    assert.equal(getValueAtPath(obj, ['a', 'b', 'nonexistent']), undefined);
+  });
+
+  it('handles null and undefined values in the path', () => {
+    const obj = {a: null, b: {c: undefined}} as const;
+    assert.equal(getValueAtPath(obj, ['a']), null);
+    assert.equal(getValueAtPath(obj, ['b', 'c']), undefined);
+  });
+
+  it('does not throw when trying to access property of null', () => {
+    const obj = {a: null} as const;
+    assert.equal(getValueAtPath(obj, ['a', 'b']), undefined);
+  });
+
+  it('does not throw when trying to access property of undefined', () => {
+    const obj = {a: undefined} as const;
+    assert.equal(getValueAtPath(obj, ['a', 'b']), undefined);
+  });
+
+  it('can access nested arrays and objects', () => {
+    const obj = {
+      data: [
+        {name: 'item1', props: {color: 'red'}},
+        {name: 'item2', props: {color: 'blue'}},
+      ],
+    } as const;
+    assert.equal(getValueAtPath(obj, ['data', '0', 'name']), 'item1');
+    assert.equal(getValueAtPath(obj, ['data', '1', 'props', 'color']), 'blue');
+  });
+
+  it('handles numeric keys as strings', () => {
+    const obj = {'0': 'first', '1': {nested: 'value'}} as const;
+    assert.equal(getValueAtPath(obj, ['0']), 'first');
+    assert.equal(getValueAtPath(obj, ['1', 'nested']), 'value');
+  });
+
+  it('handles keys with special characters', () => {
+    const obj = {
+      'key-with-dashes': 'value1',
+      'key.with.dots': {
+        'nested-key': 'value2',
+      },
+      'key with spaces': 'value3',
+      '@special$chars#': 'value4',
+    } as const;
+    assert.equal(getValueAtPath(obj, ['key-with-dashes']), 'value1');
+    assert.equal(
+      getValueAtPath(obj, ['key.with.dots', 'nested-key']),
+      'value2',
+    );
+    assert.equal(getValueAtPath(obj, ['key with spaces']), 'value3');
+    assert.equal(getValueAtPath(obj, ['@special$chars#']), 'value4');
+  });
+
+  it('handles falsy values correctly', () => {
+    const obj = {
+      zero: 0,
+      false: false,
+      emptyString: '',
+      nullValue: null,
+      undefinedValue: undefined,
+      nested: {
+        zero: 0,
+        false: false,
+      },
+    } as const;
+    assert.equal(getValueAtPath(obj, ['zero']), 0);
+    assert.equal(getValueAtPath(obj, ['false']), false);
+    assert.equal(getValueAtPath(obj, ['emptyString']), '');
+    assert.equal(getValueAtPath(obj, ['nullValue']), null);
+    assert.equal(getValueAtPath(obj, ['undefinedValue']), undefined);
+    assert.equal(getValueAtPath(obj, ['nested', 'zero']), 0);
+    assert.equal(getValueAtPath(obj, ['nested', 'false']), false);
+  });
+
+  it('handles deep nesting', () => {
+    const obj = {
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              level5: {
+                deepValue: 'found',
+              },
+            },
+          },
+        },
+      },
+    } as const;
+    assert.equal(
+      getValueAtPath(obj, [
+        'level1',
+        'level2',
+        'level3',
+        'level4',
+        'level5',
+        'deepValue',
+      ]),
+      'found',
+    );
+  });
+
+  it('handles Date objects', () => {
+    const date = new Date('2023-01-01');
+    const obj = {
+      timestamp: date,
+      nested: {
+        date: date,
+      },
+    } as const;
+    assert.equal(getValueAtPath(obj, ['timestamp']), date);
+    assert.equal(getValueAtPath(obj, ['nested', 'date']), date);
+  });
+
+  it('handles complex nested structures with mixed types', () => {
+    const obj = {
+      users: [
+        {
+          id: 1,
+          profile: {
+            settings: {
+              theme: 'dark',
+              notifications: true,
+            },
+          },
+        },
+        {
+          id: 2,
+          profile: {
+            settings: {
+              theme: 'light',
+              notifications: false,
+            },
+          },
+        },
+      ],
+      config: {
+        version: '1.0.0',
+        features: ['feature1', 'feature2'],
+      },
+    } as const;
+
+    assert.equal(
+      getValueAtPath(obj, ['users', '0', 'profile', 'settings', 'theme']),
+      'dark',
+    );
+    assert.equal(
+      getValueAtPath(obj, [
+        'users',
+        '1',
+        'profile',
+        'settings',
+        'notifications',
+      ]),
+      false,
+    );
+    assert.equal(getValueAtPath(obj, ['config', 'features', '0']), 'feature1');
+  });
+});

package/test/requests/{DevDepRequest.test.js → DevDepRequest.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {clearBuildCaches} from '@atlaspack/build-cache';
 import {resolveDevDepRequestRef} from '../../src/requests/DevDepRequest';
 import type {DevDepRequest, DevDepRequestRef} from '../../src/types';