@bixi/auth
Version:
1,416 lines (1,396 loc) • 69.2 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('@angular/router'), require('rxjs'), require('rxjs/operators'), require('extend'), require('@angular/common/http')) :
typeof define === 'function' && define.amd ? define('@bixi/auth', ['exports', '@angular/common', '@angular/core', '@angular/router', 'rxjs', 'rxjs/operators', 'extend', '@angular/common/http'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.bixi = global.bixi || {}, global.bixi.auth = {}), global.ng.common, global.ng.core, global.ng.router, global.rxjs, global.rxjs.operators, global.Extend, global.ng.common.http));
})(this, (function (exports, common, i0, router, rxjs, operators, extend, http) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
var extend__default = /*#__PURE__*/_interopDefaultLegacy(extend);
/**
* @fileoverview added by tsickle
* Generated from: src/auth.config.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var AUTH_DEFAULT_CONFIG = {
store_key: "_token",
token_invalid_redirect: true,
token_exp_offset: 10,
token_send_key: "token",
// tslint:disable-next-line: no-invalid-template-strings
token_send_template: '${token}',
token_send_place: 'header',
login_url: '/login',
ignores: [/\/login/, /assets\//, /passport\//],
allow_anonymous_key: "_allow_anonymous",
executeOtherInterceptors: true
};
/**
* @param {?} srv
* @return {?}
*/
function mergeConfig(srv) {
return srv.merge(AUTH_DEFAULT_CONFIG);
}
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
;
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
/**
* @fileoverview added by tsickle
* Generated from: src/config.type.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function BixiAuthConfig() { }
if (false) {
/**
* 存储KEY值，默认：`_token`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.store_key;
/**
* 无效时跳转至登录页，默认：`true`，包括：
* - 无效token值
* - token已过期（限JWT）
* @type {?|undefined}
*/
BixiAuthConfig.prototype.token_invalid_redirect;
/**
* token过期时间偏移值，默认：`10` 秒（单位：秒）
* @type {?|undefined}
*/
BixiAuthConfig.prototype.token_exp_offset;
/**
* 发送token参数名，默认：·
* @type {?|undefined}
*/
BixiAuthConfig.prototype.token_send_key;
/**
* 发送token模板（默认为：`'${token}'`），使用 `${token}` 表示token点位符（**注意：**请务必使用 \`\` 包裹），例如：
*
* - `Bearer ${token}`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.token_send_template;
/**
* 发送token参数位置，默认：`header`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.token_send_place;
/**
* 登录页路由地址，默认：`/login`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.login_url;
/**
* 忽略TOKEN的URL地址列表，默认值为：`[/\/login/, /assets\//, /passport\//]`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.ignores;
/**
* 允许匿名登录KEY，若请求参数中带有该KEY表示忽略TOKEN，默认：`_allow_anonymous`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.allow_anonymous_key;
/**
* 是否校验失效时命中后继续调用后续拦截器的 `intercept` 方法，默认：`true`
* @type {?|undefined}
*/
BixiAuthConfig.prototype.executeOtherInterceptors;
}
/** @type {?} */
var BIXI_AUTH_CONFIG = new i0.InjectionToken('bixi-auth-config');
/**
* 深度合并对象
*
* @param {?} original 原始对象
* @param {?} arrayProcessMethod 数组处理方式
* - `true` 表示替换新值，不管新值为哪种类型
* - `false` 表示会合并整个数组（将旧数据与新数据合并成新数组）
* @param {...?} objects 要合并的对象
* @return {?}
*/
// tslint:disable-next-line:no-any
function deepMergeKey(original, arrayProcessMethod) {
var objects = [];
for (var _i = 2; _i < arguments.length; _i++) {
objects[_i - 2] = arguments[_i];
}
if (Array.isArray(original) || typeof original !== 'object')
return original;
// tslint:disable-next-line:no-any
/** @type {?} */
var isObject = ( /**
* @param {?} v
* @return {?}
*/function (v) { return typeof v === 'object' || typeof v === 'function'; });
// tslint:disable-next-line:no-any
/** @type {?} */
var merge = ( /**
* @param {?} target
* @param {?} obj
* @return {?}
*/function (target, obj) {
Object.keys(obj)
.filter(( /**
* @param {?} key
* @return {?}
*/function (/**
* @param {?} key
* @return {?}
*/ key) { return key !== '__proto__' && Object.prototype.hasOwnProperty.call(obj, key); }))
.forEach(( /**
* @param {?} key
* @return {?}
*/function (/**
* @param {?} key
* @return {?}
*/ key) {
/** @type {?} */
var fromValue = obj[key];
/** @type {?} */
var toValue = target[key];
if (Array.isArray(toValue)) {
target[key] = arrayProcessMethod ? fromValue : __spread(toValue, fromValue);
}
else if (fromValue != null && isObject(fromValue) && toValue != null && isObject(toValue)) {
target[key] = merge(toValue, fromValue);
}
else {
target[key] = deepCopy(fromValue);
}
}));
return target;
});
objects.filter(( /**
* @param {?} v
* @return {?}
*/function (/**
* @param {?} v
* @return {?}
*/ v) { return v != null && isObject(v); })).forEach(( /**
* @param {?} v
* @return {?}
*/function (/**
* @param {?} v
* @return {?}
*/ v) { return merge(original, v); }));
return original;
}
// tslint:disable-next-line:no-any
/**
* @param {?} obj
* @return {?}
*/
function deepCopy(obj) {
/** @type {?} */
var result = extend__default["default"](true, {}, { _: obj });
return result._;
}
var BixiConfigService = /** @class */ (function () {
/**
* @param {?=} defaultConfig
*/
function BixiConfigService(defaultConfig) {
this.config = defaultConfig || {};
}
/**
* @param {?=} key
* @return {?}
*/
BixiConfigService.prototype.get = function (key) {
var _a;
// tslint:disable-next-line:no-any
/** @type {?} */
var res = ( /** @type {?} */(((( /** @type {?} */(this.config))) || {})));
return key ? (_a = {}, _a[key] = res[key], _a) : res;
};
/**
* @template R
* @param {...?} defaultValues
* @return {?}
*/
BixiConfigService.prototype.merge = function () {
var defaultValues = [];
for (var _i = 0; _i < arguments.length; _i++) {
defaultValues[_i] = arguments[_i];
}
return deepMergeKey.apply(void 0, __spread([{}, true], defaultValues, [this.get()]));
};
// tslint:disable-next-line:no-any
/**
* @template R
* @param {?} componentThis
* @param {?} defaultValues
* @return {?}
*/
BixiConfigService.prototype.attach = function (componentThis, defaultValues) {
Object.assign(componentThis, this.merge(defaultValues));
};
// tslint:disable-next-line:no-any
/**
* @param {?} componentThis
* @param {?} key
* @return {?}
*/
BixiConfigService.prototype.attachKey = function (componentThis, key) {
Object.assign(componentThis, this.get(key));
};
/**
* @param {?} value
* @return {?}
*/
BixiConfigService.prototype.set = function (value) {
this.config = Object.assign(Object.assign({}, this.config), value);
};
return BixiConfigService;
}());
BixiConfigService.decorators = [
{ type: i0.Injectable, args: [{ providedIn: 'root' },] }
];
/** @nocollapse */
BixiConfigService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [BIXI_AUTH_CONFIG,] }] }
]; };
/** @nocollapse */ BixiConfigService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function BixiConfigService_Factory() { return new BixiConfigService(i0__namespace.ɵɵinject(BIXI_AUTH_CONFIG, 8)); }, token: BixiConfigService, providedIn: "root" });
if (false) {
/**
* @type {?}
* @private
*/
BixiConfigService.prototype.config;
}
/**
* @fileoverview added by tsickle
* Generated from: src/store/local-storage.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* `localStorage` storage, **not lost after closing the browser**.
*
* ```ts
* { provide: BIXI_STORE_TOKEN, useClass: LocalStorageStore }
* ```
*/
var LocalStorageStore = /** @class */ (function () {
function LocalStorageStore() {
}
/**
* @param {?} key
* @return {?}
*/
LocalStorageStore.prototype.get = function (key) {
return JSON.parse(localStorage.getItem(key) || '{}') || {};
};
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
LocalStorageStore.prototype.set = function (key, value) {
localStorage.setItem(key, JSON.stringify(value));
return true;
};
/**
* @param {?} key
* @return {?}
*/
LocalStorageStore.prototype.remove = function (key) {
localStorage.removeItem(key);
};
return LocalStorageStore;
}());
/**
* @return {?}
*/
function BIXI_STORE_TOKEN_LOCAL_FACTORY() {
return new LocalStorageStore();
}
/**
* @fileoverview added by tsickle
* Generated from: src/store/interface.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var BIXI_STORE_TOKEN = new i0.InjectionToken('AUTH_STORE_TOKEN', {
providedIn: 'root',
factory: BIXI_STORE_TOKEN_LOCAL_FACTORY
});
/**
* @record
*/
function IStore() { }
if (false) {
/**
* @param {?} key
* @return {?}
*/
IStore.prototype.get = function (key) { };
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
IStore.prototype.set = function (key, value) { };
/**
* @param {?} key
* @return {?}
*/
IStore.prototype.remove = function (key) { };
}
/**
* @fileoverview added by tsickle
* Generated from: src/token/token.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* 维护Token信息服务，[在线文档](https://bixi.datagrand.com/auth)
*/
var TokenService = /** @class */ (function () {
/**
* @param {?} configSrv
* @param {?} store
*/
function TokenService(configSrv, store) {
this.store = store;
this.change$ = new rxjs.BehaviorSubject(null);
this._referrer = {};
this._options = mergeConfig(configSrv);
}
Object.defineProperty(TokenService.prototype, "login_url", {
/**
* 授权失败后跳转路由路径（支持外部链接地址）
* @return {?}
*/
get: function () {
return this._options.login_url;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TokenService.prototype, "referrer", {
/**
* 当前请求页面的来源页面的地址
* @return {?}
*/
get: function () {
return this._referrer;
},
enumerable: false,
configurable: true
});
Object.defineProperty(TokenService.prototype, "options", {
/**
* @return {?}
*/
get: function () {
return this._options;
},
enumerable: false,
configurable: true
});
/**
* 设置 Token 信息，当用户 Token 发生变动时都需要调用此方法重新刷新
* @param {?} data
* @return {?}
*/
TokenService.prototype.set = function (data) {
this.change$.next(data);
// tslint:disable-next-line:no-non-null-assertion
return this.store.set(( /** @type {?} */(this._options.store_key)), data);
};
/**
* @template T
* @param {?=} type
* @return {?}
*/
TokenService.prototype.get = function (type) {
// tslint:disable-next-line:no-non-null-assertion
/** @type {?} */
var data = this.store.get(( /** @type {?} */(this._options.store_key)));
return type ? (( /** @type {?} */(Object.assign(new type(), data)))) : (( /** @type {?} */(data)));
};
/**
* 清除 Token 信息，当用户退出登录时调用。
* ```
* // 清除所有 Token 信息
* tokenService.clear();
* // 只清除 token 字段
* tokenService.clear({ onlyToken: true });
* ```
* @param {?=} options
* @return {?}
*/
TokenService.prototype.clear = function (options) {
if (options === void 0) { options = { onlyToken: false }; }
/** @type {?} */
var data = null;
if (options.onlyToken === true) {
data = ( /** @type {?} */(this.get()));
data.token = "";
this.set(data);
}
else {
// tslint:disable-next-line:no-non-null-assertion
this.store.remove(( /** @type {?} */(this._options.store_key)));
}
this.change$.next(data);
};
/**
* 订阅 Token 对象变更通知
* @return {?}
*/
TokenService.prototype.change = function () {
return this.change$.pipe(operators.share());
};
return TokenService;
}());
/** @nocollapse */
TokenService.ctorParameters = function () { return [
{ type: BixiConfigService },
{ type: undefined, decorators: [{ type: i0.Inject, args: [BIXI_STORE_TOKEN,] }] }
]; };
if (false) {
/**
* @type {?}
* @private
*/
TokenService.prototype.change$;
/**
* @type {?}
* @private
*/
TokenService.prototype._referrer;
/**
* @type {?}
* @private
*/
TokenService.prototype._options;
/**
* @type {?}
* @private
*/
TokenService.prototype.store;
}
/**
* @return {?}
*/
function BIXI_SERVICE_TOKEN_FACTORY() {
return new TokenService(i0.inject(BixiConfigService), i0.inject(BIXI_STORE_TOKEN));
}
/**
* @fileoverview added by tsickle
* Generated from: src/token/interface.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var BIXI_SERVICE_TOKEN = new i0.InjectionToken('BIXI_SERVICE_TOKEN', {
providedIn: 'root',
factory: BIXI_SERVICE_TOKEN_FACTORY
});
/**
* @record
*/
function ITokenModel() { }
if (false) {
/** @type {?} */
ITokenModel.prototype.token;
/* Skipping unhandled member: [key: string]: any;*/
}
/**
* @record
*/
function AuthReferrer() { }
if (false) {
/** @type {?|undefined} */
AuthReferrer.prototype.url;
}
/**
* @record
*/
function ITokenService() { }
if (false) {
/**
* 获取登录地址
* @type {?}
*/
ITokenService.prototype.login_url;
/**
* 获取授权失败前路由信息
* @type {?|undefined}
*/
ITokenService.prototype.referrer;
/** @type {?} */
ITokenService.prototype.options;
/**
* @param {?} data
* @return {?}
*/
ITokenService.prototype.set = function (data) { };
/**
* 获取Token，形式包括：
* - `get()` 获取 Simple Token
* - `get<JWTTokenModel>(JWTTokenModel)` 获取 JWT Token
* @param {?=} type
* @return {?}
*/
ITokenService.prototype.get = function (type) { };
/**
* 获取Token，形式包括：
* - `get()` 获取 Simple Token
* - `get<JWTTokenModel>(JWTTokenModel)` 获取 JWT Token
* @template T
* @param {?=} type
* @return {?}
*/
ITokenService.prototype.get = function (type) { };
/**
* Clean authorization data
* @param {?=} options
* @return {?}
*/
ITokenService.prototype.clear = function (options) { };
/**
* @return {?}
*/
ITokenService.prototype.change = function () { };
}
/**
* @fileoverview added by tsickle
* Generated from: src/social/social.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var OPENTYPE = '_bixiAuthSocialType';
/** @type {?} */
var HREFCALLBACK = '_bixiAuthSocialCallbackByHref';
var SocialService = /** @class */ (function () {
/**
* @param {?} tokenService
* @param {?} doc
* @param {?} router
*/
function SocialService(tokenService, doc, router) {
this.tokenService = tokenService;
this.doc = doc;
this.router = router;
}
/**
* 跳转至登录页，若为 `type=window` 时，返回值是 `Observable<ITokenModel>`
* @param {?} url 获取授权地址
* @param {?=} callback 当 `type=href` 成功时的回调路由地址
* @param {?=} options options.type 打开方式，默认 `window` options.windowFeatures 等同 `window.open` 的 `features` 参数值
* @return {?}
*/
SocialService.prototype.login = function (url, callback, options) {
var _this = this;
if (callback === void 0) { callback = '/'; }
if (options === void 0) { options = {}; }
options = Object.assign({ type: 'window', windowFeatures: 'location=yes,height=570,width=520,scrollbars=yes,status=yes' }, options);
// tslint:disable-next-line:no-non-null-assertion
localStorage.setItem(OPENTYPE, ( /** @type {?} */(options.type)));
localStorage.setItem(HREFCALLBACK, callback);
if (options.type === 'href') {
this.doc.location.href = url;
return;
}
this._win = window.open(url, '_blank', options.windowFeatures);
this._winTime = setInterval(( /**
* @return {?}
*/function () {
if (_this._win && _this._win.closed) {
_this.ngOnDestroy();
/** @type {?} */
var model = _this.tokenService.get();
if (model && !model.token)
model = null;
// 触发变更通知
if (model) {
_this.tokenService.set(model);
}
_this.observer.next(model);
_this.observer.complete();
}
}), 100);
return new rxjs.Observable(( /**
* @param {?} observer
* @return {?}
*/function (observer) {
_this.observer = observer;
}));
};
/**
* 授权成功后的回调处理
*
* @param {?=} rawData 指定回调认证信息，为空时从根据当前URL解析
* @return {?}
*/
SocialService.prototype.callback = function (rawData) {
// from uri
if (!rawData && this.router.url.indexOf('?') === -1) {
throw new Error("url muse contain a ?");
}
// parse
/** @type {?} */
var data = { token: "" };
if (typeof rawData === 'string') {
/** @type {?} */
var rightUrl = rawData.split('?')[1].split('#')[0];
data = ( /** @type {?} */(this.router.parseUrl('./?' + rightUrl).queryParams));
}
else {
data = ( /** @type {?} */(rawData));
}
if (!data || !data.token)
throw new Error("invalide token data");
this.tokenService.set(data);
/** @type {?} */
var url = localStorage.getItem(HREFCALLBACK) || '/';
localStorage.removeItem(HREFCALLBACK);
/** @type {?} */
var type = localStorage.getItem(OPENTYPE);
localStorage.removeItem(OPENTYPE);
if (type === 'window') {
window.close();
}
else {
this.router.navigateByUrl(url);
}
return data;
};
/**
* @return {?}
*/
SocialService.prototype.ngOnDestroy = function () {
clearInterval(this._winTime);
this._winTime = null;
};
return SocialService;
}());
SocialService.decorators = [
{ type: i0.Injectable }
];
/** @nocollapse */
SocialService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: i0.Inject, args: [BIXI_SERVICE_TOKEN,] }] },
{ type: undefined, decorators: [{ type: i0.Inject, args: [common.DOCUMENT,] }] },
{ type: router.Router }
]; };
if (false) {
/**
* @type {?}
* @private
*/
SocialService.prototype._win;
/**
* @type {?}
* @private
*/
SocialService.prototype._winTime;
/**
* @type {?}
* @private
*/
SocialService.prototype.observer;
/**
* @type {?}
* @private
*/
SocialService.prototype.tokenService;
/**
* @type {?}
* @private
*/
SocialService.prototype.doc;
/**
* @type {?}
* @private
*/
SocialService.prototype.router;
}
/**
* @fileoverview added by tsickle
* Generated from: src/store/memory.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* 内存存储，关掉浏览器标签后**丢失**。
*
* ```ts
* { provide: BIXI_STORE_TOKEN, useClass: MemoryStore }
* ```
*/
var MemoryStore = /** @class */ (function () {
function MemoryStore() {
this.cache = {};
}
/**
* @param {?} key
* @return {?}
*/
MemoryStore.prototype.get = function (key) {
return this.cache[key] || (( /** @type {?} */({})));
};
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
MemoryStore.prototype.set = function (key, value) {
this.cache[key] = value;
return true;
};
/**
* @param {?} key
* @return {?}
*/
MemoryStore.prototype.remove = function (key) {
this.cache[key] = null;
};
return MemoryStore;
}());
if (false) {
/**
* @type {?}
* @private
*/
MemoryStore.prototype.cache;
}
/**
* @fileoverview added by tsickle
* Generated from: src/store/session-storage.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* `sessionStorage` storage, **lost after closing the browser**.
*
* ```ts
* { provide: BIXI_STORE_TOKEN, useClass: SessionStorageStore }
* ```
*/
var SessionStorageStore = /** @class */ (function () {
function SessionStorageStore() {
}
/**
* @param {?} key
* @return {?}
*/
SessionStorageStore.prototype.get = function (key) {
return JSON.parse(sessionStorage.getItem(key) || '{}') || {};
};
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
SessionStorageStore.prototype.set = function (key, value) {
sessionStorage.setItem(key, JSON.stringify(value));
return true;
};
/**
* @param {?} key
* @return {?}
*/
SessionStorageStore.prototype.remove = function (key) {
sessionStorage.removeItem(key);
};
return SessionStorageStore;
}());
/**
* @fileoverview added by tsickle
* Generated from: src/store/cookie-storage.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* `cookie` storage, muse be install
* [js-cookie](https://github.com/js-cookie/js-cookie) library
* and import `"node_modules/js-cookie/src/js.cookie.js"` in `angular.json`
*
* ```ts
* { provide: BIXI_STORE_TOKEN, useClass: CookieStorageStore }
* ```
*/
var CookieStorageStore = /** @class */ (function () {
function CookieStorageStore() {
}
/**
* @param {?} key
* @return {?}
*/
CookieStorageStore.prototype.get = function (key) {
return JSON.parse(Cookies.get(key) || '{}') || {};
};
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
CookieStorageStore.prototype.set = function (key, value) {
Cookies.set(key, JSON.stringify(value));
return true;
};
/**
* @param {?} key
* @return {?}
*/
CookieStorageStore.prototype.remove = function (key) {
Cookies.remove(key);
};
return CookieStorageStore;
}());
/**
* @fileoverview added by tsickle
* Generated from: src/token/helper.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} model
* @return {?}
*/
function CheckSimple(model) {
return model != null && typeof model.token === 'string' && model.token.length > 0;
}
/**
* @param {?} model
* @param {?} offset
* @return {?}
*/
function CheckJwt(model, offset) {
return model != null && !!model.token && !model.isExpired(offset);
}
/**
* @param {?} options
* @param {?} injector
* @param {?=} url
* @return {?}
*/
function ToLogin(options, injector, url) {
/** @type {?} */
var router$1 = injector.get(router.Router);
// tslint:disable-next-line:no-non-null-assertion
( /** @type {?} */((( /** @type {?} */(injector.get(BIXI_SERVICE_TOKEN)))).referrer)).url = url || router$1.url;
if (options.token_invalid_redirect === true) {
setTimeout(( /**
* @return {?}
*/function () {
// tslint:disable-next-line:no-non-null-assertion
if (/^https?:\/\//g.test(( /** @type {?} */(options.login_url)))) {
injector.get(common.DOCUMENT).location.href = ( /** @type {?} */(options.login_url));
}
else {
router$1.navigate([options.login_url]);
}
}));
}
}
var HttpAuthInterceptorHandler = /** @class */ (function () {
/**
* @param {?} next
* @param {?} interceptor
*/
function HttpAuthInterceptorHandler(next, interceptor) {
this.next = next;
this.interceptor = interceptor;
}
// tslint:disable-next-line:no-any
/**
* @param {?} req
* @return {?}
*/
HttpAuthInterceptorHandler.prototype.handle = function (req) {
return this.interceptor.intercept(req, this.next);
};
return HttpAuthInterceptorHandler;
}());
if (false) {
/**
* @type {?}
* @private
*/
HttpAuthInterceptorHandler.prototype.next;
/**
* @type {?}
* @private
*/
HttpAuthInterceptorHandler.prototype.interceptor;
}
/**
* @abstract
*/
var BaseInterceptor = /** @class */ (function () {
/**
* @param {?} injector
*/
function BaseInterceptor(injector) {
this.injector = injector;
}
// tslint:disable-next-line:no-any
/**
* @param {?} req
* @param {?} next
* @return {?}
*/
BaseInterceptor.prototype.intercept = function (req, next) {
var e_1, _a;
/** @type {?} */
var options = mergeConfig(this.injector.get(BixiConfigService));
if (options.ignores) {
try {
for (var _b = __values(( /** @type {?} */(options.ignores))), _c = _b.next(); !_c.done; _c = _b.next()) {
var item = _c.value;
if (item.test(req.url))
return next.handle(req);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
}
if (options.allow_anonymous_key &&
(req.params.has(options.allow_anonymous_key) || new RegExp("[?|&]" + options.allow_anonymous_key + "=[^&]+").test(req.urlWithParams))) {
return next.handle(req);
}
if (this.isAuth(options)) {
req = this.setReq(req, options);
}
else {
console.warn('[@bixi/auth](interceptor): Token 不存在或已过期，前往登录页');
ToLogin(options, this.injector);
// Interrupt Http request, so need to generate a new Observable
// tslint:disable-next-line:no-any
/** @type {?} */
var err$_1 = new rxjs.Observable(( /**
* @param {?} observer
* @return {?}
*/function (observer) {
/** @type {?} */
var res = new http.HttpErrorResponse({
url: req.url,
headers: req.headers,
status: 401,
statusText: "\u6765\u81EA @bixi/auth \u7684\u62E6\u622A\uFF0C\u6240\u8BF7\u6C42URL\u672A\u6388\u6743\uFF0C\u82E5\u662F\u767B\u5F55API\u53EF\u52A0\u5165 [url?_allow_anonymous=true] \u6765\u8868\u793A\u5FFD\u7565\u6821\u9A8C"
});
observer.error(res);
}));
if (options.executeOtherInterceptors) {
/** @type {?} */
var interceptors = this.injector.get(http.HTTP_INTERCEPTORS, []);
/** @type {?} */
var lastInterceptors = interceptors.slice(interceptors.indexOf(this) + 1);
if (lastInterceptors.length > 0) {
/** @type {?} */
var chain = lastInterceptors.reduceRight(( /**
* @param {?} _next
* @param {?} _interceptor
* @return {?}
*/function (_next, _interceptor) { return new HttpAuthInterceptorHandler(_next, _interceptor); }), {
// tslint:disable-next-line:no-any
handle: ( /**
* @param {?} _
* @return {?}
*/function (_) { return err$_1; })
});
return chain.handle(req);
}
}
return err$_1;
}
return next.handle(req);
};
return BaseInterceptor;
}());
BaseInterceptor.decorators = [
{ type: i0.Injectable }
];
/** @nocollapse */
BaseInterceptor.ctorParameters = function () { return [
{ type: i0.Injector, decorators: [{ type: i0.Optional }] }
]; };
if (false) {
/**
* @type {?}
* @protected
*/
BaseInterceptor.prototype.model;
/**
* @type {?}
* @protected
*/
BaseInterceptor.prototype.injector;
/**
* @abstract
* @param {?} options
* @return {?}
*/
BaseInterceptor.prototype.isAuth = function (options) { };
/**
* @abstract
* @param {?} req
* @param {?} options
* @return {?}
*/
BaseInterceptor.prototype.setReq = function (req, options) { };
}
/**
* @fileoverview added by tsickle
* Generated from: src/token/jwt/jwt.helper.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @param {?} str
* @return {?}
*/
function urlBase64Decode(str) {
/** @type {?} */
var output = str.replace(/-/g, '+').replace(/_/g, '/');
switch (output.length % 4) {
case 0: {
break;
}
case 2: {
output += '==';
break;
}
case 3: {
output += '=';
break;
}
default: {
throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
}
}
return b64DecodeUnicode(output);
}
/**
* @param {?} str
* @return {?}
*/
function b64decode(str) {
/** @type {?} */
var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
/** @type {?} */
var output = '';
str = String(str).replace(/=+$/, '');
for (
// initialize result and counters
// tslint:disable:no-conditional-assignment binary-expression-operand-order
// tslint:disable-next-line:no-any
var bc = 0, bs = void 0,