@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.10

package/dist/cjs/entry-client.js

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    startNativeClient: ()=>startNativeClient
+});
+const entry_client_namespaceObject = require("@modern-js/renderer-core/entry-client");
+const router_namespaceObject = require("@modern-js/renderer-core/router");
+const external_client_js_namespaceObject = require("./client.js");
+const external_entry_application_js_namespaceObject = require("./entry-application.js");
+const external_router_client_js_namespaceObject = require("./router-client.js");
+const LocalizedRouterRoot = (0, external_entry_application_js_namespaceObject.localizedRouterRoot)(external_router_client_js_namespaceObject.OctaneRouterRoot);
+function startNativeClient(options) {
+    const { nativeHydrationBuildId } = options;
+    (0, entry_client_namespaceObject.startNativeClientEntry)(options, {
+        readBootstrap: (document, identity)=>(0, external_client_js_namespaceObject.readOctaneDocumentBootstrap)(document, identity, nativeHydrationBuildId),
+        createRouter: (application, routerOptions)=>(0, router_namespaceObject.createNativeRouter)(application, routerOptions, external_entry_application_js_namespaceObject.octaneRouterFactory),
+        disposeRouter: (router)=>router.history.destroy(),
+        async prepareRouter (router, hydrating, signal) {
+            if (hydrating) await (0, external_router_client_js_namespaceObject.prepareOctaneRouterHydration)(router, {
+                signal
+            });
+            else await router.load();
+        },
+        async start ({ root, identity, bootstrap, signal, load }) {
+            const application = {
+                container: root,
+                identity,
+                nativeHydrationBuildId,
+                federation: options.federation,
+                workerFederation: options.workerFederation,
+                documentId: bootstrap?.documentId,
+                signal,
+                load: async ()=>{
+                    const view = await load();
+                    if ('component' === view.kind) return {
+                        default: (0, external_entry_application_js_namespaceObject.componentView)(view.component, view.i18n)
+                    };
+                    return view.i18n ? {
+                        default: LocalizedRouterRoot,
+                        props: {
+                            router: view.router,
+                            i18n: view.i18n
+                        }
+                    } : {
+                        default: external_router_client_js_namespaceObject.OctaneRouterRoot,
+                        props: {
+                            router: view.router
+                        }
+                    };
+                }
+            };
+            const handle = bootstrap?.hydrating ? await (0, external_client_js_namespaceObject.hydrateOctaneApplication)({
+                ...application,
+                documentIdentity: bootstrap.identity,
+                documentId: bootstrap.documentId,
+                documentNativeHydrationBuildId: bootstrap.nativeHydrationBuildId
+            }) : await (0, external_client_js_namespaceObject.mountOctaneApplication)(application);
+            return ()=>handle.dispose();
+        }
+    });
+}
+exports.startNativeClient = __webpack_exports__.startNativeClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "startNativeClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/entry-server.js

