@pro-laico/payload-fonts 0.0.0

package/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-2026 Pro Laico LLC <contact@prolaico.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# @pro-laico/payload-fonts
+
+Custom fonts for [Payload CMS](https://payloadcms.com/) — a Font typeface collection that subsets uploaded files to served WOFF2s, an optional active-font global, and an export endpoint for `next/font/local`.
+
+```bash
+pnpm add @pro-laico/payload-fonts
+```
+
+**[Documentation →](https://payload-plugins.prolaico.com/docs/plugins/payload-fonts)**
+
+## Troubleshooting
+
+**Fonts upload but nothing is served ("the font subsetter failed to load")** — a bundler (Next/Turbopack) inlined the subsetter's wasm/native assets, so `subset-font` can't load at runtime. Keep them external in `next.config`:
+
+```ts
+serverExternalPackages: ['subset-font', 'harfbuzzjs', 'fontkit']
+```
+
+Ported from [`@pro-laico/fonts`](https://github.com/pro-laico/atomic-payload/tree/main/packages/fonts) (Atomic Payload, MIT).

package/dist/access/authd.d.ts

@@ -0,0 +1,19 @@
+import type { Access } from 'payload';
+/**
+ * Default access for the `font` collection and `fontSet` global: any authenticated
+ * user. Reads are gated too because font binaries may be licensed.
+ *
+ * This is intentionally permissive — `@pro-laico/payload-fonts` ships no role model of
+ * its own. Projects that need stricter control (e.g. admin-only writes) should override
+ * `access` at registration time rather than editing this package:
+ *
+ * ```ts
+ * fontsPlugin({
+ *   fontOverrides: { access: { create: adminOnly, update: adminOnly, delete: adminOnly } },
+ *   includeFontSet: true,
+ *   fontSetOverrides: { access: { update: adminOnly } },
+ * })
+ * ```
+ */
+export declare const authd: Access;
+//# sourceMappingURL=authd.d.ts.map

package/dist/access/authd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authd.d.ts","sourceRoot":"","sources":["../../src/access/authd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAErC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,KAAK,EAAE,MAAuC,CAAA"}

package/dist/access/authd.js

@@ -0,0 +1,18 @@
+/**
+ * Default access for the `font` collection and `fontSet` global: any authenticated
+ * user. Reads are gated too because font binaries may be licensed.
+ *
+ * This is intentionally permissive — `@pro-laico/payload-fonts` ships no role model of
+ * its own. Projects that need stricter control (e.g. admin-only writes) should override
+ * `access` at registration time rather than editing this package:
+ *
+ * ```ts
+ * fontsPlugin({
+ *   fontOverrides: { access: { create: adminOnly, update: adminOnly, delete: adminOnly } },
+ *   includeFontSet: true,
+ *   fontSetOverrides: { access: { update: adminOnly } },
+ * })
+ * ```
+ */ export const authd = ({ req })=>Boolean(req.user);
+
+//# sourceMappingURL=authd.js.map

package/dist/access/authd.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/access/authd.ts"],"sourcesContent":["import type { Access } from 'payload'\n\n/**\n * Default access for the `font` collection and `fontSet` global: any authenticated\n * user. Reads are gated too because font binaries may be licensed.\n *\n * This is intentionally permissive — `@pro-laico/payload-fonts` ships no role model of\n * its own. Projects that need stricter control (e.g. admin-only writes) should override\n * `access` at registration time rather than editing this package:\n *\n * ```ts\n * fontsPlugin({\n *   fontOverrides: { access: { create: adminOnly, update: adminOnly, delete: adminOnly } },\n *   includeFontSet: true,\n *   fontSetOverrides: { access: { update: adminOnly } },\n * })\n * ```\n */\nexport const authd: Access = ({ req }) => Boolean(req.user)\n"],"names":["authd","req","Boolean","user"],"mappings":"AAEA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMA,QAAgB,CAAC,EAAEC,GAAG,EAAE,GAAKC,QAAQD,IAAIE,IAAI,EAAC"}

package/dist/collections/font.d.ts

@@ -0,0 +1,29 @@
+import { type CollectionConfig } from 'payload';
+import type { Charset } from '../hooks/optimizeFont';
+import { type FontFamilyConfig } from '../lib/families';
+/** Admin component subpath (Payload import map) for the create-only original uploader. */
+export declare const FontOriginalUploadPath = "@pro-laico/payload-fonts/admin/FontOriginalUpload";
+export interface CreateFontCollectionOptions {
+    /** Characters the subsetter keeps, or a preset ('latin' | 'latin-ext'). Default 'latin'. */
+    charset?: Charset;
+    /** Slug of the archival original upload collection. Default 'fontOriginal'. */
+    originalSlug?: string;
+    /** Slug of the optimized (served) upload collection. Default 'fontOptimized'. */
+    optimizedSlug?: string;
+    /** The options offered by the `family` field. Default sans/serif/mono/display. */
+    families?: FontFamilyConfig[];
+}
+/**
+ * The `Font` collection — ONE document per **typeface** (e.g. "Inter"). The four family slots
+ * (sans/serif/mono/display) select one of these each.
+ *
+ * It is NOT itself an upload collection. Editors drop font files into standard Payload `upload`
+ * fields backed by `fontOriginal` (raw archive) — either the `variable` group (a single
+ * variable file per upright/italic) OR the `weights` array (one file per weight/style). On save,
+ * {@link optimizeFromOriginalsHook} subsets each referenced original to a served
+ * `fontOptimized` WOFF2. The slots are Payload's own upload field, thinly wrapped to be
+ * create-only (no "Choose from existing"), so each original belongs to exactly one typeface —
+ * keeping asset cleanup safe and race-free.
+ */
+export declare const createFontCollection: (opts?: CreateFontCollectionOptions) => CollectionConfig;
+//# sourceMappingURL=font.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font.d.ts","sourceRoot":"","sources":["../../src/collections/font.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,gBAAgB,EAGtB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,iBAAiB,CAAA;AAO5E,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,sDAAsD,CAAA;AASzF,MAAM,WAAW,2BAA2B;IAC1C,4FAA4F;IAC5F,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAC9B;AA2FD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAM,2BAAgC,KAAG,gBAgH7E,CAAA"}

package/dist/collections/font.js

@@ -0,0 +1,327 @@
+import { APIError } from "payload";
+import { authd } from "../access/authd.js";
+import { cleanupFontAssetsHook, optimizeFromOriginalsHook, originalIdsFromDoc } from "../hooks/optimizeFromOriginals.js";
+import { resolveFontFamilies } from "../lib/families.js";
+import { FONT_OPTIMIZED_SLUG } from "./fontOptimized.js";
+import { FONT_ORIGINAL_SLUG } from "./fontOriginal.js";
+/** Standard `next/font/local` weight steps offered by each weight row. */ const WEIGHT_OPTIONS = [
+    '100',
+    '200',
+    '300',
+    '400',
+    '500',
+    '600',
+    '700',
+    '800',
+    '900'
+];
+/** Admin component subpath (Payload import map) for the create-only original uploader. */ export const FontOriginalUploadPath = '@pro-laico/payload-fonts/admin/FontOriginalUpload';
+/**
+ * A FRESH admin config that renders the `fontOriginal` slot create-only (no "Choose from
+ * existing"), so every slot uploads a fresh original — never shared between typefaces. A
+ * factory (not a shared object) because Payload mutates field configs in place during
+ * sanitization; sharing one reference across slots corrupts it.
+ */ const createOnlyUpload = ()=>({
+        components: {
+            Field: {
+                path: FontOriginalUploadPath
+            }
+        }
+    });
+const hasVariable = (data)=>{
+    const v = data?.variable ?? {};
+    return Boolean(v.upright || v.italic);
+};
+const hasWeights = (data)=>Array.isArray(data?.weights) && data.weights.some((w)=>w?.file);
+/**
+ * `afterRead`: report how many served `fontOptimized` files this typeface produced, so an editor can
+ * see at a glance whether optimization succeeded — `0` means nothing was served (a swap/re-save is
+ * due, or the upload failed to subset). Skipped on list reads (`findMany`) so it's one count query
+ * on the edit view, not one per row. Populates the virtual `servedFiles` sidebar field.
+ */ const servedFilesHook = (optimizedSlug)=>async ({ doc, findMany, req })=>{
+        if (findMany || !req?.payload) return doc;
+        const id = doc.id;
+        if (id == null) return doc;
+        try {
+            const { totalDocs } = await req.payload.count({
+                collection: optimizedSlug,
+                where: {
+                    font: {
+                        equals: id
+                    }
+                },
+                overrideAccess: true,
+                req
+            });
+            doc.servedFiles = totalDocs;
+        } catch  {
+        // a count failure shouldn't break the read — just leave it unset
+        }
+        return doc;
+    };
+/**
+ * `beforeValidate`: a typeface needs at least one file, and can't mix a variable font with
+ * specific weights (you compose from one or the other). Runs on create and on any update that
+ * touches these fields, so an unrelated partial edit is left alone.
+ */ const requireFontFiles = ({ data, operation })=>{
+    const touches = operation === 'create' || data != null && ('variable' in data || 'weights' in data);
+    if (!touches) return data;
+    if (hasVariable(data) && hasWeights(data)) {
+        throw new APIError('Use either a variable font or specific weight files, not both.', 400, null, true);
+    }
+    if (!hasVariable(data) && !hasWeights(data)) {
+        throw new APIError('Add at least one font file before saving.', 400, null, true);
+    }
+    return data;
+};
+/**
+ * `beforeValidate`: enforce one `fontOriginal` per typeface — reject a save that references an
+ * original already used by ANOTHER typeface. The create-only upload slots make sharing
+ * impossible from the admin UI, but this is the data-layer guarantee (covers the REST API,
+ * imports, seeds, and a future Payload upgrade that might un-hide "Choose from existing"). It's
+ * what makes the direct asset cleanup in {@link cleanupFontAssetsHook} /
+ * {@link optimizeFromOriginalsHook} safe: a de-referenced or deleted original is never still in
+ * use elsewhere.
+ */ const makeRejectSharedOriginals = (fontSlug)=>async ({ data, originalDoc, req })=>{
+        if (!data || !req?.payload) return data;
+        const ids = originalIdsFromDoc(data);
+        if (ids.length === 0) return data;
+        const selfId = originalDoc?.id ?? data.id;
+        const refs = [
+            {
+                'variable.upright': {
+                    in: ids
+                }
+            },
+            {
+                'variable.italic': {
+                    in: ids
+                }
+            },
+            {
+                'weights.file': {
+                    in: ids
+                }
+            }
+        ];
+        const where = selfId != null ? {
+            and: [
+                {
+                    id: {
+                        not_equals: selfId
+                    }
+                },
+                {
+                    or: refs
+                }
+            ]
+        } : {
+            or: refs
+        };
+        const res = await req.payload.find({
+            collection: fontSlug,
+            where: where,
+            depth: 0,
+            limit: 1,
+            overrideAccess: true,
+            req
+        });
+        if (res.totalDocs > 0) {
+            const other = res.docs[0].title || 'another typeface';
+            throw new APIError(`That font file is already used by ${other}. Each typeface needs its own upload — add a fresh copy for this slot.`, 400, null, true);
+        }
+        return data;
+    };
+/**
+ * The `Font` collection — ONE document per **typeface** (e.g. "Inter"). The four family slots
+ * (sans/serif/mono/display) select one of these each.
+ *
+ * It is NOT itself an upload collection. Editors drop font files into standard Payload `upload`
+ * fields backed by `fontOriginal` (raw archive) — either the `variable` group (a single
+ * variable file per upright/italic) OR the `weights` array (one file per weight/style). On save,
+ * {@link optimizeFromOriginalsHook} subsets each referenced original to a served
+ * `fontOptimized` WOFF2. The slots are Payload's own upload field, thinly wrapped to be
+ * create-only (no "Choose from existing"), so each original belongs to exactly one typeface —
+ * keeping asset cleanup safe and race-free.
+ */ export const createFontCollection = (opts = {})=>{
+    const fontSlug = 'font';
+    const originalSlug = opts.originalSlug || FONT_ORIGINAL_SLUG;
+    const optimizedSlug = opts.optimizedSlug || FONT_OPTIMIZED_SLUG;
+    const families = resolveFontFamilies(opts.families);
+    const fields = [
+        {
+            name: 'title',
+            type: 'text',
+            required: true,
+            label: 'Typeface name'
+        },
+        {
+            name: 'family',
+            type: 'radio',
+            required: true,
+            label: 'Preferred Family',
+            interfaceName: 'GenericFontFamily',
+            options: families.map((r)=>({
+                    label: r.label,
+                    value: r.key
+                }))
+        },
+        // Editor-facing status: how many web-ready files this typeface produced. Virtual (computed on
+        // read by `servedFilesHook`, never stored); shown only on an existing doc so a `0` after saving
+        // flags a failed/empty optimization instead of it failing silently.
+        {
+            name: 'servedFiles',
+            type: 'number',
+            virtual: true,
+            admin: {
+                readOnly: true,
+                position: 'sidebar',
+                description: 'Web-ready files generated from your uploads. 0 means nothing was served yet — re-save; if it stays 0, the upload may have failed to optimize (check server logs).',
+                condition: (data)=>Boolean(data?.id)
+            }
+        },
+        {
+            name: 'variable',
+            type: 'group',
+            label: 'Variable font',
+            admin: {
+                description: 'One file covering many weights. Use this OR specific weights below — not both.',
+                // Hidden once specific weights are added; you compose from one path or the other.
+                condition: (data)=>!hasWeights(data)
+            },
+            fields: [
+                {
+                    type: 'row',
+                    fields: [
+                        {
+                            name: 'upright',
+                            type: 'upload',
+                            relationTo: originalSlug,
+                            label: 'Upright (normal)',
+                            admin: createOnlyUpload()
+                        },
+                        {
+                            name: 'italic',
+                            type: 'upload',
+                            relationTo: originalSlug,
+                            label: 'Italic',
+                            admin: createOnlyUpload()
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            name: 'weights',
+            type: 'array',
+            label: 'Weights',
+            labels: {
+                singular: 'Weight file',
+                plural: 'Weight files'
+            },
+            admin: {
+                description: 'One file per weight/style. Add only the weights you need.',
+                condition: (data)=>!hasVariable(data)
+            },
+            // Each weight + style must be unique so the generated next/font src array has no conflicts.
+            validate: (rows)=>{
+                const seen = new Set();
+                for (const r of Array.isArray(rows) ? rows : []){
+                    const key = `${r?.weight ?? ''}|${r?.style ?? ''}`;
+                    if (seen.has(key)) return `Two files share weight ${r?.weight ?? '?'} ${r?.style ?? 'normal'}. Each weight + style must be unique.`;
+                    seen.add(key);
+                }
+                return true;
+            },
+            fields: [
+                {
+                    type: 'row',
+                    fields: [
+                        {
+                            name: 'weight',
+                            type: 'select',
+                            required: true,
+                            defaultValue: '400',
+                            options: WEIGHT_OPTIONS
+                        },
+                        {
+                            name: 'style',
+                            type: 'radio',
+                            required: true,
+                            defaultValue: 'normal',
+                            options: [
+                                'normal',
+                                'italic'
+                            ]
+                        }
+                    ]
+                },
+                {
+                    name: 'file',
+                    type: 'upload',
+                    relationTo: originalSlug,
+                    required: true,
+                    admin: createOnlyUpload()
+                }
+            ]
+        }
+    ];
+    return {
+        slug: fontSlug,
+        access: {
+            create: authd,
+            delete: authd,
+            read: authd,
+            update: authd
+        },
+        admin: {
+            group: 'Assets',
+            useAsTitle: 'title',
+            enableListViewSelectAPI: true,
+            defaultColumns: [
+                'title',
+                'family'
+            ],
+            description: 'Upload typefaces here to add them to your library. Uploading alone doesn’t put a font on your site — activate it by picking it in Font Set.'
+        },
+        timestamps: true,
+        // When a font is populated as a relationship target (e.g. the `fontSet` global at depth),
+        // return only its identifying metadata and NOT the `variable` / `weights` upload slots — which
+        // would otherwise drag the private `fontOriginal` blobs through every populated row.
+        defaultPopulate: {
+            title: true,
+            family: true
+        },
+        fields,
+        hooks: {
+            // Guard the referenced originals: at least one file, and no original shared across typefaces.
+            beforeValidate: [
+                requireFontFiles,
+                makeRejectSharedOriginals(fontSlug)
+            ],
+            // On save, (re)build the served WOFF2 files from the referenced originals (and clean up
+            // any original a swapped/removed slot de-referenced).
+            afterChange: [
+                optimizeFromOriginalsHook({
+                    charset: opts.charset,
+                    originalSlug,
+                    optimizedSlug
+                })
+            ],
+            // On read (edit view only), surface the served-file count so a failed optimize isn't silent.
+            afterRead: [
+                servedFilesHook(optimizedSlug)
+            ],
+            // Before delete, cascade to the served files + the archived originals (beforeDelete so the
+            // `fontOptimized.font` relationship is still intact — see the hook).
+            beforeDelete: [
+                cleanupFontAssetsHook({
+                    originalSlug,
+                    optimizedSlug
+                })
+            ]
+        }
+    };
+};
+
+//# sourceMappingURL=font.js.map

package/dist/collections/font.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collections/font.ts"],"sourcesContent":["import {\n  APIError,\n  type ArrayField,\n  type CollectionAfterReadHook,\n  type CollectionBeforeValidateHook,\n  type CollectionConfig,\n  type CollectionSlug,\n  type Field,\n} from 'payload'\n\nimport { authd } from '../access/authd'\nimport { cleanupFontAssetsHook, optimizeFromOriginalsHook, originalIdsFromDoc } from '../hooks/optimizeFromOriginals'\nimport type { Charset } from '../hooks/optimizeFont'\nimport { type FontFamilyConfig, resolveFontFamilies } from '../lib/families'\nimport { FONT_OPTIMIZED_SLUG } from './fontOptimized'\nimport { FONT_ORIGINAL_SLUG } from './fontOriginal'\n\n/** Standard `next/font/local` weight steps offered by each weight row. */\nconst WEIGHT_OPTIONS = ['100', '200', '300', '400', '500', '600', '700', '800', '900']\n\n/** Admin component subpath (Payload import map) for the create-only original uploader. */\nexport const FontOriginalUploadPath = '@pro-laico/payload-fonts/admin/FontOriginalUpload'\n/**\n * A FRESH admin config that renders the `fontOriginal` slot create-only (no \"Choose from\n * existing\"), so every slot uploads a fresh original — never shared between typefaces. A\n * factory (not a shared object) because Payload mutates field configs in place during\n * sanitization; sharing one reference across slots corrupts it.\n */\nconst createOnlyUpload = () => ({ components: { Field: { path: FontOriginalUploadPath } } })\n\nexport interface CreateFontCollectionOptions {\n  /** Characters the subsetter keeps, or a preset ('latin' | 'latin-ext'). Default 'latin'. */\n  charset?: Charset\n  /** Slug of the archival original upload collection. Default 'fontOriginal'. */\n  originalSlug?: string\n  /** Slug of the optimized (served) upload collection. Default 'fontOptimized'. */\n  optimizedSlug?: string\n  /** The options offered by the `family` field. Default sans/serif/mono/display. */\n  families?: FontFamilyConfig[]\n}\n\ntype VariableGroup = { upright?: unknown; italic?: unknown }\nconst hasVariable = (data: Record<string, unknown> | undefined): boolean => {\n  const v = (data?.variable ?? {}) as VariableGroup\n  return Boolean(v.upright || v.italic)\n}\nconst hasWeights = (data: Record<string, unknown> | undefined): boolean =>\n  Array.isArray(data?.weights) && (data.weights as Array<{ file?: unknown }>).some((w) => w?.file)\n\n/**\n * `afterRead`: report how many served `fontOptimized` files this typeface produced, so an editor can\n * see at a glance whether optimization succeeded — `0` means nothing was served (a swap/re-save is\n * due, or the upload failed to subset). Skipped on list reads (`findMany`) so it's one count query\n * on the edit view, not one per row. Populates the virtual `servedFiles` sidebar field.\n */\nconst servedFilesHook =\n  (optimizedSlug: string): CollectionAfterReadHook =>\n  async ({ doc, findMany, req }) => {\n    if (findMany || !req?.payload) return doc\n    const id = (doc as { id?: string | number }).id\n    if (id == null) return doc\n    try {\n      const { totalDocs } = await req.payload.count({\n        collection: optimizedSlug as CollectionSlug,\n        where: { font: { equals: id } },\n        overrideAccess: true,\n        req,\n      })\n      ;(doc as Record<string, unknown>).servedFiles = totalDocs\n    } catch {\n      // a count failure shouldn't break the read — just leave it unset\n    }\n    return doc\n  }\n\n/**\n * `beforeValidate`: a typeface needs at least one file, and can't mix a variable font with\n * specific weights (you compose from one or the other). Runs on create and on any update that\n * touches these fields, so an unrelated partial edit is left alone.\n */\nconst requireFontFiles: CollectionBeforeValidateHook = ({ data, operation }) => {\n  const touches = operation === 'create' || (data != null && ('variable' in data || 'weights' in data))\n  if (!touches) return data\n  if (hasVariable(data) && hasWeights(data)) {\n    throw new APIError('Use either a variable font or specific weight files, not both.', 400, null, true)\n  }\n  if (!hasVariable(data) && !hasWeights(data)) {\n    throw new APIError('Add at least one font file before saving.', 400, null, true)\n  }\n  return data\n}\n\n/**\n * `beforeValidate`: enforce one `fontOriginal` per typeface — reject a save that references an\n * original already used by ANOTHER typeface. The create-only upload slots make sharing\n * impossible from the admin UI, but this is the data-layer guarantee (covers the REST API,\n * imports, seeds, and a future Payload upgrade that might un-hide \"Choose from existing\"). It's\n * what makes the direct asset cleanup in {@link cleanupFontAssetsHook} /\n * {@link optimizeFromOriginalsHook} safe: a de-referenced or deleted original is never still in\n * use elsewhere.\n */\nconst makeRejectSharedOriginals =\n  (fontSlug: string): CollectionBeforeValidateHook =>\n  async ({ data, originalDoc, req }) => {\n    if (!data || !req?.payload) return data\n    const ids = originalIdsFromDoc(data as Record<string, unknown>)\n    if (ids.length === 0) return data\n    const selfId = (originalDoc as { id?: string | number } | undefined)?.id ?? (data as { id?: string | number }).id\n    const refs = [{ 'variable.upright': { in: ids } }, { 'variable.italic': { in: ids } }, { 'weights.file': { in: ids } }]\n    const where = selfId != null ? { and: [{ id: { not_equals: selfId } }, { or: refs }] } : { or: refs }\n    const res = await req.payload.find({\n      collection: fontSlug as CollectionSlug,\n      where: where as never,\n      depth: 0,\n      limit: 1,\n      overrideAccess: true,\n      req,\n    })\n    if (res.totalDocs > 0) {\n      const other = (res.docs[0] as { title?: string }).title || 'another typeface'\n      throw new APIError(\n        `That font file is already used by ${other}. Each typeface needs its own upload — add a fresh copy for this slot.`,\n        400,\n        null,\n        true,\n      )\n    }\n    return data\n  }\n\n/**\n * The `Font` collection — ONE document per **typeface** (e.g. \"Inter\"). The four family slots\n * (sans/serif/mono/display) select one of these each.\n *\n * It is NOT itself an upload collection. Editors drop font files into standard Payload `upload`\n * fields backed by `fontOriginal` (raw archive) — either the `variable` group (a single\n * variable file per upright/italic) OR the `weights` array (one file per weight/style). On save,\n * {@link optimizeFromOriginalsHook} subsets each referenced original to a served\n * `fontOptimized` WOFF2. The slots are Payload's own upload field, thinly wrapped to be\n * create-only (no \"Choose from existing\"), so each original belongs to exactly one typeface —\n * keeping asset cleanup safe and race-free.\n */\nexport const createFontCollection = (opts: CreateFontCollectionOptions = {}): CollectionConfig => {\n  const fontSlug = 'font'\n  const originalSlug = (opts.originalSlug || FONT_ORIGINAL_SLUG) as CollectionSlug\n  const optimizedSlug = opts.optimizedSlug || FONT_OPTIMIZED_SLUG\n  const families = resolveFontFamilies(opts.families)\n\n  const fields: Field[] = [\n    { name: 'title', type: 'text', required: true, label: 'Typeface name' },\n    {\n      name: 'family',\n      type: 'radio',\n      required: true,\n      label: 'Preferred Family',\n      interfaceName: 'GenericFontFamily',\n      options: families.map((r) => ({ label: r.label, value: r.key })),\n    },\n    // Editor-facing status: how many web-ready files this typeface produced. Virtual (computed on\n    // read by `servedFilesHook`, never stored); shown only on an existing doc so a `0` after saving\n    // flags a failed/empty optimization instead of it failing silently.\n    {\n      name: 'servedFiles',\n      type: 'number',\n      virtual: true,\n      admin: {\n        readOnly: true,\n        position: 'sidebar',\n        description:\n          'Web-ready files generated from your uploads. 0 means nothing was served yet — re-save; if it stays 0, the upload may have failed to optimize (check server logs).',\n        condition: (data) => Boolean((data as { id?: unknown })?.id),\n      },\n    },\n    {\n      name: 'variable',\n      type: 'group',\n      label: 'Variable font',\n      admin: {\n        description: 'One file covering many weights. Use this OR specific weights below — not both.',\n        // Hidden once specific weights are added; you compose from one path or the other.\n        condition: (data) => !hasWeights(data as Record<string, unknown>),\n      },\n      fields: [\n        {\n          type: 'row',\n          fields: [\n            { name: 'upright', type: 'upload', relationTo: originalSlug, label: 'Upright (normal)', admin: createOnlyUpload() },\n            { name: 'italic', type: 'upload', relationTo: originalSlug, label: 'Italic', admin: createOnlyUpload() },\n          ],\n        },\n      ],\n    },\n    {\n      name: 'weights',\n      type: 'array',\n      label: 'Weights',\n      labels: { singular: 'Weight file', plural: 'Weight files' },\n      admin: {\n        description: 'One file per weight/style. Add only the weights you need.',\n        condition: (data) => !hasVariable(data as Record<string, unknown>),\n      },\n      // Each weight + style must be unique so the generated next/font src array has no conflicts.\n      validate: ((rows: Array<{ weight?: string; style?: string }> | null | undefined) => {\n        const seen = new Set<string>()\n        for (const r of Array.isArray(rows) ? rows : []) {\n          const key = `${r?.weight ?? ''}|${r?.style ?? ''}`\n          if (seen.has(key)) return `Two files share weight ${r?.weight ?? '?'} ${r?.style ?? 'normal'}. Each weight + style must be unique.`\n          seen.add(key)\n        }\n        return true\n      }) as ArrayField['validate'],\n      fields: [\n        {\n          type: 'row',\n          fields: [\n            { name: 'weight', type: 'select', required: true, defaultValue: '400', options: WEIGHT_OPTIONS },\n            { name: 'style', type: 'radio', required: true, defaultValue: 'normal', options: ['normal', 'italic'] },\n          ],\n        },\n        { name: 'file', type: 'upload', relationTo: originalSlug, required: true, admin: createOnlyUpload() },\n      ],\n    },\n  ]\n\n  return {\n    slug: fontSlug,\n    access: { create: authd, delete: authd, read: authd, update: authd },\n    admin: {\n      group: 'Assets',\n      useAsTitle: 'title',\n      enableListViewSelectAPI: true,\n      defaultColumns: ['title', 'family'],\n      description:\n        'Upload typefaces here to add them to your library. Uploading alone doesn’t put a font on your site — activate it by picking it in Font Set.',\n    },\n    timestamps: true,\n    // When a font is populated as a relationship target (e.g. the `fontSet` global at depth),\n    // return only its identifying metadata and NOT the `variable` / `weights` upload slots — which\n    // would otherwise drag the private `fontOriginal` blobs through every populated row.\n    defaultPopulate: { title: true, family: true },\n    fields,\n    hooks: {\n      // Guard the referenced originals: at least one file, and no original shared across typefaces.\n      beforeValidate: [requireFontFiles, makeRejectSharedOriginals(fontSlug)],\n      // On save, (re)build the served WOFF2 files from the referenced originals (and clean up\n      // any original a swapped/removed slot de-referenced).\n      afterChange: [optimizeFromOriginalsHook({ charset: opts.charset, originalSlug, optimizedSlug })],\n      // On read (edit view only), surface the served-file count so a failed optimize isn't silent.\n      afterRead: [servedFilesHook(optimizedSlug)],\n      // Before delete, cascade to the served files + the archived originals (beforeDelete so the\n      // `fontOptimized.font` relationship is still intact — see the hook).\n      beforeDelete: [cleanupFontAssetsHook({ originalSlug, optimizedSlug })],\n    },\n  }\n}\n"],"names":["APIError","authd","cleanupFontAssetsHook","optimizeFromOriginalsHook","originalIdsFromDoc","resolveFontFamilies","FONT_OPTIMIZED_SLUG","FONT_ORIGINAL_SLUG","WEIGHT_OPTIONS","FontOriginalUploadPath","createOnlyUpload","components","Field","path","hasVariable","data","v","variable","Boolean","upright","italic","hasWeights","Array","isArray","weights","some","w","file","servedFilesHook","optimizedSlug","doc","findMany","req","payload","id","totalDocs","count","collection","where","font","equals","overrideAccess","servedFiles","requireFontFiles","operation","touches","makeRejectSharedOriginals","fontSlug","originalDoc","ids","length","selfId","refs","in","and","not_equals","or","res","find","depth","limit","other","docs","title","createFontCollection","opts","originalSlug","families","fields","name","type","required","label","interfaceName","options","map","r","value","key","virtual","admin","readOnly","position","description","condition","relationTo","labels","singular","plural","validate","rows","seen","Set","weight","style","has","add","defaultValue","slug","access","create","delete","read","update","group","useAsTitle","enableListViewSelectAPI","defaultColumns","timestamps","defaultPopulate","family","hooks","beforeValidate","afterChange","charset","afterRead","beforeDelete"],"mappings":"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"}

package/dist/collections/fontOptimized.d.ts

@@ -0,0 +1,20 @@
+import type { CollectionConfig } from 'payload';
+/** Slug of the optimized (served) weight-file upload collection. */
+export declare const FONT_OPTIMIZED_SLUG = "fontOptimized";
+export interface CreateFontOptimizedCollectionOptions {
+    /** Slug of the `Font` typeface collection these belong to. Default 'font'. */
+    fontSlug?: string;
+    /** Slug of the archival original collection each is derived from. Default 'fontOriginal'. */
+    originalSlug?: string;
+}
+/**
+ * The optimized, subsetted WOFF2 files the site actually serves — one upload document per
+ * weight/style (or variable file). They are DERIVED, not uploaded by hand: the `Font`
+ * collection's save hook reads the referenced `fontOriginal` files, subsets each to WOFF2, and
+ * creates one of these linked back to its source original and its owning typeface.
+ *
+ * Hidden from admin nav (editors only ever touch `Font`), and always server-side stored — the
+ * save hook writes the bytes, so there's nothing to client-upload.
+ */
+export declare const createFontOptimizedCollection: (opts?: CreateFontOptimizedCollectionOptions) => CollectionConfig;
+//# sourceMappingURL=fontOptimized.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fontOptimized.d.ts","sourceRoot":"","sources":["../../src/collections/fontOptimized.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,SAAS,CAAA;AAK/D,oEAAoE;AACpE,eAAO,MAAM,mBAAmB,kBAAkB,CAAA;AAElD,MAAM,WAAW,oCAAoC;IACnD,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6FAA6F;IAC7F,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GAAI,OAAM,oCAAyC,KAAG,gBA6B/F,CAAA"}

package/dist/collections/fontOptimized.js

@@ -0,0 +1,111 @@
+import { authd } from "../access/authd.js";
+import { FONT_ORIGINAL_SLUG } from "./fontOriginal.js";
+/** Slug of the optimized (served) weight-file upload collection. */ export const FONT_OPTIMIZED_SLUG = 'fontOptimized';
+/**
+ * The optimized, subsetted WOFF2 files the site actually serves — one upload document per
+ * weight/style (or variable file). They are DERIVED, not uploaded by hand: the `Font`
+ * collection's save hook reads the referenced `fontOriginal` files, subsets each to WOFF2, and
+ * creates one of these linked back to its source original and its owning typeface.
+ *
+ * Hidden from admin nav (editors only ever touch `Font`), and always server-side stored — the
+ * save hook writes the bytes, so there's nothing to client-upload.
+ */ export const createFontOptimizedCollection = (opts = {})=>{
+    const fontSlug = opts.fontSlug || 'font';
+    const originalSlug = opts.originalSlug || FONT_ORIGINAL_SLUG;
+    return {
+        slug: FONT_OPTIMIZED_SLUG,
+        // The optimized files ARE public web fonts — the build-time export endpoint (no user
+        // session) downloads them to self-host via next/font. Public read lets that read succeed
+        // even when they're on cloud storage served through Payload's access-controlled file route.
+        // Writes stay gated; the raw originals stay private.
+        access: {
+            create: authd,
+            delete: authd,
+            read: ()=>true,
+            update: authd
+        },
+        admin: {
+            group: 'Assets',
+            hidden: true,
+            useAsTitle: 'filename',
+            defaultColumns: [
+                'filename',
+                'weight',
+                'style',
+                'isVariable'
+            ]
+        },
+        upload: {
+            mimeTypes: [
+                'font/woff2'
+            ]
+        },
+        fields: [
+            // The owning typeface — the export endpoint and the reconcile hook query by it.
+            {
+                name: 'font',
+                type: 'relationship',
+                relationTo: fontSlug,
+                admin: {
+                    readOnly: true
+                }
+            },
+            // The source original this was subsetted from — the reconcile key (one optimized per original).
+            {
+                name: 'original',
+                type: 'relationship',
+                relationTo: originalSlug,
+                admin: {
+                    readOnly: true
+                }
+            },
+            // CSS font-weight: a single step ('400') or a variable range ('100 900'); served verbatim to next/font.
+            {
+                name: 'weight',
+                type: 'text',
+                admin: {
+                    readOnly: true
+                }
+            },
+            {
+                name: 'style',
+                type: 'radio',
+                options: [
+                    'normal',
+                    'italic'
+                ],
+                admin: {
+                    readOnly: true
+                }
+            },
+            {
+                name: 'isVariable',
+                type: 'checkbox',
+                admin: {
+                    readOnly: true
+                }
+            },
+            // This upright variable file ALSO carries italics via its axes (`ital`, or a negative
+            // `slnt`) — the serving layers emit a second, italic @font-face from the same file, unless
+            // the typeface has an explicit italic file.
+            {
+                name: 'italCapable',
+                type: 'checkbox',
+                admin: {
+                    readOnly: true
+                }
+            },
+            // For slnt-based italics: the positive CSS `oblique` angle (deg) matching the axis extreme.
+            {
+                name: 'obliqueAngle',
+                type: 'number',
+                admin: {
+                    readOnly: true,
+                    condition: (data)=>Boolean(data?.italCapable)
+                }
+            }
+        ]
+    };
+};
+
+//# sourceMappingURL=fontOptimized.js.map

package/dist/collections/fontOptimized.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/collections/fontOptimized.ts"],"sourcesContent":["import type { CollectionConfig, CollectionSlug } from 'payload'\n\nimport { authd } from '../access/authd'\nimport { FONT_ORIGINAL_SLUG } from './fontOriginal'\n\n/** Slug of the optimized (served) weight-file upload collection. */\nexport const FONT_OPTIMIZED_SLUG = 'fontOptimized'\n\nexport interface CreateFontOptimizedCollectionOptions {\n  /** Slug of the `Font` typeface collection these belong to. Default 'font'. */\n  fontSlug?: string\n  /** Slug of the archival original collection each is derived from. Default 'fontOriginal'. */\n  originalSlug?: string\n}\n\n/**\n * The optimized, subsetted WOFF2 files the site actually serves — one upload document per\n * weight/style (or variable file). They are DERIVED, not uploaded by hand: the `Font`\n * collection's save hook reads the referenced `fontOriginal` files, subsets each to WOFF2, and\n * creates one of these linked back to its source original and its owning typeface.\n *\n * Hidden from admin nav (editors only ever touch `Font`), and always server-side stored — the\n * save hook writes the bytes, so there's nothing to client-upload.\n */\nexport const createFontOptimizedCollection = (opts: CreateFontOptimizedCollectionOptions = {}): CollectionConfig => {\n  const fontSlug = opts.fontSlug || 'font'\n  const originalSlug = opts.originalSlug || FONT_ORIGINAL_SLUG\n  return {\n    slug: FONT_OPTIMIZED_SLUG,\n    // The optimized files ARE public web fonts — the build-time export endpoint (no user\n    // session) downloads them to self-host via next/font. Public read lets that read succeed\n    // even when they're on cloud storage served through Payload's access-controlled file route.\n    // Writes stay gated; the raw originals stay private.\n    access: { create: authd, delete: authd, read: () => true, update: authd },\n    admin: { group: 'Assets', hidden: true, useAsTitle: 'filename', defaultColumns: ['filename', 'weight', 'style', 'isVariable'] },\n    upload: { mimeTypes: ['font/woff2'] },\n    fields: [\n      // The owning typeface — the export endpoint and the reconcile hook query by it.\n      { name: 'font', type: 'relationship', relationTo: fontSlug as CollectionSlug, admin: { readOnly: true } },\n      // The source original this was subsetted from — the reconcile key (one optimized per original).\n      { name: 'original', type: 'relationship', relationTo: originalSlug as CollectionSlug, admin: { readOnly: true } },\n      // CSS font-weight: a single step ('400') or a variable range ('100 900'); served verbatim to next/font.\n      { name: 'weight', type: 'text', admin: { readOnly: true } },\n      { name: 'style', type: 'radio', options: ['normal', 'italic'], admin: { readOnly: true } },\n      { name: 'isVariable', type: 'checkbox', admin: { readOnly: true } },\n      // This upright variable file ALSO carries italics via its axes (`ital`, or a negative\n      // `slnt`) — the serving layers emit a second, italic @font-face from the same file, unless\n      // the typeface has an explicit italic file.\n      { name: 'italCapable', type: 'checkbox', admin: { readOnly: true } },\n      // For slnt-based italics: the positive CSS `oblique` angle (deg) matching the axis extreme.\n      { name: 'obliqueAngle', type: 'number', admin: { readOnly: true, condition: (data) => Boolean(data?.italCapable) } },\n    ],\n  }\n}\n"],"names":["authd","FONT_ORIGINAL_SLUG","FONT_OPTIMIZED_SLUG","createFontOptimizedCollection","opts","fontSlug","originalSlug","slug","access","create","delete","read","update","admin","group","hidden","useAsTitle","defaultColumns","upload","mimeTypes","fields","name","type","relationTo","readOnly","options","condition","data","Boolean","italCapable"],"mappings":"AAEA,SAASA,KAAK,QAAQ,qBAAiB;AACvC,SAASC,kBAAkB,QAAQ,oBAAgB;AAEnD,kEAAkE,GAClE,OAAO,MAAMC,sBAAsB,gBAAe;AASlD;;;;;;;;CAQC,GACD,OAAO,MAAMC,gCAAgC,CAACC,OAA6C,CAAC,CAAC;IAC3F,MAAMC,WAAWD,KAAKC,QAAQ,IAAI;IAClC,MAAMC,eAAeF,KAAKE,YAAY,IAAIL;IAC1C,OAAO;QACLM,MAAML;QACN,qFAAqF;QACrF,yFAAyF;QACzF,4FAA4F;QAC5F,qDAAqD;QACrDM,QAAQ;YAAEC,QAAQT;YAAOU,QAAQV;YAAOW,MAAM,IAAM;YAAMC,QAAQZ;QAAM;QACxEa,OAAO;YAAEC,OAAO;YAAUC,QAAQ;YAAMC,YAAY;YAAYC,gBAAgB;gBAAC;gBAAY;gBAAU;gBAAS;aAAa;QAAC;QAC9HC,QAAQ;YAAEC,WAAW;gBAAC;aAAa;QAAC;QACpCC,QAAQ;YACN,gFAAgF;YAChF;gBAAEC,MAAM;gBAAQC,MAAM;gBAAgBC,YAAYlB;gBAA4BQ,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YACxG,gGAAgG;YAChG;gBAAEH,MAAM;gBAAYC,MAAM;gBAAgBC,YAAYjB;gBAAgCO,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YAChH,wGAAwG;YACxG;gBAAEH,MAAM;gBAAUC,MAAM;gBAAQT,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YAC1D;gBAAEH,MAAM;gBAASC,MAAM;gBAASG,SAAS;oBAAC;oBAAU;iBAAS;gBAAEZ,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YACzF;gBAAEH,MAAM;gBAAcC,MAAM;gBAAYT,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YAClE,sFAAsF;YACtF,2FAA2F;YAC3F,4CAA4C;YAC5C;gBAAEH,MAAM;gBAAeC,MAAM;gBAAYT,OAAO;oBAAEW,UAAU;gBAAK;YAAE;YACnE,4FAA4F;YAC5F;gBAAEH,MAAM;gBAAgBC,MAAM;gBAAUT,OAAO;oBAAEW,UAAU;oBAAME,WAAW,CAACC,OAASC,QAAQD,MAAME;gBAAa;YAAE;SACpH;IACH;AACF,EAAC"}