Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

vap

Package Overview
Dependencies
Maintainers
1
Versions
568
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

vap - npm Package Compare versions

Comparing version 1.2.7 to 1.2.8

layouts/screen/CountUp/index.d.ts
layouts/screen/CountUp/index.js
layouts/screen/ScrollList/index.d.ts
layouts/screen/ScrollList/index.js
utils/Format.d.ts
utils/Format.js

2

layouts/admin/ListModal/index.js

@@ -25,2 +25,3 @@ "use strict";

var utils_1 = require("../../../utils");
// Ajax
/**

@@ -39,3 +40,2 @@ * @private

* 2. 可以弹出一个单选或多选框，选一条或多条数据后，返回给页面
*
*/

@@ -42,0 +42,0 @@ var ListModal = /** @class */ (function (_super) {

2

layouts/screen/Comments/Comment.d.ts

@@ -5,3 +5,3 @@ /// <reference types="react" />

/**
* 组件
* 基本规范的大屏组件
*/

@@ -8,0 +8,0 @@ export default class extends React.PureComponent<CommentProps> {

20

layouts/screen/Comments/Comment.js

@@ -24,3 +24,3 @@ "use strict";

/**
* 组件
* 基本规范的大屏组件
*/

@@ -43,12 +43,10 @@ var default_1 = /** @class */ (function (_super) {

}
if (this.props.style) {
_.extend(param.style, this.props.style, {
width: this.props.width,
height: this.props.height,
left: this.props.left,
top: this.props.top,
position: 'absolute'
});
}
return React.createElement("div", __assign({ style: {} }, param), this.props.children);
_.extend(param.style, this.props.style, {
width: this.props.width,
height: this.props.height,
left: this.props.left,
top: this.props.top,
position: 'absolute'
});
return React.createElement("div", __assign({}, param), this.props.children);
};

@@ -55,0 +53,0 @@ return default_1;

24

layouts/screen/Comments/interface.d.ts
/// <reference types="react" />
import * as React from 'react';
/**
* 大屏组件属性
*/
export interface CommentProps {
/**
* 组件样式，说明：width height left top position 的样式会使用 参数的，在这里写无效
*/
style?: React.CSSProperties;
/**
* class 属性
*/
className?: string;
/**
* id属性
*/
id?: string;
/**
* 组件宽度
*/
width: number | string;
/**
* 组件高度
*/
height: number | string;
/**
* 组件左边距
*/
left: number | string;
/**
* 组件上边距
*/
top: number | string;
}

2

layouts/screen/index.d.ts
export { default as Page } from './Page';
export { default as Comment } from './Comments/Comment';
export { default as ScrollList } from './ScrollList';
export { default as CountUp } from './CountUp';

4

layouts/screen/index.js

@@ -7,1 +7,5 @@ "use strict";

exports.Comment = Comment_1.default;
var ScrollList_1 = require("./ScrollList");
exports.ScrollList = ScrollList_1.default;
var CountUp_1 = require("./CountUp");
exports.CountUp = CountUp_1.default;

3

layouts/screen/Page/index.d.ts
/// <reference types="react" />
import * as React from 'react';
/**
* 大屏组件根节点，用 <Page> 包住后，可实现自动resize，收放
*/
export default class extends React.PureComponent<{

@@ -4,0 +7,0 @@ diff?: number;

3

layouts/screen/Page/index.js

@@ -48,2 +48,5 @@ "use strict";

}
/**
* 大屏组件根节点，用 <Page> 包住后，可实现自动resize，收放
*/
var default_1 = /** @class */ (function (_super) {

@@ -50,0 +53,0 @@ __extends(default_1, _super);

2

package.json
{
"name": "vap",
"version": "1.2.7",
"version": "1.2.8",
"description": "vap",

@@ -5,0 +5,0 @@ "main": "index.js",

168

utils/Ajax.d.ts

@@ -1,11 +0,157 @@

declare const _default: {
GET: (url: string, callback?: Function) => Promise<any>;
POST: (url: any, param: any, callback?: Function) => Promise<any>;
PUT: (url: any, param: any, callback?: Function) => Promise<any>;
PATCH: (url: any, param: any, callback?: Function) => Promise<any>;
DELETE: (url: any, param: any, callback?: Function) => Promise<any>;
WHEN: (...pos: Promise<void>[]) => Promise<void[]>;
SESION: (...urls: string[]) => void;
CLEAR: (...urls: string[]) => void;
};
export default _default;
/**
* Ajax 工具类
*/
export default abstract class {
/**
* 发送 HTTP GET 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： GET 通常用来获取特定不变的数据
*
* @param url 请求接口链接地址
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 额外说明 ： GET 方法支持浏览器前端缓存，可以预先将需要缓存的地址通过 Ajax.SESSION() 方法传入，对于已经缓存的地址不会发出实际的网络请求
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.GET('/api-url',json=>console.log(json));
*
* // 通过 异步队列 使用
* const all = yield Ajax.GET('/api-url');
* console.log(all);
* ```
*/
static GET(url: string, callback?: Function): Promise<any>;
/**
* 发送 HTTP POST 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： POST 通常用来做复杂的条件查询
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.POST('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.POST('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
static POST(url: any, param: any, callback?: Function): Promise<any>;
/**
* 发送 HTTP PUT 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PUT 通常用来做对象的新增
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PUT('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PUT('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
static PUT(url: any, param: any, callback?: Function): Promise<any>;
/**
* 发送 HTTP PATCH 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PATCH 通常用来做对象的修改
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PATCH('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PATCH('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
static PATCH(url: any, param: any, callback?: Function): Promise<any>;
/**
* 发送 HTTP DELETE 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： DELETE 通常用来做对象的删除
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.DELETE('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.DELETE('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
static DELETE(url: any, param: any, callback?: Function): Promise<any>;
/**
* 请多个请求一起返回了再处理，两个以上请求时，可以使用
* @param 异步请求列表
* 示例
* ```
Ajax.WHEN(
Ajax.GET('/api-common/user'),
Ajax.GET('/api-common/user/ip'),
Ajax.POST('/api-common/user',{})
).then(function(resp){
console.log(resp[0],resp[1],resp[2]);
});
* ```
*/
static WHEN(...pos: Promise<void>[]): Promise<void[]>;
/**
* 注册需要缓存的链接地址
* 此URL 在一次打开的过程中只会请求一次，
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
static SESION(...urls: string[]): void;
/**
* 清除接口本地缓存
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
static CLEAR(...urls: string[]): void;
}

601

utils/Ajax.js

@@ -129,320 +129,329 @@ "use strict";

/**
* 发送 HTTP GET 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： GET 通常用来获取特定不变的数据
*
* @param url 请求接口链接地址
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 额外说明 ： GET 方法支持浏览器前端缓存，可以预先将需要缓存的地址通过 Ajax.SESSION() 方法传入，对于已经缓存的地址不会发出实际的网络请求
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.GET('/api-url',json=>console.log(json));
*
* // 通过 异步队列 使用
* const all = yield Ajax.GET('/api-url');
* console.log(all);
* ```
* Ajax 工具类
*/
function GET(url, callback) {
return __awaiter(this, void 0, void 0, function () {
var json_1, data, json, data_1, resp;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 4];
if (!!CACHE_URL.has(url)) return [3 /*break*/, 2];
return [4 /*yield*/, request(url)];
case 1:
json_1 = _a.sent();
callback.call(null, json_1);
return [2 /*return*/];
case 2:
data = Cache_1.default.sessionData(url);
if (data) {
callback.call(null, data);
var default_1 = /** @class */ (function () {
function default_1() {
}
/**
* 发送 HTTP GET 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： GET 通常用来获取特定不变的数据
*
* @param url 请求接口链接地址
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 额外说明 ： GET 方法支持浏览器前端缓存，可以预先将需要缓存的地址通过 Ajax.SESSION() 方法传入，对于已经缓存的地址不会发出实际的网络请求
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.GET('/api-url',json=>console.log(json));
*
* // 通过 异步队列 使用
* const all = yield Ajax.GET('/api-url');
* console.log(all);
* ```
*/
default_1.GET = function (url, callback) {
return __awaiter(this, void 0, void 0, function () {
var json_1, data, json, data_1, resp;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 4];
if (!!CACHE_URL.has(url)) return [3 /*break*/, 2];
return [4 /*yield*/, request(url)];
case 1:
json_1 = _a.sent();
callback.call(null, json_1);
return [2 /*return*/];
}
return [4 /*yield*/, request(url)];
case 3:
json = _a.sent();
Cache_1.default.sessionData(url, json);
callback.call(null, json);
return [3 /*break*/, 5];
case 4:
if (!CACHE_URL.has(url)) {
return [2 /*return*/, request(url)];
}
data_1 = Cache_1.default.sessionData(url);
if (data_1) {
return [2 /*return*/, new Promise(function (resolve) {
resolve(data_1);
})];
}
resp = request(url);
resp.then(function (json) {
case 2:
data = Cache_1.default.sessionData(url);
if (data) {
callback.call(null, data);
return [2 /*return*/];
}
return [4 /*yield*/, request(url)];
case 3:
json = _a.sent();
Cache_1.default.sessionData(url, json);
});
return [2 /*return*/, resp];
case 5: return [2 /*return*/];
}
callback.call(null, json);
return [3 /*break*/, 5];
case 4:
if (!CACHE_URL.has(url)) {
return [2 /*return*/, request(url)];
}
data_1 = Cache_1.default.sessionData(url);
if (data_1) {
return [2 /*return*/, new Promise(function (resolve) {
resolve(data_1);
})];
}
resp = request(url);
resp.then(function (json) {
Cache_1.default.sessionData(url, json);
});
return [2 /*return*/, resp];
case 5: return [2 /*return*/];
}
});
});
});
}
/**
* 发送 HTTP POST 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： POST 通常用来做复杂的条件查询
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.POST('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.POST('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
function POST(url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
};
/**
* 发送 HTTP POST 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： POST 通常用来做复杂的条件查询
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.POST('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.POST('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
default_1.POST = function (url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
method: 'POST',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'POST',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'POST',
body: param
})];
case 3: return [2 /*return*/];
}
case 3: return [2 /*return*/];
}
});
});
});
}
/**
* 发送 HTTP PUT 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PUT 通常用来做对象的新增
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PUT('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PUT('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
function PUT(url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
};
/**
* 发送 HTTP PUT 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PUT 通常用来做对象的新增
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PUT('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PUT('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
default_1.PUT = function (url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
method: 'PUT',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'PUT',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'PUT',
body: param
})];
case 3: return [2 /*return*/];
}
case 3: return [2 /*return*/];
}
});
});
});
}
/**
* 发送 HTTP PATCH 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PATCH 通常用来做对象的修改
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PATCH('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PATCH('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
function PATCH(url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
};
/**
* 发送 HTTP PATCH 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： PATCH 通常用来做对象的修改
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.PATCH('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.PATCH('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
default_1.PATCH = function (url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
method: 'PATCH',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'PATCH',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'PATCH',
body: param
})];
case 3: return [2 /*return*/];
}
case 3: return [2 /*return*/];
}
});
});
});
}
/**
* 发送 HTTP DELETE 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： DELETE 通常用来做对象的删除
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.DELETE('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.DELETE('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
function DELETE(url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
};
/**
* 发送 HTTP DELETE 请求，支持 **回调函数** 与 **异步队列** 方式进行请求
* 按 RESTFUL 规范说明 ： DELETE 通常用来做对象的删除
*
* @param url 请求接口链接地址
* @param param 请求参数，调用时会参数的 `json格式` 传给接口
* @param callback 回调函数，如果没有设置，则返回一个 Promise对象
* @returns 如果没有指定回调函数，则返回一个 Promise对象
*
* 代码示例：
* ```javascript
* // 通过 回调函数 使用
* import {Ajax} from 'utils'
* Ajax.DELETE('/api-url',{status:0,find:'name'},json=>console.log(json));
*
* // 通过 异步队列 使用
* const resp = yield Ajax.DELETE('/api-url',{status:0,find:'name'});
* console.log(resp);
* ```
*/
default_1.DELETE = function (url, param, callback) {
return __awaiter(this, void 0, void 0, function () {
var json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!callback) return [3 /*break*/, 2];
return [4 /*yield*/, request(url, {
method: 'DELETE',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'DELETE',
body: param
})];
case 1:
json = _a.sent();
callback.call(null, json);
return [3 /*break*/, 3];
case 2: return [2 /*return*/, request(url, {
method: 'DELETE',
body: param
})];
case 3: return [2 /*return*/];
}
case 3: return [2 /*return*/];
}
});
});
});
}
/**
* 请多个请求一起返回了再处理，两个以上请求时，可以使用
* @param 异步请求列表
* 示例
* ```
Ajax.WHEN(
Ajax.GET('/api-common/user'),
Ajax.GET('/api-common/user/ip'),
Ajax.POST('/api-common/user',{})
).then(function(resp){
console.log(resp[0],resp[1],resp[2]);
});
* ```
*/
function WHEN() {
var pos = [];
for (var _a = 0; _a < arguments.length; _a++) {
pos[_a] = arguments[_a];
}
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, Promise.all(pos)];
};
/**
* 请多个请求一起返回了再处理，两个以上请求时，可以使用
* @param 异步请求列表
* 示例
* ```
Ajax.WHEN(
Ajax.GET('/api-common/user'),
Ajax.GET('/api-common/user/ip'),
Ajax.POST('/api-common/user',{})
).then(function(resp){
console.log(resp[0],resp[1],resp[2]);
});
* ```
*/
default_1.WHEN = function () {
var pos = [];
for (var _a = 0; _a < arguments.length; _a++) {
pos[_a] = arguments[_a];
}
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
return [2 /*return*/, Promise.all(pos)];
});
});
});
}
/**
* 注册需要缓存的链接地址
* 此URL 在一次打开的过程中只会请求一次，
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
function SESION() {
var urls = [];
for (var _a = 0; _a < arguments.length; _a++) {
urls[_a] = arguments[_a];
}
urls.map(function (url) {
if (!CACHE_URL.has(url)) {
CACHE_URL.add(url);
};
/**
* 注册需要缓存的链接地址
* 此URL 在一次打开的过程中只会请求一次，
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
default_1.SESION = function () {
var urls = [];
for (var _a = 0; _a < arguments.length; _a++) {
urls[_a] = arguments[_a];
}
});
}
;
/**
* 清除接口本地缓存
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
function CLEAR() {
var urls = [];
for (var _a = 0; _a < arguments.length; _a++) {
urls[_a] = arguments[_a];
}
urls.map(function (url) {
if (!CACHE_URL.has(url)) {
Cache_1.default.sessionDelete(url);
urls.map(function (url) {
if (!CACHE_URL.has(url)) {
CACHE_URL.add(url);
}
});
};
;
/**
* 清除接口本地缓存
* @param urls 接口地址列表，只支持 GET 接口
* 如果需要清除，可以调用 Ajax.CLEAR(url) 来清除
* 示例
* ```
* Ajax.SESSION('/url1','/url2','/url3');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.GET('/url1');
* Ajax.CLEAR('/url1','/url2');
* ```
*
*/
default_1.CLEAR = function () {
var urls = [];
for (var _a = 0; _a < arguments.length; _a++) {
urls[_a] = arguments[_a];
}
});
}
exports.default = { GET: GET, POST: POST, PUT: PUT, PATCH: PATCH, DELETE: DELETE, WHEN: WHEN, SESION: SESION, CLEAR: CLEAR };
urls.map(function (url) {
if (!CACHE_URL.has(url)) {
Cache_1.default.sessionDelete(url);
}
});
};
return default_1;
}());
exports.default = default_1;
// export default { GET, POST, PUT, PATCH, DELETE, WHEN,SESION,CLEAR }