@@ -0,0 +1,135 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNativeServerEntry: ()=>createNativeServerEntry,
+    createNativeWorkerFederationRuntime: ()=>external_worker_federation_js_namespaceObject.createNativeWorkerFederationRuntime,
+    withOctaneDocumentFields: ()=>withOctaneDocumentFields
+});
+const data_namespaceObject = require("@modern-js/renderer-core/data");
+const entry_server_namespaceObject = require("@modern-js/renderer-core/entry-server");
+const router_namespaceObject = require("@modern-js/renderer-core/router");
+const external_entry_application_js_namespaceObject = require("./entry-application.js");
+const external_manifest_js_namespaceObject = require("./manifest.js");
+const external_router_server_js_namespaceObject = require("./router-server.js");
+const external_server_js_namespaceObject = require("./server.js");
+const external_worker_federation_js_namespaceObject = require("./worker-federation.js");
+const OCTANE_DOCUMENT_FIELDS = new Set([
+    'content-language',
+    'content-location',
+    'content-disposition'
+]);
+function withOctaneDocumentFields(policy, responseHeaders) {
+    const fields = (0, data_namespaceObject.collectDataHeaders)(responseHeaders).filter(([name])=>OCTANE_DOCUMENT_FIELDS.has(name.toLowerCase()));
+    return fields.length ? {
+        ...policy,
+        headers: [
+            ...policy.headers,
+            ...fields
+        ]
+    } : policy;
+}
+const LocalizedRouterServer = (0, external_entry_application_js_namespaceObject.localizedRouterRoot)(external_router_server_js_namespaceObject.OctaneRouterServer);
+function createNativeServerEntry(options) {
+    return (0, entry_server_namespaceObject.createNativeServerEntry)(options, {
+        document: (document, nativeManifest, identity)=>({
+                ...document,
+                nativeHydrationBuildId: (0, external_manifest_js_namespaceObject.validateOctaneModuleManifest)(nativeManifest, identity).nativeHydrationBuildId
+            }),
+        run: (_session, callback)=>callback(),
+        respond: (_session, response)=>response,
+        createRouter: (application, routerOptions)=>(0, router_namespaceObject.createNativeRouter)(application, routerOptions, external_entry_application_js_namespaceObject.octaneRouterFactory),
+        renderCSR: ({ session }, document)=>(0, external_server_js_namespaceObject.renderOctaneCSRDocument)({
+                session,
+                document
+            }),
+        renderComponent: ({ session, workerFederation }, component, document, i18n)=>(0, external_server_js_namespaceObject.renderOctaneApplication)({
+                session,
+                App: (0, external_entry_application_js_namespaceObject.componentView)(component, i18n),
+                document,
+                federation: options.federation,
+                workerFederation,
+                workerFederationLocale: options.workerFederationLocale
+            }),
+        async renderRoutes ({ request, context: { session, workerFederation }, router, outcomes, document, forbiddenValues, i18n }) {
+            const response = await (0, external_router_server_js_namespaceObject.createOctaneRequestHandler)({
+                request,
+                session,
+                createRouter: ()=>router,
+                serialization: {
+                    forbiddenValues
+                }
+            })(async ({ router, responseHeaders })=>{
+                const metadata = (0, data_namespaceObject.mergeDataResponseMetadata)(outcomes, {
+                    status: (0, external_router_server_js_namespaceObject.getSsrStatus)(router)
+                });
+                const policy = (0, data_namespaceObject.dataMetadataToDocumentPolicy)({
+                    ...metadata,
+                    headers: (0, data_namespaceObject.mergeHeaderFields)((0, data_namespaceObject.collectDataHeaders)(responseHeaders), metadata.headers)
+                });
+                session.resolveResponse(withOctaneDocumentFields(policy, responseHeaders));
+                const rendered = await (0, external_server_js_namespaceObject.renderOctaneApplication)({
+                    session,
+                    ...i18n ? {
+                        App: LocalizedRouterServer,
+                        props: {
+                            router,
+                            i18n
+                        }
+                    } : {
+                        App: external_router_server_js_namespaceObject.OctaneRouterServer,
+                        props: {
+                            router
+                        }
+                    },
+                    document,
+                    federation: options.federation,
+                    workerFederation,
+                    workerFederationLocale: options.workerFederationLocale,
+                    router
+                });
+                return (0, external_router_server_js_namespaceObject.createSsrStreamResponse)(router, rendered);
+            });
+            return session.committedPolicy ? response : (0, data_namespaceObject.mergeDataResponseIntoResponse)(response, (0, data_namespaceObject.mergeDataResponseMetadata)(outcomes, {
+                status: response.status
+            }));
+        }
+    });
+}
+exports.createNativeServerEntry = __webpack_exports__.createNativeServerEntry;
+exports.createNativeWorkerFederationRuntime = __webpack_exports__.createNativeWorkerFederationRuntime;
+exports.withOctaneDocumentFields = __webpack_exports__.withOctaneDocumentFields;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeServerEntry",
+    "createNativeWorkerFederationRuntime",
+    "withOctaneDocumentFields"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/federation-context.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    FederationApplication: ()=>FederationApplication,
+    FederationContext: ()=>FederationContext,
+    FederationRoot: ()=>FederationRoot,
+    createFederationScope: ()=>createFederationScope
+});
+const federation_namespaceObject = require("@modern-js/renderer-core/federation");
+const external_octane_namespaceObject = require("octane");
+const FederationContext = (0, external_octane_namespaceObject.createContext)(null);
+function createFederationScope(binding, server, nonce) {
+    return {
+        instance: (0, federation_namespaceObject.getFederationHost)(binding),
+        server,
+        ...void 0 === nonce ? {} : {
+            nonce
+        }
+    };
+}
+function FederationRoot(props) {
+    return (0, external_octane_namespaceObject.createElement)(FederationContext, {
+        value: props.scope,
+        children: props.children
+    });
+}
+function FederationApplication(props) {
+    return (0, external_octane_namespaceObject.createElement)(FederationRoot, {
+        scope: props.scope,
+        children: (0, external_octane_namespaceObject.createElement)(props.application.default, props.application.props)
+    });
+}
+exports.FederationApplication = __webpack_exports__.FederationApplication;
+exports.FederationContext = __webpack_exports__.FederationContext;
+exports.FederationRoot = __webpack_exports__.FederationRoot;
+exports.createFederationScope = __webpack_exports__.createFederationScope;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FederationApplication",
+    "FederationContext",
+    "FederationRoot",
+    "createFederationScope"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/federation.js

