@yume-chan/scrcpy 3.0.0-beta.0 → 3.0.0-beta.1

package/src/2_1/options.ts

@@ -2,56 +2,70 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
 
 import type {
+    MapBoolean,
     ScrcpyAudioStreamMetadata,
     ScrcpyDisplay,
     ScrcpyEncoder,
-    ScrcpyMediaStreamPacket,
     ScrcpyOptions,
     ScrcpyOptionsListEncoders,
     ScrcpyScrollController,
     ScrcpyVideoStream,
+    ScrcpyVideoStreamPacket,
 } from "../base/index.js";
 import { ScrcpyDeviceMessageParsers } from "../base/index.js";
 import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
 } from "../latest.js";
 
-import type { Init } from "./impl/index.js";
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
 import {
     AckClipboardHandler,
     ClipboardStream,
+    computeOptionValues,
     ControlMessageTypes,
     createMediaStreamTransformer,
     createScrollController,
     Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
     parseAudioStreamMetadata,
     parseDisplay,
     parseEncoder,
+    parseVideoCodecOption,
     parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
     serialize,
     serializeBackOrScreenOnControlMessage,
     serializeInjectTouchControlMessage,
     serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
     setListDisplays,
     setListEncoders,
 } from "./impl/index.js";
 
-export class ScrcpyOptions2_1<TVideo extends boolean>
-    implements ScrcpyOptions<Init<TVideo>>, ScrcpyOptionsListEncoders
+export class ScrcpyOptions2_1<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ScrcpyOptions2_1.Value<TInit>>,
+        ScrcpyOptionsListEncoders
 {
     static readonly Defaults = Defaults;
 
-    readonly value: Required<Init<TVideo>>;
+    readonly value: ScrcpyOptions2_1.Value<TInit>;
 
     get controlMessageTypes(): typeof ControlMessageTypes {
         return ControlMessageTypes;
     }
 
     #clipboard: ClipboardStream | undefined;
-    get clipboard(): ReadableStream<string> | undefined {
-        return this.#clipboard;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
     }
 
     #ackClipboardHandler: AckClipboardHandler | undefined;
@@ -61,8 +75,8 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
         return this.#deviceMessageParsers;
     }
 
-    constructor(init: Init<TVideo>) {
-        this.value = { ...Defaults, ...init } as never;
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
 
         if (this.value.control) {
             if (this.value.clipboardAutosync) {
@@ -78,7 +92,7 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     }
 
     serialize(): string[] {
-        return serialize<Init<boolean>>(this.value, Defaults);
+        return serialize(this.value, Defaults);
     }
 
     setListDisplays(): void {
@@ -100,18 +114,29 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     parseVideoStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyVideoStream> {
-        return parseVideoStreamMetadata(this.value, stream);
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendCodecMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
     }
 
     parseAudioStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
-        return parseAudioStreamMetadata(stream, this.value);
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
     }
 
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyMediaStreamPacket
+        ScrcpyVideoStreamPacket
     > {
         return createMediaStreamTransformer(this.value);
     }
@@ -119,31 +144,57 @@ export class ScrcpyOptions2_1<TVideo extends boolean>
     serializeInjectTouchControlMessage(
         message: ScrcpyInjectTouchControlMessage,
     ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeInjectTouchControlMessage(message);
     }
 
     serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnControlMessage,
     ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeBackOrScreenOnControlMessage(message);
     }
 
     serializeSetClipboardControlMessage(
         message: ScrcpySetClipboardControlMessage,
     ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeSetClipboardControlMessage(
             message,
             this.#ackClipboardHandler,
         );
     }
 
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
     createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return createScrollController();
     }
 }
 
-type Init_<TVideo extends boolean> = Init<TVideo>;
+type Init_ = Init;
 
 export namespace ScrcpyOptions2_1 {
-    export type Init<TVideo extends boolean = boolean> = Init_<TVideo>;
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
 }

package/src/2_2/generate-type-tests.js

