fontdue-js 3.0.0-alpha13 → 3.0.0-alpha15

package/dist/next/tenant.js

@@ -20,13 +20,14 @@
 //
 // The fontdue-js components embedded in pages fetch the same way: their
 // server-side preloads read the per-render config set by
-// __prepareFontdueRender (or configureFontduePreview in single-tenant apps),
-// and in the browser they fetch the relative /graphql on the page's own
-// origin — so multi-tenant mode needs no NEXT_PUBLIC_FONTDUE_URL at all.
+// __prepareFontdueRender (multi-tenant) or, in single-tenant apps, the ambient
+// resolver that <FontdueProvider> registers — no per-render setup call — and in
+// the browser they fetch the relative /graphql on the page's own origin, so
+// multi-tenant mode needs no NEXT_PUBLIC_FONTDUE_URL at all.
 
 import { notFound, unstable_rethrow } from 'next/navigation';
 import { cookies, draftMode } from 'next/headers';
-import { setFontdueServerConfig, getFontdueSlotConfig } from '../relay/serverConfig.js';
+import { setFontdueServerConfig } from '../relay/serverConfig.js';
 import { PREVIEW_TOKEN_COOKIE, previewAuthHeaders } from '../preview/index.js';
 export const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
 export const singleTenantUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
@@ -90,8 +91,7 @@ export function fontdueServerConfig(domain) {
   return {
     url: origin,
     headers,
-    cacheTags: [`graphql:${domain}`],
-    domain
+    cacheTags: [`graphql:${domain}`]
   };
 }
 
@@ -134,32 +134,6 @@ async function applyRenderConfig(domain) {
   setFontdueServerConfig(await buildRenderConfig(domain));
 }
 
-// Single-tenant render setup — the one line at the top of every page, layout
-// and generateMetadata that fetches Fontdue data or renders Fontdue components:
-//
-//   await configureFontduePreview();
-//
-// It points this render's server-side fetches — your own (createFontdueFetch)
-// AND the embedded components' preloads (type testers, store, character viewer)
-// — at your Fontdue site (NEXT_PUBLIC_FONTDUE_URL), and when a logged-in admin
-// has entered preview it forwards their token and serves a live (uncached)
-// render so hidden (unpublished) fonts show up. Public renders stay cached and
-// tagged for /api/revalidate.
-//
-// Call it per entry point, not just the layout: a soft navigation re-renders
-// only the page segment with a fresh render store. Reading draft mode is
-// static-safe — it only forces dynamic rendering when an admin is actually
-// previewing, so static generation keeps working otherwise.
-//
-// Returns the endpoint, handy for e.g. a metadataBase fallback. Route handlers
-// (robots/sitemap) aren't React renders, so call fontdueEndpoint()
-// there instead.
-export async function configureFontduePreview() {
-  const domain = new URL(requireSingleTenantUrl()).host;
-  await applyRenderConfig(domain);
-  return endpointForDomain(domain);
-}
-
 // Internal multi-tenant API (double-underscored, not part of the public
 // foundry surface): the one line at the top of every page, layout and
 // generateMetadata body in the multi-tenant [domain] route tree (the
