@yume-chan/adb 0.0.15 → 0.0.17

package/src/commands/sync/response.ts

@@ -1,64 +1,68 @@
-import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
-import type { AdbBufferedStream } from '../../stream/index.js';
-import { decodeUtf8 } from "../../utils/index.js";
-
-export enum AdbSyncResponseId {
-    Entry = 'DENT',
-    Entry2 = 'DNT2',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Done = 'DONE',
-    Data = 'DATA',
-    Ok = 'OKAY',
-    Fail = 'FAIL',
-}
-
-// DONE responses' size are always same as the request's normal response.
-// For example DONE responses for LIST requests are 16 bytes (same as DENT responses),
-// but DONE responses for STAT requests are 12 bytes (same as STAT responses)
-// So we need to know responses' size in advance.
-export class AdbSyncDoneResponse implements StructLike<AdbSyncDoneResponse> {
-    private length: number;
-
-    public readonly id = AdbSyncResponseId.Done;
-
-    public constructor(length: number) {
-        this.length = length;
-    }
-
-    public async deserialize(stream: StructAsyncDeserializeStream): Promise<this> {
-        await stream.read(this.length);
-        return this;
-    }
-}
-
-export const AdbSyncFailResponse =
-    new Struct({ littleEndian: true })
-        .uint32('messageLength')
-        .string('message', { lengthField: 'messageLength' })
-        .postDeserialize(object => {
-            throw new Error(object.message);
-        });
-
-export async function adbSyncReadResponse<T extends Record<string, StructLike<any>>>(
-    stream: AdbBufferedStream,
-    types: T,
-    // When `T` is a union type, `T[keyof T]` only includes their common keys.
-    // For example, let `type T = { a: string, b: string } | { a: string, c: string}`,
-    // `keyof T` is `'a'`, not `'a' | 'b' | 'c'`.
-    // However, `T extends unknown ? keyof T : never` will distribute `T`,
-    // so returns all keys.
-): Promise<StructValueType<T extends unknown ? T[keyof T] : never>> {
-    const id = decodeUtf8(await stream.read(4));
-
-    if (id === AdbSyncResponseId.Fail) {
-        await AdbSyncFailResponse.deserialize(stream);
-    }
-
-    if (types[id]) {
-        return types[id]!.deserialize(stream);
-    }
-
-    throw new Error(`Expected '${Object.keys(types).join(', ')}', but got '${id}'`);
-}
+import type { BufferedReadableStream } from '@yume-chan/stream-extra';
+import Struct, { StructValueType, type StructLike } from '@yume-chan/struct';
+
+import { decodeUtf8 } from '../../utils/index.js';
+
+export enum AdbSyncResponseId {
+    Entry = 'DENT',
+    Entry2 = 'DNT2',
+    Lstat = 'STAT',
+    Stat = 'STA2',
+    Lstat2 = 'LST2',
+    Done = 'DONE',
+    Data = 'DATA',
+    Ok = 'OKAY',
+    Fail = 'FAIL',
+}
+
+export const AdbSyncFailResponse =
+    new Struct({ littleEndian: true })
+        .uint32('messageLength')
+        .string('message', { lengthField: 'messageLength' })
+        .postDeserialize(object => {
+            throw new Error(object.message);
+        });
+
+export async function adbSyncReadResponse<T>(
+    stream: BufferedReadableStream,
+    id: AdbSyncResponseId,
+    type: StructLike<T>,
+): Promise<T> {
+    const actualId = decodeUtf8(await stream.read(4));
+    switch (actualId) {
+        case AdbSyncResponseId.Fail:
+            await AdbSyncFailResponse.deserialize(stream);
+            throw new Error('Unreachable');
+        case id:
+            return await type.deserialize(stream);
+        default:
+            throw new Error(`Expected '${id}', but got '${actualId}'`);
+    }
+}
+
+export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>>(
+    stream: BufferedReadableStream,
+    id: AdbSyncResponseId,
+    type: T,
+): AsyncGenerator<StructValueType<T>, void, void> {
+    while (true) {
+        const actualId = decodeUtf8(await stream.read(4));
+        switch (actualId) {
+            case AdbSyncResponseId.Fail:
+                await AdbSyncFailResponse.deserialize(stream);
+                throw new Error('Unreachable');
+            case AdbSyncResponseId.Done:
+                // `DONE` responses' size are always same as the request's normal response.
+                //
+                // For example, `DONE` responses for `LIST` requests are 16 bytes (same as `DENT` responses),
+                // but `DONE` responses for `STAT` requests are 12 bytes (same as `STAT` responses).
+                await stream.read(type.size);
+                return;
+            case id:
+                yield await type.deserialize(stream);
+                break;
+            default:
+                throw new Error(`Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`);
+        }
+    }
+}

