@pikku/cli 0.7.0 → 0.7.1

package/src/utils.ts

@@ -0,0 +1,284 @@
+import { relative, dirname } from 'path'
+import { PathToNameAndType, InspectorState } from '@pikku/inspector'
+import { mkdir, writeFile } from 'fs/promises'
+import chalk from 'chalk'
+import { fileURLToPath } from 'url'
+import { readFileSync } from 'fs'
+
+const __filename = fileURLToPath(import.meta.url)
+
+export const logPrimary = (message: string) => {
+  console.log(chalk.green(message))
+}
+
+export const logSuccess = (message: string) => {
+  console.log(chalk.green(message))
+}
+
+export const logInfo = (message: string) => {
+  console.log(chalk.blue(message))
+}
+
+export const getFileImportRelativePath = (
+  from: string,
+  to: string,
+  packageMappings: Record<string, string>
+): string => {
+  let filePath = relative(dirname(from), to)
+  if (!/^\.+\//.test(filePath)) {
+    filePath = `./${filePath}`
+  }
+  // let usesPackageName = false
+  for (const [path, packageName] of Object.entries(packageMappings)) {
+    if (filePath.includes(path)) {
+      // usesPackageName = true
+      filePath = filePath.replace(new RegExp(`.*${path}`), packageName)
+      break
+    }
+  }
+  // if (usesPackageName) {
+  //   return filePath.replace('.ts', '')
+  // }
+  return filePath.replace('.ts', '.js')
+}
+
+interface Meta {
+  file: string
+  variable: string
+  type: string
+  typePath: string
+}
+
+export type FilesAndMethods = {
+  userSessionType: Meta
+  sessionServicesType: Meta
+  singletonServicesType: Meta
+  pikkuConfigFactory: Meta
+  singletonServicesFactory: Meta
+  sessionServicesFactory: Meta
+}
+
+export interface PikkuCLIOptions {
+  watch?: boolean
+  config?: string
+  configFileType?: string
+  userSessionType?: string
+  singletonServicesFactoryType?: string
+  sessionServicesFactoryType?: string
+  tags?: string[]
+}
+
+const getMetaTypes = (
+  type: string,
+  errors: Map<string, PathToNameAndType>,
+  map: PathToNameAndType,
+  desiredType?: string
+) => {
+  if (desiredType) {
+    const entries = Object.entries(map)
+    for (const [file, meta] of entries) {
+      for (const { type, variable, typePath } of meta) {
+        if (type === desiredType) {
+          return { file, variable, type, typePath }
+        }
+      }
+    }
+    errors.set(`No ${desiredType} found that extends ${type}`, map)
+    return undefined
+  }
+
+  const totalValues = Object.values(map).flat()
+  if (totalValues.length === 0) {
+    errors.set(`No ${type} found`, map)
+  } else if (totalValues.length > 1) {
+    errors.set(`More than one ${type} found`, map)
+  } else {
+    const entry = Object.entries(map)[0]
+    if (entry) {
+      const [file, [{ type, variable, typePath }]] = entry
+      return { file, type, variable, typePath }
+    }
+  }
+
+  return undefined
+}
+
+export const getPikkuFilesAndMethods = async (
+  {
+    singletonServicesTypeImportMap,
+    sessionServicesTypeImportMap,
+    userSessionTypeImportMap,
+    sessionServicesFactories,
+    singletonServicesFactories,
+    configFactories,
+  }: InspectorState,
+  packageMappings: Record<string, string>,
+  outputFile: string,
+  {
+    configFileType,
+    singletonServicesFactoryType,
+    sessionServicesFactoryType,
+  }: PikkuCLIOptions,
+  requires: Partial<{
+    config: boolean
+    sessionServiceType: boolean
+    singletonServicesType: boolean
+    userSessionType: boolean
+    singletonServicesFactory: boolean
+    sessionServicesFactory: boolean
+  }> = {
+    config: false,
+    singletonServicesType: false,
+    sessionServiceType: false,
+    userSessionType: false,
+    singletonServicesFactory: false,
+    sessionServicesFactory: false,
+  }
+): Promise<FilesAndMethods> => {
+  let errors = new Map<string, PathToNameAndType>()
+
+  const result: Partial<FilesAndMethods> = {
+    userSessionType: getMetaTypes(
+      'CoreUserSession',
+      requires.userSessionType ? errors : new Map(),
+      userSessionTypeImportMap,
+      configFileType
+    ),
+    singletonServicesType: getMetaTypes(
+      'CoreSingletonServices',
+      requires.singletonServicesType ? errors : new Map(),
+      singletonServicesTypeImportMap
+    ),
+    sessionServicesType: getMetaTypes(
+      'CoreServices',
+      requires.sessionServiceType ? errors : new Map(),
+      sessionServicesTypeImportMap
+    ),
+    pikkuConfigFactory: getMetaTypes(
+      'CoreConfig',
+      requires.config ? errors : new Map(),
+      configFactories,
+      configFileType
+    ),
+    singletonServicesFactory: getMetaTypes(
+      'CreateSingletonServices',
+      requires.singletonServicesFactory ? errors : new Map(),
+      singletonServicesFactories,
+      singletonServicesFactoryType
+    ),
+    sessionServicesFactory: getMetaTypes(
+      'CreateSessionServices',
+      requires.sessionServicesFactory ? errors : new Map(),
+      sessionServicesFactories,
+      sessionServicesFactoryType
+    ),
+  }
+
+  if (errors.size > 0) {
+    const result: string[] = ['Found errors:']
+    errors.forEach((filesAndMethods, message) => {
+      result.push(`- ${message}`)
+      for (const [file, methods] of Object.entries(filesAndMethods)) {
+        result.push(
+          `\t* file: ${getFileImportRelativePath(outputFile, file, packageMappings)}`
+        )
+        result.push(
+          `\t* methods: ${methods.map(({ variable, type }) => `${variable}: ${type}`).join(', ')}`
+        )
+      }
+    })
+
+    console.error(result.join('\n'))
+    process.exit(1)
+  }
+
+  return result as FilesAndMethods
+}
+
+export const writeFileInDir = async (
+  path: string,
+  content: string,
+  ignoreModifyComment: boolean = false
+) => {
+  if (content.includes('server-only')) {
+    content = content.replace(
+      "'server-only'",
+      `'server-only'\n\n${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}`
+    )
+  } else {
+    content = `${ignoreModifyComment ? '' : DO_NOT_MODIFY_COMMENT}${content}`
+  }
+
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, content, 'utf-8')
+  logSuccess(`✓ File written to ${path}`)
+}
+
+export const logCommandInfoAndTime = async (
+  commandStart: string,
+  commandEnd: string,
+  [skipCondition, skipMessage = 'none found']: [boolean] | [boolean, string],
+  callback: (...args: any[]) => Promise<unknown>
+): Promise<boolean> => {
+  if (skipCondition === true) {
+    logInfo(
+      `• Skipping ${commandStart.charAt(0).toLocaleLowerCase()}${commandStart.slice(1)} since ${skipMessage}.`
+    )
+    return false
+  }
+
+  const start = Date.now()
+  chalk.blue(`• ${commandStart}...`)
+  await callback()
+
+  logSuccess(`✓ ${commandEnd} in ${Date.now() - start}ms.`)
+  return true
+}
+
+const logo = `
+ ______ _ _     _           
+(_____ (_) |   | |          
+ _____) )| |  _| |  _ _   _ 
+|  ____/ | |_/ ) |_/ ) | | |
+| |    | |  _ (|  _ (| |_| |
+|_|    |_|_| \_)_| \_)____/ 
+`
+
+export const logPikkuLogo = () => {
+  logPrimary(logo)
+
+  const packageJson = JSON.parse(
+    readFileSync(`${dirname(__filename)}/../../package.json`, 'utf-8')
+  )
+  logPrimary(`⚙️ Welcome to the Pikku CLI (v${packageJson.version})\n`)
+}
+
+// TODO: add version back in once the ESM dust settles
+export const DO_NOT_MODIFY_COMMENT = `/**
+ * This file was generated by the @pikku/cli
+ */
+`
+
+export const serializeFileImports = (
+  importType: string,
+  outputPath: string,
+  files: Set<string>,
+  packageMappings: Record<string, string> = {}
+) => {
+  const serializedOutput: string[] = [
+    `/* The files with an ${importType} function call */`,
+  ]
+
+  Array.from(files)
+    .sort()
+    .forEach((path) => {
+      const filePath = getFileImportRelativePath(
+        outputPath,
+        path,
+        packageMappings
+      )
+      serializedOutput.push(`import '${filePath}'`)
+    })
+
+  return serializedOutput.join('\n')
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "module": "Node16",
+    "outDir": "dist",
+    "target": "esnext",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["bin/**/*.ts", "src/**/*.ts"],
+  "exclude": ["**/*.test.ts", "node_modules", "bin/dist"],
+  "references": [
+    {
+      "path": "../core/tsconfig.json"
+    },
+    {
+      "path": "../inspector/tsconfig.json"
+    }
+  ]
+}

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

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

