@yume-chan/adb 0.0.13 → 0.0.16

package/src/commands/sync/list.ts

@@ -1,86 +1,86 @@
-import Struct from '@yume-chan/struct';
-import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
-
-export interface AdbSyncEntry extends AdbSyncStat {
-    name: string;
-}
-
-export const AdbSyncEntryResponse =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncLstatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry as const });
-
-export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
-
-export const AdbSyncEntry2Response =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncStatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry2 as const });
-
-export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
-
-const LIST_V1_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
-};
-
-const LIST_V2_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry2]: AdbSyncEntry2Response,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntry2Response.size),
-};
-
-export async function* adbSyncOpenDir(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-    v2: boolean,
-): AsyncGenerator<AdbSyncEntry, void, void> {
-    let requestId: AdbSyncRequestId.List | AdbSyncRequestId.List2;
-    let responseType: typeof LIST_V1_RESPONSE_TYPES | typeof LIST_V2_RESPONSE_TYPES;
-
-    if (v2) {
-        requestId = AdbSyncRequestId.List2;
-        responseType = LIST_V2_RESPONSE_TYPES;
-    } else {
-        requestId = AdbSyncRequestId.List;
-        responseType = LIST_V1_RESPONSE_TYPES;
-    }
-
-    await adbSyncWriteRequest(writer, requestId, path);
-
-    while (true) {
-        const response = await adbSyncReadResponse(stream, responseType);
-        switch (response.id) {
-            case AdbSyncResponseId.Entry:
-                yield {
-                    mode: response.mode,
-                    size: BigInt(response.size),
-                    mtime: BigInt(response.mtime),
-                    get type() { return response.type; },
-                    get permission() { return response.permission; },
-                    name: response.name,
-                };
-                break;
-            case AdbSyncResponseId.Entry2:
-                // `LST2` can return error codes for failed `lstat` calls.
-                // `LIST` just ignores them.
-                // But they only contain `name` so still pretty useless.
-                if (response.error !== 0) {
-                    continue;
-                }
-                yield response;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
-        }
-    }
-}
+import Struct from '@yume-chan/struct';
+import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
+
+export interface AdbSyncEntry extends AdbSyncStat {
+    name: string;
+}
+
+export const AdbSyncEntryResponse =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncLstatResponse)
+        .uint32('nameLength')
+        .string('name', { lengthField: 'nameLength' })
+        .extra({ id: AdbSyncResponseId.Entry as const });
+
+export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
+
+export const AdbSyncEntry2Response =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncStatResponse)
+        .uint32('nameLength')
+        .string('name', { lengthField: 'nameLength' })
+        .extra({ id: AdbSyncResponseId.Entry2 as const });
+
+export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
+
+const LIST_V1_RESPONSE_TYPES = {
+    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
+    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
+};
+
+const LIST_V2_RESPONSE_TYPES = {
+    [AdbSyncResponseId.Entry2]: AdbSyncEntry2Response,
+    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntry2Response.size),
+};
+
+export async function* adbSyncOpenDir(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+    v2: boolean,
+): AsyncGenerator<AdbSyncEntry, void, void> {
+    let requestId: AdbSyncRequestId.List | AdbSyncRequestId.List2;
+    let responseType: typeof LIST_V1_RESPONSE_TYPES | typeof LIST_V2_RESPONSE_TYPES;
+
+    if (v2) {
+        requestId = AdbSyncRequestId.List2;
+        responseType = LIST_V2_RESPONSE_TYPES;
+    } else {
+        requestId = AdbSyncRequestId.List;
+        responseType = LIST_V1_RESPONSE_TYPES;
+    }
+
+    await adbSyncWriteRequest(writer, requestId, path);
+
+    while (true) {
+        const response = await adbSyncReadResponse(stream, responseType);
+        switch (response.id) {
+            case AdbSyncResponseId.Entry:
+                yield {
+                    mode: response.mode,
+                    size: BigInt(response.size),
+                    mtime: BigInt(response.mtime),
+                    get type() { return response.type; },
+                    get permission() { return response.permission; },
+                    name: response.name,
+                };
+                break;
+            case AdbSyncResponseId.Entry2:
+                // `LST2` can return error codes for failed `lstat` calls.
+                // `LIST` just ignores them.
+                // But they only contain `name` so still pretty useless.
+                if (response.error !== 0) {
+                    continue;
+                }
+                yield response;
+                break;
+            case AdbSyncResponseId.Done:
+                return;
+            default:
+                throw new Error('Unexpected response id');
+        }
+    }
+}

package/src/commands/sync/pull.ts

