@driftime/sanity-plugin-font 0.0.0-stage → 0.1.1

package/dist/next-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-loader.js","names":["path","isDefined","writeFontCatalog","createCatalogModule","LoaderContext","resourcePath","generateCatalogModule","catalog","process","cwd","undefined","relative","dirname","file","replaceAll","startsWith","LoaderContext","generateCatalogModule","fontCatalogLoader","this","code","resourcePath"],"sources":["../src/build/loader.ts","../src/next-loader.ts"],"sourcesContent":["import path from \"node:path\";\n\nimport { isDefined } from \"@repo/lib/utils\";\n\nimport { writeFontCatalog } from \"@/build/catalog\";\nimport { createCatalogModule } from \"@/build/module\";\n\n/**\n * The parts of a webpack or Turbopack loader's context the build step uses.\n *\n * @public\n */\nexport interface LoaderContext {\n  /** Path of the module being loaded. */\n  resourcePath: string;\n}\n\n/**\n * Generates the module that replaces the placeholder catalog, importing the catalog from where the build step wrote it.\n *\n * @param resourcePath - Path of the placeholder being replaced.\n * @returns The module's code.\n */\nexport async function generateCatalogModule(resourcePath: string) {\n  const catalog = await writeFontCatalog(process.cwd());\n  if (!isDefined(catalog)) return createCatalogModule(undefined);\n\n  const relative = path.relative(path.dirname(resourcePath), catalog.file).replaceAll(\"\\\\\", \"/\");\n\n  return createCatalogModule(relative.startsWith(\".\") ? relative : `./${relative}`);\n}\n","import type { LoaderContext } from \"@/build/loader\";\nimport { generateCatalogModule } from \"@/build/loader\";\n\n/**\n * Webpack and Turbopack loader that replaces the placeholder catalog with the one the build step downloaded.\n *\n * @param this - The loader context.\n * @returns The catalog module's code.\n * @public\n */\nasync function fontCatalogLoader(this: LoaderContext) {\n  const code = await generateCatalogModule(this.resourcePath);\n\n  return code;\n}\n\nexport default fontCatalogLoader;\n"],"mappings":";;;;;;;;;AAuBA,eAAsBM,sBAAsBD,cAAsB;CAChE,IAAME,UAAU,MAAML,iBAAiBM,QAAQC,IAAI,CAAC;CACpD,IAAI,CAACR,UAAUM,OAAO,GAAG,OAAOJ,oBAAoBO,KAAAA,CAAS;CAE7D,IAAMC,WAAWX,KAAKW,SAASX,KAAKY,QAAQP,YAAY,GAAGE,QAAQM,IAAI,CAAC,CAACC,WAAW,MAAM,GAAG;CAE7F,OAAOX,oBAAoBQ,SAASI,WAAW,GAAG,IAAIJ,WAAW,KAAKA,UAAU;AAClF;;;;;;;;ACpBA,eAAeO,oBAAuC;CAGpD,OAAOE,MAFYH,sBAAsB,KAAKI,YAAY;AAG5D"}

package/dist/next.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The parts of a webpack configuration the build step extends.
+ *
+ * @public
+ */
+interface SanityFontWebpackConfig {
+  /** Module settings, whose rules the build step adds to. */
+  module?: {
+    rules?: unknown[];
+  };
+}
+/**
+ * The parts of a Next.js configuration the build step extends, so the package doesn't depend on Next.js's own types.
+ *
+ * @public
+ */
+interface SanityFontNextConfig {
+  /** Turbopack settings, whose rules the build step adds to. */
+  turbopack?: {
+    rules?: Record<string, unknown>;
+  };
+  /** Customises webpack, for projects that build with it instead of Turbopack. */
+  webpack?: SanityFontWebpackCustomizer | null;
+}
+/**
+ * Customises webpack, as Next.js's `webpack` option does. The context is typed `never` because the build step only
+ * passes Next.js's own context through, so any context type a project's function declares is accepted.
+ *
+ * @public
+ */
+type SanityFontWebpackCustomizer = (config: SanityFontWebpackConfig, context: never) => SanityFontWebpackConfig;
+/**
+ * Adds the font build step to a Next.js configuration, for Studios embedded in a Next.js app. It works with both
+ * Turbopack and webpack.
+ *
+ * @returns A function that extends the Next.js configuration into an async configuration function, which downloads the
+ *   catalog before Next.js starts building.
+ * @public
+ */
+export declare function withFonts(): <Config extends SanityFontNextConfig>(config: Config) => (phase: string) => Promise<Config>;
+export type { SanityFontNextConfig, SanityFontWebpackConfig, SanityFontWebpackCustomizer };
+//# sourceMappingURL=next.d.ts.map

package/dist/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","names":["SanityFontWebpackConfig","SanityFontNextConfig","Record","SanityFontWebpackCustomizer","withFonts","Config","Promise"],"sources":["../src/build/next.ts"],"mappings":"AAmBA;;;;;UAAiBA;;EAEf;IAAW;;;;;;;;UAQIC;;EAEf;IAAc,QAAQC;;;EAEtB,UAAUC;;;;;;;;KASAA,+BAA+B,QAAQH,yBAAyB,mBAAmBA;;;;;;;;;wBAa/EI,cAIe,eAAeH,sBAAoB,QAAUI,YAAM,kBAiBnDC,QAAAD"}

package/dist/next.js

@@ -0,0 +1,48 @@
+import { i as isCatalogModule, n as catalogModulePath, t as writeFontCatalog } from "./catalog-BVw1r_SG.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Path of the loader, published next to this file. */
+const loaderPath = fileURLToPath(new URL("next-loader.js", import.meta.url));
+/**
+* Adds the font build step to a Next.js configuration, for Studios embedded in a Next.js app. It works with both
+* Turbopack and webpack.
+*
+* @returns A function that extends the Next.js configuration into an async configuration function, which downloads the
+*   catalog before Next.js starts building.
+* @public
+*/
+function withFonts() {
+	let loader = { loader: loaderPath }, placeholder = path.basename(path.dirname(path.dirname(catalogModulePath)));
+	return function extendConfig(config) {
+		let { turbopack, webpack } = config, extendedConfig = {
+			...config,
+			turbopack: {
+				...turbopack,
+				rules: {
+					...turbopack?.rules,
+					[`**/${placeholder}/dist/catalog.js`]: {
+						loaders: [loader],
+						as: "*.js"
+					}
+				}
+			},
+			webpack(webpackConfig, context) {
+				let resolved = webpack?.(webpackConfig, context) ?? webpackConfig, rule = {
+					test: isCatalogModule,
+					use: [loader]
+				};
+				return {
+					...resolved,
+					module: {
+						...resolved.module,
+						rules: [...resolved.module?.rules ?? [], rule]
+					}
+				};
+			}
+		};
+		return async (phase) => ((phase === "phase-development-server" || phase === "phase-production-build") && await writeFontCatalog(process.cwd()), extendedConfig);
+	};
+}
+export { withFonts };
+
+//# sourceMappingURL=next.js.map