@@ -0,0 +1,205 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    federatedComponent: ()=>federatedComponent
+});
+const federation_namespaceObject = require("@modern-js/renderer-core/federation");
+const external_octane_namespaceObject = require("octane");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const context_js_namespaceObject = require("./i18n/context.js");
+const external_worker_federation_context_js_namespaceObject = require("./worker-federation-context.js");
+const external_worker_federation_contexts_js_namespaceObject = require("./worker-federation-contexts.js");
+function withTimeout(promise, timeout, label) {
+    if (void 0 === timeout) return promise;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(new Error(`Remote module ${label} did not load within ${timeout}ms`)), timeout);
+        timer.unref?.();
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+const publisherRegistrationEffectSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+function federatedComponent(remote, options = {}) {
+    if ('string' == typeof remote ? !/^[^/]+\/.+/u.test(remote) : 'function' != typeof remote) throw new TypeError("federatedComponent requires a remote id such as 'remote/Widget' or a loader");
+    if (void 0 !== options.timeout && (!Number.isFinite(options.timeout) || options.timeout <= 0)) throw new TypeError('federatedComponent timeout must be a positive number of milliseconds');
+    const id = 'string' == typeof remote ? remote : void 0;
+    const standalone = {
+        instance: void 0,
+        server: "u" < typeof document
+    };
+    const components = new WeakMap();
+    const workerOwners = new WeakMap();
+    return (props)=>{
+        const context = (0, external_octane_namespaceObject.useContext)(external_federation_context_js_namespaceObject.FederationContext) ?? standalone;
+        const worker = (0, external_octane_namespaceObject.useContext)(external_worker_federation_context_js_namespaceObject.WorkerFederationContext);
+        const language = worker ? (0, external_octane_namespaceObject.useContext)(context_js_namespaceObject.I18nContext)?.language ?? worker.locale : void 0;
+        const contextKeys = worker ? (0, external_worker_federation_contexts_js_namespaceObject.useOctaneWorkerContextKeys)(options.contextKeys) : void 0;
+        let owner = context;
+        if (worker) {
+            let scopes = workerOwners.get(context);
+            if (!scopes) workerOwners.set(context, scopes = new WeakMap());
+            let variants = scopes.get(worker);
+            if (!variants) scopes.set(worker, variants = new Map());
+            const key = JSON.stringify([
+                context.server ? language : void 0,
+                contextKeys
+            ]);
+            let variant = variants.get(key);
+            if (!variant) variants.set(key, variant = {});
+            owner = variant;
+        }
+        let Remote = components.get(owner);
+        if (!Remote) {
+            Remote = (0, external_octane_namespaceObject.lazy)(async ()=>{
+                try {
+                    if (context.server && !id) throw new Error('A federatedComponent loader renders in the browser only; use a remote id to server-render it');
+                    if (worker) {
+                        if (!id || !language) throw new Error('Worker federation requires a remote id and the owning entry locale');
+                        const separator = id.indexOf('/');
+                        const remoteName = id.slice(0, separator);
+                        const expose = `./${id.slice(separator + 1)}`;
+                        const controller = new AbortController();
+                        const signal = worker.signal ? AbortSignal.any([
+                            worker.signal,
+                            controller.signal
+                        ]) : controller.signal;
+                        const timeout = options.timeout ?? (context.server ? 3000 : void 0);
+                        let admitted;
+                        try {
+                            admitted = await withTimeout(worker.transport.admit({
+                                remote: remoteName,
+                                expose,
+                                locale: language,
+                                signal
+                            }), timeout, id);
+                        } finally{
+                            controller.abort();
+                        }
+                        const BrowserRemote = (0, external_octane_namespaceObject.lazy)(async ()=>{
+                            const { module, assets } = await (0, federation_namespaceObject.loadFederatedModule)(context.instance, id);
+                            if ('function' != typeof module?.default) throw new TypeError('A federated Octane module must default-export a native component');
+                            const component = module.default;
+                            const Loaded = (props, scope, extra)=>{
+                                for (const href of assets?.css ?? [])(0, external_octane_namespaceObject.preinit)(href, {
+                                    as: 'style',
+                                    precedence: 'federated',
+                                    ...void 0 === context.nonce ? {} : {
+                                        nonce: context.nonce
+                                    }
+                                });
+                                return component(props, scope, extra);
+                            };
+                            return {
+                                default: Loaded
+                            };
+                        });
+                        const boundary = (0, external_octane_namespaceObject.externalSnapshotBoundary)({
+                            authority: admitted.coordinate.native,
+                            component: BrowserRemote,
+                            contextKeys,
+                            timeoutMs: timeout,
+                            async snapshot (request, signal) {
+                                const response = await worker.transport.request({
+                                    remote: remoteName,
+                                    expose,
+                                    locale: language,
+                                    payload: (0, external_octane_namespaceObject.serializeExternalSnapshotRequest)(request),
+                                    signal
+                                });
+                                return (0, external_octane_namespaceObject.decodeExternalSnapshot)(response.payload);
+                            }
+                        });
+                        const Loaded = (props)=>{
+                            for (const href of admitted.styles)(0, external_octane_namespaceObject.preinit)(href, {
+                                as: 'style',
+                                precedence: 'federated',
+                                ...void 0 === context.nonce ? {} : {
+                                    nonce: context.nonce
+                                }
+                            });
+                            return (0, external_octane_namespaceObject.createElement)(boundary, props);
+                        };
+                        return {
+                            default: Loaded
+                        };
+                    }
+                    const { module, assets } = await withTimeout(Promise.resolve().then(()=>id ? (0, federation_namespaceObject.loadFederatedModule)(context.instance, id) : remote().then((module)=>({
+                                module,
+                                assets: void 0
+                            }))), options.timeout ?? (context.server ? 3000 : void 0), id ?? 'loader');
+                    if ('function' != typeof module?.default) throw new TypeError('A federated Octane module must default-export a native component');
+                    if (context.server && !assets) throw new Error(`Cannot server-render ${id}: the host has no browser assets for this remote`);
+                    const component = (0, external_octane_namespaceObject.publisherBoundary)(module.default, {
+                        publisherKey: id ?? 'ultramodern:browser-loader'
+                    });
+                    const Loaded = (props)=>{
+                        (0, external_octane_namespaceObject.useEffect)(()=>{
+                            if (context.server || !id || !context.instance) return;
+                            const register = Reflect.get(context.instance, Symbol.for('ultramodern.federation.browser-dev-boundary.v1'));
+                            if ('function' != typeof register) return;
+                            return register(id, module.default, component);
+                        }, [], publisherRegistrationEffectSlot);
+                        for (const href of assets?.css ?? [])(0, external_octane_namespaceObject.preinit)(href, {
+                            as: 'style',
+                            precedence: 'federated',
+                            ...void 0 === context.nonce ? {} : {
+                                nonce: context.nonce
+                            }
+                        });
+                        return (0, external_octane_namespaceObject.createElement)(component, props);
+                    };
+                    return {
+                        default: Loaded
+                    };
+                } catch (error) {
+                    if (!context.server) components.delete(owner);
+                    throw error;
+                }
+            });
+            components.set(owner, Remote);
+        }
+        return (0, external_octane_namespaceObject.createElement)(external_octane_namespaceObject.Suspense, {
+            fallback: options.fallback,
+            children: (0, external_octane_namespaceObject.createElement)(Remote, props)
+        });
+    };
+}
+exports.federatedComponent = __webpack_exports__.federatedComponent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "federatedComponent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/i18n/I18nProvider.js

