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

package/dist/cjs/router-server-snapshot.js

@@ -0,0 +1,405 @@
+"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__, {
+    prepareOctaneRouterSerialization: ()=>prepareOctaneRouterSerialization
+});
+const data_namespaceObject = require("@modern-js/renderer-core/data");
+const session_namespaceObject = require("@modern-js/renderer-core/session");
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const external_router_server_cleanup_js_namespaceObject = require("./router-server-cleanup.js");
+const external_router_snapshot_js_namespaceObject = require("./router-snapshot.js");
+const external_routes_js_namespaceObject = require("./routes.js");
+const ERROR_FIELDS = new Set([
+    'name',
+    'message',
+    'stack',
+    'cause'
+]);
+const ROUTE_ERROR_FIELDS = new Set([
+    ...ERROR_FIELDS,
+    'routeId',
+    'status',
+    'data'
+]);
+const errorConstructors = new Map([
+    [
+        Error.prototype,
+        Error
+    ],
+    [
+        TypeError.prototype,
+        TypeError
+    ],
+    [
+        RangeError.prototype,
+        RangeError
+    ],
+    [
+        SyntaxError.prototype,
+        SyntaxError
+    ],
+    [
+        ReferenceError.prototype,
+        ReferenceError
+    ],
+    [
+        URIError.prototype,
+        URIError
+    ],
+    [
+        EvalError.prototype,
+        EvalError
+    ]
+]);
+const owners = new WeakMap();
+function prepareOctaneRouterSerialization(router, session, options = {}) {
+    session.signal.throwIfAborted();
+    if (owners.has(router)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('a router already has a request serialization owner');
+    const adapterProperty = Object.getOwnPropertyDescriptor(router.options, 'serializationAdapters');
+    const dehydrateProperty = Object.getOwnPropertyDescriptor(router.options, 'dehydrate');
+    if (adapterProperty?.get || adapterProperty?.set || dehydrateProperty?.get || dehydrateProperty?.set) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native serializer options must be owned data properties');
+    const consumerAdapters = adapterProperty?.value ?? [];
+    if (!Array.isArray(consumerAdapters) || Object.getPrototypeOf(consumerAdapters) !== Array.prototype) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native serializationAdapters must be an owned array');
+    const adapterFields = (0, external_router_snapshot_js_namespaceObject.descriptors)(consumerAdapters);
+    if (consumerAdapters.length > 1 || 1 === consumerAdapters.length && adapterFields['0']?.value !== external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter || Object.keys(adapterFields).length !== consumerAdapters.length + 1) throw (0, external_router_snapshot_js_namespaceObject.invalid)('custom serializationAdapters are not admitted in framework SSR; return supported public data');
+    const consumerDehydrate = dehydrateProperty?.value;
+    if (void 0 !== consumerDehydrate && 'function' != typeof consumerDehydrate) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native dehydrate must be an owned function');
+    owners.set(router, session);
+    const production = options.production ?? 'production' === process.env['NODE_ENV'];
+    const policy = (0, data_namespaceObject.createRequestDataPolicy)([
+        session,
+        session.request,
+        session.platform,
+        session.platform.bindings,
+        ...options.forbiddenValues ?? []
+    ]);
+    const copies = new WeakMap();
+    const projectedRoots = new WeakSet();
+    let nativeRoot;
+    let released = false;
+    let failure;
+    const fail = (error)=>{
+        failure ??= error;
+        session.fail(failure);
+        (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
+        throw failure;
+    };
+    const assertActive = ()=>{
+        if (void 0 !== failure) throw failure;
+        session.signal.throwIfAborted();
+    };
+    function copyPublic(value) {
+        policy.assertValue(value);
+        return copyValue(value);
+    }
+    function copyValue(value) {
+        if (null === value || 'object' != typeof value) return value;
+        const fields = (0, external_router_snapshot_js_namespaceObject.descriptors)(value);
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const prototype = Object.getPrototypeOf(value);
+        let result;
+        if (prototype === Date.prototype) result = new Date(Date.prototype.valueOf.call(value));
+        else if (prototype === RegExp.prototype) {
+            const source = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source').get.call(value);
+            const flags = [
+                'hasIndices',
+                'global',
+                'ignoreCase',
+                'multiline',
+                'dotAll',
+                'unicode',
+                'unicodeSets',
+                'sticky'
+            ];
+            const letters = [
+                'd',
+                'g',
+                'i',
+                'm',
+                's',
+                'u',
+                'v',
+                'y'
+            ];
+            const enabled = flags.map((flag, index)=>Object.getOwnPropertyDescriptor(RegExp.prototype, flag)?.get?.call(value) ? letters[index] : '').join('');
+            result = new RegExp(source, enabled);
+        } else result = prototype === Map.prototype ? new Map() : prototype === Set.prototype ? new Set() : Array.isArray(value) ? [] : Object.create(prototype);
+        copies.set(value, result);
+        if (prototype === Map.prototype) for (const [key, item] of Map.prototype.entries.call(value))Map.prototype.set.call(result, copyValue(key), copyValue(item));
+        else if (prototype === Set.prototype) for (const item of Set.prototype.values.call(value))Set.prototype.add.call(result, copyValue(item));
+        for (const [key, field] of Object.entries(fields))if (!Array.isArray(value) || 'length' !== key) Object.defineProperty(result, key, {
+            ...field,
+            value: copyValue(field.value)
+        });
+        if (Array.isArray(value)) Object.defineProperty(result, 'length', fields['length']);
+        if (!Object.isExtensible(value)) Object.preventExtensions(result);
+        return result;
+    }
+    function copyError(value) {
+        if (null === value || 'object' != typeof value) return copyPublic(value);
+        policy.assertRoot(value);
+        const prototype = Object.getPrototypeOf(value);
+        const routeError = prototype === external_routes_js_namespaceObject.RouteDataError.prototype;
+        const Constructor = errorConstructors.get(prototype);
+        if (!routeError && !Constructor) return copyPublic(value);
+        const fields = (0, external_router_snapshot_js_namespaceObject.descriptors)(value, routeError ? ROUTE_ERROR_FIELDS : ERROR_FIELDS, true);
+        if ('[object Error]' !== Object.prototype.toString.call(value)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('an error requires genuine native Error slots');
+        const name = fields['name'] ? (0, external_router_snapshot_js_namespaceObject.stringField)(fields, 'name') : routeError ? 'Error' : Constructor.name;
+        const message = fields['message'] ? (0, external_router_snapshot_js_namespaceObject.stringField)(fields, 'message') : '';
+        const stack = production ? void 0 : fields['stack']?.value;
+        if (void 0 !== stack && 'string' != typeof stack) throw (0, external_router_snapshot_js_namespaceObject.invalid)('stack must be a data string');
+        const cause = fields['cause'] ? copyPublic(fields['cause'].value) : void 0;
+        const projectedData = routeError ? copyPublic(fields['data']?.value) : void 0;
+        const previous = copies.get(value);
+        if (previous) return previous;
+        if (routeError) {
+            const routeId = (0, external_router_snapshot_js_namespaceObject.stringField)(fields, 'routeId');
+            const status = fields['status']?.value;
+            if (!routeId || !Number.isInteger(status) || status < 400 || status > 599) throw (0, external_router_snapshot_js_namespaceObject.invalid)('a route error has invalid identity or status');
+            const result = {
+                kind: external_router_snapshot_js_namespaceObject.ROUTE_ERROR_KIND,
+                routeId,
+                status,
+                name,
+                message,
+                data: projectedData,
+                ...void 0 === stack ? {} : {
+                    stack
+                },
+                ...fields['cause'] ? {
+                    cause
+                } : {}
+            };
+            copies.set(value, result);
+            return result;
+        }
+        const publicError = production ? (0, data_namespaceObject.publicDataError)(value, true) : {
+            name,
+            message
+        };
+        const result = {
+            kind: external_router_snapshot_js_namespaceObject.NATIVE_ERROR_KIND,
+            type: production ? 'Error' : Constructor.name,
+            name: publicError.name,
+            message: publicError.message,
+            ...void 0 === stack ? {} : {
+                stack
+            },
+            ...!production && fields['cause'] ? {
+                cause
+            } : {}
+        };
+        copies.set(value, result);
+        return result;
+    }
+    function copyPromise(value) {
+        policy.assertRoot(value);
+        if (Reflect.ownKeys(value).length > 0) throw (0, external_router_snapshot_js_namespaceObject.invalid)('deferred values require native Promises without own fields');
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const checked = Promise.prototype.then.call(value, (settled)=>{
+            try {
+                if (released || session.signal.aborted) throw (0, external_router_snapshot_js_namespaceObject.invalid)('the request serialization owner was released');
+                policy.assertRoot(value);
+                return copyPublic(settled);
+            } catch (error) {
+                return fail(error);
+            }
+        }, (reason)=>{
+            if (released || session.signal.aborted) throw (0, external_router_snapshot_js_namespaceObject.invalid)('the request serialization owner was released');
+            let projected;
+            try {
+                policy.assertRoot(value);
+                projected = copyError(reason);
+            } catch (error) {
+                return fail(error);
+            }
+            throw projected;
+        });
+        copies.set(value, checked);
+        Promise.prototype.then.call(checked, void 0, ()=>{});
+        return checked;
+    }
+    function copyLoader(value) {
+        if ((0, external_router_snapshot_js_namespaceObject.nativePromise)(value)) return copyPromise(value);
+        if (!(0, external_router_snapshot_js_namespaceObject.record)(value)) return copyPublic(value);
+        policy.assertRoot(value);
+        const fields = (0, external_router_snapshot_js_namespaceObject.descriptors)(value);
+        if (!Object.values(fields).some((field)=>(0, external_router_snapshot_js_namespaceObject.nativePromise)(field.value))) return copyPublic(value);
+        const previous = copies.get(value);
+        if (previous) return previous;
+        const result = Object.create(Object.getPrototypeOf(value));
+        copies.set(value, result);
+        for (const [key, field] of Object.entries(fields))Object.defineProperty(result, key, {
+            ...field,
+            value: (0, external_router_snapshot_js_namespaceObject.nativePromise)(field.value) ? copyPromise(field.value) : copyPublic(field.value)
+        });
+        if (!Object.isExtensible(value)) Object.preventExtensions(result);
+        return result;
+    }
+    function projectRoot(value) {
+        assertActive();
+        assertMatches();
+        if (!(0, external_router_snapshot_js_namespaceObject.record)(value) || Object.getPrototypeOf(value) !== Object.prototype) throw (0, external_router_snapshot_js_namespaceObject.invalid)('the first native serializer value must be its fresh outer record');
+        const fields = (0, external_router_snapshot_js_namespaceObject.descriptors)(value, external_router_snapshot_js_namespaceObject.NATIVE_ROOT_FIELDS);
+        const matches = fields['matches']?.value;
+        if (!fields['manifest'] || !Array.isArray(matches)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('the native outer record shape changed');
+        const arrayFields = (0, external_router_snapshot_js_namespaceObject.descriptors)(matches);
+        const projectedMatches = [];
+        for(let index = 0; index < matches.length; index++){
+            const match = arrayFields[String(index)]?.value;
+            if (!(0, external_router_snapshot_js_namespaceObject.record)(match)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native matches must be dense records');
+            const matchFields = (0, external_router_snapshot_js_namespaceObject.descriptors)(match, external_router_snapshot_js_namespaceObject.MATCH_FIELDS);
+            const projected = {};
+            const id = (0, external_router_snapshot_js_namespaceObject.stringField)(matchFields, 'i');
+            const status = (0, external_router_snapshot_js_namespaceObject.stringField)(matchFields, 's');
+            const updatedAt = matchFields['u']?.value;
+            if (!id || 'number' != typeof updatedAt || !Number.isFinite(updatedAt)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native match metadata changed');
+            if (![
+                'pending',
+                'success',
+                'error',
+                'notFound',
+                'redirected'
+            ].includes(status)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native match status changed');
+            projected['i'] = id;
+            projected['u'] = updatedAt;
+            projected['s'] = status;
+            for (const [key, field] of Object.entries(matchFields))if ('i' !== key && 'u' !== key && 's' !== key) projected[key] = 'l' === key ? copyLoader(field.value) : 'e' === key ? copyError(field.value) : copyPublic(field.value);
+            projectedMatches.push(projected);
+        }
+        const result = {
+            manifest: copyPublic(fields['manifest'].value),
+            matches: projectedMatches
+        };
+        if (fields['lastMatchId']) result['lastMatchId'] = (0, external_router_snapshot_js_namespaceObject.stringField)(fields, 'lastMatchId');
+        if (fields['dehydratedData']) result['dehydratedData'] = copyPublic(fields['dehydratedData'].value);
+        projectedRoots.add(result);
+        return result;
+    }
+    const adapter = Object.freeze((0, tanstack_router_namespaceObject.createSerializationAdapter)({
+        key: external_router_snapshot_js_namespaceObject.ADAPTER_KEY,
+        test (value) {
+            if (null === value || 'object' != typeof value || projectedRoots.has(value)) return false;
+            if (nativeRoot) return false;
+            nativeRoot = value;
+            return true;
+        },
+        toSerializable (value) {
+            try {
+                return projectRoot(value);
+            } catch (error) {
+                return fail(error);
+            }
+        },
+        fromSerializable: external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter.fromSerializable
+    }));
+    const adapters = Object.freeze([
+        adapter
+    ]);
+    const wrappedDehydrate = async ()=>{
+        try {
+            assertMatches();
+            const result = 'function' == typeof consumerDehydrate ? await (0, session_namespaceObject.untilAborted)(Reflect.apply(consumerDehydrate, router.options, []), session.signal) : void 0;
+            assertMatches();
+            return result;
+        } catch (error) {
+            return fail(error);
+        }
+    };
+    const nativeOptions = {
+        ...router.options,
+        serializationAdapters: adapters,
+        dehydrate: wrappedDehydrate
+    };
+    router.update(nativeOptions);
+    session.registerCleanup(()=>{
+        released = true;
+        (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
+    });
+    function assertMatches() {
+        try {
+            assertActive();
+            const currentAdapters = Object.getOwnPropertyDescriptor(router.options, 'serializationAdapters');
+            const currentDehydrate = Object.getOwnPropertyDescriptor(router.options, 'dehydrate');
+            if (currentAdapters?.get || currentAdapters?.set || currentAdapters?.value !== adapters || currentDehydrate?.get || currentDehydrate?.set || currentDehydrate?.value !== wrappedDehydrate) throw (0, external_router_snapshot_js_namespaceObject.invalid)('the request serializer owner was replaced');
+            for (const match of router.stores.matches.get()){
+                const prototype = Object.getPrototypeOf(match);
+                if (prototype !== Object.prototype && null !== prototype) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native matches require owned plain records');
+                for (const key of [
+                    'id',
+                    'routeId',
+                    'updatedAt',
+                    'status',
+                    '__beforeLoadContext',
+                    'loaderData',
+                    'error',
+                    'ssr',
+                    'globalNotFound',
+                    'styles',
+                    'headScripts'
+                ]){
+                    const field = Object.getOwnPropertyDescriptor(match, key);
+                    if (field?.get || field?.set) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native match fields must be owned values before dehydrate');
+                    if (!field && prototype && Object.getOwnPropertyDescriptor(prototype, key)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native match fields cannot be inherited');
+                    if (('id' === key || 'routeId' === key) && ('string' != typeof field?.value || !field.value)) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native match identity must be an owned nonempty string');
+                    if ('updatedAt' === key && ('number' != typeof field?.value || !Number.isFinite(field.value))) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native updatedAt must be an owned finite number');
+                    if ('status' === key && ('string' != typeof field?.value || ![
+                        'pending',
+                        'success',
+                        'error',
+                        'notFound',
+                        'redirected'
+                    ].includes(field.value))) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native status must be an owned supported string');
+                    if (('styles' === key || 'headScripts' === key) && field?.value !== void 0) {
+                        const value = field.value;
+                        if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native styles/headScripts are not admitted by the fragment host');
+                        const fields = (0, external_router_snapshot_js_namespaceObject.descriptors)(value);
+                        if (fields['length']?.value !== 0 || 1 !== Reflect.ownKeys(value).length) throw (0, external_router_snapshot_js_namespaceObject.invalid)('native styles/headScripts are not admitted by the fragment host');
+                    }
+                }
+            }
+        } catch (error) {
+            fail(error);
+        }
+    }
+    return {
+        assertActive,
+        assertMatches
+    };
+}
+exports.prepareOctaneRouterSerialization = __webpack_exports__.prepareOctaneRouterSerialization;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "prepareOctaneRouterSerialization"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-server.js

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_modules__ = {
+    "./router-handler" (module) {
+        module.exports = require("./router-handler.js");
+    },
+    "./router-injection" (module) {
+        module.exports = require("./router-injection.js");
+    },
+    "./router-server-snapshot" (module) {
+        module.exports = require("./router-server-snapshot.js");
+    },
+    "@octanejs/tanstack-router" (module) {
+        module.exports = require("@octanejs/tanstack-router");
+    },
+    "@octanejs/tanstack-router/ssr/server" (module) {
+        module.exports = require("@octanejs/tanstack-router/ssr/server");
+    },
+    "octane/server" (module) {
+        module.exports = require("octane/server");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__);
+    var _octanejs_tanstack_router__rspack_import_0 = __webpack_require__("@octanejs/tanstack-router");
+    var octane_server__rspack_import_1 = __webpack_require__("octane/server");
+    var _octanejs_tanstack_router_ssr_server__rspack_import_2 = __webpack_require__("@octanejs/tanstack-router/ssr/server");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _octanejs_tanstack_router_ssr_server__rspack_import_2)if ([
+        "createOctaneRequestHandler",
+        "prepareOctaneRouterSerialization",
+        "default",
+        "OctaneRouterServer",
+        "createOctaneRouterInjection"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_octanejs_tanstack_router_ssr_server__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _router_handler__rspack_import_3 = __webpack_require__("./router-handler");
+    var _router_injection__rspack_import_4 = __webpack_require__("./router-injection");
+    var _router_server_snapshot__rspack_import_5 = __webpack_require__("./router-server-snapshot");
+    function OctaneRouterServer({ router }) {
+        return (0, octane_server__rspack_import_1.createElement)(_octanejs_tanstack_router__rspack_import_0.RouterProvider, {
+            router
+        });
+    }
+    __webpack_require__.d(__webpack_exports__, {
+        OctaneRouterServer: ()=>OctaneRouterServer,
+        createOctaneRequestHandler: ()=>_router_handler__rspack_import_3.createOctaneRequestHandler,
+        createOctaneRouterInjection: ()=>_router_injection__rspack_import_4.createOctaneRouterInjection,
+        prepareOctaneRouterSerialization: ()=>_router_server_snapshot__rspack_import_5.prepareOctaneRouterSerialization
+    });
+})();
+exports.OctaneRouterServer = __webpack_exports__.OctaneRouterServer;
+exports.createOctaneRequestHandler = __webpack_exports__.createOctaneRequestHandler;
+exports.createOctaneRouterInjection = __webpack_exports__.createOctaneRouterInjection;
+exports.prepareOctaneRouterSerialization = __webpack_exports__.prepareOctaneRouterSerialization;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OctaneRouterServer",
+    "createOctaneRequestHandler",
+    "createOctaneRouterInjection",
+    "prepareOctaneRouterSerialization"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});