diff --git a/packages/protobuf/package.json b/packages/protobuf/package.json new file mode 100644 index 00000000..df67a597 --- /dev/null +++ b/packages/protobuf/package.json @@ -0,0 +1,14 @@ +{ + "name": "@snowluma/protobuf", + "type": "module", + "version": "0.0.4", + "description": "A lightweight, elegant, and efficient protobuf-ts solution.From NapNeko/NapCatQQ", + "main": "./src/NapProto.ts", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1", + "prepack": "tsc" + }, + "dependencies": { + "@protobuf-ts/runtime": "^2.9.4" + } +} diff --git a/packages/protobuf/src/NapProto.ts b/packages/protobuf/src/NapProto.ts new file mode 100644 index 00000000..09e47c3a --- /dev/null +++ b/packages/protobuf/src/NapProto.ts @@ -0,0 +1,202 @@ +// @ts-nocheck +import { MessageType, PartialMessage, RepeatType, ScalarType } from '@protobuf-ts/runtime'; +import { PartialFieldInfo } from '@protobuf-ts/runtime/build/types/reflection-info'; + +export type LowerCamelCase = CamelCaseHelper; + +export type CamelCaseHelper< + S extends string, + CapNext extends boolean, + IsFirstChar extends boolean +> = S extends `${infer F}${infer R}` + ? F extends '_' + ? CamelCaseHelper + : F extends `${number}` + ? `${F}${CamelCaseHelper}` + : CapNext extends true + ? `${Uppercase}${CamelCaseHelper}` + : IsFirstChar extends true + ? `${Lowercase}${CamelCaseHelper}` + : `${F}${CamelCaseHelper}` + : ''; + +export type ScalarTypeToTsType = T extends + | ScalarType.DOUBLE + | ScalarType.FLOAT + | ScalarType.INT32 + | ScalarType.FIXED32 + | ScalarType.UINT32 + | ScalarType.SFIXED32 + | ScalarType.SINT32 + ? number + : T extends ScalarType.INT64 | ScalarType.UINT64 | ScalarType.FIXED64 | ScalarType.SFIXED64 | ScalarType.SINT64 + ? bigint + : T extends ScalarType.BOOL + ? boolean + : T extends ScalarType.STRING + ? string + : T extends ScalarType.BYTES + ? Uint8Array + : never; + +export interface BaseProtoFieldType { + kind: 'scalar' | 'message'; + no: number; + type: T; + optional: O; + repeat: R; +} + +export interface ScalarProtoFieldType + extends BaseProtoFieldType { + kind: 'scalar'; +} + +export interface MessageProtoFieldType< + T extends () => ProtoMessageType, + O extends boolean, + R extends O extends true ? false : boolean +> extends BaseProtoFieldType { + kind: 'message'; +} + +export type ProtoFieldType = + | ScalarProtoFieldType + | MessageProtoFieldType<() => ProtoMessageType, boolean, boolean>; + +export type ProtoMessageType = { + [key: string]: ProtoFieldType; +}; + +export function ProtoField< + T extends ScalarType, + O extends boolean = false, + R extends O extends true ? false : boolean = false +> (no: number, type: T, optional?: O, repeat?: R): ScalarProtoFieldType; +export function ProtoField< + T extends () => ProtoMessageType, + O extends boolean = false, + R extends O extends true ? false : boolean = false +> (no: number, type: T, optional?: O, repeat?: R): MessageProtoFieldType; +export function ProtoField ( + no: number, + type: ScalarType | (() => ProtoMessageType), + optional?: boolean, + repeat?: boolean +): ProtoFieldType { + if (typeof type === 'function') { + return { kind: 'message', no, type, optional: optional ?? false, repeat: repeat ?? false }; + } else { + return { kind: 'scalar', no, type, optional: optional ?? false, repeat: repeat ?? false }; + } +} + +export type ProtoFieldReturnType = + NonNullable extends ScalarProtoFieldType + ? ScalarTypeToTsType + : T extends NonNullable> + ? NonNullable, E>> + : never; + +export type RequiredFieldsBaseType = { + [K in keyof T as T[K] extends { optional: true; } ? never : LowerCamelCase]: T[K] extends { + repeat: true; + } + ? ProtoFieldReturnType[] + : ProtoFieldReturnType; +}; + +export type OptionalFieldsBaseType = { + [K in keyof T as T[K] extends { optional: true; } ? LowerCamelCase : never]?: T[K] extends { + repeat: true; + } + ? ProtoFieldReturnType[] + : ProtoFieldReturnType; +}; + +export type RequiredFieldsType = E extends true + ? Partial> + : RequiredFieldsBaseType; + +export type OptionalFieldsType = E extends true + ? Partial> + : OptionalFieldsBaseType; + +export type NapProtoStructType = RequiredFieldsType & OptionalFieldsType; + +export type NapProtoEncodeStructType = NapProtoStructType; + +export type NapProtoDecodeStructType = NapProtoStructType; + +class NapProtoRealMsg { + private readonly _field: PartialFieldInfo[]; + private readonly _proto_msg: MessageType>; + private static cache = new WeakMap>(); + + private constructor (fields: T) { + this._field = Object.keys(fields).map((key) => { + const field = fields[key]; + if (field.kind === 'scalar') { + const repeatType = field.repeat + ? [ScalarType.STRING, ScalarType.BYTES].includes(field.type) + ? RepeatType.UNPACKED + : RepeatType.PACKED + : RepeatType.NO; + return { + no: field.no, + name: key, + kind: 'scalar', + T: field.type, + opt: field.optional, + repeat: repeatType, + }; + } else if (field.kind === 'message') { + return { + no: field.no, + name: key, + kind: 'message', + repeat: field.repeat ? RepeatType.PACKED : RepeatType.NO, + T: () => NapProtoRealMsg.getInstance(field.type())._proto_msg, + }; + } else { + throw new Error(`Unknown field kind: ${field.kind}`); + } + }) as PartialFieldInfo[]; + this._proto_msg = new MessageType>('nya', this._field); + } + + static getInstance (fields: T): NapProtoRealMsg { + let instance = this.cache.get(fields); + if (!instance) { + instance = new NapProtoRealMsg(fields); + this.cache.set(fields, instance); + } + return instance; + } + + encode (data: NapProtoEncodeStructType): Uint8Array { + return this._proto_msg.toBinary(this._proto_msg.create(data as PartialMessage>)); + } + + decode (data: Uint8Array): NapProtoDecodeStructType { + return this._proto_msg.fromBinary(data) as NapProtoDecodeStructType; + } +} + +export class NapProtoMsg { + private realMsg: NapProtoRealMsg; + + constructor (fields: T) { + this.realMsg = NapProtoRealMsg.getInstance(fields); + } + + encode (data: NapProtoEncodeStructType): Uint8Array { + return this.realMsg.encode(data); + } + + decode (data: Uint8Array): NapProtoDecodeStructType { + return this.realMsg.decode(data); + } +} + +export { ScalarType } from '@protobuf-ts/runtime'; diff --git a/packages/protobuf/tsconfig.json b/packages/protobuf/tsconfig.json new file mode 100644 index 00000000..cd0e5b46 --- /dev/null +++ b/packages/protobuf/tsconfig.json @@ -0,0 +1,5 @@ +{ + "extends": "../../tsconfig.base.json", + "include": ["src/**/*"], + "exclude": ["node_modules"] +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index be5db7cb..3d3a1829 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -64,6 +64,12 @@ importers: specifier: ^4.1.4 version: 4.1.4(@types/node@24.12.2)(vite@8.0.8(@types/node@24.12.2)(esbuild@0.27.7)(jiti@2.6.1)(sass@1.99.0)(tsx@4.21.0)) + packages/protobuf: + dependencies: + '@protobuf-ts/runtime': + specifier: ^2.9.4 + version: 2.11.1 + packages/runtime: {} packages/sdk: @@ -680,6 +686,9 @@ packages: resolution: {integrity: sha512-tmmZ3lQxAe/k/+rNnXQRawJ4NjxO2hqiOLTHvWchtGZULp4RyFeh6aU4XdOYBFe2KE1oShQTv4AblOs2iOrNnQ==} engines: {node: '>= 10.0.0'} + '@protobuf-ts/runtime@2.11.1': + resolution: {integrity: sha512-KuDaT1IfHkugM2pyz+FwiY80ejWrkH1pAtOBOZFuR6SXEFTsnb/jiQWQ1rCIrcKx2BtyxnxW6BWwsVSA/Ie+WQ==} + '@radix-ui/number@1.1.1': resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==} @@ -3019,6 +3028,8 @@ snapshots: '@parcel/watcher-win32-x64': 2.5.6 optional: true + '@protobuf-ts/runtime@2.11.1': {} + '@radix-ui/number@1.1.1': {} '@radix-ui/primitive@1.1.3': {}