131

utils/Cache.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* @private
*/
var CACHE = {};
/**
* @private
*/
var session = sessionStorage;
exports.default = {
// 暂时注释掉还未使用的方法
// /**
// * 获取缓存
// */
// GET:function(key:string ,def:any= null){
// if(_.has(CACHE,key)){
// return CACHE[key];
// }
// return def;
// },
// /**
// * 设置缓存
// */
// SET:function(key:string ,value:any){
// if(value===null){
// _.unset(CACHE,key);
// }else{
// CACHE[key]==value;
// }
// },
// /**
// * 监听缓存，当值变化时，回调
// */
// LISTEN:function(key:string,callback:Function){
// console.log(key);
// },
/**
* 删除SESSION缓存
*/
sessionDelete: function (key) {
session.removeItem(key);
},
/**
* 获取（传`key`参数）,设置（同时传`key`,`value`参数）
* @param key key
* @param value val 需要是对象或数组类型
*
*/
sessionData: function (key, value) {
if (value === void 0) { value = undefined; }
if (value !== undefined) {
var txt = JSON.stringify(value);
session.setItem(key, txt);
// 暂时注释掉还未使用的方法
// /**
// * 获取缓存
// */
// GET:function(key:string ,def:any= null){
// if(_.has(CACHE,key)){
// return CACHE[key];
// }
// return def;
// },
// /**
// * 设置缓存
// */
// SET:function(key:string ,value:any){
// if(value===null){
// _.unset(CACHE,key);
// }else{
// CACHE[key]==value;
// }
// },
// /**
// * 监听缓存，当值变化时，回调
// */
// LISTEN:function(key:string,callback:Function){
// console.log(key);
// },
/**
* 删除SESSION缓存
*/
function sessionDelete(key) {
session.removeItem(key);
}
/**
* 获取（传`key`参数）,设置（同时传`key`,`value`参数）
* @param key key
* @param value val 需要是对象或数组类型
*
*/
function sessionData(key, value) {
if (value === void 0) { value = undefined; }
if (value !== undefined) {
var txt = JSON.stringify(value);
session.setItem(key, txt);
}
else {
if (session.getItem(key)) {
return JSON.parse(session.getItem(key));
}
else {
if (session.getItem(key)) {
return JSON.parse(session.getItem(key));
}
}
return '';
},
/**
* 获取（传`key`参数）,设置（同时传`key`,`value`参数）
* @param key key
* @param value val 字符串类型
*
*/
sessionString: function (key, value) {
if (value) {
session.setItem(key, value);
}
return session.getItem(key);
}
};
return '';
}
/**
* 获取（传`key`参数）,设置（同时传`key`,`value`参数）
* @param key key
* @param value val 字符串类型
*
*/
function sessionString(key, value) {
if (value) {
session.setItem(key, value);
}
return session.getItem(key);
}
exports.default = { sessionDelete: sessionDelete, sessionData: sessionData, sessionString: sessionString };

70

utils/Const.d.ts

@@ -1,28 +0,78 @@

declare const _default: {
PAGE_OPTIONS: string[];
STATUS_OPTION: {
export default abstract class {
/**
* 通用分页
*/
static PAGE_OPTIONS: string[];
/**
* 启用 / 禁用 Switch 开关选项，用于表单元素的输入
* ```
* {name:'启用',value:'0'},
* {name:'禁用',value:'1'}
* ```
*/
static STATUS_OPTION: {
name: string;
value: string;
}[];
STATUS_FILTER: {
/**
* 全部 / 启用 / 禁用 过滤器 定义，用于 Table 头上的过滤搜索
* ```
* {name:'全部',value:''},
* {name:'启用',value:'0'},
* {name:'禁用',value:'1'}
* ```
*/
static STATUS_FILTER: {
name: string;
value: string;
}[];
STATUS_MAP: {
/**
* 启用 / 禁用 映射文字，用于将值传为文字进行显示
* ```
* {
* '0':'是',
* '1':'否'
* }
* ```
*/
static STATUS_MAP: {
'0': string;
'1': string;
};
IS_NOT_OPTION: {
/**
* 是 / 否 Switch 开关选项，用于表单元素的输入
* ```
* {name:'是',value:'0'},
* {name:'否',value:'1'}
* ```
*/
static IS_NOT_OPTION: {
name: string;
value: string;
}[];
IS_NOT_FILTER: {
/**
* 全部 / 是 / 否 过滤器 定义，用于 Table 头上的过滤搜索
* ```
* {name:'全部',value:''},
* {name:'是',value:'0'},
* {name:'否',value:'1'}
* ```
*/
static IS_NOT_FILTER: {
name: string;
value: string;
}[];
IS_NOT_MAP: {
/**
* 是 / 否 映射文字，用于将值传为文字进行显示
* ```
* {
* '0':'是',
* '1':'否'
* }
* ```
*/
static IS_NOT_MAP: {
'0': string;
'1': string;
};
};
export default _default;
}

22

utils/Const.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = {
var default_1 = /** @class */ (function () {
function default_1() {
}
/**
* 通用分页
*/
PAGE_OPTIONS: ["10", "15", "50", "100"],
default_1.PAGE_OPTIONS = ["10", "15", "50", "100"];
/**

@@ -15,3 +17,3 @@ * 启用 / 禁用 Switch 开关选项，用于表单元素的输入

*/
STATUS_OPTION: [{ name: '启用', value: '0' }, { name: '禁用', value: '1' }],
default_1.STATUS_OPTION = [{ name: '启用', value: '0' }, { name: '禁用', value: '1' }];
/**

@@ -25,3 +27,3 @@ * 全部 / 启用 / 禁用 过滤器 定义，用于 Table 头上的过滤搜索

*/
STATUS_FILTER: [{ name: '全部', value: '' }, { name: '启用', value: '0' }, { name: '禁用', value: '1' }],
default_1.STATUS_FILTER = [{ name: '全部', value: '' }, { name: '启用', value: '0' }, { name: '禁用', value: '1' }];
/**

@@ -36,3 +38,3 @@ * 启用 / 禁用 映射文字，用于将值传为文字进行显示

*/
STATUS_MAP: { '0': '启用', '1': '禁用' },
default_1.STATUS_MAP = { '0': '启用', '1': '禁用' };
/**

@@ -45,3 +47,3 @@ * 是 / 否 Switch 开关选项，用于表单元素的输入

*/
IS_NOT_OPTION: [{ name: '是', value: '0' }, { name: '否', value: '1' }],
default_1.IS_NOT_OPTION = [{ name: '是', value: '0' }, { name: '否', value: '1' }];
/**

@@ -55,3 +57,3 @@ * 全部 / 是 / 否 过滤器 定义，用于 Table 头上的过滤搜索

*/
IS_NOT_FILTER: [{ name: '全部', value: '' }, { name: '是', value: '0' }, { name: '否', value: '1' }],
default_1.IS_NOT_FILTER = [{ name: '全部', value: '' }, { name: '是', value: '0' }, { name: '否', value: '1' }];
/**

@@ -66,3 +68,5 @@ * 是 / 否 映射文字，用于将值传为文字进行显示

*/
IS_NOT_MAP: { '0': '是', '1': '否' },
};
default_1.IS_NOT_MAP = { '0': '是', '1': '否' };
return default_1;
}());
exports.default = default_1;

1

utils/index.d.ts

@@ -6,1 +6,2 @@ export { default as Ajax } from './Ajax';

export { default as Renders } from './Renders';
export { default as Format } from './Format';

2

utils/index.js

@@ -13,1 +13,3 @@ "use strict";

exports.Renders = Renders_1.default;
var Format_1 = require("./Format");
exports.Format = Format_1.default;

2

utils/Renders.d.ts

@@ -41,5 +41,5 @@ /**

declare const _default: {
statusRender: (statusMap?: StatusMap, def?: string) => Render;
strRender: (len?: number, hasDot?: boolean, className?: string) => Render;
listRender: (arr?: any[], value?: string, name?: string, def?: string) => Render;
statusRender: (statusMap?: StatusMap, def?: string) => Render;
momentRender: (time?: boolean, nearly?: number, format?: string) => Render;

@@ -46,0 +46,0 @@ htmlRender: (className?: string) => (val: any) => JSX.Element;

283

utils/Renders.js

@@ -7,81 +7,98 @@ "use strict";

var moment = require("moment");
exports.default = {
/**
* 字符串截取 Render
* @param len 截取长度，默认为 20
* @param hasDot 是否有3个省略号 默认为 true
* @param className className
*/
strRender: function (len, hasDot, className) {
if (len === void 0) { len = 20; }
if (hasDot === void 0) { hasDot = true; }
if (className === void 0) { className = ''; }
var fn = function (str) {
var newLength = 0;
var newStr = [];
var chineseRegex = /[^\x00-\xff]/g;
var singleChar = "";
var strLength = str.replace(chineseRegex, "**").length;
for (var i = 0; i < strLength; i++) {
singleChar = str.charAt(i).toString();
if (singleChar.match(chineseRegex) !== null) {
newLength += 2;
}
else {
newLength++;
}
if (newLength > len) {
break;
}
newStr.push(singleChar);
/**
* 字符串截取 Render
* @param len 截取长度，默认为 20
* @param hasDot 是否有3个省略号 默认为 true
* @param className className
*/
function strRender(len, hasDot, className) {
if (len === void 0) { len = 20; }
if (hasDot === void 0) { hasDot = true; }
if (className === void 0) { className = ''; }
var fn = function (str) {
var newLength = 0;
var newStr = [];
var chineseRegex = /[^\x00-\xff]/g;
var singleChar = "";
var strLength = str.replace(chineseRegex, "**").length;
for (var i = 0; i < strLength; i++) {
singleChar = str.charAt(i).toString();
if (singleChar.match(chineseRegex) !== null) {
newLength += 2;
}
if (hasDot && strLength > len) {
newStr.push("...");
else {
newLength++;
}
return React.createElement("span", { className: className }, newStr.join(''));
};
return fn;
},
/**
* 列表 Render 构造器
* @param arr 默认为一个空数组
* @param value 数据对应取值的字段 默认为 'id'
* @param name 数据对应显示的字段 默认为 'name'
* @param def 数据没有找到时的字段 默认为 '未知'
*/
listRender: function (arr, value, name, def) {
if (arr === void 0) { arr = []; }
if (value === void 0) { value = 'id'; }
if (name === void 0) { name = 'name'; }
if (def === void 0) { def = '未知'; }
var VALUES = {};
arr.map(function (item) {
if (newLength > len) {
break;
}
newStr.push(singleChar);
}
if (hasDot && strLength > len) {
newStr.push("...");
}
return React.createElement("span", { className: className }, newStr.join(''));
};
return fn;
}
/**
* 列表 Render 构造器
* @param arr 默认为一个空数组
* @param value 数据对应取值的字段 默认为 'id'
* @param name 数据对应显示的字段 默认为 'name'
* @param def 数据没有找到时的字段 默认为 '未知'
*/
function listRender(arr, value, name, def) {
if (arr === void 0) { arr = []; }
if (value === void 0) { value = 'id'; }
if (name === void 0) { name = 'name'; }
if (def === void 0) { def = '未知'; }
var VALUES = {};
arr.map(function (item) {
VALUES[item[value]] = item[name];
});
var fn = function (val) {
var key = val + '';
var text = def;
if (_.has(VALUES, key)) {
text = VALUES[key];
}
return React.createElement("span", null, text);
};
fn.update = function (list) {
VALUES = {};
list.map(function (item) {
VALUES[item[value]] = item[name];
});
var fn = function (val) {
var key = val + '';
var text = def;
if (_.has(VALUES, key)) {
text = VALUES[key];
}
return React.createElement("span", null, text);
};
fn.update = function (list) {
VALUES = {};
list.map(function (item) {
VALUES[item[value]] = item[name];
});
};
return fn;
},
/**
* 状态 Render 构造器
* @param statusMap 一个StatusMap 默认为 { success: { name: '正常', value: 0 }, error: { name: '异常', value: 1 } }
* @param def 数据没有找到时的显示名称 默认为 '未知'
*/
statusRender: function (statusMap, def) {
if (statusMap === void 0) { statusMap = { success: { name: '正常', value: 0 }, error: { name: '异常', value: 1 } }; }
if (def === void 0) { def = '未知'; }
var STYLES = {};
var VALUES = {};
};
return fn;
}
/**
* 状态 Render 构造器
* @param statusMap 一个StatusMap 默认为 { success: { name: '正常', value: 0 }, error: { name: '异常', value: 1 } }
* @param def 数据没有找到时的显示名称 默认为 '未知'
*/
function statusRender(statusMap, def) {
if (statusMap === void 0) { statusMap = { success: { name: '正常', value: 0 }, error: { name: '异常', value: 1 } }; }
if (def === void 0) { def = '未知'; }
var STYLES = {};
var VALUES = {};
_.keys(statusMap).map(function (style) {
var key = statusMap[style].value + '';
STYLES[key] = style;
VALUES[key] = statusMap[style].name;
});
var fn = function (val) {
var key = val + '';
var style = 'default';
var text = def;
if (_.has(VALUES, key)) {
text = VALUES[key];
}
if (_.has(STYLES, key)) {
style = STYLES[key];
}
return React.createElement(antd_1.Badge, { status: style, text: text });
};
fn.update = function (statusMap) {
_.keys(statusMap).map(function (style) {

@@ -92,68 +109,50 @@ var key = statusMap[style].value + '';

});
var fn = function (val) {
var key = val + '';
var style = 'default';
var text = def;
if (_.has(VALUES, key)) {
text = VALUES[key];
}
if (_.has(STYLES, key)) {
style = STYLES[key];
}
return React.createElement(antd_1.Badge, { status: style, text: text });
};
fn.update = function (statusMap) {
_.keys(statusMap).map(function (style) {
var key = statusMap[style].value + '';
STYLES[key] = style;
VALUES[key] = statusMap[style].name;
});
};
return fn;
},
/**
* 时间 Render 构造器
* @param time 是否显示时分秒，默认为 true 即 `YYYY-MM-DD HH:mm:ss`, 设置为 `false` 则显示为'YYYY-MM-DD'
* @param nearly 最近 {x} 天 时，转换为 moment 方式显示，比如 5秒前，15小时前，2天前等等。 默认为 3
* @param format 时间参数的格式，默认为空，如果是特别格式，请指定此参数，否则不好解析
*
*/
momentRender: function (time, nearly, format) {
if (time === void 0) { time = true; }
if (nearly === void 0) { nearly = 3; }
if (format === void 0) { format = null; }
var now = moment();
var from = now.unix();
var fn = function (val) {
var time = format ? moment(val, format) : moment(new Date(val));
var to = time.unix();
var diff = from - to;
var txt = '';
if (diff >= 0 && diff < 86400 * nearly) {
txt = time.fromNow();
}
else if (time) {
txt = time.format('YYYY-MM-DD HH:mm:ss');
}
else {
txt = time.format('YYYY-MM-DD');
}
return React.createElement("span", null, txt);
};
fn.update = function () {
now = moment();
from = now.unix();
};
return fn;
},
/**
* 返回一个 htmlRender，用于显示自定义的html,会用div包住
* @param className 包住自定义html的 className 默认为空
*/
htmlRender: function (className) {
if (className === void 0) { className = ''; }
return function (val) {
return React.createElement("div", { className: className, dangerouslySetInnerHTML: { __html: val } });
};
}
};
};
return fn;
}
/**
* 时间 Render 构造器
* @param time 是否显示时分秒，默认为 true 即 `YYYY-MM-DD HH:mm:ss`, 设置为 `false` 则显示为'YYYY-MM-DD'
* @param nearly 最近 {x} 天 时，转换为 moment 方式显示，比如 5秒前，15小时前，2天前等等。 默认为 3
* @param format 时间参数的格式，默认为空，如果是特别格式，请指定此参数，否则不好解析
*
*/
function momentRender(time, nearly, format) {
if (time === void 0) { time = true; }
if (nearly === void 0) { nearly = 3; }
if (format === void 0) { format = null; }
var now = moment();
var from = now.unix();
var fn = function (val) {
var time = format ? moment(val, format) : moment(new Date(val));
var to = time.unix();
var diff = from - to;
var txt = '';
if (diff >= 0 && diff < 86400 * nearly) {
txt = time.fromNow();
}
else if (time) {
txt = time.format('YYYY-MM-DD HH:mm:ss');
}
else {
txt = time.format('YYYY-MM-DD');
}
return React.createElement("span", null, txt);
};
fn.update = function () {
now = moment();
from = now.unix();
};
return fn;
}
/**
* 返回一个 htmlRender，用于显示自定义的html,会用div包住
* @param className 包住自定义html的 className 默认为空
*/
function htmlRender(className) {
if (className === void 0) { className = ''; }
return function (val) {
return React.createElement("div", { className: className, dangerouslySetInnerHTML: { __html: val } });
};
}
exports.default = { statusRender: statusRender, strRender: strRender, listRender: listRender, momentRender: momentRender, htmlRender: htmlRender };
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc