@multiplatform.one/keycloak 0.7.0 → 0.7.2

package/lib/chunk-QFP2JWHZ.js

@@ -0,0 +1,443 @@
+"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 _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 _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 _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);
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _optionalChain(ops) {
+    var lastAccessLHS = undefined;
+    var value = ops[0];
+    var i = 1;
+    while(i < ops.length){
+        var op = ops[i];
+        var fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+            return undefined;
+        }
+        if (op === "access" || op === "optionalAccess") {
+            lastAccessLHS = value;
+            value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+            var _value;
+            value = fn(function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return (_value = value).call.apply(_value, [
+                    lastAccessLHS
+                ].concat(_to_consumable_array(args)));
+            });
+            lastAccessLHS = undefined;
+        }
+    }
+    return value;
+}
+var _chunkJLIMB5ODjs = require("./chunk-JLIMB5OD.js");
+var _chunk3ZPHNEJLjs = require("./chunk-3ZPHNEJL.js");
+var _chunkC2FNSVJOjs = require("./chunk-C2FNSVJO.js");
+var _chunkNWRANDZ6js = require("./chunk-NWRANDZ6.js");
+// src/provider/keycloakProvider.tsx
+var _keycloakjs = require("@bitspur/keycloak-js");
+var _keycloakjs2 = _interopRequireDefault(_keycloakjs);
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+var _multiplatformone = require("multiplatform.one");
+var _reactkeycloakweb = require("@bitspur/react-keycloak-web");
+var _reactkeycloakssr = require("@bitspur/react-keycloak-ssr");
+var _router = require("next/router");
+var logger = console;
+function KeycloakProvider(param) {
+    var children = param.children, cookies = param.cookies, keycloakConfig = param.keycloakConfig, keycloakInitOptions = param.keycloakInitOptions, loadingComponent = param.loadingComponent, onEvent = param.onEvent, onTokens = param.onTokens;
+    var _chunk3ZPHNEJLjs_useAuthConfig_call = _chunk3ZPHNEJLjs.useAuthConfig.call(void 0), debug = _chunk3ZPHNEJLjs_useAuthConfig_call.debug, ensureFreshness = _chunk3ZPHNEJLjs_useAuthConfig_call.ensureFreshness, persist = _chunk3ZPHNEJLjs_useAuthConfig_call.persist, messageHandlerKeys = _chunk3ZPHNEJLjs_useAuthConfig_call.messageHandlerKeys, ssr = _chunk3ZPHNEJLjs_useAuthConfig_call.ssr;
+    var authState = _chunkC2FNSVJOjs.useAuthState.call(void 0);
+    var LoadingComponent = loadingComponent || function() {
+        return /* @__PURE__ */ _react2.default.createElement(_react2.default.Fragment, null, debug ? "authenticating" : null);
+    };
+    var query = (_multiplatformone.MultiPlatform.isNext ? _router.useRouter.call(void 0) : {
+        query: {}
+    }).query;
+    var _react_useState_call = _sliced_to_array(_react.useState.call(void 0, _chunkNWRANDZ6js.validToken.call(void 0, ensureFreshness && ("refreshToken" in query && (_optionalChain([
+        query,
+        "access",
+        function(_) {
+            return _.refreshToken;
+        },
+        "optionalAccess",
+        function(_2) {
+            return _2.toString;
+        },
+        "call",
+        function(_3) {
+            return _3();
+        }
+    ]) || true) || persist && authState.refreshToken) || false)), 2), refreshToken = _react_useState_call[0], setRefreshToken = _react_useState_call[1];
+    var _react_useState_call1 = _sliced_to_array(_react.useState.call(void 0, _chunkNWRANDZ6js.validToken.call(void 0, "idToken" in query && (_optionalChain([
+        query,
+        "access",
+        function(_4) {
+            return _4.idToken;
+        },
+        "optionalAccess",
+        function(_5) {
+            return _5.toString;
+        },
+        "call",
+        function(_6) {
+            return _6();
+        }
+    ]) || true) || persist && authState.idToken || false, refreshToken)), 2), idToken = _react_useState_call1[0], setIdToken = _react_useState_call1[1];
+    var _react_useState_call2 = _sliced_to_array(_react.useState.call(void 0, _chunkNWRANDZ6js.validToken.call(void 0, "token" in query && (_optionalChain([
+        query,
+        "access",
+        function(_7) {
+            return _7.token;
+        },
+        "optionalAccess",
+        function(_8) {
+            return _8.toString;
+        },
+        "call",
+        function(_9) {
+            return _9();
+        }
+    ]) || true) || persist && authState.token || false, refreshToken)), 2), token = _react_useState_call2[0], setToken = _react_useState_call2[1];
+    _react.useEffect.call(void 0, function() {
+        if (token !== true && refreshToken !== true && idToken !== true) return;
+        if (debug) logger.debug("post message", JSON.stringify({
+            type: "LOADED"
+        }));
+        (messageHandlerKeys || []).forEach(function(key) {
+            _optionalChain([
+                window,
+                "optionalAccess",
+                function(_10) {
+                    return _10.webkit;
+                },
+                "optionalAccess",
+                function(_11) {
+                    return _11.messageHandlers;
+                },
+                "optionalAccess",
+                function(_12) {
+                    return _12[key];
+                },
+                "optionalAccess",
+                function(_13) {
+                    return _13.postMessage;
+                },
+                "call",
+                function(_14) {
+                    return _14(JSON.stringify({
+                        type: "LOADED"
+                    }));
+                }
+            ]);
+        });
+        _optionalChain([
+            window,
+            "optionalAccess",
+            function(_15) {
+                return _15.ReactNativeWebView;
+            },
+            "optionalAccess",
+            function(_16) {
+                return _16.postMessage;
+            },
+            "call",
+            function(_17) {
+                return _17(JSON.stringify({
+                    type: "LOADED"
+                }));
+            }
+        ]);
+        _optionalChain([
+            window,
+            "optionalAccess",
+            function(_18) {
+                return _18.parent;
+            },
+            "optionalAccess",
+            function(_19) {
+                return _19.postMessage;
+            },
+            "call",
+            function(_20) {
+                return _20(JSON.stringify({
+                    type: "LOADED"
+                }));
+            }
+        ]);
+    }, []);
+    _react.useEffect.call(void 0, function() {
+        if (refreshToken !== true) return;
+        var messageCallback = function(e) {
+            var data = _optionalChain([
+                e,
+                "optionalAccess",
+                function(_21) {
+                    return _21.data;
+                }
+            ]) || null;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(data);
+                } catch (err) {}
+            }
+            if (debug) logger.debug("received message", JSON.stringify(data));
+            var message = data;
+            if (!message.type) return;
+            if (message.type.toUpperCase() === "REFRESH_TOKEN" && message.payload) {
+                if (debug) logger.debug("setting refresh token", message.payload);
+                setRefreshToken(_chunkNWRANDZ6js.validToken.call(void 0, message.payload));
+                window.removeEventListener("message", messageCallback);
+            }
+        };
+        if (debug) {
+            logger.debug("listening for message", JSON.stringify({
+                type: "REFRESH_TOKEN",
+                payload: "<some_refresh_token>"
+            }));
+        }
+        window.addEventListener("message", messageCallback);
+        return function() {
+            window.removeEventListener("message", messageCallback);
+        };
+    }, []);
+    _react.useEffect.call(void 0, function() {
+        if (token !== true) return;
+        var messageCallback = function(e) {
+            var data = _optionalChain([
+                e,
+                "optionalAccess",
+                function(_22) {
+                    return _22.data;
+                }
+            ]) || null;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(data);
+                } catch (err) {}
+            }
+            if (debug) logger.debug("received message", JSON.stringify(data));
+            var message = data;
+            if (!message.type) return;
+            if (message.type.toUpperCase() === "TOKEN" && message.payload) {
+                if (debug) logger.debug("setting token", message.payload);
+                setToken(_chunkNWRANDZ6js.validToken.call(void 0, message.payload, refreshToken));
+                window.removeEventListener("message", messageCallback);
+            }
+        };
+        if (debug) {
+            logger.debug("listening for message", JSON.stringify({
+                type: "TOKEN",
+                payload: "<some_token>"
+            }));
+        }
+        window.addEventListener("message", messageCallback);
+        return function() {
+            window.removeEventListener("message", messageCallback);
+        };
+    }, []);
+    _react.useEffect.call(void 0, function() {
+        if (idToken !== true) return;
+        var messageCallback = function(e) {
+            var data = _optionalChain([
+                e,
+                "optionalAccess",
+                function(_23) {
+                    return _23.data;
+                }
+            ]) || null;
+            if (typeof data === "string") {
+                try {
+                    data = JSON.parse(data);
+                } catch (err) {}
+            }
+            if (debug) logger.debug("received message", JSON.stringify(data));
+            var message = data;
+            if (!message.type) return;
+            if (message.type.toUpperCase() === "ID_TOKEN" && message.payload) {
+                if (debug) logger.debug("setting id token", message.payload);
+                setIdToken(_chunkNWRANDZ6js.validToken.call(void 0, message.payload, refreshToken));
+                window.removeEventListener("message", messageCallback);
+            }
+        };
+        if (debug) {
+            logger.debug("listening for message", JSON.stringify({
+                type: "ID_TOKEN",
+                payload: "<some_id_token>"
+            }));
+        }
+        window.addEventListener("message", messageCallback);
+        return function() {
+            window.removeEventListener("message", messageCallback);
+        };
+    }, []);
+    var handleEvent = _react.useCallback.call(void 0, function(eventType, error) {
+        if (error) {
+            if (typeof error === "string") throw new Error(error);
+            var err = new Error(error.error);
+            err.errorDescription = error.error_description;
+            throw err;
+        }
+        if (onEvent) onEvent(eventType, error);
+    }, []);
+    var keycloak = _react.useMemo.call(void 0, function() {
+        return typeof window !== "undefined" && new (0, _keycloakjs2.default)({
+            url: keycloakConfig.url,
+            realm: keycloakConfig.realm,
+            clientId: keycloakConfig.clientId
+        });
+    }, [
+        keycloakInitOptions,
+        token,
+        refreshToken,
+        idToken
+    ]);
+    var initOptions = _react.useMemo.call(void 0, function() {
+        var initOptions2 = _object_spread({}, defaultKeycloakInitOptions, keycloakInitOptions);
+        if (debug) initOptions2.enableLogging = true;
+        if (token && typeof token === "string") {
+            initOptions2.token = token;
+            initOptions2.timeSkew = 0;
+            if (idToken && typeof idToken === "string") initOptions2.idToken = idToken;
+            if (refreshToken && typeof refreshToken === "string") initOptions2.refreshToken = refreshToken;
+        }
+        if (typeof window !== "undefined" && window.self !== window.top || token && !refreshToken) {
+            initOptions2.checkLoginIframe = false;
+            initOptions2.flow = "implicit";
+            initOptions2.onLoad = void 0;
+        }
+        return initOptions2;
+    }, [
+        keycloakInitOptions,
+        token,
+        refreshToken,
+        idToken
+    ]);
+    if (token === true || idToken === true || refreshToken === true) return /* @__PURE__ */ _react2.default.createElement(LoadingComponent, null);
+    if (cookies && ssr) {
+        return(// @ts-ignore
+        /* @__PURE__ */ _react2.default.createElement(_reactkeycloakssr.SSRKeycloakProvider, {
+            LoadingComponent: /* @__PURE__ */ _react2.default.createElement(LoadingComponent, null),
+            autoRefreshToken: initOptions.checkLoginIframe,
+            initOptions: initOptions,
+            onEvent: handleEvent,
+            onTokens: onTokens,
+            persistor: _reactkeycloakssr.SSRCookies.call(void 0, cookies),
+            keycloakConfig: {
+                clientId: keycloakConfig.clientId,
+                realm: keycloakConfig.realm,
+                url: keycloakConfig.url
+            }
+        }, /* @__PURE__ */ _react2.default.createElement(_chunkJLIMB5ODjs.AfterAuth, null, children)));
+    }
+    if (!keycloak) return /* @__PURE__ */ _react2.default.createElement(LoadingComponent, null);
+    return /* @__PURE__ */ _react2.default.createElement(_reactkeycloakweb.ReactKeycloakProvider, {
+        LoadingComponent: /* @__PURE__ */ _react2.default.createElement(LoadingComponent, null),
+        authClient: keycloak,
+        autoRefreshToken: initOptions.checkLoginIframe,
+        initOptions: initOptions,
+        onEvent: handleEvent,
+        onTokens: onTokens
+    }, /* @__PURE__ */ _react2.default.createElement(_chunkJLIMB5ODjs.AfterAuth, null, children));
+}
+var defaultKeycloakInitOptions = {
+    checkLoginIframe: true,
+    checkLoginIframeInterval: 5,
+    enableLogging: false,
+    onLoad: "check-sso",
+    pkceMethod: "S256"
+};
+exports.KeycloakProvider = KeycloakProvider;
+exports.defaultKeycloakInitOptions = defaultKeycloakInitOptions;

