@looker/api-explorer 0.9.55 → 0.9.57

package/src/utils/adaptorUtils.ts

@@ -24,56 +24,56 @@
 
  */
 
-import type { ILookerVersions, SpecItem, SpecList } from '@looker/sdk-codegen'
-import { ApiModel, upgradeSpecObject } from '@looker/sdk-codegen'
-import { api_spec } from '@looker/sdk'
-import { getEnvAdaptor } from '@looker/extension-utils'
-import type { RunItValues } from '@looker/run-it'
-import { getUrl } from '@looker/run-it'
+import type { ILookerVersions, SpecItem, SpecList } from '@looker/sdk-codegen';
+import { ApiModel, upgradeSpecObject } from '@looker/sdk-codegen';
+import { api_spec } from '@looker/sdk';
+import { getEnvAdaptor } from '@looker/extension-utils';
+import type { RunItValues } from '@looker/run-it';
+import { getUrl } from '@looker/run-it';
 
-export type StorageLocation = 'session' | 'local'
+export type StorageLocation = 'session' | 'local';
 
 /** Object returned from storage service */
 export interface IStorageValue {
   /** Location of the stored object */
-  location: StorageLocation
+  location: StorageLocation;
   /** Stored string representation of the value (usually JSON) */
-  value: string
+  value: string;
 }
 
 /** function to retrieve a spec based on version and name */
 export type ApiSpecFetcher = (
   version: string,
   name: string
-) => Promise<string | RunItValues>
+) => Promise<string | RunItValues>;
 
 /** Either the spec is parsed or it's undefined */
-export type ParsedSpec = ApiModel | undefined
+export type ParsedSpec = ApiModel | undefined;
 
 /** service abstraction for extension and browser based usage */
 export interface RunItConfigurator {
-  getStorage: (key: string, defaultValue?: string) => IStorageValue
-  setStorage(key: string, value: string, location: 'local' | 'session'): string
-  removeStorage(key: string): void
+  getStorage: (key: string, defaultValue?: string) => IStorageValue;
+  setStorage(key: string, value: string, location: 'local' | 'session'): string;
+  removeStorage(key: string): void;
 }
 
 /** Processed specifications */
 export interface ILoadedSpecs {
   /** API server url */
-  baseUrl: string
+  baseUrl: string;
   /** Web server url */
-  webUrl: string
+  webUrl: string;
   /** should APIX run headless? */
-  headless: boolean
+  headless: boolean;
   /** loaded specifications */
-  specs: SpecList
+  specs: SpecList;
   /** communication errors */
-  fetchResult: string
+  fetchResult: string;
 }
 
 /** Extends versions payload with headless toggle for API Explorer */
 export interface IAPIXConfig extends ILookerVersions {
-  headless?: boolean
+  headless?: boolean;
 }
 
 /**
@@ -81,15 +81,15 @@ export interface IAPIXConfig extends ILookerVersions {
  * @param content to convert
  */
 const makeApi = (content: string | RunItValues) => {
-  let json
+  let json;
   if (typeof content === 'string') {
-    json = JSON.parse(content)
+    json = JSON.parse(content);
   } else {
-    json = content
+    json = content;
   }
-  json = upgradeSpecObject(json)
-  return ApiModel.fromJson(json)
-}
+  json = upgradeSpecObject(json);
+  return ApiModel.fromJson(json);
+};
 
 /**
  * Ensure the URI is a full URL
@@ -98,17 +98,17 @@ const makeApi = (content: string | RunItValues) => {
  */
 export const fullify = (uri: string, baseUrl: string): string => {
   if (uri.match(/^https?:/)) {
-    return uri
+    return uri;
   }
-  const url = new URL(uri, baseUrl)
-  return url.toString()
-}
+  const url = new URL(uri, baseUrl);
+  return url.toString();
+};
 /**
  * parse spec url into version and name for api_spec call
  * @param spec to parse
  */
 const apiSpecBits = (spec: SpecItem): string[] =>