package/dist/bin/pikku-http.js

@@ -1,27 +0,0 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, serializeFileImports, writeFileInDir, } from '../src/utils.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuHTTP = async (cliConfig, visitState) => {
-    return await logCommandInfoAndTime('Finding HTTP routes', 'Found HTTP routes', [visitState.http.files.size === 0], async () => {
-        const { routesFile, packageMappings } = cliConfig;
-        const { http } = visitState;
-        const content = [
-            serializeFileImports('addHTTPRoute', routesFile, http.files, packageMappings),
-            `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
-        ];
-        await writeFileInDir(routesFile, content.join('\n\n'));
-    });
-};
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
-    await pikkuHTTP(cliConfig, visitState);
-}
-export const routes = (program) => {
-    program
-        .command('routes')
-        .description('Find all routes to import')
-        .option('-c | --config <string>', 'The path to pikku cli config file')
-        .action(action);
-};

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

@@ -1,5 +0,0 @@
-import { Command } from 'commander';
-import { PikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { InspectorState } from '@pikku/inspector';
-export declare const pikkuHTTPMap: ({ routesMapDeclarationFile, packageMappings }: PikkuCLIConfig, { http, functions }: InspectorState) => Promise<boolean>;
-export declare const routesMap: (program: Command) => void;

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

@@ -1,23 +0,0 @@
-import { getPikkuCLIConfig } from '../src/pikku-cli-config.js';
-import { logCommandInfoAndTime, logPikkuLogo, writeFileInDir, } from '../src/utils.js';
-import { serializeTypedRoutesMap } from '../src/serialize-typed-route-map.js';
-import { inspectorGlob } from '../src/inspector-glob.js';
-export const pikkuHTTPMap = async ({ routesMapDeclarationFile, packageMappings }, { http, functions }) => {
-    return await logCommandInfoAndTime('Creating routes map', 'Created routes map', [http.files.size === 0], async () => {
-        const content = serializeTypedRoutesMap(routesMapDeclarationFile, packageMappings, functions.typesMap, http.meta, http.metaInputTypes);
-        await writeFileInDir(routesMapDeclarationFile, content);
-    });
-};
-async function action(cliOptions) {
-    logPikkuLogo();
-    const cliConfig = await getPikkuCLIConfig(cliOptions.config, ['rootDir', 'routeDirectories', 'routesFile'], cliOptions.tags);
-    const visitState = await inspectorGlob(cliConfig.rootDir, cliConfig.routeDirectories, cliConfig.filters);
-    await pikkuHTTPMap(cliConfig, visitState);
-}
-export const routesMap = (program) => {
-    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/dist/src/channels/serialize-channels.d.ts

@@ -1,3 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-export declare const serializeChannels: (outputPath: string, filesWithChannels: Set<string>, packageMappings?: Record<string, string>) => string;
-export declare const serializeChannelMeta: (channelsMeta: ChannelsMeta) => string;

package/dist/src/channels/serialize-channels.js

@@ -1,19 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeChannels = (outputPath, filesWithChannels, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addChannel function call */',
-    ];
-    Array.from(filesWithChannels)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};
-export const serializeChannelMeta = (channelsMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('channel', 'meta', ${JSON.stringify(channelsMeta, null, 2)})`);
-    return serializedOutput.join('\n');
-};

package/dist/src/channels/serialize-typed-channel-map.d.ts

@@ -1,3 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-import { TypesMap } from '@pikku/inspector';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, channelsMeta: ChannelsMeta) => string;

