@modern-js/runtime 2.15.0 → 2.15.1-alpha.1

package/dist/js/modern/core/loader/loaderManager.js

@@ -0,0 +1,165 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import invariant from "invariant";
+const createGetId = () => {
+  const idCache = /* @__PURE__ */ new Map();
+  return (objectId) => {
+    const cachedId = idCache.get(objectId);
+    if (cachedId) {
+      return cachedId;
+    }
+    const id = JSON.stringify(objectId);
+    invariant(id, "params should be not null value");
+    idCache.set(objectId, id);
+    return id;
+  };
+};
+var LoaderStatus = /* @__PURE__ */ ((LoaderStatus2) => {
+  LoaderStatus2[LoaderStatus2["idle"] = 0] = "idle";
+  LoaderStatus2[LoaderStatus2["loading"] = 1] = "loading";
+  LoaderStatus2[LoaderStatus2["fulfilled"] = 2] = "fulfilled";
+  LoaderStatus2[LoaderStatus2["rejected"] = 3] = "rejected";
+  return LoaderStatus2;
+})(LoaderStatus || {});
+const createLoader = (id, initialData = {
+  loading: false,
+  reloading: false,
+  data: void 0,
+  error: void 0
+}, loaderFn, skip = false) => {
+  let promise;
+  let status = 0 /* idle */;
+  let { data, error } = initialData;
+  let hasLoaded = false;
+  const handlers = /* @__PURE__ */ new Set();
+  const load = () => __async(void 0, null, function* () {
+    if (skip) {
+      return promise;
+    }
+    if (status === 1 /* loading */) {
+      return promise;
+    }
+    status = 1 /* loading */;
+    notify();
+    promise = loaderFn().then((value) => {
+      data = value;
+      error = null;
+      status = 2 /* fulfilled */;
+    }).catch((e) => {
+      error = e;
+      data = null;
+      status = 3 /* rejected */;
+    }).finally(() => {
+      promise = null;
+      hasLoaded = true;
+      notify();
+    });
+    return promise;
+  });
+  const getResult = () => ({
+    loading: !hasLoaded && status === 1 /* loading */,
+    reloading: hasLoaded && status === 1 /* loading */,
+    data,
+    error: error instanceof Error ? `${error.message}` : error,
+    _error: error
+  });
+  const notify = () => {
+    [...handlers].forEach((handler) => {
+      handler(status, getResult());
+    });
+  };
+  const onChange = (handler) => {
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  };
+  return {
+    get result() {
+      return getResult();
+    },
+    get promise() {
+      return promise;
+    },
+    onChange,
+    load
+  };
+};
+const createLoaderManager = (initialDataMap, managerOptions = {}) => {
+  const { skipStatic = false, skipNonStatic = false } = managerOptions;
+  const loadersMap = /* @__PURE__ */ new Map();
+  const getId = createGetId();
+  const add = (loaderFn, loaderOptions) => {
+    const id = getId(loaderOptions.params);
+    let loader = loadersMap.get(id);
+    const cache = loaderOptions._cache;
+    if (!loader || cache === false) {
+      const ignoreNonStatic = skipNonStatic && !loaderOptions.static;
+      const ignoreStatic = skipStatic && loaderOptions.static;
+      const skipExec = ignoreNonStatic || ignoreStatic;
+      loader = createLoader(
+        id,
+        typeof initialDataMap[id] !== "undefined" ? initialDataMap[id] : { data: loaderOptions.initialData },
+        loaderFn,
+        skipExec
+      );
+      loadersMap.set(id, loader);
+    }
+    return id;
+  };
+  const get = (id) => loadersMap.get(id);
+  const hasPendingLoaders = () => {
+    for (const loader of loadersMap.values()) {
+      const { promise } = loader;
+      if (promise instanceof Promise) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const awaitPendingLoaders = () => __async(void 0, null, function* () {
+    const pendingLoaders = [];
+    for (const [id, loader] of loadersMap) {
+      const { promise } = loader;
+      if (promise instanceof Promise) {
+        pendingLoaders.push([id, loader]);
+      }
+    }
+    yield Promise.all(pendingLoaders.map((item) => item[1].promise));
+    return pendingLoaders.reduce(
+      (res, [id, loader]) => {
+        res[id] = loader.result;
+        return res;
+      },
+      {}
+    );
+  });
+  return {
+    hasPendingLoaders,
+    awaitPendingLoaders,
+    add,
+    get
+  };
+};
+export {
+  LoaderStatus,
+  createLoaderManager
+};

package/dist/js/modern/core/loader/useLoader.js

@@ -0,0 +1,114 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import {
+  useContext,
+  useRef,
+  useMemo,
+  useState,
+  useCallback,
+  useEffect
+} from "react";
+import invariant from "invariant";
+import { RuntimeReactContext } from "../../runtime-context";
+import { LoaderStatus } from "./loaderManager";
+const useLoader = (loaderFn, options = { params: void 0 }) => {
+  const context = useContext(RuntimeReactContext);
+  const isSSRRender = Boolean(context.ssr);
+  const { loaderManager } = context;
+  const loaderRef = useRef();
+  const unlistenLoaderChangeRef = useRef(null);
+  if (isSSRRender && Object.prototype.hasOwnProperty.call(options, "_cache")) {
+    delete options._cache;
+  }
+  const load = useCallback(
+    (params) => {
+      var _a, _b, _c, _d, _e, _f;
+      if (typeof params === "undefined") {
+        return (_a = loaderRef.current) == null ? void 0 : _a.load();
+      }
+      const id = loaderManager.add(
+        () => {
+          try {
+            const res2 = loaderFn(context, params);
+            if (res2 instanceof Promise) {
+              return res2;
+            }
+            return Promise.resolve(res2);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        },
+        __spreadProps(__spreadValues({}, options), {
+          params
+        })
+      );
+      loaderRef.current = loaderManager.get(id);
+      (_b = unlistenLoaderChangeRef.current) == null ? void 0 : _b.call(unlistenLoaderChangeRef);
+      if (isSSRRender) {
+        return void 0;
+      }
+      if (options.skip) {
+        return void 0;
+      }
+      if (context._hydration && ((_e = (_d = (_c = window == null ? void 0 : window._SSR_DATA) == null ? void 0 : _c.data) == null ? void 0 : _d.loadersData[id]) == null ? void 0 : _e.error) === null) {
+        return void 0;
+      }
+      const res = loaderRef.current.load();
+      unlistenLoaderChangeRef.current = (_f = loaderRef.current) == null ? void 0 : _f.onChange(
+        (_status, _result) => {
+          var _a2, _b2;
+          setResult(_result);
+          if (_status === LoaderStatus.fulfilled) {
+            (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, _result.data);
+          }
+          if (_status === LoaderStatus.rejected) {
+            (_b2 = options == null ? void 0 : options.onError) == null ? void 0 : _b2.call(options, _result.error);
+          }
+        }
+      );
+      return res;
+    },
+    [options.skip]
+  );
+  useEffect(
+    () => () => {
+      var _a;
+      (_a = unlistenLoaderChangeRef.current) == null ? void 0 : _a.call(unlistenLoaderChangeRef);
+    },
+    []
+  );
+  useMemo(() => {
+    var _a;
+    const p = (_a = options.params) != null ? _a : loaderFn.id;
+    invariant(
+      typeof p !== "undefined" && p !== null,
+      "Params is required in useLoader"
+    );
+    load(p);
+  }, [options.params]);
+  const [result, setResult] = useState(loaderRef.current.result);
+  return __spreadProps(__spreadValues({}, result), {
+    reload: load
+  });
+};
+var useLoader_default = useLoader;
+export {
+  useLoader_default as default
+};

package/dist/js/modern/core/plugin.js

@@ -0,0 +1,58 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import {
+  createManager,
+  createPipeline,
+  createAsyncPipeline
+} from "@modern-js/plugin";
+import { createLoaderManager } from "./loader/loaderManager";
+const hoc = createPipeline();
+const provide = createPipeline();
+const client = createAsyncPipeline();
+const server = createAsyncPipeline();
+const init = createAsyncPipeline();
+const pickContext = createPipeline();
+const runtimeHooks = {
+  hoc,
+  provide,
+  client,
+  server,
+  init,
+  pickContext
+};
+const createRuntime = () => createManager(runtimeHooks);
+const registerInit = (App, _init) => {
+  const originalInit = App.init;
+  App.init = (context) => __async(void 0, null, function* () {
+    if (!context.loaderManager) {
+      context.loaderManager = createLoaderManager({});
+    }
+    yield Promise.all([originalInit == null ? void 0 : originalInit(context), _init == null ? void 0 : _init(context)]);
+  });
+};
+const runtime = createRuntime();
+const { createPlugin } = runtime;
+export {
+  createPlugin,
+  createRuntime,
+  registerInit,
+  runtime
+};

package/dist/js/modern/document/Body.js

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

package/dist/js/modern/document/DocumentContext.js

@@ -0,0 +1,9 @@
+import React from "react";
+const DocumentContext = React.createContext({
+  config: {},
+  templateParams: {},
+  processEnv: {}
+});
+export {
+  DocumentContext
+};

package/dist/js/modern/document/DocumentStructrueContext.js

@@ -0,0 +1,11 @@
+import React from "react";
+const DocumentStructrueContext = React.createContext({
+  hasSetHead: false,
+  hasSetScripts: false,
+  hasSetBody: false,
+  hasSetRoot: false,
+  hasSetLinks: false
+});
+export {
+  DocumentStructrueContext
+};

package/dist/js/modern/document/Head.js

@@ -0,0 +1,27 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { DocumentStructrueContext } from "./DocumentStructrueContext";
+import { Scripts } from "./Scripts";
+import { Links } from "./Links";
+import { DOCUMENT_META_PLACEHOLDER } from "./constants";
+function Head(props) {
+  const { hasSetScripts, hasSetLinks } = useContext(DocumentStructrueContext);
+  const { children } = props;
+  return /* @__PURE__ */ jsxs("head", {
+    children: [
+      `${DOCUMENT_META_PLACEHOLDER}`,
+      !hasSetLinks && /* @__PURE__ */ jsx(Links, {}),
+      !hasSetScripts && /* @__PURE__ */ jsx(Scripts, {}),
+      children
+    ]
+  });
+}
+function DefaultHead() {
+  return /* @__PURE__ */ jsx("head", {
+    children: `${DOCUMENT_META_PLACEHOLDER}`
+  });
+}
+export {
+  DefaultHead,
+  Head
+};

package/dist/js/modern/document/Html.js

@@ -0,0 +1,78 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Body } from "./Body";
+import { DocumentStructrueContext } from "./DocumentStructrueContext";
+import { Head } from "./Head";
+function findTargetChild(tag, children) {
+  return children.find((item) => getEleType(item) === tag);
+}
+function getEleType(ele) {
+  return typeof (ele == null ? void 0 : ele.type) === "function" ? ele.type.name : ele == null ? void 0 : ele.type;
+}
+function findTargetElement(tag, children) {
+  var _a;
+  if (children.length === 0) {
+    return null;
+  }
+  let nextChildren = [];
+  for (const item of children) {
+    if (tag === getEleType(item)) {
+      return item;
+    }
+    if ((_a = item == null ? void 0 : item.props) == null ? void 0 : _a.children) {
+      nextChildren = nextChildren.concat(item.props.children);
+    }
+  }
+  return findTargetElement(tag, nextChildren);
+}
+function Html(props) {
+  const { children } = props;
+  const hasSetHead = Boolean(findTargetChild("Head", children));
+  const hasSetScripts = Boolean(findTargetElement("Scripts", children));
+  const hasSetLinks = Boolean(findTargetElement("Links", children));
+  const hasSetBody = Boolean(findTargetChild("Body", children));
+  const hasSetRoot = Boolean(findTargetElement("Root", 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) => {
+            return item ? null : [
+              "Head",
+              "Body"
+            ][index];
+          }),
+          ` Element`
+        ]
+      })
+    });
+  }
+  return /* @__PURE__ */ jsx("html", {
+    children: /* @__PURE__ */ jsxs(DocumentStructrueContext.Provider, {
+      value: {
+        hasSetHead,
+        hasSetScripts,
+        hasSetLinks,
+        hasSetRoot,
+        hasSetBody,
+        docChild: children
+      },
+      children: [
+        !hasSetHead && /* @__PURE__ */ jsx(Head, {}),
+        !hasSetBody && /* @__PURE__ */ jsx(Body, {}),
+        children
+      ]
+    })
+  });
+}
+export {
+  Html
+};