@@ -0,0 +1,106 @@
+/// <reference types="node" />
+
+import { writeFileSync } from "node:fs";
+import { format } from "prettier";
+
+let content = `
+// Generated by generate-type-tests.js. Do not edit manually.
+
+import type {ReadableStream} from "@yume-chan/stream-extra";
+
+import type {ScrcpyOptions2_2} from "./options.js";
+
+type Equal<X, Y> =
+    (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+        ? true
+        : false;
+
+function expectTrue<T extends true>(value?: T) { void value; }
+
+`;
+
+const controlValues = ["true", "false", "undefined"];
+const videoSourceValues = [`"display"`, `"camera"`, "undefined"];
+
+/**
+ * @param {string[]} values
+ */
+function* powerSetExceptEmpty(values) {
+    /**
+     * @param {number} start
+     * @param {string[]} combo
+     * @returns {Generator<string[], void, unknown>}
+     */
+    function* backtrack(start, combo) {
+        if (combo.length > 0) {
+            yield [...combo];
+        }
+
+        for (let i = start; i < values.length; i++) {
+            combo.push(values[i]);
+            yield* backtrack(i + 1, combo);
+            combo.pop();
+        }
+    }
+
+    yield* backtrack(0, []);
+}
+
+/**
+ *
+ * @param {string[]} control
+ * @param {string[]} videoSource
+ * @param {string} expectedType
+ * @returns {string}
+ */
+function generateCase(control, videoSource, expectedType) {
+    return `
+expectTrue<Equal<ScrcpyOptions2_2<{control:${control.join("|")}, videoSource:${videoSource.join("|")}}>["clipboard"], ${expectedType}>>();
+    `.trim();
+}
+
+for (const control of powerSetExceptEmpty(controlValues)) {
+    content += `\n// #region control: ${control.join(" | ")}\n`;
+
+    for (const videoSource of powerSetExceptEmpty(videoSourceValues)) {
+        const willDisableControl =
+            videoSource.length === 1 && videoSource[0] === `"camera"`;
+        if (willDisableControl) {
+            content += generateCase(control, videoSource, "undefined");
+            continue;
+        }
+
+        const controlDefinitelyDisabled =
+            control.length === 1 && control[0] === "false";
+
+        const mayDisableControl = videoSource.includes(`"camera"`);
+        if (mayDisableControl) {
+            content += generateCase(
+                control,
+                videoSource,
+                controlDefinitelyDisabled
+                    ? "undefined"
+                    : "ReadableStream<string> | undefined",
+            );
+            continue;
+        }
+
+        const controlMaybeDisabled = control.includes("false");
+
+        content += generateCase(
+            control,
+            videoSource,
+            controlDefinitelyDisabled
+                ? "undefined"
+                : controlMaybeDisabled
+                  ? "ReadableStream<string> | undefined"
+                  : "ReadableStream<string>",
+        );
+    }
+
+    content += `\n// #endregion\n`;
+}
+
+content = await format(content, { parser: "typescript", tabWidth: 4 });
+
+writeFileSync(new URL("./type-tests.spec.ts", import.meta.url), content);

package/src/2_2/impl/compute-option-values.ts

@@ -0,0 +1,44 @@
+import type { ComputeOptionTypes as ComputeOptionTypes1_15 } from "../../1_15/impl/index.js";
+import { computeOptionValues as computeOptionValues1_15 } from "../../1_15/impl/index.js";
+
+import { PrevImpl } from "./prev.js";
+
+// Distributive Conditional Types
+// (https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types)
+type ComputeControl<TVideoSource, TControl> = TVideoSource extends "camera"
+    ? false
+    : TControl;
+
+type OverrideControl<T> = Omit<T, "control"> & {
+    control: ComputeControl<
+        T extends { videoSource: infer TVideoSource } ? TVideoSource : never,
+        T extends { control: infer TControl } ? TControl : never
+    >;
+};
+
+export type ComputeOptionTypes<
+    T extends object,
+    TDefaults extends object,
+> = PrevImpl.OverrideClipboardAutosync<
+    OverrideControl<ComputeOptionTypes1_15<T, TDefaults>>
+>;
+
+export function computeOptionValues<
+    T extends {
+        videoSource?: string | undefined;
+        control?: boolean | undefined;
+        clipboardAutosync?: boolean | undefined;
+    },
+    TDefaults extends {
+        videoSource: string;
+        control: boolean;
+        clipboardAutosync: boolean;
+    },
+>(options: T, defaults: TDefaults): ComputeOptionTypes<T, TDefaults> {
+    const value = computeOptionValues1_15(options, defaults);
+    if (value.videoSource !== "display") {
+        value.control = false as never;
+    }
+    PrevImpl.overrideClipboardAutosync(value as never);
+    return value as never;
+}

package/src/2_2/impl/defaults.ts

@@ -13,4 +13,4 @@ export const Defaults = {
     cameraHighSpeed: false,
     listCameras: false,
     listCameraSizes: false,
-} as const satisfies Required<Init<true>>;
+} as const satisfies Required<Init>;

package/src/2_2/impl/index.ts

@@ -1,4 +1,6 @@
 export * from "../../2_1/impl/index.js";
+export { computeOptionValues } from "./compute-option-values.js";
+export type { ComputeOptionTypes } from "./compute-option-values.js";
 export { Defaults } from "./defaults.js";
 export type { Init } from "./init.js";
 export { parseDisplay } from "./parse-display.js";

package/src/2_2/impl/init.ts

