@akinon/pz-theme 2.0.162-beta.0 → 2.0.162

package/src/region/__tests__/region-source.test.ts

@@ -0,0 +1,621 @@
+/**
+ * ZERO-5391 — the storefront's region source: which region a request belongs
+ * to, how the `theme-regions` registry is read and remembered, which slug a
+ * placeholder resolves to, when a region copy counts, and how a copy's own
+ * data-source records join theme-config's.
+ */
+jest.mock('react', () => {
+  const actual = jest.requireActual('react');
+  // Jest runs the client build, where `cache` does not memoize. Give the module
+  // the RSC behaviour (same args, same settled promise) with one store per
+  // wrapped function; clearing the stores starts a new request. The stores
+  // live in the factory: a top-level const would be in its TDZ when the
+  // hoisted factory runs.
+  const stores: Map<string, unknown>[] = [];
+  const cache = <A extends unknown[], R>(fn: (...args: A) => R) => {
+    const store = new Map<string, R>();
+    stores.push(store as Map<string, unknown>);
+    return (...args: A): R => {
+      const key = JSON.stringify(args);
+      if (!store.has(key)) store.set(key, fn(...args));
+      return store.get(key) as R;
+    };
+  };
+  return {
+    ...actual,
+    cache,
+    __clearCaches: () => stores.forEach((store) => store.clear())
+  };
+});
+
+const getWidgetData = jest.fn();
+const appFetch = jest.fn();
+const draftMode = jest.fn();
+
+jest.mock('@akinon/next/data/server', () => ({
+  getWidgetData: (...args: unknown[]) => getWidgetData(...args)
+}));
+
+jest.mock(
+  '@akinon/next/utils/app-fetch',
+  () => ({
+    __esModule: true,
+    default: (...args: unknown[]) => appFetch(...args)
+  }),
+  { virtual: true }
+);
+
+jest.mock(
+  '@akinon/next/utils/server-variables',
+  () => ({
+    ServerVariables: { locale: 'en-ae', currency: 'usd', previewId: '' }
+  }),
+  { virtual: true }
+);
+
+jest.mock('next/headers', () => ({
+  draftMode: (...args: unknown[]) => draftMode(...args)
+}));
+
+import {
+  __resetRegionSourceForTests,
+  getRegionRegistry,
+  getRequestRegion,
+  REGION_REGISTRY_FALLBACK_MEMO_MS,
+  REGION_REGISTRY_LAST_FOUND_MAX_AGE_MS,
+  REGION_REGISTRY_MEMO_MS,
+  readMarketPlaceholderCopy,
+  resolveRegionSlug,
+  withRegionDataSources
+} from '../region-source';
+
+const { ServerVariables } = jest.requireMock(
+  '@akinon/next/utils/server-variables'
+) as {
+  ServerVariables: { locale: string; currency: string; previewId?: unknown };
+};
+
+/** A new request: every React.cache store is emptied. */
+const newRequest = (): void =>
+  (jest.requireMock('react') as { __clearCaches: () => void }).__clearCaches();
+
+const T0 = 1_700_000_000_000;
+let now = T0;
+let nowSpy: jest.SpyInstance<number, []>;
+let warnSpy: jest.SpyInstance;
+
+/** The registry widget as commerce answers it: the attribute wrapped. */
+const registryWidget = (regions: Record<string, string[]>) => ({
+  slug: 'theme-regions',
+  attributes: {
+    theme_regions: {
+      value: JSON.stringify({
+        version: 1,
+        regions: Object.fromEntries(
+          Object.entries(regions).map(([code, slugs]) => [
+            code,
+            {
+              placeholders: Object.fromEntries(
+                slugs.map((slug) => [slug, { updatedAt: '2026-11-02' }])
+              )
+            }
+          ])
+        )
+      }),
+      kwargs: {}
+    }
+  }
+});
+
+const AE_HEADER = registryWidget({ ae: ['header'] });
+
+const slugOf = (call: unknown[]): string => (call[0] as { slug: string }).slug;
+
+const registryReads = (): number =>
+  getWidgetData.mock.calls.filter((call) => slugOf(call) === 'theme-regions')
+    .length;
+
+const readsOf = (slug: string): number =>
+  getWidgetData.mock.calls.filter((call) => slugOf(call) === slug).length;
+
+/** Answers the registry slug with `registry`, every other slug with `others`. */
+const serve = (
+  registry: (() => unknown) | unknown,
+  others: (slug: string) => unknown = () => null
+) =>
+  getWidgetData.mockImplementation(async ({ slug }: { slug: string }) => {
+    if (slug !== 'theme-regions') return others(slug);
+    return typeof registry === 'function' ? registry() : registry;
+  });
+
+beforeEach(() => {
+  getWidgetData.mockReset();
+  appFetch.mockReset();
+  draftMode.mockReset().mockResolvedValue({ isEnabled: false });
+  ServerVariables.locale = 'en-ae';
+  ServerVariables.currency = 'usd';
+  ServerVariables.previewId = '';
+  now = T0;
+  nowSpy = jest.spyOn(Date, 'now').mockImplementation(() => now);
+  warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+  __resetRegionSourceForTests();
+  newRequest();
+});
+
+afterEach(() => {
+  nowSpy.mockRestore();
+  warnSpy.mockRestore();
+});
+
+describe('getRequestRegion', () => {
+  it('derives the region from the request locale', () => {
+    expect(getRequestRegion()).toBe('ae');
+
+    for (const [locale, region] of [
+      ['tr', ''],
+      ['EN-AE', 'ae'],
+      ['ar-ae', 'ae'],
+      ['zh-hant-tw', 'tw'],
+      ['es-419', '']
+    ]) {
+      newRequest();
+      ServerVariables.locale = locale;
+      expect(getRequestRegion()).toBe(region);
+    }
+  });
+
+  it('pins one region per request', () => {
+    expect(getRequestRegion()).toBe('ae');
+    ServerVariables.locale = 'tr';
+    expect(getRequestRegion()).toBe('ae');
+  });
+});
+
+describe('a language-only locale', () => {
+  it('resolves every slug to itself without any I/O', async () => {
+    ServerVariables.locale = 'tr';
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(await readMarketPlaceholderCopy('header')).toBeNull();
+
+    expect(getWidgetData).not.toHaveBeenCalled();
+    expect(appFetch).not.toHaveBeenCalled();
+    expect(draftMode).not.toHaveBeenCalled();
+  });
+});
+
+describe('the live registry read', () => {
+  it('reads the registry once per request, through the cached core reader', async () => {
+    serve(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(await resolveRegionSlug('footer')).toBe('footer');
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+
+    expect(getWidgetData).toHaveBeenCalledTimes(1);
+    expect(getWidgetData).toHaveBeenCalledWith({
+      slug: 'theme-regions',
+      locale: 'en-ae',
+      cacheOptions: { expire: 60 }
+    });
+    expect(appFetch).not.toHaveBeenCalled();
+  });
+
+  it('remembers a found registry for 60 s across requests', async () => {
+    serve(AE_HEADER);
+    await getRegionRegistry();
+
+    newRequest();
+    now = T0 + REGION_REGISTRY_MEMO_MS - 1;
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(registryReads()).toBe(1);
+
+    newRequest();
+    now = T0 + REGION_REGISTRY_MEMO_MS + 1;
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(registryReads()).toBe(2);
+  });
+
+  it('remembers an absent registry the same way, after a single attempt', async () => {
+    serve(undefined);
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(registryReads()).toBe(1);
+
+    newRequest();
+    now = T0 + REGION_REGISTRY_MEMO_MS - 1;
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(registryReads()).toBe(1);
+
+    newRequest();
+    now = T0 + REGION_REGISTRY_MEMO_MS + 1;
+    await resolveRegionSlug('header');
+    expect(registryReads()).toBe(2);
+  });
+
+  it('keeps one memo per locale', async () => {
+    serve(AE_HEADER);
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+
+    newRequest();
+    ServerVariables.locale = 'ar-ae';
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+
+    expect(getWidgetData.mock.calls.map(([args]) => args.locale)).toEqual([
+      'en-ae',
+      'ar-ae'
+    ]);
+  });
+
+  it('turns an unreadable registry into the default content and warns once per memo window', async () => {
+    serve({ attributes: { theme_regions: { value: '{nope', kwargs: {} } } });
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0][0]).toContain('"theme-regions" is unreadable');
+
+    newRequest();
+    now = T0 + 1_000;
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('turns a failing read into the default content', async () => {
+    getWidgetData.mockRejectedValue(new Error('commerce is down'));
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(registryReads()).toBe(1);
+  });
+});
+
+describe('a named preview (draft mode and a preview id)', () => {
+  beforeEach(() => {
+    ServerVariables.previewId = 'draft';
+    draftMode.mockResolvedValue({ isEnabled: true });
+  });
+
+  it('reads the registry uncached and never memoises it', async () => {
+    appFetch.mockResolvedValue(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).toHaveBeenCalledTimes(1);
+    expect(appFetch).toHaveBeenCalledWith({
+      url: '/widgets/theme-regions/',
+      locale: 'en-ae',
+      currency: 'usd',
+      init: { next: { revalidate: 0 } }
+    });
+    expect(getWidgetData).not.toHaveBeenCalled();
+
+    newRequest();
+    await resolveRegionSlug('header');
+    expect(appFetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('leaves the live memo alone', async () => {
+    appFetch.mockResolvedValue(AE_HEADER);
+    await resolveRegionSlug('header');
+
+    newRequest();
+    ServerVariables.previewId = '';
+    serve(registryWidget({ ae: ['footer'] }));
+    expect(await resolveRegionSlug('footer')).toBe('footer-region-ae');
+    expect(registryReads()).toBe(1);
+  });
+
+  it('needs draft mode: a preview id alone reads the live registry', async () => {
+    draftMode.mockResolvedValue({ isEnabled: false });
+    serve(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).not.toHaveBeenCalled();
+    expect(registryReads()).toBe(1);
+
+    // ...and is memoised like any live read.
+    newRequest();
+    await resolveRegionSlug('header');
+    expect(registryReads()).toBe(1);
+  });
+
+  it('needs a preview id: draft mode alone reads the live registry', async () => {
+    ServerVariables.previewId = '';
+    serve(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).not.toHaveBeenCalled();
+    expect(registryReads()).toBe(1);
+    // Ordinary traffic never has to ask for draft mode.
+    expect(draftMode).not.toHaveBeenCalled();
+  });
+
+  it('reads live when draft mode cannot be asked (no request scope)', async () => {
+    draftMode.mockImplementation(() => {
+      throw new Error('`draftMode` was called outside a request scope.');
+    });
+    serve(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).not.toHaveBeenCalled();
+    expect(registryReads()).toBe(1);
+  });
+
+  it('reads live on a core without preview ids', async () => {
+    ServerVariables.previewId = undefined;
+    serve(AE_HEADER);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).not.toHaveBeenCalled();
+  });
+});
+
+describe('a registry the locale has found survives a failing read', () => {
+  /** A found read at T0, then the memo window lapses. */
+  const foundThenLapse = async (): Promise<void> => {
+    serve(AE_HEADER);
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    getWidgetData.mockClear();
+    newRequest();
+    now = T0 + REGION_REGISTRY_MEMO_MS + 1;
+  };
+
+  it('keeps serving the last found registry through a transient miss, after one extra attempt', async () => {
+    await foundThenLapse();
+    serve(undefined);
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(registryReads()).toBe(2);
+  });
+
+  it('memoises that fallback only briefly, so the next request checks again', async () => {
+    await foundThenLapse();
+    serve(undefined);
+    await resolveRegionSlug('header');
+    const lapsedAt = now;
+
+    newRequest();
+    now = lapsedAt + REGION_REGISTRY_FALLBACK_MEMO_MS - 1;
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(registryReads()).toBe(2);
+
+    newRequest();
+    now = lapsedAt + REGION_REGISTRY_FALLBACK_MEMO_MS + 1;
+    serve(registryWidget({ ae: ['footer'] }));
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(await resolveRegionSlug('footer')).toBe('footer-region-ae');
+    expect(registryReads()).toBe(3);
+  });
+
+  it('uses the extra attempt when it answers', async () => {
+    await foundThenLapse();
+    let attempts = 0;
+    serve(() => {
+      attempts += 1;
+      return attempts === 1 ? undefined : registryWidget({ ae: ['footer'] });
+    });
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(await resolveRegionSlug('footer')).toBe('footer-region-ae');
+    expect(attempts).toBe(2);
+  });
+
+  it('lets a found registry without the entry remove it', async () => {
+    await foundThenLapse();
+    serve(registryWidget({ ae: [] }));
+
+    expect(await resolveRegionSlug('header')).toBe('header');
+    expect(registryReads()).toBe(1);
+
+    // The new registry is what a later failure falls back to.
+    newRequest();
+    now += REGION_REGISTRY_MEMO_MS + 1;
+    serve(undefined);
+    expect(await resolveRegionSlug('header')).toBe('header');
+  });
+
+  it('serves the last found registry when the read turns unreadable', async () => {
+    await foundThenLapse();
+    serve({ attributes: { theme_regions: { value: '{nope', kwargs: {} } } });
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0][0]).toContain('last readable registry');
+  });
+
+  it('serves the last found registry when the read throws', async () => {
+    await foundThenLapse();
+    getWidgetData.mockRejectedValue(new Error('commerce is down'));
+
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(registryReads()).toBe(2);
+  });
+
+  it('gives up on a last found registry older than 15 minutes', async () => {
+    serve(AE_HEADER);
+    await resolveRegionSlug('header');
+
+    newRequest();
+    now = T0 + REGION_REGISTRY_LAST_FOUND_MAX_AGE_MS + 1;
+    serve(undefined);
+    expect(await resolveRegionSlug('header')).toBe('header');
+
+    // A locale that has had a registry re-checks soon, not after a minute.
+    const missedAt = now;
+    newRequest();
+    now = missedAt + REGION_REGISTRY_FALLBACK_MEMO_MS + 1;
+    serve(AE_HEADER);
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+  });
+
+  it('keeps what each locale found to itself', async () => {
+    serve(AE_HEADER);
+    await resolveRegionSlug('header');
+
+    newRequest();
+    ServerVariables.locale = 'ar-ae';
+    getWidgetData.mockClear();
+    serve(undefined);
+    expect(await resolveRegionSlug('header')).toBe('header');
+    // Never found for 'ar-ae': a miss is not retried.
+    expect(registryReads()).toBe(1);
+  });
+
+  it('falls back for a preview too, without memoising anything', async () => {
+    serve(AE_HEADER);
+    await resolveRegionSlug('header');
+
+    newRequest();
+    ServerVariables.previewId = 'draft';
+    draftMode.mockResolvedValue({ isEnabled: true });
+    appFetch.mockResolvedValue(undefined);
+    expect(await resolveRegionSlug('header')).toBe('header-region-ae');
+    expect(appFetch).toHaveBeenCalledTimes(2);
+
+    newRequest();
+    await resolveRegionSlug('header');
+    expect(appFetch).toHaveBeenCalledTimes(4);
+  });
+});
+
+describe('readMarketPlaceholderCopy', () => {
+  const copy = (layout: unknown) => ({
+    slug: 'header-region-ae',
+    attributes: { theme_editor_placeholder: layout }
+  });
+
+  it.each([
+    ['a wrapped layout', { value: '[{"section_slug":"sec-ae"}]', kwargs: {} }],
+    ['a wrapped empty layout', { value: '[]', kwargs: {} }],
+    ['a bare empty layout', '[]'],
+    ['a parsed layout', [{ section_slug: 'sec-ae' }]]
+  ])('returns a listed copy with %s', async (_label, layout) => {
+    const answer = copy(layout);
+    serve(AE_HEADER, (slug) => (slug === 'header-region-ae' ? answer : null));
+
+    expect(await readMarketPlaceholderCopy('header')).toBe(answer);
+    expect(readsOf('header-region-ae')).toBe(1);
+    expect(readsOf('header')).toBe(0);
+  });
+
+  it('gives up on a listed copy that answers nothing after the chrome retries', async () => {
+    serve(AE_HEADER);
+
+    expect(await readMarketPlaceholderCopy('header')).toBeNull();
+    expect(readsOf('header-region-ae')).toBe(3);
+  });
+
+  it.each([
+    ['a truthy 404 body', { detail: 'Not found.' }],
+    ['no layout attribute', { slug: 'header-region-ae', attributes: {} }],
+    ['null attributes', { slug: 'header-region-ae', attributes: null }],
+    ['a wrapped null layout', copy({ value: null, kwargs: {} })]
+  ])('never lets an answer with %s stand in', async (_label, answer) => {
+    serve(AE_HEADER, (slug) => (slug === 'header-region-ae' ? answer : null));
+
+    expect(await readMarketPlaceholderCopy('header')).toBeNull();
+  });
+
+  it('answers null when the copy read throws', async () => {
+    serve(AE_HEADER, (slug) => {
+      if (slug === 'header-region-ae') throw new Error('commerce is down');
+      return null;
+    });
+
+    expect(await readMarketPlaceholderCopy('header')).toBeNull();
+    expect(readsOf('header-region-ae')).toBe(3);
+  });
+
+  it('never probes a copy the registry does not list', async () => {
+    serve(AE_HEADER);
+
+    expect(await readMarketPlaceholderCopy('footer')).toBeNull();
+    expect(readsOf('footer-region-ae')).toBe(0);
+    expect(readsOf('footer')).toBe(0);
+  });
+});
+
+describe('withRegionDataSources', () => {
+  const themeConfig = [
+    { id: 'ds-1', name: 'Default picks' },
+    { id: 'ds-ae-1', name: 'AE picks (republished)', region: 'ae' },
+    { id: 'ds-2', name: 'Default banners' }
+  ];
+  const own = [
+    {
+      id: 'ds-ae-1',
+      name: 'AE picks (as this copy last saw it)',
+      region: 'ae'
+    },
+    { id: 'ds-ae-2', name: 'AE banners', region: 'ae' }
+  ];
+  const widget = (value: unknown) => ({
+    slug: 'header-region-ae',
+    attributes: { theme_region_dataSources: value }
+  });
+
+  it.each([
+    ['no widget', null],
+    ['an undefined widget', undefined],
+    ['a widget without attributes', { slug: 'header' }],
+    ['null attributes', { slug: 'header', attributes: null }],
+    ['no records attribute', { slug: 'header', attributes: {} }],
+    ['a null attribute', widget(null)],
+    ['malformed JSON', widget('[{nope')],
+    ['a wrapped malformed value', widget({ value: '{', kwargs: {} })],
+    ['an object instead of a list', widget('{"id":"ds-ae-1"}')],
+    ['an empty list', widget('[]')],
+    [
+      'records without a usable id',
+      widget([null, 'ds-ae-1', { id: '' }, { id: 7 }])
+    ]
+  ])('returns the same list for %s', (_label, placeholderWidget) => {
+    expect(withRegionDataSources(themeConfig, placeholderWidget)).toBe(
+      themeConfig
+    );
+  });
+
+  it.each([
+    ['a JSON string', JSON.stringify(own)],
+    ['the commerce wrapping', { value: JSON.stringify(own), kwargs: {} }],
+    ['a parsed list', own]
+  ])(
+    'adds the records theme-config lacks from %s, theme-config winning',
+    (_label, value) => {
+      const snapshot = JSON.parse(JSON.stringify(themeConfig));
+
+      expect(withRegionDataSources(themeConfig, widget(value))).toEqual([
+        { id: 'ds-1', name: 'Default picks' },
+        { id: 'ds-ae-1', name: 'AE picks (republished)', region: 'ae' },
+        { id: 'ds-2', name: 'Default banners' },
+        { id: 'ds-ae-2', name: 'AE banners', region: 'ae' }
+      ]);
+      expect(themeConfig).toEqual(snapshot);
+    }
+  );
+
+  it('returns the same list when theme-config already holds every record of the copy', () => {
+    const held = [own[0]];
+    expect(withRegionDataSources(themeConfig, widget(held))).toBe(themeConfig);
+  });
+
+  it('keeps the first of two records with one id', () => {
+    const merged = withRegionDataSources(
+      [],
+      widget([
+        { id: 'ds-ae-1', name: 'first' },
+        { id: 'ds-ae-1', name: 'second' }
+      ])
+    );
+    expect(merged).toEqual([{ id: 'ds-ae-1', name: 'first' }]);
+  });
+
+  it('keeps records theme-config holds without an id', () => {
+    const odd = { name: 'no id' };
+    expect(withRegionDataSources([odd], widget(own))).toEqual([odd, ...own]);
+  });
+
+  it('still serves the copy when the theme-config list is not a list', () => {
+    expect(
+      withRegionDataSources({} as unknown as unknown[], widget(own))
+    ).toEqual(own);
+  });
+});

package/src/region/editor-handshake.ts

@@ -0,0 +1,60 @@
+import settings from 'settings';
+
+/**
+ * ZERO-5391 — the two locale settings the theme editor needs before it can
+ * offer per-country content, announced on PLACEHOLDERS_AVAILABLE beside
+ * `contentCapabilities` (see `placeholder-registry.ts`).
+ *
+ * The editor moves its canvas from one country to another by switching the
+ * preview's locale, and it links a country's page by localising the page
+ * path. Both depend on facts only the storefront's settings hold:
+ *
+ *  - `localeUrlStrategy`  under 'subdomain' a locale switch moves the preview
+ *                         to another ORIGIN, which the editor cannot follow.
+ *  - `defaultLocale`      the hide-* strategies serve the default locale
+ *                         without a path prefix, and a prefixed default-locale
+ *                         URL does not resolve.
+ *
+ * Read when a frame is built, never at module scope, and never allowed to
+ * throw: the frame these ride is the one every editor load waits for, and
+ * losing it to a settings read would cost far more than these two fields.
+ *
+ * Client-safe. `settings` is the brand app's module, already in the client
+ * graph (the core's localization provider and pz-theme's find-in-store
+ * section import it). Never import the server region reader
+ * (`region-source.ts`) from here.
+ */
+
+type LocalizationSettings = {
+  localeUrlStrategy?: unknown;
+  defaultLocaleValue?: unknown;
+};
+
+const localization = (): LocalizationSettings | undefined => {
+  try {
+    return (settings as { localization?: LocalizationSettings } | undefined)
+      ?.localization;
+  } catch {
+    return undefined;
+  }
+};
+
+/**
+ * `settings.localization.localeUrlStrategy`, or 'hide-default-locale' when it
+ * is unset — the strategy the core's locale middleware routes by in that case
+ * (`middlewares/locale.ts`), so the editor is told what the storefront does.
+ */
+export const localeUrlStrategyForEditor = (): string => {
+  const value = localization()?.localeUrlStrategy;
+  return typeof value === 'string' && value ? value : 'hide-default-locale';
+};
+
+/**
+ * `settings.localization.defaultLocaleValue`, or '' when it is not a string.
+ * The core's locale middleware refuses to route without one, so '' only ever
+ * leaves a misconfigured build.
+ */
+export const defaultLocaleForEditor = (): string => {
+  const value = localization()?.defaultLocaleValue;
+  return typeof value === 'string' ? value : '';
+};