@wix/zero-config-implementation 1.78.0 → 1.80.0

package/src/ref-elements/context.ts

@@ -1,280 +0,0 @@
-import ts from 'typescript'
-import type { ComponentInfo } from '../information-extractors/ts/types'
-import { extractEligibleRefElementPaths } from './eligible-paths'
-import { resolveModuleUrlFromEntryPath } from './module-resolution'
-import { extractBasePackageName, extractModuleLeafExportName } from './module-specifier'
-import type { RefElementContext, RefElementModule } from './types'
-
-interface RawRefElementExtensionEntry {
-  options?: {
-    type?: string
-    resources?: {
-      client?: {
-        moduleSpecifier?: string
-      }
-    }
-  }
-  type?: string
-  resources?: {
-    client?: {
-      moduleSpecifier?: string
-    }
-  }
-}
-
-interface NormalizedRefElementCatalogEntry {
-  moduleSpecifier: string
-  refComponentType: string
-}
-
-export async function buildRefElementContext(
-  program: ts.Program,
-  sourceFilePath: string,
-  componentInfo: ComponentInfo,
-  compiledEntryPath: string,
-): Promise<RefElementContext> {
-  const importedModuleSpecifiers = collectImportedRefElementModuleSpecifiers(program, sourceFilePath)
-
-  return {
-    eligiblePaths: extractEligibleRefElementPaths(componentInfo),
-    runtimeModules: await resolveRuntimeModules(importedModuleSpecifiers, compiledEntryPath),
-  }
-}
-
-async function resolveRuntimeModules(
-  importedModuleSpecifiers: string[],
-  compiledEntryPath: string,
-): Promise<RefElementModule[]> {
-  if (importedModuleSpecifiers.length === 0) {
-    return []
-  }
-
-  const importedModuleSpecifierSet = new Set(importedModuleSpecifiers)
-  const importedPackageNames = [
-    ...new Set(importedModuleSpecifiers.filter(isPackageModuleSpecifier).map(extractBasePackageName)),
-  ]
-  const catalogEntries = (
-    await Promise.all(importedPackageNames.map((packageName) => loadCatalogEntries(packageName, compiledEntryPath)))
-  ).flat()
-
-  const runtimeModulesBySpecifier = new Map<string, Set<string>>()
-
-  for (const catalogEntry of catalogEntries) {
-    if (!importedModuleSpecifierSet.has(catalogEntry.moduleSpecifier)) {
-      continue
-    }
-
-    const refComponentTypes = runtimeModulesBySpecifier.get(catalogEntry.moduleSpecifier) ?? new Set<string>()
-    refComponentTypes.add(catalogEntry.refComponentType)
-    runtimeModulesBySpecifier.set(catalogEntry.moduleSpecifier, refComponentTypes)
-  }
-
-  const runtimeModules: RefElementModule[] = []
-
-  for (const [moduleSpecifier, refComponentTypes] of runtimeModulesBySpecifier.entries()) {
-    if (refComponentTypes.size !== 1) {
-      continue
-    }
-
-    const refComponentType = [...refComponentTypes][0]
-    if (!refComponentType) {
-      continue
-    }
-
-    const resolvedModuleUrl = resolveModuleUrlFromEntryPath(compiledEntryPath, moduleSpecifier)
-    if (!resolvedModuleUrl) {
-      continue
-    }
-
-    runtimeModules.push({
-      exportNames: buildRefElementExportNames(moduleSpecifier),
-      moduleSpecifier,
-      resolvedModuleUrl,
-      refComponentType,
-    })
-  }
-
-  return runtimeModules
-}
-
-function isPackageModuleSpecifier(moduleSpecifier: string): boolean {
-  return !moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('/') && !moduleSpecifier.startsWith('file:')
-}
-
-function collectImportedRefElementModuleSpecifiers(program: ts.Program, sourceFilePath: string): string[] {
-  const entrySourceFile = findSourceFile(program, sourceFilePath)
-  if (!entrySourceFile) {
-    return []
-  }
-
-  const importedModuleSpecifiers = new Set<string>()
-  const visitedSourceFiles = new Set<string>()
-
-  function visitSourceFile(sourceFile: ts.SourceFile): void {
-    if (visitedSourceFiles.has(sourceFile.fileName)) {
-      return
-    }
-
-    visitedSourceFiles.add(sourceFile.fileName)
-
-    for (const statement of sourceFile.statements) {
-      const moduleSpecifier = readReferencedModuleSpecifier(statement)
-      if (!moduleSpecifier) {
-        continue
-      }
-
-      if (referencesRefElementModule(statement, moduleSpecifier)) {
-        importedModuleSpecifiers.add(moduleSpecifier)
-      }
-
-      const importedSourceFile = resolveImportedSourceFile(program, sourceFile.fileName, moduleSpecifier)
-      if (importedSourceFile) {
-        visitSourceFile(importedSourceFile)
-      }
-    }
-  }
-
-  visitSourceFile(entrySourceFile)
-  return [...importedModuleSpecifiers]
-}
-
-async function loadCatalogEntries(
-  packageName: string,
-  compiledEntryPath: string,
-): Promise<NormalizedRefElementCatalogEntry[]> {
-  const resolvedExtensionsUrl = resolveModuleUrlFromEntryPath(compiledEntryPath, `${packageName}/extensions`)
-  if (!resolvedExtensionsUrl) {
-    return []
-  }
-
-  const extensionModule = (await import(resolvedExtensionsUrl)) as Record<string, unknown>
-
-  return extractRawExtensionEntries(extensionModule)
-    .map(normalizeExtensionEntry)
-    .flatMap((catalogEntry) => (catalogEntry ? [catalogEntry] : []))
-}
-
-function referencesRefElementModule(statement: ts.Statement, moduleSpecifier: string): boolean {
-  const moduleLeafExportName = extractModuleLeafExportName(moduleSpecifier)
-  if (!moduleLeafExportName) {
-    return false
-  }
-
-  if (ts.isImportDeclaration(statement)) {
-    return importsRefElementModule(statement, moduleLeafExportName)
-  }
-
-  if (ts.isExportDeclaration(statement)) {
-    return reExportsRefElementModule(statement, moduleLeafExportName)
-  }
-
-  return false
-}
-
-function importsRefElementModule(importDeclaration: ts.ImportDeclaration, moduleLeafExportName: string): boolean {
-  const importClause = importDeclaration.importClause
-  if (!importClause) {
-    return false
-  }
-
-  if (importClause.name) {
-    return true
-  }
-
-  if (!importClause.namedBindings || !ts.isNamedImports(importClause.namedBindings)) {
-    return false
-  }
-
-  return importClause.namedBindings.elements.some((importSpecifier) => {
-    const importedName = importSpecifier.propertyName?.text ?? importSpecifier.name.text
-    return importedName === moduleLeafExportName
-  })
-}
-
-function reExportsRefElementModule(exportDeclaration: ts.ExportDeclaration, moduleLeafExportName: string): boolean {
-  if (!exportDeclaration.exportClause || !ts.isNamedExports(exportDeclaration.exportClause)) {
-    return false
-  }
-
-  return exportDeclaration.exportClause.elements.some((exportSpecifier) => {
-    const exportedSourceName = exportSpecifier.propertyName?.text ?? exportSpecifier.name.text
-    return exportedSourceName === 'default' || exportedSourceName === moduleLeafExportName
-  })
-}
-
-function extractRawExtensionEntries(extensionModule: Record<string, unknown>): RawRefElementExtensionEntry[] {
-  const defaultExport = extensionModule.default
-  const extensionEntries = Array.isArray(defaultExport)
-    ? defaultExport
-    : ((defaultExport as { extensions?: unknown[] } | undefined)?.extensions ?? extensionModule.extensions)
-
-  return Array.isArray(extensionEntries) ? (extensionEntries as RawRefElementExtensionEntry[]) : []
-}
-
-function normalizeExtensionEntry(rawEntry: RawRefElementExtensionEntry): NormalizedRefElementCatalogEntry | undefined {
-  const normalizedEntry = rawEntry.options ?? rawEntry
-  const moduleSpecifier = normalizedEntry.resources?.client?.moduleSpecifier
-  const refComponentType = normalizedEntry.type
-
-  if (!moduleSpecifier || !refComponentType) {
-    return undefined
-  }
-
-  return {
-    moduleSpecifier,
-    refComponentType,
-  }
-}
-
-function buildRefElementExportNames(moduleSpecifier: string): string[] {
-  const exportNames = new Set<string>(['default'])
-  if (extractBasePackageName(moduleSpecifier) === moduleSpecifier) {
-    return [...exportNames]
-  }
-
-  const moduleLeafName = extractModuleLeafExportName(moduleSpecifier)
-  if (moduleLeafName) {
-    exportNames.add(moduleLeafName)
-  }
-
-  return [...exportNames]
-}
-
-function findSourceFile(program: ts.Program, sourceFilePath: string): ts.SourceFile | undefined {
-  return (
-    program.getSourceFile(sourceFilePath) ??
-    program.getSourceFiles().find((sourceFile) => sourceFile.fileName === sourceFilePath)
-  )
-}
-
-function resolveImportedSourceFile(
-  program: ts.Program,
-  importingFilePath: string,
-  moduleSpecifier: string,
-): ts.SourceFile | undefined {
-  const resolvedModule = ts.resolveModuleName(moduleSpecifier, importingFilePath, program.getCompilerOptions(), ts.sys)
-  const resolvedFileName = resolvedModule.resolvedModule?.resolvedFileName
-
-  if (!resolvedFileName) {
-    return undefined
-  }
-
-  const resolvedSourceFile = findSourceFile(program, resolvedFileName)
-  if (!resolvedSourceFile || resolvedSourceFile.isDeclarationFile) {
-    return undefined
-  }
-
-  return resolvedSourceFile
-}
-
-function readReferencedModuleSpecifier(statement: ts.Statement): string | undefined {
-  if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
-    return statement.moduleSpecifier.text
-  }
-
-  if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
-    return statement.moduleSpecifier.text
-  }
-
-  return undefined
-}