@xfe-repo/web-register 1.0.0

package/README.md

@@ -0,0 +1,3 @@
+# `@xfe-repo/web-register`
+
+web register库

package/dist/index.d.mts

@@ -0,0 +1,62 @@
+import { ComponentType } from 'react';
+
+declare class ContextStorageClass<ExtendContext = null> implements ContextStorage<ExtendContext> {
+    constructor(context: RegisterContext<ExtendContext>);
+    private storage;
+    get context(): RegisterContext<ExtendContext>;
+}
+
+declare const createRegister: <ExtendConfig = null, ExtendContext = null, P = any>(options?: CreateOptions<ExtendConfig, ExtendContext, P> | undefined) => Register<ExtendConfig, ExtendContext, P>;
+declare const register: Register<null, null, any>;
+
+type CreateOptions<ExtendConfig = null, ExtendContext = null, P = any> = {
+    plugins?: RegisterPlugin<ExtendConfig, ExtendContext>[];
+    onError?: Function;
+    LoadFullback?: ComponentType<any> | null;
+    ErrorFullback?: ComponentType<any> | null;
+    renderTitle?: (name: string, context: RegisterContext<ExtendContext, P>) => string;
+};
+type ORegisterConfig = {
+    name: string;
+    onLoad?: (context: RegisterContext) => Promise<any>;
+    onLeave?: (context: ORegisterContext) => Promise<boolean>;
+};
+type ORegisterContext<P = {}, Q = {}, R = {}> = {
+    payload: Readonly<P>;
+    query: Q;
+    result?: R;
+    error?: Error;
+    isPreload?: boolean;
+};
+type RegisterConfig<ExtendConfig = null> = ExtendConfig extends null ? ORegisterConfig & CreateOptions : ORegisterConfig & CreateOptions & ExtendConfig;
+type RegisterContext<ExtendContext = null, P = any, Q = any, R = any> = ExtendContext extends null ? ORegisterContext<P, Q, R> : ORegisterContext<P, Q, R> & ExtendContext;
+type LoadParams<Q = any> = {
+    isPreload?: boolean;
+    query: Q;
+};
+type RegisterComponentStatic<ExtendContext = null, P = any> = {
+    config?: RegisterConfig;
+    emitOnLoad?: <Q, R>(params?: LoadParams<Q>) => Promise<RegisterContext<ExtendContext, P, Q, R>>;
+    emitOnLeave?: () => Promise<boolean>;
+};
+type RegisterComponentType<P = any> = ComponentType<P> & RegisterComponentStatic;
+type RegisterPlugin<ExtendConfig = null, ExtendContext = null> = {
+    registerHook?: (config: RegisterConfig<ExtendConfig>, WrappedComponent: RegisterComponentType) => ComponentType<any> | void;
+    loadHook?: (config: RegisterConfig<ExtendConfig>, context: RegisterContext<ExtendContext>) => Promise<any>;
+    leaveHook?: (config: RegisterConfig<ExtendConfig>, context: RegisterContext<ExtendContext>) => Promise<boolean>;
+};
+type ContextStorage<ExtendContext = null, P = any, Q = any, R = any> = {
+    context: RegisterContext<ExtendContext, P, Q, R>;
+};
+type SetContextStorage<ExtendContext = null, P = any> = <Q = any, R = any>(contextStorage: ContextStorage<ExtendContext, P, Q, R>) => void;
+type GetContext<ExtendContext = null, P = any> = <Q = any, R = any>() => RegisterContext<ExtendContext, P, Q, R>;
+interface Register<ExtendConfig = null, ExtendContext = null, P = any> {
+    (config: RegisterConfig<ExtendConfig>): (WrappedComponent: any) => any;
+    setContextStorage: SetContextStorage<ExtendContext, P>;
+    getContext: GetContext<ExtendContext, P>;
+}
+type WithRegisterContext<ExtendContext = null, P = any, Q = any, R = any> = {
+    context: RegisterContext<ExtendContext, P, Q, R>;
+};
+
+export { type ContextStorage, ContextStorageClass, type CreateOptions, type GetContext, type LoadParams, type ORegisterConfig, type ORegisterContext, type Register, type RegisterComponentStatic, type RegisterComponentType, type RegisterConfig, type RegisterContext, type RegisterPlugin, type SetContextStorage, type WithRegisterContext, createRegister, register as default };

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import { ComponentType } from 'react';
+
+declare class ContextStorageClass<ExtendContext = null> implements ContextStorage<ExtendContext> {
+    constructor(context: RegisterContext<ExtendContext>);
+    private storage;
+    get context(): RegisterContext<ExtendContext>;
+}
+
+declare const createRegister: <ExtendConfig = null, ExtendContext = null, P = any>(options?: CreateOptions<ExtendConfig, ExtendContext, P> | undefined) => Register<ExtendConfig, ExtendContext, P>;
+declare const register: Register<null, null, any>;
+
+type CreateOptions<ExtendConfig = null, ExtendContext = null, P = any> = {
+    plugins?: RegisterPlugin<ExtendConfig, ExtendContext>[];
+    onError?: Function;
+    LoadFullback?: ComponentType<any> | null;
+    ErrorFullback?: ComponentType<any> | null;
+    renderTitle?: (name: string, context: RegisterContext<ExtendContext, P>) => string;
+};
+type ORegisterConfig = {
+    name: string;
+    onLoad?: (context: RegisterContext) => Promise<any>;
+    onLeave?: (context: ORegisterContext) => Promise<boolean>;
+};
+type ORegisterContext<P = {}, Q = {}, R = {}> = {
+    payload: Readonly<P>;
+    query: Q;
+    result?: R;
+    error?: Error;
+    isPreload?: boolean;
+};
+type RegisterConfig<ExtendConfig = null> = ExtendConfig extends null ? ORegisterConfig & CreateOptions : ORegisterConfig & CreateOptions & ExtendConfig;
+type RegisterContext<ExtendContext = null, P = any, Q = any, R = any> = ExtendContext extends null ? ORegisterContext<P, Q, R> : ORegisterContext<P, Q, R> & ExtendContext;
+type LoadParams<Q = any> = {
+    isPreload?: boolean;
+    query: Q;
+};
+type RegisterComponentStatic<ExtendContext = null, P = any> = {
+    config?: RegisterConfig;
+    emitOnLoad?: <Q, R>(params?: LoadParams<Q>) => Promise<RegisterContext<ExtendContext, P, Q, R>>;
+    emitOnLeave?: () => Promise<boolean>;
+};
+type RegisterComponentType<P = any> = ComponentType<P> & RegisterComponentStatic;
+type RegisterPlugin<ExtendConfig = null, ExtendContext = null> = {
+    registerHook?: (config: RegisterConfig<ExtendConfig>, WrappedComponent: RegisterComponentType) => ComponentType<any> | void;
+    loadHook?: (config: RegisterConfig<ExtendConfig>, context: RegisterContext<ExtendContext>) => Promise<any>;
+    leaveHook?: (config: RegisterConfig<ExtendConfig>, context: RegisterContext<ExtendContext>) => Promise<boolean>;
+};
+type ContextStorage<ExtendContext = null, P = any, Q = any, R = any> = {
+    context: RegisterContext<ExtendContext, P, Q, R>;
+};
+type SetContextStorage<ExtendContext = null, P = any> = <Q = any, R = any>(contextStorage: ContextStorage<ExtendContext, P, Q, R>) => void;
+type GetContext<ExtendContext = null, P = any> = <Q = any, R = any>() => RegisterContext<ExtendContext, P, Q, R>;
+interface Register<ExtendConfig = null, ExtendContext = null, P = any> {
+    (config: RegisterConfig<ExtendConfig>): (WrappedComponent: any) => any;
+    setContextStorage: SetContextStorage<ExtendContext, P>;
+    getContext: GetContext<ExtendContext, P>;
+}
+type WithRegisterContext<ExtendContext = null, P = any, Q = any, R = any> = {
+    context: RegisterContext<ExtendContext, P, Q, R>;
+};
+
+export { type ContextStorage, ContextStorageClass, type CreateOptions, type GetContext, type LoadParams, type ORegisterConfig, type ORegisterContext, type Register, type RegisterComponentStatic, type RegisterComponentType, type RegisterConfig, type RegisterContext, type RegisterPlugin, type SetContextStorage, type WithRegisterContext, createRegister, register as default };

