@modern-js/plugin-data-loader 2.5.0-alpha.0 → 2.5.1-alpha.0

package/dist/esm/runtime/response.js

@@ -1,284 +0,0 @@
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _asyncToGenerator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _defineProperty(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
-    }
-    return _arr;
-}
-function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-var __generator = this && this.__generator || function(thisArg, body) {
-    var f, y, t, g, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    };
-    return g = {
-        next: verb(0),
-        "throw": verb(1),
-        "return": verb(2)
-    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(_)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-};
-import { TextEncoder } from "util";
-import { serializeJson } from "@modern-js/utils";
-function isTrackedPromise(value) {
-    return value != null && typeof value.then === "function" && value._tracked === true;
-}
-var DEFERRED_VALUE_PLACEHOLDER_PREFIX = "__deferred_promise:";
-function createDeferredReadableStream(deferredData, signal) {
-    var encoder = new TextEncoder();
-    var stream = new ReadableStream({
-        start: function start(controller) {
-            return _asyncToGenerator(function() {
-                var criticalData, preresolvedKeys, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, preresolvedKey, unsubscribe;
-                return __generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            criticalData = {};
-                            preresolvedKeys = [];
-                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                            try {
-                                for(_iterator = Object.entries(deferredData.data)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                    _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], value = _step_value[1];
-                                    if (isTrackedPromise(value)) {
-                                        criticalData[key] = "".concat(DEFERRED_VALUE_PLACEHOLDER_PREFIX).concat(key);
-                                        if (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
-                                            preresolvedKeys.push(key);
-                                        }
-                                    } else {
-                                        criticalData[key] = value;
-                                    }
-                                }
-                            } catch (err) {
-                                _didIteratorError = true;
-                                _iteratorError = err;
-                            } finally{
-                                try {
-                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                        _iterator.return();
-                                    }
-                                } finally{
-                                    if (_didIteratorError) {
-                                        throw _iteratorError;
-                                    }
-                                }
-                            }
-                            controller.enqueue(encoder.encode("".concat(JSON.stringify(criticalData), "\n\n")));
-                            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                            try {
-                                for(_iterator1 = preresolvedKeys[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                                    preresolvedKey = _step1.value;
-                                    enqueueTrackedPromise(controller, encoder, preresolvedKey, deferredData.data[preresolvedKey]);
-                                }
-                            } catch (err) {
-                                _didIteratorError1 = true;
-                                _iteratorError1 = err;
-                            } finally{
-                                try {
-                                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                        _iterator1.return();
-                                    }
-                                } finally{
-                                    if (_didIteratorError1) {
-                                        throw _iteratorError1;
-                                    }
-                                }
-                            }
-                            unsubscribe = deferredData.subscribe(function(aborted, settledKey) {
-                                if (settledKey) {
-                                    enqueueTrackedPromise(controller, encoder, settledKey, deferredData.data[settledKey]);
-                                }
-                            });
-                            return [
-                                4,
-                                deferredData.resolveData(signal)
-                            ];
-                        case 1:
-                            _state.sent();
-                            unsubscribe();
-                            controller.close();
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        }
-    });
-    return stream;
-}
-function enqueueTrackedPromise(controller, encoder, settledKey, promise) {
-    if ("_error" in promise) {
-        var _error = promise._error;
-        controller.enqueue(encoder.encode("error:".concat(serializeJson(_defineProperty({}, settledKey, {
-            message: _error.message,
-            stack: _error.stack
-        })), "\n\n")));
-    } else {
-        var _promise__data;
-        controller.enqueue(encoder.encode("data:".concat(JSON.stringify(_defineProperty({}, settledKey, (_promise__data = promise._data) !== null && _promise__data !== void 0 ? _promise__data : null)), "\n\n")));
-    }
-}
-export { createDeferredReadableStream };

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

