@looker/api-explorer 0.9.55 → 0.9.59

package/src/utils/hooks/navigation.spec.ts

@@ -23,12 +23,12 @@
  SOFTWARE.
 
  */
-import { useHistory } from 'react-router-dom'
-import { useNavigation } from './navigation'
+import { useHistory } from 'react-router-dom';
+import { useNavigation } from './navigation';
 
-const mockHistoryPush = jest.fn()
+const mockHistoryPush = jest.fn();
 jest.mock('react-router-dom', () => {
-  const ReactRouterDOM = jest.requireActual('react-router-dom')
+  const ReactRouterDOM = jest.requireActual('react-router-dom');
   return {
     ...ReactRouterDOM,
     useHistory: () => ({
@@ -38,81 +38,83 @@ jest.mock('react-router-dom', () => {
         search: 's=test&sdk=py&t=get',
       },
     }),
-  }
-})
+  };
+});
 
 describe('useNavigation', () => {
-  const history = useHistory()
+  const history = useHistory();
   const { navigate, navigateWithGlobalParams, buildPathWithGlobalParams } =
-    useNavigation()
-  const curParams = new URLSearchParams(history.location.search)
-  const route = `/3.1`
+    useNavigation();
+  const curParams = new URLSearchParams(history.location.search);
+  const route = `/3.1`;
 
   describe('navigate', () => {
     test('preserves existing query params when given params are undefined', () => {
-      navigate(route)
-      expect(curParams.get('s')).toBe('test')
-      expect(curParams.get('sdk')).toBe('py')
-      expect(curParams.get('t')).toBe('get')
+      navigate(route);
+      expect(curParams.get('s')).toBe('test');
+      expect(curParams.get('sdk')).toBe('py');
+      expect(curParams.get('t')).toBe('get');
       expect(mockHistoryPush).lastCalledWith({
         pathname: route,
         search: curParams.toString(),
-      })
-    })
+      });
+    });
 
     test('clears existing params when given params are null', () => {
-      navigate(route, null)
+      navigate(route, null);
       expect(mockHistoryPush).lastCalledWith({
         pathname: route,
-      })
-    })
+      });
+    });
 
     test('removes null query params while persisting undefined params if in URL', () => {
-      navigate(route, { s: null, sdk: 'test' })
+      navigate(route, { s: null, sdk: 'test' });
       expect(mockHistoryPush).lastCalledWith({
         pathname: route,
         search: 'sdk=test&t=get',
-      })
-    })
+      });
+    });
 
     test('sets query parameters when given a populated query params object', () => {
-      const newParams = new URLSearchParams()
-      newParams.set('s', 'newTest')
-      newParams.set('sdk', 'kt')
-      newParams.set('t', 'post')
+      const newParams = new URLSearchParams();
+      newParams.set('s', 'newTest');
+      newParams.set('sdk', 'kt');
+      newParams.set('t', 'post');
       navigate(route, {
         s: newParams.get('s'),
         sdk: newParams.get('sdk'),
         t: newParams.get('t'),
-      })
+      });
       expect(mockHistoryPush).lastCalledWith({
         pathname: route,
         search: newParams.toString(),
-      })
-    })
-  })
+      });
+    });
+  });
 
   describe('buildPathWithGlobalParams', () => {
     test('creates path with global parameters excluding scene specific parameters', () => {
-      curParams.delete('t')
+      curParams.delete('t');
       expect(buildPathWithGlobalParams(route)).toEqual(
         `${route}?${curParams.toString()}`
-      )
-    })
+      );
+    });
 
     test('adds other parameters if present', () => {
-      curParams.delete('t')
-      const actual = buildPathWithGlobalParams(route, { e: 400 })
-      expect(actual).toEqual(`${route}?${curParams.toString()}&e=400`)
-    })
-  })
+      curParams.delete('t');
+      const actual = buildPathWithGlobalParams(route, { e: 400 });
+      expect(actual).toEqual(`${route}?${curParams.toString()}&e=400`);
+    });
+  });
 
   describe('navigateWithGlobalParams', () => {
     test('preserves global query params and removes scene specific parameters', () => {
-      curParams.delete('t')
-      navigateWithGlobalParams(route)
-      expect(curParams.get('s')).toEqual('test')
-      expect(mockHistoryPush).lastCalledWith(`${route}?${curParams.toString()}`)
-    })
-  })
-})
+      curParams.delete('t');
+      navigateWithGlobalParams(route);
+      expect(curParams.get('s')).toEqual('test');
+      expect(mockHistoryPush).lastCalledWith(
+        `${route}?${curParams.toString()}`
+      );
+    });
+  });
+});

package/src/utils/hooks/navigation.ts

