@modern-js/plugin-data-loader 2.69.4 → 3.0.0-alpha.0

package/dist/esm/cli/data.mjs

@@ -0,0 +1,111 @@
+import { AbortedDeferredError, DeferredData } from "@modern-js/runtime-utils/browser";
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+async function parseDeferredReadableStream(stream) {
+    if (!stream) throw new Error('parseDeferredReadableStream requires stream argument');
+    let deferredData;
+    const deferredResolvers = {};
+    try {
+        const sectionReader = readStreamSections(stream);
+        const initialSectionResult = await sectionReader.next();
+        const initialSection = initialSectionResult.value;
+        if (!initialSection) throw new Error('no critical data');
+        const criticalData = JSON.parse(initialSection);
+        if ('object' == typeof criticalData && null !== criticalData) {
+            for (const [eventKey, value] of Object.entries(criticalData))if ('string' == typeof value && value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
+                deferredData = deferredData || {};
+                deferredData[eventKey] = new Promise((resolve, reject)=>{
+                    deferredResolvers[eventKey] = {
+                        resolve: (value)=>{
+                            resolve(value);
+                            delete deferredResolvers[eventKey];
+                        },
+                        reject: (error)=>{
+                            reject(error);
+                            delete deferredResolvers[eventKey];
+                        }
+                    };
+                });
+            }
+        }
+        (async ()=>{
+            try {
+                for await (const section of sectionReader){
+                    const [event, ...sectionDataStrings] = section.split(':');
+                    const sectionDataString = sectionDataStrings.join(':');
+                    const data = JSON.parse(sectionDataString);
+                    if ('data' === event) {
+                        for (const [key, value] of Object.entries(data))if (deferredResolvers[key]) deferredResolvers[key].resolve(value);
+                    } else if ('error' === event) for (const [key, value] of Object.entries(data)){
+                        const err = new Error(value.message);
+                        err.stack = value.stack;
+                        if (deferredResolvers[key]) deferredResolvers[key].reject(err);
+                    }
+                }
+                for (const [key, resolver] of Object.entries(deferredResolvers))resolver.reject(new AbortedDeferredError(`Deferred ${key} will never resolved`));
+            } catch (error) {
+                for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+            }
+        })();
+        return new DeferredData({
+            ...criticalData,
+            ...deferredData
+        });
+    } catch (error) {
+        for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+        throw error;
+    }
+}
+async function* readStreamSections(stream) {
+    const reader = stream.getReader();
+    let buffer = [];
+    let sections = [];
+    let closed = false;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const readStreamSection = async ()=>{
+        if (sections.length > 0) return sections.shift();
+        while(!closed && 0 === sections.length){
+            const chunk = await reader.read();
+            if (chunk.done) {
+                closed = true;
+                break;
+            }
+            buffer.push(chunk.value);
+            try {
+                const bufferedString = decoder.decode(mergeArrays(...buffer));
+                const splitSections = bufferedString.split('\n\n');
+                if (splitSections.length >= 2) {
+                    sections.push(...splitSections.slice(0, -1));
+                    buffer = [
+                        encoder.encode(splitSections.slice(-1).join('\n\n'))
+                    ];
+                }
+                if (sections.length > 0) break;
+            } catch  {
+                continue;
+            }
+        }
+        if (sections.length > 0) return sections.shift();
+        if (buffer.length > 0) {
+            const bufferedString = decoder.decode(mergeArrays(...buffer));
+            sections = bufferedString.split('\n\n').filter((s)=>s);
+            buffer = [];
+        }
+        return sections.shift();
+    };
+    let section = await readStreamSection();
+    while(section){
+        yield section;
+        section = await readStreamSection();
+    }
+}
+function mergeArrays(...arrays) {
+    const out = new Uint8Array(arrays.reduce((total, arr)=>total + arr.length, 0));
+    let offset = 0;
+    for (const arr of arrays){
+        out.set(arr, offset);
+        offset += arr.length;
+    }
+    return out;
+}
+export { parseDeferredReadableStream };

package/dist/esm/cli/generateClient.mjs