-  spec.specURL?.split('/').slice(-2) || []
+  spec.specURL?.split('/').slice(-2) || [];
 
 /**
  * Use the functional api_spec fetch
@@ -116,9 +116,9 @@ const apiSpecBits = (spec: SpecItem): string[] =>
  * @param name to retrieve
  */
 export const funFetch = (version: string, name: string): Promise<string> => {
-  const sdk = getEnvAdaptor().sdk
-  return sdk.ok(api_spec(sdk, version, name))
-}
+  const sdk = getEnvAdaptor().sdk;
+  return sdk.ok(api_spec(sdk, version, name));
+};
 
 /**
  * try to fetch a spec by URL, trap any errors and return undefined
@@ -126,12 +126,12 @@ export const funFetch = (version: string, name: string): Promise<string> => {
  */
 export const specUrlFetch = async (url: string): Promise<ParsedSpec> => {
   try {
-    const content = await getUrl(url)
-    return makeApi(content)
+    const content = await getUrl(url);
+    return makeApi(content);
   } catch (error) {
-    return undefined
+    return undefined;
   }
-}
+};
 
 /**
  * fetch and compile an API specification to an ApiModel if it's not already available
@@ -145,12 +145,12 @@ export const sdkSpecFetch = async (
   spec: SpecItem,
   fetcher: ApiSpecFetcher
 ): Promise<ParsedSpec> => {
-  if (spec.api) return spec.api
-  if (!spec.specURL) return undefined
-  const [version, name] = apiSpecBits(spec)
-  const content = await fetcher(version, name)
-  return makeApi(content)
-}
+  if (spec.api) return spec.api;
+  if (!spec.specURL) return undefined;
+  const [version, name] = apiSpecBits(spec);
+  const content = await fetcher(version, name);
+  return makeApi(content);
+};
 
 /** Attempt to retrieve spec by URL, then api_spec SDK call
  *
@@ -161,21 +161,21 @@ export const fallbackFetch = async (
   spec: SpecItem,
   fetcher: ApiSpecFetcher
 ): Promise<ParsedSpec> => {
-  if (spec.api) return spec.api
-  if (!spec.specURL) return undefined
-  let api: ParsedSpec
+  if (spec.api) return spec.api;
+  if (!spec.specURL) return undefined;
+  let api: ParsedSpec;
   try {
-    api = await specUrlFetch(spec.specURL)
+    api = await specUrlFetch(spec.specURL);
   } catch (error) {
-    console.error({ error })
+    console.error({ error });
   }
   if (!api) {
-    const sdk = getEnvAdaptor().sdk
-    const authed = sdk.authSession.isAuthenticated()
+    const sdk = getEnvAdaptor().sdk;
+    const authed = sdk.authSession.isAuthenticated();
     if (!authed) {
-      await sdk.authSession.login()
+      await sdk.authSession.login();
     }
-    api = await sdkSpecFetch(spec, fetcher)
+    api = await sdkSpecFetch(spec, fetcher);
   }
-  return api
-}
+  return api;
+};

package/src/utils/apixAdaptor.ts

@@ -23,50 +23,56 @@
  SOFTWARE.
 
  */
-import type { IEnvironmentAdaptor } from '@looker/extension-utils'
-import { BrowserAdaptor, getEnvAdaptor } from '@looker/extension-utils'
-import type { IAPIMethods } from '@looker/sdk-rtl'
-import type { SpecItem, SpecList } from '@looker/sdk-codegen'
-import { getSpecsFromVersions } from '@looker/sdk-codegen'
-import { RunItConfigKey, RunItNoConfig } from '@looker/run-it'
-import cloneDeep from 'lodash/cloneDeep'
+import type { IEnvironmentAdaptor } from '@looker/extension-utils';
+import { BrowserAdaptor, getEnvAdaptor } from '@looker/extension-utils';
+import type { IAPIMethods } from '@looker/sdk-rtl';
+import type { SpecItem, SpecList } from '@looker/sdk-codegen';
+import { getSpecsFromVersions } from '@looker/sdk-codegen';
+import { RunItConfigKey, RunItNoConfig } from '@looker/run-it';
+import cloneDeep from 'lodash/cloneDeep';
 
-import { fullify, fallbackFetch, funFetch } from './adaptorUtils'
+import { fallbackFetch, fullify, funFetch } from './adaptorUtils';
 
 export interface IApixAdaptor extends IEnvironmentAdaptor {
-  fetchSpecList(versionsUrl?: string): Promise<SpecList>
-  fetchSpec(spec: SpecItem): Promise<SpecItem>
+  fetchSpecList(versionsUrl?: string): Promise<SpecList>;
+  fetchSpec(spec: SpecItem): Promise<SpecItem>;
 }
 