package/dist/next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.js","names":["path","fileURLToPath","writeFontCatalog","catalogModulePath","isCatalogModule","WebpackRule","test","resource","use","loader","SanityFontWebpackConfig","module","rules","SanityFontNextConfig","turbopack","Record","webpack","SanityFontWebpackCustomizer","config","context","loaderPath","URL","import","meta","url","withFonts","placeholder","basename","dirname","extendConfig","Config","extendedConfig","loaders","as","webpackConfig","resolved","rule","phase","process","cwd"],"sources":["../src/build/next.ts"],"sourcesContent":["import path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nimport { writeFontCatalog } from \"@/build/catalog\";\nimport { catalogModulePath, isCatalogModule } from \"@/build/module\";\n\n/** A webpack rule, limited to what the build step adds. */\ninterface WebpackRule {\n  /** Matches the placeholder catalog. */\n  test: (resource: string) => boolean;\n  /** The loader that replaces it. */\n  use: { loader: string }[];\n}\n\n/**\n * The parts of a webpack configuration the build step extends.\n *\n * @public\n */\nexport interface SanityFontWebpackConfig {\n  /** Module settings, whose rules the build step adds to. */\n  module?: { rules?: unknown[] };\n}\n\n/**\n * The parts of a Next.js configuration the build step extends, so the package doesn't depend on Next.js's own types.\n *\n * @public\n */\nexport interface SanityFontNextConfig {\n  /** Turbopack settings, whose rules the build step adds to. */\n  turbopack?: { rules?: Record<string, unknown> };\n  /** Customises webpack, for projects that build with it instead of Turbopack. */\n  webpack?: SanityFontWebpackCustomizer | null;\n}\n\n/**\n * Customises webpack, as Next.js's `webpack` option does. The context is typed `never` because the build step only\n * passes Next.js's own context through, so any context type a project's function declares is accepted.\n *\n * @public\n */\nexport type SanityFontWebpackCustomizer = (config: SanityFontWebpackConfig, context: never) => SanityFontWebpackConfig;\n\n/** Path of the loader, published next to this file. */\nconst loaderPath = fileURLToPath(new URL(\"next-loader.js\", import.meta.url));\n\n/**\n * Adds the font build step to a Next.js configuration, for Studios embedded in a Next.js app. It works with both\n * Turbopack and webpack.\n *\n * @returns A function that extends the Next.js configuration into an async configuration function, which downloads the\n *   catalog before Next.js starts building.\n * @public\n */\nexport function withFonts() {\n  const loader = { loader: loaderPath };\n  const placeholder = path.basename(path.dirname(path.dirname(catalogModulePath)));\n\n  return function extendConfig<Config extends SanityFontNextConfig>(config: Config) {\n    const { turbopack, webpack } = config;\n    const extendedConfig: Config = {\n      ...config,\n      turbopack: {\n        ...turbopack,\n        rules: { ...turbopack?.rules, [`**/${placeholder}/dist/catalog.js`]: { loaders: [loader], as: \"*.js\" } },\n      },\n      webpack(webpackConfig: SanityFontWebpackConfig, context: never) {\n        const resolved = webpack?.(webpackConfig, context) ?? webpackConfig;\n        const rule: WebpackRule = { test: isCatalogModule, use: [loader] };\n\n        return { ...resolved, module: { ...resolved.module, rules: [...(resolved.module?.rules ?? []), rule] } };\n      },\n    };\n\n    // Turbopack never finds a file that wasn't there when the build started, even with a cache from an earlier build.\n    return async (phase: string) => {\n      // `next start` also loads the configuration, where `node_modules` may be read-only and nothing is bundled.\n      if (phase === \"phase-development-server\" || phase === \"phase-production-build\") {\n        await writeFontCatalog(process.cwd());\n      }\n\n      return extendedConfig;\n    };\n  };\n}\n"],"mappings":";;;;AA6CA,MAAMoB,aAAanB,cAAc,IAAIoB,IAAI,kBAAkBC,YAAYE,GAAG,CAAC;;;;;;;;;AAU3E,SAAgBC,YAAY;CAC1B,IAAMhB,SAAS,EAAEA,QAAQW,WAAW,GAC9BM,cAAc1B,KAAK2B,SAAS3B,KAAK4B,QAAQ5B,KAAK4B,QAAQzB,iBAAiB,CAAC,CAAC;CAE/E,OAAO,SAAS0B,aAAkDX,QAAgB;EAChF,IAAM,EAAEJ,WAAWE,YAAYE,QACzBa,iBAAyB;GAC7B,GAAGb;GACHJ,WAAW;IACT,GAAGA;IACHF,OAAO;KAAE,GAAGE,WAAWF;MAAQ,MAAMc,YAAW,oBAAqB;MAAEM,SAAS,CAACvB,MAAM;MAAGwB,IAAI;KAAO;IAAE;GACzG;GACAjB,QAAQkB,eAAwCf,SAAgB;IAC9D,IAAMgB,WAAWnB,UAAUkB,eAAef,OAAO,KAAKe,eAChDE,OAAoB;KAAE9B,MAAMF;KAAiBI,KAAK,CAACC,MAAM;IAAE;IAEjE,OAAO;KAAE,GAAG0B;KAAUxB,QAAQ;MAAE,GAAGwB,SAASxB;MAAQC,OAAO,CAAC,GAAIuB,SAASxB,QAAQC,SAAS,CAAA,GAAKwB,IAAI;KAAE;IAAE;GACzG;EACF;EAGA,OAAO,OAAOC,YAERA,UAAU,8BAA8BA,UAAU,6BACpD,MAAMnC,iBAAiBoC,QAAQC,IAAI,CAAC,GAG/BR;CAEX;AACF"}

package/dist/render.d.ts

@@ -0,0 +1,12 @@
+import { a as resolveFont, i as SanityResolvedFont, n as SanityFontPreload, r as SanityResolveFontOptions, t as SanityFontPreconnect } from "./resolve-Bkp0dEmr.js";
+import { c as SanityFontStyle, i as SanityFontDisplay, l as SanityFontWeight, n as SanityFontAsset, o as SanityFontFile, r as SanityFontCategory, s as SanityFontSource, t as SanityFont } from "./types-DZl90ROd.js";
+import { FontStyles, SanityFontStylesProps } from "@driftime/sanity-plugin-font/font-styles";
+/**
+ * GROQ projection that expands an uploaded font's files, so their URLs arrive with the font. Spread it into the
+ * projection of a font field, such as `headingFont { ${fontFragment} }`.
+ *
+ * @public
+ */
+export declare const fontFragment: string;
+export { FontStyles, type SanityFont, type SanityFontAsset, type SanityFontCategory, type SanityFontDisplay, type SanityFontFile, type SanityFontPreconnect, type SanityFontPreload, type SanityFontSource, type SanityFontStyle, type SanityFontStylesProps, type SanityFontWeight, type SanityResolveFontOptions, type SanityResolvedFont, resolveFont };
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","names":[],"sources":["../src/groq/fragments.ts"],"mappings":";;;;;;;;;qBAQa"}

package/dist/render.js