@@ -0,0 +1,22 @@
+import path from "path";
+const generateClient = ({ inline, action, routeId })=>{
+    let requestCode = "";
+    const requestCreatorPath = path.join(__dirname, './createRequest').replace('/cjs/cli/', '/esm/cli/').replace(/\\/g, '/');
+    const importCode = `
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
+  `;
+    requestCode = inline ? action ? `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    ` : `
+      export const loader = createRequest('${routeId}');
+    ` : `
+    export default createRequest('${routeId}');
+  `;
+    const generatedCode = `
+    ${importCode}
+    ${requestCode}
+  `;
+    return generatedCode;
+};
+export { generateClient };

package/dist/esm/cli/loader.mjs

@@ -0,0 +1,34 @@
+import { promisify } from "util";
+import { logger } from "@modern-js/utils/logger";
+import { generateClient } from "./generateClient";
+async function loader(source) {
+    this.cacheable();
+    const target = this._compiler?.options.target;
+    const shouldSkip = (compileTarget)=>target === compileTarget || Array.isArray(target) && target.includes(compileTarget);
+    if (shouldSkip('node') || shouldSkip('webworker') || shouldSkip('async-node')) return source;
+    const { resourceQuery } = this;
+    const options = resourceQuery.slice(1).split('&').reduce((pre, cur)=>{
+        const [key, value] = cur.split('=');
+        if (key && value) pre[key] = 'true' === value ? true : 'false' === value ? false : value;
+        return pre;
+    }, {});
+    if (!options.loaderId || options.retain) return source;
+    if (options.clientData) {
+        const readFile = promisify(this.fs.readFile);
+        try {
+            const clientDataPath = this.resourcePath.includes('.loader.') ? this.resourcePath.replace('.loader.', '.data.client.') : this.resourcePath.replace('.data.', '.data.client.');
+            this.addDependency(clientDataPath);
+            const clientDataContent = await readFile(clientDataPath);
+            return clientDataContent;
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) logger.error(`Failed to read the clientData file ${options.clientData}`);
+        }
+    }
+    const code = generateClient({
+        inline: options.inline,
+        action: options.action,
+        routeId: options.routeId
+    });
+    return code;
+}
+export { loader as default };

package/dist/esm/common/constants.mjs

@@ -0,0 +1,4 @@
+const LOADER_ID_PARAM = '__loader';
+const DIRECT_PARAM = '__ssrDirect';
+const CONTENT_TYPE_DEFERRED = 'text/modernjs-deferred';
+export { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM };

package/dist/esm/runtime/errors.mjs

@@ -0,0 +1,52 @@
+import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+function sanitizeError(error) {
+    if (error instanceof Error && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV) {
+        const sanitized = new Error(error.message || 'Unexpected Server Error');
+        sanitized.stack = void 0;
+        return sanitized;
+    }
+    return error;
+}
+function sanitizeErrors(errors) {
+    return Object.entries(errors).reduce((acc, [routeId, error])=>Object.assign(acc, {
+            [routeId]: sanitizeError(error)
+        }), {});
+}
+function serializeError(error) {
+    const sanitized = sanitizeError(error);
+    return {
+        message: sanitized.message,
+        stack: sanitized.stack
+    };
+}
+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) {
+        const sanitized = sanitizeError(val);
+        serialized[key] = {
+            message: sanitized.message,
+            stack: sanitized.stack,
+            __type: 'Error',
+            ...'Error' !== sanitized.name ? {
+                __subType: sanitized.name
+            } : {}
+        };
+    } else serialized[key] = val;
+    return serialized;
+}
+function errorResponseToJson(errorResponse) {
+    return Response.json(serializeError(errorResponse.error || new Error('Unexpected Server Error')), {
+        status: errorResponse.status,
+        statusText: errorResponse.statusText,
+        headers: {
+            'X-Modernjs-Error': 'yes'
+        }
+    });
+}
+export { errorResponseToJson, sanitizeError, sanitizeErrors, serializeError, serializeErrors };

package/dist/esm/runtime/index.mjs

