betterdisplaycli 0.1.17 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "betterdisplaycli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "description": "TypeScript bindings for `betterdisplaycli`.",
   "author": "Lucas Garron <code@garron.net>",
   "license": "MIT",

package/src/Device.ts

@@ -1,5 +1,6 @@
 import { PrintableShellCommand } from "printable-shell-command";
-import { print, type QuietOption } from "./get";
+import { getDisplayWithSelectorArg, print, type QuietOption } from "./get";
+import { isNotUndefined, ResolutionInfo } from "./ResolutionInfo";
 
 type BOOLEAN_SETTING = "connected" | "hiDPI" | "notch";
 type STRING_SETTING = "resolution";
@@ -135,12 +136,86 @@ class SingleDisplay extends Device {
       ).shellOut({ print: false });
     },
   };
+
+  resolution = {
+    get: async (): Promise<ResolutionInfo> => {
+      return ResolutionInfo.fromString(await this.string.get("resolution"));
+    },
+    // The return value indicates if any changes were needed (and performed)
+    set: async (
+      resolutionInfo: ResolutionInfo,
+      options?: QuietOption,
+    ): Promise<boolean> => {
+      const currentResolution = await this.resolution.get();
+
+      const args: string[] = [];
+      if (resolutionInfo.width !== currentResolution.width) {
+        args.push(`--width=${resolutionInfo.width}`);
+      }
+      if (resolutionInfo.width !== currentResolution.height) {
+        args.push(`--height=${resolutionInfo.height}`);
+      }
+      if (
+        isNotUndefined(resolutionInfo.hiDPI) &&
+        resolutionInfo.hiDPI !== currentResolution.hiDPI
+      ) {
+        args.push(`--hiDPI=${resolutionInfo.hiDPI}`);
+      }
+      if (
+        isNotUndefined(resolutionInfo.notch) &&
+        resolutionInfo.notch !== currentResolution.notch
+      ) {
+        args.push(`--notch=${resolutionInfo.notch ? "on" : "off"}`);
+      }
+
+      if (args.length === 0) {
+        // No changes to perform.
+        return false;
+      }
+
+      await print(
+        new PrintableShellCommand("betterdisplaycli", [
+          "set",
+          `--name=${this.info.name}`,
+          ...args,
+        ]),
+        { argumentLineWrapping: "inline" },
+        options,
+      ).shellOut({ print: false });
+      return true;
+    },
+  };
+
+  async connect(): Promise<void> {
+    await this.boolean.set("connected", true);
+  }
+
+  async disconnect(): Promise<void> {
+    await this.boolean.set("connected", false);
+  }
 }
 
 export class Display extends SingleDisplay {
   constructor(public override readonly info: DisplayInfo) {
     super(info);
   }
+
+  static main(): Promise<Display> {
+    return getDisplayWithSelectorArg("--displayWithMainStatus");
+  }
+
+  static fromName(name: string): Promise<Display> {
+    return getDisplayWithSelectorArg(`--name=${name}`);
+  }
+
+  static async tryFromName(name: string): Promise<Display | null> {
+    try {
+      return await getDisplayWithSelectorArg(`--name=${name}`);
+    } catch {
+      // TODO: what is the simplest way to verify this was because there was no such display (as opposed to a general invocation error)?
+      return null;
+    }
+  }
 }
 
 export class VirtualScreen extends SingleDisplay {

package/src/ResolutionInfo.ts

@@ -0,0 +1,93 @@
+// biome-ignore lint/suspicious/noExplicitAny: `any` is the correct API.
+export function isPositiveInteger(n: any): n is number {
+  return Number.isInteger(n) && n > 0;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: `any` is the correct API.
+export function isNotUndefined<T extends Exclude<any, undefined>>(
+  v: T | undefined,
+): v is T {
+  return typeof v !== "undefined";
+}
+
+export interface ResolutionInfoData {
+  width: number;
+  height: number;
+  pixelRatio?: number;
+  notch?: boolean;
+}
+
+export class ResolutionInfo {
+  #data: ResolutionInfoData;
+  constructor(data: ResolutionInfoData) {
+    this.#data = data;
+    if (!isPositiveInteger(data.width)) {
+      throw new Error("Invalid width (expected a positive integer).");
+    }
+    if (!isPositiveInteger(data.height)) {
+      throw new Error("Invalid height (expected a positive integer).");
+    }
+    if (
+      isNotUndefined(data.pixelRatio) &&
+      (!isPositiveInteger(data.pixelRatio) || ![1, 2].includes(data.pixelRatio))
+    ) {
+      throw new Error("Invalid pixel ratio (expected 1 or 2 if set).");
+    }
+    if (isNotUndefined(data.notch) && typeof data.notch !== "boolean") {
+      throw new Error("Invalid notch (expected boolean if present).");
+    }
+  }
+
+  get width(): number {
+    return this.#data.width;
+  }
+
+  get height(): number {
+    return this.#data.height;
+  }
+
+  get pixelRatio(): number | undefined {
+    return this.#data.pixelRatio;
+  }
+
+  get hiDPI(): boolean | undefined {
+    if (isNotUndefined(this.pixelRatio)) {
+      return this.pixelRatio === 2;
+    }
+    return undefined;
+  }
+
+  get notch(): boolean | undefined {
+    return this.#data.notch;
+  }
+
+  static fromString(s: string): ResolutionInfo {
+    const match = s.match(
+      /^([1-9][0-9]*)[x×]([1-9][0-9]*)+(@([1-9][0-9]*)x)?([+-]notch)?$/,
+    );
+    console.log({ s, match });
+    if (!match) {
+      throw new Error("Invalid resolution info.");
+    }
+    const width = parseInt(match[1], 10);
+    const height = parseInt(match[2], 10);
+    const pixelRatio = match[4] ? parseInt(match[4], 10) : undefined;
+    const notch = match[5] ? match[5][0] === "+" : undefined;
+    return new ResolutionInfo({ width, height, pixelRatio, notch });
+  }
+
+  logicalResolutionString(): string {
+    return `${this.width}x${this.height}`;
+  }
+
+  toString(): string {
+    let output = this.logicalResolutionString();
+    if (isNotUndefined(this.pixelRatio)) {
+      output += `@${this.pixelRatio}x`;
+    }
+    if (isNotUndefined(this.notch)) {
+      output += `${this.notch ? "+" : "-"}notch`;
+    }
+    return output;
+  }
+}

package/src/get.ts

@@ -7,6 +7,8 @@ import {
   type VirtualScreen,
 } from "./Device";
 
+const BINARY_NAME = "betterdisplaycli";
+
 export interface QuietOption {
   quiet?: boolean;
 }
@@ -22,6 +24,30 @@ export function print(
   return command;
 }
 
+async function getDeviceInfos<T>(
+  printable_shell_command: PrintableShellCommand,
+  options?: {
+    ignoreDisplayGroups?: true;
+  } & QuietOption,
+): Promise<T[]> {
+  const jsonStream = await print(
+    printable_shell_command,
+    { argumentLineWrapping: "inline" },
+    options,
+  )
+    .stdout()
+    .text();
+  const deviceInfos: DeviceInfo[] = JSON.parse(`[${jsonStream}]`);
+  return deviceInfos
+    .map((info) => deviceFromInfo(info))
+    .filter((device: Device) => {
+      return (
+        !options?.ignoreDisplayGroups ||
+        device.info.deviceType !== "DisplayGroup"
+      );
+    }) as T[];
+}
+
 export async function getAllDevices(
   options?: {
     ignoreDisplayGroups?: true;
@@ -33,7 +59,7 @@ export async function getAllDevices(
   } & QuietOption,
 ): Promise<Device[]> {
   const jsonStream = await print(
-    new PrintableShellCommand("betterdisplaycli", [["get", "--identifiers"]]),
+    new PrintableShellCommand(BINARY_NAME, [["get", "--identifiers"]]),
     { argumentLineWrapping: "inline" },
     options,
   )
@@ -50,9 +76,24 @@ export async function getAllDevices(
     });
 }
 
+export async function getDisplayWithSelectorArg(
+  arg: "--displayWithMainStatus" | `--name=${string}`,
+): Promise<Display> {
+  return (
+    await getDeviceInfos<Display>(
+      new PrintableShellCommand("betterdisplaycli", [
+        "get",
+        arg,
+        "--type=Display",
+        "--identifiers",
+      ]),
+    )
+  )[0];
+}
+
 export async function connectAllDisplays(options?: QuietOption): Promise<void> {
   await print(
-    new PrintableShellCommand("betterdisplaycli", [
+    new PrintableShellCommand(BINARY_NAME, [
       ["perform", "--connectAllDisplays"],
     ]),
     { argumentLineWrapping: "inline" },

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./Device";
 export { connectAllDisplays, getAllDevices } from "./get";
+export { ResolutionInfo, type ResolutionInfoData } from "./ResolutionInfo";