@pikku/inspector 0.12.75 → 0.12.81

package/src/tsconfig-paths.test.ts

@@ -1,90 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from './inspector.js'
-import type { InspectorLogger } from './types.js'
-
-const logger: InspectorLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  diagnostic: () => {},
-  critical: () => {},
-  hasCriticalErrors: () => false,
-}
-
-const FACTORY = [
-  'export type Config = {',
-  '  name: string',
-  '  func: (services: any, data: { qty: number }) => Promise<{ ok: boolean }>',
-  '}',
-  'export const pikkuSessionlessFunc = (config: Config): Config => config',
-].join('\n')
-
-// The parameter is deliberately unannotated: its type can only come from the
-// factory's contextual type, which is exactly what an unresolved import loses.
-const funcSource = (specifier: string) =>
-  [
-    `import { pikkuSessionlessFunc } from '${specifier}'`,
-    'export const buysAnApple = pikkuSessionlessFunc({',
-    "  name: 'buysAnApple',",
-    '  func: async (_services, data) => ({ ok: data.qty > 0 }),',
-    '})',
-  ].join('\n')
-
-const makeProject = async (specifier: string) => {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-tsconfig-paths-'))
-  await mkdir(join(rootDir, 'generated'))
-  await mkdir(join(rootDir, 'src'))
-  await writeFile(
-    join(rootDir, 'tsconfig.json'),
-    JSON.stringify({
-      compilerOptions: {
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
-        paths: { '#gen/*': ['./generated/*'] },
-      },
-    })
-  )
-  await writeFile(
-    join(rootDir, 'package.json'),
-    JSON.stringify({ type: 'module' })
-  )
-  await writeFile(join(rootDir, 'generated', 'factory.ts'), FACTORY)
-  const funcFile = join(rootDir, 'src', 'apple.func.ts')
-  await writeFile(funcFile, funcSource(specifier))
-  return { rootDir, funcFile, tsconfig: join(rootDir, 'tsconfig.json') }
-}
-
-describe('tsconfig path mappings', () => {
-  test('a relative import gives the function its input type', async () => {
-    const { rootDir, funcFile } = await makeProject('../generated/factory.js')
-    try {
-      const state = await inspect(logger, [funcFile], { rootDir })
-      const meta = state.functions.meta['buysAnApple']
-      assert.ok(meta, 'buysAnApple meta should exist')
-      assert.deepStrictEqual(meta!.inputs, ['BuysAnAppleInput'])
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('an import that only resolves through tsconfig paths keeps its input type', async () => {
-    const { rootDir, funcFile, tsconfig } = await makeProject('#gen/factory.js')
-    try {
-      const state = await inspect(logger, [funcFile], { rootDir, tsconfig })
-      const meta = state.functions.meta['buysAnApple']
-      assert.ok(meta, 'buysAnApple meta should exist')
-      assert.deepStrictEqual(
-        meta!.inputs,
-        ['BuysAnAppleInput'],
-        'without the project path mappings the factory resolves to `any`, and the input is silently dropped'
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/types-map.ts

@@ -1,141 +0,0 @@
-export class TypesMap {
-  private map: Map<string, { originalName: string; path: string | null }> =
-    new Map()
-  public customTypes: Map<string, { type: string; references: string[] }> =
-    new Map()
-
-  public addCustomType(name: string, type: string, references: string[]) {
-    this.customTypes.set(name, { type, references })
-  }
-
-  public addType(originalName: string, path: string) {
-    this.map.set(originalName, { originalName, path })
-  }
-
-  public addUniqueType(originalName: string, path: string): string {
-    const uniqueName = `${originalName}_${Math.random().toString(36).substring(7)}`
-    this.map.set(uniqueName, { originalName, path })
-    return uniqueName
-  }
-
-  public getUniqueName(name: string): string {
-    const meta = this.getTypeMeta(name)
-    return meta.uniqueName
-  }
-
-  public getTypeMeta(name: string): {
-    originalName: string
-    uniqueName: string
-    path: string | null
-  } {
-    if (
-      [
-        'string',
-        'number',
-        'boolean',
-        'null',
-        'undefined',
-        'void',
-        'unknown',
-        'never',
-      ].includes(name)
-    ) {
-      return {
-        originalName: name,
-        uniqueName: name,
-        path: null,
-      }
-    }
-
-    if (this.customTypes.has(name)) {
-      return {
-        originalName: name,
-        uniqueName: name,
-        path: null,
-      }
-    }
-
-    let meta = this.map.get(name)
-    if (!meta) {
-      meta = Array.from(this.map.entries()).find(
-        ([_, { originalName }]) => originalName === name
-      )?.[1]
-    }
-    if (!meta) {
-      throw new Error(`Type ${name} not found in typesMap`)
-    }
-
-    const getName = this.squash()
-    return {
-      uniqueName: getName(name),
-      originalName: meta.originalName,
-      path: meta?.path,
-    }
-  }
-
-  public exists(originalName: string, path: string): string | undefined {
-    const found = Array.from(this.map.entries()).find(([_, type]) => {
-      return type.path === path && type.originalName === originalName
-    })
-    return found ? found[0] : undefined
-  }
-
-  private squash() {
-    const duplicateNames = new Set<string>()
-    const pathToNamesMap = new Map<string, Map<string, string>>()
-    const nameOccurrences = new Map<string, Set<string>>()
-
-    // First pass: Track occurrences of each original name across paths
-    this.map.forEach(({ path, originalName }) => {
-      if (path) {
-        if (!nameOccurrences.has(originalName)) {
-          nameOccurrences.set(originalName, new Set())
-        }
-        nameOccurrences.get(originalName)!.add(path)
-      }
-    })
-
-    // Second pass: Populate pathToNamesMap
-    this.map.forEach(({ path, originalName }, uniqueName) => {
-      if (!path) return
-
-      if (!pathToNamesMap.has(path)) {
-        pathToNamesMap.set(path, new Map())
-      }
-
-      const isDuplicate = nameOccurrences.get(originalName)!.size > 1
-      if (isDuplicate) {
-        duplicateNames.add(uniqueName)
-      }
-      // Use uniqueName only if the originalName is duplicated across files
-      const nameToUse = isDuplicate ? uniqueName : originalName
-      pathToNamesMap.get(path)!.set(nameToUse, originalName)
-    })
-
-    const getName = (uniqueName: string) => {
-      if (duplicateNames.has(uniqueName)) {
-        return uniqueName
-      }
-      if (
-        uniqueName === 'string' ||
-        uniqueName === 'number' ||
-        uniqueName === 'boolean' ||
-        uniqueName === 'null'
-      ) {
-        return uniqueName
-      }
-      if (!this.map.has(uniqueName)) {
-        const found = Array.from(this.map.entries()).find(
-          ([_, { originalName }]) => originalName === uniqueName
-        )?.[1]
-        if (!found) {
-          throw new Error(`Type ${uniqueName} not found in typesMap`)
-        }
-        return found.originalName
-      }
-      return this.map.get(uniqueName)!.originalName
-    }
-
-    return getName
-  }
-}