@wular/pnext 0.0.4 → 0.0.6

package/src/compat/next/font/cache.ts

@@ -7,66 +7,66 @@
 //   - every local source file must still match the stat it was read at, so a font swapped while the
 //     server was not running re-resolves and re-emits.
 // Nothing here is used by `pnext build`, which owns the directory it just wiped.
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { mkdir, stat } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import type { ResolvedConfig } from '../../../config';
-import { restartCacheEnabled } from '../../../dev/restart-cache';
-import { writeFileAtomic } from '../../../utils/fs';
-import type { MetadataLink } from '../../../types';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { mkdir, stat } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import type { ResolvedConfig } from '../../../config'
+import { restartCacheEnabled } from '../../../dev/restart/enabled'
+import { writeFileAtomic } from '../../../utils/fs'
+import type { MetadataLink } from '../../../types'
 
 export interface PersistableFont {
-  css: string;
-  preloads: MetadataLink[];
-  usesFonts: boolean;
-  files: string[];
+  css: string
+  preloads: MetadataLink[]
+  usesFonts: boolean
+  files: string[]
   /** Local font files the resolution read (google resolutions have none). */
-  sources?: string[];
+  sources?: string[]
 }
 
 /** `[file, mtimeMs, size]` — a local source and the stat it was resolved at. */
-type SourceStat = [string, number, number];
+type SourceStat = [string, number, number]
 
 interface Entry extends PersistableFont {
-  sourceStats: SourceStat[];
+  sourceStats: SourceStat[]
 }
 
 interface IndexFile {
-  version: number;
+  version: number
   /** Content hash of the font runtime, so an upgrade never serves its output. */
-  runtime: string;
-  fonts: Record<string, Entry>;
+  runtime: string
+  fonts: Record<string, Entry>
 }
 
 /** Bumped whenever a record's shape changes; an older index is simply ignored. */
-const INDEX_VERSION = 1;
+const INDEX_VERSION = 1
 
 interface FontIndex {
-  file: string;
-  fonts: Map<string, Entry>;
-  dirty: boolean;
-  flush?: Timer;
+  file: string
+  fonts: Map<string, Entry>
+  dirty: boolean
+  flush?: Timer
 }
 
-const indexes = new Map<string, FontIndex>();
+const indexes = new Map<string, FontIndex>()
 
 function fontIndex(config: ResolvedConfig): FontIndex {
-  const file = path.join(config.outPath, 'cache', 'fonts', 'index.json');
-  const existing = indexes.get(file);
-  if (existing) return existing;
-  const created: FontIndex = { file, fonts: readIndex(file), dirty: false };
-  indexes.set(file, created);
+  const file = path.join(config.outPath, 'cache', 'fonts', 'index.json')
+  const existing = indexes.get(file)
+  if (existing) return existing
+  const created: FontIndex = { file, fonts: readIndex(file), dirty: false }
+  indexes.set(file, created)
   process.on('exit', () => {
-    if (!created.dirty) return;
-    created.dirty = false;
+    if (!created.dirty) return
+    created.dirty = false
     try {
-      writeFileSync(created.file, serializeIndex(created.fonts));
+      writeFileSync(created.file, serializeIndex(created.fonts))
     } catch {
       // Best effort: a missing index only costs the next boot a re-resolve.
     }
-  });
-  return created;
+  })
+  return created
 }
 
 /** The recorded resolution for `key`, or undefined when it no longer describes disk. */
