solid-auth-client
Version:
Opaquely authenticates solid clients
1,347 lines (1,113 loc) • 265 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("fetch"), require("window"));
else if(typeof define === 'function' && define.amd)
define(["fetch", "window"], factory);
else if(typeof exports === 'object')
exports["auth"] = factory(require("fetch"), require("window"));
else
root["solid"] = root["solid"] || {}, root["solid"]["auth"] = factory(root["fetch"], root["window"]);
})(window, function(__WEBPACK_EXTERNAL_MODULE__5__, __WEBPACK_EXTERNAL_MODULE__27__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _solid_auth_client__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
// Export a singleton instance of SolidAuthClient
const auth = new _solid_auth_client__WEBPACK_IMPORTED_MODULE_0__["default"]();
/* harmony default export */ __webpack_exports__["default"] = (auth); // Bind methods to instance, so they can be invoked as regular functions
// (e.g., to pass around the fetch function)
Object.getOwnPropertyNames(_solid_auth_client__WEBPACK_IMPORTED_MODULE_0__["default"].prototype).forEach(property => {
const value = auth[property];
if (typeof value === 'function') {
auth[property] = value.bind(auth);
}
}); // Expose window.SolidAuthClient for backward compatibility
if (typeof window !== 'undefined') {
if ('SolidAuthClient' in window) {
console.warn('Caution: multiple versions of solid-auth-client active.');
} else {
let warned = false;
Object.defineProperty(window, 'SolidAuthClient', {
enumerable: true,
get: () => {
if (!warned) {
warned = true;
console.warn('window.SolidAuthClient has been deprecated.');
console.warn('Please use window.solid.auth instead.');
}
return auth;
}
});
}
}
/***/ }),
/* 1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return SolidAuthClient; });
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);
/* harmony import */ var events__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(events__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _authn_fetch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
/* harmony import */ var _popup__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(65);
/* harmony import */ var _session__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8);
/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(9);
/* harmony import */ var _url_util__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6);
/* harmony import */ var _webid_oidc__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(11);
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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else 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; }
/* global fetch */
// Store the global fetch, so the user is free to override it
const globalFetch = fetch;
class SolidAuthClient extends events__WEBPACK_IMPORTED_MODULE_1___default.a {
constructor(...args) {
super(...args);
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_pendingSession", void 0);
}
fetch(input, options) {
this.emit('request', Object(_url_util__WEBPACK_IMPORTED_MODULE_6__["toUrlString"])(input));
return Object(_authn_fetch__WEBPACK_IMPORTED_MODULE_2__["authnFetch"])(Object(_storage__WEBPACK_IMPORTED_MODULE_5__["defaultStorage"])(), globalFetch, input, options);
}
login(idp, options) {
options = _objectSpread(_objectSpread({}, defaultLoginOptions(Object(_url_util__WEBPACK_IMPORTED_MODULE_6__["currentUrlNoParams"])())), options);
return _webid_oidc__WEBPACK_IMPORTED_MODULE_7__["login"](idp, options);
}
async popupLogin(options) {
options = _objectSpread(_objectSpread({}, defaultLoginOptions()), options);
if (!/https?:/.test(options.popupUri)) {
options.popupUri = new URL(options.popupUri || '/.well-known/solid/login', window.location).toString();
}
if (!options.callbackUri) {
options.callbackUri = options.popupUri;
}
const popup = Object(_popup__WEBPACK_IMPORTED_MODULE_3__["openIdpPopup"])(options.popupUri);
const session = await Object(_popup__WEBPACK_IMPORTED_MODULE_3__["obtainSession"])(options.storage, popup, options);
this.emit('login', session);
this.emit('session', session);
return session;
}
async currentSession(storage = Object(_storage__WEBPACK_IMPORTED_MODULE_5__["defaultStorage"])()) {
// Try to obtain a stored or pending session
let session = this._pendingSession || (await Object(_session__WEBPACK_IMPORTED_MODULE_4__["getSession"])(storage)); // If none found, attempt to create a new session
if (!session) {
// Try to create a new OIDC session from stored tokens
try {
this._pendingSession = _webid_oidc__WEBPACK_IMPORTED_MODULE_7__["currentSession"](storage);
session = await this._pendingSession;
} catch (err) {
console.error(err);
} // Save the new session and emit session events
if (session) {
await Object(_session__WEBPACK_IMPORTED_MODULE_4__["saveSession"])(storage)(session);
this.emit('login', session);
this.emit('session', session);
}
delete this._pendingSession;
}
return session;
}
async trackSession(callback) {
/* eslint-disable standard/no-callback-literal */
callback(await this.currentSession());
this.on('session', callback);
}
stopTrackSession(callback) {
this.removeListener('session', callback);
}
async logout(storage = Object(_storage__WEBPACK_IMPORTED_MODULE_5__["defaultStorage"])()) {
const session = await Object(_session__WEBPACK_IMPORTED_MODULE_4__["getSession"])(storage);
if (session) {
try {
await _webid_oidc__WEBPACK_IMPORTED_MODULE_7__["logout"](storage, globalFetch);
this.emit('logout');
this.emit('session', null);
} catch (err) {
console.warn('Error logging out:');
console.error(err);
}
await Object(_session__WEBPACK_IMPORTED_MODULE_4__["clearSession"])(storage);
}
}
}
function defaultLoginOptions(url) {
return {
callbackUri: url ? url.split('#')[0] : '',
popupUri: '',
storage: Object(_storage__WEBPACK_IMPORTED_MODULE_5__["defaultStorage"])()
};
}
/***/ }),
/* 2 */
/***/ (function(module, exports) {
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
module.exports = _defineProperty;
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var ReflectOwnKeys
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
if (handler === undefined)
return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function eventListener() {
if (errorListener !== undefined) {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
var errorListener;
// Adding an error listener is not optional because
// if an error is thrown on an event emitter we cannot
// guarantee that the actual event we are waiting will
// be fired. The result could be a silent way to create
// memory or file descriptor leaks, which is something
// we should avoid.
if (name !== 'error') {
errorListener = function errorListener(err) {
emitter.removeListener(name, eventListener);
reject(err);
};
emitter.once('error', errorListener);
}
emitter.once(name, eventListener);
});
}
/***/ }),
/* 4 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "authnFetch", function() { return authnFetch; });
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var isomorphic_fetch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
/* harmony import */ var isomorphic_fetch__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(isomorphic_fetch__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _url_util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6);
/* harmony import */ var _host__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7);
/* harmony import */ var _session__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8);
/* harmony import */ var _webid_oidc__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(11);
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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else 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; }
async function authnFetch(storage, fetch, input, options) {
// Copy headers into a modifiable object
if (options) {
const headers = copyHeaders(options.headers);
options = _objectSpread(_objectSpread({}, options), {}, {
headers
});
} // If not authenticated, perform a regular fetch
const session = await Object(_session__WEBPACK_IMPORTED_MODULE_4__["getSession"])(storage);
if (!session) {
return fetch(input, options);
} // If we know the server expects credentials, send them
if (await shouldShareCredentials(storage, input)) {
return Object(_webid_oidc__WEBPACK_IMPORTED_MODULE_5__["fetchWithCredentials"])(session, fetch, input, options);
} // If we don't know for sure, try a regular fetch first
let resp = await fetch(input, options); // If the server then requests credentials, send them
if (resp.status === 401) {
await Object(_host__WEBPACK_IMPORTED_MODULE_3__["updateHostFromResponse"])(storage)(resp);
if (await shouldShareCredentials(storage, input)) {
resp = Object(_webid_oidc__WEBPACK_IMPORTED_MODULE_5__["fetchWithCredentials"])(session, fetch, input, options);
}
}
return resp;
}
async function shouldShareCredentials(storage, input) {
const requestHost = await Object(_host__WEBPACK_IMPORTED_MODULE_3__["getHost"])(storage)(Object(_url_util__WEBPACK_IMPORTED_MODULE_2__["toUrlString"])(input));
return requestHost != null && requestHost.requiresAuth;
}
function copyHeaders(origHeaders) {
const headers = {};
if (origHeaders) {
if (typeof origHeaders.forEach === 'function') {
origHeaders.forEach((value, key) => {
headers[key] = value;
});
} else {
for (const key in origHeaders) {
headers[key] = origHeaders[key];
}
}
}
return headers;
}
/***/ }),
/* 5 */
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE__5__;
/***/ }),
/* 6 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "currentUrl", function() { return currentUrl; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "currentUrlNoParams", function() { return currentUrlNoParams; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "navigateTo", function() { return navigateTo; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "originOf", function() { return originOf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toUrlString", function() { return toUrlString; });
/* eslint-env browser */
function getLocation() {
return typeof window !== 'undefined' ? window.location : {
href: 'https://example.org/',
pathname: '/',
origin: 'example.org'
};
}
const currentUrl = () => getLocation().href;
const currentUrlNoParams = () => getLocation().origin + getLocation().pathname;
const navigateTo = url => {
getLocation().href = url;
};
const originOf = url => new URL(url).origin;
const toUrlString = url => {
if (typeof url !== 'string') {
url = 'url' in url ? url.url : url.toString();
}
return new URL(url, currentUrl()).toString();
};
/***/ }),
/* 7 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getHost", function() { return getHost; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "saveHost", function() { return saveHost; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "updateHostFromResponse", function() { return updateHostFromResponse; });
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _session__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
/* harmony import */ var _webid_oidc__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11);
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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else 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; }
/* globalRequest, Response, URL */
function getHost(storage) {
return async url => {
const {
host
} = new URL(url);
const session = await Object(_session__WEBPACK_IMPORTED_MODULE_1__["getSession"])(storage);
if (session && host === new URL(session.idp).host) {
return {
url: host,
requiresAuth: true
};
}
const {
hosts
} = await Object(_storage__WEBPACK_IMPORTED_MODULE_2__["getData"])(storage);
return hosts && hosts[host];
};
}
function saveHost(storage) {
return async ({
url,
requiresAuth
}) => {
await Object(_storage__WEBPACK_IMPORTED_MODULE_2__["updateStorage"])(storage, data => _objectSpread(_objectSpread({}, data), {}, {
hosts: _objectSpread(_objectSpread({}, data.hosts), {}, {
[url]: {
requiresAuth
}
})
}));
};
}
function updateHostFromResponse(storage) {
return async resp => {
if (_webid_oidc__WEBPACK_IMPORTED_MODULE_3__["requiresAuth"](resp)) {
const {
host
} = new URL(resp.url);
await saveHost(storage)({
url: host,
requiresAuth: true
});
}
};
}
/***/ }),
/* 8 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getSession", function() { return getSession; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "saveSession", function() { return saveSession; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clearSession", function() { return clearSession; });
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(target, key, source[key]); }); } else 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; }
async function getSession(storage) {
const data = await Object(_storage__WEBPACK_IMPORTED_MODULE_1__["getData"])(storage);
return data.session || null;
}
function saveSession(storage) {
return async session => {
const data = await Object(_storage__WEBPACK_IMPORTED_MODULE_1__["updateStorage"])(storage, data => _objectSpread(_objectSpread({}, data), {}, {
session
}));
return data.session;
};
}
async function clearSession(storage) {
await Object(_storage__WEBPACK_IMPORTED_MODULE_1__["updateStorage"])(storage, data => _objectSpread(_objectSpread({}, data), {}, {
session: null
}));
}
/***/ }),
/* 9 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NAMESPACE", function() { return NAMESPACE; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "defaultStorage", function() { return defaultStorage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getData", function() { return getData; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "updateStorage", function() { return updateStorage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "asyncStorage", function() { return asyncStorage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "memStorage", function() { return memStorage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ipcStorage", function() { return ipcStorage; });
/* harmony import */ var _ipc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
const NAMESPACE = 'solid-auth-client';
const defaultStorage = () => {
const hasLocalStorage = typeof window !== 'undefined' && 'localStorage' in window;
return asyncStorage(hasLocalStorage ? window.localStorage : memStorage());
};
/**
* Gets the deserialized stored data
*/
async function getData(store) {
let serialized;
let data;
try {
serialized = await store.getItem(NAMESPACE);
data = JSON.parse(serialized || '{}');
} catch (e) {
console.warn('Could not deserialize data:', serialized);
console.error(e);
data = {};
}
return data;
}
/**
* Updates a Storage object without mutating its intermediate representation.
*/
async function updateStorage(store, update) {
const currentData = await getData(store);
const newData = update(currentData);
await store.setItem(NAMESPACE, JSON.stringify(newData));
return newData;
}
/**
* Takes a synchronous storage interface and wraps it with an async interface.
*/
function asyncStorage(storage) {
return {
getItem: key => {
return Promise.resolve(storage.getItem(key));
},
setItem: (key, val) => {
return Promise.resolve(storage.setItem(key, val));
},
removeItem: key => {
return Promise.resolve(storage.removeItem(key));
}
};
}
const memStorage = () => {
const store = {};
return {
getItem: key => {
if (typeof store[key] === 'undefined') return null;
return store[key];
},
setItem: (key, val) => {
store[key] = val;
},
removeItem: key => {
delete store[key];
}
};
};
function ipcStorage(client) {
return {
getItem: key => client.request('storage/getItem', key),
setItem: (key, val) => client.request('storage/setItem', key, val),
removeItem: key => client.request('storage/removeItem', key)
};
}
/***/ }),
/* 10 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Server", function() { return Server; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Client", function() { return Client; });
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0__);
/*
This module describes a simple IPC interface for communicating between browser windows.
window.postMessage() is the transport interface, and a request/response interface
is defined on top of it as follows:
const request = {
'solid-auth-client': {
id: 1234,
method: 'doSomethingPlease',
args: [ 'one', 'two', 'three' ]
}
}
const response = {
'solid-auth-client': {
id: 1234,
ret: 'the_value'
}
}
*/
const NAMESPACE = 'solid-auth-client';
/**
* Receives and handles remote procedure calls.
*/
class Server {
constructor(clientWindow, clientOrigin, handle) {
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_clientWindow", void 0);
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_clientOrigin", void 0);
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_handler", void 0);
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_messageListener", void 0);
this._clientWindow = clientWindow;
this._clientOrigin = clientOrigin;
this._handler = handle;
this._messageListener = event => this._handleMessage(event);
}
async _handleMessage({
data,
origin
}) {
// Ensure we can post to the origin
if (origin !== this._clientOrigin) {
console.warn("solid-auth-client is listening to ".concat(this._clientOrigin, " ") + "so ignored a message received from ".concat(origin, "."));
return;
} // Parse the request and send it to the handler
const req = data && data[NAMESPACE];
if (req && req.method) {
const {
id,
method,
args
} = req;
const ret = await this._handler(method, ...args);
this._clientWindow.postMessage({
[NAMESPACE]: {
id,
ret
}
}, this._clientOrigin);
}
}
start() {
window.addEventListener('message', this._messageListener);
}
stop() {
window.removeEventListener('message', this._messageListener);
}
}
/**
* Makes remote procedure calls.
*/
class Client {
constructor(serverWindow, serverOrigin) {
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_serverWindow", void 0);
_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_0___default()(this, "_serverOrigin", void 0);
this._serverWindow = serverWindow;
this._serverOrigin = serverOrigin;
}
request(method, ...args) {
// Send the request as a message to the server window
const id = Math.random();
this._serverWindow.postMessage({
[NAMESPACE]: {
id,
method,
args
}
}, this._serverOrigin); // Create a promise that resolves to the request's return value
return new Promise((resolve, reject) => {
// Listen for responses to the request
window.addEventListener('message', responseListener); // Cancel if the response takes too long
const timeout = setTimeout(() => {
reject(new Error('Could not connect to main window.'));
window.removeEventListener('message', responseListener);
}, 2000); // Processes a possible response to the request
function responseListener({
data
}) {
const resp = data && data[NAMESPACE]; // eslint-disable-next-line no-prototype-builtins
if (resp && resp.id === id && resp.hasOwnProperty('ret')) {
resolve(resp.ret);
clearTimeout(timeout);
window.removeEventListener('message', responseListener);
}
}
});
}
}
/***/ }),
/* 11 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "login", function() { return login; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "currentSession", function() { return currentSession; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "logout", function() { return logout; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getRegisteredRp", function() { return getRegisteredRp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "requiresAuth", function() { return requiresAuth; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fetchWithCredentials", function() { return fetchWithCredentials; });
/* harmony import */ var _babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12);
/* harmony import */ var _babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_objectWithoutProperties__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
/* harmony import */ var _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var auth_header__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14);
/* harmony import */ var auth_header__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(auth_header__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _solid_oidc_rp__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(18);
/* harmony import */ var _solid_oidc_rp__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_solid_oidc_rp__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _solid_oidc_rp_src_PoPToken__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(61);
/* harmony import */ var _solid_oidc_rp_src_PoPToken__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_solid_oidc_rp_src_PoPToken__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var _url_util__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6);
/* harmony import */ var _storage__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(9);
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 _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _babel_runtime_helpers_defineProperty__WEBPACK_IMPORTED_MODULE_1___default()(target, key, source[key]); }); } else 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; }
/* global Response */
async function login(idp, options) {
try {
const rp = await getRegisteredRp(idp, options);
await saveAppHashFragment(options.storage);
return sendAuthRequest(rp, options);
} catch (err) {
console.warn('Error logging in with WebID-OIDC');
console.error(err);
return null;
}
}
async function currentSession(storage = Object(_storage__WEBPACK_IMPORTED_MODULE_6__["defaultStorage"])()) {
try {
// Obtain the Relying Party
const rp = await getStoredRp(storage);
if (!rp) {
return null;
} // Obtain and clear the OIDC URL fragment
const url = Object(_url_util__WEBPACK_IMPORTED_MODULE_5__["currentUrl"])();
if (!/#(.*&)?access_token=/.test(url)) {
return null;
}
window.location.hash = '';
await restoreAppHashFragment(storage); // Obtain a session from the Relying Party
const storeData = await Object(_storage__WEBPACK_IMPORTED_MODULE_6__["getData"])(storage);
const session = await rp.validateResponse(url, storeData);
if (!session) {
return null;
}
return _objectSpread(_objectSpread({}, session), {}, {
webId: session.idClaims.sub,
idp: session.issuer
});
} catch (err) {
console.warn('Error finding a WebID-OIDC session');
console.error(err);
return null;
}
}
async function logout(storage, fetch) {
const rp = await getStoredRp(storage);
if (rp) {
try {
// First log out from the IDP
await rp.logout(); // Then, log out from the RP
try {
await fetch('/.well-known/solid/logout', {
credentials: 'include'
});
} catch (e) {
// Ignore errors for when we are not on a Solid pod
// But tell users it is harmless because they will see the GET failure in the console
console.info("Couldn't find /.well-known/solid/logout, this is harmless.");
}
} catch (err) {
console.warn('Error logging out of the WebID-OIDC session');
console.error(err);
}
}
}
a