@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/esm/core/server/string/ssrData.mjs

@@ -0,0 +1,117 @@
+import { serializeJson } from "@modern-js/runtime-utils/node";
+import { getRouterHydrationScripts } from "../../../router/runtime/lifecycle.mjs";
+import { ROUTER_DATA_JSON_ID, SSR_DATA_JSON_ID } from "../../constants.mjs";
+import { attributesToString, serializeErrors } from "../utils.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var _options = /*#__PURE__*/ new WeakMap(), _getSSRData = /*#__PURE__*/ new WeakSet(), _getRouterData = /*#__PURE__*/ new WeakSet(), _getSSRDataScripts = /*#__PURE__*/ new WeakSet();
+class SSRDataCollector {
+    effect() {
+        const { chunkSet } = _class_private_field_get(this, _options);
+        const ssrData = _class_private_method_get(this, _getSSRData, getSSRData).call(this);
+        const routerData = _class_private_method_get(this, _getRouterData, getRouterData).call(this);
+        const ssrDataScripts = _class_private_method_get(this, _getSSRDataScripts, getSSRDataScripts).call(this, ssrData, routerData);
+        chunkSet.ssrScripts = ssrDataScripts;
+    }
+    constructor(options){
+        _class_private_method_init(this, _getSSRData);
+        _class_private_method_init(this, _getRouterData);
+        _class_private_method_init(this, _getSSRDataScripts);
+        _class_private_field_init(this, _options, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _options, options);
+    }
+}
+function getSSRData() {
+    const { chunkSet, ssrConfig, ssrContext, runtimeContext } = _class_private_field_get(this, _options);
+    const { reporter, request } = ssrContext;
+    const headers = 'object' == typeof ssrConfig && ssrConfig.unsafeHeaders ? Object.fromEntries(Object.entries(request.headers).filter(([key, _])=>ssrConfig.unsafeHeaders?.map((header)=>header.toLowerCase())?.includes(key.toLowerCase()))) : void 0;
+    return {
+        data: {
+            initialData: runtimeContext.initialData,
+            i18nData: runtimeContext.__i18nData__
+        },
+        context: {
+            request: {
+                params: request.params,
+                query: request.query,
+                pathname: request.pathname,
+                host: request.host,
+                url: request.url,
+                headers: headers
+            },
+            reporter: {
+                sessionId: reporter?.sessionId
+            }
+        },
+        mode: 'string',
+        renderLevel: chunkSet.renderLevel
+    };
+}
+function getRouterData() {
+    const { routerContext, runtimeContext } = _class_private_field_get(this, _options);
+    const snapshotRouterData = runtimeContext.routerServerSnapshot?.routerData;
+    if (snapshotRouterData) return {
+        loaderData: snapshotRouterData.loaderData,
+        errors: serializeErrors(snapshotRouterData.errors || null)
+    };
+    return routerContext ? {
+        loaderData: routerContext.loaderData,
+        errors: serializeErrors(routerContext.errors)
+    } : void 0;
+}
+function getSSRDataScripts(ssrData, routerData) {
+    const { nonce, useJsonScript = false } = _class_private_field_get(this, _options);
+    const hydrationScripts = getRouterHydrationScripts(_class_private_field_get(this, _options).runtimeContext);
+    const serializeSSRData = serializeJson(ssrData);
+    const attrsStr = attributesToString({
+        nonce
+    });
+    let ssrDataScripts = useJsonScript ? `<script type="application/json" id="${SSR_DATA_JSON_ID}">${serializeSSRData}</script>` : `<script${attrsStr}>window._SSR_DATA = ${serializeSSRData}</script>`;
+    if (routerData) {
+        const serializedRouterData = serializeJson(routerData);
+        ssrDataScripts += useJsonScript ? `\n<script type="application/json" id="${ROUTER_DATA_JSON_ID}">${serializedRouterData}</script>` : `\n<script${attrsStr}>window._ROUTER_DATA = ${serializedRouterData}</script>`;
+    }
+    if (hydrationScripts.length) ssrDataScripts += `\n${hydrationScripts.join('\n')}`;
+    return ssrDataScripts;
+}
+export { SSRDataCollector };

package/dist/esm/core/server/tracer.mjs

