@ontrails/adapter-kit 1.0.0-beta.39 → 1.0.0-beta.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ontrails/adapter-kit",
-  "version": "1.0.0-beta.39",
+  "version": "1.0.0-beta.42",
   "description": "Internal adapter authoring kit for Trails metadata, scaffolding, and checks.",
   "files": [
     "src/**/*.ts",
@@ -21,7 +21,8 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "dependencies": {
-    "@ontrails/core": "^1.0.0-beta.39"
+    "@ontrails/core": "^1.0.0-beta.42",
+    "@ontrails/source": "^1.0.0-beta.42"
   },
   "peerDependencies": {
     "zod": "^4.3.5"

package/src/catalog.ts

@@ -6,11 +6,17 @@
  * internal tooling package.
  */
 
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 
 import { listWorkspacePackages } from '@ontrails/core';
 
+import {
+  adapterSourceExportKind,
+  adapterSourceExportKindHasType,
+  adapterSourceExportKindHasValue,
+} from './source.js';
+
 export const adapterTargetPlacements = ['extracted', 'subpath'] as const;
 
 export type AdapterTargetPlacementValue =
@@ -85,47 +91,12 @@ interface ParsedCatalogTarget {
   readonly targetEntry?: AdapterTargetCatalogEntry | undefined;
 }
 
-type ExportKind = 'type' | 'type-value' | 'value';
-
-interface StarExportSpecifier {
-  readonly specifier: string;
-  readonly typeOnly: boolean;
-}
-
-interface NamedExportSpecifier {
-  readonly identifier: string;
-  readonly specifier: string;
-  readonly typeOnly: boolean;
-}
-
-interface NamedImportSpecifier {
-  readonly identifier: string;
-  readonly specifier: string;
-  readonly typeOnly: boolean;
-}
-
-interface ExportListSpecifier {
-  readonly exported: string;
-  readonly local: string;
-  readonly typeOnly: boolean;
-}
-
-type ImportKindResolver = (
-  importSpecifier: NamedImportSpecifier
-) => ExportKind | undefined;
-
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   Boolean(value && typeof value === 'object' && !Array.isArray(value));
 
 const targetIdPattern = /^[a-z][a-z0-9-]*$/u;
 const exportIdentifierPattern = /^[A-Za-z_$][\w$]*$/u;
 
-const exportKindHasType = (kind: ExportKind | undefined): boolean =>
-  kind === 'type' || kind === 'type-value';
-
-const exportKindHasValue = (kind: ExportKind | undefined): boolean =>
-  kind === 'value' || kind === 'type-value';
-
 const normalizePath = (path: string): string => path.replaceAll('\\', '/');
 
 const normalizeRealPath = (path: string): string => {
@@ -144,264 +115,6 @@ const pathIsFile = (path: string): boolean => {
   }
 };
 
-const localDeclarationKind = (
-  code: string,
-  identifier: string,
-  exportedOnly = false
-): ExportKind | undefined => {
-  const escapedIdentifier = identifier.replaceAll(
-    /[.*+?^${}()|[\]\\]/gu,
-    '\\$&'
-  );
-  const exportPrefix = exportedOnly ? '\\bexport\\s+' : '\\b(?:export\\s+)?';
-  const valueDeclarationPattern = new RegExp(
-    `${exportPrefix}(?!declare\\s+)(?:(?:async\\s+)?function|const|let|var)\\s+${escapedIdentifier}\\b`,
-    'u'
-  );
-  if (valueDeclarationPattern.test(code)) {
-    return 'value';
-  }
-
-  const typeValueDeclarationPattern = new RegExp(
-    `${exportPrefix}(?!declare\\s+)(?:abstract\\s+)?(?:class|enum)\\s+${escapedIdentifier}\\b`,
-    'u'
-  );
-  if (typeValueDeclarationPattern.test(code)) {
-    return 'type-value';
-  }
-
-  const typeDeclarationPattern = new RegExp(
-    `${exportPrefix}(?:declare\\s+)?(?:interface|type)\\s+${escapedIdentifier}\\b`,
-    'u'
-  );
-  return typeDeclarationPattern.test(code) ? 'type' : undefined;
-};
-
-const maskDeadSourceText = (
-  source: string,
-  options: { strings: boolean }
-): string => {
-  const output = [...source];
-  let index = 0;
-
-  const maskRange = (start: number, end: number): void => {
-    for (let cursor = start; cursor < end; cursor += 1) {
-      if (output[cursor] !== '\n') {
-        output[cursor] = ' ';
-      }
-    }
-  };
-
-  const skipQuoted = (quote: '"' | "'" | '`'): void => {
-    const start = index;
-    index += 1;
-    while (index < source.length) {
-      if (source[index] === '\\') {
-        index += 2;
-        continue;
-      }
-      if (source[index] === quote) {
-        index += 1;
-        break;
-      }
-      index += 1;
-    }
-    if (options.strings) {
-      maskRange(start, index);
-    }
-  };
-
-  while (index < source.length) {
-    if (source.startsWith('//', index)) {
-      const end = source.indexOf('\n', index + 2);
-      const stop = end === -1 ? source.length : end;
-      maskRange(index, stop);
-      index = stop;
-      continue;
-    }
-    if (source.startsWith('/*', index)) {
-      const end = source.indexOf('*/', index + 2);
-      const stop = end === -1 ? source.length : end + 2;
-      maskRange(index, stop);
-      index = stop;
-      continue;
-    }
-    const char = source[index];
-    if (char === '"' || char === "'" || char === '`') {
-      skipQuoted(char);
-      continue;
-    }
-    index += 1;
-  }
-
-  return output.join('');
-};
-
-const defaultExportKind = (source: string): ExportKind | undefined => {
-  const code = maskDeadSourceText(source, { strings: true });
-  if (/\bexport\s+default\s+(?:async\s+)?function\*?\b/u.test(code)) {
-    return 'value';
-  }
-  if (/\bexport\s+default\s+(?:abstract\s+)?(?:class|enum)\b/u.test(code)) {
-    return 'type-value';
-  }
-  if (/\bexport\s+default\s+(?:interface|type)\b/u.test(code)) {
-    return 'type';
-  }
-
-  const expressionIdentifier =
-    /\bexport\s+default\s+(?<identifier>[A-Za-z_$][\w$]*)\b/u.exec(code)
-      ?.groups?.['identifier'];
-  if (expressionIdentifier) {
-    return localDeclarationKind(code, expressionIdentifier) ?? 'value';
-  }
-
-  return /\bexport\s+default\b/u.test(code) ? 'value' : undefined;
-};
-
-const localDefaultImportSpecifier = (
-  code: string,
-  stringsMaskedCode: string,
-  identifier: string
-): NamedImportSpecifier | undefined => {
-  const pattern =
-    /\bimport\s+(?<importTypeOnly>type\s+)?(?<local>[A-Za-z_$][\w$]*)(?:\s*,\s*(?:\{[\s\S]*?\}|\*\s+as\s+[A-Za-z_$][\w$]*))?\s+from\s+['"](?<specifier>[^'"]+)['"]/gu;
-
-  for (const match of code.matchAll(pattern)) {
-    if (!stringsMaskedCode.startsWith('import', match.index ?? 0)) {
-      continue;
-    }
-    if (match.groups?.['local'] !== identifier) {
-      continue;
-    }
-
-    return {
-      identifier: 'default',
-      specifier: match.groups?.['specifier'] ?? '',
-      typeOnly: Boolean(match.groups?.['importTypeOnly']),
-    };
-  }
-
-  return undefined;
-};
-
-const parseNamedImportSpecifier = (
-  item: string,
-  declarationTypeOnly: boolean,
-  specifier: string,
-  identifier: string
-): NamedImportSpecifier | undefined => {
-  const trimmedItem = item.trim();
-  if (!trimmedItem) {
-    return undefined;
-  }
-
-  const itemTypeOnly = declarationTypeOnly || trimmedItem.startsWith('type ');
-  const specifierText = trimmedItem.replace(/^type\s+/u, '');
-  const imported =
-    /^(?<imported>[A-Za-z_$][\w$]*)(?:\s+as\s+(?<local>[A-Za-z_$][\w$]*))?$/u.exec(
-      specifierText
-    )?.groups;
-  const local = imported?.['local'] ?? imported?.['imported'];
-  const importedName = imported?.['imported'];
-  if (local !== identifier || !importedName) {
-    return undefined;
-  }
-
-  return {
-    identifier: importedName,
-    specifier,
-    typeOnly: itemTypeOnly,
-  };
-};
-
-const localNamedImportSpecifier = (
-  source: string,
-  identifier: string
-): NamedImportSpecifier | undefined => {
-  const code = maskDeadSourceText(source, { strings: false });
-  const stringsMaskedCode = maskDeadSourceText(source, { strings: true });
-  const defaultSpecifier = localDefaultImportSpecifier(
-    code,
-    stringsMaskedCode,
-    identifier
-  );
-  if (defaultSpecifier) {
-    return defaultSpecifier;
-  }
-
-  const pattern =
-    /\bimport\s+(?<importTypeOnly>type\s+)?\{(?<imports>[\s\S]*?)\}\s+from\s+['"](?<specifier>[^'"]+)['"]/gu;
-
-  for (const match of code.matchAll(pattern)) {
-    if (!stringsMaskedCode.startsWith('import', match.index ?? 0)) {
-      continue;
-    }
-
-    const declarationTypeOnly = Boolean(match.groups?.['importTypeOnly']);
-    const namedImports = match.groups?.['imports'] ?? '';
-    const specifier = match.groups?.['specifier'] ?? '';
-    for (const item of namedImports.split(',')) {
-      const namedSpecifier = parseNamedImportSpecifier(
-        item,
-        declarationTypeOnly,
-        specifier,
-        identifier
-      );
-      if (namedSpecifier) {
-        return namedSpecifier;
-      }
-    }
-  }
-
-  return undefined;
-};
-
-const parseExportListSpecifier = (
-  item: string,
-  declarationTypeOnly: boolean
-): ExportListSpecifier | undefined => {
-  const trimmedItem = item.trim();
-  if (!trimmedItem) {
-    return undefined;
-  }
-
-  const typeOnly = declarationTypeOnly || trimmedItem.startsWith('type ');
-  const specifierText = trimmedItem.replace(/^type\s+/u, '');
-  const exported =
-    /^(?<local>[A-Za-z_$][\w$]*)(?:\s+as\s+(?<name>[A-Za-z_$][\w$]*))?$/u.exec(
-      specifierText
-    )?.groups;
-  const local = exported?.['local'];
-  if (!local) {
-    return undefined;
-  }
-
-  return {
-    exported: exported?.['name'] ?? local,
-    local,
-    typeOnly,
-  };
-};
-
-const exportedLocalBindingKind = (
-  source: string,
-  code: string,
-  local: string,
-  resolveImportKind: ImportKindResolver
-): ExportKind | undefined => {
-  const localKind = localDeclarationKind(code, local);
-  if (localKind) {
-    return localKind;
-  }
-
-  const importSpecifier = localNamedImportSpecifier(source, local);
-  if (importSpecifier?.typeOnly) {
-    return 'type';
-  }
-  return importSpecifier ? resolveImportKind(importSpecifier) : undefined;
-};
-
 const exportConditions = new Set([
   'bun',
   'node',
@@ -870,228 +583,6 @@ const normalizeConformance = (
   };
 };
 
-const namedExportKind = (
-  source: string,
-  identifier: string,
-  resolveImportKind: ImportKindResolver
-): ExportKind | undefined => {
-  if (identifier === 'default') {
-    const defaultKind = defaultExportKind(source);
-    if (defaultKind) {
-      return defaultKind;
-    }
-  }
-
-  const code = maskDeadSourceText(source, { strings: true });
-  const directKind = localDeclarationKind(code, identifier, true);
-  if (directKind) {
-    return directKind;
-  }
-
-  const exportListPattern =
-    /\bexport\s+(?<typeOnly>type\s+)?\{(?<exports>[\s\S]*?)\}(?!\s+from\b)/gu;
-
-  for (const match of code.matchAll(exportListPattern)) {
-    const declarationTypeOnly = Boolean(match.groups?.['typeOnly']);
-    const namedExports = match.groups?.['exports'] ?? '';
-    for (const item of namedExports.split(',')) {
-      const exported = parseExportListSpecifier(item, declarationTypeOnly);
-      if (exported?.exported !== identifier) {
-        continue;
-      }
-
-      const localKind = exportedLocalBindingKind(
-        source,
-        code,
-        exported.local,
-        resolveImportKind
-      );
-      if (!localKind) {
-        return undefined;
-      }
-      return exported.typeOnly ? 'type' : localKind;
-    }
-  }
-
-  return undefined;
-};
-
-const starExportSpecifiers = (
-  source: string
-): readonly StarExportSpecifier[] => {
-  const code = maskDeadSourceText(source, { strings: false });
-  const stringsMaskedCode = maskDeadSourceText(source, { strings: true });
-  return [
-    ...code.matchAll(
-      /\bexport\s+(?<typeOnly>type\s+)?\*\s+from\s+['"](?<specifier>[^'"]+)['"]/gu
-    ),
-  ]
-    .filter((match) => stringsMaskedCode.startsWith('export', match.index ?? 0))
-    .map((match) => ({
-      specifier: match.groups?.['specifier'] ?? '',
-      typeOnly: Boolean(match.groups?.['typeOnly']),
-    }));
-};
-
-const namedExportSpecifiers = (
-  source: string,
-  identifier: string
-): readonly NamedExportSpecifier[] => {
-  const code = maskDeadSourceText(source, { strings: false });
-  const stringsMaskedCode = maskDeadSourceText(source, { strings: true });
-  const exports: NamedExportSpecifier[] = [];
-  const pattern =
-    /\bexport\s+(?<typeOnly>type\s+)?\{(?<exports>[\s\S]*?)\}\s+from\s+['"](?<specifier>[^'"]+)['"]/gu;
-
-  for (const match of code.matchAll(pattern)) {
-    if (!stringsMaskedCode.startsWith('export', match.index ?? 0)) {
-      continue;
-    }
-
-    const specifier = match.groups?.['specifier'];
-    if (!specifier?.startsWith('.')) {
-      continue;
-    }
-
-    const declarationTypeOnly = Boolean(match.groups?.['typeOnly']);
-    const namedExports = match.groups?.['exports'] ?? '';
-    for (const item of namedExports.split(',')) {
-      const trimmedItem = item.trim();
-      if (!trimmedItem) {
-        continue;
-      }
-
-      const itemTypeOnly =
-        declarationTypeOnly || trimmedItem.startsWith('type ');
-      const specifierText = trimmedItem.replace(/^type\s+/u, '');
-      const exported =
-        /^(?<local>[A-Za-z_$][\w$]*)(?:\s+as\s+(?<name>[A-Za-z_$][\w$]*))?$/u.exec(
-          specifierText
-        )?.groups;
-      const local = exported?.['local'];
-      if (!local || (exported?.['name'] ?? local) !== identifier) {
-        continue;
-      }
-
-      exports.push({
-        identifier: local,
-        specifier,
-        typeOnly: itemTypeOnly,
-      });
-    }
-  }
-
-  return exports;
-};
-
-const resolveLocalModuleSpecifier = (
-  sourcePath: string,
-  specifier: string
-): string | undefined => {
-  if (!specifier.startsWith('.')) {
-    return undefined;
-  }
-
-  const basePath = resolve(dirname(sourcePath), specifier);
-  const candidates = [
-    basePath,
-    basePath.endsWith('.js') ? `${basePath.slice(0, -3)}.ts` : undefined,
-    basePath.endsWith('.js') ? `${basePath.slice(0, -3)}.tsx` : undefined,
-    basePath.endsWith('.mjs') ? `${basePath.slice(0, -4)}.mts` : undefined,
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    join(basePath, 'index.ts'),
-    join(basePath, 'index.tsx'),
-  ].filter((candidate): candidate is string => candidate !== undefined);
-
-  return candidates.find((candidate) => existsSync(candidate));
-};
-
-const namedExportKindFromFile = (
-  sourcePath: string,
-  identifier: string,
-  visited = new Set<string>()
-): ExportKind | undefined => {
-  const normalizedSourcePath = normalizeRealPath(sourcePath);
-  const visitKey = `${normalizedSourcePath}:${identifier}`;
-  if (visited.has(visitKey)) {
-    return undefined;
-  }
-  visited.add(visitKey);
-
-  let source: string;
-  try {
-    source = readFileSync(normalizedSourcePath, 'utf8');
-  } catch {
-    return undefined;
-  }
-
-  const directKind = namedExportKind(source, identifier, (importSpecifier) => {
-    const importTarget = resolveLocalModuleSpecifier(
-      normalizedSourcePath,
-      importSpecifier.specifier
-    );
-    if (!importTarget) {
-      return;
-    }
-    return namedExportKindFromFile(
-      importTarget,
-      importSpecifier.identifier,
-      new Set(visited)
-    );
-  });
-  if (directKind) {
-    return directKind;
-  }
-
-  let sawTypeExport = false;
-  for (const exportSpecifier of namedExportSpecifiers(source, identifier)) {
-    const exportTarget = resolveLocalModuleSpecifier(
-      normalizedSourcePath,
-      exportSpecifier.specifier
-    );
-    if (!exportTarget) {
-      continue;
-    }
-
-    const reexportedKind = namedExportKindFromFile(
-      exportTarget,
-      exportSpecifier.identifier,
-      new Set(visited)
-    );
-    if (exportKindHasValue(reexportedKind) && !exportSpecifier.typeOnly) {
-      return reexportedKind;
-    }
-    if (exportKindHasType(reexportedKind)) {
-      sawTypeExport = true;
-    }
-  }
-
-  for (const exportSpecifier of starExportSpecifiers(source)) {
-    const exportTarget = resolveLocalModuleSpecifier(
-      normalizedSourcePath,
-      exportSpecifier.specifier
-    );
-    if (!exportTarget) {
-      continue;
-    }
-
-    const reexportedKind = namedExportKindFromFile(
-      exportTarget,
-      identifier,
-      new Set(visited)
-    );
-    if (exportKindHasValue(reexportedKind) && !exportSpecifier.typeOnly) {
-      return reexportedKind;
-    }
-    if (exportKindHasType(reexportedKind)) {
-      sawTypeExport = true;
-    }
-  }
-
-  return sawTypeExport ? 'type' : undefined;
-};
-
 const conformanceExportDiagnostics = (
   context: AdapterTargetParseContext,
   target: string,
@@ -1114,11 +605,14 @@ const conformanceExportDiagnostics = (
     keyof AdapterTargetConformanceManifest,
     string,
   ][]) {
-    const exportKind = namedExportKindFromFile(testingExportTarget, identifier);
-    if (field === 'adapterType' && exportKindHasType(exportKind)) {
+    const exportKind = adapterSourceExportKind(testingExportTarget, identifier);
+    if (field === 'adapterType' && adapterSourceExportKindHasType(exportKind)) {
       continue;
     }
-    if (field !== 'adapterType' && exportKindHasValue(exportKind)) {
+    if (
+      field !== 'adapterType' &&
+      adapterSourceExportKindHasValue(exportKind)
+    ) {
       continue;
     }
     const expectedExport =