@bleedingdev/modern-js-i18n-integration 0.0.0 → 3.9.0-ultramodern.11

package/src/federation/boundary.tsx

@@ -0,0 +1,129 @@
+import {
+  type FederatedI18nBoundaryProps,
+  getActualI18nextInstance,
+  ModernI18nContext,
+  ModernI18nProvider,
+  ReactI18nextProviderContext,
+} from '@modern-js/plugin-i18n/runtime/consumer';
+import { type FC, useContext, useMemo } from 'react';
+
+export type { FederatedI18nBoundaryProps } from '@modern-js/plugin-i18n/runtime/consumer';
+
+/**
+ * Keeps a federated surface's translation resources inside its delivery unit.
+ * The host supplies only the active language; the remote owns and versions the
+ * resources used below this boundary.
+ */
+export const FederatedI18nBoundary: FC<FederatedI18nBoundaryProps> = ({
+  children,
+  defaultNamespace,
+  fallbackLanguage,
+  resources,
+  supportedLanguages,
+}) => {
+  const parent = useContext(ModernI18nContext);
+  const I18nextProvider = useContext(ReactI18nextProviderContext);
+  if (!parent) {
+    throw new Error(
+      'FederatedI18nBoundary must be used within ModernI18nProvider',
+    );
+  }
+
+  const languages =
+    supportedLanguages ?? parent.languages ?? Object.keys(resources);
+  const scopedInstance = useMemo(() => {
+    const parentInstance = getActualI18nextInstance(parent.i18nInstance);
+    const clone = parentInstance.cloneInstance?.({
+      defaultNS: defaultNamespace,
+      fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
+      forkResourceStore: true,
+      initImmediate: false,
+      lng: parent.language,
+      ns: [defaultNamespace],
+      resources,
+      supportedLngs: languages,
+    });
+    if (!clone) {
+      throw new Error(
+        'FederatedI18nBoundary requires an i18n instance with cloneInstance support',
+      );
+    }
+    const resourceStore = clone.store;
+    const parentResourceStore = parentInstance.store;
+    const sharesNestedResourceState = Object.entries(
+      resourceStore?.data ?? {},
+    ).some(([language, namespaces]) => {
+      const parentNamespaces = parentResourceStore?.data?.[language];
+      return (
+        namespaces === parentNamespaces ||
+        Object.entries(namespaces).some(
+          ([namespace, resource]) =>
+            resource !== null &&
+            typeof resource === 'object' &&
+            resource === parentNamespaces?.[namespace],
+        )
+      );
+    });
+    if (
+      clone === parentInstance ||
+      resourceStore === parentResourceStore ||
+      resourceStore?.data === parentResourceStore?.data ||
+      sharesNestedResourceState
+    ) {
+      throw new Error(
+        'FederatedI18nBoundary cloneInstance did not isolate the host resource store',
+      );
+    }
+    if (
+      !resourceStore?.addResourceBundle ||
+      !clone.removeResourceBundle ||
+      !resourceStore.data
+    ) {
+      throw new Error(
+        'FederatedI18nBoundary requires an isolated mutable i18n resource store',
+      );
+    }
+    for (const [language, namespaces] of Object.entries(resourceStore.data)) {
+      for (const namespace of Object.keys(namespaces)) {
+        clone.removeResourceBundle(language, namespace);
+      }
+    }
+    for (const [language, namespaces] of Object.entries(resources)) {
+      for (const [namespace, resource] of Object.entries(namespaces)) {
+        resourceStore.addResourceBundle(
+          language,
+          namespace,
+          resource as Record<string, string>,
+          true,
+          true,
+        );
+      }
+    }
+    return clone;
+  }, [
+    defaultNamespace,
+    fallbackLanguage,
+    languages,
+    parent.i18nInstance,
+    parent.language,
+    resources,
+  ]);
+  const value = useMemo(
+    () => ({
+      ...parent,
+      i18nInstance: scopedInstance,
+      language: parent.language,
+      languages,
+    }),
+    [languages, parent, scopedInstance],
+  );
+
+  const scopedContent = (
+    <ModernI18nProvider value={value}>{children}</ModernI18nProvider>
+  );
+  return I18nextProvider ? (
+    <I18nextProvider i18n={scopedInstance}>{scopedContent}</I18nextProvider>
+  ) : (
+    scopedContent
+  );
+};

package/src/federation/registration.ts

@@ -0,0 +1,8 @@
+import type { RuntimePluginAPI } from '@modern-js/plugin/runtime';
+import { FederatedI18nBoundary } from './boundary';
+
+export function registerFederatedI18nBoundary(api: RuntimePluginAPI<{}>): void {
+  api.resolveComponent((component, { name }) =>
+    name === 'i18n.FederatedI18nBoundary' ? FederatedI18nBoundary : component,
+  );
+}

package/src/languageSynchronization.tsx

@@ -0,0 +1,23 @@
+import { useLanguageSync } from '@modern-js/i18n-runtime-extensions';
+import type { I18nLanguageSynchronizationProps } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+
+/** Bind the shared controller to this native provider's instance and state. */
+export const I18nLanguageSynchronization = ({
+  i18nInstance,
+  localePathRedirect,
+  languages,
+  pathname,
+  prevLangRef,
+  setLang,
+  children,
+}: I18nLanguageSynchronizationProps) => {
+  const synchronizeLanguage = useLanguageSync(
+    i18nInstance,
+    localePathRedirect,
+    languages,
+    pathname,
+    prevLangRef,
+    setLang,
+  );
+  return children(synchronizeLanguage);
+};

package/src/navigation.tsx

