react-cheminfo 0.10.0 → 0.12.0

package/src/seo/core/routes.ts

@@ -8,12 +8,15 @@
  * the table is a page a search engine only ever sees as the home page.
  */
 
+import {
+  safeDecode,
+  trimTrailingSlash,
+  withoutQueryOrFragment,
+} from '../../router/core/address.ts';
 import { stripBasePath } from '../../router/core/basePath.ts';
 
 const QUERY_OR_FRAGMENT = /[?#]/;
 
-const TRAILING_SLASHES = /\/+$/;
-
 // A scheme and an authority: what `location.href` hands out, and the one shape
 // that cannot be confused with a path. `//host/path` is left as a path, because
 // a route table is free to name one.
@@ -54,7 +57,8 @@ export interface RouteMeta {
  *
  * An address a route claims exactly always wins over one that claims it as a
  * subtree, and between two subtrees the longer claim wins, so `/molecules/HEM`
- * is a molecule rather than whatever `/` answers.
+ * is a molecule rather than whatever `/` answers. Segments are compared
+ * decoded, so `/exercises/caf%C3%A9` is the route written `/exercises/café`.
  * @param routes - Every address the site answers.
  * @param path - Absolute path, without a query string.
  * @returns Its entry, or `undefined` when the site does not know the address.
@@ -136,14 +140,13 @@ export function homeRoute(routes: readonly RouteMeta[]): RouteMeta {
  *
  * An address written twice ships two sitemap entries and two links to a page
  * only the first entry describes, and one carrying a `..` segment writes its
- * file outside the build output — a real build asked for `/../escaped` and got
- * a sibling of `dist`. Two addresses that differ only in an empty segment or in
- * case are the same defect wearing a disguise: `//x` and `/x` both write
- * `dist/x/index.html`, and so do `/About` and `/about` on the case-insensitive
- * filesystem macOS and Windows ship by default — one file, two sitemap entries,
- * and only one of the two descriptions survives. All of it is author
- * configuration read at build time, so it is refused where it is written rather
- * than repaired where it lands.
+ * file outside the build output. Two addresses that differ only in an empty
+ * segment or in case are the same defect wearing a disguise: `//x` and `/x`
+ * both write `dist/x/index.html`, and so do `/About` and `/about` on the
+ * case-insensitive filesystem macOS and Windows ship by default — one file, two
+ * sitemap entries, and only one of the two descriptions survives. All of it is
+ * author configuration read at build time, so it is refused where it is written
+ * rather than repaired where it lands.
  * @param routes - Every address the site answers.
  * @throws {Error} When the table is empty, names one address twice — under any
  * of those spellings — or carries a path that is not one.
@@ -174,18 +177,6 @@ export function assertRoutes(routes: readonly RouteMeta[]): void {
   }
 }
 
-/**
- * Drop the trailing slashes, so `/about/` and `/about` are one page and an
- * origin written `https://host/surge//` composes one address rather than one
- * with an empty segment in it.
- * @param value - A path or an origin.
- * @returns It, without the trailing slashes `/` itself keeps.
- */
-export function trimTrailingSlash(value: string): string {
-  const trimmed = value.replace(TRAILING_SLASHES, '');
-  return trimmed === '' && value !== '' ? '/' : trimmed;
-}
-
 function assertPath(path: string, written: string): void {
   if (!path.startsWith('/')) {
     throw new Error(`a route path starts at the site root: ${written}`);
@@ -204,17 +195,31 @@ function assertPath(path: string, written: string): void {
 // path already, with the query string and the fragment cut off either way.
 function pathOf(url: string): string {
   if (ABSOLUTE_URL.test(url) && URL.canParse(url)) return new URL(url).pathname;
-  const cut = url.search(QUERY_OR_FRAGMENT);
-  return cut === -1 ? url : url.slice(0, cut);
+  return withoutQueryOrFragment(url);
+}
+
+// The one shape two paths are compared in: no trailing slash, and each segment
+// decoded, so a browser's `caf%C3%A9` names the table's `café`. A segment whose
+// escapes decode to a `/` stays escaped: `/a%2Fb` is one segment, not `/a/b`.
+function comparable(path: string): string {
+  const trimmed = trimTrailingSlash(path) || '/';
+  if (!trimmed.includes('%')) return trimmed;
+  const segments = trimmed.split('/');
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index] ?? '';
+    const decoded = safeDecode(segment);
+    segments[index] = decoded.includes('/') ? segment : decoded;
+  }
+  return segments.join('/');
 }
 
 function exactRoute(
   routes: readonly RouteMeta[],
   path: string,
 ): RouteMeta | undefined {
-  const wanted = trimTrailingSlash(path) || '/';
+  const wanted = comparable(path);
   for (const route of routes) {
-    if ((trimTrailingSlash(route.path) || '/') === wanted) return route;
+    if (comparable(route.path) === wanted) return route;
   }
   return undefined;
 }
@@ -223,13 +228,13 @@ function prefixRoute(
   routes: readonly RouteMeta[],
   path: string,
 ): RouteMeta | undefined {
-  const wanted = trimTrailingSlash(path) || '/';
+  const wanted = comparable(path);
   let claimed: RouteMeta | undefined;
   let claimedLength = -1;
 
   for (const route of routes) {
     if (route.prefix !== true) continue;
-    const routePath = trimTrailingSlash(route.path) || '/';
+    const routePath = comparable(route.path);
     if (!isUnder(routePath, wanted)) continue;
     if (routePath.length > claimedLength) {
       claimed = route;

package/src/seo/core/siteFiles.ts

@@ -11,11 +11,11 @@
 
 import { siteById } from '../../ecosystem/core/lookup.ts';
 import type { EcosystemSite, SiteId } from '../../ecosystem/core/sites.ts';
+import { trimTrailingSlash } from '../../router/core/address.ts';
 import { basePathOf } from '../../router/core/basePath.ts';
 import { escapeText } from '../../share/core/escape.ts';
 
 import type { RouteMeta } from './routes.ts';
-import { trimTrailingSlash } from './routes.ts';
 
 // A crawler fetches what it is given over HTTP, so an origin is written in one
 // of the two schemes it speaks. Parsing alone does not say that: `localhost:3000`

package/src/seo/core/startDocumentMeta.ts

@@ -3,10 +3,9 @@
  *
  * The server, or the build that wrote one file per address, already titled the
  * page it handed out; this is what a move inside the app changes, and what a
- * crawler that renders the page reads afterwards. Every site did the same three
- * things around it — read the address it is on, look it up in its route table,
- * write the head — so all three live here, and a site says only where its
- * address is read and how a change to it is noticed.
+ * crawler that renders the page reads afterwards. Reading the address, looking
+ * it up in the route table and writing the head happen together here, so a site
+ * says only where its address is read and how a change to it is noticed.
  */
 
 import { writeDocumentMeta } from './documentMeta.ts';

package/src/seo/core/trackingScript.ts

@@ -0,0 +1,25 @@
+/**
+ * Put the audience-measurement snippet at the end of a page's `<head>`.
+ *
+ * The snippet is operator input, read from `TRACKING_SCRIPT` by the server or
+ * the container entrypoint, and taken verbatim: nothing in it is expanded. An
+ * unset or blank snippet leaves the page untouched, so a deployment measuring
+ * nothing serves exactly the page that was built. A page already carrying the
+ * snippet is returned as it is, so the call is safe to repeat.
+ * @param html - The page.
+ * @param snippet - The analytics snippet.
+ * @returns The page, carrying the snippet once: before its first `</head>`, or
+ * at its end when it has none.
+ */
+export function injectTrackingScript(
+  html: string,
+  snippet?: string | null,
+): string {
+  const script = snippet?.trim() ?? '';
+  if (script === '' || html.includes(script)) return html;
+  const head = html.search(HEAD_END);
+  if (head === -1) return `${html}\n${script}\n`;
+  return `${html.slice(0, head)}${script}\n${html.slice(head)}`;
+}
+
+const HEAD_END = /<\/head>/i;

package/src/seo/vite/ogCard.ts

@@ -11,9 +11,11 @@
  * a site must be able to import with none of the optional peers installed.
  */
 
-import { siteById } from '../../ecosystem/core/lookup.ts';
+import { siteNameColors } from '../../ecosystem/core/nameColors.ts';
 import type { EcosystemSite, SiteId } from '../../ecosystem/core/sites.ts';
 import { escapeText } from '../../share/core/escape.ts';
+import { FAMILY_TOKEN_VALUES } from '../../tokens/core/familyTokens.ts';
+import { resolveSite } from '../core/siteFiles.ts';
 
 /** The width every card is drawn at. */
 export const OG_WIDTH = 1200;
@@ -46,8 +48,8 @@ export interface OgCardOptions {
  * @returns A complete HTML document.
  */
 export async function ogCardHtml(options: OgCardOptions): Promise<string> {
-  const site =
-    typeof options.site === 'string' ? siteById(options.site) : options.site;
+  const site = resolveSite(options.site);
+  const colors = siteNameColors(site, { colors: 'literal' });
   const description = options.description ?? site.tagline;
   const [{ createElement }, { renderToStaticMarkup }, { SiteMark }] =
     await Promise.all([
@@ -73,17 +75,17 @@ export async function ogCardHtml(options: OgCardOptions): Promise<string> {
         flex-direction: column;
         justify-content: center;
         padding: 88px;
-        background: #ffffff;
-        color: #16202c;
+        background: ${FAMILY_TOKEN_VALUES['--surface']};
+        color: ${FAMILY_TOKEN_VALUES['--text']};
         font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
           Helvetica, Arial, sans-serif;
         gap: 28px;
       }
       h1 { font-size: 76px; font-weight: 700; letter-spacing: -0.02em; }
-      .lead { color: ${site.brand}; }
-      .alt { color: ${site.brandAlt}; }
-      .dot { color: #8a96a3; }
-      p { max-width: 900px; color: #5b6875; font-size: 34px; line-height: 1.35; }
+      .lead { color: ${colors.lead}; }
+      .alt { color: ${colors.alt}; }
+      .dot { color: ${colors.dot}; }
+      p { max-width: 900px; color: ${FAMILY_TOKEN_VALUES['--text-muted']}; font-size: 34px; line-height: 1.35; }
       .rule {
         width: 180px;
         height: 10px;

package/src/seo/vite/prerender.ts

@@ -23,13 +23,14 @@ import { dirname, join, resolve } from 'node:path';
 import type { Logger, Plugin } from 'vite';
 
 import type { EcosystemSite, SiteId } from '../../ecosystem/core/sites.ts';
+import { trimTrailingSlash } from '../../router/core/address.ts';
 import type { NoscriptText } from '../core/noscript.ts';
 import { noscriptIndex } from '../core/noscript.ts';
 import { pageHeadTags } from '../core/pageMeta.ts';
 import type { RobotsDisallow } from '../core/robots.ts';
 import { robotsTxt } from '../core/robots.ts';
 import type { RouteMeta } from '../core/routes.ts';
-import { assertRoutes, homeRoute, trimTrailingSlash } from '../core/routes.ts';
+import { assertRoutes, homeRoute } from '../core/routes.ts';
 import { sitemapXml } from '../core/siteFiles.ts';
 import { structuredDataScript } from '../core/structuredData.ts';
 import { PAGE_BODY_MARKER, PAGE_HEAD_MARKER, fill } from '../core/template.ts';

package/src/share/core/config.ts

@@ -75,7 +75,10 @@ export function applyShareConfig<
     if (!owned.has(entry[0])) entries.push(entry);
   }
   if (config.embed) entries.push([EMBED_PARAM, '1']);
-  const hidden = orderHidden(new Set(config.hidden), vocabulary.parts);
+  const hidden = orderHidden(
+    new Set(config.hidden),
+    visibleShareParts(vocabulary.parts, config.embed),
+  );
   if (hidden.length > 0) entries.push([HIDE_PARAM, hidden.join(',')]);
   const values = config.params as Readonly<Record<string, unknown>>;
   for (const [key, codec] of Object.entries(codecs)) {
@@ -85,6 +88,26 @@ export function applyShareConfig<
   return serializeQuery(entries);
 }
 
+/**
+ * The parts a link can meaningfully switch off in a given layout: all of them
+ * on the full site, and only those outside the site header once the page is
+ * embedded, because the header and everything in it are already gone.
+ * @param parts - The hideable parts, in the vocabulary order.
+ * @param embed - Whether the link drops the site chrome.
+ * @returns The parts that still mean something, in the same order.
+ */
+export function visibleShareParts(
+  parts: readonly HideablePart[],
+  embed: boolean,
+): readonly HideablePart[] {
+  if (!embed) return parts;
+  const visible: HideablePart[] = [];
+  for (const part of parts) {
+    if (part.inHeader !== true) visible.push(part);
+  }
+  return visible;
+}
+
 /**
  * Whether the link switches a part of the page off.
  *

package/src/share/core/index.ts

@@ -7,11 +7,13 @@ export {
   isShareConfigured,
   parseShareConfig,
   suggestedShareConfig,
+  visibleShareParts,
 } from './config.ts';
 export { escapeAttribute, escapeText } from './escape.ts';
 export type {
   BooleanParamOptions,
   IntegerParamOptions,
+  NumberParamOptions,
   ShareParamCodec,
   StringParamOptions,
 } from './params.ts';
@@ -19,8 +21,23 @@ export {
   booleanParam,
   enumParam,
   integerParam,
+  numberParam,
   stringParam,
 } from './params.ts';
+export type {
+  PreferenceHistory,
+  PreferenceLocation,
+  SyncPreferencesOptions,
+  UrlPreference,
+  UrlPreferences,
+} from './preferences.ts';
+export {
+  applyPreferencesFromSearch,
+  syncPreferencesWithUrl,
+  writePreferencesToSearch,
+} from './preferences.ts';
+export type { SharePreset } from './presets.ts';
+export { applySharePreset, findSharePreset } from './presets.ts';
 export type { EmbedCodeOptions, ShareUrlOptions } from './url.ts';
 export { buildEmbedCode, buildShareUrl } from './url.ts';
 export type {

package/src/share/core/params.ts

@@ -97,6 +97,60 @@ export function integerParam<Fallback extends number | null>(
   };
 }
 
+/** What {@link numberParam} is configured with. */
+export interface NumberParamOptions {
+  /** The smallest value a link may ask for. */
+  min: number;
+  /** The largest value a link may ask for. */
+  max: number;
+  /**
+   * The value an absent or malformed parameter falls back to, and the one
+   * deleted rather than written.
+   */
+  default: number;
+  /**
+   * The decimal places kept, so a slider does not write `0.30000000000000004`
+   * into the address. Omitted, the value is kept as it is.
+   * @default undefined
+   */
+  decimals?: number;
+}
+
+/**
+ * A real number a link carries — a size factor, an opacity — clamped to the
+ * range the tool can serve and, when asked, rounded to a number of decimal
+ * places. As with {@link integerParam}, a value outside the range is brought
+ * back inside it rather than rejected.
+ * @param options - The range, the default and the precision.
+ * @returns The codec.
+ */
+export function numberParam(
+  options: NumberParamOptions,
+): ShareParamCodec<number> {
+  const { min, max, default: fallback, decimals } = options;
+  function normalize(value: number): number {
+    const bounded = Math.min(max, Math.max(min, value));
+    if (decimals === undefined) return bounded;
+    const factor = 10 ** decimals;
+    return Math.round(bounded * factor) / factor;
+  }
+  return {
+    parse(raw) {
+      if (raw === null) return fallback;
+      const text = raw.trim();
+      if (text === '') return fallback;
+      const parsed = Number(text);
+      if (Number.isNaN(parsed)) return fallback;
+      return normalize(parsed);
+    },
+    serialize(value) {
+      if (typeof value !== 'number' || Number.isNaN(value)) return null;
+      const normalized = normalize(value);
+      return normalized === fallback ? null : String(normalized);
+    },
+  };
+}
+
 /** What {@link stringParam} is configured with. */
 export interface StringParamOptions {
   /**

package/src/share/core/preferences.ts

@@ -0,0 +1,211 @@
+import { EMBED_PARAM, HIDE_PARAM } from './config.ts';
+import type { ShareParamCodec } from './params.ts';
+import type { QueryEntry } from './query.ts';
+import { firstValues, parseQuery, serializeQuery } from './query.ts';
+
+/**
+ * One persisted user choice mirrored in the address bar: how it is read from
+ * and written to a link, and how the site reads and stores it.
+ */
+export interface UrlPreference<Value> {
+  /** How the value is read from a link and written back; its default is never written. */
+  codec: ShareParamCodec<Value>;
+  /**
+   * The value in force.
+   * @returns The current value.
+   */
+  get(): Value;
+  /**
+   * Store a value a link carries, which makes it the visitor's saved preference.
+   * @param value - The value to store.
+   */
+  set(value: Value): void;
+}
+
+/** The preferences a site mirrors, keyed by their URL parameter name. */
+export type UrlPreferences = Readonly<Record<string, UrlPreference<unknown>>>;
+
+/** The minimal part of `window.location` the sync reads. */
+export interface PreferenceLocation {
+  /** The path of the address. */
+  readonly pathname: string;
+  /** The query string, with its leading `?` or empty. */
+  readonly search: string;
+  /** The fragment, with its leading `#` or empty. */
+  readonly hash: string;
+}
+
+/** The minimal part of `window.history` the sync writes through. */
+export interface PreferenceHistory {
+  /** The state of the current entry, kept as it is. */
+  readonly state: unknown;
+  /**
+   * Rewrite the current entry without adding one.
+   * @param data - The state to keep.
+   * @param unused - Ignored by browsers.
+   * @param url - The new address.
+   */
+  replaceState(data: unknown, unused: string, url: string): void;
+}
+
+/** What {@link syncPreferencesWithUrl} is given. */
+export interface SyncPreferencesOptions {
+  /** The preferences to mirror, keyed by their URL parameter name. */
+  preferences: UrlPreferences;
+  /** Call the listener whenever any preference changes, and answer a function that stops calling it. */
+  subscribe: (listener: () => void) => () => void;
+  /**
+   * The address to read and keep up to date.
+   * @default globalThis.location
+   */
+  location?: PreferenceLocation;
+  /**
+   * The history to rewrite.
+   * @default globalThis.history
+   */
+  history?: PreferenceHistory;
+}
+
+/**
+ * Store the preferences a link carries. Only the keys present are set: a key
+ * the link omits leaves the saved preference as it is. A malformed value falls
+ * back to the codec's default.
+ * @param search - The query string, with or without its leading `?`.
+ * @param preferences - The preferences, keyed by their URL parameter name.
+ * @returns The names of the preferences that were set, in declaration order.
+ */
+export function applyPreferencesFromSearch(
+  search: string,
+  preferences: UrlPreferences,
+): string[] {
+  assertPreferenceNames(preferences);
+  const values = firstValues(parseQuery(search));
+  const applied: string[] = [];
+  for (const [name, preference] of Object.entries(preferences)) {
+    const raw = values.get(name);
+    if (raw === undefined) continue;
+    preference.set(preference.codec.parse(raw));
+    applied.push(name);
+  }
+  return applied;
+}
+
+/**
+ * Write the preferences into a query string. A preference already in the
+ * address keeps its place, a new one is appended, one at its default is
+ * deleted; every other key keeps its value and its order.
+ * @param search - The query string, with or without its leading `?`.
+ * @param preferences - The preferences, keyed by their URL parameter name.
+ * @returns The new query string, without its leading `?`.
+ */
+export function writePreferencesToSearch(
+  search: string,
+  preferences: UrlPreferences,
+): string {
+  assertPreferenceNames(preferences);
+  const written = new Map<string, string | null>();
+  for (const [name, preference] of Object.entries(preferences)) {
+    written.set(name, preference.codec.serialize(preference.get()));
+  }
+  const entries: QueryEntry[] = [];
+  const placed = new Set<string>();
+  for (const entry of parseQuery(search)) {
+    const [key] = entry;
+    if (!written.has(key)) {
+      entries.push(entry);
+      continue;
+    }
+    if (placed.has(key)) continue;
+    placed.add(key);
+    const raw = written.get(key);
+    if (raw !== null && raw !== undefined) entries.push([key, raw]);
+  }
+  for (const [name, raw] of written) {
+    if (!placed.has(name) && raw !== null) entries.push([name, raw]);
+  }
+  return serializeQuery(entries);
+}
+
+/**
+ * Mirror a site's preferences in the address bar. The preferences the current
+ * address carries are applied once, then the address is rewritten with
+ * `history.replaceState` — never a new history entry — every time one changes.
+ * The path, the hash and every other query key are kept, and the address is
+ * left alone when nothing in it would change.
+ *
+ * A site using signals subscribes with an effect reading every value:
+ *
+ * ```ts
+ * const stop = syncPreferencesWithUrl({
+ *   preferences: {
+ *     strategy: {
+ *       codec: enumParam(['greedy', 'exhaustive'] as const, 'greedy'),
+ *       get: () => state.preferences.strategy.value,
+ *       set: (value) => (state.preferences.strategy.value = value),
+ *     },
+ *   },
+ *   subscribe: (listener) =>
+ *     effect(() => {
+ *       void state.preferences.strategy.value;
+ *       listener();
+ *     }),
+ * });
+ * ```
+ * @param options - The preferences, how to watch them, and the address.
+ * @returns A function that stops rewriting the address.
+ */
+export function syncPreferencesWithUrl(
+  options: SyncPreferencesOptions,
+): () => void {
+  const {
+    preferences,
+    subscribe,
+    location = globalThis.location,
+    history = globalThis.history,
+  } = options;
+  assertPreferenceNames(preferences);
+  applyPreferencesFromSearch(location.search, preferences);
+  let active = true;
+  function write(): void {
+    if (!active) return;
+    const current = location.search;
+    const next = writePreferencesToSearch(current, preferences);
+    if (sameQuery(current, next)) return;
+    const query = next === '' ? '' : `?${next}`;
+    history.replaceState(
+      history.state,
+      '',
+      `${location.pathname}${query}${location.hash}`,
+    );
+  }
+  const unsubscribe = subscribe(write);
+  write();
+  return () => {
+    active = false;
+    unsubscribe();
+  };
+}
+
+const RESERVED_NAMES = new Set([EMBED_PARAM, HIDE_PARAM]);
+
+function assertPreferenceNames(preferences: UrlPreferences): void {
+  for (const name of Object.keys(preferences)) {
+    if (RESERVED_NAMES.has(name)) {
+      throw new Error(
+        `preference "${name}" collides with a reserved share parameter`,
+      );
+    }
+  }
+}
+
+function sameQuery(current: string, next: string): boolean {
+  const before = parseQuery(current);
+  const after = parseQuery(next);
+  if (before.length !== after.length) return false;
+  for (let index = 0; index < before.length; index++) {
+    const left = before[index];
+    const right = after[index];
+    if (left?.[0] !== right?.[0] || left?.[1] !== right?.[1]) return false;
+  }
+  return true;
+}

package/src/share/core/presets.ts

@@ -0,0 +1,89 @@
+import type { ShareConfig } from './config.ts';
+import { applyShareConfig } from './config.ts';
+import type {
+  ShareParamCodecs,
+  ShareParamValues,
+  ShareVocabulary,
+} from './vocabulary.ts';
+
+/**
+ * A ready-made link the share dialog offers as one tab: the handful of
+ * configurations a site knows people actually hand out, so building one is a
+ * click rather than six boxes.
+ */
+export interface SharePreset<
+  Codecs extends ShareParamCodecs = Record<string, never>,
+> {
+  /** Names the preset among the others of the dialog. */
+  key: string;
+  /** The tab label, a few words. */
+  label: string;
+  /** One sentence saying what the link shows, for the person building it. */
+  description: string;
+  /**
+   * Whether the link drops the site chrome.
+   * @default true
+   */
+  embed?: boolean;
+  /**
+   * The parts the link switches off. A key the vocabulary does not list is
+   * ignored.
+   * @default []
+   */
+  hidden?: readonly string[];
+  /**
+   * The tool's own parameters the preset pins. A parameter it does not name
+   * keeps the value the draft holds.
+   * @default {}
+   */
+  params?: Partial<ShareParamValues<Codecs>>;
+}
+
+/**
+ * The configuration a preset turns a draft into.
+ * @param config - The draft as it stands.
+ * @param preset - The preset to apply.
+ * @param vocabulary - What this site's links can say.
+ * @returns The draft with the preset's layout, parts and parameters.
+ */
+export function applySharePreset<
+  Codecs extends ShareParamCodecs = Record<string, never>,
+>(
+  config: ShareConfig<Codecs>,
+  preset: SharePreset<Codecs>,
+  vocabulary: ShareVocabulary<Codecs>,
+): ShareConfig<Codecs> {
+  const asked = new Set(preset.hidden);
+  const hidden: string[] = [];
+  for (const part of vocabulary.parts) {
+    if (asked.has(part.key)) hidden.push(part.key);
+  }
+  return {
+    embed: preset.embed ?? true,
+    hidden,
+    params: { ...config.params, ...preset.params },
+  };
+}
+
+/**
+ * The preset a draft already is, judged by the link both would write, so a
+ * part the layout makes meaningless does not tell them apart.
+ * @param config - The draft to recognise.
+ * @param presets - The presets the dialog offers.
+ * @param vocabulary - What this site's links can say.
+ * @returns The first preset writing the same link, or `undefined`.
+ */
+export function findSharePreset<
+  Codecs extends ShareParamCodecs = Record<string, never>,
+>(
+  config: ShareConfig<Codecs>,
+  presets: ReadonlyArray<SharePreset<Codecs>>,
+  vocabulary: ShareVocabulary<Codecs>,
+): SharePreset<Codecs> | undefined {
+  const link = applyShareConfig('', config, vocabulary);
+  for (const preset of presets) {
+    const presetConfig = applySharePreset(config, preset, vocabulary);
+    if (applyShareConfig('', presetConfig, vocabulary) === link) return preset;
+  }
+  return undefined;
+}