@pikku/cli 0.7.2 → 0.7.4

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @pikku/cli
 
+## 0.7.4
+
+### Patch Changes
+
+- 6af8a19: fix: always write functions meta data
+- Updated dependencies [6af8a19]
+  - @pikku/core@0.7.7
+
+## 0.7.3
+
+### Patch Changes
+
+- 46d4458: feat: we now have typed rpc calls inside of functions!
+- Updated dependencies [46d4458]
+  - @pikku/core@0.7.5
+
 ## 0.7.2
 
 ### Patch Changes

package/bin/pikku-all.ts

@@ -5,7 +5,7 @@ import {
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
+} from '../src/utils/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { pikkuHTTP } from './pikku-http-routes.js'
 import { pikkuFunctionTypes } from './pikku-function-types.js'
@@ -23,6 +23,7 @@ import { inspectorGlob } from '../src/inspector-glob.js'
 import chokidar from 'chokidar'
 import { pikkuFunctions } from './pikku-functions.js'
 import { pikkuRPC } from './pikku-rpc.js'
+import { pikkuRPCMap } from './pikku-rpc-map.js'
 
 const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   const metaImports: string[] = []
@@ -67,7 +68,9 @@ const runAll = async (cliConfig: PikkuCLIConfig, options: PikkuCLIOptions) => {
   addImport(cliConfig.functionsFile, 'events')
 
   await pikkuRPC(cliConfig, visitState)
-  addImport(cliConfig.rpcFile, 'meta')
+  await pikkuRPCMap(cliConfig, visitState)
+  addImport(cliConfig.rpcMetaFile, 'meta')
+  addImport(cliConfig.rpcFile, 'events')
 
   const routes = await pikkuHTTP(cliConfig, visitState)
   if (routes) {

package/bin/pikku-channels-map.ts

@@ -1,14 +1,7 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
 import { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuChannelsMap = async (
   { channelsMapDeclarationFile, packageMappings }: PikkuCLIConfig,
@@ -29,27 +22,3 @@ export const pikkuChannelsMap = async (
     }
   )
 }
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
-    cliOptions.tags,
-    false
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuChannelsMap(cliConfig, visitState)
-}
-
-export const channelsMap = (program: Command): void => {
-  program
-    .command('channels-map')
-    .description('Generate a map of all channels to aid in type checking')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-channels.ts

@@ -1,14 +1,10 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
+} from '../src/utils/utils.js'
 
 export const pikkuChannels = async (
   cliConfig: PikkuCLIConfig,
@@ -37,27 +33,3 @@ export const pikkuChannels = async (
     }
   )
 }
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
-    cliOptions.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuChannels(cliConfig, visitState)
-}
-
-export const channels = (program: Command): void => {
-  program
-    .command('channels')
-    .description('Find all channels to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-fetch.ts

@@ -1,13 +1,13 @@
 import { Command } from 'commander'
+import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js'
 import {
   getFileImportRelativePath,
   logCommandInfoAndTime,
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
-import { serializeFetchWrapper } from '../src/serialize-fetch-wrapper.js'
+} from '../src/utils/utils.js'
 
 export const pikkuFetch = async ({
   fetchFile,

package/bin/pikku-function-types.ts

@@ -1,20 +1,20 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   getFileImportRelativePath,
   getPikkuFilesAndMethods,
   logCommandInfoAndTime,
-  logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
-import { pikkuHTTP } from './pikku-http-routes.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
+} from '../src/utils/utils.js'
 import { serializePikkuTypes } from '../src/serialize-pikku-types.js'
 
 export const pikkuFunctionTypes = async (
-  { typesDeclarationFile: typesFile, packageMappings }: PikkuCLIConfig,
+  {
+    typesDeclarationFile: typesFile,
+    packageMappings,
+    rpcMapDeclarationFile,
+  }: PikkuCLIConfig,
   options: PikkuCLIOptions,
   visitState: InspectorState
 ) => {
@@ -42,43 +42,9 @@ export const pikkuFunctionTypes = async (
         `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(typesFile, singletonServicesType.typePath, packageMappings)}'`,
         singletonServicesType.type,
         `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(typesFile, sessionServicesType.typePath, packageMappings)}'`,
-        sessionServicesType.type
+        `import type { TypedPikkuRPC } from '${getFileImportRelativePath(typesFile, rpcMapDeclarationFile, packageMappings)}'`
       )
       await writeFileInDir(typesFile, content)
     }
   )
 }
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'srcDirectories', 'typesDeclarationFile'],
-    cliOptions.tags
-  )
-
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuHTTP(cliConfig, visitState)
-}
-
-export const functionTypes = (program: Command): void => {
-  program
-    .command('types')
-    .description('Generate the core API')
-    .option('-ct | --pikku-config-type', 'The type of your pikku config object')
-    .option(
-      '-ss | --singleton-services-factory-type',
-      'The type of your singleton services factory'
-    )
-    .option(
-      '-se | --session-services-factory-type',
-      'The type of your session services factory'
-    )
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-functions.ts

@@ -1,31 +1,16 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  serializeFileImports,
-  writeFileInDir,
-} from '../src/utils.js'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
 
 export const pikkuFunctions = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