@@ -0,0 +1,12 @@
+/**
+ * The selected-router navigation adapter now lives in
+ * `@modern-js/plugin-i18n`, so a bare `appTools() + i18nPlugin()` app gets
+ * mapped `<Link>` navigation and language-invariant active state without this
+ * integration package. Re-exported here so the composed
+ * `ultramodernI18nIntegrationPlugin` keeps its own entry point and any consumer
+ * importing it from this package continues to work.
+ */
+export {
+  I18nRouterNavigationProvider,
+  useIntegratedRouterAdapter,
+} from '@modern-js/plugin-i18n/runtime/no-react-i18next';

package/src/options.ts

@@ -0,0 +1,18 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nPluginOptions as NativeRuntimeOptions } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+import type { I18nPluginOptions as NativeServerOptions } from '@modern-js/plugin-i18n/server';
+
+export type IntegratedLocaleDetectionOptions = NonNullable<
+  NativeRuntimeOptions['localeDetection']
+> & {
+  localisedUrls?: LocalisedUrlsOption;
+  localeDetectionByEntry?: Record<string, IntegratedLocaleDetectionOptions>;
+};
+
+export type I18nPluginOptions = NativeRuntimeOptions & {
+  localeDetection?: IntegratedLocaleDetectionOptions;
+};
+
+export type I18nServerPluginOptions = NativeServerOptions & {
+  localeDetection: IntegratedLocaleDetectionOptions;
+};

package/src/runtime-no-react-i18next.ts

@@ -0,0 +1,5 @@
+import { i18nPlugin as nativeI18nPlugin } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+import { composeI18nPlugin } from './runtimeComposition';
+
+export const i18nPlugin = composeI18nPlugin(nativeI18nPlugin);
+export default i18nPlugin;

package/src/runtime.ts

@@ -0,0 +1,5 @@
+import { i18nPlugin as nativeI18nPlugin } from '@modern-js/plugin-i18n/runtime';
+import { composeI18nPlugin } from './runtimeComposition';
+
+export const i18nPlugin = composeI18nPlugin(nativeI18nPlugin);
+export default i18nPlugin;

package/src/runtimeComposition.ts

@@ -0,0 +1,33 @@
+import type { I18nPluginOptions as NativeI18nPluginOptions } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+import type { RuntimePlugin } from '@modern-js/runtime';
+import { registerFederatedI18nBoundary } from './federation/registration';
+import { I18nLanguageSynchronization } from './languageSynchronization';
+import { I18nRouterNavigationProvider } from './navigation';
+import type { I18nPluginOptions } from './options';
+import { createI18nUrlStrategy } from './urlStrategy';
+
+export const composeI18nPlugin =
+  (nativeI18nPlugin: (options: NativeI18nPluginOptions) => RuntimePlugin) =>
+  (options: I18nPluginOptions = {}): RuntimePlugin => {
+    const {
+      localisedUrls,
+      localeDetectionByEntry: _entryOptions,
+      ...nativeLocaleDetection
+    } = options.localeDetection ?? {};
+    const native = nativeI18nPlugin({
+      ...options,
+      localeDetection: nativeLocaleDetection,
+      urlStrategy: options.urlStrategy ?? createI18nUrlStrategy(localisedUrls),
+      NavigationProvider:
+        options.NavigationProvider ?? I18nRouterNavigationProvider,
+      LanguageSynchronization:
+        options.LanguageSynchronization ?? I18nLanguageSynchronization,
+    });
+    return {
+      ...native,
+      setup(api) {
+        registerFederatedI18nBoundary(api);
+        return native.setup?.(api);
+      },
+    };
+  };

package/src/server.ts

@@ -0,0 +1,27 @@
+import { getLocaleDetectionOptions } from '@modern-js/plugin-i18n/config';
+import { i18nServerPlugin as nativeI18nServerPlugin } from '@modern-js/plugin-i18n/server';
+import type {
+  I18nServerPluginOptions,
+  IntegratedLocaleDetectionOptions,
+} from './options';
+import { createI18nUrlStrategy } from './urlStrategy';
+
+export const i18nServerPlugin = (options: I18nServerPluginOptions) =>
+  nativeI18nServerPlugin({
+    ...options,
+    resolveUrlStrategy:
+      options.resolveUrlStrategy ??
+      (entryName =>
+        createI18nUrlStrategy(
+          options.localeDetection
+            ? (
+                getLocaleDetectionOptions(
+                  entryName,
+                  options.localeDetection,
+                ) as IntegratedLocaleDetectionOptions
+              ).localisedUrls
+            : undefined,
+        )),
+  });
+
+export default i18nServerPlugin;

package/src/urlStrategy.ts

@@ -0,0 +1,19 @@
+import {
+  canonicalTargetPathname,
+  isDefaultLocaleRedirectSkipPath,
+  type LocalisedUrlsOption,
+  localiseTargetPathname,
+} from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '@modern-js/plugin-i18n/runtime/no-react-i18next';
+
+/** Each integration owns its map; no process-wide configuration is installed. */
+export const createI18nUrlStrategy = (
+  localisedUrls?: LocalisedUrlsOption,
+): I18nUrlStrategy => ({
+  localizePathname: (pathname, language, languages) =>
+    localiseTargetPathname(pathname, language, [...languages], localisedUrls),
+  canonicalPathname: (pathname, languages) =>
+    canonicalTargetPathname(pathname, [...languages], localisedUrls),
+  shouldSkipRedirect: (pathname, languages) =>
+    isDefaultLocaleRedirectSkipPath(pathname, [...languages]),
+});

package/README.md

@@ -1,3 +0,0 @@
-# @bleedingdev/modern-js-i18n-integration
-
-This 0.0.0 version only registers the package name so npm trusted publishing can be configured. It contains no runtime implementation. Use the subsequent UltraModern.js release, published from the repository workflow with provenance.