@@ -0,0 +1,15 @@
+var tracer_SSRTimings = /*#__PURE__*/ function(SSRTimings) {
+    SSRTimings["PRERENDER"] = "ssr-prerender";
+    SSRTimings["RENDER_HTML"] = "ssr-render-html";
+    SSRTimings["RENDER_SHELL"] = "ssr-render-shell";
+    return SSRTimings;
+}({});
+var tracer_SSRErrors = /*#__PURE__*/ function(SSRErrors) {
+    SSRErrors["PRERENDER"] = "App Prerender";
+    SSRErrors["RENDER_HTML"] = "App Render To HTML";
+    SSRErrors["RENDER_STREAM"] = "An error occurs during streaming SSR";
+    SSRErrors["RENDER_SHELL"] = "An error occurs during streaming render shell";
+    SSRErrors["LOADER_ERROR"] = "App error occurs during data loader";
+    return SSRErrors;
+}({});
+export { tracer_SSRErrors as SSRErrors, tracer_SSRTimings as SSRTimings };

package/dist/esm/core/server/utils.mjs

@@ -0,0 +1,39 @@
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+function attributesToString(attributes) {
+    return Object.entries(attributes).reduce((str, [key, value])=>void 0 === value ? str : `${str} ${key}="${value}"`, '');
+}
+function safeReplace(source, searchValue, replaceValue) {
+    return source.replace(searchValue, ()=>replaceValue);
+}
+function checkIsNode() {
+    return "u" > typeof process && process.release?.name === 'node';
+}
+function serializeErrors(errors) {
+    if (!errors) return null;
+    const entries = Object.entries(errors);
+    const serialized = {};
+    for (const [key, val] of entries)if (isRouteErrorResponse(val)) serialized[key] = {
+        ...val,
+        __type: 'RouteErrorResponse'
+    };
+    else if (val instanceof Error) serialized[key] = {
+        message: val.message,
+        stack: val.stack,
+        __type: 'Error'
+    };
+    else serialized[key] = val;
+    return serialized;
+}
+function getSSRConfigByEntry(entryName, ssr, ssrByEntries) {
+    if (ssrByEntries?.[entryName]) return ssrByEntries[entryName];
+    return ssr || true;
+}
+function getSSRMode(ssrConfig) {
+    if ('boolean' == typeof ssrConfig) {
+        const result = ssrConfig ? 'stream' : false;
+        return result;
+    }
+    const result = ssrConfig?.mode === 'string' ? 'string' : 'stream';
+    return result;
+}
+export { attributesToString, checkIsNode, getSSRConfigByEntry, getSSRMode, safeReplace, serializeErrors };

package/dist/esm/document/Body.mjs

@@ -0,0 +1,20 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { BODY_PARTICALS_SEPARATOR, DOCUMENT_CHUNKSMAP_PLACEHOLDER, DOCUMENT_SSRDATASCRIPT_PLACEHOLDER } from "./constants.mjs";
+import { DocumentStructureContext } from "./DocumentStructureContext.mjs";
+import { DefaultRoot } from "./Root.mjs";
+function Body(props) {
+    const { hasSetRoot } = useContext(DocumentStructureContext);
+    const { children, ...rest } = props;
+    return /*#__PURE__*/ jsxs("body", {
+        ...rest,
+        children: [
+            hasSetRoot ? null : /*#__PURE__*/ jsx(DefaultRoot, {}),
+            children,
+            `${BODY_PARTICALS_SEPARATOR}`,
+            `${DOCUMENT_CHUNKSMAP_PLACEHOLDER}`,
+            `${DOCUMENT_SSRDATASCRIPT_PLACEHOLDER}`
+        ]
+    });
+}
+export { Body };

package/dist/esm/document/Comment.mjs

@@ -0,0 +1,15 @@
+import { Fragment, jsxs } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_COMMENT_PLACEHOLDER_END, DOCUMENT_COMMENT_PLACEHOLDER_START } from "./constants.mjs";
+function Comment(props) {
+    const { comment, children } = props;
+    const commentStr = encodeURIComponent(children || comment || '');
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_COMMENT_PLACEHOLDER_START}`,
+            `${commentStr}`,
+            `${DOCUMENT_COMMENT_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Comment };

package/dist/esm/document/DocumentContext.mjs

@@ -0,0 +1,7 @@
+import react from "react";
+const DocumentContext = /*#__PURE__*/ react.createContext({
+    config: {},
+    templateParams: {},
+    processEnv: {}
+});
+export { DocumentContext };

package/dist/esm/document/DocumentStructureContext.mjs

@@ -0,0 +1,10 @@
+import react from "react";
+const DocumentStructureContext = /*#__PURE__*/ react.createContext({
+    hasSetHead: false,
+    hasSetScripts: false,
+    hasSetBody: false,
+    hasSetRoot: false,
+    hasSetLinks: false,
+    hasSetTitle: false
+});
+export { DocumentStructureContext };

package/dist/esm/document/Head.mjs

@@ -0,0 +1,29 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { DOCUMENT_META_PLACEHOLDER, HEAD_PARTICALS_SEPARATOR, TOP_PARTICALS_SEPARATOR } from "./constants.mjs";
+import { DocumentStructureContext } from "./DocumentStructureContext.mjs";
+import { Links } from "./Links.mjs";
+import { Scripts } from "./Scripts.mjs";
+import { Title } from "./Title.mjs";
+function Head(props) {
+    const { hasSetScripts, hasSetLinks, hasSetTitle } = useContext(DocumentStructureContext);
+    const { children, ...rest } = props;
+    return /*#__PURE__*/ jsxs("head", {
+        ...rest,
+        children: [
+            TOP_PARTICALS_SEPARATOR,
+            DOCUMENT_META_PLACEHOLDER,
+            !hasSetTitle && /*#__PURE__*/ jsx(Title, {}),
+            !hasSetLinks && /*#__PURE__*/ jsx(Links, {}),
+            !hasSetScripts && /*#__PURE__*/ jsx(Scripts, {}),
+            HEAD_PARTICALS_SEPARATOR,
+            children
+        ]
+    });
+}
+function DefaultHead() {
+    return /*#__PURE__*/ jsx("head", {
+        children: DOCUMENT_META_PLACEHOLDER
+    });
+}
+export { DefaultHead, Head };

package/dist/esm/document/Html.mjs

@@ -0,0 +1,86 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { Body } from "./Body.mjs";
+import { DocumentStructureContext } from "./DocumentStructureContext.mjs";
+import { Head } from "./Head.mjs";
+import { Links } from "./Links.mjs";
+import { Root } from "./Root.mjs";
+import { Scripts } from "./Scripts.mjs";
+function findTargetChildByName(tag, children) {
+    return children.find((item)=>getEleType(item) === tag);
+}
+function findTargetChildByComponent(component, children) {
+    return children.find((item)=>item?.type === component);
+}
+function findTargetElementByComponent(component, children) {
+    if (0 === children.length) return null;
+    let nextChildren = [];
+    for (const item of children){
+        if (item?.type === component) return item;
+        if (item?.props?.children) nextChildren = nextChildren.concat(item.props.children);
+    }
+    return findTargetElementByComponent(component, nextChildren);
+}
+function getEleType(ele) {
+    return 'function' == typeof ele?.type ? ele.type.name : ele?.type;
+}
+function findTargetElement(tag, children) {
+    if (0 === children.length) return null;
+    let nextChildren = [];
+    for (const item of children){
+        if (tag === getEleType(item)) return item;
+        if (item?.props?.children) nextChildren = nextChildren.concat(item.props.children);
+    }
+    return findTargetElement(tag, nextChildren);
+}
+function Html(props) {
+    const { children, ...rest } = props;
+    const hasSetHead = Boolean(findTargetChildByComponent(Head, children) || findTargetChildByName('Head', children));
+    const hasSetScripts = Boolean(findTargetElementByComponent(Scripts, children) || findTargetChildByName('Scripts', children));
+    const hasSetLinks = Boolean(findTargetElementByComponent(Links, children) || findTargetChildByName('Links', children));
+    const hasSetBody = Boolean(findTargetElementByComponent(Body, children) || findTargetChildByName('Body', children));
+    const hasSetRoot = Boolean(findTargetElementByComponent(Root, children) || findTargetChildByName('Root', children));
+    const hasSetTitle = Boolean(findTargetElement('title', children));
+    const notMissMustChild = [
+        hasSetHead,
+        hasSetBody
+    ].every((item)=>item);
+    if (!notMissMustChild) return /*#__PURE__*/ jsx("html", {
+        children: /*#__PURE__*/ jsxs("body", {
+            style: {
+                color: 'red'
+            },
+            children: [
+                "Miss the ",
+                [
+                    hasSetHead,
+                    hasSetBody
+                ].map((item, index)=>item ? null : [
+                        'Head',
+                        'Body'
+                    ][index]),
+                " Element"
+            ]
+        })
+    });
+    return /*#__PURE__*/ jsx("html", {
+        ...rest,
+        children: /*#__PURE__*/ jsxs(DocumentStructureContext.Provider, {
+            value: {
+                hasSetHead,
+                hasSetScripts,
+                hasSetLinks,
+                hasSetRoot,
+                hasSetBody,
+                hasSetTitle,
+                docChild: children
+            },
+            children: [
+                !hasSetHead && /*#__PURE__*/ jsx(Head, {}),
+                !hasSetBody && /*#__PURE__*/ jsx(Body, {}),
+                children
+            ]
+        })
+    });
+}
+export { Html };