@@ -0,0 +1,59 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    I18nProvider: ()=>I18nProvider
+});
+const external_octane_namespaceObject = require("octane");
+const external_context_js_namespaceObject = require("./context.js");
+const languageStoreSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+function I18nProvider(props) {
+    const instance = props.instance;
+    const language = (0, external_octane_namespaceObject.useSyncExternalStore)((notify)=>{
+        instance.on?.('languageChanged', notify);
+        return ()=>instance.off?.('languageChanged', notify);
+    }, ()=>instance.language, ()=>instance.language, languageStoreSlot);
+    const value = {
+        instance: props.instance,
+        languages: props.languages,
+        localisedUrls: props.localisedUrls,
+        language
+    };
+    return (0, external_octane_namespaceObject.createElement)(external_context_js_namespaceObject.I18nContext, {
+        value,
+        children: props.children
+    });
+}
+exports.I18nProvider = __webpack_exports__.I18nProvider;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18nProvider"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/i18n/LocalizedLink.js

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LocalizedLink: ()=>LocalizedLink
+});
+const paths_namespaceObject = require("@modern-js/i18n-runtime-extensions/paths");
+const external_octane_namespaceObject = require("octane");
+const external_router_js_namespaceObject = require("../router.js");
+const external_context_js_namespaceObject = require("./context.js");
+const targetLocationSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+function LocalizedLink(props) {
+    const context = (0, external_octane_namespaceObject.useContext)(external_context_js_namespaceObject.I18nContext);
+    if (!context) throw new Error('[renderer-octane] LocalizedLink was used outside of an I18nProvider.');
+    const router = (0, external_router_js_namespaceObject.useRouter)();
+    const location = (0, external_router_js_namespaceObject.useLocation)(void 0, targetLocationSlot);
+    const { language: requestedLanguage, to, children, ...options } = props;
+    const language = void 0 === requestedLanguage ? context.language : (0, paths_namespaceObject.configuredLanguage)(requestedLanguage, context.languages);
+    const externalTarget = to.startsWith('//') || URL.canParse(to);
+    const pathname = externalTarget ? to : (0, paths_namespaceObject.localizePath)(router.buildLocation({
+        to,
+        from: options.from,
+        params: options.params,
+        unsafeRelative: options.unsafeRelative,
+        _fromLocation: location
+    }).pathname, language, {
+        languages: [
+            ...context.languages
+        ],
+        localisedUrls: context.localisedUrls
+    });
+    return (0, external_octane_namespaceObject.createElement)(external_router_js_namespaceObject.Link, {
+        ...options,
+        to: router.options.rewrite ? to : pathname,
+        ...router.options.rewrite && !externalTarget ? {
+            mask: {
+                to: pathname,
+                inheritSearch: true,
+                hash: options.hash,
+                state: options.state
+            }
+        } : {},
+        ...language === context.language ? {} : {
+            hreflang: language
+        }
+    }, children);
+}
+exports.LocalizedLink = __webpack_exports__.LocalizedLink;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LocalizedLink"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});