package/dist/src/channels/serialize-typed-channel-map.js

@@ -1,93 +0,0 @@
-import { serializeImportMap } from '../core/serialize-import-map.js';
-import { generateCustomTypes } from '../http/serialize-typed-route-map.js';
-export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
-    const { channels, requiredTypes } = generateChannels(channelsMeta);
-    typesMap.customTypes.forEach(({ references }) => {
-        for (const reference of references) {
-            requiredTypes.add(reference);
-        }
-    });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-    
-${imports}
-${serializedCustomTypes}
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${channels}
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelRouteHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-`;
-};
-function generateChannels(channelsMeta) {
-    const requiredTypes = new Set();
-    const channelsObject = {};
-    for (const meta of Object.values(channelsMeta)) {
-        const { name, messageRoutes, message } = meta;
-        if (!channelsObject[name]) {
-            channelsObject[name] = { message, routes: {} };
-        }
-        for (const [key, route] of Object.entries(messageRoutes)) {
-            if (!channelsObject[name].routes[key]) {
-                channelsObject[name].routes[key] = {};
-            }
-            for (const [method, { inputs, outputs }] of Object.entries(route)) {
-                const inputTypes = inputs || null;
-                const outputTypes = outputs || null;
-                channelsObject[name].routes[key][method] = {
-                    inputTypes,
-                    outputTypes,
-                };
-                inputTypes?.forEach((type) => requiredTypes.add(type));
-                outputTypes?.forEach((type) => requiredTypes.add(type));
-            }
-        }
-    }
-    let routesStr = 'export type ChannelsMap = {\n';
-    for (const [channelPath, { routes, message }] of Object.entries(channelsObject)) {
-        routesStr += `  readonly '${channelPath}': {\n`;
-        // Add `routes` object
-        routesStr += `    readonly routes: {\n`;
-        for (const [key, methods] of Object.entries(routes)) {
-            routesStr += `      readonly ${key}: {\n`;
-            for (const [method, handler] of Object.entries(methods)) {
-                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
-            }
-            routesStr += '      },\n';
-        }
-        routesStr += '    },\n';
-        // Add `defaultMessage` outside `routes`
-        if (message) {
-            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
-        }
-        else {
-            routesStr += `    readonly defaultMessage: never,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return { channels: routesStr, requiredTypes };
-}
-// Utility to format type arrays
-function formatTypeArray(types) {
-    return types ? types.join(' | ') : 'null';
-}

package/dist/src/channels/serialize-websocket-wrapper.d.ts

@@ -1 +0,0 @@
-export declare const serializeWebsocketWrapper: (channelsMapPath: string) => string;

package/dist/src/core/serialize-import-map.d.ts

@@ -1,2 +0,0 @@
-import { TypesMap } from '@pikku/inspector';
-export declare const serializeImportMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, requiredTypes: Set<string>) => string;

package/dist/src/core/serialize-import-map.js

@@ -1,24 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeImportMap = (relativeToPath, packageMappings, typesMap, requiredTypes) => {
-    const paths = new Map();
-    Array.from(requiredTypes).forEach((requiredType) => {
-        const { originalName, uniqueName, path } = typesMap.getTypeMeta(requiredType);
-        if (!path) {
-            // This is a custom type that exists in file, so we don't need to import it
-            return;
-        }
-        const variables = paths.get(path) || [];
-        if (originalName === uniqueName) {
-            variables.push(originalName);
-        }
-        else {
-            variables.push(`${originalName} as ${uniqueName}`);
-        }
-        paths.set(path, variables);
-    });
-    const imports = [];
-    for (const [path, variables] of paths.entries()) {
-        imports.push(`import type { ${variables.join(', ')} } from '${getFileImportRelativePath(relativeToPath, path, packageMappings)}'`);
-    }
-    return imports.join('\n');
-};

package/dist/src/core/serialize-pikku-types.d.ts

@@ -1,4 +0,0 @@
-/**
- *
- */
-export declare const serializePikkuTypes: (userSessionTypeImport: string, userSessionTypeName: string, singletonServicesTypeImport: string, singletonServicesTypeName: string, sessionServicesTypeImport: string, servicesTypeName: string) => string;

package/dist/src/events/channels/serialize-channels.d.ts

@@ -1,3 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-export declare const serializeChannels: (outputPath: string, filesWithChannels: Set<string>, packageMappings?: Record<string, string>) => string;
-export declare const serializeChannelMeta: (channelsMeta: ChannelsMeta) => string;

package/dist/src/events/channels/serialize-channels.js

@@ -1,19 +0,0 @@
-import { getFileImportRelativePath } from '../utils.js';
-export const serializeChannels = (outputPath, filesWithChannels, packageMappings = {}) => {
-    const serializedOutput = [
-        '/* The files with an addChannel function call */',
-    ];
-    Array.from(filesWithChannels)
-        .sort()
-        .forEach((path) => {
-        const filePath = getFileImportRelativePath(outputPath, path, packageMappings);
-        serializedOutput.push(`import '${filePath}'`);
-    });
-    return serializedOutput.join('\n');
-};
-export const serializeChannelMeta = (channelsMeta) => {
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push(`pikkuState('channel', 'meta', ${JSON.stringify(channelsMeta, null, 2)})`);
-    return serializedOutput.join('\n');
-};

package/dist/src/events/channels/serialize-typed-channel-map.d.ts

@@ -1,3 +0,0 @@
-import { ChannelsMeta } from '@pikku/core/channel';
-import { TypesMap } from '@pikku/inspector';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, channelsMeta: ChannelsMeta) => string;

