@wular/pnext 0.0.4 → 0.0.7

package/src/compat/next/image/config.ts

@@ -8,44 +8,44 @@
 // accepts.
 // ---------------------------------------------------------------------------
 
-import { getNextConfig } from '../config-loader';
+import { getNextConfig } from '../config-loader'
 
 export interface LocalPattern {
-  pathname?: string;
-  search?: string;
+  pathname?: string
+  search?: string
 }
 
 export interface RemotePattern {
-  protocol?: string;
-  hostname?: string;
-  port?: string;
-  pathname?: string;
-  search?: string;
+  protocol?: string
+  hostname?: string
+  port?: string
+  pathname?: string
+  search?: string
 }
 
 export interface ResolvedImagesConfig {
-  deviceSizes: number[];
-  imageSizes: number[];
+  deviceSizes: number[]
+  imageSizes: number[]
   /** deviceSizes + imageSizes, sorted ascending (Next's `allSizes`). */
-  allSizes: number[];
-  qualities: number[] | undefined;
-  formats: string[];
-  path: string;
-  loader: string;
-  loaderFile: string;
-  domains: string[];
-  disableStaticImages: boolean;
-  minimumCacheTTL: number;
-  maximumRedirects: number;
-  maximumResponseBody: number;
-  dangerouslyAllowLocalIP: boolean;
-  dangerouslyAllowSVG: boolean;
-  contentSecurityPolicy: string;
-  contentDispositionType: string;
-  localPatterns: LocalPattern[] | undefined;
-  remotePatterns: RemotePattern[];
-  unoptimized: boolean;
-  customCacheHandler: boolean;
+  allSizes: number[]
+  qualities: number[] | undefined
+  formats: string[]
+  path: string
+  loader: string
+  loaderFile: string
+  domains: string[]
+  disableStaticImages: boolean
+  minimumCacheTTL: number
+  maximumRedirects: number
+  maximumResponseBody: number
+  dangerouslyAllowLocalIP: boolean
+  dangerouslyAllowSVG: boolean
+  contentSecurityPolicy: string
+  contentDispositionType: string
+  localPatterns: LocalPattern[] | undefined
+  remotePatterns: RemotePattern[]
+  unoptimized: boolean
+  customCacheHandler: boolean
 }
 
 const DEFAULTS = {
@@ -69,41 +69,39 @@ const DEFAULTS = {
   qualities: [75] as number[] | undefined,
   unoptimized: false,
   customCacheHandler: false,
-} as const;
+} as const
 
-let cached: { key: unknown; value: ResolvedImagesConfig } | undefined;
+let cached: { key: unknown; value: ResolvedImagesConfig } | undefined
 
 function asNumberArray(value: unknown, fallback: number[]): number[] {
-  if (!Array.isArray(value)) return fallback;
-  const nums = value.filter((v): v is number => typeof v === 'number');
-  return nums.length > 0 ? nums : fallback;
+  if (!Array.isArray(value)) return fallback
+  const nums = value.filter((v): v is number => typeof v === 'number')
+  return nums.length > 0 ? nums : fallback
 }
 
 /** The app's resolved images config, defaults overlaid with next.config.images. */
 export function getImagesConfig(): ResolvedImagesConfig {
-  const raw = getNextConfig().images;
-  if (cached && cached.key === raw) return cached.value;
-  const images = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>;
+  const raw = getNextConfig().images
+  if (cached && cached.key === raw) return cached.value
+  const images = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
 
   const deviceSizes = asNumberArray(images.deviceSizes, [...DEFAULTS.deviceSizes]).sort(
     (a, b) => a - b,
-  );
+  )
   const imageSizes = asNumberArray(images.imageSizes, [...DEFAULTS.imageSizes]).sort(
     (a, b) => a - b,
-  );
+  )
   const qualities =
     images.qualities === undefined
       ? [...(DEFAULTS.qualities ?? [])]