@@ -23,24 +23,24 @@
  SOFTWARE.
 
  */
-import { useHistory } from 'react-router-dom'
+import { useHistory } from 'react-router-dom';
 
-const GLOBAL_PARAMS = ['s', 'sdk']
+const GLOBAL_PARAMS = ['s', 'sdk'];
 
 interface QueryParamProps {
   /** Search Query **/
-  s?: string | null
+  s?: string | null;
   /** Chosen SDK Language **/
-  sdk?: string | null
+  sdk?: string | null;
   /** Tag Scene Filter **/
-  t?: string | null
+  t?: string | null;
 }
 
 /**
  * Hook for navigating to given route with query params
  */
 export const useNavigation = () => {
-  const history = useHistory()
+  const history = useHistory();
 
   /**
    * Navigates to path including provided search parameters
@@ -49,26 +49,29 @@ export const useNavigation = () => {
    * @param queryParams Hash of query param name/value pairs to include in the destination url
    */
   const navigate = (path: string, queryParams?: QueryParamProps | null) => {
-    const urlParams = new URLSearchParams(history.location.search)
+    const urlParams = new URLSearchParams(history.location.search);
 
     if (queryParams === undefined) {
       // if params passed in is undefined, maintain existing parameters in the URL
-      history.push({ pathname: path, search: urlParams.toString() })
+      history.push({ pathname: path, search: urlParams.toString() });
     } else if (queryParams === null) {
       // if params passed in is null, remove all parameters from the URL
-      history.push({ pathname: path })
+      history.push({ pathname: path });
     } else {
       // push each key as new param to URL, excluding entries with value null
       Object.keys(queryParams).forEach((key) => {
-        if (queryParams[key] === null || queryParams[key] === '') {
-          urlParams.delete(key)
+        if (
+          queryParams[key as keyof QueryParamProps] === null ||
+          queryParams[key as keyof QueryParamProps] === ''
+        ) {
+          urlParams.delete(key);
         } else {
-          urlParams.set(key, queryParams[key])
+          urlParams.set(key, queryParams[key as keyof QueryParamProps] ?? '');
         }
-      })
-      history.push({ pathname: path, search: urlParams.toString() })
+      });
+      history.push({ pathname: path, search: urlParams.toString() });
     }
-  }
+  };
 
   /**
    * Builds path to a scene and removes any scene-specific URL parameters
@@ -78,31 +81,31 @@ export const useNavigation = () => {
    * @returns a path excluding scene-specific search parameters
    */
   const buildPathWithGlobalParams = (path: string, otherParams = {}) => {
-    const params = new URLSearchParams(history.location.search)
+    const params = new URLSearchParams(history.location.search);
 
     for (const key of params.keys()) {
       if (!GLOBAL_PARAMS.includes(key)) {
-        params.delete(key)
+        params.delete(key);
       }
     }
-    const globalParams = params.toString()
+    const globalParams = params.toString();
 
-    let additionalParams = ''
+    let additionalParams = '';
     Object.entries(otherParams).forEach(([key, value]) => {
-      additionalParams += `${key}=${value}`
-    })
+      additionalParams += `${key}=${value}`;
+    });
 
-    let queryString = ''
+    let queryString = '';
     if (globalParams) {
-      queryString = globalParams
+      queryString = globalParams;
     }
 
     if (additionalParams) {
-      queryString += globalParams ? `&${additionalParams}` : additionalParams
+      queryString += globalParams ? `&${additionalParams}` : additionalParams;
     }
 
-    return `${path}${queryString ? `?${queryString}` : ''}`
-  }
+    return `${path}${queryString ? `?${queryString}` : ''}`;
+  };
 
   /**
    * Navigates to a scene removing any scene-specific URL parameters
@@ -110,12 +113,12 @@ export const useNavigation = () => {
    * @param path Pathname to navigate to
    */
   const navigateWithGlobalParams = (path: string) => {
-    history.push(buildPathWithGlobalParams(path))
-  }
+    history.push(buildPathWithGlobalParams(path));
+  };
 
   return {
     navigate,
     navigateWithGlobalParams,
     buildPathWithGlobalParams,
-  }
-}
+  };
+};

package/src/utils/hooks/useQuery.ts

@@ -23,14 +23,14 @@
  SOFTWARE.
 
  */
-import { useMemo } from 'react'
-import { useLocation } from 'react-router-dom'
+import { useMemo } from 'react';
+import { useLocation } from 'react-router-dom';
 
 /**
  * Hook for retrieving query params
  */
 export const useQuery = () => {
-  const { search } = useLocation()
+  const { search } = useLocation();
 
-  return useMemo(() => new URLSearchParams(search), [search])
-}
+  return useMemo(() => new URLSearchParams(search), [search]);
+};