package/dist/index.js

@@ -0,0 +1,676 @@
+"use strict";
+function _array_like_to_array(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 _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(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 _async_to_generator(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 _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(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 _non_iterable_rest() {
+    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 _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(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) {
+            _define_property(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 _object_spread_props(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 _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(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 _array_like_to_array(o, minLen);
+}
+function _ts_generator(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
+        };
+    }
+}
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    ContextStorageClass: function() {
+        return ContextStorageClass;
+    },
+    createRegister: function() {
+        return createRegister;
+    },
+    default: function() {
+        return src_default;
+    }
+});
+module.exports = __toCommonJS(src_exports);
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+// src/Register.tsx
+var import_react = require("react");
+var import_react_helmet = require("react-helmet");
+var import_jsx_runtime = require("react/jsx-runtime");
+var createRegisterComponent = function(config, getContext, WrappedComponent) {
+    var RegisterComponent = (0, import_react.memo)(function(props) {
+        var context = getContext();
+        var isPreload = context.isPreload, query = context.query;
+        var name = config.name, ErrorFullback = config.ErrorFullback, LoadFullback = config.LoadFullback, renderTitle = config.renderTitle;
+        var _ref = _sliced_to_array((0, import_react.useState)(!isPreload), 2), needLoad = _ref[0], setNeedLoad = _ref[1];
+        var _ref1 = _sliced_to_array((0, import_react.useState)(), 2), loadError = _ref1[0], setLoadError = _ref1[1];
+        var isLeave = false;
+        var emitLoad = (0, import_react.useCallback)(/*#__PURE__*/ _async_to_generator(function() {
+            var _WrappedComponent_emitOnLoad, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!needLoad || loadError) return [
+                            2
+                        ];
+                        return [
+                            4,
+                            (_WrappedComponent_emitOnLoad = WrappedComponent.emitOnLoad) === null || _WrappedComponent_emitOnLoad === void 0 ? void 0 : _WrappedComponent_emitOnLoad.call(WrappedComponent, {
+                                query: query
+                            })
+                        ];
+                    case 1:
+                        error = (_state.sent() || {}).error;
+                        if (isLeave) return [
+                            2
+                        ];
+                        ErrorFullback && setLoadError(error);
+                        LoadFullback && setNeedLoad(false);
+                        return [
+                            2
+                        ];
+                }
+            });
+        }), [
+            needLoad,
+            loadError
+        ]);
+        void emitLoad();
+        if (isPreload) delete context.isPreload;
+        (0, import_react.useEffect)(function() {
+            return function() {
+                var _WrappedComponent_emitOnLeave;
+                isLeave = true;
+                (_WrappedComponent_emitOnLeave = WrappedComponent.emitOnLeave) === null || _WrappedComponent_emitOnLeave === void 0 ? void 0 : _WrappedComponent_emitOnLeave.call(WrappedComponent);
+            };
+        }, []);
+        var content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WrappedComponent, _object_spread_props(_object_spread({}, props), {
+            context: context
+        }));
+        if (loadError && ErrorFullback) content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ErrorFullback, {});
+        if (needLoad && LoadFullback) content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoadFullback, {});
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react.Fragment, {
+            children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_helmet.Helmet, {
+                    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("title", {
+                        children: (renderTitle === null || renderTitle === void 0 ? void 0 : renderTitle(name, context)) || name
+                    })
+                }),
+                content
+            ]
+        });
+    });
+    var componentName = WrappedComponent.displayName || WrappedComponent.name || "Component";
+    RegisterComponent.displayName = "Register(".concat(componentName, ")");
+    return RegisterComponent;
+};
+// src/contextStorage/client.ts
+var ContextStorageClass = /*#__PURE__*/ function() {
+    function ContextStorageClass(context) {
+        _class_call_check(this, ContextStorageClass);
+        this.storage = {
+            context: context
+        };
+    }
+    _create_class(ContextStorageClass, [
+        {
+            key: "context",
+            get: function get() {
+                var context = this.storage.context;
+                if (!context) throw new Error("Can not find context in ContextStorage");
+                return this.storage.context;
+            }
+        }
+    ]);
+    return ContextStorageClass;
+}();
+// src/index.ts
+var createRegister = function(options) {
+    var _contextStorage;
+    var _emitOnLoad = function() {
+        var _ref = _async_to_generator(function(config, getContext, params) {
+            var onLoad, onError, _config_plugins, plugins, context, finalResult, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, loadHook, result, err, result1, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        onLoad = config.onLoad, onError = config.onError, _config_plugins = config.plugins, plugins = _config_plugins === void 0 ? [] : _config_plugins;
+                        context = getContext();
+                        if (params === null || params === void 0 ? void 0 : params.isPreload) {
+                            context.isPreload = true;
+                        }
+                        context.query = (params === null || params === void 0 ? void 0 : params.query) || {};
+                        delete context.error;
+                        finalResult = {};
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            12,
+                            ,
+                            13
+                        ]);
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            7,
+                            8,
+                            9
+                        ]);
+                        _iterator = plugins[Symbol.iterator]();
+                        _state.label = 3;
+                    case 3:
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                            3,
+                            6
+                        ];
+                        loadHook = _step.value.loadHook;
+                        return [
+                            4,
+                            loadHook === null || loadHook === void 0 ? void 0 : loadHook(config, context)
+                        ];
+                    case 4:
+                        result = _state.sent();
+                        finalResult = _object_spread({}, finalResult, result);
+                        _state.label = 5;
+                    case 5:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            3
+                        ];
+                    case 6:
+                        return [
+                            3,
+                            9
+                        ];
+                    case 7:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            9
+                        ];
+                    case 8:
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                        return [
+                            7
+                        ];
+                    case 9:
+                        if (!onLoad) return [
+                            3,
+                            11
+                        ];
+                        return [
+                            4,
+                            onLoad(context)
+                        ];
+                    case 10:
+                        result1 = _state.sent();
+                        finalResult = _object_spread({}, finalResult, result1);
+                        _state.label = 11;
+                    case 11:
+                        context.result = finalResult;
+                        return [
+                            3,
+                            13
+                        ];
+                    case 12:
+                        e = _state.sent();
+                        context.error = _instanceof(e, Error) ? e : new Error("register onLoad error");
+                        onError ? onError(e) : console.error(e);
+                        return [
+                            3,
+                            13
+                        ];
+                    case 13:
+                        return [
+                            2,
+                            context
+                        ];
+                }
+            });
+        });
+        return function _emitOnLoad(config, getContext, params) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var _emitOnLeave = function() {
+        var _ref = _async_to_generator(function(config, getContext) {
+            var onLeave, onError, _config_plugins, plugins, context, canLeave, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, leaveHook, e;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        onLeave = config.onLeave, onError = config.onError, _config_plugins = config.plugins, plugins = _config_plugins === void 0 ? [] : _config_plugins;
+                        context = getContext();
+                        canLeave = true;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            4,
+                            ,
+                            5
+                        ]);
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = plugins[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                leaveHook = _step.value.leaveHook;
+                                canLeave = !!(leaveHook === null || leaveHook === void 0 ? void 0 : leaveHook(config, context));
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        if (!onLeave) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            onLeave(context)
+                        ];
+                    case 2:
+                        canLeave = _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            3,
+                            5
+                        ];
+                    case 4:
+                        e = _state.sent();
+                        onError ? onError(e) : console.error(e);
+                        return [
+                            3,
+                            5
+                        ];
+                    case 5:
+                        return [
+                            2,
+                            canLeave
+                        ];
+                }
+            });
+        });
+        return function _emitOnLeave(config, getContext) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var register2 = function(config) {
+        return function(WrappedComponent) {
+            var finalPlugin = _to_consumable_array((options === null || options === void 0 ? void 0 : options.plugins) || []).concat(_to_consumable_array((config === null || config === void 0 ? void 0 : config.plugins) || []));
+            config = _object_spread_props(_object_spread({}, options, config), {
+                plugins: finalPlugin
+            });
+            var TempRegisterComponent = WrappedComponent;
+            TempRegisterComponent.config = config;
+            TempRegisterComponent.emitOnLoad = function(params) {
+                return _emitOnLoad(config, register2.getContext, params);
+            };
+            TempRegisterComponent.emitOnLeave = function() {
+                return _emitOnLeave(config, register2.getContext);
+            };
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = finalPlugin[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var registerHook = _step.value.registerHook;
+                    if (!registerHook) continue;
+                    var ExtendWrappedComponent = registerHook(config, TempRegisterComponent);
+                    if (!ExtendWrappedComponent) continue;
+                    (0, import_hoist_non_react_statics.default)(ExtendWrappedComponent, TempRegisterComponent);
+                    TempRegisterComponent = ExtendWrappedComponent;
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            var FinalRegisterComponent = createRegisterComponent(config, register2.getContext, TempRegisterComponent);
+            (0, import_hoist_non_react_statics.default)(FinalRegisterComponent, TempRegisterComponent);
+            return FinalRegisterComponent;
+        };
+    };
+    register2.setContextStorage = function(contextStorage) {
+        _contextStorage = contextStorage;
+    };
+    register2.getContext = function() {
+        return _contextStorage.context;
+    };
+    return register2;
+};
+var register = createRegister();
+var src_default = register;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+    ContextStorageClass: ContextStorageClass,
+    createRegister: createRegister
+});

