@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/cjs/runtime/rsc/ReplayableStream.js

@@ -0,0 +1,141 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    REPLAYABLE_STREAM_MARKER: ()=>REPLAYABLE_STREAM_MARKER,
+    ReplayableStream: ()=>ReplayableStream
+});
+const REPLAYABLE_STREAM_MARKER = Symbol.for('modern.tanstack.rsc.ReplayableStream');
+class ReplayableStream {
+    start() {
+        const signal = this.options.signal;
+        if (signal?.aborted) return void this.release();
+        this.abortListener = ()=>this.release();
+        signal?.addEventListener('abort', this.abortListener, {
+            once: true
+        });
+        const reader = this.source.getReader();
+        this.reader = reader;
+        const pump = async ()=>{
+            try {
+                while(!this.released){
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    this.chunks.push(value);
+                    this.notify();
+                }
+            } catch (err) {
+                if (!this.released) this.error = err;
+            } finally{
+                this.done = true;
+                this.detachAbortListener();
+                try {
+                    reader.releaseLock();
+                } catch  {}
+                if (this.reader === reader) this.reader = null;
+                this.notify();
+            }
+        };
+        pump();
+    }
+    detachAbortListener() {
+        const signal = this.options.signal;
+        if (signal && this.abortListener) signal.removeEventListener('abort', this.abortListener);
+        this.abortListener = null;
+    }
+    notify() {
+        this.waiter?.resolve();
+        this.waiter = null;
+    }
+    wait() {
+        if (this.done || this.released) return Promise.resolve();
+        if (!this.waiter) {
+            let resolve;
+            const promise = new Promise((res)=>{
+                resolve = res;
+            });
+            this.waiter = {
+                promise,
+                resolve
+            };
+        }
+        return this.waiter.promise;
+    }
+    release() {
+        if (this.released) return;
+        this.released = true;
+        this.chunks = [];
+        this.detachAbortListener();
+        try {
+            this.reader?.cancel(new Error('ReplayableStream released'));
+        } catch  {}
+        this.notify();
+    }
+    isReleased() {
+        return this.released;
+    }
+    createReplayStream() {
+        if (this.released) return new ReadableStream({
+            start (controller) {
+                controller.close();
+            }
+        });
+        let index = 0;
+        return new ReadableStream({
+            pull: async (controller)=>{
+                while(true){
+                    if (index < this.chunks.length) return void controller.enqueue(this.chunks[index++]);
+                    if (this.error) return void controller.error(this.error);
+                    if (this.done || this.released) return void controller.close();
+                    await this.wait();
+                }
+            },
+            cancel: ()=>{}
+        });
+    }
+    constructor(source, options = {}){
+        this.source = source;
+        this.options = options;
+        this[_REPLAYABLE_STREAM_MARKER] = true;
+        this.chunks = [];
+        this.done = false;
+        this.waiter = null;
+        this.released = false;
+        this.reader = null;
+        this.abortListener = null;
+        this.start();
+    }
+}
+_REPLAYABLE_STREAM_MARKER = REPLAYABLE_STREAM_MARKER;
+var _REPLAYABLE_STREAM_MARKER;
+exports.REPLAYABLE_STREAM_MARKER = __webpack_exports__.REPLAYABLE_STREAM_MARKER;
+exports.ReplayableStream = __webpack_exports__.ReplayableStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "REPLAYABLE_STREAM_MARKER",
+    "ReplayableStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/RscNodeRenderer.js

@@ -0,0 +1,65 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    RscNodeRenderer: ()=>RscNodeRenderer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const external_symbols_js_namespaceObject = require("./symbols.js");
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function RscNodeRenderInner({ data }) {
+    const getTree = data[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE];
+    if (!getTree) throw new Error('Renderable RSC is missing its decoded tree getter.');
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
+        children: selectTreePath(getTree(), data[external_symbols_js_namespaceObject.RSC_PROXY_PATH] || [])
+    });
+}
+function RscNodeRenderer({ data }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyFallback, {}),
+        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RscNodeRenderInner, {
+            data: data
+        })
+    });
+}
+exports.RscNodeRenderer = __webpack_exports__.RscNodeRenderer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RscNodeRenderer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/SlotContext.js

