watchwhere 0.2.3 → 0.3.0

package/README.md

@@ -61,6 +61,10 @@ ww --version
 - self-host your own proxy from [`proxy/`](./proxy) if you'd rather not use
   the hosted one
 
+## attribution
+
+this product uses the TMDB API but is not endorsed or certified by TMDB.
+
 ## license
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchwhere",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "region-aware streaming availability CLI — find which of your subs has a given title",
   "type": "module",
   "bin": {

package/src/commands/init.ts

@@ -3,7 +3,12 @@ import { c } from "../colors.ts";
 import { loadConfig, saveConfig } from "../config.ts";
 import { resolveLocale, t } from "../i18n.ts";
 import { getCachedRegionProviders } from "../cache.ts";
-import { usingProxy, verifyToken } from "../tmdb.ts";
+import {
+  applyRegionPinning,
+  isSubscriptionProvider,
+  usingProxy,
+  verifyToken,
+} from "../tmdb.ts";
 import { pickLanguage } from "./lang.ts";
 
 export async function runInit(): Promise<void> {
@@ -50,7 +55,11 @@ export async function runInit(): Promise<void> {
   const language = await pickLanguage(m, existing?.language);
 
   process.stdout.write(c.dim(`  ${m.loadingProviders(region)}`));
-  const providers = await getCachedRegionProviders(region, tmdbToken.trim());
+  const allProviders = await getCachedRegionProviders(region, tmdbToken.trim());
+  const providers = applyRegionPinning(
+    allProviders.filter(isSubscriptionProvider),
+    region,
+  );
   console.log(c.dim(m.providersFound(providers.length)));
 
   if (providers.length === 0) {

package/src/commands/search.ts

@@ -4,10 +4,12 @@ import { resolveLocale, t } from "../i18n.ts";
 import { picker } from "../picker.ts";
 import { editableInput } from "../prompts.ts";
 import {
+  getReleaseDates,
   getWatchProviders,
   searchAll,
   type MediaItem,
   type TmdbProvider,
+  type TmdbReleaseDate,
 } from "../tmdb.ts";
 
 const PAGE_SIZE = 10;
@@ -34,6 +36,54 @@ function joinNames(providers: ReadonlyArray<TmdbProvider> | undefined): string {
   return providers?.map((p) => p.provider_name).join(", ") ?? "";
 }
 
+// pick at most one entry per modern format (4k / blu-ray / dvd), latest first.
+// older formats (laserdisc, vhs, steelbook, etc.) are dropped to keep output tight.
+const PHYSICAL_FORMATS: ReadonlyArray<{ key: string; match: RegExp }> = [
+  { key: "4k uhd", match: /\b(4k|uhd)\b/i },
+  { key: "blu-ray", match: /blu.?ray/i },
+  { key: "dvd", match: /\bdvd\b/i },
+];
+
+function printPhysical(
+  releases: ReadonlyArray<TmdbReleaseDate>,
+  region: string,
+  m: ReturnType<typeof t>,
+): void {
+  const physical = releases
+    .filter((r) => r.type === 5 && r.note.trim() !== "")
+    .sort((a, b) => b.release_date.localeCompare(a.release_date));
+  if (physical.length === 0) return;
+
+  const byFormat = new Map<string, TmdbReleaseDate>();
+  for (const r of physical) {
+    for (const fmt of PHYSICAL_FORMATS) {
+      if (fmt.match.test(r.note) && !byFormat.has(fmt.key)) {
+        byFormat.set(fmt.key, r);
+        break;
+      }
+    }
+  }
+  if (byFormat.size === 0) return;
+
+  const ordered = PHYSICAL_FORMATS.map((fmt) => byFormat.get(fmt.key)).filter(
+    (r): r is TmdbReleaseDate => r !== undefined,
+  );
+
+  console.log();
+  console.log(c.dim(`  ${m.physicalLabel} (${region})`));
+  const width = Math.max(
+    ...PHYSICAL_FORMATS.filter((fmt) => byFormat.has(fmt.key)).map(
+      (fmt) => fmt.key.length,
+    ),
+  );
+  for (const r of ordered) {
+    const key = PHYSICAL_FORMATS.find((fmt) => fmt.match.test(r.note))!.key;
+    const label = pad(key, width + 2);
+    const date = r.release_date.slice(0, 10);
+    console.log(`  ${c.dim(label)}${date}`);
+  }
+}
+
 async function pickItem(
   results: ReadonlyArray<MediaItem>,
   m: ReturnType<typeof t>,
@@ -86,7 +136,13 @@ async function displayItem(
   m: ReturnType<typeof t>,
 ): Promise<void> {
   process.stdout.write(c.dim(`  ${m.fetchingProviders(cfg.region)}`));
-  const providers = await getWatchProviders(item.id, item.mediaType, cfg.tmdbToken);
+  const [providers, releases] = await Promise.all([
+    getWatchProviders(item.id, item.mediaType, cfg.tmdbToken),
+    // physical releases only exist for movies; failures don't break the search
+    item.mediaType === "movie"
+      ? getReleaseDates(item.id, cfg.tmdbToken).catch(() => null)
+      : Promise.resolve(null),
+  ]);
   console.log(c.dim(m.done));
 
   const regionData = providers.results[cfg.region];
@@ -142,9 +198,21 @@ async function displayItem(
     if (buy.length > 0) console.log(`  ${pad(m.buy, 10)}${joinNames(buy)}`);
   }
 
-  if (regionData.link) {
-    console.log();
-    console.log(`  ${c.dim(m.link)}  ${c.cyan(regionData.link)}`);
+  if (releases) {
+    // physical release data on TMDB is sparse outside of US; if the user's
+    // region has nothing labeled, fall back to US so the feature still works
+    const inRegion =
+      releases.results.find((r) => r.iso_3166_1 === cfg.region)?.release_dates ?? [];
+    const hasLabeled = inRegion.some(
+      (r) => r.type === 5 && r.note.trim() !== "",
+    );
+    if (hasLabeled) {
+      printPhysical(inRegion, cfg.region, m);
+    } else {
+      const usReleases =
+        releases.results.find((r) => r.iso_3166_1 === "US")?.release_dates ?? [];
+      printPhysical(usReleases, "US", m);
+    }
   }
 }
 

package/src/commands/subs.ts

@@ -3,6 +3,7 @@ import { c } from "../colors.ts";
 import { loadConfig, saveConfig } from "../config.ts";
 import { resolveLocale, t } from "../i18n.ts";
 import { getCachedRegionProviders } from "../cache.ts";
+import { applyRegionPinning, isSubscriptionProvider } from "../tmdb.ts";
 
 export async function runSubs(): Promise<void> {
   const cfg = await loadConfig();
@@ -12,7 +13,11 @@ export async function runSubs(): Promise<void> {
   const m = t(resolveLocale(cfg.language));
 
   process.stdout.write(c.dim(`  ${m.loadingProviders(cfg.region)}`));
-  const providers = await getCachedRegionProviders(cfg.region, cfg.tmdbToken);
+  const allProviders = await getCachedRegionProviders(cfg.region, cfg.tmdbToken);
+  const providers = applyRegionPinning(
+    allProviders.filter(isSubscriptionProvider),
+    cfg.region,
+  );
   console.log(c.dim(m.providersFound(providers.length)));
 
   if (providers.length === 0) {

package/src/i18n.ts

@@ -52,7 +52,6 @@ interface Catalog {
   ads: string;
   rent: string;
   buy: string;
-  link: string;
 
   // config (show)
   noConfigYet: string;
@@ -130,6 +129,10 @@ interface Catalog {
 
   // update notifier
   updateAvailable: (version: string) => string;
+
+  // physical releases
+  physicalLabel: string;
+  noPhysicalRelease: string;
 }
 
 const en: Catalog = {
@@ -163,7 +166,6 @@ const en: Catalog = {
   ads: "ads",
   rent: "rent",
   buy: "buy",
-  link: "link",
 
   noConfigYet: "no config yet — run `ww init` first.",
   resolvingNames: "resolving subscription names… ",
@@ -235,6 +237,9 @@ const en: Catalog = {
   ambiguousQuery: (n) => `${n} matches, query is ambiguous. refine, or run interactively.`,
 
   updateAvailable: (version) => `new version available: ${version} (bun install -g watchwhere)`,
+
+  physicalLabel: "physical",
+  noPhysicalRelease: "no physical release in this region",
 };
 
 const tr: Catalog = {
@@ -270,7 +275,6 @@ const tr: Catalog = {
   ads: "reklamlı",
   rent: "kirala",
   buy: "satın al",
-  link: "bağlantı",
 
   noConfigYet: "henüz config yok — önce `ww init` çalıştır.",
   resolvingNames: "abonelik isimleri çözümleniyor… ",
@@ -343,6 +347,9 @@ const tr: Catalog = {
   ambiguousQuery: (n) => `${n} eşleşme var, sorgu belirsiz. daralt veya interaktif çalıştır.`,
 
   updateAvailable: (version) => `yeni sürüm var: ${version} (bun install -g watchwhere)`,
+
+  physicalLabel: "fiziksel",
+  noPhysicalRelease: "bu bölgede fiziksel release yok",
 };
 
 const CATALOGS: Record<Locale, Catalog> = { en, tr };

package/src/index.ts

@@ -144,7 +144,7 @@ async function maybeNotifyUpdate(): Promise<void> {
     const cfg = await loadConfig().catch(() => null);
     const m = t(resolveLocale(cfg?.language));
     console.log();
-    console.log(c.dim(`  ${c.yellow("›")} ${m.updateAvailable(newer)}`));
+    console.log(`  ${c.yellow("›")} ${c.dim(m.updateAvailable(newer))}`);
   } catch {
     // best-effort, never block exit
   }

package/src/tmdb.ts

@@ -72,6 +72,24 @@ export interface TmdbProvidersListResponse {
   readonly results: ReadonlyArray<TmdbProvider>;
 }
 
+export interface TmdbReleaseDate {
+  readonly certification: string;
+  readonly iso_639_1: string;
+  readonly note: string;
+  readonly release_date: string;
+  readonly type: number;
+}
+
+export interface TmdbReleaseDatesByRegion {
+  readonly iso_3166_1: string;
+  readonly release_dates: ReadonlyArray<TmdbReleaseDate>;
+}
+
+export interface TmdbReleaseDatesResponse {
+  readonly id: number;
+  readonly results: ReadonlyArray<TmdbReleaseDatesByRegion>;
+}
+
 export class TmdbError extends Error {
   constructor(
     message: string,
@@ -169,6 +187,16 @@ export function getWatchProviders(
   );
 }
 
+export function getReleaseDates(
+  id: number,
+  token: string,
+): Promise<TmdbReleaseDatesResponse> {
+  return tmdbFetch<TmdbReleaseDatesResponse>(
+    `/movie/${id}/release_dates`,
+    token,
+  );
+}
+
 export function toMediaItem(
   item: TmdbMovie | TmdbTv,
   mediaType: MediaType,
@@ -239,3 +267,50 @@ export async function verifyToken(token: string): Promise<boolean> {
     return false;
   }
 }
+
+// rental-only storefronts on TMDB. these aren't subscriptions, so they
+// shouldn't pollute the "your subs" picker. they still appear correctly
+// under rent/buy sections for individual movies.
+const RENTAL_ONLY_IDS: ReadonlySet<number> = new Set([
+  2,   // Apple TV (storefront, not Apple TV+)
+  3,   // Google Play Movies
+  7,   // Fandango at Home (formerly Vudu)
+  10,  // Amazon Video (a-la-carte rental, separate from Prime Video)
+  68,  // Microsoft Store
+  192, // YouTube (rental, separate from YouTube Premium)
+]);
+
+export function isSubscriptionProvider(provider: TmdbProvider): boolean {
+  return !RENTAL_ONLY_IDS.has(provider.provider_id);
+}
+
+// per-region pin order. provider ids listed here float to the top in the
+// listed order; everything else falls back to TMDB's display_priority.
+// regions not listed use TMDB order unchanged.
+const REGION_PIN_ORDER: Record<string, ReadonlyArray<number>> = {
+  TR: [
+    8,    // Netflix
+    119,  // Amazon Prime Video
+    337,  // Disney Plus
+    1899, // Max (HBO Max)
+    11,   // MUBI
+    188,  // YouTube Premium
+  ],
+};
+
+export function applyRegionPinning(
+  providers: ReadonlyArray<TmdbProvider>,
+  region: string,
+): ReadonlyArray<TmdbProvider> {
+  const pinned = REGION_PIN_ORDER[region];
+  if (!pinned || pinned.length === 0) return providers;
+  const orderById = new Map(pinned.map((id, i) => [id, i]));
+  const top: TmdbProvider[] = [];
+  const rest: TmdbProvider[] = [];
+  for (const p of providers) {
+    if (orderById.has(p.provider_id)) top.push(p);
+    else rest.push(p);
+  }
+  top.sort((a, b) => orderById.get(a.provider_id)! - orderById.get(b.provider_id)!);
+  return [...top, ...rest];
+}