@xfe-repo/web-register 1.3.2 → 1.3.4

package/dist/index.d.mts

@@ -0,0 +1,63 @@
+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>) => 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;
+    getQuery?: (context: RegisterContext<ExtendContext, P>) => string | Partial<Record<string, 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

@@ -441,9 +441,7 @@ var createRegister = function(options) {
                     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;
-                        }
+                        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 = {};

package/dist/index.mjs

@@ -0,0 +1,606 @@
+// src/index.ts
+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
+        };
+    }
+}
+import hoistNonReactStatic from "hoist-non-react-statics";
+// src/Register.tsx
+import { memo, Fragment, useEffect, useState, useCallback, useMemo } from "react";
+import { Helmet } from "react-helmet";
+import queryString from "query-string";
+import { jsx, jsxs } from "react/jsx-runtime";
+var createRegisterComponent = function(config, getContext, WrappedComponent) {
+    var RegisterComponent = memo(function(props) {
+        var context = getContext();
+        var isPreload = context.isPreload;
+        var name = config.name, ErrorFullback = config.ErrorFullback, LoadFullback = config.LoadFullback, renderTitle = config.renderTitle, getQuery = config.getQuery;
+        var query = useMemo(function() {
+            var query2 = (getQuery === null || getQuery === void 0 ? void 0 : getQuery(context)) || "";
+            var isParsed = typeof query2 === "object";
+            return isParsed ? query2 : queryString.parse(query2, {
+                parseBooleans: true,
+                parseNumbers: true
+            });
+        }, []);
+        var _useState = _sliced_to_array(useState(!isPreload), 2), needLoad = _useState[0], setNeedLoad = _useState[1];
+        var _useState1 = _sliced_to_array(useState(), 2), loadError = _useState1[0], setLoadError = _useState1[1];
+        var isLeave = false;
+        var emitLoad = 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;
+        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__ */ jsx(WrappedComponent, _object_spread_props(_object_spread({}, props), {
+            context: context
+        }));
+        if (loadError && ErrorFullback) content = /* @__PURE__ */ jsx(ErrorFullback, {});
+        if (needLoad && LoadFullback) content = /* @__PURE__ */ jsx(LoadFullback, {});
+        return /* @__PURE__ */ jsxs(Fragment, {
+            children: [
+                renderTitle && name && /* @__PURE__ */ jsx(Helmet, {
+                    title: renderTitle(name, context)
+                }),
+                content
+            ]
+        });
+    });
+    var componentName = WrappedComponent.displayName || WrappedComponent.name || "Component";
+    RegisterComponent.displayName = "Register(".concat(componentName, ")");
+    return RegisterComponent;
+};
+// src/storage/client.ts
+var ContextStorageClass = /*#__PURE__*/ function() {
+    "use strict";
+    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;
+                    hoistNonReactStatic(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);
+            hoistNonReactStatic(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;
+export { ContextStorageClass, createRegister, src_default as default };

package/package.json

@@ -1,9 +1,21 @@
 {
   "name": "@xfe-repo/web-register",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "sideEffects": false,
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "files": [
     "dist"
   ],