@@ -0,0 +1,54 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    SlotProvider: ()=>SlotProvider,
+    useSlotContext: ()=>useSlotContext
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const SlotContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+function useSlotContext() {
+    return (0, external_react_namespaceObject.use)(SlotContext);
+}
+function SlotProvider({ children, implementations, strict }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SlotContext, {
+        value: {
+            implementations,
+            strict: true === strict
+        },
+        children: children
+    });
+}
+exports.SlotProvider = __webpack_exports__.SlotProvider;
+exports.useSlotContext = __webpack_exports__.useSlotContext;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SlotProvider",
+    "useSlotContext"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/client.js

@@ -0,0 +1,93 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    CompositeComponent: ()=>external_CompositeComponent_js_namespaceObject.CompositeComponent,
+    getTanstackRscSerializationAdapters: ()=>getTanstackRscSerializationAdapters,
+    rscSerializationAdapter: ()=>rscSerializationAdapter
+});
+const react_router_namespaceObject = require("@tanstack/react-router");
+const external_react_namespaceObject = require("react");
+const external_CompositeComponent_js_namespaceObject = require("./CompositeComponent.js");
+const external_createRscProxy_js_namespaceObject = require("./createRscProxy.js");
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+function createTreeGetter(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = loadModernRscClientRuntime().then((runtime)=>runtime.createFromReadableStream(stream, {
+            callServer: runtime.callServer
+        })).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return (0, external_react_namespaceObject.use)(treePromise);
+    };
+}
+function createFromFlightStream(serialized) {
+    const streamWrapper = {
+        createReplayStream: ()=>serialized.stream
+    };
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(serialized.stream), {
+        renderable: 'renderable' === serialized.kind,
+        slotUsagesStream: serialized.slotUsagesStream,
+        stream: streamWrapper
+    });
+}
+const adapter = (0, react_router_namespaceObject.createSerializationAdapter)({
+    key: '$MODERN_TANSTACK_RSC',
+    test: (_value)=>false,
+    toSerializable: ()=>{
+        throw new Error('TanStack RSC data cannot be serialized on client.');
+    },
+    fromSerializable: (value)=>createFromFlightStream(value)
+});
+function getTanstackRscSerializationAdapters() {
+    return [
+        adapter
+    ];
+}
+const rscSerializationAdapter = getTanstackRscSerializationAdapters;
+exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.getTanstackRscSerializationAdapters = __webpack_exports__.getTanstackRscSerializationAdapters;
+exports.rscSerializationAdapter = __webpack_exports__.rscSerializationAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CompositeComponent",
+    "getTanstackRscSerializationAdapters",
+    "rscSerializationAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/createRscProxy.js