-      : asNumberArray(images.qualities, [...(DEFAULTS.qualities ?? [])]).sort((a, b) => a - b);
+      : asNumberArray(images.qualities, [...(DEFAULTS.qualities ?? [])]).sort((a, b) => a - b)
 
   const value: ResolvedImagesConfig = {
     deviceSizes,
     imageSizes,
     allSizes: [...deviceSizes, ...imageSizes].sort((a, b) => a - b),
     qualities,
-    formats: Array.isArray(images.formats)
-      ? (images.formats as string[])
-      : [...DEFAULTS.formats],
+    formats: Array.isArray(images.formats) ? (images.formats as string[]) : [...DEFAULTS.formats],
     path: typeof images.path === 'string' ? images.path : DEFAULTS.path,
     loader: typeof images.loader === 'string' ? images.loader : DEFAULTS.loader,
     loaderFile: typeof images.loaderFile === 'string' ? images.loaderFile : DEFAULTS.loaderFile,
@@ -145,21 +143,21 @@ export function getImagesConfig(): ResolvedImagesConfig {
     unoptimized:
       typeof images.unoptimized === 'boolean' ? images.unoptimized : DEFAULTS.unoptimized,
     customCacheHandler: Boolean(images.customCacheHandler),
-  };
-  cached = { key: raw, value };
-  return value;
+  }
+  cached = { key: raw, value }
+  return value
 }
 
 function normalizeLocalPatterns(value: unknown): LocalPattern[] | undefined {
-  if (!Array.isArray(value)) return undefined;
+  if (!Array.isArray(value)) return undefined
   const patterns = value.map(entry => {
-    if (typeof entry === 'string') return { pathname: entry, search: '' };
-    const obj = (entry ?? {}) as Record<string, unknown>;
+    if (typeof entry === 'string') return { pathname: entry, search: '' }
+    const obj = (entry ?? {}) as Record<string, unknown>
     return {
       pathname: typeof obj.pathname === 'string' ? obj.pathname : undefined,
       search: typeof obj.search === 'string' ? obj.search : undefined,
-    };
-  });
+    }
+  })
   // Next implicitly allows statically-imported media once localPatterns is
   // configured, so build-time optimized static images keep loading. Appended to
   // the normalized list so the runtime check and the images-manifest writer
@@ -167,12 +165,12 @@ function normalizeLocalPatterns(value: unknown): LocalPattern[] | undefined {
   patterns.push(
     { pathname: '/_next/static/media/**', search: '' },
     { pathname: '/_next/static/immutable/media/**', search: '' },
-  );
-  return patterns;
+  )
+  return patterns
 }
 
 function normalizeRemotePatterns(value: unknown): RemotePattern[] {
-  if (!Array.isArray(value)) return [];
+  if (!Array.isArray(value)) return []
   return value.map(entry => {
     // next.config may pass a URL instance (new URL('https://host/**')).
     if (entry instanceof URL) {
@@ -182,15 +180,15 @@ function normalizeRemotePatterns(value: unknown): RemotePattern[] {
         ...(entry.port ? { port: entry.port } : {}),
         pathname: entry.pathname,
         search: entry.search,
-      };
+      }
     }
-    const obj = (entry ?? {}) as Record<string, unknown>;
+    const obj = (entry ?? {}) as Record<string, unknown>
     return {
       protocol: typeof obj.protocol === 'string' ? obj.protocol : undefined,
       hostname: typeof obj.hostname === 'string' ? obj.hostname : undefined,
       port: typeof obj.port === 'string' ? obj.port : undefined,
       pathname: typeof obj.pathname === 'string' ? obj.pathname : undefined,
       search: typeof obj.search === 'string' ? obj.search : undefined,
-    };
-  });
+    }
+  })
 }

package/src/compat/next/image/optimizer.ts

@@ -6,62 +6,66 @@
 // and the build-time blur-placeholder generator for static imports.
 // ---------------------------------------------------------------------------
 
-import type { ResolvedImagesConfig } from './config';
+import type { ResolvedImagesConfig } from './config'
 
-export { serveImageOptimizer } from '../../image-optimizer';
+export { serveImageOptimizer } from '../../image-optimizer/optimize'
 
-const BLUR_QUALITY = 70;
+const BLUR_QUALITY = 70
 
 interface SharpPipeline {
-  resize(options: { width?: number; height?: number; withoutEnlargement?: boolean }): SharpPipeline;
-  webp(options: { quality: number }): SharpPipeline;
-  avif(options: { quality: number }): SharpPipeline;
-  png(options: { quality: number }): SharpPipeline;
-  jpeg(options: { quality: number; mozjpeg?: boolean }): SharpPipeline;
-  toBuffer(): Promise<Buffer>;
+  resize(options: { width?: number; height?: number; withoutEnlargement?: boolean }): SharpPipeline
+  webp(options: { quality: number }): SharpPipeline
+  avif(options: { quality: number }): SharpPipeline
+  png(options: { quality: number }): SharpPipeline
+  jpeg(options: { quality: number; mozjpeg?: boolean }): SharpPipeline
+  toBuffer(): Promise<Buffer>
 }
 
-type SharpModule = (input: Buffer | Uint8Array) => SharpPipeline;
+type SharpModule = (input: Buffer | Uint8Array) => SharpPipeline
 