@@ -169,8 +143,9 @@ export async function configureFontduePreview() {
 //
 // Reads the request's site from the route param, 404s anything that isn't a
 // plain hostname, and configures the render (including preview) for that site.
-// Like configureFontduePreview, it runs per entry point. Route handlers are not
-// React renders — use the returned endpoint explicitly there.
+// It runs per entry point: a soft navigation re-renders only the page segment
+// with a fresh render store. Route handlers are not React renders — use the
+// returned endpoint explicitly there.
 export async function __prepareFontdueRender(props) {
   const {
     domain
@@ -217,23 +192,6 @@ async function readPreviewHeaders() {
   }
 }
 
-// Endpoint for the app's own GraphQL fetches in this render pass: whatever
-// __prepareFontdueRender configured, or — in a single-tenant app without the
-// [domain] tree, where __prepareFontdueRender is never called — the
-// NEXT_PUBLIC_FONTDUE_URL site. Throwing rather than guessing in
-// multi-tenant mode turns a forgotten __prepareFontdueRender into an
-// unmissable error instead of a silent wrong-site fetch on soft
-// navigations.
-export function fontdueEndpoint() {
-  var _getFontdueSlotConfig;
-  const domain = (_getFontdueSlotConfig = getFontdueSlotConfig()) === null || _getFontdueSlotConfig === void 0 ? void 0 : _getFontdueSlotConfig.domain;
-  if (domain) return endpointForDomain(domain);
-  if (isMultiTenant) {
-    throw new Error('fontdue-js/next: no render config set — call __prepareFontdueRender(props) at the top of every page, layout and generateMetadata that fetches.');
-  }
-  return endpointForDomain(new URL(requireSingleTenantUrl()).host);
-}
-
 // The single-tenant ambient resolver that lets a foundry skip per-render setup
 // is registered from ./registerSingleTenantResolver.ts (imported as a side
 // effect by the FontdueProvider react-server entrypoint), not here — so this

package/dist/relay/environment.js

@@ -7,7 +7,7 @@ import { PREVIEW_HEADER, hasPreviewMarkerCookie } from '../preview/constants.js'
 // (defineVersionPlugin in .babelrc.cjs) with the literal package.json#version.
 // Exported so UI (the admin toolbar) can surface it without re-reading the
 // build-time global in a 'use client' module.
-export const version = "3.0.0-alpha13";
+export const version = "3.0.0-alpha15";
 const IS_SERVER = typeof window === typeof undefined;
 
 // Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).

package/dist/relay/serverConfig.d.ts

@@ -5,17 +5,10 @@ export interface FontdueServerConfig {
     headers?: Record<string, string>;
     /** Extra Next.js fetch cache tags applied to every server-side GraphQL fetch. */
     cacheTags?: string[];
-    /**
-     * The site domain this render is for, when known. Set by
-     * fontdue-js/next's __prepareFontdueRender so render-scoped helpers
-     * (fontdueEndpoint) can recover it.
-     */
-    domain?: string;
 }
 type MaybePromise<T> = T | Promise<T>;
 type AmbientConfigResolver = () => MaybePromise<FontdueServerConfig | undefined>;
 export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
 export declare function registerAmbientConfigResolver(resolver: AmbientConfigResolver): void;
-export declare function getFontdueSlotConfig(): FontdueServerConfig | undefined;
 export declare function resolveFontdueServerConfig(): Promise<FontdueServerConfig | undefined>;
 export {};

package/dist/relay/serverConfig.js

@@ -99,18 +99,6 @@ function mergeServerConfig(ambient, slot) {
   };
 }
 
-// Slot-only read of the render-scoped config. It deliberately does NOT run the
-// ambient resolver: the single-tenant Next resolver is async (it awaits
-// draftMode()/cookies()), so a synchronous read could never reflect it without
-// silently dropping the preview token. Anything that needs the resolved
-// url/headers — every server-side fetch — must use resolveFontdueServerConfig()
-// instead. This exists only to recover the multi-tenant `domain` the slot
-// carries (set by __prepareFontdueRender), which fontdueEndpoint() reads from a
-// synchronous path.
-export function getFontdueSlotConfig() {
-  return store().getSlot().current;
-}
-
 // Asynchronous read used by the server-side fetch paths (the Relay network
 // layer and createFontdueFetch). Awaits the ambient resolver so a resolver that
 // reads request-scoped async APIs (Next's draftMode()/cookies()) can feed

package/dist/scripts/publishUnicodeData.js

@@ -0,0 +1,68 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = path.join(__dirname, '../data');
+
+// CDN buckets that serve the unicode-names asset. Both the npm package and the
+// script-tag bundle default to cdn.fontdue.com (prod), so prod is the only
+// strictly-required one — but the asset is reference data, not code, and we
+// push to all three so dev/staging (and any `cdnUrl` override used for testing)
+// resolve too. See docs/GCS.md.
+const BUCKETS = ['fontdue-dev', 'fontdue-staging', 'fontdue-prod'];
+const CACHE_CONTROL = 'public, max-age=31536000, immutable';
+
+// Read the content hash written into unicodeNamesVersion.ts. It's the single
+// source of truth for both the CDN filename and the runtime fetch URL, so the
+// uploaded object always matches what CharacterViewer requests.
+export function readUnicodeNamesVersion() {
+  const src = readFileSync(path.join(DATA_DIR, 'unicodeNamesVersion.ts'), 'utf-8');
+  const match = src.match(/UNICODE_NAMES_VERSION\s*=\s*['"]([^'"]+)['"]/);
+  if (!match) {
+    throw new Error('Could not read UNICODE_NAMES_VERSION from src/data/unicodeNamesVersion.ts');
+  }
+  return match[1];
+}
+
+// Upload data/unicodeNames.json to each CDN bucket at the immutable,
+// content-hashed path the runtime fetches. `-n` (no-clobber) makes this
+// idempotent: a re-run is a no-op unless the data — and therefore the hash —
+// changed. Requires gsutil on PATH and credentials with write access to the
+// buckets (`gcloud auth login`). Throws on failure so the caller can decide
+// whether that's fatal.
+export function publishUnicodeData() {
+  let {
+    buckets = BUCKETS
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const version = readUnicodeNamesVersion();
+  const source = path.join(DATA_DIR, 'unicodeNames.json');
+  const fileName = `unicode-names.${version}.json`;
+  for (const bucket of buckets) {
+    const dest = `gs://${bucket}/js/dist/${fileName}`;
+    console.log(`uploading ${fileName} → ${dest}`);
+    execFileSync('gsutil', ['-h', `Cache-Control:${CACHE_CONTROL}`, '-h', 'Content-Type:application/json', 'cp', '-n', '-a', 'public-read', source, dest], {
+      stdio: 'inherit'
+    });
+  }
+  console.log(`unicode names ${version} published to: ${buckets.join(', ')}`);
+}
+
+// A friendly hint for the two failure modes worth distinguishing: gsutil not
+// installed vs. installed-but-can't-write (usually missing auth).
+export function describePublishError(err) {
+  if (err && err.code === 'ENOENT') {
+    return 'gsutil not found on PATH. Install the Google Cloud SDK and authenticate:\n' + '  brew install --cask gcloud-cli   # then restart your shell\n' + '  gcloud auth login\n' + 'See docs/GCS.md.';
+  }
+  return 'Failed to upload to the CDN. Make sure you are authenticated with write\n' + 'access to the buckets:\n' + '  gcloud auth login\n' + 'See docs/GCS.md.';
+}
+
+// CLI entry point: `npm run publish-unicode-data`
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    publishUnicodeData();
+  } catch (err) {
+    console.error(describePublishError(err));
+    process.exit(1);
+  }
+}

