obsidian-integration-testing 10.1.0 → 10.3.0

package/dist/lib/cjs/sharp-loader.d.cts

@@ -0,0 +1,56 @@
+/**
+ * @file
+ *
+ * Lazily loads `sharp`, the OPTIONAL peer dependency the image helpers need, and
+ * describes the slice of its surface they use.
+ *
+ * The load is deferred because a static import would drag `sharp`'s
+ * platform-specific native binaries into every consumer of this package's index,
+ * when only screenshot post-processing needs them. The type is structural for
+ * the same reason: this module type-checks without `sharp`'s own types being
+ * resolvable.
+ */
+/**
+ * A layer passed to `sharp`'s `composite`.
+ */
+export interface SharpCompositeLayer {
+    readonly input: Buffer;
+    readonly left: number;
+    readonly top: number;
+}
+/**
+ * The `sharp` entry point the image helpers use.
+ */
+export type SharpFactory = (input: Uint8Array) => SharpInstance;
+/**
+ * One `sharp` pipeline.
+ */
+export interface SharpInstance {
+    blur(this: void, sigma: number): SharpInstance;
+    composite(this: void, layers: SharpCompositeLayer[]): SharpInstance;
+    metadata(this: void): Promise<SharpMetadata>;
+    png(this: void): SharpInstance;
+    resize(this: void, width: number, height: number, options?: SharpResizeOptions): SharpInstance;
+    toBuffer(this: void): Promise<Buffer>;
+}
+/**
+ * The subset of `sharp`'s metadata the image helpers read.
+ */
+export interface SharpMetadata {
+    readonly height?: number | undefined;
+    readonly width?: number | undefined;
+}
+/**
+ * The subset of `sharp`'s resize options the image helpers set.
+ */
+export interface SharpResizeOptions {
+    readonly fit: 'cover' | 'fill';
+}
+/**
+ * Loads `sharp` on demand.
+ *
+ * @param caller - Name of the calling helper, so the error says which one needs it.
+ * @returns A {@link Promise} that resolves to the `sharp` factory.
+ * @throws Error naming the missing optional peer dependency.
+ */
+export declare function importSharp(caller: string): Promise<SharpFactory>;

package/dist/lib/esm/fit-screenshot.d.mts

@@ -0,0 +1,117 @@
+/**
+ * @file
+ *
+ * Fits a screenshot onto a canvas of a different aspect ratio without cropping
+ * it or distorting it, filling the leftover margins with a blurred, enlarged
+ * copy of the same image (the "pillarbox" treatment used by store listings).
+ *
+ * The motivating case is a mobile store screenshot. The Android emulator's
+ * framebuffer is whatever the AVD's screen is — a Pixel 10 Pro XL is 1344x2992,
+ * roughly 9:20 — while the community store asks for 900x1600 (9:16). Cropping
+ * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so
+ * the image is scaled to fit the HEIGHT and the two side margins are filled.
+ *
+ * The geometry is a pure function so it can be unit-tested; the pixel work needs
+ * `sharp`, which is an OPTIONAL peer dependency — declared rather than bundled
+ * because only screenshot capture needs it, and it ships platform-specific
+ * native binaries that every other consumer would pay for.
+ */
+/**
+ * Parameters for {@link computeFitToCanvas}.
+ */
+export interface ComputeFitToCanvasParams {
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+    /**
+     * Height of the source image, in pixels.
+     */
+    readonly sourceHeightInPixels: number;
+    /**
+     * Width of the source image, in pixels.
+     */
+    readonly sourceWidthInPixels: number;
+}
+/**
+ * Options for {@link fitScreenshotToCanvas}.
+ */
+export interface FitScreenshotToCanvasOptions {
+    /**
+     * Gaussian blur strength applied to the margin fill.
+     *
+     * @default `24`
+     */
+    readonly blurSigma?: number;
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+}
+/**
+ * Where the scaled source image sits on the canvas.
+ */
+export interface FitToCanvasGeometry {
+    /**
+     * Width of each side margin, in pixels. Both sides are equal by construction.
+     */
+    readonly marginInPixels: number;
+    /**
+     * Left offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetXInPixels: number;
+    /**
+     * Top offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetYInPixels: number;
+    /**
+     * Height the source is scaled to, in pixels.
+     */
+    readonly scaledHeightInPixels: number;
+    /**
+     * Width the source is scaled to, in pixels.
+     */
+    readonly scaledWidthInPixels: number;
+}
+/**
+ * Computes how a source image is scaled and placed to fill a canvas's height,
+ * with equal margins on the left and right.
+ *
+ * The scaled width is rounded to the nearest integer that leaves an EVEN
+ * remainder, so the two margins are exactly equal — an asymmetric pillarbox is
+ * visible at a glance and looks like a mistake. Where both neighbors qualify,
+ * the one closer to the true scaled width wins, so the aspect error stays below
+ * one part in a thousand.
+ *
+ * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600
+ * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px
+ * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720
+ * (margin 90) because 718 is nearer 718.72.
+ *
+ * @param params - The source and canvas dimensions.
+ * @returns The scaled size, the offsets, and the side margin.
+ * @throws Error if any dimension is not a positive number.
+ */
+export declare function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry;
+/**
+ * Scales a screenshot to fill a canvas's height and fills the side margins with
+ * a blurred, enlarged copy of the same image.
+ *
+ * Nothing is cropped and nothing is stretched: the visible screenshot keeps its
+ * aspect ratio to within a rounding pixel, and the margins are made of the
+ * image itself rather than a flat color, so the result reads as one frame.
+ *
+ * @param bytes - The source PNG.
+ * @param options - The target canvas size and blur strength.
+ * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.
+ * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.
+ */
+export declare function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array>;