package/src/utils/index.ts

@@ -23,11 +23,11 @@
  SOFTWARE.
 
  */
-export { highlightHTML } from './highlight'
-export * from './path'
-export * from './sdkLanguage'
-export { getLoded } from './lodeUtils'
-export { useWindowSize } from './useWindowSize'
-export * from './apixAdaptor'
-export * from './adaptorUtils'
-export { useNavigation, useGlobalStoreSync, useQuery } from './hooks'
+export { highlightHTML } from './highlight';
+export * from './path';
+export * from './sdkLanguage';
+export { getLoded } from './lodeUtils';
+export { useWindowSize } from './useWindowSize';
+export * from './apixAdaptor';
+export * from './adaptorUtils';
+export { useNavigation, useGlobalStoreSync, useQuery } from './hooks';

package/src/utils/lodeUtils.ts

@@ -24,22 +24,22 @@
 
  */
 
-import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen'
+import type { IDeclarationMine, IExampleMine } from '@looker/sdk-codegen';
 
-export const apixFilesHost = 'http://localhost:30000'
+export const apixFilesHost = 'http://localhost:30000';
 
 const fetchLode = async (lodeUrl: string) => {
   try {
-    const result = await fetch(lodeUrl, { mode: 'cors' })
-    return result.text()
+    const result = await fetch(lodeUrl, { mode: 'cors' });
+    return result.text();
   } catch (error) {
-    return ''
+    return '';
   }
-}
+};
 
 interface FullLode {
-  examples?: IExampleMine
-  declarations?: IDeclarationMine
+  examples?: IExampleMine;
+  declarations?: IDeclarationMine;
 }
 
 export const getLoded = async (
@@ -47,22 +47,22 @@ export const getLoded = async (
   declarationsLodeUrl?: string
 ): Promise<FullLode> => {
   // First try to load from the apix-files server
-  let examples = await fetchLode(`${apixFilesHost}/examplesIndex.json`)
+  let examples = await fetchLode(`${apixFilesHost}/examplesIndex.json`);
   if (!examples && examplesLodeUrl) {
-    examples = await fetchLode(examplesLodeUrl)
+    examples = await fetchLode(examplesLodeUrl);
   }
 
-  let declarations
+  let declarations;
   if (declarationsLodeUrl) {
-    declarations = await fetchLode(declarationsLodeUrl)
+    declarations = await fetchLode(declarationsLodeUrl);
   }
 
-  const lode: FullLode = { examples: undefined, declarations: undefined }
+  const lode: FullLode = { examples: undefined, declarations: undefined };
   if (examples) {
-    lode.examples = JSON.parse(examples)
+    lode.examples = JSON.parse(examples);
   }
   if (declarations) {
-    lode.declarations = JSON.parse(declarations)
+    lode.declarations = JSON.parse(declarations);
   }
-  return lode
-}
+  return lode;
+};

package/src/utils/path.spec.ts

@@ -24,120 +24,122 @@
 
  */
 
