pi-image-tools 1.3.0 → 1.3.1

package/src/providers/mac-pngpaste.ts

@@ -1,69 +1,69 @@
-import { buildNamespaceWrappedCommand, defaultCommandExists, type CommandExists } from "../shell-environment.js";
-import {
-  defaultCommandRunner,
-  MAX_BUFFER_BYTES,
-  READ_TIMEOUT_MS,
-  type CommandRunner,
-} from "./command-runner.js";
-import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
-
-export interface PngpasteProviderOptions {
-  priority?: number;
-  commandRunner?: CommandRunner;
-  commandExists?: CommandExists;
-}
-
-export class PngpasteProvider implements ClipboardImageProvider {
-  readonly capabilities;
-  private readonly commandRunner: CommandRunner;
-  private readonly commandExists: CommandExists;
-
-  constructor(options: PngpasteProviderOptions = {}) {
-    this.capabilities = {
-      id: "mac-pngpaste",
-      name: "pngpaste",
-      platforms: ["darwin"],
-      priority: options.priority ?? 10,
-    };
-    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
-    this.commandExists = options.commandExists ?? defaultCommandExists;
-  }
-
-  isAvailable(context: ClipboardProviderContext): boolean {
-    try {
-      return this.commandExists("pngpaste", context);
-    } catch {
-      return false;
-    }
-  }
-
-  read(context: ClipboardProviderContext): ClipboardReadResult {
-    const wrapped = buildNamespaceWrappedCommand(
-      "pngpaste",
-      ["-"],
-      context,
-      this.commandExists,
-    );
-    const result = this.commandRunner(wrapped.command, wrapped.args, {
-      environment: context.environment,
-      maxBuffer: MAX_BUFFER_BYTES,
-      timeout: READ_TIMEOUT_MS,
-    });
-
-    if (result.missingCommand) {
-      return { available: false, image: null };
-    }
-
-    if (!result.ok || result.stdout.length === 0) {
-      return { available: true, image: null };
-    }
-
-    return {
-      available: true,
-      image: {
-        bytes: new Uint8Array(result.stdout),
-        mimeType: "image/png",
-      },
-    };
-  }
-}
+import { buildNamespaceWrappedCommand, defaultCommandExists, type CommandExists } from "../shell-environment.js";
+import {
+  defaultCommandRunner,
+  MAX_BUFFER_BYTES,
+  READ_TIMEOUT_MS,
+  type CommandRunner,
+} from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export interface PngpasteProviderOptions {
+  priority?: number;
+  commandRunner?: CommandRunner;
+  commandExists?: CommandExists;
+}
+
+export class PngpasteProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly commandRunner: CommandRunner;
+  private readonly commandExists: CommandExists;
+
+  constructor(options: PngpasteProviderOptions = {}) {
+    this.capabilities = {
+      id: "mac-pngpaste",
+      name: "pngpaste",
+      platforms: ["darwin"],
+      priority: options.priority ?? 10,
+    };
+    this.commandRunner = options.commandRunner ?? defaultCommandRunner;
+    this.commandExists = options.commandExists ?? defaultCommandExists;
+  }
+
+  isAvailable(context: ClipboardProviderContext): boolean {
+    try {
+      return this.commandExists("pngpaste", context);
+    } catch {
+      return false;
+    }
+  }
+
+  read(context: ClipboardProviderContext): ClipboardReadResult {
+    const wrapped = buildNamespaceWrappedCommand(
+      "pngpaste",
+      ["-"],
+      context,
+      this.commandExists,
+    );
+    const result = this.commandRunner(wrapped.command, wrapped.args, {
+      environment: context.environment,
+      maxBuffer: MAX_BUFFER_BYTES,
+      timeout: READ_TIMEOUT_MS,
+    });
+
+    if (result.missingCommand) {
+      return { available: false, image: null };
+    }
+
+    if (!result.ok || result.stdout.length === 0) {
+      return { available: true, image: null };
+    }
+
+    return {
+      available: true,
+      image: {
+        bytes: new Uint8Array(result.stdout),
+        mimeType: "image/png",
+      },
+    };
+  }
+}