package/src/commands/sync/stat.ts

@@ -1,150 +1,129 @@
-import Struct, { placeholder } from '@yume-chan/struct';
-import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-
-// https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
-export enum LinuxFileType {
-    Directory = 0o04,
-    File = 0o10,
-    Link = 0o12,
-}
-
-export interface AdbSyncStat {
-    mode: number;
-    size: bigint;
-    mtime: bigint;
-    get type(): LinuxFileType;
-    get permission(): number;
-
-    uid?: number;
-    gid?: number;
-    atime?: bigint;
-    ctime?: bigint;
-}
-
-export const AdbSyncLstatResponse =
-    new Struct({ littleEndian: true })
-        .int32('mode')
-        .int32('size')
-        .int32('mtime')
-        .extra({
-            id: AdbSyncResponseId.Lstat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (object.mode === 0 &&
-                object.size === 0 &&
-                object.mtime === 0
-            ) {
-                throw new Error('lstat failed');
-            }
-        });
-
-export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
-
-export enum AdbSyncStatErrorCode {
-    SUCCESS = 0,
-    EACCES = 13,
-    EEXIST = 17,
-    EFAULT = 14,
-    EFBIG = 27,
-    EINTR = 4,
-    EINVAL = 22,
-    EIO = 5,
-    EISDIR = 21,
-    ELOOP = 40,
-    EMFILE = 24,
-    ENAMETOOLONG = 36,
-    ENFILE = 23,
-    ENOENT = 2,
-    ENOMEM = 12,
-    ENOSPC = 28,
-    ENOTDIR = 20,
-    EOVERFLOW = 75,
-    EPERM = 1,
-    EROFS = 30,
-    ETXTBSY = 26,
-}
-
-export const AdbSyncStatResponse =
-    new Struct({ littleEndian: true })
-        .uint32('error', placeholder<AdbSyncStatErrorCode>())
-        .uint64('dev')
-        .uint64('ino')
-        .uint32('mode')
-        .uint32('nlink')
-        .uint32('uid')
-        .uint32('gid')
-        .uint64('size')
-        .uint64('atime')
-        .uint64('mtime')
-        .uint64('ctime')
-        .extra({
-            id: AdbSyncResponseId.Stat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (object.error) {
-                throw new Error(AdbSyncStatErrorCode[object.error]);
-            }
-        });
-
-export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
-
-const STAT_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Stat]: AdbSyncStatResponse,
-};
-
-const LSTAT_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Lstat]: AdbSyncLstatResponse,
-};
-
-const LSTAT_V2_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Lstat2]: AdbSyncStatResponse,
-};
-
-export async function adbSyncLstat(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-    v2: boolean,
-): Promise<AdbSyncStat> {
-    let requestId: AdbSyncRequestId.Lstat | AdbSyncRequestId.Lstat2;
-    let responseType: typeof LSTAT_RESPONSE_TYPES | typeof LSTAT_V2_RESPONSE_TYPES;
-
-    if (v2) {
-        requestId = AdbSyncRequestId.Lstat2;
-        responseType = LSTAT_V2_RESPONSE_TYPES;
-    } else {
-        requestId = AdbSyncRequestId.Lstat;
-        responseType = LSTAT_RESPONSE_TYPES;
-    }
-
-    await adbSyncWriteRequest(writer, requestId, path);
-    const response = await adbSyncReadResponse(stream, responseType);
-
-    switch (response.id) {
-        case AdbSyncResponseId.Lstat:
-            return {
-                mode: response.mode,
-                size: BigInt(response.size),
-                mtime: BigInt(response.mtime),
-                get type() { return response.type; },
-                get permission() { return response.permission; },
-            };
-        default:
-            return response;
-    }
-}
-
-export async function adbSyncStat(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
-}
+import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import Struct, { placeholder } from '@yume-chan/struct';
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+
+// https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
+export enum LinuxFileType {
+    Directory = 0o04,
+    File = 0o10,
+    Link = 0o12,
+}
+
+export interface AdbSyncStat {
+    mode: number;
+    size: bigint;
+    mtime: bigint;
+    get type(): LinuxFileType;
+    get permission(): number;
+
+    uid?: number;
+    gid?: number;
+    atime?: bigint;
+    ctime?: bigint;
+}
+
+export const AdbSyncLstatResponse =
+    new Struct({ littleEndian: true })
+        .int32('mode')
+        .int32('size')
+        .int32('mtime')
+        .extra({
+            id: AdbSyncResponseId.Lstat as const,
+            get type() { return this.mode >> 12 as LinuxFileType; },
+            get permission() { return this.mode & 0b00001111_11111111; },
+        })
+        .postDeserialize((object) => {
+            if (
+                object.mode === 0 &&
+                object.size === 0 &&
+                object.mtime === 0
+            ) {
+                throw new Error('lstat failed');
+            }
+        });
+
+export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
+
+export enum AdbSyncStatErrorCode {
+    SUCCESS = 0,
+    EACCES = 13,
+    EEXIST = 17,
+    EFAULT = 14,
+    EFBIG = 27,
+    EINTR = 4,
+    EINVAL = 22,
+    EIO = 5,
+    EISDIR = 21,
+    ELOOP = 40,
+    EMFILE = 24,
+    ENAMETOOLONG = 36,
+    ENFILE = 23,
+    ENOENT = 2,
+    ENOMEM = 12,
+    ENOSPC = 28,
+    ENOTDIR = 20,
+    EOVERFLOW = 75,
+    EPERM = 1,
+    EROFS = 30,
+    ETXTBSY = 26,
+}
+
+export const AdbSyncStatResponse =
+    new Struct({ littleEndian: true })
+        .uint32('error', placeholder<AdbSyncStatErrorCode>())
+        .uint64('dev')
+        .uint64('ino')
+        .uint32('mode')
+        .uint32('nlink')
+        .uint32('uid')
+        .uint32('gid')
+        .uint64('size')
+        .uint64('atime')
+        .uint64('mtime')
+        .uint64('ctime')
+        .extra({
+            id: AdbSyncResponseId.Stat as const,
+            get type() { return this.mode >> 12 as LinuxFileType; },
+            get permission() { return this.mode & 0b00001111_11111111; },
+        })
+        .postDeserialize((object) => {
+            if (object.error) {
+                throw new Error(AdbSyncStatErrorCode[object.error]);
+            }
+        });
+
+export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
+
+export async function adbSyncLstat(
+    stream: BufferedReadableStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+    v2: boolean,
+): Promise<AdbSyncStat> {
+    if (v2) {
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat2, path);
+        return await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat2, AdbSyncStatResponse);
+    } else {
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat, path);
+        const response = await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat, AdbSyncLstatResponse);
+        return {
+            mode: response.mode,
+            // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
+            size: BigInt(response.size),
+            mtime: BigInt(response.mtime),
+            get type() { return response.type; },
+            get permission() { return response.permission; },
+        };
+    }
+}
+
+export async function adbSyncStat(
+    stream: BufferedReadableStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+): Promise<AdbSyncStatResponse> {
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
+    return await adbSyncReadResponse(stream, AdbSyncResponseId.Stat, AdbSyncStatResponse);
+}