package/lib/chunk-RTZ3CZKS.js

@@ -0,0 +1,161 @@
+"use strict";
+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 _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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var _chunkQFP2JWHZjs = require("./chunk-QFP2JWHZ.js");
+var _chunkKLLABHICjs = require("./chunk-KLLABHIC.js");
+var _chunkYGNNHTFEjs = require("./chunk-YGNNHTFE.js");
+var _chunkA7UBOIALjs = require("./chunk-A7UBOIAL.js");
+// src/provider/index.tsx
+var _react = require("react");
+var _react2 = _interopRequireDefault(_react);
+var _config = require("app/config");
+var persist = _config.config.get("KEYCLOAK_PERSIST") === "1";
+var AuthProvider = function(_param) {
+    var // keycloak config
+    realm = _param.realm, clientId = _param.clientId, baseUrl = _param.baseUrl, // auth config
+    debug = _param.debug, ensureFreshness = _param.ensureFreshness, loginRoute = _param.loginRoute, messageHandlerKeys = _param.messageHandlerKeys, ssr = _param.ssr, // props
+    children = _param.children, cookies = _param.cookies, disabled = _param.disabled, loadingComponent = _param.loadingComponent, onEvent = _param.onEvent, onTokens = _param.onTokens, keycloakInitOptions = _object_without_properties(_param, [
+        "realm",
+        "clientId",
+        "baseUrl",
+        "debug",
+        "ensureFreshness",
+        "loginRoute",
+        "messageHandlerKeys",
+        "ssr",
+        "children",
+        "cookies",
+        "disabled",
+        "loadingComponent",
+        "onEvent",
+        "onTokens"
+    ]);
+    var tokensFromQuery = _chunkKLLABHICjs.useTokensFromQuery.call(void 0);
+    var tokensFromState = _chunkYGNNHTFEjs.useTokensFromState.call(void 0);
+    var authConfig = _react.useMemo.call(void 0, function() {
+        return _object_spread_props(_object_spread({}, _chunkA7UBOIALjs.defaultAuthConfig, typeof debug !== "undefined" ? {
+            debug: debug
+        } : {}, typeof ensureFreshness !== "undefined" ? {
+            ensureFreshness: ensureFreshness
+        } : {}, typeof loginRoute !== "undefined" ? {
+            loginRoute: loginRoute
+        } : {}, typeof messageHandlerKeys !== "undefined" ? {
+            messageHandlerKeys: messageHandlerKeys
+        } : {}), {
+            persist: !tokensFromState && !tokensFromQuery && cookies && ssr ? false : typeof persist !== "undefined" ? persist : _chunkA7UBOIALjs.defaultAuthConfig.persist,
+            ssr: !tokensFromState && !tokensFromQuery && cookies ? typeof ssr !== "undefined" ? ssr : _chunkA7UBOIALjs.defaultAuthConfig.ssr : false
+        });
+    }, [
+        debug,
+        ensureFreshness,
+        loginRoute,
+        messageHandlerKeys,
+        persist,
+        ssr
+    ]);
+    if (disabled) {
+        return /* @__PURE__ */ _react2.default.createElement(_chunkA7UBOIALjs.AuthConfigContext.Provider, {
+            value: authConfig
+        }, children);
+    }
+    return /* @__PURE__ */ _react2.default.createElement(_chunkA7UBOIALjs.AuthConfigContext.Provider, {
+        value: authConfig
+    }, /* @__PURE__ */ _react2.default.createElement(_chunkQFP2JWHZjs.KeycloakProvider, {
+        cookies: cookies,
+        keycloakConfig: {
+            realm: realm || "main",
+            clientId: clientId || "app",
+            url: baseUrl
+        },
+        keycloakInitOptions: keycloakInitOptions,
+        loadingComponent: loadingComponent,
+        onEvent: onEvent,
+        onTokens: onTokens
+    }, children));
+};
+exports.AuthProvider = AuthProvider;