-import { api } from '../test-data'
+import { api } from '../test-data';
 import {
   buildMethodPath,
   buildPath,
   buildTypePath,
   getSceneType,
   isValidFilter,
-} from './path'
+} from './path';
 
 describe('path utils', () => {
-  const testParam = 's=test'
+  const testParam = 's=test';
   describe('buildMethodPath', () => {
     test('it builds a method path', () => {
-      const path = buildMethodPath('3.1', 'Dashboard', 'create_dashboard')
-      expect(path).toEqual('/3.1/methods/Dashboard/create_dashboard')
-    })
+      const path = buildMethodPath('3.1', 'Dashboard', 'create_dashboard');
+      expect(path).toEqual('/3.1/methods/Dashboard/create_dashboard');
+    });
     test('it builds a method path with params', () => {
       const path = buildMethodPath(
         '3.1',
         'Dashboard',
         'create_dashboard',
         testParam
-      )
+      );
       expect(path).toEqual(
         `/3.1/methods/Dashboard/create_dashboard?${testParam}`
-      )
-    })
-  })
+      );
+    });
+  });
 
   describe('buildTypePath', () => {
     test('it builds a type path', () => {
-      const path = buildTypePath('3.1', 'Dashboard', 'WriteDashboard')
-      expect(path).toEqual('/3.1/types/Dashboard/WriteDashboard')
-    })
+      const path = buildTypePath('3.1', 'Dashboard', 'WriteDashboard');
+      expect(path).toEqual('/3.1/types/Dashboard/WriteDashboard');
+    });
     test('it builds a type path with params', () => {
       const path = buildTypePath(
         '3.1',
         'Dashboard',
         'create_dashboard',
         testParam
-      )
-      expect(path).toEqual(`/3.1/types/Dashboard/create_dashboard?${testParam}`)
-    })
-  })
+      );
+      expect(path).toEqual(
+        `/3.1/types/Dashboard/create_dashboard?${testParam}`
+      );
+    });
+  });
 
   describe('buildPath', () => {
     test('given a method it builds a method path', () => {
-      const path = buildPath(api, api.methods.create_dashboard, '3.1')
-      expect(path).toEqual('/3.1/methods/Dashboard/create_dashboard')
-    })
+      const path = buildPath(api, api.methods.create_dashboard, '3.1');
+      expect(path).toEqual('/3.1/methods/Dashboard/create_dashboard');
+    });
 
     test('given a type it creates a type path', () => {
-      const path = buildPath(api, api.types.Dashboard, '3.1')
-      expect(path).toEqual('/3.1/types/Dashboard/Dashboard')
-    })
-  })
+      const path = buildPath(api, api.types.Dashboard, '3.1');
+      expect(path).toEqual('/3.1/types/Dashboard/Dashboard');
+    });
+  });
 
   describe('getSceneType', () => {
     test('returns correct scene type given location with pathname', () => {
-      const methodPath = '/3.1/methods/RandomMethod'
-      const typePath = '/3.1/types/RandomType'
-      expect(getSceneType(methodPath)).toEqual('methods')
-      expect(getSceneType(typePath)).toEqual('types')
-    })
+      const methodPath = '/3.1/methods/RandomMethod';
+      const typePath = '/3.1/types/RandomType';
+      expect(getSceneType(methodPath)).toEqual('methods');
+      expect(getSceneType(typePath)).toEqual('types');
+    });
     test('returns empty string if there is no scene type', () => {
-      const noSceneTypePath = '/'
-      expect(getSceneType(noSceneTypePath)).toEqual('')
-    })
-  })
+      const noSceneTypePath = '/';
+      expect(getSceneType(noSceneTypePath)).toEqual('');
+    });
+  });
 
   describe('isValidFilter', () => {
-    const methodPath = '/3.1/methods/RandomMethod'
-    const typePath = '/3.1/types/RandomType'
+    const methodPath = '/3.1/methods/RandomMethod';
+    const typePath = '/3.1/types/RandomType';
 
     test("validates 'all' as a valid filter for methods and types", () => {
-      expect(isValidFilter(methodPath, 'ALL')).toBe(true)
-      expect(isValidFilter(typePath, 'ALL')).toBe(true)
-    })
+      expect(isValidFilter(methodPath, 'ALL')).toBe(true);
+      expect(isValidFilter(typePath, 'ALL')).toBe(true);
+    });
 
-    const methodFilters = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE']
-    const typeFilters = ['SPECIFICATION', 'WRITE', 'REQUEST', 'ENUMERATED']
+    const methodFilters = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+    const typeFilters = ['SPECIFICATION', 'WRITE', 'REQUEST', 'ENUMERATED'];
 
     test.each(methodFilters)(
       'validates %s as a valid method filter',
       (filter) => {
-        expect(isValidFilter(methodPath, filter)).toBe(true)
+        expect(isValidFilter(methodPath, filter)).toBe(true);
       }
-    )
+    );
 
     test.each(methodFilters)(
       'invalidates %s when containing extra characters',
       (filter) => {
-        expect(isValidFilter(methodPath, filter + 'x')).toBe(false)
+        expect(isValidFilter(methodPath, filter + 'x')).toBe(false);
       }
-    )
+    );
 
     test.each(typeFilters)('validates %s as a valid type filter', (filter) => {
-      expect(isValidFilter(typePath, filter)).toBe(true)
-    })
+      expect(isValidFilter(typePath, filter)).toBe(true);
+    });
 
     test.each(typeFilters)(
       'invalidates %s when containing extra characters',
       (filter) => {
-        expect(isValidFilter(typePath, filter + 'x')).toBe(false)
+        expect(isValidFilter(typePath, filter + 'x')).toBe(false);
       }
-    )
+    );
 
     test('invalidates wrong parameter for methods and types', () => {
-      expect(isValidFilter(methodPath, 'INVALID')).toBe(false)
-      expect(isValidFilter(typePath, 'INVALID')).toBe(false)
-    })
+      expect(isValidFilter(methodPath, 'INVALID')).toBe(false);
+      expect(isValidFilter(typePath, 'INVALID')).toBe(false);
+    });
 
     test.each(typeFilters)('validates %s as a valid type filter', (filter) => {
-      expect(isValidFilter(typePath, filter)).toBe(true)
-    })
-  })
-})
+      expect(isValidFilter(typePath, filter)).toBe(true);
+    });
+  });
+});