package/dist/scripts/updateUnicodeData.js

@@ -1,6 +1,10 @@
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
+import https from 'node:https';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { publishUnicodeData, describePublishError } from './publishUnicodeData.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 // URL from which to fetch the Unicode data
 const UNICODE_DATA_URL = 'https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt';
@@ -31,15 +35,46 @@ function parseAndConvertData(data) {
   return result;
 }
 
-// Main function to fetch, parse, and write the Unicode data to a JSON file
+// Main function to fetch, parse, write, and publish the Unicode data.
+//
+// The map is NOT bundled into the package — it's ~1.2 MB of reference data used
+// only to label glyphs in CharacterViewer. Instead it ships as a static JSON
+// asset served from the Fontdue CDN, which CharacterViewer fetches at runtime.
+// The asset is reference data on its own (roughly yearly) release schedule, so
+// it isn't coupled to the npm publish or the app deploy: regenerating the data
+// here also publishes it to the CDN, and any code that later references the new
+// hash just works.
+//
+// We write two files:
+//   - data/unicodeNames.json        the raw map (uploaded to the CDN; excluded
+//                                   from the npm tarball via .npmignore `src/*`)
+//   - data/unicodeNamesVersion.ts   a content hash of that JSON
+//
+// The hash is the single source of truth for the immutable CDN filename AND the
+// runtime fetch URL, so the two always agree. Refresh = re-run this script.
 async function main() {
   try {
     const data = await fetchUnicodeData();
     const jsonData = parseAndConvertData(data);
-    fs.writeFileSync(path.join(__dirname, '../data/unicodeData.ts'), `const data: { [code: string]: string} = ${JSON.stringify(jsonData)}; export default data;`);
-    console.log('unicode data has been written to unicodeData.ts');
+    const json = JSON.stringify(jsonData);
+    const hash = crypto.createHash('sha256').update(json).digest('hex').slice(0, 16);
+    const dataDir = path.join(__dirname, '../data');
+    fs.writeFileSync(path.join(dataDir, 'unicodeNames.json'), json);
+    fs.writeFileSync(path.join(dataDir, 'unicodeNamesVersion.ts'), `// Generated by \`npm run update-unicode-data\`. Content hash of unicodeNames.json.\n` + `// Both the CDN asset filename and the runtime fetch URL derive from this, so\n` + `// they always agree. Do not edit by hand.\n` + `export const UNICODE_NAMES_VERSION = ${JSON.stringify(hash)};\n`);
+    console.log(`unicode data written: ${Object.keys(jsonData).length} entries, hash ${hash}`);
+
+    // Publish the freshly-written map to the CDN. If this fails (no gsutil /
+    // credentials), don't fail the regen — the data is valid and the hash is
+    // committed; just point the way to publishing it before the change ships.
+    try {
+      publishUnicodeData();
+    } catch (err) {
+      console.warn('\n⚠ Data regenerated, but the CDN upload was skipped or failed. The new\n' + '  hash is in unicodeNamesVersion.ts, but the asset must be on the CDN\n' + '  before any code referencing it ships. Once you have gsutil + creds:\n' + '    npm run publish-unicode-data\n');
+      console.warn(describePublishError(err));
+    }
   } catch (error) {
     console.error('Error:', error);
+    process.exit(1);
   }
 }
 