package/dist/lib/esm/fit-screenshot.mjs

@@ -0,0 +1,78 @@
+import { importSharp } from "./sharp-loader.mjs";
+const DEFAULT_BLUR_SIGMA = 24;
+const MARGIN_SIDES = 2;
+function computeFitToCanvas(params) {
+  const {
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  } = params;
+  const namedDimensions = [
+    ["canvasHeightInPixels", canvasHeightInPixels],
+    ["canvasWidthInPixels", canvasWidthInPixels],
+    ["sourceHeightInPixels", sourceHeightInPixels],
+    ["sourceWidthInPixels", sourceWidthInPixels]
+  ];
+  for (const [name, value] of namedDimensions) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);
+    }
+  }
+  const scaledHeightInPixels = canvasHeightInPixels;
+  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);
+  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);
+  if (scaledWidthInPixels > canvasWidthInPixels) {
+    throw new Error(
+      `computeFitToCanvas: the source is wider than the canvas once scaled to its height (${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`
+    );
+  }
+  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;
+  return {
+    marginInPixels,
+    offsetXInPixels: marginInPixels,
+    offsetYInPixels: 0,
+    scaledHeightInPixels,
+    scaledWidthInPixels
+  };
+}
+async function fitScreenshotToCanvas(bytes, options) {
+  const {
+    blurSigma = DEFAULT_BLUR_SIGMA,
+    canvasHeightInPixels,
+    canvasWidthInPixels
+  } = options;
+  const sharp = await importSharp("fitScreenshotToCanvas");
+  const metadata = await sharp(bytes).metadata();
+  const sourceWidthInPixels = metadata.width;
+  const sourceHeightInPixels = metadata.height;
+  if (sourceWidthInPixels === void 0 || sourceHeightInPixels === void 0) {
+    throw new Error("fitScreenshotToCanvas: could not read the source image dimensions.");
+  }
+  const geometry = computeFitToCanvas({
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  });
+  const background = await sharp(bytes).resize(canvasWidthInPixels, canvasHeightInPixels, { fit: "cover" }).blur(blurSigma).toBuffer();
+  const foreground = await sharp(bytes).resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: "fill" }).toBuffer();
+  const composed = await sharp(background).composite([{
+    input: foreground,
+    left: geometry.offsetXInPixels,
+    top: geometry.offsetYInPixels
+  }]).png().toBuffer();
+  return new Uint8Array(composed);
+}
+function roundToMatchingParity(value, target) {
+  const rounded = Math.round(value);
+  if ((target - rounded) % MARGIN_SIDES === 0) {
+    return rounded;
+  }
+  return value >= rounded ? rounded + 1 : rounded - 1;
+}
+export {
+  computeFitToCanvas,
+  fitScreenshotToCanvas
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/fit-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Fits a screenshot onto a canvas of a different aspect ratio without cropping\n * it or distorting it, filling the leftover margins with a blurred, enlarged\n * copy of the same image (the \"pillarbox\" treatment used by store listings).\n *\n * The motivating case is a mobile store screenshot. The Android emulator's\n * framebuffer is whatever the AVD's screen is \u2014 a Pixel 10 Pro XL is 1344x2992,\n * roughly 9:20 \u2014 while the community store asks for 900x1600 (9:16). Cropping\n * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so\n * the image is scaled to fit the HEIGHT and the two side margins are filled.\n *\n * The geometry is a pure function so it can be unit-tested; the pixel work needs\n * `sharp`, which is an OPTIONAL peer dependency \u2014 declared rather than bundled\n * because only screenshot capture needs it, and it ships platform-specific\n * native binaries that every other consumer would pay for.\n */\n\nimport { importSharp } from './sharp-loader.mjs';\n\n/**\n * Parameters for {@link computeFitToCanvas}.\n */\nexport interface ComputeFitToCanvasParams {\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n\n  /**\n   * Height of the source image, in pixels.\n   */\n  readonly sourceHeightInPixels: number;\n\n  /**\n   * Width of the source image, in pixels.\n   */\n  readonly sourceWidthInPixels: number;\n}\n\n/**\n * Options for {@link fitScreenshotToCanvas}.\n */\nexport interface FitScreenshotToCanvasOptions {\n  /**\n   * Gaussian blur strength applied to the margin fill.\n   *\n   * @default `24`\n   */\n  readonly blurSigma?: number;\n\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n}\n\n/**\n * Where the scaled source image sits on the canvas.\n */\nexport interface FitToCanvasGeometry {\n  /**\n   * Width of each side margin, in pixels. Both sides are equal by construction.\n   */\n  readonly marginInPixels: number;\n\n  /**\n   * Left offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetXInPixels: number;\n\n  /**\n   * Top offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetYInPixels: number;\n\n  /**\n   * Height the source is scaled to, in pixels.\n   */\n  readonly scaledHeightInPixels: number;\n\n  /**\n   * Width the source is scaled to, in pixels.\n   */\n  readonly scaledWidthInPixels: number;\n}\n\n/**\n * Default Gaussian blur strength for the margin fill: soft enough that no\n * detail reads as content, gentle enough to keep the frame's colors.\n */\nconst DEFAULT_BLUR_SIGMA = 24;\n\n/**\n * The number of side margins the leftover width is split between.\n */\nconst MARGIN_SIDES = 2;\n\n/**\n * Computes how a source image is scaled and placed to fill a canvas's height,\n * with equal margins on the left and right.\n *\n * The scaled width is rounded to the nearest integer that leaves an EVEN\n * remainder, so the two margins are exactly equal \u2014 an asymmetric pillarbox is\n * visible at a glance and looks like a mistake. Where both neighbors qualify,\n * the one closer to the true scaled width wins, so the aspect error stays below\n * one part in a thousand.\n *\n * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600\n * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px\n * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720\n * (margin 90) because 718 is nearer 718.72.\n *\n * @param params - The source and canvas dimensions.\n * @returns The scaled size, the offsets, and the side margin.\n * @throws Error if any dimension is not a positive number.\n */\nexport function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry {\n  const {\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  } = params;\n\n  const namedDimensions: [string, number][] = [\n    ['canvasHeightInPixels', canvasHeightInPixels],\n    ['canvasWidthInPixels', canvasWidthInPixels],\n    ['sourceHeightInPixels', sourceHeightInPixels],\n    ['sourceWidthInPixels', sourceWidthInPixels]\n  ];\n\n  for (const [name, value] of namedDimensions) {\n    if (!Number.isFinite(value) || value <= 0) {\n      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);\n    }\n  }\n\n  const scaledHeightInPixels = canvasHeightInPixels;\n  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);\n  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);\n\n  if (scaledWidthInPixels > canvasWidthInPixels) {\n    throw new Error(\n      'computeFitToCanvas: the source is wider than the canvas once scaled to its height '\n        + `(${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`\n    );\n  }\n\n  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;\n\n  return {\n    marginInPixels,\n    offsetXInPixels: marginInPixels,\n    offsetYInPixels: 0,\n    scaledHeightInPixels,\n    scaledWidthInPixels\n  };\n}\n\n/**\n * Scales a screenshot to fill a canvas's height and fills the side margins with\n * a blurred, enlarged copy of the same image.\n *\n * Nothing is cropped and nothing is stretched: the visible screenshot keeps its\n * aspect ratio to within a rounding pixel, and the margins are made of the\n * image itself rather than a flat color, so the result reads as one frame.\n *\n * @param bytes - The source PNG.\n * @param options - The target canvas size and blur strength.\n * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.\n * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.\n */\nexport async function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array> {\n  const {\n    blurSigma = DEFAULT_BLUR_SIGMA,\n    canvasHeightInPixels,\n    canvasWidthInPixels\n  } = options;\n\n  const sharp = await importSharp('fitScreenshotToCanvas');\n  const metadata = await sharp(bytes).metadata();\n  const sourceWidthInPixels = metadata.width;\n  const sourceHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (sourceWidthInPixels === undefined || sourceHeightInPixels === undefined) {\n    throw new Error('fitScreenshotToCanvas: could not read the source image dimensions.');\n  }\n\n  const geometry = computeFitToCanvas({\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  });\n\n  // The background is the same frame blown up to COVER the canvas and blurred,\n  // So the margins carry the screenshot's own colors instead of a flat bar.\n  const background = await sharp(bytes)\n    .resize(canvasWidthInPixels, canvasHeightInPixels, { fit: 'cover' })\n    .blur(blurSigma)\n    .toBuffer();\n\n  const foreground = await sharp(bytes)\n    .resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: 'fill' })\n    .toBuffer();\n\n  const composed = await sharp(background)\n    .composite([{\n      input: foreground,\n      left: geometry.offsetXInPixels,\n      top: geometry.offsetYInPixels\n    }])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(composed);\n}\n\n/**\n * Rounds a width to the nearest integer sharing `target`'s parity, so\n * `target - result` is even and splits into two equal margins.\n *\n * @param value - The exact scaled width.\n * @param target - The canvas width whose parity must be matched.\n * @returns The nearest integer of the same parity as `target`.\n */\nfunction roundToMatchingParity(value: number, target: number): number {\n  const rounded = Math.round(value);\n  if ((target - rounded) % MARGIN_SIDES === 0) {\n    return rounded;\n  }\n\n  // `rounded` leaves an odd remainder, so step to whichever neighbor is closer\n  // To the true value; both have the parity `rounded` lacks.\n  return value >= rounded ? rounded + 1 : rounded - 1;\n}\n"],
  "mappings": "AAmBA,SAAS,mBAAmB;AAmF5B,MAAM,qBAAqB;AAK3B,MAAM,eAAe;AAqBd,SAAS,mBAAmB,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,kBAAsC;AAAA,IAC1C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,IAC3C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,EAC7C;AAEA,aAAW,CAAC,MAAM,KAAK,KAAK,iBAAiB;AAC3C,QAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,YAAM,IAAI,MAAM,uBAAuB,IAAI,mCAAmC,OAAO,KAAK,CAAC,GAAG;AAAA,IAChG;AAAA,EACF;AAEA,QAAM,uBAAuB;AAC7B,QAAM,mBAAmB,uBAAuB,uBAAuB;AACvE,QAAM,sBAAsB,sBAAsB,kBAAkB,mBAAmB;AAEvF,MAAI,sBAAsB,qBAAqB;AAC7C,UAAM,IAAI;AAAA,MACR,sFACQ,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC;AAAA,IACtE;AAAA,EACF;AAEA,QAAM,kBAAkB,sBAAsB,uBAAuB;AAErE,SAAO;AAAA,IACL;AAAA,IACA,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACF;AAeA,eAAsB,sBAAsB,OAAmB,SAA4D;AACzH,QAAM;AAAA,IACJ,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,QAAQ,MAAM,YAAY,uBAAuB;AACvD,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS;AAC7C,QAAM,sBAAsB,SAAS;AACrC,QAAM,uBAAuB,SAAS;AAGtC,MAAI,wBAAwB,UAAa,yBAAyB,QAAW;AAC3E,UAAM,IAAI,MAAM,oEAAoE;AAAA,EACtF;AAEA,QAAM,WAAW,mBAAmB;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAID,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,qBAAqB,sBAAsB,EAAE,KAAK,QAAQ,CAAC,EAClE,KAAK,SAAS,EACd,SAAS;AAEZ,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,SAAS,qBAAqB,SAAS,sBAAsB,EAAE,KAAK,OAAO,CAAC,EACnF,SAAS;AAEZ,QAAM,WAAW,MAAM,MAAM,UAAU,EACpC,UAAU,CAAC;AAAA,IACV,OAAO;AAAA,IACP,MAAM,SAAS;AAAA,IACf,KAAK,SAAS;AAAA,EAChB,CAAC,CAAC,EACD,IAAI,EACJ,SAAS;AAEZ,SAAO,IAAI,WAAW,QAAQ;AAChC;AAUA,SAAS,sBAAsB,OAAe,QAAwB;AACpE,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,OAAK,SAAS,WAAW,iBAAiB,GAAG;AAC3C,WAAO;AAAA,EACT;AAIA,SAAO,SAAS,UAAU,UAAU,IAAI,UAAU;AACpD;",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -22,10 +22,14 @@ export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronC
 export { resolveElectronCompatibility } from './electron-compatibility.mjs';
 export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.mjs';
 export { evalInObsidian } from './eval-in-obsidian.mjs';
+export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.mjs';
+export { computeFitToCanvas, fitScreenshotToCanvas } from './fit-screenshot.mjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';
 export { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';
 export type { InstallerCompatibility, InstallerCompatibilityTier, ResolveInstallerCompatibilityParams } from './installer-compatibility.mjs';
 export { resolveInstallerCompatibility } from './installer-compatibility.mjs';
+export type { ComputeLabelBandParams, LabelBandGeometry, LabelScreenshotOptions } from './label-screenshot.mjs';
+export { buildLabelSvg, computeLabelBand, escapeSvgText, labelScreenshot } from './label-screenshot.mjs';
 export type { LibResolver } from './lib-registry.mjs';
 export { registerLibResolver } from './lib-registry.mjs';
 export type { ObsidianRuntimeVersions, ObsidianVersionDownloads, ObsidianVersionMetadata } from './obsidian-metadata.mjs';

package/dist/lib/esm/index.mjs

@@ -16,8 +16,18 @@ import { buildDemoVaultPopulate } from "./demo-vault-populate.mjs";
 import { readDemoVaultTree } from "./demo-vault-tree.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import {
+  computeFitToCanvas,
+  fitScreenshotToCanvas
+} from "./fit-screenshot.mjs";
 import { IncompatibleInstallerVersionError } from "./incompatible-installer-version-error.mjs";
 import { resolveInstallerCompatibility } from "./installer-compatibility.mjs";
+import {
+  buildLabelSvg,
+  computeLabelBand,
+  escapeSvgText,
+  labelScreenshot
+} from "./label-screenshot.mjs";
 import { registerLibResolver } from "./lib-registry.mjs";
 import { getVersionMetadata } from "./obsidian-metadata.mjs";
 import {
@@ -50,13 +60,19 @@ export {
   TemporaryVault,
   buildDemoVaultPopulate,
   buildDeviceMetricsOverride,
+  buildLabelSvg,
   captureObsidianScreenshot,
+  computeFitToCanvas,
+  computeLabelBand,
   connectToCdp,
   createTransportFromOptions,
   decodeBase64Png,
+  escapeSvgText,
   evalInObsidian,
+  fitScreenshotToCanvas,
   getVersionMetadata,
   isPng,
+  labelScreenshot,
   pollInObsidian,
   readDemoVaultTree,
   readPngDimensions,
@@ -70,4 +86,4 @@ export {
   setVaultPathResolver,
   unregisterVault
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/label-screenshot.d.mts

@@ -0,0 +1,98 @@
+/**
+ * @file
+ *
+ * Adds a caption band to an already-captured screenshot.
+ *
+ * A store listing shows screenshots ONE AT A TIME, in a carousel, with no
+ * caption of its own — so an image has to say what it is showing. Without that,
+ * a shot of the state a plugin removes reads as a shot of the state the plugin
+ * causes, which is the opposite of the message.
+ *
+ * The band is drawn over the BOTTOM of the frame, for two reasons: the top is
+ * where the content being demonstrated usually starts, and the bottom of an
+ * Obsidian frame is chrome — status bar, word count, sync indicator — which the
+ * band then covers rather than competing with.
+ *
+ * This is post-processing, deliberately. The capture stays an untouched device
+ * frame, and rewording a label needs no re-shoot.
+ */
+/**
+ * Parameters for {@link computeLabelBand}.
+ */
+export interface ComputeLabelBandParams {
+    /**
+     * Height of the image being labeled, in pixels.
+     */
+    readonly imageHeightInPixels: number;
+    /**
+     * Width of the image being labeled, in pixels.
+     */
+    readonly imageWidthInPixels: number;
+}
+/**
+ * The geometry of the caption band.
+ */
+export interface LabelBandGeometry {
+    /**
+     * Font size for the caption, in pixels.
+     */
+    readonly fontSizeInPixels: number;
+    /**
+     * Height of the band, in pixels.
+     */
+    readonly heightInPixels: number;
+    /**
+     * Distance from the top of the image to the top of the band, in pixels.
+     */
+    readonly topInPixels: number;
+}
+/**
+ * Options for {@link labelScreenshot}.
+ */
+export interface LabelScreenshotOptions {
+    /**
+     * The caption. Keep it to a handful of words: it is read at listing-thumbnail
+     * size, and it is clipped rather than wrapped.
+     */
+    readonly text: string;
+}
+/**
+ * Builds the SVG for the caption band.
+ *
+ * @param text - The caption.
+ * @param geometry - The band geometry.
+ * @param imageWidthInPixels - Width of the image, so the band spans it.
+ * @returns The SVG markup.
+ */
+export declare function buildLabelSvg(text: string, geometry: LabelBandGeometry, imageWidthInPixels: number): string;
+/**
+ * Computes the caption band's size and position for a given image.
+ *
+ * @param params - The image dimensions.
+ * @returns The band geometry.
+ * @throws Error if either dimension is not a positive number.
+ */
+export declare function computeLabelBand(params: ComputeLabelBandParams): LabelBandGeometry;
+/**
+ * Escapes text for inclusion in SVG character data.
+ *
+ * A caption is authored per screenshot and can legitimately contain `&` or the
+ * angle brackets Obsidian uses in link syntax; unescaped, those make the SVG
+ * impossible to parse and `sharp` fails on a caption rather than on an image.
+ *
+ * @param text - The raw caption.
+ * @returns The caption, safe to embed in SVG.
+ */
+export declare function escapeSvgText(text: string): string;
+/**
+ * Draws a caption band across the bottom of a screenshot.
+ *
+ * The image keeps its dimensions exactly: the band is composited OVER the
+ * frame, never appended to it, because the store expects a specific size.
+ *
+ * @param bytes - The captured PNG.
+ * @param options - The caption.
+ * @returns A {@link Promise} that resolves to the labeled PNG, the same size as the input.
+ * @throws Error if `sharp` is not installed, or the image dimensions cannot be read.
+ */
+export declare function labelScreenshot(bytes: Uint8Array, options: LabelScreenshotOptions): Promise<Uint8Array>;

package/dist/lib/esm/label-screenshot.mjs

@@ -0,0 +1,54 @@
+import { importSharp } from "./sharp-loader.mjs";
+const FONT_SIZE_RATIO = 0.034;
+const BAND_HEIGHT_RATIO = 2.2;
+const BAND_OPACITY = 0.82;
+const MINIMUM_FONT_SIZE_IN_PIXELS = 18;
+const CENTER_DIVISOR = 2;
+function buildLabelSvg(text, geometry, imageWidthInPixels) {
+  const { fontSizeInPixels, heightInPixels } = geometry;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(imageWidthInPixels)}" height="${String(heightInPixels)}"><rect x="0" y="0" width="${String(imageWidthInPixels)}" height="${String(heightInPixels)}" fill="#000000" fill-opacity="${String(BAND_OPACITY)}"/><text x="${String(imageWidthInPixels / CENTER_DIVISOR)}" y="${String(heightInPixels / CENTER_DIVISOR)}" font-family="Segoe UI, Helvetica, Arial, sans-serif" font-size="${String(fontSizeInPixels)}" font-weight="600" fill="#ffffff" text-anchor="middle" dominant-baseline="central">${escapeSvgText(text)}</text></svg>`;
+}
+function computeLabelBand(params) {
+  const { imageHeightInPixels, imageWidthInPixels } = params;
+  if (!Number.isFinite(imageWidthInPixels) || imageWidthInPixels <= 0) {
+    throw new Error(`computeLabelBand: imageWidthInPixels must be a positive number, got ${String(imageWidthInPixels)}.`);
+  }
+  if (!Number.isFinite(imageHeightInPixels) || imageHeightInPixels <= 0) {
+    throw new Error(`computeLabelBand: imageHeightInPixels must be a positive number, got ${String(imageHeightInPixels)}.`);
+  }
+  const fontSizeInPixels = Math.max(MINIMUM_FONT_SIZE_IN_PIXELS, Math.round(imageWidthInPixels * FONT_SIZE_RATIO));
+  const heightInPixels = Math.min(imageHeightInPixels, Math.round(fontSizeInPixels * BAND_HEIGHT_RATIO));
+  return {
+    fontSizeInPixels,
+    heightInPixels,
+    topInPixels: imageHeightInPixels - heightInPixels
+  };
+}
+function escapeSvgText(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+async function labelScreenshot(bytes, options) {
+  const sharp = await importSharp("labelScreenshot");
+  const metadata = await sharp(bytes).metadata();
+  const imageWidthInPixels = metadata.width;
+  const imageHeightInPixels = metadata.height;
+  if (imageWidthInPixels === void 0 || imageHeightInPixels === void 0) {
+    throw new Error("labelScreenshot: could not read the source image dimensions.");
+  }
+  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });
+  const svg = buildLabelSvg(options.text, geometry, imageWidthInPixels);
+  const layer = {
+    input: Buffer.from(svg),
+    left: 0,
+    top: geometry.topInPixels
+  };
+  const labeled = await sharp(bytes).composite([layer]).png().toBuffer();
+  return new Uint8Array(labeled);
+}
+export {
+  buildLabelSvg,
+  computeLabelBand,
+  escapeSvgText,
+  labelScreenshot
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/label-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Adds a caption band to an already-captured screenshot.\n *\n * A store listing shows screenshots ONE AT A TIME, in a carousel, with no\n * caption of its own \u2014 so an image has to say what it is showing. Without that,\n * a shot of the state a plugin removes reads as a shot of the state the plugin\n * causes, which is the opposite of the message.\n *\n * The band is drawn over the BOTTOM of the frame, for two reasons: the top is\n * where the content being demonstrated usually starts, and the bottom of an\n * Obsidian frame is chrome \u2014 status bar, word count, sync indicator \u2014 which the\n * band then covers rather than competing with.\n *\n * This is post-processing, deliberately. The capture stays an untouched device\n * frame, and rewording a label needs no re-shoot.\n */\n\nimport type { SharpCompositeLayer } from './sharp-loader.mjs';\n\nimport { importSharp } from './sharp-loader.mjs';\n\n/**\n * Parameters for {@link computeLabelBand}.\n */\nexport interface ComputeLabelBandParams {\n  /**\n   * Height of the image being labeled, in pixels.\n   */\n  readonly imageHeightInPixels: number;\n\n  /**\n   * Width of the image being labeled, in pixels.\n   */\n  readonly imageWidthInPixels: number;\n}\n\n/**\n * The geometry of the caption band.\n */\nexport interface LabelBandGeometry {\n  /**\n   * Font size for the caption, in pixels.\n   */\n  readonly fontSizeInPixels: number;\n\n  /**\n   * Height of the band, in pixels.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * Distance from the top of the image to the top of the band, in pixels.\n   */\n  readonly topInPixels: number;\n}\n\n/**\n * Options for {@link labelScreenshot}.\n */\nexport interface LabelScreenshotOptions {\n  /**\n   * The caption. Keep it to a handful of words: it is read at listing-thumbnail\n   * size, and it is clipped rather than wrapped.\n   */\n  readonly text: string;\n}\n\n/**\n * Caption size as a fraction of image WIDTH, not height.\n *\n * Width is what governs legibility here: a 900x1600 phone frame and a 1200x800\n * desktop frame are read at similar on-screen widths in a listing, so sizing by\n * width keeps the caption visually consistent across the two.\n */\nconst FONT_SIZE_RATIO = 0.034;\n\n/**\n * Band height as a multiple of the font size \u2014 enough to sit the text on with\n * clear space above and below.\n */\nconst BAND_HEIGHT_RATIO = 2.2;\n\n/**\n * Opacity of the band, dark enough to carry light text over any Obsidian theme\n * while the frame beneath stays faintly visible rather than looking cut off.\n */\nconst BAND_OPACITY = 0.82;\n\nconst MINIMUM_FONT_SIZE_IN_PIXELS = 18;\n\n/**\n * Divisor that turns a span into its midpoint, for centering the caption.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the SVG for the caption band.\n *\n * @param text - The caption.\n * @param geometry - The band geometry.\n * @param imageWidthInPixels - Width of the image, so the band spans it.\n * @returns The SVG markup.\n */\nexport function buildLabelSvg(text: string, geometry: LabelBandGeometry, imageWidthInPixels: number): string {\n  const { fontSizeInPixels, heightInPixels } = geometry;\n\n  return `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\">`\n    + `<rect x=\"0\" y=\"0\" width=\"${String(imageWidthInPixels)}\" height=\"${String(heightInPixels)}\" `\n    + `fill=\"#000000\" fill-opacity=\"${String(BAND_OPACITY)}\"/>`\n    + `<text x=\"${String(imageWidthInPixels / CENTER_DIVISOR)}\" y=\"${String(heightInPixels / CENTER_DIVISOR)}\" `\n    + `font-family=\"Segoe UI, Helvetica, Arial, sans-serif\" font-size=\"${String(fontSizeInPixels)}\" `\n    + 'font-weight=\"600\" fill=\"#ffffff\" text-anchor=\"middle\" dominant-baseline=\"central\">'\n    + `${escapeSvgText(text)}</text></svg>`;\n}\n\n/**\n * Computes the caption band's size and position for a given image.\n *\n * @param params - The image dimensions.\n * @returns The band geometry.\n * @throws Error if either dimension is not a positive number.\n */\nexport function computeLabelBand(params: ComputeLabelBandParams): LabelBandGeometry {\n  const { imageHeightInPixels, imageWidthInPixels } = params;\n\n  if (!Number.isFinite(imageWidthInPixels) || imageWidthInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageWidthInPixels must be a positive number, got ${String(imageWidthInPixels)}.`);\n  }\n\n  if (!Number.isFinite(imageHeightInPixels) || imageHeightInPixels <= 0) {\n    throw new Error(`computeLabelBand: imageHeightInPixels must be a positive number, got ${String(imageHeightInPixels)}.`);\n  }\n\n  const fontSizeInPixels = Math.max(MINIMUM_FONT_SIZE_IN_PIXELS, Math.round(imageWidthInPixels * FONT_SIZE_RATIO));\n  const heightInPixels = Math.min(imageHeightInPixels, Math.round(fontSizeInPixels * BAND_HEIGHT_RATIO));\n\n  return {\n    fontSizeInPixels,\n    heightInPixels,\n    topInPixels: imageHeightInPixels - heightInPixels\n  };\n}\n\n/**\n * Escapes text for inclusion in SVG character data.\n *\n * A caption is authored per screenshot and can legitimately contain `&` or the\n * angle brackets Obsidian uses in link syntax; unescaped, those make the SVG\n * impossible to parse and `sharp` fails on a caption rather than on an image.\n *\n * @param text - The raw caption.\n * @returns The caption, safe to embed in SVG.\n */\nexport function escapeSvgText(text: string): string {\n  return text\n    .replaceAll('&', '&amp;')\n    .replaceAll('<', '&lt;')\n    .replaceAll('>', '&gt;')\n    .replaceAll('\"', '&quot;')\n    .replaceAll('\\'', '&apos;');\n}\n\n/**\n * Draws a caption band across the bottom of a screenshot.\n *\n * The image keeps its dimensions exactly: the band is composited OVER the\n * frame, never appended to it, because the store expects a specific size.\n *\n * @param bytes - The captured PNG.\n * @param options - The caption.\n * @returns A {@link Promise} that resolves to the labeled PNG, the same size as the input.\n * @throws Error if `sharp` is not installed, or the image dimensions cannot be read.\n */\nexport async function labelScreenshot(bytes: Uint8Array, options: LabelScreenshotOptions): Promise<Uint8Array> {\n  const sharp = await importSharp('labelScreenshot');\n  const metadata = await sharp(bytes).metadata();\n  const imageWidthInPixels = metadata.width;\n  const imageHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (imageWidthInPixels === undefined || imageHeightInPixels === undefined) {\n    throw new Error('labelScreenshot: could not read the source image dimensions.');\n  }\n\n  const geometry = computeLabelBand({ imageHeightInPixels, imageWidthInPixels });\n  const svg = buildLabelSvg(options.text, geometry, imageWidthInPixels);\n  const layer: SharpCompositeLayer = {\n    input: Buffer.from(svg),\n    left: 0,\n    top: geometry.topInPixels\n  };\n\n  const labeled = await sharp(bytes)\n    .composite([layer])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(labeled);\n}\n"],
  "mappings": "AAqBA,SAAS,mBAAmB;AAuD5B,MAAM,kBAAkB;AAMxB,MAAM,oBAAoB;AAM1B,MAAM,eAAe;AAErB,MAAM,8BAA8B;AAKpC,MAAM,iBAAiB;AAUhB,SAAS,cAAc,MAAc,UAA6B,oBAAoC;AAC3G,QAAM,EAAE,kBAAkB,eAAe,IAAI;AAE7C,SAAO,kDAAkD,OAAO,kBAAkB,CAAC,aAAa,OAAO,cAAc,CAAC,8BACtF,OAAO,kBAAkB,CAAC,aAAa,OAAO,cAAc,CAAC,kCACzD,OAAO,YAAY,CAAC,eACxC,OAAO,qBAAqB,cAAc,CAAC,QAAQ,OAAO,iBAAiB,cAAc,CAAC,qEACnC,OAAO,gBAAgB,CAAC,uFAExF,cAAc,IAAI,CAAC;AAC5B;AASO,SAAS,iBAAiB,QAAmD;AAClF,QAAM,EAAE,qBAAqB,mBAAmB,IAAI;AAEpD,MAAI,CAAC,OAAO,SAAS,kBAAkB,KAAK,sBAAsB,GAAG;AACnE,UAAM,IAAI,MAAM,uEAAuE,OAAO,kBAAkB,CAAC,GAAG;AAAA,EACtH;AAEA,MAAI,CAAC,OAAO,SAAS,mBAAmB,KAAK,uBAAuB,GAAG;AACrE,UAAM,IAAI,MAAM,wEAAwE,OAAO,mBAAmB,CAAC,GAAG;AAAA,EACxH;AAEA,QAAM,mBAAmB,KAAK,IAAI,6BAA6B,KAAK,MAAM,qBAAqB,eAAe,CAAC;AAC/G,QAAM,iBAAiB,KAAK,IAAI,qBAAqB,KAAK,MAAM,mBAAmB,iBAAiB,CAAC;AAErG,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,aAAa,sBAAsB;AAAA,EACrC;AACF;AAYO,SAAS,cAAc,MAAsB;AAClD,SAAO,KACJ,WAAW,KAAK,OAAO,EACvB,WAAW,KAAK,MAAM,EACtB,WAAW,KAAK,MAAM,EACtB,WAAW,KAAK,QAAQ,EACxB,WAAW,KAAM,QAAQ;AAC9B;AAaA,eAAsB,gBAAgB,OAAmB,SAAsD;AAC7G,QAAM,QAAQ,MAAM,YAAY,iBAAiB;AACjD,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS;AAC7C,QAAM,qBAAqB,SAAS;AACpC,QAAM,sBAAsB,SAAS;AAGrC,MAAI,uBAAuB,UAAa,wBAAwB,QAAW;AACzE,UAAM,IAAI,MAAM,8DAA8D;AAAA,EAChF;AAEA,QAAM,WAAW,iBAAiB,EAAE,qBAAqB,mBAAmB,CAAC;AAC7E,QAAM,MAAM,cAAc,QAAQ,MAAM,UAAU,kBAAkB;AACpE,QAAM,QAA6B;AAAA,IACjC,OAAO,OAAO,KAAK,GAAG;AAAA,IACtB,MAAM;AAAA,IACN,KAAK,SAAS;AAAA,EAChB;AAEA,QAAM,UAAU,MAAM,MAAM,KAAK,EAC9B,UAAU,CAAC,KAAK,CAAC,EACjB,IAAI,EACJ,SAAS;AAEZ,SAAO,IAAI,WAAW,OAAO;AAC/B;",
  "names": []
}


package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "10.0.0";
+const LIBRARY_VERSION = false ? "dev" : "10.2.0";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/sharp-loader.d.mts

@@ -0,0 +1,56 @@
+/**
+ * @file
+ *
+ * Lazily loads `sharp`, the OPTIONAL peer dependency the image helpers need, and
+ * describes the slice of its surface they use.
+ *
+ * The load is deferred because a static import would drag `sharp`'s
+ * platform-specific native binaries into every consumer of this package's index,
+ * when only screenshot post-processing needs them. The type is structural for
+ * the same reason: this module type-checks without `sharp`'s own types being
+ * resolvable.
+ */
+/**
+ * A layer passed to `sharp`'s `composite`.
+ */
+export interface SharpCompositeLayer {
+    readonly input: Buffer;
+    readonly left: number;
+    readonly top: number;
+}
+/**
+ * The `sharp` entry point the image helpers use.
+ */
+export type SharpFactory = (input: Uint8Array) => SharpInstance;
+/**
+ * One `sharp` pipeline.
+ */
+export interface SharpInstance {
+    blur(this: void, sigma: number): SharpInstance;
+    composite(this: void, layers: SharpCompositeLayer[]): SharpInstance;
+    metadata(this: void): Promise<SharpMetadata>;
+    png(this: void): SharpInstance;
+    resize(this: void, width: number, height: number, options?: SharpResizeOptions): SharpInstance;
+    toBuffer(this: void): Promise<Buffer>;
+}
+/**
+ * The subset of `sharp`'s metadata the image helpers read.
+ */
+export interface SharpMetadata {
+    readonly height?: number | undefined;
+    readonly width?: number | undefined;
+}
+/**
+ * The subset of `sharp`'s resize options the image helpers set.
+ */
+export interface SharpResizeOptions {
+    readonly fit: 'cover' | 'fill';
+}
+/**
+ * Loads `sharp` on demand.
+ *
+ * @param caller - Name of the calling helper, so the error says which one needs it.
+ * @returns A {@link Promise} that resolves to the `sharp` factory.
+ * @throws Error naming the missing optional peer dependency.
+ */
+export declare function importSharp(caller: string): Promise<SharpFactory>;

package/dist/lib/esm/sharp-loader.mjs

@@ -0,0 +1,16 @@
+async function importSharp(caller) {
+  try {
+    const sharpModule = await import("sharp");
+    const factory = sharpModule.default;
+    return factory;
+  } catch (error) {
+    throw new Error(
+      `${caller} needs the optional peer dependency "sharp". Install it in the consuming project (npm i -D sharp).`,
+      { cause: error }
+    );
+  }
+}
+export {
+  importSharp
+};
+//# sourceMappingURL=data:application/json;base64,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