@modern-js/runtime 2.22.1 → 2.22.2-alpha.1

package/dist/js/treeshaking/ssr/utils.js

@@ -0,0 +1,134 @@
+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 _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 _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+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 isReact18 = function() {
+    return process.env.IS_REACT18 === "true";
+};
+var formatServer = function(request) {
+    var _ref = request.headers || {}, _ref_cookie = _ref.cookie, cookie = _ref_cookie === void 0 ? "" : _ref_cookie, tmp = _ref["user-agent"], userAgent = tmp === void 0 ? "" : tmp, referer = _ref.referer;
+    return _objectSpread({
+        cookie: cookie,
+        userAgent: userAgent,
+        referer: referer
+    }, request);
+};
+var getQuery = function() {
+    return window.location.search.substring(1).split("&").reduce(function(res, item) {
+        var _item_split = _slicedToArray(item.split("="), 2), key = _item_split[0], value = _item_split[1];
+        if (key) {
+            res[key] = value;
+        }
+        return res;
+    }, {});
+};
+var formatClient = function(request) {
+    var _request_headers, _request_headers1;
+    return {
+        params: request.params || {},
+        host: request.host || location.host,
+        pathname: request.pathname || location.pathname,
+        headers: request.headers || {},
+        cookieMap: request.cookieMap || {},
+        cookie: ((_request_headers = request.headers) === null || _request_headers === void 0 ? void 0 : _request_headers.cookie) || document.cookie,
+        userAgent: ((_request_headers1 = request.headers) === null || _request_headers1 === void 0 ? void 0 : _request_headers1["user-agent"]) || navigator.userAgent,
+        referer: request.referer || document.referrer,
+        query: request.query || getQuery(),
+        url: location.href
+    };
+};
+var mockResponse = function() {
+    return {
+        setHeader: function setHeader() {
+            console.warn("response.setHeader() can only be used in the server side");
+        },
+        status: function status() {
+            console.warn("response.status() can only be used in the server side");
+        },
+        get locals () {
+            console.warn("response.locals can only be used in the server side");
+            return {};
+        }
+    };
+};
+var isCrossOrigin = function() {
+    var url = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "", base = arguments.length > 1 ? arguments[1] : void 0;
+    if (url.startsWith("/") || url.startsWith("./")) {
+        return false;
+    } else if (!url.includes(base)) {
+        return true;
+    } else {
+        return false;
+    }
+};
+export { formatClient, formatServer, isCrossOrigin, isReact18, mockResponse };

package/dist/js/treeshaking/state/cli/index.js

@@ -0,0 +1,71 @@
+import { getEntryOptions, createRuntimeExportsUtils, PLUGIN_SCHEMAS } from "@modern-js/utils";
+var PLUGIN_IDENTIFIER = "state";
+var cli_default = function() {
+    return {
+        name: "@modern-js/plugin-state",
+        required: [
+            "@modern-js/runtime"
+        ],
+        setup: function(api) {
+            var stateConfigMap = /* @__PURE__ */ new Map();
+            var pluginsExportsUtils;
+            return {
+                config: function config() {
+                    var appContext = api.useAppContext();
+                    pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
+                    return {
+                        source: {
+                            alias: {
+                                "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
+                            }
+                        }
+                    };
+                },
+                modifyEntryImports: function modifyEntryImports(param) {
+                    var entrypoint = param.entrypoint, imports = param.imports;
+                    var _getEntryOptions;
+                    var entryName = entrypoint.entryName;
+                    var userConfig = api.useResolvedConfigContext();
+                    var packageName = api.useAppContext().packageName;
+                    var stateConfig = (_getEntryOptions = getEntryOptions(entryName, userConfig.runtime, userConfig.runtimeByEntries, packageName)) === null || _getEntryOptions === void 0 ? void 0 : _getEntryOptions.state;
+                    stateConfigMap.set(entryName, stateConfig);
+                    if (stateConfig) {
+                        imports.push({
+                            value: "@modern-js/runtime/plugins",
+                            specifiers: [
+                                {
+                                    imported: PLUGIN_IDENTIFIER
+                                }
+                            ]
+                        });
+                    }
+                    return {
+                        entrypoint: entrypoint,
+                        imports: imports
+                    };
+                },
+                modifyEntryRuntimePlugins: function modifyEntryRuntimePlugins(param) {
+                    var entrypoint = param.entrypoint, plugins = param.plugins;
+                    var stateOptions = stateConfigMap.get(entrypoint.entryName);
+                    if (stateOptions) {
+                        plugins.push({
+                            name: PLUGIN_IDENTIFIER,
+                            options: "".concat(JSON.stringify(stateConfigMap.get(entrypoint.entryName)))
+                        });
+                    }
+                    return {
+                        entrypoint: entrypoint,
+                        plugins: plugins
+                    };
+                },
+                validateSchema: function validateSchema() {
+                    return PLUGIN_SCHEMAS["@modern-js/plugin-state"];
+                },
+                addRuntimeExports: function addRuntimeExports() {
+                    pluginsExportsUtils.addExport("export { default as state } from '@modern-js/runtime/model'");
+                }
+            };
+        }
+    };
+};
+export { cli_default as default };

package/dist/js/treeshaking/state/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./runtime";
+import { default as default3 } from "./runtime";
+export * from "./runtime";
+export { default3 as default, default2 as state };

package/dist/js/treeshaking/state/plugins.js

