refactor: rename 'supported' → 'synchronous' query, move helper stuff

Author: jrolfs

lib/fixture/locator/fixtures.ts

@@ -1,43 +1,28 @@
-import type {Locator, Page, PlaywrightTestArgs, TestFixture} from '@playwright/test'
+import type {Locator, PlaywrightTestArgs, TestFixture} from '@playwright/test'
 import {selectors} from '@playwright/test'
-import {queries} from '@testing-library/dom'
 
-import {replacer} from '../helpers'
-import type {
-  Config,
-  LocatorQueries as Queries,
-  Query,
-  SelectorEngine,
-  SupportedQuery,
-} from '../types'
+import type {Config, LocatorQueries as Queries, SelectorEngine, SynchronousQuery} from '../types'
 
-import {buildTestingLibraryScript, isAllQuery, isNotFindQuery, queryToSelector} from './helpers'
+import {
+  buildTestingLibraryScript,
+  isAllQuery,
+  queriesFor,
+  queryToSelector,
+  synchronousQueryNames,
+} from './helpers'
 
-const allQueryNames = Object.keys(queries) as Query[]
-
-const queryNames = allQueryNames.filter(isNotFindQuery)
 const defaultConfig: Config = {testIdAttribute: 'data-testid', asyncUtilTimeout: 1000}
 
 const options = Object.fromEntries(
   Object.entries(defaultConfig).map(([key, value]) => [key, [value, {option: true}] as const]),
 )
 
-const queriesFor = (pageOrLocator: Page | Locator) =>
-  queryNames.reduce(
-    (rest, query) => ({
-      ...rest,
-      [query]: (...args: Parameters<Queries[keyof Queries]>) =>
-        pageOrLocator.locator(`${queryToSelector(query)}=${JSON.stringify(args, replacer)}`),
-    }),
-    {} as Queries,
-  )
-
 const queriesFixture: TestFixture<Queries, PlaywrightTestArgs> = async ({page}, use) =>
   use(queriesFor(page))
 
 const within = (locator: Locator): Queries => queriesFor(locator)
 
-declare const queryName: SupportedQuery
+declare const queryName: SynchronousQuery
 
 const engine: () => SelectorEngine = () => ({
   query(root, selector) {
@@ -77,7 +62,7 @@ const registerSelectorsFixture: [
   async ({}, use) => {
     try {
       await Promise.all(
-        queryNames.map(async name =>
+        synchronousQueryNames.map(async name =>
           selectors.register(
             queryToSelector(name),
             `(${engine.toString().replace(/queryName/g, `"${name}"`)})()`,

lib/fixture/locator/helpers.ts

@@ -1,14 +1,27 @@
 import {promises as fs} from 'fs'
 
+import type {Locator, Page} from '@playwright/test'
+import {queries} from '@testing-library/dom'
+
 import {configureTestingLibraryScript} from '../../common'
-import {reviver} from '../helpers'
-import type {AllQuery, Config, FindQuery, Query, Selector, SupportedQuery} from '../types'
+import {replacer, reviver} from '../helpers'
+import type {
+  AllQuery,
+  Config,
+  FindQuery,
+  LocatorQueries as Queries,
+  Query,
+  Selector,
+  SynchronousQuery,
+} from '../types'
+
+const allQueryNames = Object.keys(queries) as Query[]
 
 const isAllQuery = (query: Query): query is AllQuery => query.includes('All')
 const isNotFindQuery = (query: Query): query is Exclude<Query, FindQuery> =>
   !query.startsWith('find')
 
-const queryToSelector = (query: SupportedQuery) =>
+const queryToSelector = (query: SynchronousQuery) =>
   query.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase() as Selector
 
 const buildTestingLibraryScript = async ({config}: {config: Config}) => {
@@ -26,4 +39,16 @@ const buildTestingLibraryScript = async ({config}: {config: Config}) => {
   `
 }
 
-export {isAllQuery, isNotFindQuery, queryToSelector, buildTestingLibraryScript}
+const synchronousQueryNames = allQueryNames.filter(isNotFindQuery)
+
+const queriesFor = (pageOrLocator: Page | Locator) =>
+  synchronousQueryNames.reduce(
+    (rest, query) => ({
+      ...rest,
+      [query]: (...args: Parameters<Queries[keyof Queries]>) =>
+        pageOrLocator.locator(`${queryToSelector(query)}=${JSON.stringify(args, replacer)}`),
+    }),
+    {} as Queries,
+  )
+
+export {buildTestingLibraryScript, isAllQuery, queriesFor, queryToSelector, synchronousQueryNames}

lib/fixture/types.ts

@@ -45,9 +45,10 @@ export type Query = keyof Queries
 
 export type AllQuery = Extract<Query, `${string}All${string}`>
 export type FindQuery = Extract<Query, `find${string}`>
-export type SupportedQuery = Exclude<Query, FindQuery>
+export type GetQuery = Extract<Query, `get${string}`>
+export type SynchronousQuery = Exclude<Query, FindQuery>
 
-export type Selector = KebabCase<SupportedQuery>
+export type Selector = KebabCase<SynchronousQuery>
 
 export type {Config}
 export interface ConfigFn {