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

package/dist/cjs/plugin/index.js

@@ -0,0 +1,151 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    rendererAdapter: ()=>rendererAdapter
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const adapter_namespaceObject = require("@modern-js/renderer-core/adapter");
+const external_manifest_js_namespaceObject = require("../manifest.js");
+const external_compiler_js_namespaceObject = require("./compiler.js");
+const external_create_js_namespaceObject = require("./create.js");
+const external_profile_js_namespaceObject = require("./profile.js");
+const external_source_js_namespaceObject = require("./source.js");
+const rendererAdapter = (0, adapter_namespaceObject.defineRendererAdapter)({
+    name: 'octane',
+    kind: 'native',
+    profile: external_profile_js_namespaceObject.octaneProfile,
+    routerFrameworks: [
+        'octane'
+    ],
+    runtime: {
+        package: 'octane',
+        bootstrap: '@modern-js/renderer-octane',
+        entryClient: '@modern-js/renderer-octane/entry-client',
+        entryServer: '@modern-js/renderer-octane/entry-server',
+        router: '@modern-js/renderer-octane/router',
+        i18n: '@modern-js/renderer-octane/i18n',
+        manifest: '@modern-js/renderer-octane/manifest'
+    },
+    federation: {
+        library: 'module',
+        ssr: true,
+        shared: [
+            'octane',
+            'octane/',
+            'octane/internal/context',
+            'octane/internal/signal-read',
+            'octane/signals',
+            '@octanejs/tanstack-router',
+            '@octanejs/tanstack-router/',
+            '@modern-js/renderer-octane',
+            '@modern-js/renderer-octane/',
+            '@modern-js/renderer-octane/router',
+            '@modern-js/renderer-octane/federation',
+            '@modern-js/renderer-core',
+            '@modern-js/renderer-core/',
+            '@tanstack/router-core',
+            '@tanstack/history',
+            'seroval',
+            'seroval-plugins'
+        ],
+        sharedByEnvironment: {
+            client: {
+                'octane/internal/client': 'octane/internal/client',
+                'octane/signals/client': 'octane/signals/client',
+                'octane/profiling': 'octane/profiling',
+                'octane/hydration/streamed-signals': 'octane/hydration/streamed-signals',
+                '@modern-js/renderer-octane/client': '@modern-js/renderer-octane/client'
+            },
+            server: {
+                octane: 'octane/server',
+                'octane/server': 'octane/server',
+                'octane/internal/server': 'octane/internal/server',
+                'octane/signals/server': 'octane/signals/server'
+            }
+        }
+    },
+    worker: {
+        nativeDocuments: true,
+        rsc: false
+    },
+    lazyStyles: 'document',
+    entryClient: {
+        declarations: 'declare const __webpack_hash__: string;\n',
+        fields: {
+            nativeHydrationBuildId: '__webpack_hash__'
+        }
+    },
+    svgComponentTemplate: ()=>external_node_path_default().join((0, external_compiler_js_namespaceObject.pluginSourceDirectory)(), 'svg-component-template.cjs'),
+    compiler: external_compiler_js_namespaceObject.createOctaneCompilerPlugin,
+    artifacts: external_manifest_js_namespaceObject.compilerArtifacts,
+    assertSupportedSource: external_source_js_namespaceObject.assertOctaneEntrySource,
+    create: {
+        templates: {
+            federation: true,
+            workers: true
+        },
+        dependencies: (profile, { typescriptVersion })=>({
+                frameworkDependencies: [
+                    '@modern-js/renderer-core',
+                    '@modern-js/renderer-octane'
+                ],
+                dependencies: (0, adapter_namespaceObject.nativeRendererDependencies)(profile),
+                devDependencies: {
+                    [profile.compiler.name]: profile.dependencies[profile.compiler.name] ?? profile.compiler.version,
+                    typescript: typescriptVersion
+                },
+                typecheckCommand: 'octane-tsc --noEmit --project tsconfig.json',
+                tsconfig: {
+                    tsrx: {
+                        compiler: 'octane/compiler/volar',
+                        platform: 'web'
+                    }
+                }
+            }),
+        generateAppSources: external_create_js_namespaceObject.generateOctaneAppSources
+    }
+});
+exports.rendererAdapter = __webpack_exports__.rendererAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "rendererAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/profile.js