-export const getApixAdaptor = () => getEnvAdaptor() as IApixAdaptor
+export const getApixAdaptor = () => getEnvAdaptor() as IApixAdaptor;
 
 export class ApixAdaptor extends BrowserAdaptor implements IApixAdaptor {
-  constructor(sdk: IAPIMethods, private readonly fallbackVersionsUrl: string) {
-    super(sdk)
+  constructor(
+    sdk: IAPIMethods,
+    private readonly fallbackVersionsUrl: string
+  ) {
+    super(sdk);
   }
 
   async fetchSpecList(versionsUrl?: string): Promise<SpecList> {
-    const data = await this.localStorageGetItem(RunItConfigKey)
-    const config = data ? JSON.parse(data) : RunItNoConfig
-    let url: string
+    const data = await this.localStorageGetItem(RunItConfigKey);
+    const config = data ? JSON.parse(data) : RunItNoConfig;
+    let url: string;
 
     if (versionsUrl) {
-      url = versionsUrl
+      url = versionsUrl;
     } else {
       url = config.base_url
         ? `${config.base_url}/versions`
-        : `${this.fallbackVersionsUrl}/versions.json`
+        : `${this.fallbackVersionsUrl}/versions.json`;
     }
 
-    const versions = await this.sdk.authSession.transport.rawRequest('GET', url)
-    const specs = await getSpecsFromVersions(JSON.parse(versions.body))
-    return specs
+    const versions = await this.sdk.authSession.transport.rawRequest(
+      'GET',
+      url
+    );
+    const specs = await getSpecsFromVersions(JSON.parse(versions.body));
+    return specs;
   }
 
   async fetchSpec(spec: SpecItem): Promise<SpecItem> {
-    const _spec = cloneDeep(spec)
-    _spec.specURL = fullify(spec.specURL!, origin)
-    _spec.api = await fallbackFetch(_spec, funFetch)
-    return _spec
+    const _spec = cloneDeep(spec);
+    _spec.specURL = fullify(spec.specURL!, origin);
+    _spec.api = await fallbackFetch(_spec, funFetch);
+    return _spec;
   }
 }

package/src/utils/highlight.spec.tsx

@@ -23,30 +23,30 @@
  SOFTWARE.
 
  */
-import React from 'react'
-import { highlightHTML } from './highlight'
+import React from 'react';
+import { highlightHTML } from './highlight';
 
 describe('HTML highlighting', () => {
-  const str = 'create_dashboard'
+  const str = 'create_dashboard';
 
   test('it returns original string when there are no matches', () => {
-    const result = highlightHTML('query', str)
-    expect(result).toEqual(['create_dashboard'])
-  })
+    const result = highlightHTML('query', str);
+    expect(result).toEqual(['create_dashboard']);
+  });
 
   test('it returns original string when no pattern is provided', () => {
-    const result = highlightHTML('', str)
-    expect(result).toEqual(str)
-  })
+    const result = highlightHTML('', str);
+    expect(result).toEqual(str);
+  });
 
   test('it wraps matches with span tags', () => {
-    const result = highlightHTML('dash', str)
+    const result = highlightHTML('dash', str);
     expect(result).toEqual([
       'create_',
       <span key="1" className="hi">
         dash
       </span>,
       'board',
-    ])
-  })
-})
+    ]);
+  });
+});

package/src/utils/highlight.tsx

@@ -24,7 +24,7 @@
 
  */
 
-import React from 'react'
+import React from 'react';
 
 /**
  * Returns an HTML string with matches wrapped with with span tags
@@ -33,26 +33,26 @@ import React from 'react'
  * @returns content with highlighted matches
  */
 export const highlightHTML = (pattern: string, content: string) => {
-  let highlightedContent
+  let highlightedContent;
   if (!pattern) {
-    highlightedContent = content
+    highlightedContent = content;
   } else {
     try {
-      const target = new RegExp(`(${pattern})`, 'gi')
-      const contentArray = content.split(target)
+      const target = new RegExp(`(${pattern})`, 'gi');
+      const contentArray = content.split(target);
       highlightedContent = contentArray.map((str, index) => {
         if (target.test(str)) {
           return (
             <span key={index} className={'hi'}>
               {str}
             </span>
-          )
+          );
         }
-        return str
-      })
+        return str;
+      });
     } catch (e) {
-      highlightedContent = content
+      highlightedContent = content;
     }
   }
-  return highlightedContent
-}
+  return highlightedContent;
+};

package/src/utils/hooks/globalStoreSync.spec.tsx

@@ -23,78 +23,78 @@
  SOFTWARE.
 
  */