@@ -0,0 +1,183 @@
+import { t as isDefined } from "./utils-BV38iODp.js";
+import { n as createStylesheetUrl, t as getFamilyName } from "./family-BAGnEjZg.js";
+import { a as fontStyles, n as fontDisplays, s as fontWeights, t as fontCategories } from "./types-DheP5tax.js";
+import { stegaClean } from "@sanity/client/stega";
+import { FontStyles } from "@driftime/sanity-plugin-font/font-styles";
+/** Font stack shown in place of each kind of typeface while it loads, or if it can't. */
+const fontFallbacks = {
+	"sans-serif": "ui-sans-serif, system-ui, sans-serif",
+	serif: "ui-serif, Georgia, serif",
+	display: "ui-sans-serif, system-ui, sans-serif",
+	handwriting: "cursive",
+	monospace: "ui-monospace, monospace"
+};
+/**
+* Hashes text into a short identifier that's the same every time for the same text, for naming generated classes.
+*
+* @param value - The text.
+* @returns The identifier, in letters and digits.
+*/
+function hashText(value) {
+	let hash = 5381;
+	for (let character of value) hash = (hash * 33 + (character.codePointAt(0) ?? 0)) % 4294967296;
+	return hash.toString(36);
+}
+/** Generic font families, which CSS reads as keywords and so are never quoted. */
+const genericFamilies = /* @__PURE__ */ new Set([
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui",
+	"ui-serif",
+	"ui-sans-serif",
+	"ui-monospace",
+	"ui-rounded",
+	"emoji",
+	"math",
+	"fangsong"
+]), variablePattern = /^--[A-Za-z_][\w-]*$/u, fileFormats = {
+	woff2: {
+		format: "woff2",
+		type: "font/woff2"
+	},
+	woff: {
+		format: "woff",
+		type: "font/woff"
+	}
+};
+/**
+* Quotes text as a CSS string, so a stored value can't end the string and add rules of its own, or end the `<style>`
+* element a site puts the rules in.
+*
+* @param value - The text.
+* @returns The quoted string.
+*/
+function quoteCss(value) {
+	return `"${value.replaceAll(/[\n\r\f]/gu, " ").replaceAll(/["\\]/gu, String.raw`\$&`).replaceAll("<", String.raw`\3c `)}"`;
+}
+/**
+* Narrows a stored value to one of a list's members.
+*
+* @param list - The members.
+* @param value - The stored value.
+* @returns The value, or undefined when it isn't a member.
+*/
+function readMember(list, value) {
+	return list.find((member) => member === value);
+}
+/**
+* Builds the `@font-face` rule and preload for one uploaded file.
+*
+* @param family - Name of the family, cleaned.
+* @param file - The file.
+* @param display - How the font is shown while it loads.
+* @returns The rule and preload, or undefined when the file's URL or format can't be read.
+*/
+function resolveFontFile(family, file, display) {
+	let url = stegaClean(file.asset?.url);
+	if (!isDefined(url) || !url.startsWith("https://")) return;
+	let extension = new URL(url).pathname.split(".").at(-1)?.toLowerCase(), format = isDefined(extension) ? fileFormats[extension] : void 0;
+	if (!isDefined(format)) return;
+	let weight = readMember(fontWeights, file.weight) ?? 400, maxWeight = readMember(fontWeights, file.maxWeight), style = readMember(fontStyles, stegaClean(file.style)) ?? "normal", weightRange = isDefined(maxWeight) && maxWeight > weight ? `${weight} ${maxWeight}` : `${weight}`;
+	return {
+		rule: [
+			"@font-face {",
+			`  font-family: ${quoteCss(family)};`,
+			`  font-style: ${style};`,
+			`  font-weight: ${weightRange};`,
+			`  font-display: ${display};`,
+			`  src: url(${quoteCss(url)}) format("${format.format}");`,
+			"}"
+		].join("\n"),
+		preload: {
+			href: url,
+			type: format.type
+		}
+	};
+}
+/**
+* Works out how a font is loaded: Google's stylesheet, or the `@font-face` rules and files of an upload.
+*
+* @param value - The stored font.
+* @param family - Name of the family, cleaned.
+* @param display - How the font is shown while it loads.
+* @returns How the font is loaded, or undefined when an uploaded font has no file that can be read.
+*/
+function resolveLoading(value, family, display) {
+	let { source, weights, styles, files } = value ?? {};
+	if (stegaClean(source) === "upload") {
+		let resolved = (files ?? []).flatMap((file) => {
+			let resolvedFile = resolveFontFile(family, file, display);
+			return isDefined(resolvedFile) ? [resolvedFile] : [];
+		});
+		return isDefined(resolved) ? {
+			fontFace: resolved.map(({ rule }) => rule).join("\n"),
+			preconnect: [...new Set(resolved.map(({ preload }) => new URL(preload.href).origin))].map((href) => ({
+				href,
+				crossOrigin: !0
+			})),
+			preload: resolved.map(({ preload }) => preload)
+		} : void 0;
+	}
+	let loadedWeights = (weights ?? []).flatMap((weight) => {
+		let member = readMember(fontWeights, weight);
+		return isDefined(member) ? [member] : [];
+	}), loadedStyles = (styles ?? []).flatMap((style) => {
+		let member = readMember(fontStyles, stegaClean(style));
+		return isDefined(member) ? [member] : [];
+	});
+	return {
+		stylesheet: createStylesheetUrl(family, loadedWeights, loadedStyles, display),
+		preconnect: [{
+			href: "https://fonts.googleapis.com",
+			crossOrigin: !1
+		}, {
+			href: "https://fonts.gstatic.com",
+			crossOrigin: !0
+		}],
+		preload: []
+	};
+}
+/**
+* Resolves a stored font into what a site needs to load and apply it, shaped like a `next/font` font: a class and an
+* inline style that set the font, and a class that defines a CSS variable, with the rules behind them. An uploaded
+* font's files are only read when the query expands their assets.
+*
+* @param value - The stored font.
+* @param options - How the font is loaded and shown, and the CSS variable to define.
+* @returns The font, or undefined when nothing usable was stored.
+* @public
+*/
+function resolveFont(value, options = {}) {
+	let family = getFamilyName(value);
+	if (!isDefined(family)) return;
+	let { display: requestedDisplay, preload: hinted = !0, fallback } = options, loading = resolveLoading(value, family, readMember(fontDisplays, requestedDisplay) ?? "swap");
+	if (!isDefined(loading)) return;
+	let category = readMember(fontCategories, stegaClean(value?.category)) ?? "sans-serif", stack = (fallback ?? []).map((name) => name.trim()).filter((name) => isDefined(name)), fallbackStack = isDefined(stack) ? stack.map((name) => genericFamilies.has(name) ? name : quoteCss(name)).join(", ") : fontFallbacks[category], fontFamily = `${quoteCss(family)}, ${fallbackStack}`, className = `font-${hashText(`${fontFamily} ${"stylesheet" in loading ? loading.stylesheet : loading.fontFace}`)}`, variableName = isDefined(options.variable) && variablePattern.test(options.variable) ? options.variable : void 0, variable = isDefined(variableName) ? `${className}-${variableName.slice(2)}` : void 0, css = [
+		loading.fontFace,
+		`.${className} { font-family: ${fontFamily}; }`,
+		isDefined(variable) && isDefined(variableName) ? `.${variable} { ${variableName}: ${fontFamily}; }` : void 0
+	].filter((rule) => isDefined(rule)).join("\n"), preconnect = hinted ? loading.preconnect : [], preload = hinted ? loading.preload : [];
+	return {
+		className,
+		style: { fontFamily },
+		...isDefined(variable) && { variable },
+		fontFamily,
+		..."stylesheet" in loading ? { stylesheet: loading.stylesheet } : { fontFace: loading.fontFace },
+		css,
+		preconnect,
+		preload
+	};
+}
+/**
+* GROQ projection that expands an uploaded font's files, so their URLs arrive with the font. Spread it into the
+* projection of a font field, such as `headingFont { ${fontFragment} }`.
+*
+* @public
+*/
+const fontFragment = "..., files[] { ..., asset-> { url } }";
+export { FontStyles, fontFragment, resolveFont };
+
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","names":["SanityFontCategory","fontFallbacks","Record","serif","display","handwriting","monospace","hashText","value","hash","character","codePointAt","toString","isDefined","stegaClean","fontFallbacks","getFamilyName","createStylesheetUrl","hashText","SanityFont","SanityFontCategory","SanityFontDisplay","SanityFontFile","SanityFontStyle","SanityFontWeight","fontCategories","fontDisplays","fontStyles","fontWeights","SanityResolveFontOptions","display","preload","fallback","variable","SanityFontPreconnect","href","crossOrigin","SanityFontPreload","type","SanityResolvedFont","className","style","fontFamily","stylesheet","fontFace","css","preconnect","genericFamilies","Set","variablePattern","fileFormats","Record","format","woff2","woff","quoteCss","value","escaped","replaceAll","String","raw","readMember","list","Member","find","member","resolveFontFile","family","file","url","asset","startsWith","undefined","extension","URL","pathname","split","at","toLowerCase","weight","maxWeight","weightRange","rule","join","resolveLoading","source","weights","styles","files","resolved","flatMap","resolvedFile","map","origin","loadedWeights","loadedStyles","resolveFont","options","requestedDisplay","hinted","loading","category","stack","name","trim","filter","fallbackStack","has","variableName","test","slice","SanityFont","SanityFontAsset","SanityFontFile","fontFragment"],"sources":["../src/config/fallbacks.ts","../src/lib/hash.ts","../src/lib/resolve.ts","../src/groq/fragments.ts"],"sourcesContent":["import type { SanityFontCategory } from \"@/types\";\n\n/** Font stack shown in place of each kind of typeface while it loads, or if it can't. */\nexport const fontFallbacks: Record<SanityFontCategory, string> = {\n  \"sans-serif\": \"ui-sans-serif, system-ui, sans-serif\",\n  serif: \"ui-serif, Georgia, serif\",\n  display: \"ui-sans-serif, system-ui, sans-serif\",\n  handwriting: \"cursive\",\n  monospace: \"ui-monospace, monospace\",\n};\n","/**\n * Hashes text into a short identifier that's the same every time for the same text, for naming generated classes.\n *\n * @param value - The text.\n * @returns The identifier, in letters and digits.\n */\nexport function hashText(value: string) {\n  let hash = 5381;\n\n  // A polynomial hash, kept to 32 bits so it stays exact in a JavaScript number.\n  for (const character of value) {\n    hash = (hash * 33 + (character.codePointAt(0) ?? 0)) % 4_294_967_296;\n  }\n\n  return hash.toString(36);\n}\n","import { isDefined } from \"@repo/lib/utils\";\nimport { stegaClean } from \"@sanity/client/stega\";\n\nimport { fontFallbacks } from \"@/config/fallbacks\";\nimport { getFamilyName } from \"@/lib/family\";\nimport { createStylesheetUrl } from \"@/lib/google\";\nimport { hashText } from \"@/lib/hash\";\nimport type {\n  SanityFont,\n  SanityFontCategory,\n  SanityFontDisplay,\n  SanityFontFile,\n  SanityFontStyle,\n  SanityFontWeight,\n} from \"@/types\";\nimport { fontCategories, fontDisplays, fontStyles, fontWeights } from \"@/types\";\n\n/**\n * Options for resolving a font.\n *\n * @public\n */\nexport interface SanityResolveFontOptions {\n  /** How the font is shown while it loads, as CSS's `font-display` names it. Defaults to `swap`. */\n  display?: SanityFontDisplay;\n  /** Whether the page hints that the font's files should start downloading early. Defaults to `true`. */\n  preload?: boolean;\n  /** Fonts shown in its place while it loads, or if it can't, such as `[\"Geist\", \"sans-serif\"]`. Defaults to a fallback for its kind of typeface. */\n  fallback?: string[];\n  /**\n   * CSS variable the `variable` class defines, such as `--font-heading`. A name that isn't a valid custom property is\n   * ignored, and without one there's no `variable` class.\n   */\n  variable?: string;\n}\n\n/**\n * An origin to connect to early, with whether the connection needs CORS to match the requests that follow.\n *\n * @public\n */\nexport interface SanityFontPreconnect {\n  /** The origin. */\n  href: string;\n  /** Whether the requests to it use CORS, as font files do. */\n  crossOrigin: boolean;\n}\n\n/**\n * An uploaded file to preload, with the attributes a preload link needs.\n *\n * @public\n */\nexport interface SanityFontPreload {\n  /** Address of the file. */\n  href: string;\n  /** MIME type of the file, such as `font/woff2`. */\n  type: string;\n}\n\n/**\n * A stored font, ready for a site to load and apply.\n *\n * @public\n */\nexport interface SanityResolvedFont {\n  /** Class that sets the font as an element's `font-family`. */\n  className: string;\n  /** Inline style that sets the font as an element's `font-family`. */\n  style: { fontFamily: string };\n  /** Class that defines the CSS variable named in the options, or undefined when none was named. */\n  variable?: string;\n  /** Value for `font-family`: the family, then a fallback for its kind of typeface. */\n  fontFamily: string;\n  /** Google Fonts stylesheet to link, or undefined for an uploaded font. */\n  stylesheet?: string;\n  /** `@font-face` rules for an uploaded font, or undefined for a Google font. */\n  fontFace?: string;\n  /** Every rule the classes and an uploaded font's files need, for a `<style>` element. */\n  css: string;\n  /** Origins to connect to early, so the font's files start downloading sooner. */\n  preconnect: SanityFontPreconnect[];\n  /** Uploaded files to preload, empty for a Google font. */\n  preload: SanityFontPreload[];\n}\n\n/** Generic font families, which CSS reads as keywords and so are never quoted. */\nconst genericFamilies = new Set([\n  \"serif\",\n  \"sans-serif\",\n  \"monospace\",\n  \"cursive\",\n  \"fantasy\",\n  \"system-ui\",\n  \"ui-serif\",\n  \"ui-sans-serif\",\n  \"ui-monospace\",\n  \"ui-rounded\",\n  \"emoji\",\n  \"math\",\n  \"fangsong\",\n]);\n\n/** A valid CSS custom property name, which is also safe to use in a class name. */\nconst variablePattern = /^--[A-Za-z_][\\w-]*$/u;\n\n/** Format and MIME type of each font file extension. */\nconst fileFormats: Record<string, { format: string; type: string }> = {\n  woff2: { format: \"woff2\", type: \"font/woff2\" },\n  woff: { format: \"woff\", type: \"font/woff\" },\n};\n\n/**\n * Quotes text as a CSS string, so a stored value can't end the string and add rules of its own, or end the `<style>`\n * element a site puts the rules in.\n *\n * @param value - The text.\n * @returns The quoted string.\n */\nfunction quoteCss(value: string) {\n  const escaped = value\n    .replaceAll(/[\\n\\r\\f]/gu, \" \")\n    .replaceAll(/[\"\\\\]/gu, String.raw`\\$&`)\n    .replaceAll(\"<\", String.raw`\\3c `);\n\n  return `\"${escaped}\"`;\n}\n\n/**\n * Narrows a stored value to one of a list's members.\n *\n * @param list - The members.\n * @param value - The stored value.\n * @returns The value, or undefined when it isn't a member.\n */\nfunction readMember<Member>(list: readonly Member[], value: unknown) {\n  return list.find((member) => member === value);\n}\n\n/**\n * Builds the `@font-face` rule and preload for one uploaded file.\n *\n * @param family - Name of the family, cleaned.\n * @param file - The file.\n * @param display - How the font is shown while it loads.\n * @returns The rule and preload, or undefined when the file's URL or format can't be read.\n */\nfunction resolveFontFile(family: string, file: SanityFontFile, display: SanityFontDisplay) {\n  const url = stegaClean(file.asset?.url);\n  if (!isDefined(url) || !url.startsWith(\"https://\")) return undefined;\n\n  const extension = new URL(url).pathname.split(\".\").at(-1)?.toLowerCase();\n  const format = isDefined(extension) ? fileFormats[extension] : undefined;\n  if (!isDefined(format)) return undefined;\n\n  const weight = readMember(fontWeights, file.weight) ?? 400;\n  const maxWeight = readMember(fontWeights, file.maxWeight);\n  const style = readMember(fontStyles, stegaClean(file.style)) ?? \"normal\";\n  const weightRange = isDefined(maxWeight) && maxWeight > weight ? `${weight} ${maxWeight}` : `${weight}`;\n\n  const rule = [\n    \"@font-face {\",\n    `  font-family: ${quoteCss(family)};`,\n    `  font-style: ${style};`,\n    `  font-weight: ${weightRange};`,\n    `  font-display: ${display};`,\n    `  src: url(${quoteCss(url)}) format(\"${format.format}\");`,\n    \"}\",\n  ].join(\"\\n\");\n\n  return { rule, preload: { href: url, type: format.type } };\n}\n\n/**\n * Works out how a font is loaded: Google's stylesheet, or the `@font-face` rules and files of an upload.\n *\n * @param value - The stored font.\n * @param family - Name of the family, cleaned.\n * @param display - How the font is shown while it loads.\n * @returns How the font is loaded, or undefined when an uploaded font has no file that can be read.\n */\nfunction resolveLoading(value: SanityFont | undefined, family: string, display: SanityFontDisplay) {\n  const { source, weights, styles, files } = value ?? {};\n\n  if (stegaClean(source) === \"upload\") {\n    const resolved = (files ?? []).flatMap((file) => {\n      const resolvedFile = resolveFontFile(family, file, display);\n\n      return isDefined(resolvedFile) ? [resolvedFile] : [];\n    });\n    if (!isDefined(resolved)) return undefined;\n\n    return {\n      fontFace: resolved.map(({ rule }) => rule).join(\"\\n\"),\n      preconnect: [...new Set(resolved.map(({ preload }) => new URL(preload.href).origin))].map((href) => ({\n        href,\n        crossOrigin: true,\n      })),\n      preload: resolved.map(({ preload }) => preload),\n    };\n  }\n\n  const loadedWeights = (weights ?? []).flatMap((weight) => {\n    const member: SanityFontWeight | undefined = readMember(fontWeights, weight);\n\n    return isDefined(member) ? [member] : [];\n  });\n  const loadedStyles = (styles ?? []).flatMap((style) => {\n    const member: SanityFontStyle | undefined = readMember(fontStyles, stegaClean(style));\n\n    return isDefined(member) ? [member] : [];\n  });\n\n  return {\n    stylesheet: createStylesheetUrl(family, loadedWeights, loadedStyles, display),\n    // The stylesheet is fetched without CORS and the font files with it, so each origin is connected to to match.\n    preconnect: [\n      { href: \"https://fonts.googleapis.com\", crossOrigin: false },\n      { href: \"https://fonts.gstatic.com\", crossOrigin: true },\n    ],\n    preload: [],\n  };\n}\n\n/**\n * Resolves a stored font into what a site needs to load and apply it, shaped like a `next/font` font: a class and an\n * inline style that set the font, and a class that defines a CSS variable, with the rules behind them. An uploaded\n * font's files are only read when the query expands their assets.\n *\n * @param value - The stored font.\n * @param options - How the font is loaded and shown, and the CSS variable to define.\n * @returns The font, or undefined when nothing usable was stored.\n * @public\n */\nexport function resolveFont(\n  value: SanityFont | undefined,\n  options: SanityResolveFontOptions = {},\n): SanityResolvedFont | undefined {\n  const family = getFamilyName(value);\n  if (!isDefined(family)) return undefined;\n\n  const { display: requestedDisplay, preload: hinted = true, fallback } = options;\n  const display = readMember(fontDisplays, requestedDisplay) ?? \"swap\";\n  const loading = resolveLoading(value, family, display);\n  if (!isDefined(loading)) return undefined;\n\n  const category: SanityFontCategory = readMember(fontCategories, stegaClean(value?.category)) ?? \"sans-serif\";\n  const stack = (fallback ?? []).map((name) => name.trim()).filter((name) => isDefined(name));\n  const fallbackStack = isDefined(stack)\n    ? stack.map((name) => (genericFamilies.has(name) ? name : quoteCss(name))).join(\", \")\n    : fontFallbacks[category];\n  const fontFamily = `${quoteCss(family)}, ${fallbackStack}`;\n  const className = `font-${hashText(`${fontFamily} ${\"stylesheet\" in loading ? loading.stylesheet : loading.fontFace}`)}`;\n  const variableName =\n    isDefined(options.variable) && variablePattern.test(options.variable) ? options.variable : undefined;\n  const variable = isDefined(variableName) ? `${className}-${variableName.slice(2)}` : undefined;\n\n  const css = [\n    loading.fontFace,\n    `.${className} { font-family: ${fontFamily}; }`,\n    isDefined(variable) && isDefined(variableName) ? `.${variable} { ${variableName}: ${fontFamily}; }` : undefined,\n  ]\n    .filter((rule) => isDefined(rule))\n    .join(\"\\n\");\n\n  const preconnect = hinted ? loading.preconnect : [];\n  const preload = hinted ? loading.preload : [];\n\n  return {\n    className,\n    style: { fontFamily },\n    ...(isDefined(variable) && { variable }),\n    fontFamily,\n    ...(\"stylesheet\" in loading ? { stylesheet: loading.stylesheet } : { fontFace: loading.fontFace }),\n    css,\n    preconnect,\n    preload,\n  };\n}\n","import type { SanityFont, SanityFontAsset, SanityFontFile } from \"@/types\";\n\n/**\n * GROQ projection that expands an uploaded font's files, so their URLs arrive with the font. Spread it into the\n * projection of a font field, such as `headingFont { ${fontFragment} }`.\n *\n * @public\n */\nexport const fontFragment = `..., ${\"files\" satisfies keyof SanityFont}[] { ..., ${\"asset\" satisfies keyof SanityFontFile}-> { ${\"url\" satisfies keyof SanityFontAsset} } }`;\n"],"mappings":"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"}

