phecda-core 1.0.5 → 1.0.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +11 -12
- package/dist/index.js +185 -92
- package/dist/index.mjs +182 -91
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -2,17 +2,11 @@ interface PhecdaNameSpace {
|
|
|
2
2
|
[name: string]: Phecda;
|
|
3
3
|
}
|
|
4
4
|
interface UsePipeOptions {
|
|
5
|
-
transform
|
|
6
|
-
collectError
|
|
5
|
+
transform?: boolean;
|
|
6
|
+
collectError?: boolean;
|
|
7
7
|
}
|
|
8
8
|
interface PhecdaHandler {
|
|
9
|
-
|
|
10
|
-
pipe?: (instance: any) => void;
|
|
11
|
-
rule?: RegExp | string | Function | number;
|
|
12
|
-
info?: string;
|
|
13
|
-
meta?: any;
|
|
14
|
-
error?: any;
|
|
15
|
-
http?: any;
|
|
9
|
+
[key: string]: any;
|
|
16
10
|
}
|
|
17
11
|
interface Phecda {
|
|
18
12
|
_namespace: {
|
|
@@ -22,13 +16,14 @@ interface Phecda {
|
|
|
22
16
|
__IGNORE_VAR__: Set<PropertyKey>;
|
|
23
17
|
__STATE_VAR__: Set<PropertyKey>;
|
|
24
18
|
__STATE_HANDLER__: Map<PropertyKey, PhecdaHandler[]>;
|
|
19
|
+
__STATE_NAMESPACE__: Map<PropertyKey, Object>;
|
|
25
20
|
};
|
|
26
21
|
}
|
|
27
22
|
type ClassValue<I> = {
|
|
28
23
|
[P in keyof I]: I[P] extends Function ? undefined : I[P];
|
|
29
24
|
};
|
|
30
25
|
|
|
31
|
-
declare function plainToClass<M extends new (...args: any) => any, Data extends Record<PropertyKey, any>>(Model: M, input: Data, options?:
|
|
26
|
+
declare function plainToClass<M extends new (...args: any) => any, Data extends Record<PropertyKey, any>>(Model: M, input: Data, options?: UsePipeOptions): Promise<{
|
|
32
27
|
err: string[];
|
|
33
28
|
data: InstanceType<M>;
|
|
34
29
|
}>;
|
|
@@ -87,11 +82,13 @@ declare function Window(target: any): void;
|
|
|
87
82
|
|
|
88
83
|
declare function validate(p: RegExp | string | Function | Object | Number, v: any): Promise<any>;
|
|
89
84
|
declare function getTag<M extends new (...args: any) => any>(Model: M): any;
|
|
85
|
+
declare function mergeOptions(obj1: any, obj2?: any): any;
|
|
90
86
|
|
|
87
|
+
declare function isPhecda(target: any): any;
|
|
91
88
|
declare function init(target: Phecda): void;
|
|
92
89
|
declare function regisInitEvent(target: Phecda, key: string): void;
|
|
93
90
|
declare function getInitEvent(target: Phecda): string[];
|
|
94
|
-
declare function
|
|
91
|
+
declare function setModalVar(target: Phecda, key: PropertyKey): void;
|
|
95
92
|
declare function setExposeKey(target: Phecda, key: PropertyKey): void;
|
|
96
93
|
declare function setIgnoreKey(target: Phecda, key: PropertyKey): void;
|
|
97
94
|
declare function getModelState(target: Phecda): string[];
|
|
@@ -99,6 +96,8 @@ declare function getExposeKey(target: Phecda): string[];
|
|
|
99
96
|
declare function getIgnoreKey(target: Phecda): string[];
|
|
100
97
|
declare function regisHandler(target: Phecda, key: PropertyKey, handler: PhecdaHandler): void;
|
|
101
98
|
declare function getHandler(target: Phecda, key: PropertyKey): PhecdaHandler[];
|
|
99
|
+
declare function mergeState(target: Phecda, key: PropertyKey, state: any): void;
|
|
100
|
+
declare function getState(target: Phecda, key: PropertyKey): Object | undefined;
|
|
102
101
|
declare function register(instance: Phecda): void;
|
|
103
102
|
|
|
104
103
|
declare function isArray(info?: string): (obj: any, key: PropertyKey) => void;
|
|
@@ -126,4 +125,4 @@ declare function getProperty(key: string): any;
|
|
|
126
125
|
|
|
127
126
|
declare function Watcher(eventName: string): (obj: any, key: string) => void;
|
|
128
127
|
|
|
129
|
-
export { ClassValue, Clear, Err, Get, Ignore, Init, Phecda, PhecdaHandler, PhecdaNameSpace, Pipe, Rule, Storage, Tag, UsePipeOptions, Watcher, Window, activeInstance, addDecoToClass, classToValue, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, getProperty, getTag, init, injectProperty, isArray, isBoolean, isCnName, isDate, isEnName, isHexColor, isIdCard, isLandline, isMailBox, isMobile, isNumber, isObject, isPostalCode, isString, isWechat, plainToClass, regisHandler, regisInitEvent, register, setExposeKey, setIgnoreKey,
|
|
128
|
+
export { ClassValue, Clear, Err, Get, Ignore, Init, Phecda, PhecdaHandler, PhecdaNameSpace, Pipe, Rule, Storage, Tag, UsePipeOptions, Watcher, Window, activeInstance, addDecoToClass, classToValue, getExposeKey, getHandler, getIgnoreKey, getInitEvent, getModelState, getProperty, getState, getTag, init, injectProperty, isArray, isBoolean, isCnName, isDate, isEnName, isHexColor, isIdCard, isLandline, isMailBox, isMobile, isNumber, isObject, isPhecda, isPostalCode, isString, isWechat, mergeOptions, mergeState, plainToClass, regisHandler, regisInitEvent, register, setExposeKey, setIgnoreKey, setModalVar, snapShot, to, toNumber, toString, validate };
|
package/dist/index.js
CHANGED
|
@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
|
|
|
3
3
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
4
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
5
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
6
|
+
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
6
7
|
var __export = (target, all) => {
|
|
7
8
|
for (var name in all)
|
|
8
9
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
@@ -40,6 +41,7 @@ __export(src_exports, {
|
|
|
40
41
|
getInitEvent: () => getInitEvent,
|
|
41
42
|
getModelState: () => getModelState,
|
|
42
43
|
getProperty: () => getProperty,
|
|
44
|
+
getState: () => getState,
|
|
43
45
|
getTag: () => getTag,
|
|
44
46
|
init: () => init,
|
|
45
47
|
injectProperty: () => injectProperty,
|
|
@@ -54,17 +56,20 @@ __export(src_exports, {
|
|
|
54
56
|
isMailBox: () => isMailBox,
|
|
55
57
|
isMobile: () => isMobile,
|
|
56
58
|
isNumber: () => isNumber,
|
|
57
|
-
isObject: () =>
|
|
59
|
+
isObject: () => isObject2,
|
|
60
|
+
isPhecda: () => isPhecda,
|
|
58
61
|
isPostalCode: () => isPostalCode,
|
|
59
62
|
isString: () => isString,
|
|
60
63
|
isWechat: () => isWechat,
|
|
64
|
+
mergeOptions: () => mergeOptions,
|
|
65
|
+
mergeState: () => mergeState,
|
|
61
66
|
plainToClass: () => plainToClass,
|
|
62
67
|
regisHandler: () => regisHandler,
|
|
63
68
|
regisInitEvent: () => regisInitEvent,
|
|
64
69
|
register: () => register,
|
|
65
70
|
setExposeKey: () => setExposeKey,
|
|
66
71
|
setIgnoreKey: () => setIgnoreKey,
|
|
67
|
-
|
|
72
|
+
setModalVar: () => setModalVar,
|
|
68
73
|
snapShot: () => snapShot,
|
|
69
74
|
to: () => to,
|
|
70
75
|
toNumber: () => toNumber,
|
|
@@ -73,7 +78,50 @@ __export(src_exports, {
|
|
|
73
78
|
});
|
|
74
79
|
module.exports = __toCommonJS(src_exports);
|
|
75
80
|
|
|
81
|
+
// src/utils.ts
|
|
82
|
+
async function validate(p, v) {
|
|
83
|
+
if (typeof p === "string" || typeof p === "number") {
|
|
84
|
+
if (v === p)
|
|
85
|
+
return true;
|
|
86
|
+
}
|
|
87
|
+
if (typeof p === "function")
|
|
88
|
+
return p(v);
|
|
89
|
+
if (p instanceof RegExp)
|
|
90
|
+
return p.test(v);
|
|
91
|
+
return false;
|
|
92
|
+
}
|
|
93
|
+
__name(validate, "validate");
|
|
94
|
+
function getTag(Model) {
|
|
95
|
+
return Model.prototype?._namespace?.__TAG__;
|
|
96
|
+
}
|
|
97
|
+
__name(getTag, "getTag");
|
|
98
|
+
function mergeOptions(obj1, obj2) {
|
|
99
|
+
if (!obj2)
|
|
100
|
+
return obj1;
|
|
101
|
+
for (const i in obj2) {
|
|
102
|
+
if (isObject(obj1[i]) && isObject(obj2[i])) {
|
|
103
|
+
mergeOptions(obj1[i], obj2[i]);
|
|
104
|
+
continue;
|
|
105
|
+
}
|
|
106
|
+
if (Array.isArray(obj1[i]) && Array.isArray(obj2[i])) {
|
|
107
|
+
obj1[i].push(...obj2[i].filter((item) => !obj1[i].includes(item)));
|
|
108
|
+
continue;
|
|
109
|
+
}
|
|
110
|
+
obj1[i] = obj2[i];
|
|
111
|
+
}
|
|
112
|
+
return obj1;
|
|
113
|
+
}
|
|
114
|
+
__name(mergeOptions, "mergeOptions");
|
|
115
|
+
function isObject(obj) {
|
|
116
|
+
return Object.prototype.toString.call(obj) === "[object Object]";
|
|
117
|
+
}
|
|
118
|
+
__name(isObject, "isObject");
|
|
119
|
+
|
|
76
120
|
// src/core.ts
|
|
121
|
+
function isPhecda(target) {
|
|
122
|
+
return target && !!target.prototype._namespace;
|
|
123
|
+
}
|
|
124
|
+
__name(isPhecda, "isPhecda");
|
|
77
125
|
function init(target) {
|
|
78
126
|
if (!target._namespace) {
|
|
79
127
|
target._namespace = {
|
|
@@ -82,53 +130,89 @@ function init(target) {
|
|
|
82
130
|
__EXPOSE_VAR__: /* @__PURE__ */ new Set(),
|
|
83
131
|
__IGNORE_VAR__: /* @__PURE__ */ new Set(),
|
|
84
132
|
__STATE_VAR__: /* @__PURE__ */ new Set(),
|
|
85
|
-
__STATE_HANDLER__: /* @__PURE__ */ new Map()
|
|
133
|
+
__STATE_HANDLER__: /* @__PURE__ */ new Map(),
|
|
134
|
+
__STATE_NAMESPACE__: /* @__PURE__ */ new Map()
|
|
86
135
|
};
|
|
87
136
|
}
|
|
88
137
|
}
|
|
138
|
+
__name(init, "init");
|
|
89
139
|
function regisInitEvent(target, key) {
|
|
90
140
|
init(target);
|
|
91
141
|
target._namespace.__INIT_EVENT__.add(key);
|
|
92
142
|
}
|
|
143
|
+
__name(regisInitEvent, "regisInitEvent");
|
|
93
144
|
function getInitEvent(target) {
|
|
94
145
|
init(target);
|
|
95
|
-
return [
|
|
146
|
+
return [
|
|
147
|
+
...target._namespace.__INIT_EVENT__
|
|
148
|
+
];
|
|
96
149
|
}
|
|
97
|
-
|
|
150
|
+
__name(getInitEvent, "getInitEvent");
|
|
151
|
+
function setModalVar(target, key) {
|
|
98
152
|
init(target);
|
|
99
153
|
target._namespace.__STATE_VAR__.add(key);
|
|
100
154
|
setExposeKey(target, key);
|
|
101
155
|
}
|
|
156
|
+
__name(setModalVar, "setModalVar");
|
|
102
157
|
function setExposeKey(target, key) {
|
|
103
158
|
init(target);
|
|
104
159
|
target._namespace.__EXPOSE_VAR__.add(key);
|
|
105
160
|
}
|
|
161
|
+
__name(setExposeKey, "setExposeKey");
|
|
106
162
|
function setIgnoreKey(target, key) {
|
|
107
163
|
init(target);
|
|
108
164
|
target._namespace.__IGNORE_VAR__.add(key);
|
|
109
165
|
}
|
|
166
|
+
__name(setIgnoreKey, "setIgnoreKey");
|
|
110
167
|
function getModelState(target) {
|
|
111
168
|
init(target);
|
|
112
|
-
return [
|
|
169
|
+
return [
|
|
170
|
+
...target._namespace.__STATE_VAR__
|
|
171
|
+
];
|
|
113
172
|
}
|
|
173
|
+
__name(getModelState, "getModelState");
|
|
114
174
|
function getExposeKey(target) {
|
|
115
175
|
init(target);
|
|
116
|
-
return [
|
|
176
|
+
return [
|
|
177
|
+
...target._namespace.__EXPOSE_VAR__
|
|
178
|
+
];
|
|
117
179
|
}
|
|
180
|
+
__name(getExposeKey, "getExposeKey");
|
|
118
181
|
function getIgnoreKey(target) {
|
|
119
182
|
init(target);
|
|
120
|
-
return [
|
|
183
|
+
return [
|
|
184
|
+
...target._namespace.__IGNORE_VAR__
|
|
185
|
+
];
|
|
121
186
|
}
|
|
187
|
+
__name(getIgnoreKey, "getIgnoreKey");
|
|
122
188
|
function regisHandler(target, key, handler) {
|
|
123
189
|
init(target);
|
|
124
190
|
if (!target._namespace.__STATE_HANDLER__.has(key))
|
|
125
|
-
target._namespace.__STATE_HANDLER__.set(key, [
|
|
191
|
+
target._namespace.__STATE_HANDLER__.set(key, [
|
|
192
|
+
handler
|
|
193
|
+
]);
|
|
126
194
|
else
|
|
127
195
|
target._namespace.__STATE_HANDLER__.get(key).push(handler);
|
|
128
196
|
}
|
|
197
|
+
__name(regisHandler, "regisHandler");
|
|
129
198
|
function getHandler(target, key) {
|
|
130
199
|
return target._namespace.__STATE_HANDLER__.get(key) || [];
|
|
131
200
|
}
|
|
201
|
+
__name(getHandler, "getHandler");
|
|
202
|
+
function mergeState(target, key, state) {
|
|
203
|
+
const namespace = target._namespace.__STATE_NAMESPACE__;
|
|
204
|
+
if (!namespace.has(key))
|
|
205
|
+
namespace.set(key, state);
|
|
206
|
+
else
|
|
207
|
+
mergeOptions(namespace.get(key), state);
|
|
208
|
+
}
|
|
209
|
+
__name(mergeState, "mergeState");
|
|
210
|
+
function getState(target, key) {
|
|
211
|
+
const namespace = target._namespace.__STATE_NAMESPACE__;
|
|
212
|
+
if (namespace)
|
|
213
|
+
return namespace.get(key);
|
|
214
|
+
}
|
|
215
|
+
__name(getState, "getState");
|
|
132
216
|
function register(instance) {
|
|
133
217
|
const stateVars = getModelState(instance);
|
|
134
218
|
for (const item of stateVars) {
|
|
@@ -137,19 +221,21 @@ function register(instance) {
|
|
|
137
221
|
hanlder.init?.(instance);
|
|
138
222
|
}
|
|
139
223
|
}
|
|
224
|
+
__name(register, "register");
|
|
140
225
|
|
|
141
226
|
// src/decorators.ts
|
|
142
227
|
function Init(target, key) {
|
|
143
|
-
|
|
228
|
+
setModalVar(target, key);
|
|
144
229
|
regisHandler(target, key, {
|
|
145
230
|
async init(instance) {
|
|
146
231
|
instance[key]();
|
|
147
232
|
}
|
|
148
233
|
});
|
|
149
234
|
}
|
|
235
|
+
__name(Init, "Init");
|
|
150
236
|
function Rule(rule, info, meta) {
|
|
151
237
|
return (obj, key) => {
|
|
152
|
-
|
|
238
|
+
setModalVar(obj, key);
|
|
153
239
|
regisHandler(obj, key, {
|
|
154
240
|
rule,
|
|
155
241
|
info,
|
|
@@ -157,9 +243,11 @@ function Rule(rule, info, meta) {
|
|
|
157
243
|
});
|
|
158
244
|
};
|
|
159
245
|
}
|
|
246
|
+
__name(Rule, "Rule");
|
|
160
247
|
function Ignore(target, key) {
|
|
161
248
|
setIgnoreKey(target, key);
|
|
162
249
|
}
|
|
250
|
+
__name(Ignore, "Ignore");
|
|
163
251
|
function Clear(target, key) {
|
|
164
252
|
init(target);
|
|
165
253
|
target._namespace.__INIT_EVENT__.delete(key);
|
|
@@ -168,20 +256,23 @@ function Clear(target, key) {
|
|
|
168
256
|
target._namespace.__STATE_VAR__.delete(key);
|
|
169
257
|
target._namespace.__STATE_HANDLER__.delete(key);
|
|
170
258
|
}
|
|
259
|
+
__name(Clear, "Clear");
|
|
171
260
|
function Err(cb) {
|
|
172
261
|
return (target, key) => {
|
|
173
|
-
|
|
262
|
+
setModalVar(target, key);
|
|
174
263
|
regisHandler(target, key, {
|
|
175
264
|
error: cb
|
|
176
265
|
});
|
|
177
266
|
};
|
|
178
267
|
}
|
|
268
|
+
__name(Err, "Err");
|
|
179
269
|
function Get(target, key) {
|
|
180
270
|
setExposeKey(target, key);
|
|
181
271
|
}
|
|
272
|
+
__name(Get, "Get");
|
|
182
273
|
function Pipe(v) {
|
|
183
274
|
return (obj, key) => {
|
|
184
|
-
|
|
275
|
+
setModalVar(obj, key);
|
|
185
276
|
regisHandler(obj, key, {
|
|
186
277
|
async pipe(instance) {
|
|
187
278
|
const tasks = v.value;
|
|
@@ -191,19 +282,21 @@ function Pipe(v) {
|
|
|
191
282
|
});
|
|
192
283
|
};
|
|
193
284
|
}
|
|
285
|
+
__name(Pipe, "Pipe");
|
|
194
286
|
function Tag(tag) {
|
|
195
287
|
return (target) => {
|
|
196
288
|
init(target.prototype);
|
|
197
289
|
target.prototype._namespace.__TAG__ = tag;
|
|
198
290
|
};
|
|
199
291
|
}
|
|
292
|
+
__name(Tag, "Tag");
|
|
200
293
|
function Storage(target) {
|
|
201
294
|
init(target.prototype);
|
|
202
295
|
const tag = target.prototype._namespace.__TAG__;
|
|
203
296
|
if (tag === "")
|
|
204
297
|
throw new Error("miss tag");
|
|
205
298
|
const uniTag = Symbol(tag);
|
|
206
|
-
|
|
299
|
+
setModalVar(target.prototype, uniTag);
|
|
207
300
|
regisHandler(target.prototype, uniTag, {
|
|
208
301
|
init: (instance) => {
|
|
209
302
|
const { state } = instance;
|
|
@@ -219,6 +312,7 @@ function Storage(target) {
|
|
|
219
312
|
}
|
|
220
313
|
});
|
|
221
314
|
}
|
|
315
|
+
__name(Storage, "Storage");
|
|
222
316
|
function Window(target) {
|
|
223
317
|
if (!window.__PHECDA__)
|
|
224
318
|
window.__PHECDA__ = {};
|
|
@@ -226,53 +320,44 @@ function Window(target) {
|
|
|
226
320
|
if (tag)
|
|
227
321
|
window.__PHECDA__[tag] = target;
|
|
228
322
|
}
|
|
229
|
-
|
|
230
|
-
// src/utils.ts
|
|
231
|
-
async function validate(p, v) {
|
|
232
|
-
if (typeof p === "string" || typeof p === "number") {
|
|
233
|
-
if (v === p)
|
|
234
|
-
return true;
|
|
235
|
-
}
|
|
236
|
-
if (typeof p === "function")
|
|
237
|
-
return p(v);
|
|
238
|
-
if (p instanceof RegExp)
|
|
239
|
-
return p.test(v);
|
|
240
|
-
return false;
|
|
241
|
-
}
|
|
242
|
-
function getTag(Model) {
|
|
243
|
-
return Model.prototype?._namespace?.__TAG__;
|
|
244
|
-
}
|
|
323
|
+
__name(Window, "Window");
|
|
245
324
|
|
|
246
325
|
// src/helper.ts
|
|
247
326
|
async function plainToClass(Model, input, options = {}) {
|
|
248
327
|
const data = new Model();
|
|
249
|
-
const resolvedOptions = {
|
|
250
|
-
collectError: true,
|
|
251
|
-
transform: false,
|
|
252
|
-
...options
|
|
253
|
-
};
|
|
254
328
|
const err = [];
|
|
255
329
|
const stateVars = getModelState(data);
|
|
256
330
|
for (const item of stateVars) {
|
|
257
331
|
data[item] = input[item];
|
|
258
332
|
const handlers = getHandler(data, item);
|
|
259
333
|
if (handlers) {
|
|
260
|
-
|
|
261
|
-
const
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
334
|
+
if (options.collectError !== false) {
|
|
335
|
+
for (const handler of handlers) {
|
|
336
|
+
const rule = handler.rule;
|
|
337
|
+
if (rule && !await validate(rule, data[item])) {
|
|
338
|
+
err.push(handler.info || "");
|
|
339
|
+
if (!options.collectError)
|
|
340
|
+
break;
|
|
341
|
+
}
|
|
266
342
|
}
|
|
267
343
|
}
|
|
268
|
-
if (err.length > 0 && !
|
|
269
|
-
return {
|
|
270
|
-
|
|
271
|
-
|
|
344
|
+
if (err.length > 0 && !options.transform)
|
|
345
|
+
return {
|
|
346
|
+
err,
|
|
347
|
+
data
|
|
348
|
+
};
|
|
349
|
+
if (options.transform !== false) {
|
|
350
|
+
for (const handler of handlers)
|
|
351
|
+
await handler.pipe?.(data);
|
|
352
|
+
}
|
|
272
353
|
}
|
|
273
354
|
}
|
|
274
|
-
return {
|
|
355
|
+
return {
|
|
356
|
+
data,
|
|
357
|
+
err
|
|
358
|
+
};
|
|
275
359
|
}
|
|
360
|
+
__name(plainToClass, "plainToClass");
|
|
276
361
|
function classToValue(instance) {
|
|
277
362
|
const data = {};
|
|
278
363
|
const exposeVar = getExposeKey(instance);
|
|
@@ -284,11 +369,16 @@ function classToValue(instance) {
|
|
|
284
369
|
}
|
|
285
370
|
return data;
|
|
286
371
|
}
|
|
372
|
+
__name(classToValue, "classToValue");
|
|
287
373
|
function to(task, oldTasks) {
|
|
288
374
|
const tasks = oldTasks || [];
|
|
289
375
|
tasks.push(task);
|
|
290
|
-
return {
|
|
376
|
+
return {
|
|
377
|
+
to: (task2) => to(task2, tasks),
|
|
378
|
+
value: tasks
|
|
379
|
+
};
|
|
291
380
|
}
|
|
381
|
+
__name(to, "to");
|
|
292
382
|
function snapShot(data) {
|
|
293
383
|
const snap = {};
|
|
294
384
|
for (const i in data)
|
|
@@ -305,96 +395,88 @@ function snapShot(data) {
|
|
|
305
395
|
}
|
|
306
396
|
};
|
|
307
397
|
}
|
|
398
|
+
__name(snapShot, "snapShot");
|
|
308
399
|
function addDecoToClass(c, key, handler, type = "normal") {
|
|
309
400
|
handler(type === "normal" ? c.prototype : c, key);
|
|
310
401
|
}
|
|
402
|
+
__name(addDecoToClass, "addDecoToClass");
|
|
311
403
|
|
|
312
404
|
// src/preset/rule.ts
|
|
313
405
|
function isArray(info) {
|
|
314
406
|
return Rule((param) => Array.isArray(param), info || "it should be an array");
|
|
315
407
|
}
|
|
408
|
+
__name(isArray, "isArray");
|
|
316
409
|
function isBoolean(info) {
|
|
317
|
-
return Rule((param) => [
|
|
410
|
+
return Rule((param) => [
|
|
411
|
+
true,
|
|
412
|
+
false
|
|
413
|
+
].includes(param), info || "it should be true or false");
|
|
318
414
|
}
|
|
415
|
+
__name(isBoolean, "isBoolean");
|
|
319
416
|
function isNumber(info) {
|
|
320
417
|
return Rule((param) => typeof param === "number", info || "it should be true or false");
|
|
321
418
|
}
|
|
419
|
+
__name(isNumber, "isNumber");
|
|
322
420
|
function isString(info) {
|
|
323
421
|
return Rule((param) => typeof param === "string", info || "it should be a string");
|
|
324
422
|
}
|
|
325
|
-
|
|
423
|
+
__name(isString, "isString");
|
|
424
|
+
function isObject2(info) {
|
|
326
425
|
return Rule((param) => {
|
|
327
426
|
return Object.prototype.toString.call(param) === "[object Object]";
|
|
328
427
|
}, info || "it should be an object");
|
|
329
428
|
}
|
|
429
|
+
__name(isObject2, "isObject");
|
|
330
430
|
function isMobile(info) {
|
|
331
|
-
return Rule(
|
|
332
|
-
/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/,
|
|
333
|
-
info || "it should be a mobile phone number"
|
|
334
|
-
);
|
|
431
|
+
return Rule(/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/, info || "it should be a mobile phone number");
|
|
335
432
|
}
|
|
433
|
+
__name(isMobile, "isMobile");
|
|
336
434
|
function isLandline(info) {
|
|
337
|
-
return Rule(
|
|
338
|
-
/\d{3}-\d{8}|\d{4}-\d{7}/,
|
|
339
|
-
info || "it should be a mobile phone number"
|
|
340
|
-
);
|
|
435
|
+
return Rule(/\d{3}-\d{8}|\d{4}-\d{7}/, info || "it should be a mobile phone number");
|
|
341
436
|
}
|
|
437
|
+
__name(isLandline, "isLandline");
|
|
342
438
|
function isMailBox(info) {
|
|
343
|
-
return Rule(
|
|
344
|
-
/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
|
|
345
|
-
info || "it should be a mailbox number"
|
|
346
|
-
);
|
|
439
|
+
return Rule(/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, info || "it should be a mailbox number");
|
|
347
440
|
}
|
|
441
|
+
__name(isMailBox, "isMailBox");
|
|
348
442
|
function isIdCard(info) {
|
|
349
|
-
return Rule(
|
|
350
|
-
/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/,
|
|
351
|
-
info || "it should be an identity card number"
|
|
352
|
-
);
|
|
443
|
+
return Rule(/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/, info || "it should be an identity card number");
|
|
353
444
|
}
|
|
445
|
+
__name(isIdCard, "isIdCard");
|
|
354
446
|
function isCnName(info) {
|
|
355
|
-
return Rule(
|
|
356
|
-
/^([\u4E00-\u9FA5·]{2,16})$/,
|
|
357
|
-
info || "\u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57"
|
|
358
|
-
);
|
|
447
|
+
return Rule(/^([\u4E00-\u9FA5·]{2,16})$/, info || "\u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57");
|
|
359
448
|
}
|
|
449
|
+
__name(isCnName, "isCnName");
|
|
360
450
|
function isEnName(info) {
|
|
361
|
-
return Rule(
|
|
362
|
-
/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/,
|
|
363
|
-
info || "it should be a valid en-name"
|
|
364
|
-
);
|
|
451
|
+
return Rule(/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/, info || "it should be a valid en-name");
|
|
365
452
|
}
|
|
453
|
+
__name(isEnName, "isEnName");
|
|
366
454
|
function isDate(info) {
|
|
367
|
-
return Rule(
|
|
368
|
-
/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/,
|
|
369
|
-
info || "it should be a valid date"
|
|
370
|
-
);
|
|
455
|
+
return Rule(/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/, info || "it should be a valid date");
|
|
371
456
|
}
|
|
457
|
+
__name(isDate, "isDate");
|
|
372
458
|
function isWechat(info) {
|
|
373
|
-
return Rule(
|
|
374
|
-
/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/,
|
|
375
|
-
info || "it should be a valid date"
|
|
376
|
-
);
|
|
459
|
+
return Rule(/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/, info || "it should be a valid date");
|
|
377
460
|
}
|
|
461
|
+
__name(isWechat, "isWechat");
|
|
378
462
|
function isHexColor(info) {
|
|
379
|
-
return Rule(
|
|
380
|
-
/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,
|
|
381
|
-
info || "it should be a valid hex-color"
|
|
382
|
-
);
|
|
463
|
+
return Rule(/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/, info || "it should be a valid hex-color");
|
|
383
464
|
}
|
|
465
|
+
__name(isHexColor, "isHexColor");
|
|
384
466
|
function isPostalCode(info) {
|
|
385
|
-
return Rule(
|
|
386
|
-
/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/,
|
|
387
|
-
info || "it should be a valid postal code"
|
|
388
|
-
);
|
|
467
|
+
return Rule(/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/, info || "it should be a valid postal code");
|
|
389
468
|
}
|
|
469
|
+
__name(isPostalCode, "isPostalCode");
|
|
390
470
|
|
|
391
471
|
// src/preset/pipe.ts
|
|
392
472
|
function toNumber() {
|
|
393
473
|
return Pipe(to((param) => Number(param)));
|
|
394
474
|
}
|
|
475
|
+
__name(toNumber, "toNumber");
|
|
395
476
|
function toString() {
|
|
396
477
|
return Pipe(to((param) => String(param)));
|
|
397
478
|
}
|
|
479
|
+
__name(toString, "toString");
|
|
398
480
|
|
|
399
481
|
// src/namespace.ts
|
|
400
482
|
var activeInstance = {};
|
|
@@ -402,21 +484,28 @@ function injectProperty(key, value) {
|
|
|
402
484
|
activeInstance[key] = value;
|
|
403
485
|
return activeInstance;
|
|
404
486
|
}
|
|
487
|
+
__name(injectProperty, "injectProperty");
|
|
405
488
|
function getProperty(key) {
|
|
406
489
|
return activeInstance[key];
|
|
407
490
|
}
|
|
491
|
+
__name(getProperty, "getProperty");
|
|
408
492
|
|
|
409
493
|
// src/custom/decorator.ts
|
|
410
494
|
function Watcher(eventName) {
|
|
411
495
|
return (obj, key) => {
|
|
412
|
-
|
|
496
|
+
setModalVar(obj, key);
|
|
413
497
|
regisHandler(obj, key, {
|
|
414
498
|
init(instance) {
|
|
415
|
-
getProperty("watcher")?.({
|
|
499
|
+
getProperty("watcher")?.({
|
|
500
|
+
eventName,
|
|
501
|
+
instance,
|
|
502
|
+
key
|
|
503
|
+
});
|
|
416
504
|
}
|
|
417
505
|
});
|
|
418
506
|
};
|
|
419
507
|
}
|
|
508
|
+
__name(Watcher, "Watcher");
|
|
420
509
|
// Annotate the CommonJS export names for ESM import in node:
|
|
421
510
|
0 && (module.exports = {
|
|
422
511
|
Clear,
|
|
@@ -439,6 +528,7 @@ function Watcher(eventName) {
|
|
|
439
528
|
getInitEvent,
|
|
440
529
|
getModelState,
|
|
441
530
|
getProperty,
|
|
531
|
+
getState,
|
|
442
532
|
getTag,
|
|
443
533
|
init,
|
|
444
534
|
injectProperty,
|
|
@@ -454,16 +544,19 @@ function Watcher(eventName) {
|
|
|
454
544
|
isMobile,
|
|
455
545
|
isNumber,
|
|
456
546
|
isObject,
|
|
547
|
+
isPhecda,
|
|
457
548
|
isPostalCode,
|
|
458
549
|
isString,
|
|
459
550
|
isWechat,
|
|
551
|
+
mergeOptions,
|
|
552
|
+
mergeState,
|
|
460
553
|
plainToClass,
|
|
461
554
|
regisHandler,
|
|
462
555
|
regisInitEvent,
|
|
463
556
|
register,
|
|
464
557
|
setExposeKey,
|
|
465
558
|
setIgnoreKey,
|
|
466
|
-
|
|
559
|
+
setModalVar,
|
|
467
560
|
snapShot,
|
|
468
561
|
to,
|
|
469
562
|
toNumber,
|
package/dist/index.mjs
CHANGED
|
@@ -1,4 +1,50 @@
|
|
|
1
|
+
var __defProp = Object.defineProperty;
|
|
2
|
+
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
3
|
+
|
|
4
|
+
// src/utils.ts
|
|
5
|
+
async function validate(p, v) {
|
|
6
|
+
if (typeof p === "string" || typeof p === "number") {
|
|
7
|
+
if (v === p)
|
|
8
|
+
return true;
|
|
9
|
+
}
|
|
10
|
+
if (typeof p === "function")
|
|
11
|
+
return p(v);
|
|
12
|
+
if (p instanceof RegExp)
|
|
13
|
+
return p.test(v);
|
|
14
|
+
return false;
|
|
15
|
+
}
|
|
16
|
+
__name(validate, "validate");
|
|
17
|
+
function getTag(Model) {
|
|
18
|
+
return Model.prototype?._namespace?.__TAG__;
|
|
19
|
+
}
|
|
20
|
+
__name(getTag, "getTag");
|
|
21
|
+
function mergeOptions(obj1, obj2) {
|
|
22
|
+
if (!obj2)
|
|
23
|
+
return obj1;
|
|
24
|
+
for (const i in obj2) {
|
|
25
|
+
if (isObject(obj1[i]) && isObject(obj2[i])) {
|
|
26
|
+
mergeOptions(obj1[i], obj2[i]);
|
|
27
|
+
continue;
|
|
28
|
+
}
|
|
29
|
+
if (Array.isArray(obj1[i]) && Array.isArray(obj2[i])) {
|
|
30
|
+
obj1[i].push(...obj2[i].filter((item) => !obj1[i].includes(item)));
|
|
31
|
+
continue;
|
|
32
|
+
}
|
|
33
|
+
obj1[i] = obj2[i];
|
|
34
|
+
}
|
|
35
|
+
return obj1;
|
|
36
|
+
}
|
|
37
|
+
__name(mergeOptions, "mergeOptions");
|
|
38
|
+
function isObject(obj) {
|
|
39
|
+
return Object.prototype.toString.call(obj) === "[object Object]";
|
|
40
|
+
}
|
|
41
|
+
__name(isObject, "isObject");
|
|
42
|
+
|
|
1
43
|
// src/core.ts
|
|
44
|
+
function isPhecda(target) {
|
|
45
|
+
return target && !!target.prototype._namespace;
|
|
46
|
+
}
|
|
47
|
+
__name(isPhecda, "isPhecda");
|
|
2
48
|
function init(target) {
|
|
3
49
|
if (!target._namespace) {
|
|
4
50
|
target._namespace = {
|
|
@@ -7,53 +53,89 @@ function init(target) {
|
|
|
7
53
|
__EXPOSE_VAR__: /* @__PURE__ */ new Set(),
|
|
8
54
|
__IGNORE_VAR__: /* @__PURE__ */ new Set(),
|
|
9
55
|
__STATE_VAR__: /* @__PURE__ */ new Set(),
|
|
10
|
-
__STATE_HANDLER__: /* @__PURE__ */ new Map()
|
|
56
|
+
__STATE_HANDLER__: /* @__PURE__ */ new Map(),
|
|
57
|
+
__STATE_NAMESPACE__: /* @__PURE__ */ new Map()
|
|
11
58
|
};
|
|
12
59
|
}
|
|
13
60
|
}
|
|
61
|
+
__name(init, "init");
|
|
14
62
|
function regisInitEvent(target, key) {
|
|
15
63
|
init(target);
|
|
16
64
|
target._namespace.__INIT_EVENT__.add(key);
|
|
17
65
|
}
|
|
66
|
+
__name(regisInitEvent, "regisInitEvent");
|
|
18
67
|
function getInitEvent(target) {
|
|
19
68
|
init(target);
|
|
20
|
-
return [
|
|
69
|
+
return [
|
|
70
|
+
...target._namespace.__INIT_EVENT__
|
|
71
|
+
];
|
|
21
72
|
}
|
|
22
|
-
|
|
73
|
+
__name(getInitEvent, "getInitEvent");
|
|
74
|
+
function setModalVar(target, key) {
|
|
23
75
|
init(target);
|
|
24
76
|
target._namespace.__STATE_VAR__.add(key);
|
|
25
77
|
setExposeKey(target, key);
|
|
26
78
|
}
|
|
79
|
+
__name(setModalVar, "setModalVar");
|
|
27
80
|
function setExposeKey(target, key) {
|
|
28
81
|
init(target);
|
|
29
82
|
target._namespace.__EXPOSE_VAR__.add(key);
|
|
30
83
|
}
|
|
84
|
+
__name(setExposeKey, "setExposeKey");
|
|
31
85
|
function setIgnoreKey(target, key) {
|
|
32
86
|
init(target);
|
|
33
87
|
target._namespace.__IGNORE_VAR__.add(key);
|
|
34
88
|
}
|
|
89
|
+
__name(setIgnoreKey, "setIgnoreKey");
|
|
35
90
|
function getModelState(target) {
|
|
36
91
|
init(target);
|
|
37
|
-
return [
|
|
92
|
+
return [
|
|
93
|
+
...target._namespace.__STATE_VAR__
|
|
94
|
+
];
|
|
38
95
|
}
|
|
96
|
+
__name(getModelState, "getModelState");
|
|
39
97
|
function getExposeKey(target) {
|
|
40
98
|
init(target);
|
|
41
|
-
return [
|
|
99
|
+
return [
|
|
100
|
+
...target._namespace.__EXPOSE_VAR__
|
|
101
|
+
];
|
|
42
102
|
}
|
|
103
|
+
__name(getExposeKey, "getExposeKey");
|
|
43
104
|
function getIgnoreKey(target) {
|
|
44
105
|
init(target);
|
|
45
|
-
return [
|
|
106
|
+
return [
|
|
107
|
+
...target._namespace.__IGNORE_VAR__
|
|
108
|
+
];
|
|
46
109
|
}
|
|
110
|
+
__name(getIgnoreKey, "getIgnoreKey");
|
|
47
111
|
function regisHandler(target, key, handler) {
|
|
48
112
|
init(target);
|
|
49
113
|
if (!target._namespace.__STATE_HANDLER__.has(key))
|
|
50
|
-
target._namespace.__STATE_HANDLER__.set(key, [
|
|
114
|
+
target._namespace.__STATE_HANDLER__.set(key, [
|
|
115
|
+
handler
|
|
116
|
+
]);
|
|
51
117
|
else
|
|
52
118
|
target._namespace.__STATE_HANDLER__.get(key).push(handler);
|
|
53
119
|
}
|
|
120
|
+
__name(regisHandler, "regisHandler");
|
|
54
121
|
function getHandler(target, key) {
|
|
55
122
|
return target._namespace.__STATE_HANDLER__.get(key) || [];
|
|
56
123
|
}
|
|
124
|
+
__name(getHandler, "getHandler");
|
|
125
|
+
function mergeState(target, key, state) {
|
|
126
|
+
const namespace = target._namespace.__STATE_NAMESPACE__;
|
|
127
|
+
if (!namespace.has(key))
|
|
128
|
+
namespace.set(key, state);
|
|
129
|
+
else
|
|
130
|
+
mergeOptions(namespace.get(key), state);
|
|
131
|
+
}
|
|
132
|
+
__name(mergeState, "mergeState");
|
|
133
|
+
function getState(target, key) {
|
|
134
|
+
const namespace = target._namespace.__STATE_NAMESPACE__;
|
|
135
|
+
if (namespace)
|
|
136
|
+
return namespace.get(key);
|
|
137
|
+
}
|
|
138
|
+
__name(getState, "getState");
|
|
57
139
|
function register(instance) {
|
|
58
140
|
const stateVars = getModelState(instance);
|
|
59
141
|
for (const item of stateVars) {
|
|
@@ -62,19 +144,21 @@ function register(instance) {
|
|
|
62
144
|
hanlder.init?.(instance);
|
|
63
145
|
}
|
|
64
146
|
}
|
|
147
|
+
__name(register, "register");
|
|
65
148
|
|
|
66
149
|
// src/decorators.ts
|
|
67
150
|
function Init(target, key) {
|
|
68
|
-
|
|
151
|
+
setModalVar(target, key);
|
|
69
152
|
regisHandler(target, key, {
|
|
70
153
|
async init(instance) {
|
|
71
154
|
instance[key]();
|
|
72
155
|
}
|
|
73
156
|
});
|
|
74
157
|
}
|
|
158
|
+
__name(Init, "Init");
|
|
75
159
|
function Rule(rule, info, meta) {
|
|
76
160
|
return (obj, key) => {
|
|
77
|
-
|
|
161
|
+
setModalVar(obj, key);
|
|
78
162
|
regisHandler(obj, key, {
|
|
79
163
|
rule,
|
|
80
164
|
info,
|
|
@@ -82,9 +166,11 @@ function Rule(rule, info, meta) {
|
|
|
82
166
|
});
|
|
83
167
|
};
|
|
84
168
|
}
|
|
169
|
+
__name(Rule, "Rule");
|
|
85
170
|
function Ignore(target, key) {
|
|
86
171
|
setIgnoreKey(target, key);
|
|
87
172
|
}
|
|
173
|
+
__name(Ignore, "Ignore");
|
|
88
174
|
function Clear(target, key) {
|
|
89
175
|
init(target);
|
|
90
176
|
target._namespace.__INIT_EVENT__.delete(key);
|
|
@@ -93,20 +179,23 @@ function Clear(target, key) {
|
|
|
93
179
|
target._namespace.__STATE_VAR__.delete(key);
|
|
94
180
|
target._namespace.__STATE_HANDLER__.delete(key);
|
|
95
181
|
}
|
|
182
|
+
__name(Clear, "Clear");
|
|
96
183
|
function Err(cb) {
|
|
97
184
|
return (target, key) => {
|
|
98
|
-
|
|
185
|
+
setModalVar(target, key);
|
|
99
186
|
regisHandler(target, key, {
|
|
100
187
|
error: cb
|
|
101
188
|
});
|
|
102
189
|
};
|
|
103
190
|
}
|
|
191
|
+
__name(Err, "Err");
|
|
104
192
|
function Get(target, key) {
|
|
105
193
|
setExposeKey(target, key);
|
|
106
194
|
}
|
|
195
|
+
__name(Get, "Get");
|
|
107
196
|
function Pipe(v) {
|
|
108
197
|
return (obj, key) => {
|
|
109
|
-
|
|
198
|
+
setModalVar(obj, key);
|
|
110
199
|
regisHandler(obj, key, {
|
|
111
200
|
async pipe(instance) {
|
|
112
201
|
const tasks = v.value;
|
|
@@ -116,19 +205,21 @@ function Pipe(v) {
|
|
|
116
205
|
});
|
|
117
206
|
};
|
|
118
207
|
}
|
|
208
|
+
__name(Pipe, "Pipe");
|
|
119
209
|
function Tag(tag) {
|
|
120
210
|
return (target) => {
|
|
121
211
|
init(target.prototype);
|
|
122
212
|
target.prototype._namespace.__TAG__ = tag;
|
|
123
213
|
};
|
|
124
214
|
}
|
|
215
|
+
__name(Tag, "Tag");
|
|
125
216
|
function Storage(target) {
|
|
126
217
|
init(target.prototype);
|
|
127
218
|
const tag = target.prototype._namespace.__TAG__;
|
|
128
219
|
if (tag === "")
|
|
129
220
|
throw new Error("miss tag");
|
|
130
221
|
const uniTag = Symbol(tag);
|
|
131
|
-
|
|
222
|
+
setModalVar(target.prototype, uniTag);
|
|
132
223
|
regisHandler(target.prototype, uniTag, {
|
|
133
224
|
init: (instance) => {
|
|
134
225
|
const { state } = instance;
|
|
@@ -144,6 +235,7 @@ function Storage(target) {
|
|
|
144
235
|
}
|
|
145
236
|
});
|
|
146
237
|
}
|
|
238
|
+
__name(Storage, "Storage");
|
|
147
239
|
function Window(target) {
|
|
148
240
|
if (!window.__PHECDA__)
|
|
149
241
|
window.__PHECDA__ = {};
|
|
@@ -151,53 +243,44 @@ function Window(target) {
|
|
|
151
243
|
if (tag)
|
|
152
244
|
window.__PHECDA__[tag] = target;
|
|
153
245
|
}
|
|
154
|
-
|
|
155
|
-
// src/utils.ts
|
|
156
|
-
async function validate(p, v) {
|
|
157
|
-
if (typeof p === "string" || typeof p === "number") {
|
|
158
|
-
if (v === p)
|
|
159
|
-
return true;
|
|
160
|
-
}
|
|
161
|
-
if (typeof p === "function")
|
|
162
|
-
return p(v);
|
|
163
|
-
if (p instanceof RegExp)
|
|
164
|
-
return p.test(v);
|
|
165
|
-
return false;
|
|
166
|
-
}
|
|
167
|
-
function getTag(Model) {
|
|
168
|
-
return Model.prototype?._namespace?.__TAG__;
|
|
169
|
-
}
|
|
246
|
+
__name(Window, "Window");
|
|
170
247
|
|
|
171
248
|
// src/helper.ts
|
|
172
249
|
async function plainToClass(Model, input, options = {}) {
|
|
173
250
|
const data = new Model();
|
|
174
|
-
const resolvedOptions = {
|
|
175
|
-
collectError: true,
|
|
176
|
-
transform: false,
|
|
177
|
-
...options
|
|
178
|
-
};
|
|
179
251
|
const err = [];
|
|
180
252
|
const stateVars = getModelState(data);
|
|
181
253
|
for (const item of stateVars) {
|
|
182
254
|
data[item] = input[item];
|
|
183
255
|
const handlers = getHandler(data, item);
|
|
184
256
|
if (handlers) {
|
|
185
|
-
|
|
186
|
-
const
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
257
|
+
if (options.collectError !== false) {
|
|
258
|
+
for (const handler of handlers) {
|
|
259
|
+
const rule = handler.rule;
|
|
260
|
+
if (rule && !await validate(rule, data[item])) {
|
|
261
|
+
err.push(handler.info || "");
|
|
262
|
+
if (!options.collectError)
|
|
263
|
+
break;
|
|
264
|
+
}
|
|
191
265
|
}
|
|
192
266
|
}
|
|
193
|
-
if (err.length > 0 && !
|
|
194
|
-
return {
|
|
195
|
-
|
|
196
|
-
|
|
267
|
+
if (err.length > 0 && !options.transform)
|
|
268
|
+
return {
|
|
269
|
+
err,
|
|
270
|
+
data
|
|
271
|
+
};
|
|
272
|
+
if (options.transform !== false) {
|
|
273
|
+
for (const handler of handlers)
|
|
274
|
+
await handler.pipe?.(data);
|
|
275
|
+
}
|
|
197
276
|
}
|
|
198
277
|
}
|
|
199
|
-
return {
|
|
278
|
+
return {
|
|
279
|
+
data,
|
|
280
|
+
err
|
|
281
|
+
};
|
|
200
282
|
}
|
|
283
|
+
__name(plainToClass, "plainToClass");
|
|
201
284
|
function classToValue(instance) {
|
|
202
285
|
const data = {};
|
|
203
286
|
const exposeVar = getExposeKey(instance);
|
|
@@ -209,11 +292,16 @@ function classToValue(instance) {
|
|
|
209
292
|
}
|
|
210
293
|
return data;
|
|
211
294
|
}
|
|
295
|
+
__name(classToValue, "classToValue");
|
|
212
296
|
function to(task, oldTasks) {
|
|
213
297
|
const tasks = oldTasks || [];
|
|
214
298
|
tasks.push(task);
|
|
215
|
-
return {
|
|
299
|
+
return {
|
|
300
|
+
to: (task2) => to(task2, tasks),
|
|
301
|
+
value: tasks
|
|
302
|
+
};
|
|
216
303
|
}
|
|
304
|
+
__name(to, "to");
|
|
217
305
|
function snapShot(data) {
|
|
218
306
|
const snap = {};
|
|
219
307
|
for (const i in data)
|
|
@@ -230,96 +318,88 @@ function snapShot(data) {
|
|
|
230
318
|
}
|
|
231
319
|
};
|
|
232
320
|
}
|
|
321
|
+
__name(snapShot, "snapShot");
|
|
233
322
|
function addDecoToClass(c, key, handler, type = "normal") {
|
|
234
323
|
handler(type === "normal" ? c.prototype : c, key);
|
|
235
324
|
}
|
|
325
|
+
__name(addDecoToClass, "addDecoToClass");
|
|
236
326
|
|
|
237
327
|
// src/preset/rule.ts
|
|
238
328
|
function isArray(info) {
|
|
239
329
|
return Rule((param) => Array.isArray(param), info || "it should be an array");
|
|
240
330
|
}
|
|
331
|
+
__name(isArray, "isArray");
|
|
241
332
|
function isBoolean(info) {
|
|
242
|
-
return Rule((param) => [
|
|
333
|
+
return Rule((param) => [
|
|
334
|
+
true,
|
|
335
|
+
false
|
|
336
|
+
].includes(param), info || "it should be true or false");
|
|
243
337
|
}
|
|
338
|
+
__name(isBoolean, "isBoolean");
|
|
244
339
|
function isNumber(info) {
|
|
245
340
|
return Rule((param) => typeof param === "number", info || "it should be true or false");
|
|
246
341
|
}
|
|
342
|
+
__name(isNumber, "isNumber");
|
|
247
343
|
function isString(info) {
|
|
248
344
|
return Rule((param) => typeof param === "string", info || "it should be a string");
|
|
249
345
|
}
|
|
250
|
-
|
|
346
|
+
__name(isString, "isString");
|
|
347
|
+
function isObject2(info) {
|
|
251
348
|
return Rule((param) => {
|
|
252
349
|
return Object.prototype.toString.call(param) === "[object Object]";
|
|
253
350
|
}, info || "it should be an object");
|
|
254
351
|
}
|
|
352
|
+
__name(isObject2, "isObject");
|
|
255
353
|
function isMobile(info) {
|
|
256
|
-
return Rule(
|
|
257
|
-
/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/,
|
|
258
|
-
info || "it should be a mobile phone number"
|
|
259
|
-
);
|
|
354
|
+
return Rule(/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/, info || "it should be a mobile phone number");
|
|
260
355
|
}
|
|
356
|
+
__name(isMobile, "isMobile");
|
|
261
357
|
function isLandline(info) {
|
|
262
|
-
return Rule(
|
|
263
|
-
/\d{3}-\d{8}|\d{4}-\d{7}/,
|
|
264
|
-
info || "it should be a mobile phone number"
|
|
265
|
-
);
|
|
358
|
+
return Rule(/\d{3}-\d{8}|\d{4}-\d{7}/, info || "it should be a mobile phone number");
|
|
266
359
|
}
|
|
360
|
+
__name(isLandline, "isLandline");
|
|
267
361
|
function isMailBox(info) {
|
|
268
|
-
return Rule(
|
|
269
|
-
/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/,
|
|
270
|
-
info || "it should be a mailbox number"
|
|
271
|
-
);
|
|
362
|
+
return Rule(/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, info || "it should be a mailbox number");
|
|
272
363
|
}
|
|
364
|
+
__name(isMailBox, "isMailBox");
|
|
273
365
|
function isIdCard(info) {
|
|
274
|
-
return Rule(
|
|
275
|
-
/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/,
|
|
276
|
-
info || "it should be an identity card number"
|
|
277
|
-
);
|
|
366
|
+
return Rule(/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/, info || "it should be an identity card number");
|
|
278
367
|
}
|
|
368
|
+
__name(isIdCard, "isIdCard");
|
|
279
369
|
function isCnName(info) {
|
|
280
|
-
return Rule(
|
|
281
|
-
/^([\u4E00-\u9FA5·]{2,16})$/,
|
|
282
|
-
info || "\u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57"
|
|
283
|
-
);
|
|
370
|
+
return Rule(/^([\u4E00-\u9FA5·]{2,16})$/, info || "\u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57");
|
|
284
371
|
}
|
|
372
|
+
__name(isCnName, "isCnName");
|
|
285
373
|
function isEnName(info) {
|
|
286
|
-
return Rule(
|
|
287
|
-
/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/,
|
|
288
|
-
info || "it should be a valid en-name"
|
|
289
|
-
);
|
|
374
|
+
return Rule(/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/, info || "it should be a valid en-name");
|
|
290
375
|
}
|
|
376
|
+
__name(isEnName, "isEnName");
|
|
291
377
|
function isDate(info) {
|
|
292
|
-
return Rule(
|
|
293
|
-
/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/,
|
|
294
|
-
info || "it should be a valid date"
|
|
295
|
-
);
|
|
378
|
+
return Rule(/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/, info || "it should be a valid date");
|
|
296
379
|
}
|
|
380
|
+
__name(isDate, "isDate");
|
|
297
381
|
function isWechat(info) {
|
|
298
|
-
return Rule(
|
|
299
|
-
/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/,
|
|
300
|
-
info || "it should be a valid date"
|
|
301
|
-
);
|
|
382
|
+
return Rule(/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/, info || "it should be a valid date");
|
|
302
383
|
}
|
|
384
|
+
__name(isWechat, "isWechat");
|
|
303
385
|
function isHexColor(info) {
|
|
304
|
-
return Rule(
|
|
305
|
-
/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,
|
|
306
|
-
info || "it should be a valid hex-color"
|
|
307
|
-
);
|
|
386
|
+
return Rule(/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/, info || "it should be a valid hex-color");
|
|
308
387
|
}
|
|
388
|
+
__name(isHexColor, "isHexColor");
|
|
309
389
|
function isPostalCode(info) {
|
|
310
|
-
return Rule(
|
|
311
|
-
/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/,
|
|
312
|
-
info || "it should be a valid postal code"
|
|
313
|
-
);
|
|
390
|
+
return Rule(/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/, info || "it should be a valid postal code");
|
|
314
391
|
}
|
|
392
|
+
__name(isPostalCode, "isPostalCode");
|
|
315
393
|
|
|
316
394
|
// src/preset/pipe.ts
|
|
317
395
|
function toNumber() {
|
|
318
396
|
return Pipe(to((param) => Number(param)));
|
|
319
397
|
}
|
|
398
|
+
__name(toNumber, "toNumber");
|
|
320
399
|
function toString() {
|
|
321
400
|
return Pipe(to((param) => String(param)));
|
|
322
401
|
}
|
|
402
|
+
__name(toString, "toString");
|
|
323
403
|
|
|
324
404
|
// src/namespace.ts
|
|
325
405
|
var activeInstance = {};
|
|
@@ -327,21 +407,28 @@ function injectProperty(key, value) {
|
|
|
327
407
|
activeInstance[key] = value;
|
|
328
408
|
return activeInstance;
|
|
329
409
|
}
|
|
410
|
+
__name(injectProperty, "injectProperty");
|
|
330
411
|
function getProperty(key) {
|
|
331
412
|
return activeInstance[key];
|
|
332
413
|
}
|
|
414
|
+
__name(getProperty, "getProperty");
|
|
333
415
|
|
|
334
416
|
// src/custom/decorator.ts
|
|
335
417
|
function Watcher(eventName) {
|
|
336
418
|
return (obj, key) => {
|
|
337
|
-
|
|
419
|
+
setModalVar(obj, key);
|
|
338
420
|
regisHandler(obj, key, {
|
|
339
421
|
init(instance) {
|
|
340
|
-
getProperty("watcher")?.({
|
|
422
|
+
getProperty("watcher")?.({
|
|
423
|
+
eventName,
|
|
424
|
+
instance,
|
|
425
|
+
key
|
|
426
|
+
});
|
|
341
427
|
}
|
|
342
428
|
});
|
|
343
429
|
};
|
|
344
430
|
}
|
|
431
|
+
__name(Watcher, "Watcher");
|
|
345
432
|
export {
|
|
346
433
|
Clear,
|
|
347
434
|
Err,
|
|
@@ -363,6 +450,7 @@ export {
|
|
|
363
450
|
getInitEvent,
|
|
364
451
|
getModelState,
|
|
365
452
|
getProperty,
|
|
453
|
+
getState,
|
|
366
454
|
getTag,
|
|
367
455
|
init,
|
|
368
456
|
injectProperty,
|
|
@@ -377,17 +465,20 @@ export {
|
|
|
377
465
|
isMailBox,
|
|
378
466
|
isMobile,
|
|
379
467
|
isNumber,
|
|
380
|
-
isObject,
|
|
468
|
+
isObject2 as isObject,
|
|
469
|
+
isPhecda,
|
|
381
470
|
isPostalCode,
|
|
382
471
|
isString,
|
|
383
472
|
isWechat,
|
|
473
|
+
mergeOptions,
|
|
474
|
+
mergeState,
|
|
384
475
|
plainToClass,
|
|
385
476
|
regisHandler,
|
|
386
477
|
regisInitEvent,
|
|
387
478
|
register,
|
|
388
479
|
setExposeKey,
|
|
389
480
|
setIgnoreKey,
|
|
390
|
-
|
|
481
|
+
setModalVar,
|
|
391
482
|
snapShot,
|
|
392
483
|
to,
|
|
393
484
|
toNumber,
|