@@ -1,14 +1,14 @@
 import type { PrevImpl } from "./prev.js";
 
-export interface Init<TVideo extends boolean> extends PrevImpl.Init<TVideo> {
-    videoSource?: "display" | "camera";
+export interface Init extends PrevImpl.Init {
+    videoSource?: "display" | "camera" | undefined;
     cameraId?: string | undefined;
     cameraSize?: string | undefined;
     cameraFacing?: "front" | "back" | "external" | undefined;
     cameraAr?: string | undefined;
     cameraFps?: number | undefined;
-    cameraHighSpeed?: boolean;
+    cameraHighSpeed?: boolean | undefined;
 
-    listCameras?: boolean;
-    listCameraSizes?: boolean;
+    listCameras?: boolean | undefined;
+    listCameraSizes?: boolean | undefined;
 }

package/src/2_2/options.ts

@@ -2,56 +2,70 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { ReadableStream, TransformStream } from "@yume-chan/stream-extra";
 
 import type {
+    MapBoolean,
     ScrcpyAudioStreamMetadata,
     ScrcpyDisplay,
     ScrcpyEncoder,
-    ScrcpyMediaStreamPacket,
     ScrcpyOptions,
     ScrcpyOptionsListEncoders,
     ScrcpyScrollController,
     ScrcpyVideoStream,
+    ScrcpyVideoStreamPacket,
 } from "../base/index.js";
 import { ScrcpyDeviceMessageParsers } from "../base/index.js";
 import type {
     ScrcpyBackOrScreenOnControlMessage,
     ScrcpyInjectTouchControlMessage,
     ScrcpySetClipboardControlMessage,
+    ScrcpySetDisplayPowerControlMessage,
 } from "../latest.js";
 
-import type { Init } from "./impl/index.js";
+import type { ComputeOptionTypes, Init } from "./impl/index.js";
 import {
     AckClipboardHandler,
     ClipboardStream,
+    computeOptionValues,
     ControlMessageTypes,
     createMediaStreamTransformer,
     createScrollController,
     Defaults,
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
     parseAudioStreamMetadata,
     parseDisplay,
     parseEncoder,
+    parseVideoCodecOption,
     parseVideoStreamMetadata,
+    parseVideoStreamMetadataAsync,
     serialize,
     serializeBackOrScreenOnControlMessage,
     serializeInjectTouchControlMessage,
     serializeSetClipboardControlMessage,
+    serializeSetDisplayPowerControlMessage,
     setListDisplays,
     setListEncoders,
 } from "./impl/index.js";
 
-export class ScrcpyOptions2_2<TVideo extends boolean>
-    implements ScrcpyOptions<Init<TVideo>>, ScrcpyOptionsListEncoders
+export class ScrcpyOptions2_2<TInit extends Init = Init>
+    implements
+        ScrcpyOptions<ScrcpyOptions2_2.Value<TInit>>,
+        ScrcpyOptionsListEncoders
 {
     static readonly Defaults = Defaults;
 
-    readonly value: Required<Init<TVideo>>;
+    readonly value: ScrcpyOptions2_2.Value<TInit>;
 
     get controlMessageTypes(): typeof ControlMessageTypes {
         return ControlMessageTypes;
     }
 
     #clipboard: ClipboardStream | undefined;
-    get clipboard(): ReadableStream<string> | undefined {
-        return this.#clipboard;
+    get clipboard(): MapBoolean<
+        this["value"]["clipboardAutosync"],
+        ReadableStream<string>,
+        undefined
+    > {
+        return this.#clipboard as never;
     }
 
     #ackClipboardHandler: AckClipboardHandler | undefined;
@@ -61,12 +75,8 @@ export class ScrcpyOptions2_2<TVideo extends boolean>
         return this.#deviceMessageParsers;
     }
 
-    constructor(init: Init<TVideo>) {
-        this.value = { ...Defaults, ...init } as never;
-
-        if (this.value.videoSource === "camera") {
-            this.value.control = false;
-        }
+    constructor(init: TInit) {
+        this.value = computeOptionValues(init, Defaults);
 
         if (this.value.control) {
             if (this.value.clipboardAutosync) {
@@ -82,7 +92,7 @@ export class ScrcpyOptions2_2<TVideo extends boolean>
     }
 
     serialize(): string[] {
-        return serialize<Init<boolean>>(this.value, Defaults);
+        return serialize(this.value, Defaults);
     }
 
     setListDisplays(): void {
@@ -104,18 +114,29 @@ export class ScrcpyOptions2_2<TVideo extends boolean>
     parseVideoStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyVideoStream> {
-        return parseVideoStreamMetadata(this.value, stream);
+        return parseVideoStreamMetadata(
+            stream,
+            this.value.sendDeviceMeta,
+            this.value.sendCodecMeta,
+            parseVideoCodecOption(this.value.videoCodec),
+            parseVideoStreamMetadataAsync,
+        );
     }
 
     parseAudioStreamMetadata(
         stream: ReadableStream<Uint8Array>,
     ): MaybePromiseLike<ScrcpyAudioStreamMetadata> {
-        return parseAudioStreamMetadata(stream, this.value);
+        return parseAudioStreamMetadata(
+            stream,
+            this.value.sendCodecMeta,
+            parseAudioMetadataCodec,
+            parseAudioCodecOption(this.value.audioCodec),
+        );
     }
 
     createMediaStreamTransformer(): TransformStream<
         Uint8Array,
-        ScrcpyMediaStreamPacket
+        ScrcpyVideoStreamPacket
     > {
         return createMediaStreamTransformer(this.value);
     }
@@ -123,31 +144,57 @@ export class ScrcpyOptions2_2<TVideo extends boolean>
     serializeInjectTouchControlMessage(
         message: ScrcpyInjectTouchControlMessage,
     ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeInjectTouchControlMessage(message);
     }
 
     serializeBackOrScreenOnControlMessage(
         message: ScrcpyBackOrScreenOnControlMessage,
     ): Uint8Array | undefined {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeBackOrScreenOnControlMessage(message);
     }
 
     serializeSetClipboardControlMessage(
         message: ScrcpySetClipboardControlMessage,
     ): Uint8Array | [Uint8Array, Promise<void>] {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return serializeSetClipboardControlMessage(
             message,
             this.#ackClipboardHandler,
         );
     }
 
+    serializeSetDisplayPowerControlMessage(
+        message: ScrcpySetDisplayPowerControlMessage,
+    ): Uint8Array {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
+        return serializeSetDisplayPowerControlMessage(message);
+    }
+
     createScrollController(): ScrcpyScrollController {
+        if (!this.value.control) {
+            throw new Error("control is disabled");
+        }
         return createScrollController();
     }
 }
 
-type Init_<TVideo extends boolean> = Init<TVideo>;
+type Init_ = Init;
 
 export namespace ScrcpyOptions2_2 {
-    export type Init<TVideo extends boolean = boolean> = Init_<TVideo>;
+    export type Init = Init_;
+
+    export type Value<TInit extends Init> = ComputeOptionTypes<
+        TInit,
+        typeof Defaults
+    >;
 }

package/src/2_3/impl/index.ts

@@ -1,2 +1,6 @@
 export * from "../../2_2/impl/index.js";
 export type { Init } from "./init.js";
+export {
+    parseAudioCodecOption,
+    parseAudioMetadataCodec,
+} from "./parse-audio-stream-metadata.js";

package/src/2_3/impl/init.ts

@@ -1,8 +1,5 @@
 import type { PrevImpl } from "./prev.js";
 
-export interface Init<TVideo extends boolean> extends Omit<
-    PrevImpl.Init<TVideo>,
-    "audioCodec"
-> {
-    audioCodec?: PrevImpl.Init<TVideo>["audioCodec"] | "flac";
+export interface Init extends Omit<PrevImpl.Init, "audioCodec"> {
+    audioCodec?: PrevImpl.Init["audioCodec"] | "flac";
 }

package/src/2_3/impl/parse-audio-stream-metadata.ts

@@ -0,0 +1,36 @@
+import { ScrcpyAudioCodec } from "../../base/index.js";
+
+import type { Init } from "./init.js";
+
+export function parseAudioMetadataCodec(codec: number): ScrcpyAudioCodec {
+    switch (codec) {
+        case ScrcpyAudioCodec.Raw.metadataValue:
+            return ScrcpyAudioCodec.Raw;
+        case ScrcpyAudioCodec.Opus.metadataValue:
+            return ScrcpyAudioCodec.Opus;
+        case ScrcpyAudioCodec.Aac.metadataValue:
+            return ScrcpyAudioCodec.Aac;
+        case ScrcpyAudioCodec.Flac.metadataValue:
+            return ScrcpyAudioCodec.Flac;
+        default:
+            throw new Error(`Unknown audio codec metadata value: ${codec}`);
+    }
+}
+
+export function parseAudioCodecOption(
+    audioCodec: Exclude<Init["audioCodec"], undefined>,
+): ScrcpyAudioCodec {
+    switch (audioCodec) {
+        case "raw":
+            return ScrcpyAudioCodec.Raw;
+        case "opus":
+            return ScrcpyAudioCodec.Opus;
+        case "aac":
+            return ScrcpyAudioCodec.Aac;
+        case "flac":
+            return ScrcpyAudioCodec.Flac;
+        default:
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            throw new Error(`Unknown audio codec: ${audioCodec}`);
+    }
+}