fix: remove redundant defs and declare codec return type

packages/protons-runtime/src/codecs/codec.ts → packages/protons-runtime/src/codec.ts

@@ -24,13 +24,13 @@ export interface EncodingLengthFunction<T> {
 
 export interface Codec<T> {
   name: string
-  type: number
+  type: CODEC_TYPES
   encode: EncodeFunction<T>
   decode: DecodeFunction<T>
   encodingLength: EncodingLengthFunction<T>
 }
 
-export function createCodec <T> (name: string, type: number, encode: EncodeFunction<T>, decode: DecodeFunction<T>, encodingLength: EncodingLengthFunction<T>): Codec<T> {
+export function createCodec <T> (name: string, type: CODEC_TYPES, encode: EncodeFunction<T>, decode: DecodeFunction<T>, encodingLength: EncodingLengthFunction<T>): Codec<T> {
   return {
     name,
     type,

packages/protons-runtime/src/codecs/bool.ts

@@ -1,4 +1,5 @@
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<boolean> = function boolEncodingLength () {
   return 1

packages/protons-runtime/src/codecs/bytes.ts

@@ -1,7 +1,8 @@
 
 import { Uint8ArrayList } from 'uint8arraylist'
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<Uint8Array> = function bytesEncodingLength (val) {
   const len = val.byteLength

packages/protons-runtime/src/codecs/double.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function doubleEncodingLength () {
   return 8

packages/protons-runtime/src/codecs/enum.ts

@@ -1,6 +1,7 @@
 
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, Codec, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction, Codec } from '../codec.js'
 
 export function enumeration <T> (e: T): Codec<T> {
   const encodingLength: EncodingLengthFunction<string> = function enumEncodingLength (val: string) {

packages/protons-runtime/src/codecs/fixed32.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function fixed32EncodingLength () {
   return 4

packages/protons-runtime/src/codecs/fixed64.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return 8

packages/protons-runtime/src/codecs/float.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function floatEncodingLength () {
   return 4

packages/protons-runtime/src/codecs/int32.ts

@@ -1,5 +1,6 @@
 import { signed } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function int32EncodingLength (val) {
   return signed.encodingLength(val)

packages/protons-runtime/src/codecs/int64.ts

@@ -1,5 +1,6 @@
 import { signed } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return signed.encodingLength(val)

packages/protons-runtime/src/codecs/message.ts

@@ -1,7 +1,8 @@
 import { unsigned } from '../utils/varint.js'
-import type { FieldDef, FieldDefs } from '../index.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, Codec, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction, Codec } from '../codec.js'
 import { Uint8ArrayList } from 'uint8arraylist'
+import type { FieldDefs, FieldDef } from '../index.js'
 
 export interface Factory<A, T> {
   new (obj: A): T

packages/protons-runtime/src/codecs/sfixed32.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function sfixed32EncodingLength () {
   return 4

packages/protons-runtime/src/codecs/sfixed64.ts

@@ -1,5 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function sfixed64EncodingLength () {
   return 8

packages/protons-runtime/src/codecs/sint32.ts

@@ -1,5 +1,6 @@
 import { zigzag } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function sint32EncodingLength (val) {
   return zigzag.encodingLength(val)

packages/protons-runtime/src/codecs/sint64.ts

@@ -1,5 +1,6 @@
 import { zigzag } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function int64EncodingLength (val) {
   return zigzag.encodingLength(val)

packages/protons-runtime/src/codecs/string.ts

@@ -1,7 +1,8 @@
 import { unsigned } from '../utils/varint.js'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 import { Uint8ArrayList } from 'uint8arraylist'
 
 const encodingLength: EncodingLengthFunction<string> = function stringEncodingLength (val) {

packages/protons-runtime/src/codecs/uint32.ts

@@ -1,5 +1,6 @@
 import { unsigned } from '../utils/varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<number> = function uint32EncodingLength (val) {
   return unsigned.encodingLength(val)

packages/protons-runtime/src/codecs/uint64.ts

@@ -1,5 +1,6 @@
 import { unsigned } from '../utils/big-varint.js'
-import { DecodeFunction, EncodeFunction, createCodec, EncodingLengthFunction, CODEC_TYPES } from './codec.js'
+import { createCodec, CODEC_TYPES } from '../codec.js'
+import type { DecodeFunction, EncodeFunction, EncodingLengthFunction } from '../codec.js'
 
 const encodingLength: EncodingLengthFunction<bigint> = function uint64EncodingLength (val) {
   return unsigned.encodingLength(val)

packages/protons-runtime/src/decode.ts

@@ -1,6 +1,6 @@
 import { Uint8ArrayList } from 'uint8arraylist'
 import { unsigned } from './utils/varint.js'
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 
 export function decodeMessage <T> (buf: Uint8Array, codec: Codec<T>) {
   // wrap root message

packages/protons-runtime/src/encode.ts

@@ -1,4 +1,4 @@
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 import { unsigned } from './utils/varint.js'
 
 export function encodeMessage <T> (message: T, codec: Codec<T>) {

packages/protons-runtime/src/index.ts

@@ -1,4 +1,4 @@
-import type { Codec } from './codecs/codec.js'
+import type { Codec } from './codec.js'
 
 export interface FieldDef {
   name: string
@@ -35,3 +35,4 @@ export { sint64 } from './codecs/sint64.js'
 export { string } from './codecs/string.js'
 export { uint32 } from './codecs/uint32.js'
 export { uint64 } from './codecs/uint64.js'
+export type { Codec } from './codec.js'

packages/protons-runtime/tsconfig.json

@@ -1,9 +1,7 @@
 {
   "extends": "aegir/src/config/tsconfig.aegir.json",
   "compilerOptions": {
-    "outDir": "dist",
-    "emitDeclarationOnly": false,
-    "module": "ES2020"
+    "outDir": "dist"
   },
   "include": [
     "src",

packages/protons/bin/protons.ts

@@ -6,13 +6,13 @@ import { generate } from '../src/index.js'
 async function main () {
   const cli = meow(`
   Usage
-    $ protons source
+    $ protons source...
 
   Options
-    --output, -o  Path to a directory to write transpiled typescript files into
+    --output, -o Path to a directory to write transpiled typescript files into
 
   Examples
-    $ protons ./path/to/file.proto
+    $ protons ./path/to/file.proto ./path/to/other/file.proto
 `, {
     importMeta: import.meta,
     flags: {

packages/protons/src/index.ts

@@ -141,8 +141,7 @@ export namespace ${messageDef.name} {
   export const codec = () => {
     return enumeration<typeof ${messageDef.name}>(${messageDef.name})
   }
-}
-`
+}`.trim()
   }
 
   let nested = ''
@@ -151,11 +150,10 @@ export namespace ${messageDef.name} {
     nested = '\n'
     nested += Object.values(messageDef.nested)
       .map(def => compileMessage(def, moduleDef).trim())
-      .join('\n')
+      .join('\n\n')
       .split('\n')
       .map(line => line.trim() === '' ? '' : `  ${line}`)
       .join('\n')
-    nested += '\n'
   }
 
   const fields = messageDef.fields ?? {}
@@ -164,18 +162,26 @@ export namespace ${messageDef.name} {
   moduleDef.imports.add('encodeMessage')
   moduleDef.imports.add('decodeMessage')
   moduleDef.imports.add('message')
+  moduleDef.importedTypes.add('Codec')
 
-  return `
+  const interfaceFields = defineFields(fields, messageDef, moduleDef)
+    .join('\n  ')
+    .trim()
+
+  let interfaceDef = ''
+  let interfaceCodecDef = ''
+
+  if (interfaceFields !== '') {
+    interfaceDef = `
 export interface ${messageDef.name} {
   ${
     defineFields(fields, messageDef, moduleDef)
       .join('\n  ')
       .trim()
   }
-}
-
-export namespace ${messageDef.name} {${nested}
-  export const codec = () => {
+}`
+    interfaceCodecDef = `
+  export const codec = (): Codec<${messageDef.name}> => {
     return message<${messageDef.name}>({
       ${Object.entries(fields)
       .map(([name, fieldDef]) => {
@@ -207,13 +213,21 @@ export namespace ${messageDef.name} {${nested}
 
   export const decode = (buf: Uint8Array): ${messageDef.name} => {
     return decodeMessage(buf, ${messageDef.name}.codec())
+  }`
   }
+
+  return `
+${interfaceDef}
+
+export namespace ${messageDef.name} {
+  ${`${nested}${nested !== '' && interfaceCodecDef !== '' ? '\n' : ''}${interfaceCodecDef}`.trim()}
 }
-`
+`.trimStart()
 }
 
 interface ModuleDef {
   imports: Set<string>
+  importedTypes: Set<string>
   types: Set<string>
   compiled: string[]
   globals: Record<string, ClassDef>
@@ -222,6 +236,7 @@ interface ModuleDef {
 function defineModule (def: ClassDef): ModuleDef {
   const moduleDef: ModuleDef = {
     imports: new Set(),
+    importedTypes: new Set(),
     types: new Set(),
     compiled: [],
     globals: {}
@@ -273,14 +288,27 @@ export async function generate (source: string, flags: any) {
   const def = JSON.parse(json)
   const moduleDef = defineModule(def)
 
-  const content = `
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-namespace */
+  let lines = [
+    '/* eslint-disable import/export */',
+    '/* eslint-disable @typescript-eslint/no-namespace */',
+    ''
+  ]
+
+  if (moduleDef.imports.size > 0) {
+    lines.push(`import { ${Array.from(moduleDef.imports).join(', ')} } from 'protons-runtime'`)
+  }
+
+  if (moduleDef.importedTypes.size > 0) {
+    lines.push(`import type { ${Array.from(moduleDef.importedTypes).join(', ')} } from 'protons-runtime'`)
+  }
 
-import { ${Array.from(moduleDef.imports).join(', ')} } from 'protons-runtime'
+  lines = [
+    ...lines,
+    '',
+    ...moduleDef.compiled
+  ]
 
-${moduleDef.compiled.map(str => str.trim()).join('\n\n').trim()}
-`.trim()
+  const content = lines.join('\n').trim()
 
   await fs.writeFile(pathWithExtension(source, '.ts'), content + '\n')
 }

packages/protons/test/fixtures/basic.ts

@@ -2,23 +2,26 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 
 import { encodeMessage, decodeMessage, message, string, int32 } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
 
 export interface Basic {
   foo: string
   num: number
 }
 
 export namespace Basic {
-  export const codec = message<Basic>({
-    1: { name: 'foo', codec: string },
-    2: { name: 'num', codec: int32 }
-  })
+  export const codec = (): Codec<Basic> => {
+    return message<Basic>({
+      1: { name: 'foo', codec: string },
+      2: { name: 'num', codec: int32 }
+    })
+  }
 
   export const encode = (obj: Basic): Uint8Array => {
-    return encodeMessage(obj, Basic.codec)
+    return encodeMessage(obj, Basic.codec())
   }
 
   export const decode = (buf: Uint8Array): Basic => {
-    return decodeMessage(buf, Basic.codec)
+    return decodeMessage(buf, Basic.codec())
   }
 }