@pro-laico/payload-fonts 0.0.0

package/dist/collections/fontOriginal.d.ts

@@ -0,0 +1,25 @@
+import type { CollectionConfig } from 'payload';
+/** Default slug for the archival font-original upload collection. */
+export declare const FONT_ORIGINAL_SLUG = "fontOriginal";
+/**
+ * Accepted upload mime types for the four web-font formats. OTF/TTF arrive under several
+ * different mime strings depending on the OS/browser, so the whitelist covers the common
+ * sfnt variants — otherwise a valid `.otf` can be rejected as "MIME Type invalid". Shared by
+ * the `Font` collection and this archival one (which stores the untouched original under its
+ * own original mime).
+ */
+export declare const FONT_MIME_TYPES: string[];
+/**
+ * Upload collection holding the raw, untouched font files editors drop into the `Font`
+ * typeface's `upload` fields. It's the archive of truth: the `Font` save hook reads these and
+ * subsets each to a served `fontOptimized` WOFF2, so the (lossy, subsetted) output can be
+ * re-derived with a different charset later.
+ *
+ * It carries NO hooks — uploading here is a plain store, which is exactly what lets it be a
+ * client-upload (direct-to-Blob) collection in production. Hidden from admin nav; editors only
+ * ever interact with it through the `Font` fields.
+ */
+export declare const createFontOriginalCollection: ({ slug }?: {
+    slug?: string;
+}) => CollectionConfig;
+//# sourceMappingURL=fontOriginal.d.ts.map

package/dist/collections/fontOriginal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fontOriginal.d.ts","sourceRoot":"","sources":["../../src/collections/fontOriginal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAI/C,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,iBAAiB,CAAA;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,UAW3B,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,GAAI,WAA+B;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,KAAG,gBAMnG,CAAA"}

package/dist/collections/fontOriginal.js

@@ -0,0 +1,49 @@
+import { authd } from "../access/authd.js";
+/** Default slug for the archival font-original upload collection. */ export const FONT_ORIGINAL_SLUG = 'fontOriginal';
+/**
+ * Accepted upload mime types for the four web-font formats. OTF/TTF arrive under several
+ * different mime strings depending on the OS/browser, so the whitelist covers the common
+ * sfnt variants — otherwise a valid `.otf` can be rejected as "MIME Type invalid". Shared by
+ * the `Font` collection and this archival one (which stores the untouched original under its
+ * own original mime).
+ */ export const FONT_MIME_TYPES = [
+    'font/ttf',
+    'font/otf',
+    'font/woff',
+    'font/woff2',
+    'font/sfnt',
+    'application/font-sfnt',
+    'application/vnd.ms-opentype',
+    'application/x-font-ttf',
+    'application/x-font-otf',
+    'application/x-font-truetype'
+];
+/**
+ * Upload collection holding the raw, untouched font files editors drop into the `Font`
+ * typeface's `upload` fields. It's the archive of truth: the `Font` save hook reads these and
+ * subsets each to a served `fontOptimized` WOFF2, so the (lossy, subsetted) output can be
+ * re-derived with a different charset later.
+ *
+ * It carries NO hooks — uploading here is a plain store, which is exactly what lets it be a
+ * client-upload (direct-to-Blob) collection in production. Hidden from admin nav; editors only
+ * ever interact with it through the `Font` fields.
+ */ export const createFontOriginalCollection = ({ slug = FONT_ORIGINAL_SLUG } = {})=>({
+        slug,
+        access: {
+            create: authd,
+            delete: authd,
+            read: authd,
+            update: authd
+        },
+        admin: {
+            group: 'Assets',
+            hidden: true,
+            useAsTitle: 'filename'
+        },
+        upload: {
+            mimeTypes: FONT_MIME_TYPES
+        },
+        fields: []
+    });
+
+//# sourceMappingURL=fontOriginal.js.map

package/dist/collections/fontOriginal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collections/fontOriginal.ts"],"sourcesContent":["import type { CollectionConfig } from 'payload'\n\nimport { authd } from '../access/authd'\n\n/** Default slug for the archival font-original upload collection. */\nexport const FONT_ORIGINAL_SLUG = 'fontOriginal'\n\n/**\n * Accepted upload mime types for the four web-font formats. OTF/TTF arrive under several\n * different mime strings depending on the OS/browser, so the whitelist covers the common\n * sfnt variants — otherwise a valid `.otf` can be rejected as \"MIME Type invalid\". Shared by\n * the `Font` collection and this archival one (which stores the untouched original under its\n * own original mime).\n */\nexport const FONT_MIME_TYPES = [\n  'font/ttf',\n  'font/otf',\n  'font/woff',\n  'font/woff2',\n  'font/sfnt',\n  'application/font-sfnt',\n  'application/vnd.ms-opentype',\n  'application/x-font-ttf',\n  'application/x-font-otf',\n  'application/x-font-truetype',\n]\n\n/**\n * Upload collection holding the raw, untouched font files editors drop into the `Font`\n * typeface's `upload` fields. It's the archive of truth: the `Font` save hook reads these and\n * subsets each to a served `fontOptimized` WOFF2, so the (lossy, subsetted) output can be\n * re-derived with a different charset later.\n *\n * It carries NO hooks — uploading here is a plain store, which is exactly what lets it be a\n * client-upload (direct-to-Blob) collection in production. Hidden from admin nav; editors only\n * ever interact with it through the `Font` fields.\n */\nexport const createFontOriginalCollection = ({ slug = FONT_ORIGINAL_SLUG }: { slug?: string } = {}): CollectionConfig => ({\n  slug,\n  access: { create: authd, delete: authd, read: authd, update: authd },\n  admin: { group: 'Assets', hidden: true, useAsTitle: 'filename' },\n  upload: { mimeTypes: FONT_MIME_TYPES },\n  fields: [],\n})\n"],"names":["authd","FONT_ORIGINAL_SLUG","FONT_MIME_TYPES","createFontOriginalCollection","slug","access","create","delete","read","update","admin","group","hidden","useAsTitle","upload","mimeTypes","fields"],"mappings":"AAEA,SAASA,KAAK,QAAQ,qBAAiB;AAEvC,mEAAmE,GACnE,OAAO,MAAMC,qBAAqB,eAAc;AAEhD;;;;;;CAMC,GACD,OAAO,MAAMC,kBAAkB;IAC7B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,CAAA;AAED;;;;;;;;;CASC,GACD,OAAO,MAAMC,+BAA+B,CAAC,EAAEC,OAAOH,kBAAkB,EAAqB,GAAG,CAAC,CAAC,GAAwB,CAAA;QACxHG;QACAC,QAAQ;YAAEC,QAAQN;YAAOO,QAAQP;YAAOQ,MAAMR;YAAOS,QAAQT;QAAM;QACnEU,OAAO;YAAEC,OAAO;YAAUC,QAAQ;YAAMC,YAAY;QAAW;QAC/DC,QAAQ;YAAEC,WAAWb;QAAgB;QACrCc,QAAQ,EAAE;IACZ,CAAA,EAAE"}

package/dist/components/DevFonts.d.ts