package/dist/js/modern/document/Links.js

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

package/dist/js/modern/document/Root.js

@@ -0,0 +1,33 @@
+import { jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { DocumentContext } from "./DocumentContext";
+import { DOCUMENT_SSR_PLACEHOLDER } from "./constants";
+function Root(props) {
+  const { rootId, children } = props;
+  const {
+    templateParams: { mountId = "root" }
+  } = useContext(DocumentContext);
+  return /* @__PURE__ */ jsxs("div", {
+    id: `${rootId || mountId}`,
+    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/js/modern/document/Script.js

@@ -0,0 +1,20 @@
+import { Fragment, jsxs } from "react/jsx-runtime";
+import {
+  DOCUMENT_SCRIPT_PLACEHOLDER_START,
+  DOCUMENT_SCRIPT_PLACEHOLDER_END
+} from "./constants";
+function Script(props) {
+  const { content } = props;
+  const contentStr = content.toString();
+  const contentIIFE = encodeURIComponent(`(${contentStr})()`);
+  return /* @__PURE__ */ jsxs(Fragment, {
+    children: [
+      `${DOCUMENT_SCRIPT_PLACEHOLDER_START}`,
+      `${contentIIFE}`,
+      `${DOCUMENT_SCRIPT_PLACEHOLDER_END}`
+    ]
+  });
+}
+export {
+  Script
+};

package/dist/js/modern/document/Scripts.js

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