package/dist/resolve-Bkp0dEmr.d.ts

@@ -0,0 +1,81 @@
+import { i as SanityFontDisplay, t as SanityFont } from "./types-DZl90ROd.js";
+/**
+ * Options for resolving a font.
+ *
+ * @public
+ */
+interface SanityResolveFontOptions {
+  /** How the font is shown while it loads, as CSS's `font-display` names it. Defaults to `swap`. */
+  display?: SanityFontDisplay;
+  /** Whether the page hints that the font's files should start downloading early. Defaults to `true`. */
+  preload?: boolean;
+  /** Fonts shown in its place while it loads, or if it can't, such as `["Geist", "sans-serif"]`. Defaults to a fallback for its kind of typeface. */
+  fallback?: string[];
+  /**
+   * CSS variable the `variable` class defines, such as `--font-heading`. A name that isn't a valid custom property is
+   * ignored, and without one there's no `variable` class.
+   */
+  variable?: string;
+}
+/**
+ * An origin to connect to early, with whether the connection needs CORS to match the requests that follow.
+ *
+ * @public
+ */
+interface SanityFontPreconnect {
+  /** The origin. */
+  href: string;
+  /** Whether the requests to it use CORS, as font files do. */
+  crossOrigin: boolean;
+}
+/**
+ * An uploaded file to preload, with the attributes a preload link needs.
+ *
+ * @public
+ */
+interface SanityFontPreload {
+  /** Address of the file. */
+  href: string;
+  /** MIME type of the file, such as `font/woff2`. */
+  type: string;
+}
+/**
+ * A stored font, ready for a site to load and apply.
+ *
+ * @public
+ */
+interface SanityResolvedFont {
+  /** Class that sets the font as an element's `font-family`. */
+  className: string;
+  /** Inline style that sets the font as an element's `font-family`. */
+  style: {
+    fontFamily: string;
+  };
+  /** Class that defines the CSS variable named in the options, or undefined when none was named. */
+  variable?: string;
+  /** Value for `font-family`: the family, then a fallback for its kind of typeface. */
+  fontFamily: string;
+  /** Google Fonts stylesheet to link, or undefined for an uploaded font. */
+  stylesheet?: string;
+  /** `@font-face` rules for an uploaded font, or undefined for a Google font. */
+  fontFace?: string;
+  /** Every rule the classes and an uploaded font's files need, for a `<style>` element. */
+  css: string;
+  /** Origins to connect to early, so the font's files start downloading sooner. */
+  preconnect: SanityFontPreconnect[];
+  /** Uploaded files to preload, empty for a Google font. */
+  preload: SanityFontPreload[];
+}
+/**
+ * Resolves a stored font into what a site needs to load and apply it, shaped like a `next/font` font: a class and an
+ * inline style that set the font, and a class that defines a CSS variable, with the rules behind them. An uploaded
+ * font's files are only read when the query expands their assets.
+ *
+ * @param value - The stored font.
+ * @param options - How the font is loaded and shown, and the CSS variable to define.
+ * @returns The font, or undefined when nothing usable was stored.
+ * @public
+ */
+declare function resolveFont(value: SanityFont | undefined, options?: SanityResolveFontOptions): SanityResolvedFont | undefined;
+export { resolveFont as a, SanityResolvedFont as i, SanityFontPreload as n, SanityResolveFontOptions as r, SanityFontPreconnect as t };
+//# sourceMappingURL=resolve-Bkp0dEmr.d.ts.map