@@ -0,0 +1,52 @@
+import { getPayload } from 'payload';
+import { type FontFamilyConfig } from '../lib/families';
+export interface DevFontsProps {
+    /** Your Payload config — the same `@payload-config` import you pass to `getPayload`. */
+    config: Parameters<typeof getPayload>[0]['config'];
+    /**
+     * The generated `next/font/local` definition (`import definitionFonts from '@/app/definition'`).
+     * When it already has fonts, this component renders nothing and lets `next/font` take over — so
+     * running `generate:fonts` against your dev server lets you preview the exact production path
+     * locally. Omit it and DevFonts always renders in dev.
+     */
+    definition?: Record<string, {
+        variable?: string;
+    } | undefined>;
+    /** CSS family-variable prefix; must match the download CLI's `cssVariablePrefix`. @default '--font-set' */
+    cssVarPrefix?: string;
+    /** Slug of the standalone font-selection global. @default 'fontSet' */
+    fontSetSlug?: string;
+    /** Slug of the optimized (served) upload collection. @default 'fontOptimized' */
+    optimizedSlug?: string;
+    /** Optional. The family slots are auto-discovered from the `fontSet` global, so you only need this
+     *  if you set custom per-family `fallback` stacks and want the dev preview to match them. */
+    families?: FontFamilyConfig[];
+}
+/**
+ * **Development-only** font loading. In production it renders `null` — your app self-hosts fonts
+ * with `next/font/local` (the build-time export + `payload-fonts-download` CLI), which keeps the
+ * production path stock `next/font`: precise preloading, size-adjusted fallbacks, static assets.
+ *
+ * In development (`NODE_ENV !== 'production'`) it reads the active `fontSet` selection from Payload
+ * and inlines the matching `@font-face` rules + the `--font-set*` family variables, so fonts show up
+ * immediately with no build step — change a typeface in the admin, refresh, see it. Because it
+ * emits the **same** family variables `next/font` defines in production, your app's
+ * `font-family: var(--font-setSans)` resolves identically across environments.
+ *
+ * Drop it into your root layout alongside the production wiring — each is a no-op in the other
+ * environment:
+ *
+ * ```tsx
+ * import config from '@payload-config'
+ * import definitionFonts from '@/app/definition'
+ * import { extractFonts } from '@pro-laico/payload-fonts'
+ * import { DevFonts } from '@pro-laico/payload-fonts/DevFonts'
+ *
+ * <html className={extractFonts(definitionFonts)}>
+ *   <head><DevFonts config={config} definition={definitionFonts} /></head>
+ * </html>
+ * ```
+ */
+export declare function DevFonts({ config, definition, cssVarPrefix, fontSetSlug, optimizedSlug, families, }: DevFontsProps): Promise<React.ReactElement | null>;
+export default DevFonts;
+//# sourceMappingURL=DevFonts.d.ts.map

package/dist/components/DevFonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevFonts.d.ts","sourceRoot":"","sources":["../../src/components/DevFonts.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGpC,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,iBAAiB,CAAA;AAE5E,MAAM,WAAW,aAAa;IAC5B,wFAAwF;IACxF,MAAM,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;IAClD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC,CAAA;IAC9D,2GAA2G;IAC3G,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;iGAC6F;IAC7F,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,QAAQ,CAAC,EAC7B,MAAM,EACN,UAAU,EACV,YAAY,EACZ,WAAW,EACX,aAAa,EACb,QAAQ,GACT,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,GAAG,IAAI,CAAC,CA0BpD;AAED,eAAe,QAAQ,CAAA"}

package/dist/components/DevFonts.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getPayload } from "payload";
+import { extractFonts } from "../extractFonts.js";
+import { buildFontFaceCss, getActiveFontFaces } from "../lib/activeFonts.js";
+import { resolveFontFamilies } from "../lib/families.js";
+/**
+ * **Development-only** font loading. In production it renders `null` — your app self-hosts fonts
+ * with `next/font/local` (the build-time export + `payload-fonts-download` CLI), which keeps the
+ * production path stock `next/font`: precise preloading, size-adjusted fallbacks, static assets.
+ *
+ * In development (`NODE_ENV !== 'production'`) it reads the active `fontSet` selection from Payload
+ * and inlines the matching `@font-face` rules + the `--font-set*` family variables, so fonts show up
+ * immediately with no build step — change a typeface in the admin, refresh, see it. Because it
+ * emits the **same** family variables `next/font` defines in production, your app's
+ * `font-family: var(--font-setSans)` resolves identically across environments.
+ *
+ * Drop it into your root layout alongside the production wiring — each is a no-op in the other
+ * environment:
+ *
+ * ```tsx
+ * import config from '@payload-config'
+ * import definitionFonts from '@/app/definition'
+ * import { extractFonts } from '@pro-laico/payload-fonts'
+ * import { DevFonts } from '@pro-laico/payload-fonts/DevFonts'
+ *
+ * <html className={extractFonts(definitionFonts)}>
+ *   <head><DevFonts config={config} definition={definitionFonts} /></head>
+ * </html>
+ * ```
+ */ export async function DevFonts({ config, definition, cssVarPrefix, fontSetSlug, optimizedSlug, families }) {
+    // Production self-hosts via next/font — never touch the runtime path there.
+    if (process.env.NODE_ENV === 'production') return null;
+    // If the build path already produced fonts, stand down so there's exactly one source of truth
+    // (this is how you preview the real production path locally — run `generate:fonts`).
+    if (definition && extractFonts(definition)) return null;
+    let css = '';
+    try {
+        // Only resolve `families` when explicitly given (custom fallbacks); otherwise let
+        // getActiveFontFaces auto-discover the slots from the global and use the default fallbacks.
+        const resolved = families ? resolveFontFamilies(families) : undefined;
+        const fallbacks = resolved ? Object.fromEntries(resolved.map((r)=>[
+                r.key,
+                r.fallback
+            ])) : undefined;
+        const payload = await getPayload({
+            config
+        });
+        const typefaces = await getActiveFontFaces(payload, {
+            fontSetSlug,
+            optimizedSlug,
+            families: resolved?.map((r)=>r.key)
+        });
+        css = buildFontFaceCss(typefaces, {
+            cssVarPrefix,
+            optimizedSlug,
+            fallbacks
+        });
+    } catch (err) {
+        // No DB / not seeded yet — render nothing rather than throw in the layout, but say why
+        // (dev-only component, so the warning never reaches production logs).
+        console.warn('[payload-fonts] DevFonts failed to load the active fonts:', err);
+        return null;
+    }
+    if (!css) return null;
+    // dangerouslySetInnerHTML: server-built CSS from our own data, no user input.
+    return /*#__PURE__*/ _jsx("style", {
+        "data-payload-fonts-dev": true,
+        dangerouslySetInnerHTML: {
+            __html: css
+        }
+    });
+}
+export default DevFonts;
+
+//# sourceMappingURL=DevFonts.js.map