@@ -0,0 +1,114 @@
+import { transformNestedRoutes } from "@modern-js/runtime-utils/browser";
+import { createRequestContext, reporterCtx, storage } from "@modern-js/runtime-utils/node";
+import { DEFERRED_SYMBOL, createStaticHandler, isRouteErrorResponse } from "@modern-js/runtime-utils/router";
+import { matchEntry } from "@modern-js/runtime-utils/server";
+import { time } from "@modern-js/runtime-utils/time";
+import { parseHeaders } from "@modern-js/runtime-utils/universal/request";
+import { isPlainObject } from "@modern-js/utils/lodash";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { CONTENT_TYPE_DEFERRED, LOADER_ID_PARAM } from "../common/constants";
+import { errorResponseToJson, serializeError } from "./errors";
+import { createDeferredReadableStream } from "./response";
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function isRedirectResponse(status) {
+    return redirectStatusCodes.has(status);
+}
+function isResponse(value) {
+    return null != value && 'number' == typeof value.status && 'string' == typeof value.statusText && 'object' == typeof value.headers && void 0 !== value.body;
+}
+function convertModernRedirectResponse(headers, basename) {
+    const newHeaders = new Headers(headers);
+    let redirectUrl = headers.get('Location');
+    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '');
+    newHeaders.set('X-Modernjs-Redirect', redirectUrl);
+    newHeaders.delete('Location');
+    return new Response(null, {
+        status: 204,
+        headers: newHeaders
+    });
+}
+function hasFileExtension(pathname) {
+    const lastSegment = pathname.split('/').pop() || '';
+    const dotIndex = lastSegment.lastIndexOf('.');
+    if (-1 === dotIndex) return false;
+    const extension = lastSegment.substring(dotIndex).toLowerCase();
+    return '.html' !== extension;
+}
+const handleRequest = async ({ request, serverRoutes, routes: routesConfig, context, onTiming })=>{
+    const url = new URL(request.url);
+    const routeId = url.searchParams.get(LOADER_ID_PARAM);
+    if (hasFileExtension(url.pathname)) return;
+    const entry = matchEntry(url.pathname, serverRoutes);
+    if (!routeId || !entry) return;
+    const basename = entry.urlPath;
+    const end = time();
+    const { reporter, loaderContext, monitors } = context;
+    const headersData = parseHeaders(request);
+    const activeDeferreds = new Map();
+    return storage.run({
+        headers: headersData,
+        monitors,
+        request,
+        activeDeferreds
+    }, async ()=>{
+        const routes = transformNestedRoutes(routesConfig);
+        const { queryRoute } = createStaticHandler(routes, {
+            basename
+        });
+        const requestContext = createRequestContext(loaderContext);
+        requestContext.set(reporterCtx, reporter);
+        let response;
+        try {
+            response = await queryRoute(request, {
+                routeId,
+                requestContext
+            });
+            if (isResponse(response) && isRedirectResponse(response.status)) response = convertModernRedirectResponse(response.headers, basename);
+            else if (isPlainObject(response) && (DEFERRED_SYMBOL in response || activeDeferreds.get(routeId))) {
+                let deferredData;
+                deferredData = DEFERRED_SYMBOL in response ? response[DEFERRED_SYMBOL] : activeDeferreds.get(routeId);
+                const body = createDeferredReadableStream(deferredData, request.signal);
+                const init = deferredData.init || {};
+                if (init.status && isRedirectResponse(init.status)) {
+                    if (!init.headers) throw new Error('redirect response includes no headers');
+                    response = convertModernRedirectResponse(new Headers(init.headers), basename);
+                } else {
+                    const headers = new Headers(init.headers);
+                    headers.set('Content-Type', `${CONTENT_TYPE_DEFERRED}; charset=UTF-8`);
+                    init.headers = headers;
+                    response = new Response(body, init);
+                }
+            } else response = isResponse(response) ? response : new Response(JSON.stringify(response), {
+                headers: {
+                    'Content-Type': 'application/json; charset=utf-8'
+                }
+            });
+            const cost = end();
+            response.headers.set('X-Modernjs-Response', 'yes');
+            onTiming?.(`${LOADER_REPORTER_NAME}-navigation`, cost);
+        } catch (error) {
+            if (isResponse(error)) {
+                error.headers.set('X-Modernjs-Catch', 'yes');
+                response = error;
+            } else if (isRouteErrorResponse(error)) response = errorResponseToJson(error);
+            else {
+                const errorInstance = error instanceof Error || error instanceof DOMException ? error : new Error('Unexpected Server Error');
+                response = new Response(JSON.stringify(serializeError(errorInstance)), {
+                    status: 500,
+                    headers: {
+                        'X-Modernjs-Error': 'yes',
+                        'Content-Type': 'application/json'
+                    }
+                });
+            }
+        }
+        return response;
+    });
+};
+export { handleRequest, hasFileExtension, isRedirectResponse, isResponse };