package/src/providers/native-module.ts

@@ -1,84 +1,84 @@
-import { createRequire } from "node:module";
-
-import { hasGraphicalSession } from "../shell-environment.js";
-import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
-import type { ClipboardModule } from "../types.js";
-
-const require = createRequire(import.meta.url);
-let cachedClipboardModule: ClipboardModule | null | undefined;
-
-export type ClipboardModuleLoader = (
-  platform: NodeJS.Platform,
-  environment: NodeJS.ProcessEnv,
-) => ClipboardModule | null;
-
-export function loadClipboardModule(
-  platform: NodeJS.Platform = process.platform,
-  environment: NodeJS.ProcessEnv = process.env,
-): ClipboardModule | null {
-  if (cachedClipboardModule !== undefined) {
-    return cachedClipboardModule;
-  }
-
-  if (environment.TERMUX_VERSION || !hasGraphicalSession(platform, environment)) {
-    cachedClipboardModule = null;
-    return cachedClipboardModule;
-  }
-
-  try {
-    cachedClipboardModule = require("@mariozechner/clipboard") as ClipboardModule;
-  } catch {
-    cachedClipboardModule = null;
-  }
-
-  return cachedClipboardModule;
-}
-
-export interface NativeModuleProviderOptions {
-  priority?: number;
-  moduleLoader?: ClipboardModuleLoader;
-}
-
-export class NativeModuleProvider implements ClipboardImageProvider {
-  readonly capabilities;
-  private readonly moduleLoader: ClipboardModuleLoader;
-
-  constructor(options: NativeModuleProviderOptions = {}) {
-    this.capabilities = {
-      id: "native-module",
-      name: "@mariozechner/clipboard",
-      platforms: "*" as const,
-      priority: options.priority ?? 100,
-    };
-    this.moduleLoader = options.moduleLoader ?? loadClipboardModule;
-  }
-
-  isAvailable(context: ClipboardProviderContext): boolean {
-    return this.moduleLoader(context.platform, context.environment) !== null;
-  }
-
-  async read(context: ClipboardProviderContext): Promise<ClipboardReadResult> {
-    const clipboard = this.moduleLoader(context.platform, context.environment);
-    if (!clipboard) {
-      return { available: false, image: null };
-    }
-
-    if (!clipboard.hasImage()) {
-      return { available: true, image: null };
-    }
-
-    const imageData = await clipboard.getImageBinary();
-    if (!imageData || imageData.length === 0) {
-      return { available: true, image: null };
-    }
-
-    const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
-    return {
-      available: true,
-      image: {
-        bytes,
-        mimeType: "image/png",
-      },
-    };
-  }
-}
+import { createRequire } from "node:module";
+
+import { hasGraphicalSession } from "../shell-environment.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+import type { ClipboardModule } from "../types.js";
+
+const require = createRequire(import.meta.url);
+let cachedClipboardModule: ClipboardModule | null | undefined;
+
+export type ClipboardModuleLoader = (
+  platform: NodeJS.Platform,
+  environment: NodeJS.ProcessEnv,
+) => ClipboardModule | null;
+
+export function loadClipboardModule(
+  platform: NodeJS.Platform = process.platform,
+  environment: NodeJS.ProcessEnv = process.env,
+): ClipboardModule | null {
+  if (cachedClipboardModule !== undefined) {
+    return cachedClipboardModule;
+  }
+
+  if (environment.TERMUX_VERSION || !hasGraphicalSession(platform, environment)) {
+    cachedClipboardModule = null;
+    return cachedClipboardModule;
+  }
+
+  try {
+    cachedClipboardModule = require("@mariozechner/clipboard") as ClipboardModule;
+  } catch {
+    cachedClipboardModule = null;
+  }
+
+  return cachedClipboardModule;
+}
+
+export interface NativeModuleProviderOptions {
+  priority?: number;
+  moduleLoader?: ClipboardModuleLoader;
+}
+
+export class NativeModuleProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly moduleLoader: ClipboardModuleLoader;
+
+  constructor(options: NativeModuleProviderOptions = {}) {
+    this.capabilities = {
+      id: "native-module",
+      name: "@mariozechner/clipboard",
+      platforms: "*" as const,
+      priority: options.priority ?? 100,
+    };
+    this.moduleLoader = options.moduleLoader ?? loadClipboardModule;
+  }
+
+  isAvailable(context: ClipboardProviderContext): boolean {
+    return this.moduleLoader(context.platform, context.environment) !== null;
+  }
+
+  async read(context: ClipboardProviderContext): Promise<ClipboardReadResult> {
+    const clipboard = this.moduleLoader(context.platform, context.environment);
+    if (!clipboard) {
+      return { available: false, image: null };
+    }
+
+    if (!clipboard.hasImage()) {
+      return { available: true, image: null };
+    }
+
+    const imageData = await clipboard.getImageBinary();
+    if (!imageData || imageData.length === 0) {
+      return { available: true, image: null };
+    }
+
+    const bytes = imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData);
+    return {
+      available: true,
+      image: {
+        bytes,
+        mimeType: "image/png",
+      },
+    };
+  }
+}