package/dist/resolve-Bkp0dEmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-Bkp0dEmr.d.ts","names":["SanityFont","SanityFontDisplay","SanityResolveFontOptions","SanityFontPreconnect","SanityFontPreload","SanityResolvedFont","resolveFont"],"sources":["../src/lib/resolve.ts"],"mappings":";;;;;;UAsBiBE;;EAEf,UAAUD;;EAEV;;EAEA;;;;;EAKA;;;;;;;UAQeE;;EAEf;;EAEA;;;;;;;UAQeC;;EAEf;;EAEA;;;;;;;UAQeC;;EAEf;;EAEA;IAAS;;;EAET;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,YAAYF;;EAEZ,SAASC;;;;;;;;;;;;iBAuJKE,YACd,OAAON,wBACP,UAASE,2BACRG"}

package/dist/types-DZl90ROd.d.ts

@@ -0,0 +1,106 @@
+import { SanityFontNames } from "@driftime/sanity-plugin-font/names";
+/** Schema type name of the font object. */
+declare const fontTypeName = "font";
+/** Schema type name of an uploaded font file. */
+declare const fontFileTypeName = "fontFile";
+/** Where a font comes from, in the order the picker offers them. */
+declare const fontSources: readonly ["google", "upload"];
+/**
+ * Where a font comes from: the Google Fonts catalog, or files uploaded to the dataset.
+ *
+ * @public
+ */
+type SanityFontSource = (typeof fontSources)[number];
+/** Accepts any string without losing a union's autocomplete suggestions. */
+type AnyString = string & NonNullable<unknown>;
+/**
+ * Name of a Google Fonts family, checked against the catalog once the build step has downloaded it, or any name before
+ * then.
+ *
+ * @public
+ */
+type SanityFontFamily = [SanityFontNames] extends [never] ? AnyString : SanityFontNames;
+/** Kinds of typeface, in the order the picker lists them. */
+declare const fontCategories: readonly ["sans-serif", "serif", "display", "handwriting", "monospace"];
+/**
+ * Kind of typeface, which decides the fallback shown while the font loads.
+ *
+ * @public
+ */
+type SanityFontCategory = (typeof fontCategories)[number];
+/** How a font is shown while it loads, as CSS's `font-display` names them. */
+declare const fontDisplays: readonly ["auto", "block", "swap", "fallback", "optional"];
+/**
+ * How a font is shown while it loads, as CSS's `font-display` names them.
+ *
+ * @public
+ */
+type SanityFontDisplay = (typeof fontDisplays)[number];
+/** Weights a font can be loaded in, from thinnest to heaviest. */
+declare const fontWeights: readonly [100, 200, 300, 400, 500, 600, 700, 800, 900];
+/**
+ * Weight a font can be loaded in.
+ *
+ * @public
+ */
+type SanityFontWeight = (typeof fontWeights)[number];
+/** Styles a font can be loaded in. */
+declare const fontStyles: readonly ["normal", "italic"];
+/**
+ * Style a font can be loaded in.
+ *
+ * @public
+ */
+type SanityFontStyle = (typeof fontStyles)[number];
+/**
+ * File asset an uploaded font file points to. A query expands it to read the URL.
+ *
+ * @public
+ */
+interface SanityFontAsset {
+  /** ID of the asset, until the query expands it. */
+  _ref?: string;
+  /** Address the file is served from, once the query expands the asset. */
+  url?: string;
+}
+/**
+ * One uploaded font file, with the weight and style it holds.
+ *
+ * @public
+ */
+interface SanityFontFile {
+  _type: typeof fontFileTypeName;
+  _key: string;
+  /** The file asset. */
+  asset?: SanityFontAsset;
+  /** Name of the family the file belongs to, read from the file. */
+  family?: string;
+  /** Weight the file holds, or the lightest a variable font file covers. */
+  weight?: SanityFontWeight;
+  /** Heaviest weight a variable font file covers, or undefined for a file with one weight. */
+  maxWeight?: SanityFontWeight;
+  /** Style the file holds. */
+  style?: SanityFontStyle;
+}
+/**
+ * Stored font: a Google Fonts family with the weights and styles to load, or a family uploaded as files.
+ *
+ * @public
+ */
+interface SanityFont {
+  _type: typeof fontTypeName;
+  /** Where the font comes from. */
+  source?: SanityFontSource;
+  /** Name of the font family. */
+  family?: string;
+  /** Kind of typeface. */
+  category?: SanityFontCategory;
+  /** Weights to load from Google Fonts, saved when the family is chosen. */
+  weights?: SanityFontWeight[];
+  /** Styles to load from Google Fonts, saved when the family is chosen. */
+  styles?: SanityFontStyle[];
+  /** Uploaded files, one for each weight and style. */
+  files?: SanityFontFile[];
+}
+export { SanityFontFamily as a, SanityFontStyle as c, SanityFontDisplay as i, SanityFontWeight as l, SanityFontAsset as n, SanityFontFile as o, SanityFontCategory as r, SanityFontSource as s, SanityFont as t, fontTypeName as u };
+//# sourceMappingURL=types-DZl90ROd.d.ts.map