-let sharpPromise: Promise<SharpModule | undefined> | undefined;
+let sharpPromise: Promise<SharpModule | undefined> | undefined
 function loadSharp(): Promise<SharpModule | undefined> {
   if (!sharpPromise) {
     sharpPromise = import('sharp')
       .then(m => (m.default ?? m) as unknown as SharpModule)
-      .catch(() => undefined);
+      .catch(() => undefined)
   }
-  return sharpPromise;
+  return sharpPromise
 }
 
 /** True if this request is for the image optimizer endpoint. */
 export function isImageOptimizerRequest(url: URL, config: ResolvedImagesConfig): boolean {
   // `/_next/image/` (trailingSlash: true apps) is served the same as the bare
   // path — the interceptor runs before core's trailing-slash normalization.
-  return url.pathname === config.path || url.pathname === `${config.path}/`;
+  return url.pathname === config.path || url.pathname === `${config.path}/`
 }
 
-const VALID_BLUR_EXT = new Set(['jpeg', 'jpg', 'png', 'webp', 'avif']);
+const VALID_BLUR_EXT = new Set(['jpeg', 'jpg', 'png', 'webp', 'avif'])
 
 /** True for animated webp/gif/avif — Next skips blur-placeholder generation for these. */
 function isAnimated(buffer: Buffer): boolean {
   // WebP: an 'ANIM' chunk under a VP8X container.
-  if (buffer.length > 16 && buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP') {
-    return buffer.includes(Buffer.from('ANIM', 'ascii'));
+  if (
+    buffer.length > 16 &&
+    buffer.toString('ascii', 0, 4) === 'RIFF' &&
+    buffer.toString('ascii', 8, 12) === 'WEBP'
+  ) {
+    return buffer.includes(Buffer.from('ANIM', 'ascii'))
   }
   // GIF: more than one image descriptor (0x2C) block before the trailer (0x3B).
   if (buffer.length > 6 && buffer.toString('ascii', 0, 3) === 'GIF') {
-    let frames = 0;
+    let frames = 0
     for (let i = 6; i < buffer.length; i++) {
-      if (buffer[i] === 0x2c) frames++;
-      if (frames > 1) return true;
+      if (buffer[i] === 0x2c) frames++
+      if (frames > 1) return true
     }
-    return false;
+    return false
   }
   // AVIF: 'avis' major/compatible brand in the ftyp box signals an image sequence.
   if (buffer.length > 16 && buffer.toString('ascii', 4, 8) === 'ftyp') {
-    return buffer.toString('ascii', 8, 200).includes('avis');
+    return buffer.toString('ascii', 8, 200).includes('avis')
   }
-  return false;
+  return false
 }
 
 /**
@@ -77,20 +81,20 @@ export async function generateBlurDataURL(
   blurWidth: number,
   blurHeight: number,
 ): Promise<string | undefined> {
-  const extension = ext === 'jpg' ? 'jpeg' : ext;
-  if (!VALID_BLUR_EXT.has(extension) || isAnimated(buffer)) return undefined;
-  const sharp = await loadSharp();
-  if (!sharp) return undefined;
+  const extension = ext === 'jpg' ? 'jpeg' : ext
+  if (!VALID_BLUR_EXT.has(extension) || isAnimated(buffer)) return undefined
+  const sharp = await loadSharp()
+  if (!sharp) return undefined
   try {
-    const pipeline = sharp(buffer).resize({ width: blurWidth, height: blurHeight });
-    let out: SharpPipeline;
-    if (extension === 'png') out = pipeline.png({ quality: BLUR_QUALITY });
-    else if (extension === 'webp') out = pipeline.webp({ quality: BLUR_QUALITY });
-    else if (extension === 'avif') out = pipeline.avif({ quality: BLUR_QUALITY });
-    else out = pipeline.jpeg({ quality: BLUR_QUALITY, mozjpeg: true });
-    const resized = await out.toBuffer();
-    return `data:image/${extension};base64,${resized.toString('base64')}`;
+    const pipeline = sharp(buffer).resize({ width: blurWidth, height: blurHeight })
+    let out: SharpPipeline
+    if (extension === 'png') out = pipeline.png({ quality: BLUR_QUALITY })
+    else if (extension === 'webp') out = pipeline.webp({ quality: BLUR_QUALITY })
+    else if (extension === 'avif') out = pipeline.avif({ quality: BLUR_QUALITY })
+    else out = pipeline.jpeg({ quality: BLUR_QUALITY, mozjpeg: true })
+    const resized = await out.toBuffer()
+    return `data:image/${extension};base64,${resized.toString('base64')}`
   } catch {
-    return undefined;
+    return undefined
   }
 }

package/src/compat/next/image/patterns.ts

@@ -5,31 +5,31 @@
 // whether a requested `url` is allowed (else 400).
 // ---------------------------------------------------------------------------
 
-import type { LocalPattern, RemotePattern } from './config';
+import type { LocalPattern, RemotePattern } from './config'
 
 function makePathnameRegex(pathname: string): RegExp {
   // Convert a Next path-to-regexp style glob ('/assets/**') into a RegExp.
   // '**' matches any depth; '*' matches a single segment.
-  let source = '';
-  const escaped = pathname.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  let source = ''
+  const escaped = pathname.replace(/[.+?^${}()|[\]\\]/g, '\\$&')
   // Handle ** then * (double-star must be processed first).
-  source = escaped.replace(/\/\*\*/g, '(?:/.*)?').replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
-  return new RegExp(`^${source}$`);
+  source = escaped
+    .replace(/\/\*\*/g, '(?:/.*)?')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '[^/]*')
+  return new RegExp(`^${source}$`)
 }
 