package/dist/index.mjs

@@ -0,0 +1,140 @@
+// src/index.ts
+import hoistNonReactStatic from "hoist-non-react-statics";
+
+// src/Register.tsx
+import { memo, Fragment, useEffect, useState, useCallback } from "react";
+import { Helmet } from "react-helmet";
+import { jsx, jsxs } from "react/jsx-runtime";
+var createRegisterComponent = (config, getContext, WrappedComponent) => {
+  const RegisterComponent = memo((props) => {
+    const context = getContext();
+    const { isPreload, query } = context;
+    const { name, ErrorFullback, LoadFullback, renderTitle } = config;
+    const [needLoad, setNeedLoad] = useState(!isPreload);
+    const [loadError, setLoadError] = useState();
+    let isLeave = false;
+    const emitLoad = useCallback(async () => {
+      if (!needLoad || loadError)
+        return;
+      const { error } = await WrappedComponent.emitOnLoad?.({ query }) || {};
+      if (isLeave)
+        return;
+      ErrorFullback && setLoadError(error);
+      LoadFullback && setNeedLoad(false);
+    }, [needLoad, loadError]);
+    void emitLoad();
+    if (isPreload)
+      delete context.isPreload;
+    useEffect(
+      () => () => {
+        isLeave = true;
+        WrappedComponent.emitOnLeave?.();
+      },
+      []
+    );
+    let content = /* @__PURE__ */ jsx(WrappedComponent, { ...props, context });
+    if (loadError && ErrorFullback)
+      content = /* @__PURE__ */ jsx(ErrorFullback, {});
+    if (needLoad && LoadFullback)
+      content = /* @__PURE__ */ jsx(LoadFullback, {});
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Helmet, { children: /* @__PURE__ */ jsx("title", { children: renderTitle?.(name, context) || name }) }),
+      content
+    ] });
+  });
+  const componentName = WrappedComponent.displayName || WrappedComponent.name || "Component";
+  RegisterComponent.displayName = `Register(${componentName})`;
+  return RegisterComponent;
+};
+
+// src/contextStorage/client.ts
+var ContextStorageClass = class {
+  constructor(context) {
+    this.storage = { context };
+  }
+  get context() {
+    const context = this.storage.context;
+    if (!context)
+      throw new Error("Can not find context in ContextStorage");
+    return this.storage.context;
+  }
+};
+
+// src/index.ts
+var createRegister = (options) => {
+  let _contextStorage;
+  const _emitOnLoad = async (config, getContext, params) => {
+    const { onLoad, onError, plugins = [] } = config;
+    const context = getContext();
+    if (params?.isPreload) {
+      context.isPreload = true;
+    }
+    context.query = params?.query || {};
+    delete context.error;
+    let finalResult = {};
+    try {
+      for (const { loadHook } of plugins) {
+        const result = await loadHook?.(config, context);
+        finalResult = { ...finalResult, ...result };
+      }
+      if (onLoad) {
+        const result = await onLoad(context);
+        finalResult = { ...finalResult, ...result };
+      }
+      context.result = finalResult;
+    } catch (e) {
+      context.error = e instanceof Error ? e : new Error("register onLoad error");
+      onError ? onError(e) : console.error(e);
+    }
+    return context;
+  };
+  const _emitOnLeave = async (config, getContext) => {
+    const { onLeave, onError, plugins = [] } = config;
+    const context = getContext();
+    let canLeave = true;
+    try {
+      for (const { leaveHook } of plugins) {
+        canLeave = !!leaveHook?.(config, context);
+      }
+      if (onLeave)
+        canLeave = await onLeave(context);
+    } catch (e) {
+      onError ? onError(e) : console.error(e);
+    }
+    return canLeave;
+  };
+  const register2 = (config) => (WrappedComponent) => {
+    const finalPlugin = [...options?.plugins || [], ...config?.plugins || []];
+    config = { ...options, ...config, plugins: finalPlugin };
+    let TempRegisterComponent = WrappedComponent;
+    TempRegisterComponent.config = config;
+    TempRegisterComponent.emitOnLoad = (params) => _emitOnLoad(config, register2.getContext, params);
+    TempRegisterComponent.emitOnLeave = () => _emitOnLeave(config, register2.getContext);
+    for (const { registerHook } of finalPlugin) {
+      if (!registerHook)
+        continue;
+      const ExtendWrappedComponent = registerHook(config, TempRegisterComponent);
+      if (!ExtendWrappedComponent)
+        continue;
+      hoistNonReactStatic(ExtendWrappedComponent, TempRegisterComponent);
+      TempRegisterComponent = ExtendWrappedComponent;
+    }
+    const FinalRegisterComponent = createRegisterComponent(config, register2.getContext, TempRegisterComponent);
+    hoistNonReactStatic(FinalRegisterComponent, TempRegisterComponent);
+    return FinalRegisterComponent;
+  };
+  register2.setContextStorage = (contextStorage) => {
+    _contextStorage = contextStorage;
+  };
+  register2.getContext = () => {
+    return _contextStorage.context;
+  };
+  return register2;
+};
+var register = createRegister();
+var src_default = register;
+export {
+  ContextStorageClass,
+  createRegister,
+  src_default as default
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@xfe-repo/web-register",
+  "version": "1.0.0",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "hoist-non-react-statics": "^3.3.2",
+    "react-helmet": "^6.1.0"
+  },
+  "devDependencies": {
+    "@types/hoist-non-react-statics": "^3.3.5",
+    "@types/node": "^20.10.4",
+    "@types/qs": "^6.9.10",
+    "@types/react": "^18.2.0",
+    "@types/react-helmet": "^6.1.11",
+    "eslint": "^8.53.0",
+    "react": "^18.2.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2",
+    "@xfe-repo/typescript-config": "0.0.0",
+    "@xfe-repo/eslint-config": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint \"src/**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}