@@ -74,72 +74,72 @@ export async function persistedFont(
   config: ResolvedConfig,
   key: string,
 ): Promise<PersistableFont | undefined> {
-  if (!restartCacheEnabled()) return undefined;
-  const entry = fontIndex(config).fonts.get(key);
-  if (!entry) return undefined;
-  if (!entry.files.every(file => existsSync(file))) return undefined;
+  if (!restartCacheEnabled()) return undefined
+  const entry = fontIndex(config).fonts.get(key)
+  if (!entry) return undefined
+  if (!entry.files.every(file => existsSync(file))) return undefined
   const stats = await Promise.all(
     entry.sourceStats.map(async ([file, mtimeMs, size]) => {
-      const current = await stat(file).catch(() => undefined);
-      return current?.mtimeMs === mtimeMs && current.size === size;
+      const current = await stat(file).catch(() => undefined)
+      return current?.mtimeMs === mtimeMs && current.size === size
     }),
-  );
-  if (!stats.every(Boolean)) return undefined;
-  return entry;
+  )
+  if (!stats.every(Boolean)) return undefined
+  return entry
 }
 
 /** Record a finished resolution. Failures are non-fatal — they cost a re-resolve. */
 export async function persistFont(config: ResolvedConfig, key: string, font: PersistableFont) {
-  const index = fontIndex(config);
+  const index = fontIndex(config)
   const sourceStats = await Promise.all(
     (font.sources ?? []).map(async (file): Promise<SourceStat | undefined> => {
-      const stats = await stat(file).catch(() => undefined);
-      return stats ? [file, stats.mtimeMs, stats.size] : undefined;
+      const stats = await stat(file).catch(() => undefined)
+      return stats ? [file, stats.mtimeMs, stats.size] : undefined
     }),
-  );
+  )
   // A source that vanished mid-resolve must not be recorded as validated.
-  if (sourceStats.some(entry => entry === undefined)) return;
-  index.fonts.set(key, { ...font, sourceStats: sourceStats as SourceStat[] });
-  persist(index);
+  if (sourceStats.some(entry => entry === undefined)) return
+  index.fonts.set(key, { ...font, sourceStats: sourceStats as SourceStat[] })
+  persist(index)
 }
 
 function persist(index: FontIndex) {
-  index.dirty = true;
-  if (index.flush) return;
+  index.dirty = true
+  if (index.flush) return
   index.flush = setTimeout(async () => {
-    index.flush = undefined;
-    if (!index.dirty) return;
-    const contents = serializeIndex(index.fonts);
+    index.flush = undefined
+    if (!index.dirty) return
+    const contents = serializeIndex(index.fonts)
     try {
-      await mkdir(path.dirname(index.file), { recursive: true });
-      await writeFileAtomic(index.file, contents);
-      index.dirty = false;
+      await mkdir(path.dirname(index.file), { recursive: true })
+      await writeFileAtomic(index.file, contents)
+      index.dirty = false
     } catch {
       // A write that lost a race with a cache wipe must not look persisted.
     }
-  }, 50);
+  }, 50)
   // NOT unref'd: under the dev server this timer never fired, so the index was never written and
   // every restart re-resolved every font over the network. The `exit` handler above still covers a
   // process exit inside the window.
 }
 
 function readIndex(file: string) {
-  const fonts = new Map<string, Entry>();
-  let parsed: IndexFile | undefined;
+  const fonts = new Map<string, Entry>()
+  let parsed: IndexFile | undefined
   try {
-    parsed = JSON.parse(readFileSync(file, 'utf8')) as IndexFile;
+    parsed = JSON.parse(readFileSync(file, 'utf8')) as IndexFile
   } catch {
-    return fonts;
+    return fonts
   }
   if (parsed?.version !== INDEX_VERSION || parsed.runtime !== runtimeFingerprint()) {
-    return fonts;
+    return fonts
   }
   for (const [key, entry] of Object.entries(parsed.fonts ?? {})) {
     if (entry && Array.isArray(entry.files) && Array.isArray(entry.sourceStats)) {
-      fonts.set(key, entry);
+      fonts.set(key, entry)
     }
   }
-  return fonts;
+  return fonts
 }
 
 function serializeIndex(fonts: Map<string, Entry>) {
@@ -147,25 +147,25 @@ function serializeIndex(fonts: Map<string, Entry>) {
     version: INDEX_VERSION,
     runtime: runtimeFingerprint(),
     fonts: Object.fromEntries(fonts),
-  } satisfies IndexFile);
+  } satisfies IndexFile)
 }
 
 // The CSS a resolution emits is shaped entirely by this directory's sources, so
 // editing the font runtime must retire its records the same way editing a font
 // does. Four small files, once per process.