package/dist/src/events/channels/serialize-typed-channel-map.js

@@ -1,90 +0,0 @@
-import { serializeImportMap } from '../core/serialize-import-map.js';
-import { generateCustomTypes } from '../http/serialize-typed-route-map.js';
-export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, channelsMeta) => {
-    const { channels, requiredTypes } = generateChannels(channelsMeta);
-    typesMap.customTypes.forEach(({ references }) => {
-        for (const reference of references) {
-            requiredTypes.add(reference);
-        }
-    });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
-    const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    return `/**
- * This provides the structure needed for TypeScript to be aware of channels
- */
-    
-${imports}
-${serializedCustomTypes}
-
-interface ChannelHandler<I, O> {
-    input: I;
-    output: O;
-}
-
-${channels}
-
-export type ChannelDefaultHandlerOf<Channel extends keyof ChannelsMap> =
-    ChannelsMap[Channel]['defaultMessage'] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-
-export type ChannelRouteHandlerOf<
-    Channel extends keyof ChannelsMap, 
-    Route extends keyof ChannelsMap[Channel]['routes'], 
-    Method extends keyof ChannelsMap[Channel]['routes'][Route],
-> =
-    ChannelsMap[Channel]['routes'][Route][Method] extends { input: infer I; output: infer O }
-        ? ChannelHandler<I, O>
-        : never;
-`;
-};
-function generateChannels(channelsMeta) {
-    const requiredTypes = new Set();
-    const channelsObject = {};
-    for (const meta of channelsMeta) {
-        const { name, messageRoutes, message } = meta;
-        if (!channelsObject[name]) {
-            channelsObject[name] = { message, routes: {} };
-        }
-        for (const [key, route] of Object.entries(messageRoutes)) {
-            if (!channelsObject[name].routes[key]) {
-                channelsObject[name].routes[key] = {};
-            }
-            for (const [method, { inputs, outputs }] of Object.entries(route)) {
-                const inputTypes = inputs || null;
-                const outputTypes = outputs || null;
-                channelsObject[name].routes[key][method] = {
-                    inputTypes,
-                    outputTypes,
-                };
-                inputTypes?.forEach((type) => requiredTypes.add(type));
-                outputTypes?.forEach((type) => requiredTypes.add(type));
-            }
-        }
-    }
-    let routesStr = 'export type ChannelsMap = {\n';
-    for (const [channelPath, { routes, message }] of Object.entries(channelsObject)) {
-        routesStr += `  readonly '${channelPath}': {\n`;
-        // Add `routes` object
-        routesStr += `    readonly routes: {\n`;
-        for (const [key, methods] of Object.entries(routes)) {
-            routesStr += `      readonly ${key}: {\n`;
-            for (const [method, handler] of Object.entries(methods)) {
-                routesStr += `        readonly ${method}: ChannelHandler<${formatTypeArray(handler.inputTypes) || 'void'}, ${formatTypeArray(handler.outputTypes) || 'never'}>,\n`;
-            }
-            routesStr += '      },\n';
-        }
-        routesStr += '    },\n';
-        // Add `defaultMessage` outside `routes`
-        if (message) {
-            routesStr += `    readonly defaultMessage: ChannelHandler<${formatTypeArray(message.inputs)}, ${formatTypeArray(message.outputs)}>,\n`;
-        }
-        routesStr += '  },\n';
-    }
-    routesStr += '};';
-    return { channels: routesStr, requiredTypes };
-}
-// Utility to format type arrays
-function formatTypeArray(types) {
-    return types ? types.join(' | ') : 'null';
-}

package/dist/src/events/channels/serialize-websocket-wrapper.d.ts

@@ -1 +0,0 @@
-export declare const serializeWebsocketWrapper: (channelsMapPath: string) => string;