@@ -0,0 +1,91 @@
+"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__);
+const octaneProfile = {
+    renderer: 'octane',
+    status: 'preview',
+    protocolVersion: 1,
+    minimumNode: '26.12.0',
+    hmr: {
+        editedBoundary: 'may-reset',
+        unaffectedComponents: 'preserved',
+        document: 'preserved',
+        roots: 'single',
+        cleanup: 'exactly-once'
+    },
+    compiler: {
+        name: '@octanejs/rspack-plugin',
+        version: '0.2.4'
+    },
+    hydration: {
+        name: 'octane',
+        version: '0.13.8'
+    },
+    router: {
+        name: '@octanejs/tanstack-router',
+        version: '0.2.10',
+        coreName: '@tanstack/router-core',
+        coreVersion: '1.171.38'
+    },
+    sourceExtensions: [
+        '.tsx',
+        '.tsrx',
+        '.ts',
+        '.js'
+    ],
+    jsxImportSource: 'octane',
+    dependencies: {
+        '@tsrx/oxc': '0.20.0',
+        octane: 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/octane-0.13.8.tgz',
+        '@octanejs/tanstack-router': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/octanejs-tanstack-router-0.2.10.tgz',
+        '@octanejs/rspack-plugin': 'https://github.com/BleedingDev/octane/releases/download/ultramodern-octane-2383d2ab1e70/octanejs-rspack-plugin-0.2.4.tgz',
+        '@tanstack/router-core': 'https://github.com/BleedingDev/router/releases/download/ultramodern-router-core-585d3233f7f5/tanstack-router-core-1.171.38.tgz',
+        '@modern-js/renderer-octane': '3.8.3',
+        seroval: '1.6.9',
+        'seroval-plugins': '1.6.9'
+    },
+    capabilities: {
+        worker: true,
+        moduleFederation: true,
+        rsc: false,
+        ssg: true,
+        i18n: true,
+        svgComponent: true
+    }
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    octaneProfile: octaneProfile
+});
+exports.octaneProfile = __webpack_exports__.octaneProfile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "octaneProfile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugin/source.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    assertOctaneEntrySource: ()=>assertOctaneEntrySource
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_profile_js_namespaceObject = require("./profile.js");
+async function assertOctaneEntrySource(source) {
+    if (source && '.jsx' === external_node_path_default().extname(source).toLowerCase() && (await promises_default().stat(source)).isFile()) throw new Error(`unsupported-renderer-capability: Octane does not support .jsx source: ${source}. Supported source extensions: ${external_profile_js_namespaceObject.octaneProfile.sourceExtensions.join(', ')}.`);
+}
+exports.assertOctaneEntrySource = __webpack_exports__.assertOctaneEntrySource;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertOctaneEntrySource"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-client.js

@@ -0,0 +1,139 @@
+"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__, {
+    OctaneRouterRoot: ()=>OctaneRouterRoot,
+    prepareOctaneRouterHydration: ()=>prepareOctaneRouterHydration
+});
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const client_namespaceObject = require("@octanejs/tanstack-router/ssr/client");
+const external_octane_namespaceObject = require("octane");
+const external_router_snapshot_js_namespaceObject = require("./router-snapshot.js");
+const hydration = new WeakMap();
+function abortReason(signal) {
+    return void 0 === signal.reason ? new DOMException('Octane router hydration aborted', 'AbortError') : signal.reason;
+}
+function awaitHydration(promise, signal) {
+    if (!signal) return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (success, error)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (success) resolve();
+            else reject(error);
+        };
+        const onAbort = ()=>finish(false, abortReason(signal));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        promise.then(()=>finish(true), (error)=>finish(false, error));
+        if (signal.aborted) onAbort();
+    });
+}
+function isReactiveMatchIds(value) {
+    return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
+}
+function waitForCommittedMatches(router, signal) {
+    signal?.throwIfAborted();
+    const matchesId = router.stores.ids;
+    if (matchesId.get().length > 0) return Promise.resolve();
+    if (!isReactiveMatchIds(matchesId)) throw new Error('Octane router hydration requires its native reactive match store');
+    return new Promise((resolve, reject)=>{
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const finish = ()=>{
+            if (settled || 0 === matchesId.get().length) return;
+            settled = true;
+            cleanup();
+            resolve();
+        };
+        const onAbort = ()=>{
+            if (settled) return;
+            settled = true;
+            cleanup();
+            if (signal) reject(abortReason(signal));
+        };
+        signal?.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (signal?.aborted) return void onAbort();
+        subscription = matchesId.subscribe(finish);
+        if (settled) subscription.unsubscribe();
+        else finish();
+    });
+}
+async function prepareOctaneRouterHydration(router, options = {}) {
+    (0, external_octane_namespaceObject.initializeHydrationEventCapture)();
+    options.signal?.throwIfAborted();
+    const adapters = router.options.serializationAdapters ?? [];
+    if (!adapters.includes(external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter)) {
+        const nativeOptions = {
+            ...router.options,
+            serializationAdapters: [
+                external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter,
+                ...adapters
+            ]
+        };
+        router.update(nativeOptions);
+    }
+    let pending = hydration.get(router);
+    if (!pending) {
+        pending = Promise.resolve((0, client_namespaceObject.hydrate)(router)).then(()=>{});
+        pending.catch(()=>{});
+        hydration.set(router, pending);
+    }
+    await awaitHydration(pending, options.signal);
+    await waitForCommittedMatches(router, options.signal);
+    options.signal?.throwIfAborted();
+}
+const routerHydrationEffectSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+function OctaneRouterRoot({ router }) {
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        window.$_TSR?.h();
+    }, [], routerHydrationEffectSlot);
+    return (0, external_octane_namespaceObject.createElement)(tanstack_router_namespaceObject.RouterProvider, {
+        router
+    });
+}
+exports.OctaneRouterRoot = __webpack_exports__.OctaneRouterRoot;
+exports.prepareOctaneRouterHydration = __webpack_exports__.prepareOctaneRouterHydration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OctaneRouterRoot",
+    "prepareOctaneRouterHydration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});