package/dist/components/DevFonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/components/DevFonts.tsx"],"sourcesContent":["import { getPayload } from 'payload'\nimport { extractFonts } from '../extractFonts'\nimport { buildFontFaceCss, getActiveFontFaces } from '../lib/activeFonts'\nimport { type FontFamilyConfig, resolveFontFamilies } from '../lib/families'\n\nexport interface DevFontsProps {\n  /** Your Payload config — the same `@payload-config` import you pass to `getPayload`. */\n  config: Parameters<typeof getPayload>[0]['config']\n  /**\n   * The generated `next/font/local` definition (`import definitionFonts from '@/app/definition'`).\n   * When it already has fonts, this component renders nothing and lets `next/font` take over — so\n   * running `generate:fonts` against your dev server lets you preview the exact production path\n   * locally. Omit it and DevFonts always renders in dev.\n   */\n  definition?: Record<string, { variable?: string } | undefined>\n  /** CSS family-variable prefix; must match the download CLI's `cssVariablePrefix`. @default '--font-set' */\n  cssVarPrefix?: string\n  /** Slug of the standalone font-selection global. @default 'fontSet' */\n  fontSetSlug?: string\n  /** Slug of the optimized (served) upload collection. @default 'fontOptimized' */\n  optimizedSlug?: string\n  /** Optional. The family slots are auto-discovered from the `fontSet` global, so you only need this\n   *  if you set custom per-family `fallback` stacks and want the dev preview to match them. */\n  families?: FontFamilyConfig[]\n}\n\n/**\n * **Development-only** font loading. In production it renders `null` — your app self-hosts fonts\n * with `next/font/local` (the build-time export + `payload-fonts-download` CLI), which keeps the\n * production path stock `next/font`: precise preloading, size-adjusted fallbacks, static assets.\n *\n * In development (`NODE_ENV !== 'production'`) it reads the active `fontSet` selection from Payload\n * and inlines the matching `@font-face` rules + the `--font-set*` family variables, so fonts show up\n * immediately with no build step — change a typeface in the admin, refresh, see it. Because it\n * emits the **same** family variables `next/font` defines in production, your app's\n * `font-family: var(--font-setSans)` resolves identically across environments.\n *\n * Drop it into your root layout alongside the production wiring — each is a no-op in the other\n * environment:\n *\n * ```tsx\n * import config from '@payload-config'\n * import definitionFonts from '@/app/definition'\n * import { extractFonts } from '@pro-laico/payload-fonts'\n * import { DevFonts } from '@pro-laico/payload-fonts/DevFonts'\n *\n * <html className={extractFonts(definitionFonts)}>\n *   <head><DevFonts config={config} definition={definitionFonts} /></head>\n * </html>\n * ```\n */\nexport async function DevFonts({\n  config,\n  definition,\n  cssVarPrefix,\n  fontSetSlug,\n  optimizedSlug,\n  families,\n}: DevFontsProps): Promise<React.ReactElement | null> {\n  // Production self-hosts via next/font — never touch the runtime path there.\n  if (process.env.NODE_ENV === 'production') return null\n  // If the build path already produced fonts, stand down so there's exactly one source of truth\n  // (this is how you preview the real production path locally — run `generate:fonts`).\n  if (definition && extractFonts(definition)) return null\n\n  let css = ''\n  try {\n    // Only resolve `families` when explicitly given (custom fallbacks); otherwise let\n    // getActiveFontFaces auto-discover the slots from the global and use the default fallbacks.\n    const resolved = families ? resolveFontFamilies(families) : undefined\n    const fallbacks = resolved ? Object.fromEntries(resolved.map((r) => [r.key, r.fallback])) : undefined\n    const payload = await getPayload({ config })\n    const typefaces = await getActiveFontFaces(payload, { fontSetSlug, optimizedSlug, families: resolved?.map((r) => r.key) })\n    css = buildFontFaceCss(typefaces, { cssVarPrefix, optimizedSlug, fallbacks })\n  } catch (err) {\n    // No DB / not seeded yet — render nothing rather than throw in the layout, but say why\n    // (dev-only component, so the warning never reaches production logs).\n    console.warn('[payload-fonts] DevFonts failed to load the active fonts:', err)\n    return null\n  }\n  if (!css) return null\n\n  // dangerouslySetInnerHTML: server-built CSS from our own data, no user input.\n  return <style data-payload-fonts-dev dangerouslySetInnerHTML={{ __html: css }} />\n}\n\nexport default DevFonts\n"],"names":["getPayload","extractFonts","buildFontFaceCss","getActiveFontFaces","resolveFontFamilies","DevFonts","config","definition","cssVarPrefix","fontSetSlug","optimizedSlug","families","process","env","NODE_ENV","css","resolved","undefined","fallbacks","Object","fromEntries","map","r","key","fallback","payload","typefaces","err","console","warn","style","data-payload-fonts-dev","dangerouslySetInnerHTML","__html"],"mappings":";AAAA,SAASA,UAAU,QAAQ,UAAS;AACpC,SAASC,YAAY,QAAQ,qBAAiB;AAC9C,SAASC,gBAAgB,EAAEC,kBAAkB,QAAQ,wBAAoB;AACzE,SAAgCC,mBAAmB,QAAQ,qBAAiB;AAuB5E;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,eAAeC,SAAS,EAC7BC,MAAM,EACNC,UAAU,EACVC,YAAY,EACZC,WAAW,EACXC,aAAa,EACbC,QAAQ,EACM;IACd,4EAA4E;IAC5E,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc,OAAO;IAClD,8FAA8F;IAC9F,qFAAqF;IACrF,IAAIP,cAAcN,aAAaM,aAAa,OAAO;IAEnD,IAAIQ,MAAM;IACV,IAAI;QACF,kFAAkF;QAClF,4FAA4F;QAC5F,MAAMC,WAAWL,WAAWP,oBAAoBO,YAAYM;QAC5D,MAAMC,YAAYF,WAAWG,OAAOC,WAAW,CAACJ,SAASK,GAAG,CAAC,CAACC,IAAM;gBAACA,EAAEC,GAAG;gBAAED,EAAEE,QAAQ;aAAC,KAAKP;QAC5F,MAAMQ,UAAU,MAAMzB,WAAW;YAAEM;QAAO;QAC1C,MAAMoB,YAAY,MAAMvB,mBAAmBsB,SAAS;YAAEhB;YAAaC;YAAeC,UAAUK,UAAUK,IAAI,CAACC,IAAMA,EAAEC,GAAG;QAAE;QACxHR,MAAMb,iBAAiBwB,WAAW;YAAElB;YAAcE;YAAeQ;QAAU;IAC7E,EAAE,OAAOS,KAAK;QACZ,uFAAuF;QACvF,sEAAsE;QACtEC,QAAQC,IAAI,CAAC,6DAA6DF;QAC1E,OAAO;IACT;IACA,IAAI,CAACZ,KAAK,OAAO;IAEjB,8EAA8E;IAC9E,qBAAO,KAACe;QAAMC,wBAAsB;QAACC,yBAAyB;YAAEC,QAAQlB;QAAI;;AAC9E;AAEA,eAAeV,SAAQ"}

package/dist/components/admin/FontOriginalUpload.d.ts

@@ -0,0 +1,15 @@
+import type { UploadFieldClientProps } from 'payload';
+import './FontOriginalUpload.scss';
+/**
+ * The `fontOriginal` upload slots — Payload's own upload field, but with the "Choose from
+ * existing" control hidden (see the sibling stylesheet), so every slot always uploads a FRESH
+ * original via "Create New".
+ *
+ * That enforces one `fontOriginal` per typeface slot — an original is never shared between
+ * typefaces — which keeps asset cleanup trivially safe and race-free: a de-referenced or
+ * deleted original can always be removed, with no reference count and no concurrent-delete
+ * hazard (each typeface owns its own files).
+ */
+export declare const FontOriginalUpload: (props: UploadFieldClientProps) => import("react").JSX.Element;
+export default FontOriginalUpload;
+//# sourceMappingURL=FontOriginalUpload.d.ts.map

package/dist/components/admin/FontOriginalUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontOriginalUpload.d.ts","sourceRoot":"","sources":["../../../src/components/admin/FontOriginalUpload.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAGrD,OAAO,2BAA2B,CAAA;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,sBAAsB,gCAI/D,CAAA;AAED,eAAe,kBAAkB,CAAA"}

package/dist/components/admin/FontOriginalUpload.js

@@ -0,0 +1,22 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { UploadField } from "@payloadcms/ui";
+import "./FontOriginalUpload.scss";
+/**
+ * The `fontOriginal` upload slots — Payload's own upload field, but with the "Choose from
+ * existing" control hidden (see the sibling stylesheet), so every slot always uploads a FRESH
+ * original via "Create New".
+ *
+ * That enforces one `fontOriginal` per typeface slot — an original is never shared between
+ * typefaces — which keeps asset cleanup trivially safe and race-free: a de-referenced or
+ * deleted original can always be removed, with no reference count and no concurrent-delete
+ * hazard (each typeface owns its own files).
+ */ export const FontOriginalUpload = (props)=>/*#__PURE__*/ _jsx("div", {
+        className: "font-original-upload",
+        children: /*#__PURE__*/ _jsx(UploadField, {
+            ...props
+        })
+    });
+export default FontOriginalUpload;
+
+//# sourceMappingURL=FontOriginalUpload.js.map

package/dist/components/admin/FontOriginalUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/admin/FontOriginalUpload.tsx"],"sourcesContent":["'use client'\n\nimport type { UploadFieldClientProps } from 'payload'\nimport { UploadField } from '@payloadcms/ui'\n\nimport './FontOriginalUpload.scss'\n\n/**\n * The `fontOriginal` upload slots — Payload's own upload field, but with the \"Choose from\n * existing\" control hidden (see the sibling stylesheet), so every slot always uploads a FRESH\n * original via \"Create New\".\n *\n * That enforces one `fontOriginal` per typeface slot — an original is never shared between\n * typefaces — which keeps asset cleanup trivially safe and race-free: a de-referenced or\n * deleted original can always be removed, with no reference count and no concurrent-delete\n * hazard (each typeface owns its own files).\n */\nexport const FontOriginalUpload = (props: UploadFieldClientProps) => (\n  <div className=\"font-original-upload\">\n    <UploadField {...props} />\n  </div>\n)\n\nexport default FontOriginalUpload\n"],"names":["UploadField","FontOriginalUpload","props","div","className"],"mappings":"AAAA;;AAGA,SAASA,WAAW,QAAQ,iBAAgB;AAE5C,OAAO,4BAA2B;AAElC;;;;;;;;;CASC,GACD,OAAO,MAAMC,qBAAqB,CAACC,sBACjC,KAACC;QAAIC,WAAU;kBACb,cAAA,KAACJ;YAAa,GAAGE,KAAK;;OAEzB;AAED,eAAeD,mBAAkB"}