-let fingerprint: string | undefined;
+let fingerprint: string | undefined
 
 function runtimeFingerprint() {
-  if (fingerprint !== undefined) return fingerprint;
-  const hash = createHash('sha256');
+  if (fingerprint !== undefined) return fingerprint
+  const hash = createHash('sha256')
   for (const entry of ['runtime.ts', 'google.ts', 'local.ts', 'shared.ts']) {
-    const file = new URL(entry, import.meta.url).pathname;
+    const file = new URL(entry, import.meta.url).pathname
     try {
-      hash.update(`${entry}:${Bun.hash(readFileSync(file)).toString(36)}\0`);
+      hash.update(`${entry}:${Bun.hash(readFileSync(file)).toString(36)}\0`)
     } catch {
       // ignore unreadable entries
     }
   }
-  fingerprint = hash.digest('hex').slice(0, 16);
-  return fingerprint;
+  fingerprint = hash.digest('hex').slice(0, 16)
+  return fingerprint
 }

package/src/compat/next/font/google.ts

@@ -1,2 +1,2 @@
-export * from 'next-font/google';
-export type { FontDisplay, GoogleFontOptions, NextFont, NextFontWithVariable } from './runtime';
+export * from 'next-font/google'
+export type { FontDisplay, GoogleFontOptions, NextFont, NextFontWithVariable } from './runtime'

package/src/compat/next/font/index.ts

@@ -5,4 +5,4 @@ export type {
   LocalFontSource,
   NextFont,
   NextFontWithVariable,
-} from './runtime';
+} from './runtime'

package/src/compat/next/font/local.ts

@@ -1,5 +1,5 @@
-import { localFont } from './runtime';
+import { localFont } from './runtime'
 
-export type { LocalFontOptions, LocalFontSource, NextFont, NextFontWithVariable } from './runtime';
+export type { LocalFontOptions, LocalFontSource, NextFont, NextFontWithVariable } from './runtime'
 
-export default localFont;
+export default localFont

package/src/compat/next/font/runtime-client.ts

@@ -17,7 +17,7 @@ import {
   type GoogleFontOptions,
   type LocalFontOptions,
   type NextFontWithVariable,
-} from './shared';
+} from './shared'
 
 export type {
   FontDisplay,
@@ -26,13 +26,13 @@ export type {
   LocalFontSource,
   NextFont,
   NextFontWithVariable,
-} from './shared';
+} from './shared'
 
 function fontObject(naming: {
-  className: string;
-  variable: string;
-  hasVariable: boolean;
-  style: NextFontWithVariable['style'];
+  className: string
+  variable: string
+  hasVariable: boolean
+  style: NextFontWithVariable['style']
 }): NextFontWithVariable {
   // Plain data object: no registration side effects (the server already emitted
   // the CSS/assets). Client code reads className/variable/style off this. The
@@ -42,30 +42,32 @@ function fontObject(naming: {
   const font: NextFontWithVariable = {
     className: naming.className,
     style: naming.style,
-  } as NextFontWithVariable;
-  if (naming.hasVariable) font.variable = naming.variable;
-  return font;
+  } as NextFontWithVariable
+  if (naming.hasVariable) font.variable = naming.variable
+  return font
 }
 
 export function googleFont(family: string) {
   return (options: GoogleFontOptions = {}): NextFontWithVariable =>
-    fontObject(googleFontNaming(family, options));
+    fontObject(googleFontNaming(family, options))
 }
 
 export interface LocalFontLoader {
-  (options: LocalFontOptions): NextFontWithVariable;
-  withFile: typeof localFontWithFile;
+  (options: LocalFontOptions): NextFontWithVariable
+  withFile: typeof localFontWithFile
 }
 
 export function localFontWithFile(callerFile: string | undefined, family?: string) {
   return (options: LocalFontOptions): NextFontWithVariable =>
     fontObject({
       ...localFontNaming(callerFile, options),
-      ...(family ? { fontFamily: family, style: fontStyle(family, options, options.fallback ?? []) } : {}),
-    });
+      ...(family
+        ? { fontFamily: family, style: fontStyle(family, options, options.fallback ?? []) }
+        : {}),
+    })
 }
 
 export const localFont: LocalFontLoader = Object.assign(
   (options: LocalFontOptions) => localFontWithFile(undefined)(options),
   { withFile: localFontWithFile },
-);
+)