package/dist/server/index.js

@@ -15,9 +15,10 @@
 //   1. Ambient context (preferred): whatever set the per-render config.
 //      - Astro / React Router etc.: runWithPreview (fontdue-js/preview/server)
 //        rides the token through AsyncLocalStorage.
-//      - Next: configureFontduePreview / __prepareFontdueRender
-//        (fontdue-js/next) write the site URL, cache tags, and preview token
-//        into the render-scoped slot.
+//      - Next: the single-tenant ambient resolver (registered by mounting
+//        <FontdueProvider>, no per-render call) or __prepareFontdueRender
+//        (fontdue-js/next, multi-tenant) supply the site URL, cache tags, and
+//        preview token for the render.
 //      Either way:
 //
 //        const fetchGraphql = createFontdueFetch();           // once, at module scope

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdue-js",
-  "version": "3.0.0-alpha13",
+  "version": "3.0.0-alpha15",
   "type": "module",
   "scripts": {
     "build": "npm run relay && run-p build-js build-css build-ts",
@@ -9,6 +9,7 @@
     "build-css": "sass --load-path=node_modules --no-source-map src/index.scss dist/fontdue.css",
     "relay": "relay-compiler",
     "update-unicode-data": "node src/scripts/updateUnicodeData.js",
+    "publish-unicode-data": "node src/scripts/publishUnicodeData.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "prepublishOnly": "npm run build"