package/dist/components/admin/FontOriginalUpload.scss

@@ -0,0 +1,9 @@
+// Create-only upload: hide the "Choose from existing" toggler and its "or" separator, leaving
+// just "Create New" + drag-and-drop. Each slot therefore uploads a fresh `fontOriginal` that
+// is never shared between typefaces.
+.font-original-upload {
+  .upload__listToggler,
+  .upload__dropzoneContent__orText {
+    display: none;
+  }
+}

package/dist/endpoints/exportFonts.d.ts

@@ -0,0 +1,49 @@
+import type { Endpoint } from 'payload';
+/** A family key — `sans`/`serif`/`mono`/`display` by default, but any string when customised. */
+type Family = string;
+export interface ExportFontsEndpointOptions {
+    /** Mount path under the Payload API route. Default `/fonts/export` (→ `/api/fonts/export`). */
+    path?: string;
+    /** Slug of the standalone font-selection global. Default `fontSet`. */
+    fontSetGlobalSlug?: string;
+    /** Slug of the optimized (served) weight-file upload collection. Default `fontOptimized`. */
+    fontOptimizedSlug?: string;
+    /** Family keys to resolve from the `fontSet` global. Default sans/serif/mono/display. */
+    families?: Family[];
+}
+/** A single exported weight file: filename, extension, mime, base64 bytes, and (optional) weight/style.
+ *  An upright variable file that also carries italics (ital/slnt axes) exports TWICE — once per
+ *  style, same bytes; the italic entry carries `obliqueAngle` when the italics ride a slnt axis. */
+export type ExportedFont = {
+    filename: string;
+    extension: string;
+    mimeType: string | null;
+    data: string;
+    weight?: string | null;
+    style?: string | null;
+    /** For slnt-based italics: the positive CSS `oblique` angle (deg). */
+    obliqueAngle?: number | null;
+};
+/** Per-family debug info: is a typeface selected, how many optimized files it has, and how many of
+ *  those couldn't be read from storage — so an empty export can name its cause per family. */
+export type ExportFamilyDiagnostics = {
+    selected: boolean;
+    typeface?: string;
+    optimizedFiles: number;
+    readFailures: number;
+};
+/** JSON returned by the fonts export endpoint — an array of weight files per family.
+ *  `diagnostics` is additive; older servers omit it. */
+export type ExportFontsResponse = {
+    fonts: Partial<Record<Family, ExportedFont[]>>;
+    diagnostics?: Partial<Record<Family, ExportFamilyDiagnostics>>;
+};
+/**
+ * `GET /api/fonts/export`. Resolves the active fonts from the `fontSet` global — each family
+ * points at ONE `font` typeface — and returns the bytes of that typeface's served
+ * `fontOptimized` files so the `payload-fonts-download` CLI can write them for
+ * `next/font/local`. Secured by the project's `PAYLOAD_SECRET` (Bearer).
+ */
+export declare const exportFontsEndpoint: (opts?: ExportFontsEndpointOptions) => Endpoint;
+export {};
+//# sourceMappingURL=exportFonts.d.ts.map

package/dist/endpoints/exportFonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportFonts.d.ts","sourceRoot":"","sources":["../../src/endpoints/exportFonts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,QAAQ,EAAc,MAAM,SAAS,CAAA;AAMnE,iGAAiG;AACjG,KAAK,MAAM,GAAG,MAAM,CAAA;AAGpB,MAAM,WAAW,0BAA0B;IACzC,+FAA+F;IAC/F,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,6FAA6F;IAC7F,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AAMD;;oGAEoG;AACpG,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B,CAAA;AACD;8FAC8F;AAC9F,MAAM,MAAM,uBAAuB,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAA;AAC5H;wDACwD;AACxD,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC,CAAA;IAC9C,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAA;CAC/D,CAAA;AAYD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAM,0BAA+B,KAAG,QAoH3E,CAAA"}

package/dist/endpoints/exportFonts.js