package/dist/types-DZl90ROd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DZl90ROd.d.ts","names":["SanityFontNames","fontTypeName","fontFileTypeName","fontSources","SanityFontSource","AnyString","NonNullable","SanityFontFamily","fontCategories","SanityFontCategory","fontDisplays","SanityFontDisplay","fontWeights","SanityFontWeight","fontStyles","SanityFontStyle","SanityFontAsset","SanityFontFile","SanityFont"],"sources":["../src/types.ts"],"mappings":";;cAGaC;;cAGAC;;cAGAC;;;;;;KAODC,2BAA2BD;;KAGlCE,qBAAqBC;;;;;;;KAQdC,oBAAoBP,mCAAmCK,YAAYL;;cAGlEQ;;;;;;KAODC,6BAA6BD;;cAG5BE;;;;;;KAODC,4BAA4BD;;cAG3BE;;;;;;KAODC,2BAA2BD;;cAG1BE;;;;;;KAODC,0BAA0BD;;;;;;UAOrBE;;EAEf;;EAEA;;;;;;;UAQeC;EACf,cAAcf;EACd;;EAEA,QAAQc;;EAER;;EAEA,SAASH;;EAET,YAAYA;;EAEZ,QAAQE;;;;;;;UAQOG;EACf,cAAcjB;;EAEd,SAASG;;EAET;;EAEA,WAAWK;;EAEX,UAAUI;;EAEV,SAASE;;EAET,QAAQE"}

