protons 7.7.0 → 8.0.1

package/src/types/module.ts

@@ -0,0 +1,234 @@
+import { NoMessagesFoundError } from 'protons-runtime'
+import { Enum, isEnumDef } from './enum.ts'
+import { Message } from './message.ts'
+import { Primitive } from './primitive.ts'
+import type { EnumDef } from './enum.ts'
+import type { MessageDef } from './message.ts'
+import type { Flags } from '../index.ts'
+import type { Type } from './index.ts'
+
+const types: Record<string, string> = {
+  bool: 'boolean',
+  bytes: 'Uint8Array',
+  double: 'number',
+  fixed32: 'number',
+  fixed64: 'bigint',
+  float: 'number',
+  int32: 'number',
+  int64: 'bigint',
+  sfixed32: 'number',
+  sfixed64: 'bigint',
+  sint32: 'number',
+  sint64: 'bigint',
+  string: 'string',
+  uint32: 'number',
+  uint64: 'bigint'
+}
+
+interface Import {
+  symbol: string
+  alias?: string
+  type: boolean
+}
+
+export interface ModuleDef {
+  nested?: Record<string, MessageDef | EnumDef>
+}
+
+export class Module {
+  private imports: Map<string, Import[]>
+  private types: Record<string, Type>
+  private eslintIgnores: string[]
+  public flags: Flags
+  public globals: Array<Message | Enum>
+
+  constructor (def: ModuleDef, flags: Flags) {
+    this.imports = new Map()
+    this.flags = flags
+    this.types = {}
+    this.globals = []
+    this.eslintIgnores = []
+
+    Object.entries(types).forEach(([pbType, jsType]) => {
+      this.types[pbType] = new Primitive(pbType, jsType)
+    })
+
+    const defs = def.nested
+
+    if (defs == null) {
+      throw new NoMessagesFoundError('No top-level messages found in protobuf')
+    }
+
+    for (const [name, def] of Object.entries(defs)) {
+      let type: Message | Enum
+
+      if (isEnumDef(def)) {
+        type = new Enum(name, name, def)
+      } else {
+        type = new Message(name, name, def, this)
+      }
+
+      this.globals.push(type)
+      this.types[name] = type
+    }
+
+    this.globals.forEach(type => type.init())
+  }
+
+  addImport (module: string, symbol: string, alias?: string): void {
+    const defs = this._findDefs(module)
+
+    for (const def of defs) {
+      // check if we already have a definition for this symbol
+      if (def.symbol === symbol) {
+        if (alias !== def.alias) {
+          throw new Error(`Type symbol ${symbol} imported from ${module} with alias ${def.alias} does not match alias ${alias}`)
+        }
+
+        // if it was a type before it's not now
+        def.type = false
+        return
+      }
+    }
+
+    defs.push({
+      symbol,
+      alias,
+      type: false
+    })
+  }
+
+  addTypeImport (module: string, symbol: string, alias?: string): void {
+    const defs = this._findDefs(module)
+
+    for (const def of defs) {
+      // check if we already have a definition for this symbol
+      if (def.symbol === symbol) {
+        if (alias !== def.alias) {
+          throw new Error(`Type symbol ${symbol} imported from ${module} with alias ${def.alias} does not match alias ${alias}`)
+        }
+
+        return
+      }
+    }
+
+    defs.push({
+      symbol,
+      alias,
+      type: true
+    })
+  }
+
+  addEslintIgnore (rule: string): void {
+    if (this.eslintIgnores.includes(rule)) {
+      return
+    }
+
+    this.eslintIgnores.push(rule)
+  }
+
+  _findDefs (module: string): Import[] {
+    let defs = this.imports.get(module)
+
+    if (defs == null) {
+      defs = []
+      this.imports.set(module, defs)
+    }
+
+    return defs
+  }
+
+  compile (): string {
+    const compiled = this.globals.map(def => def.compile(this)).flat()
+
+    // TODO: make these conditional
+    // const ignores: string[] = [
+    //   '/* eslint-disable import/export */',
+    //   '/* eslint-disable complexity */',
+    //   '/* eslint-disable @typescript-eslint/no-namespace */',
+    //   '/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */',
+    //   '/* eslint-disable @typescript-eslint/no-empty-interface */',
+    //   '/* eslint-disable import/consistent-type-specifier-style */',
+    //   '/* eslint-disable @typescript-eslint/no-unused-vars */',
+    //   '/* eslint-disable require-yield */'
+    // ]
+
+    const imports = []
+    const importedModules = Array.from([...this.imports.entries()])
+      .sort((a, b) => {
+        return a[0].localeCompare(b[0])
+      })
+      .sort((a, b) => {
+        const aAllTypes = a[1].reduce((acc, curr) => {
+          return acc && curr.type
+        }, true)
+
+        const bAllTypes = b[1].reduce((acc, curr) => {
+          return acc && curr.type
+        }, true)
+
+        if (aAllTypes && !bAllTypes) {
+          return 1
+        }
+
+        if (!aAllTypes && bAllTypes) {
+          return -1
+        }
+
+        return 0
+      })
+
+    // add imports
+    for (const imp of importedModules) {
+      const symbols = imp[1]
+        .filter(imp => !imp.type)
+        .sort((a, b) => {
+          return a.symbol.localeCompare(b.symbol)
+        }).map(imp => {
+          return `${imp.symbol}${imp.alias != null ? ` as ${imp.alias}` : ''}`
+        }).join(', ')
+
+      if (symbols.length > 0) {
+        imports.push(`import { ${symbols} } from '${imp[0]}'`)
+      }
+    }
+
+    // add type imports
+    for (const imp of importedModules) {
+      const symbols = imp[1]
+        .filter(imp => imp.type)
+        .sort((a, b) => {
+          return a.symbol.localeCompare(b.symbol)
+        }).map(imp => {
+          return `${imp.symbol}${imp.alias != null ? ` as ${imp.alias}` : ''}`
+        }).join(', ')
+
+      if (symbols.length > 0) {
+        imports.push(`import type { ${symbols} } from '${imp[0]}'`)
+      }
+    }
+
+    return [
+      ...this.eslintIgnores.map(rule => `/* eslint-disable ${rule} */`),
+      '',
+      ...imports,
+      '',
+      ...compiled
+    ]
+      .join('\n')
+      .split('\n')
+      .map((line) => line.trim() === '' ? '' : line)
+      .join('\n')
+      .trim()
+  }
+
+  findType (jsType: string, override?: 'string' | 'number'): Type {
+    const type = this.types[override ?? jsType]
+
+    if (type == null) {
+      throw new Error(`Type for "${jsType}"${override == null ? '' : ` (overridden to "${override}")`} not found in ${[...Object.keys(this.types)].join(', ')}`)
+    }
+
+    return type
+  }
+}