@@ -1,142 +0,0 @@
-import {
-  UNSAFE_DeferredData as DeferredData,
-  AbortedDeferredError
-} from "@modern-js/utils/remix-router";
-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 (typeof criticalData === "object" && criticalData !== null) {
-      for (const [eventKey, value] of Object.entries(criticalData)) {
-        if (typeof value !== "string" || !value.startsWith(DEFERRED_VALUE_PLACEHOLDER_PREFIX)) {
-          continue;
-        }
-        deferredData = deferredData || {};
-        deferredData[eventKey] = new Promise((resolve, reject) => {
-          deferredResolvers[eventKey] = {
-            resolve: (value2) => {
-              resolve(value2);
-              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 (event === "data") {
-            for (const [key, value] of Object.entries(data)) {
-              if (deferredResolvers[key]) {
-                deferredResolvers[key].resolve(value);
-              }
-            }
-          } else if (event === "error") {
-            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 && sections.length === 0) {
-      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/runtime/index.js

@@ -1,143 +0,0 @@
-import {
-  installGlobals,
-  writeReadableStreamToWritable,
-  Response as NodeResponse
-} from "@remix-run/node";
-import {
-  transformNestedRoutes
-} from "@modern-js/utils";
-import {
-  createStaticHandler,
-  ErrorResponse,
-  UNSAFE_DEFERRED_SYMBOL as DEFERRED_SYMBOL
-} from "@modern-js/utils/remix-router";
-import { LOADER_ID_PARAM } from "../common/constants";
-import { createDeferredReadableStream } from "./response";
-installGlobals();
-const redirectStatusCodes = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function isRedirectResponse(status) {
-  return redirectStatusCodes.has(status);
-}
-function isResponse(value) {
-  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
-}
-function convertModernRedirectResponse(headers) {
-  const newHeaders = new Headers(headers);
-  newHeaders.set("X-Modernjs-Redirect", headers.get("Location"));
-  newHeaders.delete("Location");
-  return new NodeResponse(null, {
-    status: 204,
-    headers: newHeaders
-  });
-}
-const createLoaderHeaders = (requestHeaders) => {
-  const headers = new Headers();
-  for (const [key, values] of Object.entries(requestHeaders)) {
-    if (values) {
-      if (Array.isArray(values)) {
-        for (const value of values) {
-          headers.append(key, value);
-        }
-      } else {
-        headers.set(key, values);
-      }
-    }
-  }
-  return headers;
-};
-const createLoaderRequest = (context) => {
-  const origin = `${context.protocol}://${context.host}`;
-  const url = new URL(context.url, origin);
-  const controller = new AbortController();
-  const init = {
-    method: context.method,
-    headers: createLoaderHeaders(context.headers),
-    signal: controller.signal
-  };
-  return new Request(url.href, init);
-};
-const sendLoaderResponse = async (res, nodeResponse) => {
-  res.statusMessage = nodeResponse.statusText;
-  res.statusCode = nodeResponse.status;
-  for (const [key, value] of nodeResponse.headers.entries()) {
-    res.setHeader(key, value);
-  }
-  if (nodeResponse.body) {
-    await writeReadableStreamToWritable(nodeResponse.body, res);
-  } else {
-    res.end();
-  }
-};
-const matchEntry = (pathname, entries) => {
-  return entries.find((entry) => pathname.startsWith(entry.urlPath));
-};
-const handleRequest = async ({
-  context,
-  serverRoutes,
-  routes
-}) => {
-  const { method, query } = context;
-  const routeId = query[LOADER_ID_PARAM];
-  if (!routeId) {
-    throw new Error(`Missing parameter: ${LOADER_ID_PARAM}`);
-  }
-  if (method.toLowerCase() !== "get") {
-    throw new Error("Only support httpp GET method");
-  }
-  const entry = matchEntry(context.path, serverRoutes);
-  if (!entry) {
-    throw new Error("Route is not matched");
-  }
-  const dataRoutes = transformNestedRoutes(routes);
-  const staticHandler = createStaticHandler(dataRoutes, {
-    basename: entry.urlPath
-  });
-  const { res } = context;
-  const request = createLoaderRequest(context);
-  let response;
-  try {
-    response = await staticHandler.queryRoute(request, {
-      routeId,
-      requestContext: context
-    });
-    if (isResponse(response) && isRedirectResponse(response.status)) {
-      response = convertModernRedirectResponse(response.headers);
-    } else if (DEFERRED_SYMBOL in response) {
-      const deferredData = response[DEFERRED_SYMBOL];
-      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));
-      } else {
-        const headers = new Headers(init.headers);
-        headers.set("Content-Type", "text/modernjs-deferred");
-        init.headers = headers;
-        response = new NodeResponse(body, init);
-      }
-    } else {
-      response = isResponse(response) ? response : new NodeResponse(JSON.stringify(response), {
-        headers: {
-          "Content-Type": "application/json; charset=utf-8"
-        }
-      });
-    }
-  } catch (error) {
-    const message = error instanceof ErrorResponse ? error.data : String(error);
-    response = new NodeResponse(message, {
-      status: 500,
-      headers: {
-        "Content-Type": "text/plain"
-      }
-    });
-  }
-  sendLoaderResponse(res, response);
-};
-export {
-  handleRequest,
-  isRedirectResponse,
-  isResponse,
-  matchEntry
-};

package/dist/esm-node/runtime/response.js

@@ -1,79 +0,0 @@
-import { TextEncoder } from "util";
-import { serializeJson } from "@modern-js/utils";
-function isTrackedPromise(value) {
-  return value != null && typeof value.then === "function" && value._tracked === true;
-}
-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 (typeof value._data !== "undefined" || typeof value._error !== "undefined") {
-            preresolvedKeys.push(key);
-          }
-        } else {
-          criticalData[key] = value;
-        }
-      }
-      controller.enqueue(encoder.encode(`${JSON.stringify(criticalData)}
-
-`));
-      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) {
-  var _a;
-  if ("_error" in promise) {
-    const { _error } = promise;
-    controller.enqueue(
-      encoder.encode(
-        `error:${serializeJson({
-          [settledKey]: {
-            message: _error.message,
-            stack: _error.stack
-          }
-        })}
-
-`
-      )
-    );
-  } else {
-    controller.enqueue(
-      encoder.encode(
-        `data:${JSON.stringify({ [settledKey]: (_a = promise._data) != null ? _a : null })}
-
-`
-      )
-    );
-  }
-}
-export {
-  createDeferredReadableStream
-};

package/dist/types/cli/data.d.ts

@@ -1,6 +0,0 @@
-/**
- * modified from https://github.com/remix-run/remix/blob/main/packages/remix-react/data.ts
- * license at https://github.com/remix-run/remix/blob/main/LICENSE.md
- */
-import { UNSAFE_DeferredData as DeferredData } from '@modern-js/utils/remix-router';
-export declare function parseDeferredReadableStream(stream: ReadableStream<Uint8Array>): Promise<DeferredData>;

package/dist/types/runtime/index.d.ts

@@ -1,15 +0,0 @@
-import type { ModernServerContext, NestedRoute, ServerRoute } from '@modern-js/types';
-import { Response as NodeResponse } from '@remix-run/node';
-export type ServerContext = Pick<ModernServerContext, 'req' | 'res' | 'params' | 'headers' | 'method' | 'url' | 'host' | 'protocol' | 'origin' | 'href' | 'path' | 'query'>;
-export declare function isRedirectResponse(status: number): boolean;
-export declare function isResponse(value: any): value is NodeResponse;
-export declare const matchEntry: (pathname: string, entries: ServerRoute[]) => ServerRoute | undefined;
-export declare const handleRequest: ({
-  context,
-  serverRoutes,
-  routes
-}: {
-  context: ServerContext;
-  serverRoutes: ServerRoute[];
-  routes: NestedRoute[];
-}) => Promise<void>;

package/dist/types/runtime/response.d.ts

@@ -1,2 +0,0 @@
-import { type UNSAFE_DeferredData as DeferredData } from '@modern-js/utils/remix-router';
-export declare function createDeferredReadableStream(deferredData: DeferredData, signal: AbortSignal): any;