package/dist/types-DheP5tax.js

@@ -0,0 +1,27 @@
+/** Schema type name of the font object. */
+const fontTypeName = "font", fontFileTypeName = "fontFile", fontSources = ["google", "upload"], fontCategories = [
+	"sans-serif",
+	"serif",
+	"display",
+	"handwriting",
+	"monospace"
+], fontDisplays = [
+	"auto",
+	"block",
+	"swap",
+	"fallback",
+	"optional"
+], fontWeights = [
+	100,
+	200,
+	300,
+	400,
+	500,
+	600,
+	700,
+	800,
+	900
+], fontStyles = ["normal", "italic"];
+export { fontStyles as a, fontSources as i, fontDisplays as n, fontTypeName as o, fontFileTypeName as r, fontWeights as s, fontCategories as t };
+
+//# sourceMappingURL=types-DheP5tax.js.map

package/dist/types-DheP5tax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DheP5tax.js","names":["SanityFontNames","fontTypeName","fontFileTypeName","fontSources","const","SanityFontSource","AnyString","NonNullable","SanityFontFamily","fontCategories","SanityFontCategory","fontDisplays","SanityFontDisplay","fontWeights","SanityFontWeight","fontStyles","SanityFontStyle","SanityFontAsset","_ref","url","SanityFontFile","_type","_key","asset","family","weight","maxWeight","style","SanityFont","source","category","weights","styles","files"],"sources":["../src/types.ts"],"sourcesContent":["import type { SanityFontNames } from \"@driftime/sanity-plugin-font/names\";\n\n/** Schema type name of the font object. */\nexport const fontTypeName = \"font\";\n\n/** Schema type name of an uploaded font file. */\nexport const fontFileTypeName = \"fontFile\";\n\n/** Where a font comes from, in the order the picker offers them. */\nexport const fontSources = [\"google\", \"upload\"] as const;\n\n/**\n * Where a font comes from: the Google Fonts catalog, or files uploaded to the dataset.\n *\n * @public\n */\nexport type SanityFontSource = (typeof fontSources)[number];\n\n/** Accepts any string without losing a union's autocomplete suggestions. */\ntype AnyString = string & NonNullable<unknown>;\n\n/**\n * Name of a Google Fonts family, checked against the catalog once the build step has downloaded it, or any name before\n * then.\n *\n * @public\n */\nexport type SanityFontFamily = [SanityFontNames] extends [never] ? AnyString : SanityFontNames;\n\n/** Kinds of typeface, in the order the picker lists them. */\nexport const fontCategories = [\"sans-serif\", \"serif\", \"display\", \"handwriting\", \"monospace\"] as const;\n\n/**\n * Kind of typeface, which decides the fallback shown while the font loads.\n *\n * @public\n */\nexport type SanityFontCategory = (typeof fontCategories)[number];\n\n/** How a font is shown while it loads, as CSS's `font-display` names them. */\nexport const fontDisplays = [\"auto\", \"block\", \"swap\", \"fallback\", \"optional\"] as const;\n\n/**\n * How a font is shown while it loads, as CSS's `font-display` names them.\n *\n * @public\n */\nexport type SanityFontDisplay = (typeof fontDisplays)[number];\n\n/** Weights a font can be loaded in, from thinnest to heaviest. */\nexport const fontWeights = [100, 200, 300, 400, 500, 600, 700, 800, 900] as const;\n\n/**\n * Weight a font can be loaded in.\n *\n * @public\n */\nexport type SanityFontWeight = (typeof fontWeights)[number];\n\n/** Styles a font can be loaded in. */\nexport const fontStyles = [\"normal\", \"italic\"] as const;\n\n/**\n * Style a font can be loaded in.\n *\n * @public\n */\nexport type SanityFontStyle = (typeof fontStyles)[number];\n\n/**\n * File asset an uploaded font file points to. A query expands it to read the URL.\n *\n * @public\n */\nexport interface SanityFontAsset {\n  /** ID of the asset, until the query expands it. */\n  _ref?: string;\n  /** Address the file is served from, once the query expands the asset. */\n  url?: string;\n}\n\n/**\n * One uploaded font file, with the weight and style it holds.\n *\n * @public\n */\nexport interface SanityFontFile {\n  _type: typeof fontFileTypeName;\n  _key: string;\n  /** The file asset. */\n  asset?: SanityFontAsset;\n  /** Name of the family the file belongs to, read from the file. */\n  family?: string;\n  /** Weight the file holds, or the lightest a variable font file covers. */\n  weight?: SanityFontWeight;\n  /** Heaviest weight a variable font file covers, or undefined for a file with one weight. */\n  maxWeight?: SanityFontWeight;\n  /** Style the file holds. */\n  style?: SanityFontStyle;\n}\n\n/**\n * Stored font: a Google Fonts family with the weights and styles to load, or a family uploaded as files.\n *\n * @public\n */\nexport interface SanityFont {\n  _type: typeof fontTypeName;\n  /** Where the font comes from. */\n  source?: SanityFontSource;\n  /** Name of the font family. */\n  family?: string;\n  /** Kind of typeface. */\n  category?: SanityFontCategory;\n  /** Weights to load from Google Fonts, saved when the family is chosen. */\n  weights?: SanityFontWeight[];\n  /** Styles to load from Google Fonts, saved when the family is chosen. */\n  styles?: SanityFontStyle[];\n  /** Uploaded files, one for each weight and style. */\n  files?: SanityFontFile[];\n}\n"],"mappings":";AAGA,MAAaC,eAAe,QAGfC,mBAAmB,YAGnBC,cAAc,CAAC,UAAU,QAAQ,GAqBjCM,iBAAiB;CAAC;CAAc;CAAS;CAAW;CAAe;AAAW,GAU9EE,eAAe;CAAC;CAAQ;CAAS;CAAQ;CAAY;AAAU,GAU/DE,cAAc;CAAC;CAAK;CAAK;CAAK;CAAK;CAAK;CAAK;CAAK;CAAK;AAAG,GAU1DE,aAAa,CAAC,UAAU,QAAQ"}

