1import path from "node:path";
2import type { MediaKind } from "./types";
3 
4const IMAGE_EXTENSIONS = new Set([
5  "jpg",
6  "jpeg",
7  "png",
8  "webp",
9  "gif",
10  "bmp",
11  "avif",
12  "heic",
13  "heif",
14  "svg",
15]);
16 
17const VIDEO_EXTENSIONS = new Set(["mp4", "m4v", "mov", "webm", "mkv"]);
18 
19const MIME_EXTENSION_MAP: Record<string, string> = {
20  "image/jpeg": "jpg",
21  "image/jpg": "jpg",
22  "image/png": "png",
23  "image/webp": "webp",
24  "image/gif": "gif",
25  "image/bmp": "bmp",
26  "image/avif": "avif",
27  "image/heic": "heic",
28  "image/heif": "heif",
29  "image/svg+xml": "svg",
30  "video/mp4": "mp4",
31  "video/webm": "webm",
32  "video/quicktime": "mov",
33  "video/x-m4v": "m4v",
34};
35 
36export function normalizeContentType(raw: string | null): string {
37  return raw?.split(";")[0]?.trim().toLowerCase() ?? "";
38}
39 
40export function normalizeExtension(raw: string | undefined | null): string | undefined {
41  if (!raw) {
42    return undefined;
43  }
44  const trimmed = raw.replace(/^\./, "").trim().toLowerCase();
45  if (!trimmed) {
46    return undefined;
47  }
48  if (trimmed === "jpeg" || trimmed === "jpg") {
49    return "jpg";
50  }
51  return trimmed;
52}
53 
54export function resolveExtensionFromUrl(rawUrl: string): string | undefined {
55  try {
56    const parsed = new URL(rawUrl);
57    const extFromPath = normalizeExtension(path.posix.extname(parsed.pathname));
58    if (extFromPath) {
59      return extFromPath;
60    }
61    const extFromFormat = normalizeExtension(parsed.searchParams.get("format"));
62    if (extFromFormat) {
63      return extFromFormat;
64    }
65  } catch {
66    return undefined;
67  }
68  return undefined;
69}
70 
71export function resolveExtensionFromContentType(contentType: string): string | undefined {
72  return normalizeExtension(MIME_EXTENSION_MAP[contentType]);
73}
74 
75export function resolveKindFromContentType(contentType: string): MediaKind | undefined {
76  if (!contentType) {
77    return undefined;
78  }
79  if (contentType.startsWith("image/")) {
80    return "image";
81  }
82  if (contentType.startsWith("video/")) {
83    return "video";
84  }
85  return undefined;
86}
87 
88export function resolveKindFromExtension(extension: string | undefined): MediaKind | undefined {
89  if (!extension) {
90    return undefined;
91  }
92  if (IMAGE_EXTENSIONS.has(extension)) {
93    return "image";
94  }
95  if (VIDEO_EXTENSIONS.has(extension)) {
96    return "video";
97  }
98  return undefined;
99}
100 
101export function resolveMediaKind(
102  rawUrl: string,
103  contentType: string,
104  extension: string | undefined,
105  hint?: MediaKind,
106): MediaKind | undefined {
107  const kindFromType = resolveKindFromContentType(contentType);
108  if (kindFromType) {
109    return kindFromType;
110  }
111 
112  const kindFromExtension = resolveKindFromExtension(extension);
113  if (kindFromExtension) {
114    return kindFromExtension;
115  }
116 
117  if (contentType && contentType !== "application/octet-stream") {
118    return undefined;
119  }
120 
121  if (hint) {
122    return hint;
123  }
124 
125  if (rawUrl.startsWith("data:image/")) {
126    return "image";
127  }
128 
129  if (rawUrl.startsWith("data:video/")) {
130    return "video";
131  }
132 
133  return undefined;
134}
135 
136export function resolveOutputExtension(
137  contentType: string,
138  extension: string | undefined,
139  kind: MediaKind,
140): string {
141  const fromMime = resolveExtensionFromContentType(contentType);
142  if (fromMime) {
143    return fromMime;
144  }
145  const normalized = normalizeExtension(extension);
146  if (normalized) {
147    return normalized;
148  }
149  return kind === "video" ? "mp4" : "jpg";
150}
151 
152export function isDataUri(value: string): boolean {
153  return value.startsWith("data:");
154}
155 
156export function safeDecodeURIComponent(value: string): string {
157  try {
158    return decodeURIComponent(value);
159  } catch {
160    return value;
161  }
162}
163 
164function extractEmbeddedUrl(value: string): string | undefined {
165  const encodedMatch = value.match(/https?%3A%2F%2F.+$/i)?.[0];
166  if (encodedMatch) {
167    const decoded = safeDecodeURIComponent(encodedMatch);
168    try {
169      return new URL(decoded).href;
170    } catch {
171      return undefined;
172    }
173  }
174 
175  const literalMatch = value.match(/https?:\/\/.+$/i)?.[0];
176  if (!literalMatch) {
177    return undefined;
178  }
179 
180  try {
181    return new URL(literalMatch).href;
182  } catch {
183    return undefined;
184  }
185}
186 
187export function normalizeMediaUrl(rawUrl: string): string {
188  if (isDataUri(rawUrl)) {
189    return rawUrl;
190  }
191 
192  try {
193    const parsed = new URL(rawUrl);
194    const hostname = parsed.hostname.toLowerCase();
195 
196    if (hostname === "substackcdn.com" || hostname.endsWith(".substackcdn.com")) {
197      const embeddedUrl = extractEmbeddedUrl(`${parsed.pathname}${parsed.search}`);
198      if (embeddedUrl) {
199        return embeddedUrl;
200      }
201    }
202 
203    return parsed.href;
204  } catch {
205    return rawUrl;
206  }
207}
208 
209export function sanitizeFileSegment(input: string): string {
210  return input
211    .replace(/[^a-zA-Z0-9_-]+/g, "-")
212    .replace(/-+/g, "-")
213    .replace(/^[-_]+|[-_]+$/g, "")
214    .slice(0, 48);
215}
216 
217export function resolveFileStem(rawUrl: string, extension: string, fileNameHint?: string): string {
218  const hintBase = fileNameHint?.trim();
219  if (hintBase) {
220    const parsed = path.posix.parse(hintBase);
221    const stem = parsed.name || parsed.base;
222    return sanitizeFileSegment(stem);
223  }
224 
225  if (isDataUri(rawUrl)) {
226    return "";
227  }
228 
229  try {
230    const parsed = new URL(rawUrl);
231    const base = path.posix.basename(parsed.pathname);
232    if (!base) {
233      return "";
234    }
235    const decodedBase = safeDecodeURIComponent(base);
236    const normalizedExtension = normalizeExtension(extension);
237    const stripExtension = normalizedExtension ? new RegExp(`\\.${normalizedExtension}$`, "i") : null;
238    const rawStem = stripExtension ? decodedBase.replace(stripExtension, "") : decodedBase;
239    return sanitizeFileSegment(rawStem);
240  } catch {
241    return "";
242  }
243}
244 
245export function buildFileName(
246  kind: MediaKind,
247  index: number,
248  sourceUrl: string,
249  extension: string,
250  fileNameHint?: string,
251): string {
252  const stem = resolveFileStem(sourceUrl, extension, fileNameHint);
253  const prefix = kind === "image" ? "img" : "video";
254  const serial = String(index).padStart(3, "0");
255  const suffix = stem ? `-${stem}` : "";
256  return `${prefix}-${serial}${suffix}.${extension}`;
257}
258 
259export function toPosixPath(value: string): string {
260  return value.split(path.sep).join(path.posix.sep);
261}
262