@@ -0,0 +1,141 @@
+"use strict";
+"use client";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    createRscProxy: ()=>createRscProxy
+});
+const external_react_namespaceObject = require("react");
+const external_RscNodeRenderer_js_namespaceObject = require("./RscNodeRenderer.js");
+const external_symbols_js_namespaceObject = require("./symbols.js");
+const UNHANDLED = Symbol('modern.tanstack.rsc.unhandled');
+function handleProxyTrap(kind, prop, options) {
+    switch(prop){
+        case '__SEROVAL_STREAM__':
+        case '__SEROVAL_SEQUENCE__':
+        case Symbol.iterator:
+        case Symbol.asyncIterator:
+            return 'get' === kind ? void 0 : false;
+        case external_symbols_js_namespaceObject.SERVER_COMPONENT_STREAM:
+            return 'get' === kind ? options.stream : Boolean(options.stream);
+        case external_symbols_js_namespaceObject.RENDERABLE_RSC:
+            return 'get' === kind ? options.renderable : true;
+        case external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE:
+            return 'get' === kind ? options.getTree : true;
+        case external_symbols_js_namespaceObject.RSC_PROXY_PATH:
+            return 'get' === kind ? options.path : true;
+        case external_symbols_js_namespaceObject.RSC_SLOT_USAGES_STREAM:
+            return 'get' === kind ? options.slotUsagesStream : Boolean(options.slotUsagesStream);
+        case external_symbols_js_namespaceObject.RSC_SLOT_USAGES:
+            return 'get' === kind ? options.slotUsages : Boolean(options.slotUsages);
+        case 'then':
+            return 'get' === kind ? void 0 : UNHANDLED;
+        case 'toString':
+            return 'get' === kind ? Object.prototype.toString : UNHANDLED;
+        case 'valueOf':
+            return 'get' === kind ? Object.prototype.valueOf : UNHANDLED;
+        case 'constructor':
+            return 'get' === kind ? Object : UNHANDLED;
+        default:
+            return UNHANDLED;
+    }
+}
+function createRscProxyInternal(options) {
+    const childCache = new Map();
+    const dataProxy = options.renderable ? createRscProxyInternal({
+        ...options,
+        renderable: false
+    }) : void 0;
+    const target = options.renderable ? /*#__PURE__*/ (0, external_react_namespaceObject.createElement)(external_RscNodeRenderer_js_namespaceObject.RscNodeRenderer, {
+        data: dataProxy
+    }) : {};
+    const getChild = (key)=>{
+        if (!childCache.has(key)) childCache.set(key, createRscProxyInternal({
+            ...options,
+            path: [
+                ...options.path,
+                key
+            ]
+        }));
+        return childCache.get(key);
+    };
+    return new Proxy(target, {
+        get (proxyTarget, prop) {
+            const handled = handleProxyTrap('get', prop, options);
+            if (handled !== UNHANDLED) return handled;
+            if (options.renderable) {
+                if ('props' === prop) return proxyTarget.props;
+                if ('data' === prop) return dataProxy;
+                if (prop in proxyTarget) return proxyTarget[prop];
+            }
+            if ('symbol' == typeof prop) return;
+            return getChild(prop);
+        },
+        getOwnPropertyDescriptor (proxyTarget, prop) {
+            return options.renderable ? Object.getOwnPropertyDescriptor(proxyTarget, prop) : void 0;
+        },
+        getPrototypeOf (proxyTarget) {
+            return options.renderable ? Object.getPrototypeOf(proxyTarget) : Object.prototype;
+        },
+        has (proxyTarget, prop) {
+            const handled = handleProxyTrap('has', prop, options);
+            if (handled !== UNHANDLED) return Boolean(handled);
+            if (options.renderable) return prop in proxyTarget || 'string' == typeof prop;
+            return 'string' == typeof prop;
+        },
+        ownKeys (proxyTarget) {
+            return options.renderable ? Reflect.ownKeys(proxyTarget) : [];
+        }
+    });
+}
+function createRscProxy(getTree, options = {}) {
+    const slotUsages = 'development' === process.env.NODE_ENV && options.slotUsagesStream ? options.slotUsages ?? [] : options.slotUsages;
+    if ('development' === process.env.NODE_ENV && options.slotUsagesStream && slotUsages) consumeSlotUsages(options.slotUsagesStream, slotUsages);
+    return createRscProxyInternal({
+        getTree,
+        path: [],
+        renderable: true === options.renderable,
+        slotUsages,
+        slotUsagesStream: options.slotUsagesStream,
+        stream: options.stream
+    });
+}
+async function consumeSlotUsages(stream, slotUsages) {
+    try {
+        const reader = stream.getReader();
+        for(;;){
+            const { value, done } = await reader.read();
+            if (done) break;
+            if (value?.slot) slotUsages.push(value);
+        }
+    } catch  {}
+}
+exports.createRscProxy = __webpack_exports__.createRscProxy;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRscProxy"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/rsc/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __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__, {
+    CompositeComponent: ()=>external_client_js_namespaceObject.CompositeComponent,
+    getTanstackRscSerializationAdapters: ()=>external_client_js_namespaceObject.getTanstackRscSerializationAdapters,
+    rscSerializationAdapter: ()=>external_client_js_namespaceObject.rscSerializationAdapter
+});
+const external_client_js_namespaceObject = require("./client.js");
+exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.getTanstackRscSerializationAdapters = __webpack_exports__.getTanstackRscSerializationAdapters;
+exports.rscSerializationAdapter = __webpack_exports__.rscSerializationAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CompositeComponent",
+    "getTanstackRscSerializationAdapters",
+    "rscSerializationAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});