package/src/providers/powershell-forms.ts

@@ -1,95 +1,95 @@
-import { runPowerShellCommand, type PowerShellCommandResult, type RunPowerShellCommandOptions } from "../powershell.js";
-import { MAX_BUFFER_BYTES, READ_TIMEOUT_MS } from "./command-runner.js";
-import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
-
-export type PowerShellRunner = (
-  script: string,
-  options: RunPowerShellCommandOptions,
-) => PowerShellCommandResult;
-
-export interface PowerShellFormsProviderOptions {
-  priority?: number;
-  powerShellRunner?: PowerShellRunner;
-}
-
-const READ_IMAGE_SCRIPT = `
-$ErrorActionPreference = 'Stop'
-Add-Type -AssemblyName System.Windows.Forms
-Add-Type -AssemblyName System.Drawing
-
-if (-not [System.Windows.Forms.Clipboard]::ContainsImage()) {
-  return
-}
-
-$image = [System.Windows.Forms.Clipboard]::GetImage()
-if ($null -eq $image) {
-  return
-}
-
-$stream = New-Object System.IO.MemoryStream
-try {
-  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
-  [System.Convert]::ToBase64String($stream.ToArray())
-} finally {
-  $stream.Dispose()
-  $image.Dispose()
-}
-`;
-
-export class PowerShellFormsProvider implements ClipboardImageProvider {
-  readonly capabilities;
-  private readonly powerShellRunner: PowerShellRunner;
-
-  constructor(options: PowerShellFormsProviderOptions = {}) {
-    this.capabilities = {
-      id: "powershell-forms",
-      name: "Windows PowerShell Forms clipboard",
-      platforms: ["win32"],
-      priority: options.priority ?? 20,
-    };
-    this.powerShellRunner = options.powerShellRunner ?? runPowerShellCommand;
-  }
-
-  isAvailable(_context: ClipboardProviderContext): boolean {
-    return true;
-  }
-
-  read(_context: ClipboardProviderContext): ClipboardReadResult {
-    const result = this.powerShellRunner(READ_IMAGE_SCRIPT, {
-      encoded: true,
-      maxBuffer: MAX_BUFFER_BYTES,
-      sta: true,
-      timeout: READ_TIMEOUT_MS,
-    });
-
-    if (result.missingCommand) {
-      return { available: false, image: null };
-    }
-
-    if (!result.ok) {
-      return { available: true, image: null };
-    }
-
-    const base64 = result.stdout.trim();
-    if (!base64) {
-      return { available: true, image: null };
-    }
-
-    try {
-      const bytes = Buffer.from(base64, "base64");
-      if (bytes.length === 0) {
-        return { available: true, image: null };
-      }
-
-      return {
-        available: true,
-        image: {
-          bytes: new Uint8Array(bytes),
-          mimeType: "image/png",
-        },
-      };
-    } catch {
-      return { available: true, image: null };
-    }
-  }
-}
+import { runPowerShellCommand, type PowerShellCommandResult, type RunPowerShellCommandOptions } from "../powershell.js";
+import { MAX_BUFFER_BYTES, READ_TIMEOUT_MS } from "./command-runner.js";
+import type { ClipboardImageProvider, ClipboardProviderContext, ClipboardReadResult } from "./types.js";
+
+export type PowerShellRunner = (
+  script: string,
+  options: RunPowerShellCommandOptions,
+) => PowerShellCommandResult;
+
+export interface PowerShellFormsProviderOptions {
+  priority?: number;
+  powerShellRunner?: PowerShellRunner;
+}
+
+const READ_IMAGE_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+if (-not [System.Windows.Forms.Clipboard]::ContainsImage()) {
+  return
+}
+
+$image = [System.Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $image) {
+  return
+}
+
+$stream = New-Object System.IO.MemoryStream
+try {
+  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+  [System.Convert]::ToBase64String($stream.ToArray())
+} finally {
+  $stream.Dispose()
+  $image.Dispose()
+}
+`;
+
+export class PowerShellFormsProvider implements ClipboardImageProvider {
+  readonly capabilities;
+  private readonly powerShellRunner: PowerShellRunner;
+
+  constructor(options: PowerShellFormsProviderOptions = {}) {
+    this.capabilities = {
+      id: "powershell-forms",
+      name: "Windows PowerShell Forms clipboard",
+      platforms: ["win32"],
+      priority: options.priority ?? 20,
+    };
+    this.powerShellRunner = options.powerShellRunner ?? runPowerShellCommand;
+  }
+
+  isAvailable(_context: ClipboardProviderContext): boolean {
+    return true;
+  }
+
+  read(_context: ClipboardProviderContext): ClipboardReadResult {
+    const result = this.powerShellRunner(READ_IMAGE_SCRIPT, {
+      encoded: true,
+      maxBuffer: MAX_BUFFER_BYTES,
+      sta: true,
+      timeout: READ_TIMEOUT_MS,
+    });
+
+    if (result.missingCommand) {
+      return { available: false, image: null };
+    }
+
+    if (!result.ok) {
+      return { available: true, image: null };
+    }
+
+    const base64 = result.stdout.trim();
+    if (!base64) {
+      return { available: true, image: null };
+    }
+
+    try {
+      const bytes = Buffer.from(base64, "base64");
+      if (bytes.length === 0) {
+        return { available: true, image: null };
+      }
+
+      return {
+        available: true,
+        image: {
+          bytes: new Uint8Array(bytes),
+          mimeType: "image/png",
+        },
+      };
+    } catch {
+      return { available: true, image: null };
+    }
+  }
+}

package/src/providers/registry.ts

@@ -1,88 +1,88 @@
-import type {
-  ClipboardImageProvider,
-  ClipboardProviderContext,
-  ClipboardReadResult,
-} from "./types.js";
-import type { ClipboardImage } from "../types.js";
-
-export interface ClipboardProviderAttempt {
-  providerId: string;
-  available: boolean;
-  imageFound: boolean;
-  skipped: boolean;
-}
-
-export interface ClipboardProviderRegistryReadResult {
-  image: ClipboardImage | null;
-  attempts: ClipboardProviderAttempt[];
-}
-
-function supportsPlatform(provider: ClipboardImageProvider, platform: NodeJS.Platform): boolean {
-  const { platforms } = provider.capabilities;
-  return platforms === "*" || platforms.includes(platform);
-}
-
-function byPriority(left: ClipboardImageProvider, right: ClipboardImageProvider): number {
-  return left.capabilities.priority - right.capabilities.priority;
-}
-
-export class ClipboardProviderRegistry {
-  private readonly providers: ClipboardImageProvider[] = [];
-
-  constructor(providers: readonly ClipboardImageProvider[] = []) {
-    for (const provider of providers) {
-      this.register(provider);
-    }
-  }
-
-  register(provider: ClipboardImageProvider): this {
-    this.providers.push(provider);
-    return this;
-  }
-
-  getProviders(platform: NodeJS.Platform): ClipboardImageProvider[] {
-    return this.providers.filter((provider) => supportsPlatform(provider, platform)).sort(byPriority);
-  }
-
-  async getEligible(context: ClipboardProviderContext): Promise<ClipboardImageProvider[]> {
-    const eligible: ClipboardImageProvider[] = [];
-    for (const provider of this.getProviders(context.platform)) {
-      if (await provider.isAvailable(context)) {
-        eligible.push(provider);
-      }
-    }
-
-    return eligible;
-  }
-
-  async read(context: ClipboardProviderContext): Promise<ClipboardProviderRegistryReadResult> {
-    const attempts: ClipboardProviderAttempt[] = [];
-
-    for (const provider of this.getProviders(context.platform)) {
-      const isAvailable = await provider.isAvailable(context);
-      if (!isAvailable) {
-        attempts.push({
-          providerId: provider.capabilities.id,
-          available: false,
-          imageFound: false,
-          skipped: true,
-        });
-        continue;
-      }
-
-      const result: ClipboardReadResult = await provider.read(context);
-      attempts.push({
-        providerId: provider.capabilities.id,
-        available: result.available,
-        imageFound: result.image !== null,
-        skipped: false,
-      });
-
-      if (result.image) {
-        return { image: result.image, attempts };
-      }
-    }
-
-    return { image: null, attempts };
-  }
-}
+import type {
+  ClipboardImageProvider,
+  ClipboardProviderContext,
+  ClipboardReadResult,
+} from "./types.js";
+import type { ClipboardImage } from "../types.js";
+
+export interface ClipboardProviderAttempt {
+  providerId: string;
+  available: boolean;
+  imageFound: boolean;
+  skipped: boolean;
+}
+
+export interface ClipboardProviderRegistryReadResult {
+  image: ClipboardImage | null;
+  attempts: ClipboardProviderAttempt[];
+}
+
+function supportsPlatform(provider: ClipboardImageProvider, platform: NodeJS.Platform): boolean {
+  const { platforms } = provider.capabilities;
+  return platforms === "*" || platforms.includes(platform);
+}
+
+function byPriority(left: ClipboardImageProvider, right: ClipboardImageProvider): number {
+  return left.capabilities.priority - right.capabilities.priority;
+}
+
+export class ClipboardProviderRegistry {
+  private readonly providers: ClipboardImageProvider[] = [];
+
+  constructor(providers: readonly ClipboardImageProvider[] = []) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+
+  register(provider: ClipboardImageProvider): this {
+    this.providers.push(provider);
+    return this;
+  }
+
+  getProviders(platform: NodeJS.Platform): ClipboardImageProvider[] {
+    return this.providers.filter((provider) => supportsPlatform(provider, platform)).sort(byPriority);
+  }
+
+  async getEligible(context: ClipboardProviderContext): Promise<ClipboardImageProvider[]> {
+    const eligible: ClipboardImageProvider[] = [];
+    for (const provider of this.getProviders(context.platform)) {
+      if (await provider.isAvailable(context)) {
+        eligible.push(provider);
+      }
+    }
+
+    return eligible;
+  }
+
+  async read(context: ClipboardProviderContext): Promise<ClipboardProviderRegistryReadResult> {
+    const attempts: ClipboardProviderAttempt[] = [];
+
+    for (const provider of this.getProviders(context.platform)) {
+      const isAvailable = await provider.isAvailable(context);
+      if (!isAvailable) {
+        attempts.push({
+          providerId: provider.capabilities.id,
+          available: false,
+          imageFound: false,
+          skipped: true,
+        });
+        continue;
+      }
+
+      const result: ClipboardReadResult = await provider.read(context);
+      attempts.push({
+        providerId: provider.capabilities.id,
+        available: result.available,
+        imageFound: result.image !== null,
+        skipped: false,
+      });
+
+      if (result.image) {
+        return { image: result.image, attempts };
+      }
+    }
+
+    return { image: null, attempts };
+  }
+}