@wular/pnext 0.0.3 → 0.0.6

package/src/compat/image-optimizer/cache.ts

@@ -9,31 +9,31 @@
 // images.maximumDiskCacheSize (0 disables writes entirely).
 // ---------------------------------------------------------------------------
 
-import { createHash } from 'node:crypto';
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
+import { createHash } from 'node:crypto'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
 
-export const IMAGE_CACHE_VERSION = 4;
+export const IMAGE_CACHE_VERSION = 4
 
 export function getHash(items: (string | number | Buffer)[]): string {
-  const hash = createHash('sha256');
+  const hash = createHash('sha256')
   for (const item of items) {
-    hash.update(typeof item === 'number' ? String(item) : item);
+    hash.update(typeof item === 'number' ? String(item) : item)
   }
-  return hash.digest('base64url');
+  return hash.digest('base64url')
 }
 
 export interface ImageCacheEntry {
-  buffer: Buffer;
-  etag: string;
-  upstreamEtag: string;
-  extension: string;
-  maxAge: number;
-  expireAt: number;
+  buffer: Buffer
+  etag: string
+  upstreamEtag: string
+  extension: string
+  maxAge: number
+  expireAt: number
 }
 
 export function imageCacheDir(root: string): string {
-  return path.join(root, '.next', 'cache', 'images');
+  return path.join(root, '.next', 'cache', 'images')
 }
 
 export async function readCacheEntry(
@@ -41,13 +41,13 @@ export async function readCacheEntry(
   cacheKey: string,
 ): Promise<ImageCacheEntry | undefined> {
   try {
-    const dir = path.join(cacheDir, cacheKey);
-    const files = await fs.readdir(dir);
-    const file = files[0];
-    if (!file) return undefined;
-    const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split('.', 5);
-    if (!etag || !upstreamEtag || !extension) return undefined;
-    const buffer = await fs.readFile(path.join(dir, file));
+    const dir = path.join(cacheDir, cacheKey)
+    const files = await fs.readdir(dir)
+    const file = files[0]
+    if (!file) return undefined
+    const [maxAgeSt, expireAtSt, etag, upstreamEtag, extension] = file.split('.', 5)
+    if (!etag || !upstreamEtag || !extension) return undefined
+    const buffer = await fs.readFile(path.join(dir, file))
     return {
       buffer,
       etag,
@@ -55,9 +55,9 @@ export async function readCacheEntry(
       extension,
       maxAge: Number(maxAgeSt),
       expireAt: Number(expireAtSt),
-    };
+    }
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
@@ -67,24 +67,24 @@ export async function writeCacheEntry(
   entry: ImageCacheEntry,
   maximumDiskCacheSize: number | undefined,
 ): Promise<void> {
-  if (maximumDiskCacheSize === 0) return;
+  if (maximumDiskCacheSize === 0) return
   if (maximumDiskCacheSize !== undefined && entry.buffer.byteLength > maximumDiskCacheSize) {
-    return;
+    return
   }
   try {
-    const dir = path.join(cacheDir, cacheKey);
+    const dir = path.join(cacheDir, cacheKey)
     const filename = path.join(
       dir,
       `${entry.maxAge}.${entry.expireAt}.${entry.etag}.${entry.upstreamEtag}.${entry.extension}`,
-    );
-    await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(filename, entry.buffer);
+    )
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined)
+    await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(filename, entry.buffer)
     if (maximumDiskCacheSize !== undefined) {
-      await evictToBudget(cacheDir, cacheKey, maximumDiskCacheSize);
+      await evictToBudget(cacheDir, cacheKey, maximumDiskCacheSize)
     }
   } catch (err) {
-    console.error(`Failed to write image to cache ${cacheKey}`, err);
+    console.error(`Failed to write image to cache ${cacheKey}`, err)
   }
 }
 
@@ -95,25 +95,27 @@ async function evictToBudget(
   keepKey: string,
   maximumDiskCacheSize: number,
 ): Promise<void> {
-  const keys = await fs.readdir(cacheDir).catch(() => [] as string[]);
-  const entries: { key: string; size: number; expireAt: number }[] = [];
-  let total = 0;
+  const keys = await fs.readdir(cacheDir).catch(() => [] as string[])
+  const entries: { key: string; size: number; expireAt: number }[] = []
+  let total = 0
   for (const key of keys) {
-    const dir = path.join(cacheDir, key);
-    const files = await fs.readdir(dir).catch(() => [] as string[]);
-    const file = files[0];
-    if (!file) continue;
-    const stat = await fs.stat(path.join(dir, file)).catch(() => null);
-    if (!stat) continue;
-    total += stat.size;
-    entries.push({ key, size: stat.size, expireAt: Number(file.split('.', 2)[1]) || 0 });
+    const dir = path.join(cacheDir, key)
+    const files = await fs.readdir(dir).catch(() => [] as string[])
+    const file = files[0]
+    if (!file) continue
+    const stat = await fs.stat(path.join(dir, file)).catch(() => null)
+    if (!stat) continue
+    total += stat.size
+    entries.push({ key, size: stat.size, expireAt: Number(file.split('.', 2)[1]) || 0 })
   }
-  if (total <= maximumDiskCacheSize) return;
-  entries.sort((a, b) => a.expireAt - b.expireAt);
+  if (total <= maximumDiskCacheSize) return
+  entries.sort((a, b) => a.expireAt - b.expireAt)
   for (const entry of entries) {
-    if (total <= maximumDiskCacheSize) break;
-    if (entry.key === keepKey) continue;
-    await fs.rm(path.join(cacheDir, entry.key), { recursive: true, force: true }).catch(() => undefined);
-    total -= entry.size;
+    if (total <= maximumDiskCacheSize) break
+    if (entry.key === keepKey) continue
+    await fs
+      .rm(path.join(cacheDir, entry.key), { recursive: true, force: true })
+      .catch(() => undefined)
+    total -= entry.size
   }
 }

package/src/compat/image-optimizer/detect.ts

@@ -3,25 +3,25 @@
 // serve-static tables so the optimizer classifies sources (bypass vs optimize vs reject) exactly like
 // Next.
 
-export const AVIF = 'image/avif';
-export const WEBP = 'image/webp';
-export const PNG = 'image/png';
-export const JPEG = 'image/jpeg';
-export const JXL = 'image/jxl';
-export const JP2 = 'image/jp2';
-export const HEIC = 'image/heic';
-export const GIF = 'image/gif';
-export const SVG = 'image/svg+xml';
-export const ICO = 'image/x-icon';
-export const ICNS = 'image/x-icns';
-export const TIFF = 'image/tiff';
-export const BMP = 'image/bmp';
-export const PDF = 'application/pdf';
+export const AVIF = 'image/avif'
+export const WEBP = 'image/webp'
+export const PNG = 'image/png'
+export const JPEG = 'image/jpeg'
+export const JXL = 'image/jxl'
+export const JP2 = 'image/jp2'
+export const HEIC = 'image/heic'
+export const GIF = 'image/gif'
+export const SVG = 'image/svg+xml'
+export const ICO = 'image/x-icon'
+export const ICNS = 'image/x-icns'
+export const TIFF = 'image/tiff'
+export const BMP = 'image/bmp'
+export const PDF = 'application/pdf'
 
 /** Animated variants of these are served as-is (never re-encoded). */
-export const ANIMATABLE_TYPES = [WEBP, PNG, GIF];
+export const ANIMATABLE_TYPES = [WEBP, PNG, GIF]
 /** Types sharp never re-encodes — passthrough with the original bytes. */
-export const BYPASS_TYPES = [SVG, ICO, ICNS, BMP, JXL, HEIC];
+export const BYPASS_TYPES = [SVG, ICO, ICNS, BMP, JXL, HEIC]
 
 const EXTENSION_BY_TYPE: Record<string, string> = {
   [AVIF]: 'avif',
@@ -37,25 +37,25 @@ const EXTENSION_BY_TYPE: Record<string, string> = {
   [ICNS]: 'icns',
   [TIFF]: 'tiff',
   [BMP]: 'bmp',
-};
+}
 
 const TYPE_BY_EXTENSION: Record<string, string> = Object.fromEntries(
   Object.entries(EXTENSION_BY_TYPE).map(([type, ext]) => [ext, type]),
-);
+)
 
 /** File extension for a content type (Next's getExtension); undefined if unknown. */
 export function extensionForType(contentType: string): string | undefined {
-  return EXTENSION_BY_TYPE[contentType];
+  return EXTENSION_BY_TYPE[contentType]
 }
 
 /** Content type for a cache-file extension (Next's getContentType). */
 export function typeForExtension(extension: string): string | undefined {
-  return TYPE_BY_EXTENSION[extension];
+  return TYPE_BY_EXTENSION[extension]
 }
 
 function startsWithBytes(buffer: Buffer, bytes: number[]): boolean {
   // A zero in the signature is a wildcard byte (Next's convention).
-  return bytes.every((b, i) => !b || buffer[i] === b);
+  return bytes.every((b, i) => !b || buffer[i] === b)
 }
 
 /**
@@ -64,72 +64,72 @@ function startsWithBytes(buffer: Buffer, bytes: number[]): boolean {
  * unknown formats.
  */
 export function detectContentType(buffer: Buffer): string | null {
-  if (buffer.byteLength === 0) return null;
-  if ([0xff, 0xd8, 0xff].every((b, i) => buffer[i] === b)) return JPEG;
+  if (buffer.byteLength === 0) return null
+  if ([0xff, 0xd8, 0xff].every((b, i) => buffer[i] === b)) return JPEG
   if ([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every((b, i) => buffer[i] === b)) {
-    return PNG;
+    return PNG
   }
-  if ([0x47, 0x49, 0x46, 0x38].every((b, i) => buffer[i] === b)) return GIF;
+  if ([0x47, 0x49, 0x46, 0x38].every((b, i) => buffer[i] === b)) return GIF
   if (startsWithBytes(buffer, [0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0, 0x57, 0x45, 0x42, 0x50])) {
-    return WEBP;
+    return WEBP
   }
-  if ([0x3c, 0x3f, 0x78, 0x6d, 0x6c].every((b, i) => buffer[i] === b)) return SVG;
-  if ([0x3c, 0x73, 0x76, 0x67].every((b, i) => buffer[i] === b)) return SVG;
+  if ([0x3c, 0x3f, 0x78, 0x6d, 0x6c].every((b, i) => buffer[i] === b)) return SVG
+  if ([0x3c, 0x73, 0x76, 0x67].every((b, i) => buffer[i] === b)) return SVG
   if (startsWithBytes(buffer, [0, 0, 0, 0, 0x66, 0x74, 0x79, 0x70, 0x61, 0x76, 0x69, 0x66])) {
-    return AVIF;
+    return AVIF
   }
-  if ([0x00, 0x00, 0x01, 0x00].every((b, i) => buffer[i] === b)) return ICO;
-  if ([0x69, 0x63, 0x6e, 0x73].every((b, i) => buffer[i] === b)) return ICNS;
-  if ([0x49, 0x49, 0x2a, 0x00].every((b, i) => buffer[i] === b)) return TIFF;
-  if ([0x4d, 0x4d, 0x00, 0x2a].every((b, i) => buffer[i] === b)) return TIFF;
-  if ([0x42, 0x4d].every((b, i) => buffer[i] === b)) return BMP;
-  if ([0xff, 0x0a].every((b, i) => buffer[i] === b)) return JXL;
+  if ([0x00, 0x00, 0x01, 0x00].every((b, i) => buffer[i] === b)) return ICO
+  if ([0x69, 0x63, 0x6e, 0x73].every((b, i) => buffer[i] === b)) return ICNS
+  if ([0x49, 0x49, 0x2a, 0x00].every((b, i) => buffer[i] === b)) return TIFF
+  if ([0x4d, 0x4d, 0x00, 0x2a].every((b, i) => buffer[i] === b)) return TIFF
+  if ([0x42, 0x4d].every((b, i) => buffer[i] === b)) return BMP
+  if ([0xff, 0x0a].every((b, i) => buffer[i] === b)) return JXL
   if (
     [0x00, 0x00, 0x00, 0x0c, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every(
       (b, i) => buffer[i] === b,
     )
   ) {
-    return JXL;
+    return JXL
   }
   if (startsWithBytes(buffer, [0, 0, 0, 0, 0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63])) {
-    return HEIC;
+    return HEIC
   }
-  if ([0x25, 0x50, 0x44, 0x46, 0x2d].every((b, i) => buffer[i] === b)) return PDF;
+  if ([0x25, 0x50, 0x44, 0x46, 0x2d].every((b, i) => buffer[i] === b)) return PDF
   if (
     [0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every(
       (b, i) => buffer[i] === b,
     )
   ) {
-    return JP2;
+    return JP2
   }
   // SVG documents may start with whitespace/comments/doctype before <svg.
-  const head = buffer.toString('utf8', 0, Math.min(buffer.length, 512)).trimStart();
-  if (/^(<\?xml|<!doctype svg|<svg)/i.test(head)) return SVG;
-  return null;
+  const head = buffer.toString('utf8', 0, Math.min(buffer.length, 512)).trimStart()
+  if (/^(<\?xml|<!doctype svg|<svg)/i.test(head)) return SVG
+  return null
 }
 
 /** True when a gif/apng/webp buffer contains multiple frames (Next's is-animated). */
 export function isAnimated(buffer: Buffer): boolean {
   // GIF: more than one Graphics Control Extension block (0x21 0xF9 0x04).
   if (buffer.length > 6 && buffer.toString('ascii', 0, 3) === 'GIF') {
-    let frames = 0;
+    let frames = 0
     for (let i = 0; i < buffer.length - 2; i++) {
       if (buffer[i] === 0x21 && buffer[i + 1] === 0xf9 && buffer[i + 2] === 0x04) {
-        frames++;
-        if (frames > 1) return true;
+        frames++
+        if (frames > 1) return true
       }
     }
-    return false;
+    return false
   }
   // APNG: an acTL chunk appearing before the first IDAT chunk.
   if (
     buffer.length > 8 &&
     [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every((b, i) => buffer[i] === b)
   ) {
-    const actl = buffer.indexOf('acTL');
-    if (actl === -1) return false;
-    const idat = buffer.indexOf('IDAT');
-    return idat === -1 || actl < idat;
+    const actl = buffer.indexOf('acTL')
+    if (actl === -1) return false
+    const idat = buffer.indexOf('IDAT')
+    return idat === -1 || actl < idat
   }
   // WebP: an ANIM chunk inside a VP8X container.
   if (
@@ -137,7 +137,7 @@ export function isAnimated(buffer: Buffer): boolean {
     buffer.toString('ascii', 0, 4) === 'RIFF' &&
     buffer.toString('ascii', 8, 12) === 'WEBP'
   ) {
-    return buffer.includes('ANIM');
+    return buffer.includes('ANIM')
   }
-  return false;
+  return false
 }