@@ -1,43 +1,46 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream, ReadableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-
-export const AdbSyncDataResponse =
-    new Struct({ littleEndian: true })
-        .uint32('dataLength')
-        .uint8Array('data', { lengthField: 'dataLength' })
-        .extra({ id: AdbSyncResponseId.Data as const });
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
-};
-
-export function adbSyncPull(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-): ReadableStream<Uint8Array> {
-    return new ReadableStream<Uint8Array>({
-        async start() {
-            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
-        },
-        async pull(controller) {
-            const response = await adbSyncReadResponse(stream, ResponseTypes);
-            switch (response.id) {
-                case AdbSyncResponseId.Data:
-                    controller.enqueue(response.data!);
-                    break;
-                case AdbSyncResponseId.Done:
-                    controller.close();
-                    break;
-                default:
-                    throw new Error('Unexpected response id');
-            }
-        }
-    }, {
-        highWaterMark: 16 * 1024,
-        size(chunk) { return chunk.byteLength; }
-    });
-}
+import Struct from '@yume-chan/struct';
+import { AdbBufferedStream, ReadableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+
+export const AdbSyncDataResponse =
+    new Struct({ littleEndian: true })
+        .uint32('dataLength')
+        .uint8Array('data', { lengthField: 'dataLength' })
+        .extra({ id: AdbSyncResponseId.Data as const });
+
+const RESPONSE_TYPES = {
+    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
+    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
+};
+
+export function adbSyncPull(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+): ReadableStream<Uint8Array> {
+    return new ReadableStream<Uint8Array>({
+        async start() {
+            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
+        },
+        async pull(controller) {
+            const response = await adbSyncReadResponse(stream, RESPONSE_TYPES);
+            switch (response.id) {
+                case AdbSyncResponseId.Data:
+                    controller.enqueue(response.data!);
+                    break;
+                case AdbSyncResponseId.Done:
+                    controller.close();
+                    break;
+                default:
+                    throw new Error('Unexpected response id');
+            }
+        },
+        cancel() {
+            throw new Error(`Sync commands don't support cancel.`);
+        },
+    }, {
+        highWaterMark: 16 * 1024,
+        size(chunk) { return chunk.byteLength; }
+    });
+}

package/src/commands/sync/push.ts

@@ -1,41 +1,41 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { LinuxFileType } from './stat.js';
-
-export const AdbSyncOkResponse =
-    new Struct({ littleEndian: true })
-        .uint32('unused');
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
-};
-
-export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
-
-export function adbSyncPush(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    filename: string,
-    mode: number = (LinuxFileType.File << 12) | 0o666,
-    mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE,
-): WritableStream<Uint8Array> {
-    return pipeFrom(
-        new WritableStream<Uint8Array>({
-            async start() {
-                const pathAndMode = `${filename},${mode.toString()}`;
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Send, pathAndMode);
-            },
-            async write(chunk) {
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
-            },
-            async close() {
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
-                await adbSyncReadResponse(stream, ResponseTypes);
-            },
-        }),
-        new ChunkStream(packetSize)
-    );
-}
+import Struct from '@yume-chan/struct';
+import { AdbBufferedStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { LinuxFileType } from './stat.js';
+
+export const AdbSyncOkResponse =
+    new Struct({ littleEndian: true })
+        .uint32('unused');
+
+const ResponseTypes = {
+    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
+};
+
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+
+export function adbSyncPush(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    filename: string,
+    mode: number = (LinuxFileType.File << 12) | 0o666,
+    mtime: number = (Date.now() / 1000) | 0,
+    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE,
+): WritableStream<Uint8Array> {
+    return pipeFrom(
+        new WritableStream<Uint8Array>({
+            async start() {
+                const pathAndMode = `${filename},${mode.toString()}`;
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Send, pathAndMode);
+            },
+            async write(chunk) {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
+            },
+            async close() {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
+                await adbSyncReadResponse(stream, ResponseTypes);
+            },
+        }),
+        new ChunkStream(packetSize)
+    );
+}

package/src/commands/sync/request.ts

@@ -1,50 +1,50 @@
-import Struct from '@yume-chan/struct';
-import type { WritableStreamDefaultWriter } from "../../stream/index.js";
-import { encodeUtf8 } from "../../utils/index.js";
-
-export enum AdbSyncRequestId {
-    List = 'LIST',
-    List2 = 'LIS2',
-    Send = 'SEND',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Data = 'DATA',
-    Done = 'DONE',
-    Receive = 'RECV',
-}
-
-export const AdbSyncNumberRequest =
-    new Struct({ littleEndian: true })
-        .string('id', { length: 4 })
-        .uint32('arg');
-
-export const AdbSyncDataRequest =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncNumberRequest)
-        .uint8Array('data', { lengthField: 'arg' });
-
-export async function adbSyncWriteRequest(
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    id: AdbSyncRequestId | string,
-    value: number | string | Uint8Array
-): Promise<void> {
-    let buffer: Uint8Array;
-    if (typeof value === 'number') {
-        buffer = AdbSyncNumberRequest.serialize({
-            id,
-            arg: value,
-        });
-    } else if (typeof value === 'string') {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: encodeUtf8(value),
-        });
-    } else {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: value,
-        });
-    }
-    await writer.write(buffer);
-}
+import Struct from '@yume-chan/struct';
+import type { WritableStreamDefaultWriter } from "../../stream/index.js";
+import { encodeUtf8 } from "../../utils/index.js";
+
+export enum AdbSyncRequestId {
+    List = 'LIST',
+    List2 = 'LIS2',
+    Send = 'SEND',
+    Lstat = 'STAT',
+    Stat = 'STA2',
+    Lstat2 = 'LST2',
+    Data = 'DATA',
+    Done = 'DONE',
+    Receive = 'RECV',
+}
+
+export const AdbSyncNumberRequest =
+    new Struct({ littleEndian: true })
+        .string('id', { length: 4 })
+        .uint32('arg');
+
+export const AdbSyncDataRequest =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncNumberRequest)
+        .uint8Array('data', { lengthField: 'arg' });
+
+export async function adbSyncWriteRequest(
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    id: AdbSyncRequestId | string,
+    value: number | string | Uint8Array
+): Promise<void> {
+    let buffer: Uint8Array;
+    if (typeof value === 'number') {
+        buffer = AdbSyncNumberRequest.serialize({
+            id,
+            arg: value,
+        });
+    } else if (typeof value === 'string') {
+        buffer = AdbSyncDataRequest.serialize({
+            id,
+            data: encodeUtf8(value),
+        });
+    } else {
+        buffer = AdbSyncDataRequest.serialize({
+            id,
+            data: value,
+        });
+    }
+    await writer.write(buffer);
+}

package/src/commands/sync/response.ts

@@ -1,64 +1,64 @@
-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 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}'`);
+}