@@ -0,0 +1,162 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { refId } from "../lib/refs.js";
+import { DEFAULT_FONT_FAMILIES } from "../lib/families.js";
+import { readUploadBytes } from "../lib/uploadBytes.js";
+const DEFAULT_FAMILY_KEYS = DEFAULT_FONT_FAMILIES.map((r)=>r.key);
+/**
+ * Constant-time secret compare. Both sides are sha256-hashed to a fixed 32 bytes first, so the
+ * comparison is constant-time regardless of length.
+ */ function secretsMatch(provided, secret) {
+    const a = createHash('sha256').update(provided).digest();
+    const b = createHash('sha256').update(secret).digest();
+    return timingSafeEqual(a, b);
+}
+/**
+ * `GET /api/fonts/export`. Resolves the active fonts from the `fontSet` global — each family
+ * points at ONE `font` typeface — and returns the bytes of that typeface's served
+ * `fontOptimized` files so the `payload-fonts-download` CLI can write them for
+ * `next/font/local`. Secured by the project's `PAYLOAD_SECRET` (Bearer).
+ */ export const exportFontsEndpoint = (opts = {})=>{
+    const { path: endpointPath = '/fonts/export', fontSetGlobalSlug = 'fontSet', fontOptimizedSlug = 'fontOptimized', families = DEFAULT_FAMILY_KEYS } = opts;
+    return {
+        path: endpointPath,
+        method: 'get',
+        handler: async (req)=>{
+            const { payload } = req;
+            // Compare against the RAW PAYLOAD_SECRET (what the caller sends).
+            const secret = process.env.PAYLOAD_SECRET || '';
+            const provided = (req.headers.get('authorization') || '').replace(/^Bearer\s+/i, '').trim();
+            if (!secret || !provided || !secretsMatch(provided, secret)) {
+                return Response.json({
+                    error: 'Unauthorized'
+                }, {
+                    status: 401
+                });
+            }
+            // Read the active selection from the `fontSet` global. The shared secret is the trust
+            // boundary → `overrideAccess: true`.
+            let selection;
+            try {
+                const fontSetGlobal = await payload.findGlobal({
+                    slug: fontSetGlobalSlug,
+                    // depth 1 populates each slot's typeface (defaultPopulate: title/family), so the
+                    // diagnostics can name the selected typeface.
+                    depth: 1,
+                    overrideAccess: true
+                });
+                selection = Object.fromEntries(families.map((family)=>[
+                        family,
+                        fontSetGlobal?.[family]
+                    ]));
+            } catch  {
+            // no fontSet global in this project
+            }
+            const fonts = {};
+            const diagnostics = Object.fromEntries(families.map((family)=>[
+                    family,
+                    {
+                        selected: false,
+                        optimizedFiles: 0,
+                        readFailures: 0
+                    }
+                ]));
+            if (selection) {
+                // One typeface per family (tolerate a stray array — take the first); fetch every family's
+                // served files in a single query grouped by typeface, rather than one round-trip per family.
+                const familyIds = families.map((family)=>{
+                    const ref = (Array.isArray(selection[family]) ? selection[family][0] : selection[family]) ?? null;
+                    const title = ref && typeof ref === 'object' && typeof ref.title === 'string' ? ref.title : undefined;
+                    return {
+                        family,
+                        id: refId(ref),
+                        title
+                    };
+                }).filter((r)=>r.id != null);
+                const docsByFont = new Map();
+                if (familyIds.length) {
+                    const uniqueIds = [
+                        ...new Set(familyIds.map((r)=>r.id))
+                    ];
+                    try {
+                        const res = await payload.find({
+                            collection: fontOptimizedSlug,
+                            where: {
+                                font: {
+                                    in: uniqueIds
+                                }
+                            },
+                            depth: 0,
+                            limit: 1000,
+                            overrideAccess: true
+                        });
+                        for (const doc of res.docs){
+                            const fontId = refId(doc.font);
+                            if (fontId == null) continue;
+                            const bucket = docsByFont.get(fontId);
+                            if (bucket) bucket.push(doc);
+                            else docsByFont.set(fontId, [
+                                doc
+                            ]);
+                        }
+                    } catch (err) {
+                        // leave docsByFont empty — the response just carries no fonts
+                        payload.logger.warn({
+                            msg: `[payload-fonts] export: could not query ${fontOptimizedSlug}`,
+                            err
+                        });
+                    }
+                }
+                for (const { family, id, title } of familyIds){
+                    const docs = docsByFont.get(id) ?? [];
+                    const diag = {
+                        selected: true,
+                        typeface: title,
+                        optimizedFiles: docs.length,
+                        readFailures: 0
+                    };
+                    diagnostics[family] = diag;
+                    // An explicit italic file always wins over synthesizing italics from an ital-capable
+                    // upright — same rule as `expandItalCapableFaces` on the runtime CSS path.
+                    const hasExplicitItalic = docs.some((doc)=>doc.style === 'italic');
+                    const exported = [];
+                    for (const doc of docs){
+                        const filename = typeof doc.filename === 'string' ? doc.filename : null;
+                        const bytes = filename ? await readUploadBytes(payload, fontOptimizedSlug, doc) : null;
+                        if (!filename || !bytes) {
+                            diag.readFailures++;
+                            continue;
+                        }
+                        const entry = {
+                            filename,
+                            extension: filename.split('.').pop()?.toLowerCase() || 'woff2',
+                            mimeType: doc.mimeType ?? null,
+                            data: bytes.toString('base64'),
+                            weight: doc.weight ?? null,
+                            style: doc.style ?? null
+                        };
+                        exported.push(entry);
+                        if (doc.style !== 'italic' && doc.italCapable && !hasExplicitItalic) {
+                            exported.push({
+                                ...entry,
+                                style: 'italic',
+                                obliqueAngle: typeof doc.obliqueAngle === 'number' ? doc.obliqueAngle : null
+                            });
+                        }
+                    }
+                    if (exported.length) fonts[family] = exported;
+                }
+            }
+            // no-store: the response carries font bytes behind auth.
+            return Response.json({
+                fonts,
+                diagnostics
+            }, {
+                headers: {
+                    'Cache-Control': 'no-store'
+                }
+            });
+        }
+    };
+};
+
+//# sourceMappingURL=exportFonts.js.map