-import { renderHook } from '@testing-library/react-hooks'
-import { useHistory } from 'react-router-dom'
-import type { Location } from 'history'
-import * as reactRedux from 'react-redux'
-import * as routerLocation from 'react-router-dom'
-import { createTestStore, withReduxProvider } from '../../test-utils'
-import { useGlobalStoreSync } from './globalStoreSync'
+import { renderHook } from '@testing-library/react-hooks';
+import { useHistory } from 'react-router-dom';
+import type { Location } from 'history';
+import * as reactRedux from 'react-redux';
+import * as routerLocation from 'react-router-dom';
+import { createTestStore, withReduxProvider } from '../../test-utils';
+import { useGlobalStoreSync } from './globalStoreSync';
 
 jest.mock('react-router-dom', () => {
-  const ReactRouterDOM = jest.requireActual('react-router-dom')
+  const ReactRouterDOM = jest.requireActual('react-router-dom');
   return {
     ...ReactRouterDOM,
     useHistory: jest
       .fn()
       .mockReturnValue({ push: jest.fn(), location: globalThis.location }),
     useLocation: jest.fn().mockReturnValue({ pathname: '/', search: '' }),
-  }
-})
+  };
+});
 
 describe.skip('useGlobalStoreSync', () => {
-  const mockDispatch = jest.fn()
+  const mockDispatch = jest.fn();
 
   afterEach(() => {
-    jest.clearAllMocks()
-  })
+    jest.clearAllMocks();
+  });
 
   test('does nothing if uninitialized', () => {
-    const { push } = useHistory()
-    const wrapper = ({ children }: any) => withReduxProvider(children)
-    renderHook(() => useGlobalStoreSync(), { wrapper })
-    expect(push).not.toHaveBeenCalled()
-  })
+    const { push } = useHistory();
+    const wrapper = ({ children }: any) => withReduxProvider(children);
+    renderHook(() => useGlobalStoreSync(), { wrapper });
+    expect(push).not.toHaveBeenCalled();
+  });
 
   describe('search', () => {
     test('updates store search pattern with url search pattern if present', () => {
-      const { push } = useHistory()
+      const { push } = useHistory();
       const store = createTestStore({
         settings: {
           initialized: true,
         },
-      })
+      });
       jest.spyOn(routerLocation, 'useLocation').mockReturnValue({
         pathname: '/',
         search: `s=patternFromUrl`,
-      } as unknown as Location)
-      jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch)
-      const wrapper = ({ children }: any) => withReduxProvider(children, store)
-      renderHook(() => useGlobalStoreSync(), { wrapper })
+      } as unknown as Location);
+      jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch);
+      const wrapper = ({ children }: any) => withReduxProvider(children, store);
+      renderHook(() => useGlobalStoreSync(), { wrapper });
       expect(mockDispatch).toHaveBeenCalledWith({
         payload: { searchPattern: 'patternFromUrl' },
         type: 'settings/setSearchPatternAction',
-      })
-      expect(push).toHaveBeenCalledWith({ pathname: '/', search: 'sdk=py' })
-    })
-  })
+      });
+      expect(push).toHaveBeenCalledWith({ pathname: '/', search: 'sdk=py' });
+    });
+  });
 
   describe('sdk', () => {
     test('syncs url sdk param with sdk in store', () => {
-      const { push } = useHistory()
+      const { push } = useHistory();
       const store = createTestStore({
         settings: {
           initialized: true,
           sdkLanguage: 'Kotlin',
         },
-      })
-      const wrapper = ({ children }: any) => withReduxProvider(children, store)
-      renderHook(() => useGlobalStoreSync(), { wrapper })
+      });
+      const wrapper = ({ children }: any) => withReduxProvider(children, store);
+      renderHook(() => useGlobalStoreSync(), { wrapper });
       expect(push).toHaveBeenCalledWith({
         pathname: '/',
         search: 'sdk=kt',
-      })
-    })
+      });
+    });
 
     test.each([
       ['alias', 'kt'],
@@ -102,47 +102,47 @@ describe.skip('useGlobalStoreSync', () => {
     ])(
       'overrides store with sdk full name given valid url sdk %s',
       (_, param) => {
-        const { push } = useHistory()
+        const { push } = useHistory();
         const store = createTestStore({
           settings: {
             initialized: true,
           },
-        })
+        });
         jest.spyOn(routerLocation, 'useLocation').mockReturnValue({
           pathname: '/',
           search: `sdk=${param}`,
-        } as unknown as Location)
-        jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch)
+        } as unknown as Location);
+        jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch);
         const wrapper = ({ children }: any) =>