package/dist/utils-BV38iODp.js

@@ -0,0 +1,29 @@
+/**
+* Checks whether a value is present. `false`, blank strings, and empty plain objects count as absent,
+* as does an array with no present elements.
+*
+* @param value - The value to check.
+* @returns True if the value is present.
+*/
+function isDefined(value) {
+	if (value == null || value === !1) return !1;
+	if (typeof value == "string") return value.trim() !== "";
+	if (Array.isArray(value)) return value.some((element) => isDefined(element));
+	if (typeof value == "object") {
+		let prototype = Reflect.getPrototypeOf(value);
+		return prototype !== Object.prototype && prototype !== null || Object.keys(value).length > 0;
+	}
+	return !0;
+}
+/**
+* Checks whether a value is an object whose keys can be read.
+*
+* @param value - The value to check.
+* @returns True if the value is an object.
+*/
+function isRecord(value) {
+	return typeof value == "object" && !!value;
+}
+export { isRecord as n, isDefined as t };
+
+//# sourceMappingURL=utils-BV38iODp.js.map

package/dist/utils-BV38iODp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-BV38iODp.js","names":["Nullable","T","isDefined","value","undefined","trim","Array","isArray","some","element","prototype","Reflect","getPrototypeOf","Object","keys","length","convertCase","format","words","replaceAll","toLowerCase","_match","character","toUpperCase","isRecord","Record","readPath","path","current","segment"],"sources":["../../@repo/lib/utils.ts"],"sourcesContent":["/** A value that may be null or undefined. */\ntype Nullable<T> = T | null | undefined;\n\n/**\n * Checks whether a value is present. `false`, blank strings, and empty plain objects count as absent,\n * as does an array with no present elements.\n *\n * @param value - The value to check.\n * @returns True if the value is present.\n */\nexport function isDefined<T>(value: Nullable<T> | false): value is T {\n  if (value === undefined || value === null || value === false) return false;\n  if (typeof value === \"string\") return value.trim() !== \"\";\n  if (Array.isArray(value)) return value.some((element) => isDefined(element));\n\n  if (typeof value === \"object\") {\n    const prototype = Reflect.getPrototypeOf(value);\n    if (prototype !== Object.prototype && prototype !== null) return true;\n\n    return Object.keys(value).length > 0;\n  }\n\n  return true;\n}\n\n/**\n * Converts a string to another case.\n *\n * @param value - The string to convert.\n * @param format - The case to convert to.\n * @returns The converted string.\n */\nexport function convertCase(value: string, format: \"kebab\" | \"snake\" | \"camel\" | \"pascal\" | \"title\" | \"sentence\") {\n  const words = value\n    .replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, \"$<lower> $<upper>\")\n    .replaceAll(/[-_\\s]+/gu, \" \")\n    .trim()\n    .toLowerCase();\n\n  switch (format) {\n    case \"kebab\": {\n      return words.replaceAll(/\\s+/gu, \"-\");\n    }\n    case \"snake\": {\n      return words.replaceAll(/\\s+/gu, \"_\");\n    }\n    case \"camel\": {\n      return words.replaceAll(/\\s+(?<character>.)/gu, (_match, character: string) => character.toUpperCase());\n    }\n    case \"pascal\": {\n      return words.replaceAll(/(?:^|\\s+)(?<character>.)/gu, (_match, character: string) => character.toUpperCase());\n    }\n    case \"title\": {\n      return words.replaceAll(/\\b\\w/gu, (character) => character.toUpperCase());\n    }\n    case \"sentence\": {\n      return words.replaceAll(/^(?<character>.)/gu, (character) => character.toUpperCase());\n    }\n    default: {\n      return value;\n    }\n  }\n}\n\n/**\n * Checks whether a value is an object whose keys can be read.\n *\n * @param value - The value to check.\n * @returns True if the value is an object.\n */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null;\n}\n\n/**\n * Reads a nested value by following a path of keys.\n *\n * @param value - The object to read from.\n * @param path - The keys to follow.\n * @returns The value, or undefined when the path doesn't exist.\n */\nexport function readPath(value: unknown, path: string[]) {\n  let current: unknown = value;\n\n  for (const segment of path) {\n    if (!isRecord(current)) return undefined;\n\n    current = current[segment];\n  }\n\n  return current;\n}\n"],"mappings":";;;;;;;AAUA,SAAgBE,UAAaC,OAAwC;CACnE,IAAIA,SAAiC,QAAQA,UAAU,IAAO,OAAO;CACrE,IAAI,OAAOA,SAAU,UAAU,OAAOA,MAAME,KAAK,MAAM;CACvD,IAAIC,MAAMC,QAAQJ,KAAK,GAAG,OAAOA,MAAMK,MAAMC,YAAYP,UAAUO,OAAO,CAAC;CAE3E,IAAI,OAAON,SAAU,UAAU;EAC7B,IAAMO,YAAYC,QAAQC,eAAeT,KAAK;EAG9C,OAFIO,cAAcG,OAAOH,aAAaA,cAAc,QAE7CG,OAAOC,KAAKX,KAAK,CAAC,CAACY,SAAS;CACrC;CAEA,OAAO;AACT;;;;;;;AA+CA,SAAgBS,SAASrB,OAAkD;CACzE,OAAO,OAAOA,SAAU,cAAYA;AACtC"}