@graphcommerce/next-config 8.1.0-canary.2 → 8.1.0-canary.5

package/src/interceptors/generateInterceptor.ts

@@ -0,0 +1,271 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import prettierConf from '@graphcommerce/prettier-config-pwa'
+// eslint-disable-next-line import/no-extraneous-dependencies
+import prettier from 'prettier'
+import { GraphCommerceDebugConfig } from '../generated/config'
+import { ResolveDependencyReturn } from '../utils/resolveDependency'
+import { RenameVisitor } from './RenameVisitor'
+import { parseSync, printSync } from './swc'
+
+type PluginBaseConfig = {
+  type: 'component' | 'function' | 'replace'
+  targetModule: string
+  sourceExport: string
+  sourceModule: string
+  targetExport: string
+  enabled: boolean
+  ifConfig?: string | [string, string]
+}
+
+export function isPluginBaseConfig(plugin: Partial<PluginBaseConfig>): plugin is PluginBaseConfig {
+  return (
+    typeof plugin.type === 'string' &&
+    typeof plugin.sourceModule === 'string' &&
+    typeof plugin.enabled === 'boolean' &&
+    typeof plugin.targetExport === 'string'
+  )
+}
+
+type ReactPluginConfig = PluginBaseConfig & { type: 'component' }
+type MethodPluginConfig = PluginBaseConfig & { type: 'function' }
+type ReplacePluginConfig = PluginBaseConfig & { type: 'replace' }
+
+export function isReactPluginConfig(
+  plugin: Partial<PluginBaseConfig>,
+): plugin is ReactPluginConfig {
+  if (!isPluginBaseConfig(plugin)) return false
+  return plugin.type === 'component'
+}
+
+export function isMethodPluginConfig(
+  plugin: Partial<PluginBaseConfig>,
+): plugin is MethodPluginConfig {
+  if (!isPluginBaseConfig(plugin)) return false
+  return plugin.type === 'function'
+}
+
+export function isReplacePluginConfig(
+  plugin: Partial<PluginBaseConfig>,
+): plugin is ReactPluginConfig {
+  if (!isPluginBaseConfig(plugin)) return false
+  return plugin.type === 'replace'
+}
+
+export type PluginConfig = ReactPluginConfig | MethodPluginConfig | ReplacePluginConfig
+
+export function isPluginConfig(plugin: Partial<PluginConfig>): plugin is PluginConfig {
+  return isPluginBaseConfig(plugin)
+}
+
+export type Interceptor = ResolveDependencyReturn & {
+  targetExports: Record<string, PluginConfig[]>
+  target: string
+  source: string
+  template?: string
+}
+
+export type MaterializedPlugin = Interceptor & { template: string }
+
+export const SOURCE_START = '/** ❗️ Original (modified) source starts here **/'
+export const SOURCE_END = '/** ❗️ Original (modified) source ends here **/'
+
+const originalSuffix = 'Original'
+const sourceSuffix = 'Source'
+const interceptorSuffix = 'Interceptor'
+const disabledSuffix = 'Disabled'
+const name = (plugin: PluginConfig) =>
+  `${plugin.sourceExport}${plugin.sourceModule
+    .split('/')
+    [plugin.sourceModule.split('/').length - 1].replace(/[^a-zA-Z0-9]/g, '')}`
+
+const fileName = (plugin: PluginConfig) => `${plugin.sourceModule}#${plugin.sourceExport}`
+
+const originalName = (n: string) => `${n}${originalSuffix}`
+const sourceName = (n: string) => `${n}${sourceSuffix}`
+const interceptorName = (n: string) => `${n}${interceptorSuffix}`
+const interceptorPropsName = (n: string) => `${interceptorName(n)}Props`
+
+export function moveRelativeDown(plugins: PluginConfig[]) {
+  return [...plugins].sort((a, b) => {
+    if (a.sourceModule.startsWith('.') && !b.sourceModule.startsWith('.')) return 1
+    if (!a.sourceModule.startsWith('.') && b.sourceModule.startsWith('.')) return -1
+    return 0
+  })
+}
+
+const generateIdentifyer = (s: string) =>
+  Math.abs(
+    s.split('').reduce((a, b) => {
+      // eslint-disable-next-line no-param-reassign, no-bitwise
+      a = (a << 5) - a + b.charCodeAt(0)
+      // eslint-disable-next-line no-bitwise
+      return a & a
+    }, 0),
+  ).toString()
+
+/**
+ * The is on the first line, with the format: \/* hash:${identifer} *\/
+ */
+function extractIdentifier(source: string | undefined) {
+  if (!source) return null
+  const match = source.match(/\/\* hash:(\d+) \*\//)
+  if (!match) return null
+  return match[1]
+}
+
+export async function generateInterceptor(
+  interceptor: Interceptor,
+  config: GraphCommerceDebugConfig,
+  oldInterceptorSource?: string,
+): Promise<MaterializedPlugin> {
+  const identifer = generateIdentifyer(JSON.stringify(interceptor) + JSON.stringify(config))
+
+  const { dependency, targetExports, source } = interceptor
+
+  if (oldInterceptorSource && identifer === extractIdentifier(oldInterceptorSource))
+    return { ...interceptor, template: oldInterceptorSource }
+
+  const pluginConfigs = [...Object.entries(targetExports)].map(([, plugins]) => plugins).flat()
+
+  // console.log('pluginConfigs', pluginConfigs)
+  const duplicateImports = new Set()
+
+  const pluginImports = moveRelativeDown(
+    [...pluginConfigs].sort((a, b) => a.sourceModule.localeCompare(b.sourceModule)),
+  )
+    .map(
+      (plugin) =>
+        `import { ${plugin.sourceExport} as ${sourceName(name(plugin))} } from '${plugin.sourceModule}'`,
+    )
+    .filter((str) => {
+      if (duplicateImports.has(str)) return false
+      duplicateImports.add(str)
+      return true
+    })
+    .join('\n')
+
+  const ast = parseSync(source)
+
+  new RenameVisitor(Object.keys(targetExports), (s) => originalName(s)).visitModule(ast)
+
+  const pluginExports = Object.entries(targetExports)
+    .map(([base, plugins]) => {
+      const duplicateInterceptors = new Set()
+
+      let carry = originalName(base)
+      const carryProps: string[] = []
+
+      const pluginStr = plugins
+        .reverse()
+        .filter((p: PluginConfig) => {
+          if (duplicateInterceptors.has(name(p))) return false
+          duplicateInterceptors.add(name(p))
+          return true
+        })
+        .map((p) => {
+          let result
+
+          const wrapChain = plugins
+            .reverse()
+            .map((pl) => name(pl))
+            .join(' wrapping ')
+
+          if (isReplacePluginConfig(p)) {
+            new RenameVisitor([originalName(p.targetExport)], (s) =>
+              s.replace(originalSuffix, disabledSuffix),
+            ).visitModule(ast)
+
+            carryProps.push(interceptorPropsName(name(p)))
+
+            result = `type ${interceptorPropsName(name(p))} = React.ComponentProps<typeof ${sourceName(name(p))}>`
+          }
+
+          if (isReactPluginConfig(p)) {
+            carryProps.push(interceptorPropsName(name(p)))
+
+            result = `
+              type ${interceptorPropsName(name(p))} = DistributedOmit<React.ComponentProps<typeof ${sourceName(name(p))}>, 'Prev'>
+              const ${interceptorName(name(p))} = (props: ${carryProps.join(' & ')}) => {
+                ${config.pluginStatus ? `logOnce(\`🔌 Rendering ${base} with plugin(s): ${wrapChain} wrapping <${base}/>\`)` : ''}
+
+                ${
+                  process.env.NODE_ENV === 'development'
+                    ? `if(!props['data-plugin'])
+                  logOnce('${fileName(p)} does not spread props to prev: <Prev {...props}/>. This will cause issues if multiple plugins are applied to this component.')`
+                    : ''
+                }
+                return <${sourceName(name(p))} {...props} Prev={${carry} as React.FC} />
+              }`
+          }
+
+          if (isMethodPluginConfig(p)) {
+            result = `const ${interceptorName(name(p))}: typeof ${carry} = (...args) => {
+                ${config.pluginStatus ? `logOnce(\`🔌 Calling ${base} with plugin(s): ${wrapChain} wrapping ${base}()\`)` : ''}
+                return ${sourceName(name(p))}(${carry}, ...args)
+              }`
+          }
+
+          carry = p.type === 'replace' ? sourceName(name(p)) : interceptorName(name(p))
+          return result
+        })
+        .filter((v) => !!v)
+        .join('\n')
+
+      const isComponent = plugins.every((p) => isReplacePluginConfig(p) || isReactPluginConfig(p))
+      if (isComponent && plugins.some((p) => isMethodPluginConfig(p))) {
+        throw new Error(`Cannot mix React and Method plugins for ${base} in ${dependency}.`)
+      }
+
+      if (process.env.NODE_ENV === 'development' && isComponent) {
+        return `${pluginStr}
+          export const ${base}: typeof ${carry} = (props) => {
+            return <${carry} {...props} data-plugin />
+          }`
+      }
+
+      return `
+        ${pluginStr}
+        export const ${base} = ${carry}
+      `
+    })
+    .join('\n')
+
+  const logOnce =
+    config.pluginStatus || process.env.NODE_ENV === 'development'
+      ? `
+        const logged: Set<string> = new Set();
+        const logOnce = (log: string, ...additional: unknown[]) => {
+          if (logged.has(log)) return
+          logged.add(log)
+          console.warn(log, ...additional)
+        }
+        `
+      : ''
+
+  const template = `/* hash:${identifer} */
+    /* eslint-disable */
+    /* This file is automatically generated for ${dependency} */
+    ${
+      Object.values(targetExports).some((t) => t.some((p) => p.type === 'component'))
+        ? `import type { DistributedOmit } from 'type-fest'`
+        : ''
+    }
+
+    ${pluginImports}
+
+    ${SOURCE_START}
+    ${printSync(ast).code}
+    ${SOURCE_END}
+    ${logOnce}${pluginExports}
+  `
+
+  let templateFormatted
+  try {
+    templateFormatted = await prettier.format(template, { ...prettierConf, parser: 'typescript' })
+  } catch (e) {
+    console.log('Error formatting interceptor: ', e, 'using raw template.')
+    templateFormatted = template
+  }
+
+  return { ...interceptor, template: templateFormatted }
+}

package/src/interceptors/generateInterceptors.ts

@@ -1,255 +1,85 @@
 import path from 'node:path'
+import fs from 'node:fs/promises'
+// eslint-disable-next-line import/no-extraneous-dependencies
 import { GraphCommerceDebugConfig } from '../generated/config'
-import { ResolveDependency, ResolveDependencyReturn } from '../utils/resolveDependency'
-
-type PluginBaseConfig = {
-  exported: string
-  plugin: string
-  enabled: boolean
-  ifConfig?: string
-}
-export function isPluginBaseConfig(plugin: Partial<PluginBaseConfig>): plugin is PluginBaseConfig {
-  return (
-    typeof plugin.exported === 'string' &&
-    typeof plugin.plugin === 'string' &&
-    typeof plugin.enabled === 'boolean'
-  )
-}
-
-type ReactPluginConfig = PluginBaseConfig & { component: string }
-type MethodPluginConfig = PluginBaseConfig & { func: string }
-
-export function isReactPluginConfig(
-  plugin: Partial<PluginBaseConfig>,
-): plugin is ReactPluginConfig {
-  if (!isPluginBaseConfig(plugin)) return false
-  return (plugin as ReactPluginConfig).component !== undefined
-}
-
-export function isMethodPluginConfig(
-  plugin: Partial<PluginBaseConfig>,
-): plugin is MethodPluginConfig {
-  if (!isPluginBaseConfig(plugin)) return false
-  return (plugin as MethodPluginConfig).func !== undefined
-}
-
-export type PluginConfig = ReactPluginConfig | MethodPluginConfig
-export function isPluginConfig(plugin: Partial<PluginConfig>): plugin is PluginConfig {
-  return isReactPluginConfig(plugin) || isMethodPluginConfig(plugin)
-}
-
-type Interceptor = ResolveDependencyReturn & {
-  components: Record<string, ReactPluginConfig[]>
-  funcs: Record<string, MethodPluginConfig[]>
-  target: string
-  template?: string
-}
-
-export type MaterializedPlugin = Interceptor & { template: string }
-
-function moveRelativeDown(plugins: PluginConfig[]) {
-  return [...plugins].sort((a, b) => {
-    if (a.plugin.startsWith('.') && !b.plugin.startsWith('.')) return 1
-    if (!a.plugin.startsWith('.') && b.plugin.startsWith('.')) return -1
-    return 0
-  })
-}
-
-export function generateInterceptor(
-  interceptor: Interceptor,
-  config: GraphCommerceDebugConfig,
-): MaterializedPlugin {
-  const { fromModule, dependency, components, funcs } = interceptor
-
-  const pluginConfigs = [...Object.entries(components), ...Object.entries(funcs)]
-    .map(([, plugins]) => plugins)
-    .flat()
-
-  const duplicateImports = new Set()
-
-  const pluginImports = moveRelativeDown(
-    [...pluginConfigs].sort((a, b) => a.plugin.localeCompare(b.plugin)),
-  )
-    .map((plugin) => {
-      const { plugin: p } = plugin
-      if (isReactPluginConfig(plugin))
-        return `import { Plugin as ${p.split('/')[p.split('/').length - 1]} } from '${p}'`
-      return `import { plugin as ${p.split('/')[p.split('/').length - 1]} } from '${p}'`
-    })
-    .filter((str) => {
-      if (duplicateImports.has(str)) return false
-      duplicateImports.add(str)
-      return true
-    })
-    .join('\n')
-
-  const imports = [
-    ...Object.entries(components).map(([component]) => `${component} as ${component}Base`),
-    ...Object.entries(funcs).map(([func]) => `${func} as ${func}Base`),
-  ]
-
-  const importInjectables =
-    imports.length > 1
-      ? `import { 
-  ${imports.join(',\n  ')},
-} from '${fromModule}'`
-      : `import { ${imports[0]} } from '${fromModule}'`
-
-  const entries: [string, PluginConfig[]][] = [
-    ...Object.entries(components),
-    ...Object.entries(funcs),
-  ]
-  const pluginExports = entries
-    .map(([base, plugins]) => {
-      const duplicateInterceptors = new Set()
-      const name = (p: PluginConfig) => p.plugin.split('/')[p.plugin.split('/').length - 1]
-
-      const filterNoDuplicate = (p: PluginConfig) => {
-        if (duplicateInterceptors.has(name(p))) return false
-        duplicateInterceptors.add(name(p))
-        return true
-      }
-
-      let carry = `${base}Base`
-
-      const pluginStr = plugins
-        .reverse()
-        .filter(filterNoDuplicate)
-        .map((p) => {
-          let result
-
-          if (isReactPluginConfig(p)) {
-            const wrapChain = plugins
-              .reverse()
-              .map((pl) => `<${name(pl)}/>`)
-              .join(' wrapping ')
-            const debugLog =
-              carry === `${base}Base` && config.pluginStatus
-                ? `\n  logInterceptor(\`🔌 Rendering ${base} with plugin(s): ${wrapChain} wrapping <${base}/>\`)`
-                : ''
-
-            result = `function ${name(p)}Interceptor(props: ${base}Props) {${debugLog}
-  return <${name(p)} {...props} Prev={${carry}} />
-}`
-          } else {
-            const wrapChain = plugins
-              .reverse()
-              .map((pl) => `${name(pl)}()`)
-              .join(' wrapping ')
-
-            const debugLog =
-              carry === `${base}Base` && config.pluginStatus
-                ? `\n  logInterceptor(\`🔌 Calling ${base} with plugin(s): ${wrapChain} wrapping ${base}()\`)`
-                : ''
-
-            result = `const ${name(p)}Interceptor: typeof ${base}Base = (...args) => {${debugLog}
-  return ${name(p)}(${carry}, ...args)
-}`
-          }
-          carry = `${name(p)}Interceptor`
-          return result
-        })
-        .join('\n')
-
-      const isComponent = plugins.every((p) => isReactPluginConfig(p))
-      if (isComponent && plugins.some((p) => isMethodPluginConfig(p))) {
-        throw new Error(`Cannot mix React and Method plugins for ${base} in ${dependency}.`)
-      }
-
-      return `
-/**
- * Interceptor for \`${isComponent ? `<${base}/>` : `${base}()`}\` with these plugins:
- * 
-${plugins.map((p) => ` * - \`${p.plugin}\``).join('\n')}
- */
-${isComponent ? `type ${base}Props = ComponentProps<typeof ${base}Base>\n\n` : ``}${pluginStr}
-export const ${base} = ${carry}`
-    })
-    .join('\n')
-
-  const logOnce = config.pluginStatus
-    ? `
-const logged: Set<string> = new Set();
-const logInterceptor = (log: string, ...additional: unknown[]) => {
-  if (logged.has(log)) return
-  logged.add(log)
-  console.log(log, ...additional)
-}
-`
-    : ''
-
-  const componentExports = `export * from '${fromModule}'`
-
-  const template = `/* This file is automatically generated for ${dependency} */
-
-${componentExports}
-${pluginImports}
-import { ComponentProps } from 'react'
-${importInjectables}
-${logOnce}${pluginExports}
-`
-
-  return { ...interceptor, template }
-}
+import { ResolveDependency } from '../utils/resolveDependency'
+import { findOriginalSource } from './findOriginalSource'
+import {
+  Interceptor,
+  MaterializedPlugin,
+  PluginConfig,
+  generateInterceptor,
+  isPluginConfig,
+  moveRelativeDown,
+} from './generateInterceptor'
 
 export type GenerateInterceptorsReturn = Record<string, MaterializedPlugin>
 
-export function generateInterceptors(
+export async function generateInterceptors(
   plugins: PluginConfig[],
   resolve: ResolveDependency,
   config?: GraphCommerceDebugConfig | null | undefined,
-): GenerateInterceptorsReturn {
-  // todo: Do not use reduce as we're passing the accumulator to the next iteration
-  const byExportedComponent = moveRelativeDown(plugins).reduce((acc, plug) => {
-    const { exported, plugin } = plug
-    if (!isPluginConfig(plug) || !plug.enabled) return acc
-
-    const resolved = resolve(exported)
+): Promise<GenerateInterceptorsReturn> {
+  const byTargetModuleAndExport = moveRelativeDown(plugins).reduce<Record<string, Interceptor>>(
+    (acc, plug) => {
+      let { sourceModule: pluginPath } = plug
+      if (!isPluginConfig(plug) || !plug.enabled) return acc
+
+      const result = resolve(plug.targetModule, { includeSources: true })
+      const { error, resolved } = findOriginalSource(plug, result, resolve)
+
+      if (error) {
+        console.log(error.message)
+        return acc
+      }
 
-    let pluginPathFromResolved = plugin
-    if (plugin.startsWith('.')) {
-      const resolvedPlugin = resolve(plugin)
-      pluginPathFromResolved = path.relative(
-        resolved.fromRoot.split('/').slice(0, -1).join('/'),
-        resolvedPlugin.fromRoot,
-      )
-    }
+      const { fromRoot } = resolved
 
-    if (!acc[resolved.fromRoot])
-      acc[resolved.fromRoot] = {
-        ...resolved,
-        target: `${resolved.fromRoot}.interceptor`,
-        components: {},
-        funcs: {},
-      } as Interceptor
+      if (pluginPath.startsWith('.')) {
+        const resolvedPlugin = resolve(pluginPath)
+        if (resolvedPlugin) {
+          pluginPath = path.relative(
+            resolved.fromRoot.split('/').slice(0, -1).join('/'),
+            resolvedPlugin.fromRoot,
+          )
+        }
+      }
 
-    if (isReactPluginConfig(plug)) {
-      const { component } = plug
-      if (!acc[resolved.fromRoot].components[component])
-        acc[resolved.fromRoot].components[component] = []
+      if (!acc[resolved.fromRoot]) {
+        acc[resolved.fromRoot] = {
+          ...resolved,
+          target: `${resolved.fromRoot}.interceptor`,
+          targetExports: {},
+        } as Interceptor
+      }
 
-      acc[resolved.fromRoot].components[component].push({
-        ...plug,
-        plugin: pluginPathFromResolved,
-      })
-    }
-    if (isMethodPluginConfig(plug)) {
-      const { func } = plug
-      if (!acc[resolved.fromRoot].funcs[func]) acc[resolved.fromRoot].funcs[func] = []
+      if (!acc[fromRoot].targetExports[plug.targetExport])
+        acc[fromRoot].targetExports[plug.targetExport] = []
 
-      acc[resolved.fromRoot].funcs[func].push({
-        ...plug,
-        plugin: pluginPathFromResolved,
-      })
-    }
+      acc[fromRoot].targetExports[plug.targetExport].push({ ...plug, sourceModule: pluginPath })
 
-    return acc
-  }, {} as Record<string, Interceptor>)
+      return acc
+    },
+    {},
+  )
 
   return Object.fromEntries(
-    Object.entries(byExportedComponent).map(([target, interceptor]) => [
-      target,
-      generateInterceptor(interceptor, config ?? {}),
-    ]),
+    await Promise.all(
+      Object.entries(byTargetModuleAndExport).map(async ([target, interceptor]) => {
+        const file = `${interceptor.fromRoot}.interceptor.tsx`
+
+        const originalSource = (await fs
+          .access(file, fs.constants.F_OK)
+          .then(() => true)
+          .catch(() => false))
+          ? (await fs.readFile(file)).toString()
+          : undefined
+
+        return [
+          target,
+          await generateInterceptor(interceptor, config ?? {}, originalSource),
+        ] as const
+      }),
+    ),
   )
 }

package/src/interceptors/parseStructure.ts

@@ -0,0 +1,82 @@
+import { Module } from '@swc/core'
+import get from 'lodash/get'
+import { z } from 'zod'
+import { GraphCommerceConfig } from '../generated/config'
+import { extractExports } from './extractExports'
+import { PluginConfig } from './generateInterceptor'
+
+const pluginConfigParsed = z.object({
+  type: z.enum(['component', 'function', 'replace']),
+  module: z.string(),
+  export: z.string(),
+  ifConfig: z.union([z.string(), z.tuple([z.string(), z.string()])]).optional(),
+})
+
+function nonNullable<T>(value: T): value is NonNullable<T> {
+  return value !== null && value !== undefined
+}
+const isObject = (input: unknown): input is Record<string, unknown> =>
+  typeof input === 'object' && input !== null && !Array.isArray(input)
+
+export function parseStructure(ast: Module, gcConfig: GraphCommerceConfig, sourceModule: string) {
+  const [exports, errors] = extractExports(ast)
+  if (errors.length) console.error(`Plugin error for`, errors.join('\n'))
+
+  const {
+    config: moduleConfig,
+    component,
+    func,
+    exported,
+    ifConfig,
+    plugin,
+    Plugin,
+    ...rest
+  } = exports
+
+  const exportVals = Object.keys(rest)
+  if (component && !moduleConfig) exportVals.push('Plugin')
+  if (func && !moduleConfig) exportVals.push('plugin')
+
+  return exportVals
+    .map((exportVal) => {
+      let config = isObject(moduleConfig) ? moduleConfig : {}
+
+      if (!moduleConfig && component) {
+        config = { type: 'component', module: exported, ifConfig, export: 'Plugin' }
+      } else if (!moduleConfig && func) {
+        config = { type: 'function', module: exported, ifConfig, export: 'plugin' }
+      } else if (isObject(moduleConfig)) {
+        config = { ...moduleConfig, export: exportVal }
+      } else {
+        console.error(`Plugin configuration invalid! See ${sourceModule}`)
+      }
+
+      const parsed = pluginConfigParsed.safeParse(config)
+
+      if (!parsed.success) {
+        if (errors.length)
+          console.error(parsed.error.errors.map((e) => `${e.path} ${e.message}`).join('\n'))
+        return undefined
+      }
+
+      let enabled = true
+      if (parsed.data.ifConfig) {
+        enabled = Array.isArray(parsed.data.ifConfig)
+          ? get(gcConfig, parsed.data.ifConfig[0]) === parsed.data.ifConfig[1]
+          : Boolean(get(gcConfig, parsed.data.ifConfig))
+      }
+
+      const val: PluginConfig = {
+        targetExport:
+          (exports.component as string) || (exports.func as string) || parsed.data.export,
+        sourceModule,
+        sourceExport: parsed.data.export,
+        targetModule: parsed.data.module,
+        type: parsed.data.type,
+        enabled,
+      }
+      if (parsed.data.ifConfig) val.ifConfig = parsed.data.ifConfig
+      return val
+    })
+    .filter(nonNullable)
+}

package/src/interceptors/swc.ts

@@ -0,0 +1,13 @@
+import { Output, Program, parseSync as parseSyncCore, printSync as printSyncCode } from '@swc/core'
+
+export function parseSync(src: string) {
+  return parseSyncCore(src, {
+    syntax: 'typescript',
+    tsx: true,
+    comments: true,
+  })
+}
+
+export function printSync(m: Program): Output {
+  return printSyncCode(m)
+}