-          withReduxProvider(children, store)
-        renderHook(() => useGlobalStoreSync(), { wrapper })
-        expect(push).not.toHaveBeenCalled()
+          withReduxProvider(children, store);
+        renderHook(() => useGlobalStoreSync(), { wrapper });
+        expect(push).not.toHaveBeenCalled();
         expect(mockDispatch).toHaveBeenLastCalledWith({
           payload: { sdkLanguage: 'Kotlin' },
           type: 'settings/setSdkLanguageAction',
-        })
+        });
       }
-    )
+    );
 
     test('updates url sdk param with store sdk for invalid url sdk param', () => {
-      const { push } = useHistory()
+      const { push } = useHistory();
       const store = createTestStore({
         settings: {
           initialized: true,
         },
-      })
+      });
       jest.spyOn(routerLocation, 'useLocation').mockReturnValue({
         pathname: '/',
         search: `sdk=invalid`,
-      } as unknown as Location)
-      jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch)
-      const wrapper = ({ children }: any) => withReduxProvider(children, store)
-      renderHook(() => useGlobalStoreSync(), { wrapper })
-      expect(mockDispatch).not.toHaveBeenCalled()
+      } as unknown as Location);
+      jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(mockDispatch);
+      const wrapper = ({ children }: any) => withReduxProvider(children, store);
+      renderHook(() => useGlobalStoreSync(), { wrapper });
+      expect(mockDispatch).not.toHaveBeenCalled();
       expect(push).toHaveBeenCalledWith({
         pathname: '/',
         search: `sdk=py`,
-      })
-    })
-  })
-})
+      });
+    });
+  });
+});

package/src/utils/hooks/globalStoreSync.ts

@@ -23,55 +23,55 @@
  SOFTWARE.
 
  */
-import { useLocation } from 'react-router-dom'
-import { useEffect } from 'react'
-import { useSelector } from 'react-redux'
-import { allAlias, findSdk, useNavigation } from '../index'
+import { useLocation } from 'react-router-dom';
+import { useEffect } from 'react';
+import { useSelector } from 'react-redux';
+import { allAlias, findSdk, useNavigation } from '../index';
 import {
   selectSdkLanguage,
   useSettingActions,
   useSettingStoreState,
-} from '../../state'
+} from '../../state';
 
 /**
  * Hook for syncing global URL params with the Redux store
  * Global search parameters: 's', 'sdk'
  */
 export const useGlobalStoreSync = () => {
-  const location = useLocation()
-  const { navigate } = useNavigation()
-  const { setSdkLanguageAction, setSearchPatternAction } = useSettingActions()
-  const { initialized } = useSettingStoreState()
-  const selectedSdkLanguage = useSelector(selectSdkLanguage)
+  const location = useLocation();
+  const { navigate } = useNavigation();
+  const { setSdkLanguageAction, setSearchPatternAction } = useSettingActions();
+  const { initialized } = useSettingStoreState();
+  const selectedSdkLanguage = useSelector(selectSdkLanguage);
 
   useEffect(() => {
     if (initialized) {
-      const params = new URLSearchParams(location.search)
+      const params = new URLSearchParams(location.search);
 
       // syncing search query
-      const searchParam = params.get('s')
+      const searchParam = params.get('s');
       if (searchParam) {
         setSearchPatternAction({
           searchPattern: searchParam,
-        })
+        });
       }
 
       // syncing SDK language selection
-      const sdkParam = params.get('sdk') || ''
-      const sdk = findSdk(sdkParam)
+      const sdkParam = params.get('sdk') || '';
+      const sdk = findSdk(sdkParam);
       const validSdkParam =
         !sdkParam.localeCompare(sdk.alias, 'en', { sensitivity: 'base' }) ||
-        !sdkParam.localeCompare(sdk.language, 'en', { sensitivity: 'base' })
+        !sdkParam.localeCompare(sdk.language, 'en', { sensitivity: 'base' });
       if (validSdkParam) {
         setSdkLanguageAction({
           sdkLanguage: sdk.language,
-        })
+        });
       } else {
-        const { alias } = findSdk(selectedSdkLanguage)
+        const { alias } = findSdk(selectedSdkLanguage);
         navigate(location.pathname, {
           sdk: alias === allAlias ? null : alias,
-        })
+        });
       }
     }
-  }, [initialized])
-}
+  }, [initialized]);
+};

package/src/utils/hooks/index.ts

@@ -23,6 +23,6 @@
  SOFTWARE.
 
  */
-export { useNavigation } from './navigation'
-export { useGlobalStoreSync } from './globalStoreSync'
-export { useQuery } from './useQuery'
+export { useNavigation } from './navigation';
+export { useGlobalStoreSync } from './globalStoreSync';
+export { useQuery } from './useQuery';