package/dist/esm/document/Links.mjs

@@ -0,0 +1,9 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_LINKS_PLACEHOLDER } from "./constants.mjs";
+function Links() {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: DOCUMENT_LINKS_PLACEHOLDER
+    });
+}
+export { Links };

package/dist/esm/document/Root.mjs

@@ -0,0 +1,29 @@
+import { jsxs } from "react/jsx-runtime";
+import { omit } from "@modern-js/utils/lodash";
+import { useContext } from "react";
+import { DOCUMENT_SSR_PLACEHOLDER } from "./constants.mjs";
+import { DocumentContext } from "./DocumentContext.mjs";
+function Root(props) {
+    const { rootId, children, ...rest } = props;
+    const legalProperties = omit(rest, 'id');
+    const { templateParams: { mountId = 'root' } } = useContext(DocumentContext);
+    return /*#__PURE__*/ jsxs("div", {
+        id: `${rootId || mountId}`,
+        ...legalProperties,
+        children: [
+            `${DOCUMENT_SSR_PLACEHOLDER}`,
+            children
+        ]
+    });
+}
+function DefaultRoot(props) {
+    const { templateParams: { mountId = 'root' } } = useContext(DocumentContext);
+    return /*#__PURE__*/ jsxs("div", {
+        id: `${mountId}`,
+        children: [
+            `${DOCUMENT_SSR_PLACEHOLDER}`,
+            props.children
+        ]
+    });
+}
+export { DefaultRoot, Root };

package/dist/esm/document/Script.mjs

@@ -0,0 +1,21 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { renderToString } from "react-dom/server";
+import { DOCUMENT_SCRIPT_ATTRIBUTES_END, DOCUMENT_SCRIPT_ATTRIBUTES_START, DOCUMENT_SCRIPT_PLACEHOLDER_END, DOCUMENT_SCRIPT_PLACEHOLDER_START } from "./constants.mjs";
+function Script(props) {
+    const { content, ...rests } = props;
+    const contentStr = content?.toString();
+    const contentIIFE = contentStr?.length ? encodeURIComponent(`(${contentStr})()`) : '';
+    const scriptProperties = renderToString(/*#__PURE__*/ jsx("script", {
+        ...rests
+    }));
+    const scriptpPropertiesStr = encodeURIComponent(scriptProperties.replace("<script ", '').replace("><\/script>", ''));
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_START}`,
+            `${DOCUMENT_SCRIPT_ATTRIBUTES_START}${scriptpPropertiesStr}${DOCUMENT_SCRIPT_ATTRIBUTES_END}`,
+            `${contentIIFE}`,
+            `${DOCUMENT_SCRIPT_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Script };

package/dist/esm/document/Scripts.mjs

@@ -0,0 +1,9 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_SCRIPTS_PLACEHOLDER } from "./constants.mjs";
+function Scripts() {
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: `${DOCUMENT_SCRIPTS_PLACEHOLDER}`
+    });
+}
+export { Scripts };

package/dist/esm/document/Style.mjs

@@ -0,0 +1,16 @@
+import { Fragment, jsxs } from "react/jsx-runtime";
+import "react";
+import { DOCUMENT_STYLE_PLACEHOLDER_END, DOCUMENT_STYLE_PLACEHOLDER_START } from "./constants.mjs";
+function Style(props) {
+    const { content, children } = props;
+    const contentStr = children || content;
+    const styleContent = encodeURIComponent(`${contentStr}`);
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            `${DOCUMENT_STYLE_PLACEHOLDER_START}`,
+            `${styleContent}`,
+            `${DOCUMENT_STYLE_PLACEHOLDER_END}`
+        ]
+    });
+}
+export { Style };

package/dist/esm/document/Title.mjs

@@ -0,0 +1,8 @@
+import { jsx } from "react/jsx-runtime";
+import { DOCUMENT_TITLE_PLACEHOLDER } from "./constants.mjs";
+function Title() {
+    return /*#__PURE__*/ jsx("title", {
+        children: DOCUMENT_TITLE_PLACEHOLDER
+    });
+}
+export { Title };