package/dist/endpoints/exportFonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/exportFonts.ts"],"sourcesContent":["import { createHash, timingSafeEqual } from 'node:crypto'\n\nimport type { CollectionSlug, Endpoint, GlobalSlug } from 'payload'\n\nimport { refId } from '../lib/refs'\nimport { DEFAULT_FONT_FAMILIES } from '../lib/families'\nimport { readUploadBytes } from '../lib/uploadBytes'\n\n/** A family key — `sans`/`serif`/`mono`/`display` by default, but any string when customised. */\ntype Family = string\nconst DEFAULT_FAMILY_KEYS: Family[] = DEFAULT_FONT_FAMILIES.map((r) => r.key)\n\nexport interface ExportFontsEndpointOptions {\n  /** Mount path under the Payload API route. Default `/fonts/export` (→ `/api/fonts/export`). */\n  path?: string\n  /** Slug of the standalone font-selection global. Default `fontSet`. */\n  fontSetGlobalSlug?: string\n  /** Slug of the optimized (served) weight-file upload collection. Default `fontOptimized`. */\n  fontOptimizedSlug?: string\n  /** Family keys to resolve from the `fontSet` global. Default sans/serif/mono/display. */\n  families?: Family[]\n}\n\n/** The selected typeface for a family: a populated `font` doc or its id. */\ntype TypefaceRef = { id?: string | number; title?: string | null } | string | number | null\ntype FontSelection = Partial<Record<Family, TypefaceRef | TypefaceRef[]>>\n\n/** A single exported weight file: filename, extension, mime, base64 bytes, and (optional) weight/style.\n *  An upright variable file that also carries italics (ital/slnt axes) exports TWICE — once per\n *  style, same bytes; the italic entry carries `obliqueAngle` when the italics ride a slnt axis. */\nexport type ExportedFont = {\n  filename: string\n  extension: string\n  mimeType: string | null\n  data: string\n  weight?: string | null\n  style?: string | null\n  /** For slnt-based italics: the positive CSS `oblique` angle (deg). */\n  obliqueAngle?: number | null\n}\n/** Per-family debug info: is a typeface selected, how many optimized files it has, and how many of\n *  those couldn't be read from storage — so an empty export can name its cause per family. */\nexport type ExportFamilyDiagnostics = { selected: boolean; typeface?: string; optimizedFiles: number; readFailures: number }\n/** JSON returned by the fonts export endpoint — an array of weight files per family.\n *  `diagnostics` is additive; older servers omit it. */\nexport type ExportFontsResponse = {\n  fonts: Partial<Record<Family, ExportedFont[]>>\n  diagnostics?: Partial<Record<Family, ExportFamilyDiagnostics>>\n}\n\n/**\n * Constant-time secret compare. Both sides are sha256-hashed to a fixed 32 bytes first, so the\n * comparison is constant-time regardless of length.\n */\nfunction secretsMatch(provided: string, secret: string): boolean {\n  const a = createHash('sha256').update(provided).digest()\n  const b = createHash('sha256').update(secret).digest()\n  return timingSafeEqual(a, b)\n}\n\n/**\n * `GET /api/fonts/export`. Resolves the active fonts from the `fontSet` global — each family\n * points at ONE `font` typeface — and returns the bytes of that typeface's served\n * `fontOptimized` files so the `payload-fonts-download` CLI can write them for\n * `next/font/local`. Secured by the project's `PAYLOAD_SECRET` (Bearer).\n */\nexport const exportFontsEndpoint = (opts: ExportFontsEndpointOptions = {}): Endpoint => {\n  const {\n    path: endpointPath = '/fonts/export',\n    fontSetGlobalSlug = 'fontSet',\n    fontOptimizedSlug = 'fontOptimized',\n    families = DEFAULT_FAMILY_KEYS,\n  } = opts\n\n  return {\n    path: endpointPath,\n    method: 'get',\n    handler: async (req) => {\n      const { payload } = req\n\n      // Compare against the RAW PAYLOAD_SECRET (what the caller sends).\n      const secret = process.env.PAYLOAD_SECRET || ''\n      const provided = (req.headers.get('authorization') || '').replace(/^Bearer\\s+/i, '').trim()\n      if (!secret || !provided || !secretsMatch(provided, secret)) {\n        return Response.json({ error: 'Unauthorized' }, { status: 401 })\n      }\n\n      // Read the active selection from the `fontSet` global. The shared secret is the trust\n      // boundary → `overrideAccess: true`.\n      let selection: FontSelection | undefined\n      try {\n        const fontSetGlobal = (await payload.findGlobal({\n          slug: fontSetGlobalSlug as GlobalSlug,\n          // depth 1 populates each slot's typeface (defaultPopulate: title/family), so the\n          // diagnostics can name the selected typeface.\n          depth: 1,\n          overrideAccess: true,\n          // `as unknown as` — in a project with generated types this resolves to the concrete\n          // fontSet interface, which doesn't structurally overlap a string-keyed record.\n        })) as unknown as FontSelection\n        selection = Object.fromEntries(families.map((family) => [family, fontSetGlobal?.[family]]))\n      } catch {\n        // no fontSet global in this project\n      }\n\n      const fonts: Partial<Record<Family, ExportedFont[]>> = {}\n      const diagnostics: Partial<Record<Family, ExportFamilyDiagnostics>> = Object.fromEntries(\n        families.map((family) => [family, { selected: false, optimizedFiles: 0, readFailures: 0 }]),\n      )\n      if (selection) {\n        // One typeface per family (tolerate a stray array — take the first); fetch every family's\n        // served files in a single query grouped by typeface, rather than one round-trip per family.\n        const familyIds = families\n          .map((family) => {\n            const ref = (Array.isArray(selection[family]) ? (selection[family] as TypefaceRef[])[0] : selection[family]) ?? null\n            const title = ref && typeof ref === 'object' && typeof ref.title === 'string' ? ref.title : undefined\n            return { family, id: refId(ref), title }\n          })\n          .filter((r): r is { family: Family; id: string | number; title: string | undefined } => r.id != null)\n\n        const docsByFont = new Map<string | number, Array<Record<string, unknown>>>()\n        if (familyIds.length) {\n          const uniqueIds = [...new Set(familyIds.map((r) => r.id))]\n          try {\n            const res = await payload.find({\n              collection: fontOptimizedSlug as CollectionSlug,\n              where: { font: { in: uniqueIds } },\n              depth: 0,\n              limit: 1000,\n              overrideAccess: true,\n            })\n            for (const doc of res.docs as unknown as Array<Record<string, unknown>>) {\n              const fontId = refId(doc.font)\n              if (fontId == null) continue\n              const bucket = docsByFont.get(fontId)\n              if (bucket) bucket.push(doc)\n              else docsByFont.set(fontId, [doc])\n            }\n          } catch (err) {\n            // leave docsByFont empty — the response just carries no fonts\n            payload.logger.warn({ msg: `[payload-fonts] export: could not query ${fontOptimizedSlug}`, err })\n          }\n        }\n\n        for (const { family, id, title } of familyIds) {\n          const docs = docsByFont.get(id) ?? []\n          const diag = { selected: true, typeface: title, optimizedFiles: docs.length, readFailures: 0 }\n          diagnostics[family] = diag\n          // An explicit italic file always wins over synthesizing italics from an ital-capable\n          // upright — same rule as `expandItalCapableFaces` on the runtime CSS path.\n          const hasExplicitItalic = docs.some((doc) => doc.style === 'italic')\n          const exported: ExportedFont[] = []\n          for (const doc of docs) {\n            const filename = typeof doc.filename === 'string' ? doc.filename : null\n            const bytes = filename\n              ? await readUploadBytes(payload, fontOptimizedSlug, doc as { filename?: string | null; url?: string | null })\n              : null\n            if (!filename || !bytes) {\n              diag.readFailures++\n              continue\n            }\n            const entry: ExportedFont = {\n              filename,\n              extension: filename.split('.').pop()?.toLowerCase() || 'woff2',\n              mimeType: (doc.mimeType as string) ?? null,\n              data: bytes.toString('base64'),\n              weight: (doc.weight as string) ?? null,\n              style: (doc.style as string) ?? null,\n            }\n            exported.push(entry)\n            if (doc.style !== 'italic' && doc.italCapable && !hasExplicitItalic) {\n              exported.push({ ...entry, style: 'italic', obliqueAngle: typeof doc.obliqueAngle === 'number' ? doc.obliqueAngle : null })\n            }\n          }\n          if (exported.length) fonts[family] = exported\n        }\n      }\n\n      // no-store: the response carries font bytes behind auth.\n      return Response.json({ fonts, diagnostics } satisfies ExportFontsResponse, { headers: { 'Cache-Control': 'no-store' } })\n    },\n  }\n}\n"],"names":["createHash","timingSafeEqual","refId","DEFAULT_FONT_FAMILIES","readUploadBytes","DEFAULT_FAMILY_KEYS","map","r","key","secretsMatch","provided","secret","a","update","digest","b","exportFontsEndpoint","opts","path","endpointPath","fontSetGlobalSlug","fontOptimizedSlug","families","method","handler","req","payload","process","env","PAYLOAD_SECRET","headers","get","replace","trim","Response","json","error","status","selection","fontSetGlobal","findGlobal","slug","depth","overrideAccess","Object","fromEntries","family","fonts","diagnostics","selected","optimizedFiles","readFailures","familyIds","ref","Array","isArray","title","undefined","id","filter","docsByFont","Map","length","uniqueIds","Set","res","find","collection","where","font","in","limit","doc","docs","fontId","bucket","push","set","err","logger","warn","msg","diag","typeface","hasExplicitItalic","some","style","exported","filename","bytes","entry","extension","split","pop","toLowerCase","mimeType","data","toString","weight","italCapable","obliqueAngle"],"mappings":"AAAA,SAASA,UAAU,EAAEC,eAAe,QAAQ,cAAa;AAIzD,SAASC,KAAK,QAAQ,iBAAa;AACnC,SAASC,qBAAqB,QAAQ,qBAAiB;AACvD,SAASC,eAAe,QAAQ,wBAAoB;AAIpD,MAAMC,sBAAgCF,sBAAsBG,GAAG,CAAC,CAACC,IAAMA,EAAEC,GAAG;AAwC5E;;;CAGC,GACD,SAASC,aAAaC,QAAgB,EAAEC,MAAc;IACpD,MAAMC,IAAIZ,WAAW,UAAUa,MAAM,CAACH,UAAUI,MAAM;IACtD,MAAMC,IAAIf,WAAW,UAAUa,MAAM,CAACF,QAAQG,MAAM;IACpD,OAAOb,gBAAgBW,GAAGG;AAC5B;AAEA;;;;;CAKC,GACD,OAAO,MAAMC,sBAAsB,CAACC,OAAmC,CAAC,CAAC;IACvE,MAAM,EACJC,MAAMC,eAAe,eAAe,EACpCC,oBAAoB,SAAS,EAC7BC,oBAAoB,eAAe,EACnCC,WAAWjB,mBAAmB,EAC/B,GAAGY;IAEJ,OAAO;QACLC,MAAMC;QACNI,QAAQ;QACRC,SAAS,OAAOC;YACd,MAAM,EAAEC,OAAO,EAAE,GAAGD;YAEpB,kEAAkE;YAClE,MAAMd,SAASgB,QAAQC,GAAG,CAACC,cAAc,IAAI;YAC7C,MAAMnB,WAAW,AAACe,CAAAA,IAAIK,OAAO,CAACC,GAAG,CAAC,oBAAoB,EAAC,EAAGC,OAAO,CAAC,eAAe,IAAIC,IAAI;YACzF,IAAI,CAACtB,UAAU,CAACD,YAAY,CAACD,aAAaC,UAAUC,SAAS;gBAC3D,OAAOuB,SAASC,IAAI,CAAC;oBAAEC,OAAO;gBAAe,GAAG;oBAAEC,QAAQ;gBAAI;YAChE;YAEA,sFAAsF;YACtF,qCAAqC;YACrC,IAAIC;YACJ,IAAI;gBACF,MAAMC,gBAAiB,MAAMb,QAAQc,UAAU,CAAC;oBAC9CC,MAAMrB;oBACN,iFAAiF;oBACjF,8CAA8C;oBAC9CsB,OAAO;oBACPC,gBAAgB;gBAGlB;gBACAL,YAAYM,OAAOC,WAAW,CAACvB,SAAShB,GAAG,CAAC,CAACwC,SAAW;wBAACA;wBAAQP,eAAe,CAACO,OAAO;qBAAC;YAC3F,EAAE,OAAM;YACN,oCAAoC;YACtC;YAEA,MAAMC,QAAiD,CAAC;YACxD,MAAMC,cAAgEJ,OAAOC,WAAW,CACtFvB,SAAShB,GAAG,CAAC,CAACwC,SAAW;oBAACA;oBAAQ;wBAAEG,UAAU;wBAAOC,gBAAgB;wBAAGC,cAAc;oBAAE;iBAAE;YAE5F,IAAIb,WAAW;gBACb,0FAA0F;gBAC1F,6FAA6F;gBAC7F,MAAMc,YAAY9B,SACfhB,GAAG,CAAC,CAACwC;oBACJ,MAAMO,MAAM,AAACC,CAAAA,MAAMC,OAAO,CAACjB,SAAS,CAACQ,OAAO,IAAI,AAACR,SAAS,CAACQ,OAAO,AAAkB,CAAC,EAAE,GAAGR,SAAS,CAACQ,OAAO,AAAD,KAAM;oBAChH,MAAMU,QAAQH,OAAO,OAAOA,QAAQ,YAAY,OAAOA,IAAIG,KAAK,KAAK,WAAWH,IAAIG,KAAK,GAAGC;oBAC5F,OAAO;wBAAEX;wBAAQY,IAAIxD,MAAMmD;wBAAMG;oBAAM;gBACzC,GACCG,MAAM,CAAC,CAACpD,IAA+EA,EAAEmD,EAAE,IAAI;gBAElG,MAAME,aAAa,IAAIC;gBACvB,IAAIT,UAAUU,MAAM,EAAE;oBACpB,MAAMC,YAAY;2BAAI,IAAIC,IAAIZ,UAAU9C,GAAG,CAAC,CAACC,IAAMA,EAAEmD,EAAE;qBAAG;oBAC1D,IAAI;wBACF,MAAMO,MAAM,MAAMvC,QAAQwC,IAAI,CAAC;4BAC7BC,YAAY9C;4BACZ+C,OAAO;gCAAEC,MAAM;oCAAEC,IAAIP;gCAAU;4BAAE;4BACjCrB,OAAO;4BACP6B,OAAO;4BACP5B,gBAAgB;wBAClB;wBACA,KAAK,MAAM6B,OAAOP,IAAIQ,IAAI,CAA+C;4BACvE,MAAMC,SAASxE,MAAMsE,IAAIH,IAAI;4BAC7B,IAAIK,UAAU,MAAM;4BACpB,MAAMC,SAASf,WAAW7B,GAAG,CAAC2C;4BAC9B,IAAIC,QAAQA,OAAOC,IAAI,CAACJ;iCACnBZ,WAAWiB,GAAG,CAACH,QAAQ;gCAACF;6BAAI;wBACnC;oBACF,EAAE,OAAOM,KAAK;wBACZ,8DAA8D;wBAC9DpD,QAAQqD,MAAM,CAACC,IAAI,CAAC;4BAAEC,KAAK,CAAC,wCAAwC,EAAE5D,mBAAmB;4BAAEyD;wBAAI;oBACjG;gBACF;gBAEA,KAAK,MAAM,EAAEhC,MAAM,EAAEY,EAAE,EAAEF,KAAK,EAAE,IAAIJ,UAAW;oBAC7C,MAAMqB,OAAOb,WAAW7B,GAAG,CAAC2B,OAAO,EAAE;oBACrC,MAAMwB,OAAO;wBAAEjC,UAAU;wBAAMkC,UAAU3B;wBAAON,gBAAgBuB,KAAKX,MAAM;wBAAEX,cAAc;oBAAE;oBAC7FH,WAAW,CAACF,OAAO,GAAGoC;oBACtB,qFAAqF;oBACrF,2EAA2E;oBAC3E,MAAME,oBAAoBX,KAAKY,IAAI,CAAC,CAACb,MAAQA,IAAIc,KAAK,KAAK;oBAC3D,MAAMC,WAA2B,EAAE;oBACnC,KAAK,MAAMf,OAAOC,KAAM;wBACtB,MAAMe,WAAW,OAAOhB,IAAIgB,QAAQ,KAAK,WAAWhB,IAAIgB,QAAQ,GAAG;wBACnE,MAAMC,QAAQD,WACV,MAAMpF,gBAAgBsB,SAASL,mBAAmBmD,OAClD;wBACJ,IAAI,CAACgB,YAAY,CAACC,OAAO;4BACvBP,KAAK/B,YAAY;4BACjB;wBACF;wBACA,MAAMuC,QAAsB;4BAC1BF;4BACAG,WAAWH,SAASI,KAAK,CAAC,KAAKC,GAAG,IAAIC,iBAAiB;4BACvDC,UAAU,AAACvB,IAAIuB,QAAQ,IAAe;4BACtCC,MAAMP,MAAMQ,QAAQ,CAAC;4BACrBC,QAAQ,AAAC1B,IAAI0B,MAAM,IAAe;4BAClCZ,OAAO,AAACd,IAAIc,KAAK,IAAe;wBAClC;wBACAC,SAASX,IAAI,CAACc;wBACd,IAAIlB,IAAIc,KAAK,KAAK,YAAYd,IAAI2B,WAAW,IAAI,CAACf,mBAAmB;4BACnEG,SAASX,IAAI,CAAC;gCAAE,GAAGc,KAAK;gCAAEJ,OAAO;gCAAUc,cAAc,OAAO5B,IAAI4B,YAAY,KAAK,WAAW5B,IAAI4B,YAAY,GAAG;4BAAK;wBAC1H;oBACF;oBACA,IAAIb,SAASzB,MAAM,EAAEf,KAAK,CAACD,OAAO,GAAGyC;gBACvC;YACF;YAEA,yDAAyD;YACzD,OAAOrD,SAASC,IAAI,CAAC;gBAAEY;gBAAOC;YAAY,GAAiC;gBAAElB,SAAS;oBAAE,iBAAiB;gBAAW;YAAE;QACxH;IACF;AACF,EAAC"}

package/dist/extractFonts.d.ts

@@ -0,0 +1,20 @@
+/** The shape `next/font/local` produces for each declared font — only the generated
+ *  `variable` (its CSS-variable class) is read here. */
+type FontDefinitions = Record<string, {
+    variable?: string;
+} | undefined>;
+/**
+ * Collect the `next/font/local` CSS-variable classes from a generated `definition.ts` default
+ * export into a single space-separated string for the root `<html>` `className`. Returns
+ * `undefined` when nothing has been generated yet (e.g. before the download CLI has run), so it
+ * drops straight into `className`.
+ *
+ * @example
+ * import definitionFonts from '@/app/definition'
+ * import { extractFonts } from '@pro-laico/payload-fonts'
+ *
+ * <html className={extractFonts(definitionFonts)}>
+ */
+export declare function extractFonts(definitionFonts: FontDefinitions): string | undefined;
+export {};
+//# sourceMappingURL=extractFonts.d.ts.map

package/dist/extractFonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractFonts.d.ts","sourceRoot":"","sources":["../src/extractFonts.ts"],"names":[],"mappings":"AAAA;wDACwD;AACxD,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAAA;AAExE;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,eAAe,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAMjF"}

package/dist/extractFonts.js

@@ -0,0 +1,18 @@
+/** The shape `next/font/local` produces for each declared font — only the generated
+ *  `variable` (its CSS-variable class) is read here. */ /**
+ * Collect the `next/font/local` CSS-variable classes from a generated `definition.ts` default
+ * export into a single space-separated string for the root `<html>` `className`. Returns
+ * `undefined` when nothing has been generated yet (e.g. before the download CLI has run), so it
+ * drops straight into `className`.
+ *
+ * @example
+ * import definitionFonts from '@/app/definition'
+ * import { extractFonts } from '@pro-laico/payload-fonts'
+ *
+ * <html className={extractFonts(definitionFonts)}>
+ */ export function extractFonts(definitionFonts) {
+    const variables = Object.values(definitionFonts).map((font)=>font?.variable).filter(Boolean).join(' ');
+    return variables || undefined;
+}
+
+//# sourceMappingURL=extractFonts.js.map

package/dist/extractFonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extractFonts.ts"],"sourcesContent":["/** The shape `next/font/local` produces for each declared font — only the generated\n *  `variable` (its CSS-variable class) is read here. */\ntype FontDefinitions = Record<string, { variable?: string } | undefined>\n\n/**\n * Collect the `next/font/local` CSS-variable classes from a generated `definition.ts` default\n * export into a single space-separated string for the root `<html>` `className`. Returns\n * `undefined` when nothing has been generated yet (e.g. before the download CLI has run), so it\n * drops straight into `className`.\n *\n * @example\n * import definitionFonts from '@/app/definition'\n * import { extractFonts } from '@pro-laico/payload-fonts'\n *\n * <html className={extractFonts(definitionFonts)}>\n */\nexport function extractFonts(definitionFonts: FontDefinitions): string | undefined {\n  const variables = Object.values(definitionFonts)\n    .map((font) => font?.variable)\n    .filter(Boolean)\n    .join(' ')\n  return variables || undefined\n}\n"],"names":["extractFonts","definitionFonts","variables","Object","values","map","font","variable","filter","Boolean","join","undefined"],"mappings":"AAAA;sDACsD,GAGtD;;;;;;;;;;;CAWC,GACD,OAAO,SAASA,aAAaC,eAAgC;IAC3D,MAAMC,YAAYC,OAAOC,MAAM,CAACH,iBAC7BI,GAAG,CAAC,CAACC,OAASA,MAAMC,UACpBC,MAAM,CAACC,SACPC,IAAI,CAAC;IACR,OAAOR,aAAaS;AACtB"}

package/dist/fields/font.d.ts

@@ -0,0 +1,14 @@
+import type { Field } from 'payload';
+import { type FontFamilyConfig } from '../lib/families';
+/**
+ * The per-family relationship fields for the `fontSet` global — one slot per configured family
+ * (`sans / serif / mono / display` by default), pointing at this package's `font` typeface
+ * collection and laid out two-per-row. Used by the standalone `fontSet` global
+ * (`globals/fontSet.ts`), and exported so a project assembling its own selection surface (a
+ * different global, or a group on an existing collection) can reuse the exact same slots.
+ */
+export declare const fontUploadFields: ({ fontSlug, families }?: {
+    fontSlug?: string;
+    families?: FontFamilyConfig[];
+}) => Field[];
+//# sourceMappingURL=font.d.ts.map

package/dist/fields/font.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font.d.ts","sourceRoot":"","sources":["../../src/fields/font.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,KAAK,EAAE,MAAM,SAAS,CAAA;AAEpD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,iBAAiB,CAAA;AAE5E;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,yBAAiC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAAO,KAAG,KAAK,EAqBlI,CAAA"}