package/dist/esm/runtime/response.mjs

@@ -0,0 +1,42 @@
+import { TextEncoder } from "util";
+import { serializeJson } from "@modern-js/runtime-utils/node";
+function isTrackedPromise(value) {
+    return null != value && 'function' == typeof value.then && true === value._tracked;
+}
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+function createDeferredReadableStream(deferredData, signal) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start (controller) {
+            const criticalData = {};
+            const preresolvedKeys = [];
+            for (const [key, value] of Object.entries(deferredData.data))if (isTrackedPromise(value)) {
+                criticalData[key] = `${DEFERRED_VALUE_PLACEHOLDER_PREFIX}${key}`;
+                if (void 0 !== value._data || void 0 !== value._error) preresolvedKeys.push(key);
+            } else criticalData[key] = value;
+            controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}\n\n`));
+            for (const preresolvedKey of preresolvedKeys)enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey]);
+            const unsubscribe = deferredData.subscribe((aborted, settledKey)=>{
+                if (settledKey) enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey]);
+            });
+            await deferredData.resolveData(signal);
+            unsubscribe();
+            controller.close();
+        }
+    });
+    return stream;
+}
+function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
+    if ('_error' in promise) {
+        const { _error } = promise;
+        controller.enqueue(encoder.encode(`error:${serializeJson({
+            [settledKey]: {
+                message: _error.message,
+                stack: _error.stack
+            }
+        })}\n\n`));
+    } else controller.enqueue(encoder.encode(`data:${JSON.stringify({
+        [settledKey]: promise._data ?? null
+    })}\n\n`));
+}
+export { createDeferredReadableStream };

package/dist/esm-node/cli/createRequest.mjs

@@ -0,0 +1,93 @@
+import { redirect } from "@modern-js/runtime-utils/router";
+import { compile } from "path-to-regexp";
+import { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM } from "../common/constants.mjs";
+import { parseDeferredReadableStream } from "./data.mjs";
+const getRequestUrl = ({ params, request, routeId })=>{
+    const url = new URL(request.url);
+    const toPath = compile(url.pathname, {
+        encode: encodeURIComponent
+    });
+    const newPathName = toPath(params);
+    url.pathname = newPathName;
+    url.searchParams.append(LOADER_ID_PARAM, routeId);
+    url.searchParams.append(DIRECT_PARAM, 'true');
+    return url;
+};
+const handleRedirectResponse = (res)=>{
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    if (location) throw redirect(location);
+    return res;
+};
+const isDeferredResponse = (res)=>res.headers.get('Content-Type')?.match(CONTENT_TYPE_DEFERRED) && res.body;
+const isRedirectResponse = (res)=>null != res.headers.get('X-Modernjs-Redirect');
+const isErrorResponse = (res)=>null != res.headers.get('X-Modernjs-Error');
+function isOtherErrorResponse(res) {
+    return res.status >= 400 && null == res.headers.get('X-Modernjs-Error') && null == res.headers.get('X-Modernjs-Catch') && null == res.headers.get('X-Modernjs-Response');
+}
+const isCatchResponse = (res)=>null != res.headers.get('X-Modernjs-Catch');
+const handleErrorResponse = async (res)=>{
+    const data = await res.json();
+    const error = new Error(data.message);
+    error.stack = data.stack;
+    throw error;
+};
+const handleNetworkErrorResponse = async (res)=>{
+    const text = await res.text();
+    const error = new Error(text);
+    error.stack = void 0;
+    throw error;
+};
+const createRequest = (routeId, method = 'get')=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        let res;
+        res = await fetch(url, {
+            method,
+            signal: request.signal
+        }).catch((error)=>{
+            throw error;
+        });
+        if (isRedirectResponse(res)) return handleRedirectResponse(res);
+        if (isErrorResponse(res)) return await handleErrorResponse(res);
+        if (isCatchResponse(res)) throw res;
+        if (isDeferredResponse(res)) {
+            const deferredData = await parseDeferredReadableStream(res.body);
+            return deferredData.data;
+        }
+        if (isOtherErrorResponse(res)) return await handleNetworkErrorResponse(res);
+        return res;
+    };
+const createActionRequest = (routeId)=>async ({ params, request })=>{
+        const url = getRequestUrl({
+            params,
+            request,
+            routeId
+        });
+        const init = {
+            signal: request.signal
+        };
+        if ('GET' !== request.method) {
+            init.method = request.method;
+            const contentType = request.headers.get('Content-Type');
+            if (contentType && /\bapplication\/json\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = JSON.stringify(await request.json());
+            } else if (contentType && /\btext\/plain\b/.test(contentType)) {
+                init.headers = {
+                    'Content-Type': contentType
+                };
+                init.body = await request.text();
+            } else if (contentType && /\bapplication\/x-www-form-urlencoded\b/.test(contentType)) init.body = new URLSearchParams(await request.text());
+            else init.body = await request.formData();
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) throw res;
+        return res;
+    };
+export { createActionRequest, createRequest, getRequestUrl };

package/dist/esm-node/cli/data.mjs

@@ -0,0 +1,111 @@
+import { AbortedDeferredError, DeferredData } from "@modern-js/runtime-utils/browser";
+const DEFERRED_VALUE_PLACEHOLDER_PREFIX = '__deferred_promise:';
+async function parseDeferredReadableStream(stream) {
+    if (!stream) throw new Error('parseDeferredReadableStream requires stream argument');
+    let deferredData;
+    const deferredResolvers = {};
+    try {
+        const sectionReader = readStreamSections(stream);
+        const initialSectionResult = await sectionReader.next();
+        const initialSection = initialSectionResult.value;
+        if (!initialSection) throw new Error('no critical data');
+        const criticalData = JSON.parse(initialSection);
+        if ('object' == typeof criticalData && null !== criticalData) {
+            for (const [eventKey, value] of Object.entries(criticalData))if ('string' == typeof value && value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
+                deferredData = deferredData || {};
+                deferredData[eventKey] = new Promise((resolve, reject)=>{
+                    deferredResolvers[eventKey] = {
+                        resolve: (value)=>{
+                            resolve(value);
+                            delete deferredResolvers[eventKey];
+                        },
+                        reject: (error)=>{
+                            reject(error);
+                            delete deferredResolvers[eventKey];
+                        }
+                    };
+                });
+            }
+        }
+        (async ()=>{
+            try {
+                for await (const section of sectionReader){
+                    const [event, ...sectionDataStrings] = section.split(':');
+                    const sectionDataString = sectionDataStrings.join(':');
+                    const data = JSON.parse(sectionDataString);
+                    if ('data' === event) {
+                        for (const [key, value] of Object.entries(data))if (deferredResolvers[key]) deferredResolvers[key].resolve(value);
+                    } else if ('error' === event) for (const [key, value] of Object.entries(data)){
+                        const err = new Error(value.message);
+                        err.stack = value.stack;
+                        if (deferredResolvers[key]) deferredResolvers[key].reject(err);
+                    }
+                }
+                for (const [key, resolver] of Object.entries(deferredResolvers))resolver.reject(new AbortedDeferredError(`Deferred ${key} will never resolved`));
+            } catch (error) {
+                for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+            }
+        })();
+        return new DeferredData({
+            ...criticalData,
+            ...deferredData
+        });
+    } catch (error) {
+        for (const resolver of Object.values(deferredResolvers))resolver.reject(error);
+        throw error;
+    }
+}
+async function* readStreamSections(stream) {
+    const reader = stream.getReader();
+    let buffer = [];
+    let sections = [];
+    let closed = false;
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    const readStreamSection = async ()=>{
+        if (sections.length > 0) return sections.shift();
+        while(!closed && 0 === sections.length){
+            const chunk = await reader.read();
+            if (chunk.done) {
+                closed = true;
+                break;
+            }
+            buffer.push(chunk.value);
+            try {
+                const bufferedString = decoder.decode(mergeArrays(...buffer));
+                const splitSections = bufferedString.split('\n\n');
+                if (splitSections.length >= 2) {
+                    sections.push(...splitSections.slice(0, -1));
+                    buffer = [
+                        encoder.encode(splitSections.slice(-1).join('\n\n'))
+                    ];
+                }
+                if (sections.length > 0) break;
+            } catch  {
+                continue;
+            }
+        }
+        if (sections.length > 0) return sections.shift();
+        if (buffer.length > 0) {
+            const bufferedString = decoder.decode(mergeArrays(...buffer));
+            sections = bufferedString.split('\n\n').filter((s)=>s);
+            buffer = [];
+        }
+        return sections.shift();
+    };
+    let section = await readStreamSection();
+    while(section){
+        yield section;
+        section = await readStreamSection();
+    }
+}
+function mergeArrays(...arrays) {
+    const out = new Uint8Array(arrays.reduce((total, arr)=>total + arr.length, 0));
+    let offset = 0;
+    for (const arr of arrays){
+        out.set(arr, offset);
+        offset += arr.length;
+    }
+    return out;
+}
+export { parseDeferredReadableStream };

package/dist/esm-node/cli/generateClient.mjs

@@ -0,0 +1,22 @@
+import path from "path";
+const generateClient = ({ inline, action, routeId })=>{
+    let requestCode = "";
+    const requestCreatorPath = path.join(__dirname, './createRequest').replace('/cjs/cli/', '/esm/cli/').replace(/\\/g, '/');
+    const importCode = `
+    import { createRequest, createActionRequest } from '${requestCreatorPath}';
+  `;
+    requestCode = inline ? action ? `
+      export const loader = createRequest('${routeId}');
+      export const action = createActionRequest('${routeId}')
+    ` : `
+      export const loader = createRequest('${routeId}');
+    ` : `
+    export default createRequest('${routeId}');
+  `;
+    const generatedCode = `
+    ${importCode}
+    ${requestCode}
+  `;
+    return generatedCode;
+};
+export { generateClient };

package/dist/esm-node/cli/loader.mjs

@@ -0,0 +1,34 @@
+import { promisify } from "util";
+import { logger } from "@modern-js/utils/logger";
+import { generateClient } from "./generateClient.mjs";
+async function loader(source) {
+    this.cacheable();
+    const target = this._compiler?.options.target;
+    const shouldSkip = (compileTarget)=>target === compileTarget || Array.isArray(target) && target.includes(compileTarget);
+    if (shouldSkip('node') || shouldSkip('webworker') || shouldSkip('async-node')) return source;
+    const { resourceQuery } = this;
+    const options = resourceQuery.slice(1).split('&').reduce((pre, cur)=>{
+        const [key, value] = cur.split('=');
+        if (key && value) pre[key] = 'true' === value ? true : 'false' === value ? false : value;
+        return pre;
+    }, {});
+    if (!options.loaderId || options.retain) return source;
+    if (options.clientData) {
+        const readFile = promisify(this.fs.readFile);
+        try {
+            const clientDataPath = this.resourcePath.includes('.loader.') ? this.resourcePath.replace('.loader.', '.data.client.') : this.resourcePath.replace('.data.', '.data.client.');
+            this.addDependency(clientDataPath);
+            const clientDataContent = await readFile(clientDataPath);
+            return clientDataContent;
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) logger.error(`Failed to read the clientData file ${options.clientData}`);
+        }
+    }
+    const code = generateClient({
+        inline: options.inline,
+        action: options.action,
+        routeId: options.routeId
+    });
+    return code;
+}
+export { loader as default };

package/dist/esm-node/common/constants.mjs

@@ -0,0 +1,4 @@
+const LOADER_ID_PARAM = '__loader';
+const DIRECT_PARAM = '__ssrDirect';
+const CONTENT_TYPE_DEFERRED = 'text/modernjs-deferred';
+export { CONTENT_TYPE_DEFERRED, DIRECT_PARAM, LOADER_ID_PARAM };