-export function hasLocalMatch(
-  localPatterns: LocalPattern[] | undefined,
-  url: URL,
-): boolean {
+export function hasLocalMatch(localPatterns: LocalPattern[] | undefined, url: URL): boolean {
   // undefined localPatterns => allow all local images (Next default).
-  if (localPatterns === undefined) return true;
+  if (localPatterns === undefined) return true
   return localPatterns.some(pattern => {
     if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
-      return false;
+      return false
     }
-    if (pattern.search !== undefined && pattern.search !== url.search) return false;
-    return true;
-  });
+    if (pattern.search !== undefined && pattern.search !== url.search) return false
+    return true
+  })
 }
 
 export function hasRemoteMatch(
@@ -37,42 +37,39 @@ export function hasRemoteMatch(
   remotePatterns: RemotePattern[],
   url: URL,
 ): boolean {
-  if (domains.includes(url.hostname)) return true;
+  if (domains.includes(url.hostname)) return true
   return remotePatterns.some(pattern => {
     if (pattern.protocol !== undefined && pattern.protocol !== url.protocol.replace(/:$/, '')) {
-      return false;
+      return false
     }
     if (pattern.hostname !== undefined && !matchHostname(pattern.hostname, url.hostname)) {
-      return false;
+      return false
     }
     if (pattern.port !== undefined && pattern.port !== '' && pattern.port !== url.port) {
-      return false;
+      return false
     }
-    if (
-      pattern.pathname !== undefined &&
-      !makePathnameRegex(pattern.pathname).test(url.pathname)
-    ) {
-      return false;
+    if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
+      return false
     }
     if (pattern.search !== undefined && pattern.search !== '' && pattern.search !== url.search) {
-      return false;
+      return false
     }
-    return true;
-  });
+    return true
+  })
 }
 
 function matchHostname(pattern: string, hostname: string): boolean {
   if (pattern.startsWith('**.')) {
-    const suffix = pattern.slice(2); // ".example.com"
-    return hostname.endsWith(suffix) && hostname.length > suffix.length;
+    const suffix = pattern.slice(2) // ".example.com"
+    return hostname.endsWith(suffix) && hostname.length > suffix.length
   }
   if (pattern.startsWith('*.')) {
-    const suffix = pattern.slice(1);
-    if (!hostname.endsWith(suffix)) return false;
-    const sub = hostname.slice(0, -suffix.length);
-    return sub.length > 0 && !sub.includes('.');
+    const suffix = pattern.slice(1)
+    if (!hostname.endsWith(suffix)) return false
+    const sub = hostname.slice(0, -suffix.length)
+    return sub.length > 0 && !sub.includes('.')
   }
-  return pattern === hostname;
+  return pattern === hostname
 }
 
 /**
@@ -83,21 +80,21 @@ function matchHostname(pattern: string, hostname: string): boolean {
 export function manifestLocalPatterns(
   localPatterns: LocalPattern[] | undefined,
 ): { pathname: string; search: string }[] {
-  const patterns = localPatterns ?? [{ pathname: undefined, search: '' }];
+  const patterns = localPatterns ?? [{ pathname: undefined, search: '' }]
   const entries = patterns.map(pattern => ({
     pathname: compileLocalPathname(pattern.pathname),
     search: pattern.search ?? '',
-  }));
-  return entries;
+  }))
+  return entries
 }
 
 // path-to-regexp compiled source strings Next emits for local patterns.
 function compileLocalPathname(pathname: string | undefined): string {
   if (pathname === undefined || pathname === '**') {
-    return '^(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)\\/?)$';
+    return '^(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)\\/?)$'
   }
   // '/assets/**' style
-  const base = pathname.replace(/\/\*\*$/, '');
-  const escaped = base.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\//g, '\\/');
-  return `^(?:${escaped}(?:\\/(?!\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)|$))$`;
+  const base = pathname.replace(/\/\*\*$/, '')
+  const escaped = base.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\//g, '\\/')
+  return `^(?:${escaped}(?:\\/(?!\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)|$))$`
 }