+  { functionsMetaFile }: PikkuCLIConfig,
+  { functions }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
-    'Finding Pikku functions',
-    'Found Pikku functions',
-    [visitState.functions.files.size === 0],
+    'Serializing Pikku functions',
+    'Serialized Pikku functions',
+    [false],
     async () => {
-      const { functionsFile, functionsMetaFile, packageMappings } = cliConfig
-      const { functions } = visitState
-      await writeFileInDir(
-        functionsFile,
-        serializeFileImports(
-          'addFunction',
-          functionsFile,
-          functions.files,
-          packageMappings
-        )
-      )
       await writeFileInDir(
         functionsMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('function', 'meta', ${JSON.stringify(functions.meta, null, 2)})`

package/bin/pikku-http-map.ts

@@ -1,14 +1,7 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import {
-  logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
-  writeFileInDir,
-} from '../src/utils.js'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
 import { serializeTypedRoutesMap } from '../src/serialize-typed-http-map.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuHTTPMap = async (
   { httpRoutesMapDeclarationFile, packageMappings }: PikkuCLIConfig,
@@ -31,26 +24,3 @@ export const pikkuHTTPMap = async (
     }
   )
 }
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
-    cliOptions.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuHTTPMap(cliConfig, visitState)
-}
-
-export const routesMap = (program: Command): void => {
-  program
-    .command('map')
-    .description('Generate a map of all routes to aid in type checking')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-http-routes.ts

@@ -1,14 +1,10 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
+} from '../src/utils/utils.js'
 
 export const pikkuHTTP = async (
   cliConfig: PikkuCLIConfig,
@@ -37,27 +33,3 @@ export const pikkuHTTP = async (
     }
   )
 }
-
-async function action(cliOptions: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    cliOptions.config,
-    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
-    cliOptions.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuHTTP(cliConfig, visitState)
-}
-
-export const routes = (program: Command): void => {
-  program
-    .command('routes')
-    .description('Find all routes to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-nextjs.ts

@@ -8,7 +8,7 @@ import {
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
+} from '../src/utils/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import { inspectorGlob } from '../src/inspector-glob.js'

package/bin/pikku-openapi.ts

@@ -4,7 +4,7 @@ import {
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
+} from '../src/utils/utils.js'
 import { generateSchemas } from '../src/schema-generator.js'
 import { generateOpenAPISpec } from '../src/openapi-spec-generator.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'

package/bin/pikku-rpc-map.ts

@@ -0,0 +1,25 @@
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { InspectorState } from '@pikku/inspector'
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js'
+import { serializeTypedRPCMap } from '../src/serialize-typed-rpc-map.js'
+
+export const pikkuRPCMap = async (
+  { rpcMapDeclarationFile, packageMappings }: PikkuCLIConfig,
+  { functions, rpc }: InspectorState
+) => {
+  return await logCommandInfoAndTime(
+    'Creating RPC map',
+    'Created RPC map',
+    [rpc.files.size === 0],
+    async () => {
+      const content = serializeTypedRPCMap(
+        rpcMapDeclarationFile,
+        packageMappings,
+        functions.typesMap,
+        functions.meta,
+        rpc.meta
+      )
+      await writeFileInDir(rpcMapDeclarationFile, content)
+    }
+  )
+}

package/bin/pikku-rpc.ts

@@ -1,20 +1,75 @@
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, writeFileInDir } from '../src/utils.js'
+import {
+  getFileImportRelativePath,
+  logCommandInfoAndTime,
+  writeFileInDir,
+} from '../src/utils/utils.js'
+
+export const serializeRPCImports = (
+  outputPath: string,
+  functionsMap: Map<string, { path: string; exportedName: string }>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedImports: string[] = [
+    `/* Import and register RPCs */`,
+    `import { addFunction } from '@pikku/core'`,
+  ]
+
+  const serializedRegistrations: string[] = []
+
+  // Sort by function name for consistent output
+  const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) =>
+    a[0].localeCompare(b[0])
+  )
+
+  for (const [name, { path, exportedName }] of sortedEntries) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      path,
+      packageMappings
+    )
+
+    // For directly exported functions, we can just import and register them
+    if (name === exportedName) {
+      serializedImports.push(`import { ${exportedName} } from '${filePath}'`)
+      serializedRegistrations.push(
+        `addFunction('${name}', { func: ${exportedName} })`
+      )
+    }
+    // For renamed functions, we need to import and alias them
+    else {
+      serializedImports.push(
+        `import { ${exportedName} as ${name} } from '${filePath}'`
+      )
+      serializedRegistrations.push(`addFunction('${name}', ${name})`)
+    }
+  }
+
+  // Add a blank line between imports and registrations
+  if (serializedImports.length > 0 && serializedRegistrations.length > 0) {
+    serializedImports.push('')
+  }
+
+  // Combine the imports and registrations
+  return [...serializedImports, ...serializedRegistrations].join('\n')
+}
 
 export const pikkuRPC = async (
-  cliConfig: PikkuCLIConfig,
-  visitState: InspectorState
+  { rpcFile, rpcMetaFile, packageMappings }: PikkuCLIConfig,
+  { rpc }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
     'Finding RPCs tasks',
-    'Found rpcs',
-    [visitState.functions.files.size === 0],
+    'Found RPCs',
+    [rpc.files.size === 0],
     async () => {
-      const { rpcFile } = cliConfig
-      const { rpc } = visitState
       await writeFileInDir(
         rpcFile,
+        serializeRPCImports(rpcFile, rpc.files, packageMappings)
+      )
+      await writeFileInDir(
+        rpcMetaFile,
         `import { pikkuState } from '@pikku/core'\npikkuState('rpc', 'meta', ${JSON.stringify(rpc.meta, null, 2)})`
       )
     }

package/bin/pikku-scheduler.ts

@@ -1,15 +1,11 @@
-import { Command } from 'commander'
-import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
+import { PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
 import {
   logCommandInfoAndTime,
-  logPikkuLogo,
-  PikkuCLIOptions,
   serializeFileImports,
   writeFileInDir,
-} from '../src/utils.js'
+} from '../src/utils/utils.js'
 import { serializeSchedulerMeta } from '../src/serialize-scheduler-meta.js'
-import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuScheduler = async (
   cliConfig: PikkuCLIConfig,
@@ -38,27 +34,3 @@ export const pikkuScheduler = async (
     }
   )
 }
-
-async function action(options: PikkuCLIOptions): Promise<void> {
-  logPikkuLogo()
-
-  const cliConfig = await getPikkuCLIConfig(
-    options.config,
-    ['rootDir', 'srcDirectories', 'httpRoutesFile'],
-    options.tags
-  )
-  const visitState = await inspectorGlob(
-    cliConfig.rootDir,
-    cliConfig.srcDirectories,
-    cliConfig.filters
-  )
-  await pikkuScheduler(cliConfig, visitState)
-}
-
-export const schedules = (program: Command): void => {
-  program
-    .command('scheduler')
-    .description('Find all scheduled tasks to import')
-    .option('-c | --config <string>', 'The path to pikku cli config file')
-    .action(action)
-}

package/bin/pikku-schemas.ts

@@ -3,12 +3,12 @@ import { saveSchemas, generateSchemas } from '../src/schema-generator.js'
 
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { InspectorState } from '@pikku/inspector'
-import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils.js'
+import { logCommandInfoAndTime, logPikkuLogo } from '../src/utils/utils.js'
 import { inspectorGlob } from '../src/inspector-glob.js'
 
 export const pikkuSchemas = async (
   { tsconfig, schemaDirectory, supportsImportAttributes }: PikkuCLIConfig,
-  { functions, http, channels }: InspectorState
+  { functions, http }: InspectorState
 ) => {
   return await logCommandInfoAndTime(
     'Creating schemas',

package/bin/pikku-websocket.ts

@@ -5,7 +5,7 @@ import {
   logPikkuLogo,
   PikkuCLIOptions,
   writeFileInDir,
-} from '../src/utils.js'
+} from '../src/utils/utils.js'
 import { getPikkuCLIConfig, PikkuCLIConfig } from '../src/pikku-cli-config.js'
 import { serializeWebsocketWrapper } from '../src/serialize-websocket-wrapper.js'
 

package/bin/pikku.ts

@@ -1,26 +1,16 @@
 #!/usr/bin/env node
 import { Command } from 'commander'
 import { schemas } from './pikku-schemas.js'
-import { routes } from './pikku-http-routes.js'
 import { nextjs } from './pikku-nextjs.js'
 import { all } from './pikku-all.js'
-import { functionTypes } from './pikku-function-types.js'
-import { routesMap } from './pikku-http-map.js'
 import { fetch } from './pikku-fetch.js'
-import { channels } from './pikku-channels.js'
-import { schedules } from './pikku-scheduler.js'
 
 const program = new Command('pikku')
 program.usage('[command]')
 
 all(program)
-routes(program)
-routesMap(program)
-functionTypes(program)
 schemas(program)
 nextjs(program)
 fetch(program)
-channels(program)
-schedules(program)
 
 program.parse(process.argv)

package/dist/bin/pikku-all.d.ts

@@ -1,4 +1,4 @@
 import { Command } from 'commander';
-import { PikkuCLIOptions } from '../src/utils.js';
+import { PikkuCLIOptions } from '../src/utils/utils.js';
 export declare const action: (options: PikkuCLIOptions) => Promise<void>;
 export declare const all: (program: Command) => void;

package/dist/bin/pikku-all.js

@@ -1,4 +1,4 @@
-import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { getFileImportRelativePath, logInfo, logPikkuLogo, writeFileInDir, } from '../src/utils/utils.js';
 import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { pikkuHTTP } from './pikku-http-routes.js';
 import { pikkuFunctionTypes } from './pikku-function-types.js';
@@ -16,6 +16,7 @@ import { inspectorGlob } from '../src/inspector-glob.js';
 import chokidar from 'chokidar';
 import { pikkuFunctions } from './pikku-functions.js';
 import { pikkuRPC } from './pikku-rpc.js';
+import { pikkuRPCMap } from './pikku-rpc-map.js';
 const runAll = async (cliConfig, options) => {
     const metaImports = [];
     const imports = [];
@@ -47,7 +48,9 @@ const runAll = async (cliConfig, options) => {
     addImport(cliConfig.functionsMetaFile, 'meta');
     addImport(cliConfig.functionsFile, 'events');
     await pikkuRPC(cliConfig, visitState);
-    addImport(cliConfig.rpcFile, 'meta');
+    await pikkuRPCMap(cliConfig, visitState);
+    addImport(cliConfig.rpcMetaFile, 'meta');
+    addImport(cliConfig.rpcFile, 'events');
     const routes = await pikkuHTTP(cliConfig, visitState);
     if (routes) {
         await pikkuHTTPMap(cliConfig, visitState);

package/dist/bin/pikku-channels-map.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuChannelsMap: ({ channelsMapDeclarationFile, packageMappings }: PikkuCLIConfig, state: InspectorState) => Promise<boolean>;
-export declare const channelsMap: (program: Command) => void;

package/dist/bin/pikku-channels-map.js

@@ -1,23 +1,8 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
+import { logCommandInfoAndTime, writeFileInDir } from '../src/utils/utils.js';
 import { serializeTypedChannelsMap } from '../src/serialize-typed-channel-map.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
 export const pikkuChannelsMap = async ({ channelsMapDeclarationFile, packageMappings }, state) => {
     return await logCommandInfoAndTime('Creating channels map', 'Created channels map', [state.channels.files.size === 0], async () => {
         const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.channels.meta);
         await writeFileInDir(channelsMapDeclarationFile, content);
     });
 };
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'srcDirectories', 'httpRoutesFile'], cliOptions.tags, false);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.srcDirectories, cliConfig.filters);
-    await pikkuChannelsMap(cliConfig, visitState);
-}
-export const channelsMap = (program) => {
-    program
-        .command('channels-map')
-        .description('Generate a map of all channels to aid in type checking')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

package/dist/bin/pikku-channels.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
 import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
 import { InspectorState } from '@pikku/inspector';
 export declare const pikkuChannels: (cliConfig: PikkuCLIConfig, visitState: InspectorState) => Promise<boolean>;
-export declare const channels: (program: Command) => void;