@@ -0,0 +1,14 @@
+import { plugin as effectsPlugin } from "@modern-js-reduck/plugin-effects";
+import autoActionsPlugin from "@modern-js-reduck/plugin-auto-actions";
+import immerPlugin from "@modern-js-reduck/plugin-immutable";
+import { default as default2 } from "@modern-js-reduck/plugin-devtools";
+var effects = function() {
+    return effectsPlugin;
+};
+var immer = function() {
+    return immerPlugin;
+};
+var autoActions = function() {
+    return autoActionsPlugin;
+};
+export { autoActions, default2 as devtools, effects, immer };

package/dist/js/treeshaking/state/runtime/index.js

@@ -0,0 +1,5 @@
+export * from "@modern-js-reduck/react";
+import { model, createStore } from "@modern-js-reduck/store";
+import { default as default2 } from "./plugin";
+export * from "./plugin";
+export { createStore, default2 as default, model };

package/dist/js/treeshaking/state/runtime/plugin.js

@@ -0,0 +1,198 @@
+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 _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 _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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);
+}
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import { createStore } from "@modern-js-reduck/store";
+import { Provider } from "@modern-js-reduck/react";
+import hoistNonReactStatics from "hoist-non-react-statics";
+import { immer, effects, autoActions, devtools } from "../plugins";
+import { RuntimeReactContext } from "../../core";
+import { isBrowser } from "../../common";
+var StatePluginHandleMap = {
+    immer: immer,
+    effects: effects,
+    autoActions: autoActions,
+    devtools: devtools
+};
+var getStoreConfig = function(config) {
+    var internalPlugins = [
+        "immer",
+        "effects",
+        "autoActions",
+        "devtools"
+    ];
+    var plugins = [];
+    internalPlugins.filter(function(plugin) {
+        return config[plugin] !== false;
+    }).forEach(function(plugin) {
+        return plugins.push(StatePluginHandleMap[plugin](config[plugin]));
+    });
+    var storeConfig = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(config)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _slicedToArray(_step.value, 2), key = _step_value[0], value = _step_value[1];
+            if (!internalPlugins.includes(key)) {
+                storeConfig[key] = value;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    storeConfig.plugins = plugins;
+    return storeConfig;
+};
+var state = function(config) {
+    return {
+        name: "@modern-js/plugin-state",
+        setup: function() {
+            var storeConfig = getStoreConfig(config);
+            return {
+                hoc: function hoc(param, next) {
+                    var App = param.App;
+                    var getStateApp = function(props) {
+                        var context = useContext(RuntimeReactContext);
+                        return /* @__PURE__ */ jsx(Provider, {
+                            store: context.store,
+                            config: storeConfig,
+                            children: /* @__PURE__ */ jsx(App, _objectSpread({}, props))
+                        });
+                    };
+                    return next({
+                        App: hoistNonReactStatics(getStateApp, App)
+                    });
+                },
+                init: function init(param, next) {
+                    var context = param.context;
+                    if (isBrowser()) {
+                        var _window__SSR_DATA, _window__SSR_DATA_data;
+                        storeConfig.initialState = storeConfig.initialState || (window === null || window === void 0 ? void 0 : (_window__SSR_DATA = window._SSR_DATA) === null || _window__SSR_DATA === void 0 ? void 0 : (_window__SSR_DATA_data = _window__SSR_DATA.data) === null || _window__SSR_DATA_data === void 0 ? void 0 : _window__SSR_DATA_data.storeState) || {};
+                    }
+                    context.store = createStore(storeConfig);
+                    return next({
+                        context: context
+                    });
+                },
+                pickContext: function pickContext(param, next) {
+                    var context = param.context, pickedContext = param.pickedContext;
+                    return next({
+                        context: context,
+                        pickedContext: _objectSpreadProps(_objectSpread({}, pickedContext), {
+                            store: context.store
+                        })
+                    });
+                }
+            };
+        }
+    };
+};
+var plugin_default = state;
+export * from "../plugins";
+export { plugin_default as default };

package/dist/js/treeshaking/state/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/document/constants.d.ts

@@ -1,7 +1,6 @@
 export declare const DOC_EXT: string[];
 export declare const DOCUMENT_META_PLACEHOLDER: string;
 export declare const HTML_SEPARATOR = "<!--<?- html ?>-->";
-export declare const HTML_CHUNKSMAP_SEPARATOR = "<!--<?- chunksMap.js ?>-->";
 export declare const HTML_SSRDATASCRIPT_SEPARATOR = "<!--<?- SSRDataScript ?>-->";
 export declare const DOCUMENT_SSR_PLACEHOLDER: string;
 export declare const DOCUMENT_CHUNKSMAP_PLACEHOLDER: string;

package/dist/types/runtimeContext.d.ts

@@ -13,6 +13,14 @@ export interface BaseRuntimeContext {
   store?: Store;
   routeManifest: RouteManifest;
   routerContext?: StaticHandlerContext;
+  /**
+   * private method
+   */
+  remixRouter?: Router;
+  /**
+   * private
+   */
+  unstable_getBlockNavState?: () => boolean;
 }
 export interface RuntimeContext extends BaseRuntimeContext {
   [key: string]: any;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.22.1",
+  "version": "2.22.2-alpha.1",
   "engines": {
     "node": ">=14.17.6"
   },
@@ -194,15 +194,16 @@
     "webpack": "^5.82.1",
     "@modern-js/app-tools": "2.22.1",
     "@modern-js/core": "2.22.1",
-    "@modern-js/server-core": "2.22.1",
     "@scripts/build": "2.22.1",
+    "@modern-js/server-core": "2.22.1",
     "@scripts/jest-config": "2.22.1"
   },
   "sideEffects": false,
   "modernConfig": {},
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "dev": "modern-lib build --watch",