package/src/types/primitive.ts

@@ -0,0 +1,215 @@
+import { ArrayField } from '../fields/array-field.ts'
+import type { Type } from './index.ts'
+import type { Field } from '../fields/field.ts'
+
+const decoderGenerators: Record<string, (jsTypeOverride?: 'number' | 'string') => string> = {
+  bool: () => 'reader.bool()',
+  bytes: () => 'reader.bytes()',
+  double: () => 'reader.double()',
+  fixed32: () => 'reader.fixed32()',
+  fixed64: (jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return 'reader.fixed64Number()'
+    }
+
+    if (jsTypeOverride === 'string') {
+      return 'reader.fixed64String()'
+    }
+
+    return 'reader.fixed64()'
+  },
+  float: () => 'reader.float()',
+  int32: () => 'reader.int32()',
+  int64: (jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return 'reader.int64Number()'
+    }
+
+    if (jsTypeOverride === 'string') {
+      return 'reader.int64String()'
+    }
+
+    return 'reader.int64()'
+  },
+  sfixed32: () => 'reader.sfixed32()',
+  sfixed64: (jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return 'reader.sfixed64Number()'
+    }
+
+    if (jsTypeOverride === 'string') {
+      return 'reader.sfixed64String()'
+    }
+
+    return 'reader.sfixed64()'
+  },
+  sint32: () => 'reader.sint32()',
+  sint64: (jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return 'reader.sint64Number()'
+    }
+
+    if (jsTypeOverride === 'string') {
+      return 'reader.sint64String()'
+    }
+
+    return 'reader.sint64()'
+  },
+  string: () => 'reader.string()',
+  uint32: () => 'reader.uint32()',
+  uint64: (jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return 'reader.uint64Number()'
+    }
+
+    if (jsTypeOverride === 'string') {
+      return 'reader.uint64String()'
+    }
+
+    return 'reader.uint64()'
+  }
+}
+
+const encoderGenerators: Record<string, (val: string, jsTypeOverride?: 'number' | 'string') => string> = {
+  bool: (val) => `w.bool(${val})`,
+  bytes: (val) => `w.bytes(${val})`,
+  double: (val) => `w.double(${val})`,
+  fixed32: (val) => `w.fixed32(${val})`,
+  fixed64: (val, jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return `w.fixed64Number(${val})`
+    }
+
+    if (jsTypeOverride === 'string') {
+      return `w.fixed64String(${val})`
+    }
+
+    return `w.fixed64(${val})`
+  },
+  float: (val) => `w.float(${val})`,
+  int32: (val) => `w.int32(${val})`,
+  int64: (val, jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return `w.int64Number(${val})`
+    }
+
+    if (jsTypeOverride === 'string') {
+      return `w.int64String(${val})`
+    }
+
+    return `w.int64(${val})`
+  },
+  sfixed32: (val) => `w.sfixed32(${val})`,
+  sfixed64: (val, jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return `w.sfixed64Number(${val})`
+    }
+
+    if (jsTypeOverride === 'string') {
+      return `w.sfixed64String(${val})`
+    }
+
+    return `w.sfixed64(${val})`
+  },
+  sint32: (val) => `w.sint32(${val})`,
+  sint64: (val, jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return `w.sint64Number(${val})`
+    }
+
+    if (jsTypeOverride === 'string') {
+      return `w.sint64String(${val})`
+    }
+
+    return `w.sint64(${val})`
+  },
+  string: (val) => `w.string(${val})`,
+  uint32: (val) => `w.uint32(${val})`,
+  uint64: (val, jsTypeOverride) => {
+    if (jsTypeOverride === 'number') {
+      return `w.uint64Number(${val})`
+    }
+
+    if (jsTypeOverride === 'string') {
+      return `w.uint64String(${val})`
+    }
+
+    return `w.uint64(${val})`
+  }
+}
+
+interface DefaultValueTestGenerator {
+  (field: string): string
+}
+
+const defaultValueTestGenerators: Record<string, DefaultValueTestGenerator> = {
+  bool: (field) => `(${field} != null && ${field} !== false)`,
+  bytes: (field) => `(${field} != null && ${field}.byteLength > 0)`,
+  double: (field) => `(${field} != null && ${field} !== 0)`,
+  fixed32: (field) => `(${field} != null && ${field} !== 0)`,
+  fixed64: (field) => `(${field} != null && ${field} !== 0n)`,
+  float: (field) => `(${field} != null && ${field} !== 0)`,
+  int32: (field) => `(${field} != null && ${field} !== 0)`,
+  int64: (field) => `(${field} != null && ${field} !== 0n)`,
+  sfixed32: (field) => `(${field} != null && ${field} !== 0)`,
+  sfixed64: (field) => `(${field} != null && ${field} !== 0n)`,
+  sint32: (field) => `(${field} != null && ${field} !== 0)`,
+  sint64: (field) => `(${field} != null && ${field} !== 0n)`,
+  string: (field) => `(${field} != null && ${field} !== '')`,
+  uint32: (field) => `(${field} != null && ${field} !== 0)`,
+  uint64: (field) => `(${field} != null && ${field} !== 0n)`
+}
+
+const defaultValueTestGeneratorsJsTypeOverrides: Record<string, DefaultValueTestGenerator> = {
+  number: (field) => `(${field} != null && ${field} !== 0)`,
+  string: (field) => `(${field} != null && ${field} !== '')`
+}
+
+export class Primitive implements Type {
+  public jsType: string
+  public pbType: string
+
+  constructor (pbType: string, jsType: string) {
+    this.jsType = jsType
+    this.pbType = pbType
+  }
+
+  init (): void {
+
+  }
+
+  getDecoder (field: Field): string {
+    return decoderGenerators[this.pbType](field.jsTypeOverride)
+  }
+
+  getStreamingDecoder (field: Field, prefix: string): string {
+    const generator = decoderGenerators[this.pbType](field.jsTypeOverride)
+
+    if (field instanceof ArrayField) {
+      return `yield {
+                field: ${prefix},
+                index: obj.${field.name},
+                value: ${generator}
+              }`
+    }
+
+    return generator
+  }
+
+  getValueTest (field: Field, accessor: string): string {
+    // proto3 singular fields should only be written out if they are not the default value
+    if (!field.optional && !field.proto2Required) {
+      if (field.jsTypeOverride != null) {
+        return defaultValueTestGeneratorsJsTypeOverrides[field.jsTypeOverride](accessor)
+      }
+
+      return defaultValueTestGenerators[field.type](accessor)
+    }
+
+    return `${accessor} != null`
+  }
+
+  getEncoder (field: Field, accessor: string): string {
+    return encoderGenerators[this.pbType](accessor, field.jsTypeOverride)
+  }
+}

package/LICENSE

@@ -1,4 +0,0 @@
-This project is dual licensed under MIT and Apache-2.0.
-
-MIT: https://www.opensource.org/licenses/mit
-Apache-2.0: https://www.apache.org/licenses/license-2.0