ascertain 0.14.39 → 0.15.0-0
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/LICENSE +21 -0
- package/README.md +51 -10
- package/build/index.cjs +221 -58
- package/build/index.cjs.map +1 -1
- package/build/index.d.ts +65 -34
- package/build/index.js +210 -56
- package/build/index.js.map +1 -1
- package/package.json +22 -12
- package/src/index.js +0 -201
package/build/index.d.ts
CHANGED
|
@@ -1,35 +1,66 @@
|
|
|
1
|
-
export
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
1
|
+
export declare class AssertError extends TypeError {
|
|
2
|
+
readonly value: unknown;
|
|
3
|
+
readonly expected: unknown;
|
|
4
|
+
readonly path: string;
|
|
5
|
+
readonly subject: string;
|
|
6
|
+
static join(errors: AssertError[], separator?: string): AssertError;
|
|
7
|
+
constructor(value: unknown, expected: unknown, path: string, subject?: string);
|
|
8
|
+
}
|
|
9
|
+
type AssertErrorConstructor = new (value: unknown, expected: unknown, path: string, subject?: string) => Error;
|
|
10
|
+
type Keys = string | number | symbol;
|
|
5
11
|
type DataValue = any;
|
|
6
|
-
type Data = Record<
|
|
7
|
-
|
|
8
|
-
export type Schema<T> = T extends Data
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
export const
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
export
|
|
34
|
-
|
|
35
|
-
|
|
12
|
+
type Data = Record<Keys, unknown>;
|
|
13
|
+
type DataArray = DataValue[];
|
|
14
|
+
export type Schema<T> = T extends Data ? {
|
|
15
|
+
[S in keyof T]?: Schema<T[S]>;
|
|
16
|
+
} : T extends DataArray ? [Schema<T[number]>] : DataValue;
|
|
17
|
+
export type SchemaData<S> = S extends Record<Keys, unknown> ? {
|
|
18
|
+
[K in keyof S as Exclude<K, typeof $keys | typeof $values>]?: SchemaData<S[K]>;
|
|
19
|
+
} & Record<string, unknown> : S extends unknown[] ? unknown[] : unknown;
|
|
20
|
+
declare abstract class Operation<T extends Data = DataValue> {
|
|
21
|
+
readonly schemas: Schema<T>[];
|
|
22
|
+
constructor(schemas: Schema<T>[]);
|
|
23
|
+
}
|
|
24
|
+
declare class Or<T extends Data = DataValue> extends Operation<T> {
|
|
25
|
+
}
|
|
26
|
+
export declare const or: <T extends Data = any>(...schemas: Schema<T>[]) => Or<T>;
|
|
27
|
+
declare class And<T extends Data = DataValue> extends Operation<T> {
|
|
28
|
+
}
|
|
29
|
+
export declare const and: <T extends Data = any>(...schemas: Schema<T>[]) => And<T>;
|
|
30
|
+
declare class Optional<T extends Data = DataValue> extends Operation<T> {
|
|
31
|
+
constructor(schema: Schema<T>);
|
|
32
|
+
}
|
|
33
|
+
export declare const optional: <T extends Data = any>(schema: Schema<T>) => Optional<T>;
|
|
34
|
+
declare class Tuple<T extends Data = DataValue> extends Operation<T> {
|
|
35
|
+
}
|
|
36
|
+
export declare const tuple: <T extends Data = any>(...schemas: Schema<T>[]) => Tuple<T>;
|
|
37
|
+
export declare const $keys: unique symbol;
|
|
38
|
+
export declare const $values: unique symbol;
|
|
39
|
+
export declare const fromBase64: (value: string) => string;
|
|
40
|
+
export declare const as: {
|
|
41
|
+
string: (value: string | undefined) => string | undefined;
|
|
42
|
+
number: (value: string | undefined) => number | undefined;
|
|
43
|
+
date: (value: string | undefined) => Date | undefined;
|
|
44
|
+
time: (value: string | undefined) => number | undefined;
|
|
45
|
+
boolean: (value: string | undefined) => boolean | undefined;
|
|
46
|
+
array: (value: string | undefined, delimiter: string) => string[] | undefined;
|
|
47
|
+
json: (value: string | undefined) => any;
|
|
48
|
+
base64: (value: string | undefined) => string | undefined;
|
|
49
|
+
};
|
|
50
|
+
export declare class Context {
|
|
51
|
+
readonly options: CompilerOptions;
|
|
52
|
+
readonly Error: AssertErrorConstructor;
|
|
53
|
+
readonly errors: AssertError[];
|
|
54
|
+
readonly registry: unknown[];
|
|
55
|
+
private varIndex;
|
|
56
|
+
constructor(options?: CompilerOptions);
|
|
57
|
+
error(errors: AssertError[]): boolean;
|
|
58
|
+
register(value: unknown): number;
|
|
59
|
+
unique(prefix: string): string;
|
|
60
|
+
}
|
|
61
|
+
export interface CompilerOptions {
|
|
62
|
+
error?: AssertErrorConstructor;
|
|
63
|
+
}
|
|
64
|
+
export declare const compile: <S>(schema: S, rootName: string, options?: CompilerOptions) => (data: SchemaData<S>) => any;
|
|
65
|
+
export declare const ascertain: <T extends Data = any>(schema: Schema<T>, data: T, rootName?: string) => void;
|
|
66
|
+
export {};
|
package/build/index.js
CHANGED
|
@@ -1,58 +1,45 @@
|
|
|
1
|
-
|
|
1
|
+
export class AssertError extends TypeError {
|
|
2
|
+
value;
|
|
3
|
+
expected;
|
|
4
|
+
path;
|
|
5
|
+
subject;
|
|
6
|
+
static join(errors, separator = ' or ') {
|
|
7
|
+
return new AssertError(errors[0].value, errors.map((e)=>`${e.expected}`).join(separator), errors[0].path, errors[0].subject);
|
|
8
|
+
}
|
|
2
9
|
constructor(value, expected, path, subject = 'value'){
|
|
10
|
+
super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);
|
|
3
11
|
this.value = value;
|
|
4
12
|
this.expected = expected;
|
|
5
13
|
this.path = path;
|
|
6
14
|
this.subject = subject;
|
|
7
15
|
}
|
|
8
|
-
toString() {
|
|
9
|
-
return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;
|
|
10
|
-
}
|
|
11
|
-
};
|
|
12
|
-
function findFirstError(array, map) {
|
|
13
|
-
for(let i = 0; i < array.length; i++){
|
|
14
|
-
const error = map(array[i], i);
|
|
15
|
-
if (error) {
|
|
16
|
-
return error;
|
|
17
|
-
}
|
|
18
|
-
}
|
|
19
|
-
return false;
|
|
20
16
|
}
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
if (
|
|
26
|
-
|
|
27
|
-
} else {
|
|
28
|
-
errors.push(error);
|
|
17
|
+
class Operation {
|
|
18
|
+
schemas;
|
|
19
|
+
constructor(schemas){
|
|
20
|
+
this.schemas = schemas;
|
|
21
|
+
if (schemas.length === 0) {
|
|
22
|
+
throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);
|
|
29
23
|
}
|
|
30
24
|
}
|
|
31
|
-
return errors.reduce((result, error)=>{
|
|
32
|
-
return new AssertError(result.value, [
|
|
33
|
-
result.expected,
|
|
34
|
-
error.expected
|
|
35
|
-
].join(' or '), result.path, result.string);
|
|
36
|
-
});
|
|
37
25
|
}
|
|
38
|
-
|
|
39
|
-
this.schema = schema;
|
|
26
|
+
class Or extends Operation {
|
|
40
27
|
}
|
|
41
|
-
|
|
42
|
-
|
|
28
|
+
export const or = (...schemas)=>new Or(schemas);
|
|
29
|
+
class And extends Operation {
|
|
43
30
|
}
|
|
44
|
-
|
|
45
|
-
|
|
31
|
+
export const and = (...schemas)=>new And(schemas);
|
|
32
|
+
class Optional extends Operation {
|
|
33
|
+
constructor(schema){
|
|
34
|
+
super([
|
|
35
|
+
schema
|
|
36
|
+
]);
|
|
37
|
+
}
|
|
46
38
|
}
|
|
47
|
-
export const optional = (schema)=>
|
|
48
|
-
|
|
49
|
-
}
|
|
50
|
-
export const
|
|
51
|
-
return new And(schema);
|
|
52
|
-
};
|
|
53
|
-
export const or = (...schema)=>{
|
|
54
|
-
return new Or(schema);
|
|
55
|
-
};
|
|
39
|
+
export const optional = (schema)=>new Optional(schema);
|
|
40
|
+
class Tuple extends Operation {
|
|
41
|
+
}
|
|
42
|
+
export const tuple = (...schemas)=>new Tuple(schemas);
|
|
56
43
|
export const $keys = Symbol.for('@@keys');
|
|
57
44
|
export const $values = Symbol.for('@@values');
|
|
58
45
|
export const fromBase64 = typeof Buffer === 'undefined' ? (value)=>atob(value) : (value)=>Buffer.from(value, 'base64').toString('utf-8');
|
|
@@ -79,7 +66,7 @@ export const as = {
|
|
|
79
66
|
time: (value)=>{
|
|
80
67
|
const matches = value?.match(/^(\d+)(ms|s|m|h|d|w)?$/);
|
|
81
68
|
if (matches) {
|
|
82
|
-
const [
|
|
69
|
+
const [, amount, unit = 'ms'] = matches;
|
|
83
70
|
return parseInt(amount, 10) * MULTIPLIERS[unit];
|
|
84
71
|
}
|
|
85
72
|
return undefined;
|
|
@@ -101,28 +88,196 @@ export const as = {
|
|
|
101
88
|
}
|
|
102
89
|
}
|
|
103
90
|
};
|
|
104
|
-
|
|
91
|
+
export class Context {
|
|
92
|
+
options;
|
|
93
|
+
Error;
|
|
94
|
+
errors;
|
|
95
|
+
registry;
|
|
96
|
+
varIndex;
|
|
97
|
+
constructor(options = {}){
|
|
98
|
+
this.options = options;
|
|
99
|
+
this.errors = [];
|
|
100
|
+
this.registry = [];
|
|
101
|
+
this.varIndex = 0;
|
|
102
|
+
this.Error = options.error ?? AssertError;
|
|
103
|
+
}
|
|
104
|
+
error(errors) {
|
|
105
|
+
this.errors.push(...errors);
|
|
106
|
+
return true;
|
|
107
|
+
}
|
|
108
|
+
register(value) {
|
|
109
|
+
if (!this.registry.includes(value)) {
|
|
110
|
+
this.registry.push(value);
|
|
111
|
+
}
|
|
112
|
+
return this.registry.indexOf(value);
|
|
113
|
+
}
|
|
114
|
+
unique(prefix) {
|
|
115
|
+
return `${prefix}$$${this.varIndex++}`;
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
const codeGen = (schema, context, valuePath, path)=>{
|
|
119
|
+
if (schema instanceof And) {
|
|
120
|
+
const valueAlias = context.unique('v');
|
|
121
|
+
const errorsAlias = context.unique('err');
|
|
122
|
+
const code = schema.schemas.map((s)=>`try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e); }`).join('\n');
|
|
123
|
+
return `// And
|
|
124
|
+
const ${errorsAlias} = [];
|
|
125
|
+
const ${valueAlias} = ${valuePath};
|
|
126
|
+
${code}
|
|
127
|
+
if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ' and '); }
|
|
128
|
+
`;
|
|
129
|
+
} else if (schema instanceof Or) {
|
|
130
|
+
const valueAlias = context.unique('v');
|
|
131
|
+
const errorsAlias = context.unique('err');
|
|
132
|
+
const code = schema.schemas.map((s)=>codeGen(s, context, valueAlias, path)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw ctx.Error.join(${errorsAlias}, ' or ')`);
|
|
133
|
+
return `// Or
|
|
134
|
+
const ${errorsAlias} = [];
|
|
135
|
+
const ${valueAlias} = ${valuePath};
|
|
136
|
+
${code}
|
|
137
|
+
`;
|
|
138
|
+
} else if (schema instanceof Optional) {
|
|
139
|
+
const valueAlias = context.unique('v');
|
|
140
|
+
return `// Optional
|
|
141
|
+
const ${valueAlias} = ${valuePath};
|
|
142
|
+
if (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }
|
|
143
|
+
`;
|
|
144
|
+
} else if (schema instanceof Tuple) {
|
|
145
|
+
const valueAlias = context.unique('v');
|
|
146
|
+
const errorsAlias = context.unique('err');
|
|
147
|
+
const code = schema.schemas.map((s, idx)=>`try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`).join('\n');
|
|
148
|
+
return `// Tuple
|
|
149
|
+
const ${valueAlias} = ${valuePath};
|
|
150
|
+
const ${errorsAlias} = [];
|
|
151
|
+
if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'Array', \`${path}\`); }
|
|
152
|
+
${code}
|
|
153
|
+
if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }
|
|
154
|
+
`;
|
|
155
|
+
}
|
|
156
|
+
if (typeof schema === 'function') {
|
|
157
|
+
const index = context.register(schema);
|
|
158
|
+
const valueAlias = context.unique('v');
|
|
159
|
+
const registryAlias = context.unique('r');
|
|
160
|
+
return `
|
|
161
|
+
const ${valueAlias} = ${valuePath};
|
|
162
|
+
const ${registryAlias} = ctx.registry[${index}];
|
|
163
|
+
if (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \`${path}\`); }
|
|
164
|
+
if (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \`instance of \${${registryAlias}.name}\`, \`${path}\`, 'instance of'); }
|
|
165
|
+
else if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \`${path}\`, 'type'); }
|
|
166
|
+
`;
|
|
167
|
+
} else if (Array.isArray(schema)) {
|
|
168
|
+
const valueAlias = context.unique('v');
|
|
169
|
+
const code = [
|
|
170
|
+
`const ${valueAlias} = ${valuePath};`,
|
|
171
|
+
`if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \`${path}\`); }`
|
|
172
|
+
];
|
|
173
|
+
if (schema.length > 0) {
|
|
174
|
+
const value = context.unique('val');
|
|
175
|
+
const key = context.unique('key');
|
|
176
|
+
const errorsAlias = context.unique('err');
|
|
177
|
+
const orCode = schema.map((s)=>codeGen(s, context, value, `${path}[\${${key}}]`)).reduceRight((result, code)=>`try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw ctx.Error.join(${errorsAlias}, ' or ')`);
|
|
178
|
+
code.push(`for(const ${key} in ${valueAlias}) {`, `const ${errorsAlias} = [];`, `const ${value} = ${valueAlias}[${key}];`, orCode, `}`);
|
|
179
|
+
}
|
|
180
|
+
return code.join('\n');
|
|
181
|
+
} else if (typeof schema === 'object' && schema !== null) {
|
|
182
|
+
if (schema instanceof RegExp) {
|
|
183
|
+
const valueAlias = context.unique('v');
|
|
184
|
+
return `
|
|
185
|
+
const ${valueAlias} = ${valuePath};
|
|
186
|
+
if (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \`${path}\`); }
|
|
187
|
+
`;
|
|
188
|
+
} else {
|
|
189
|
+
const valueAlias = context.unique('v');
|
|
190
|
+
const code = [
|
|
191
|
+
`const ${valueAlias} = ${valuePath};`,
|
|
192
|
+
`if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \`${path}\`); }`,
|
|
193
|
+
`if (${valueAlias} === null) { throw new ctx.Error(${valueAlias}, 'object', \`${path}\`); }`
|
|
194
|
+
];
|
|
195
|
+
if ($keys in schema) {
|
|
196
|
+
const keysAlias = context.unique('key');
|
|
197
|
+
const errorsAlias = context.unique('err');
|
|
198
|
+
const value = context.unique('v');
|
|
199
|
+
code.push(`
|
|
200
|
+
const ${keysAlias} = Object.keys(${valueAlias});
|
|
201
|
+
const ${errorsAlias} = ${keysAlias}.map((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).flat().filter(Boolean);
|
|
202
|
+
if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }
|
|
203
|
+
`);
|
|
204
|
+
}
|
|
205
|
+
if ($values in schema) {
|
|
206
|
+
const vAlias = context.unique('val');
|
|
207
|
+
const valuesAlias = context.unique('vals');
|
|
208
|
+
const errorsAlias = context.unique('err');
|
|
209
|
+
code.push(`{
|
|
210
|
+
const ${valuesAlias} = Object.values(${valuePath});
|
|
211
|
+
const ${errorsAlias} = ${valuesAlias}.map((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).flat().filter(Boolean);
|
|
212
|
+
if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }
|
|
213
|
+
}`);
|
|
214
|
+
}
|
|
215
|
+
const keys = Object.keys(schema);
|
|
216
|
+
code.push(...keys.map((key)=>codeGen(schema[key], context, `${valueAlias}['${key}']`, `${path}.${key}`)));
|
|
217
|
+
return `{${code.join('\n')}}`;
|
|
218
|
+
}
|
|
219
|
+
} else {
|
|
220
|
+
const valueAlias = context.unique('v');
|
|
221
|
+
return `
|
|
222
|
+
const ${valueAlias} = ${valuePath};
|
|
223
|
+
if (${valueAlias} !== ${schema}) { throw new ctx.Error(${valueAlias}, ${schema}, \`${path}\`); }
|
|
224
|
+
`;
|
|
225
|
+
}
|
|
226
|
+
};
|
|
227
|
+
export const compile = (schema, rootName, options = {})=>{
|
|
228
|
+
const context = new Context(options);
|
|
229
|
+
const code = codeGen(schema, context, 'data', rootName);
|
|
230
|
+
const validator = new Function('ctx', 'data', code);
|
|
231
|
+
return (data)=>validator(context, data);
|
|
232
|
+
};
|
|
233
|
+
const findFirstError = (array, map)=>{
|
|
234
|
+
for(let i = 0; i < array.length; i++){
|
|
235
|
+
const error = map(array[i], i);
|
|
236
|
+
if (error) {
|
|
237
|
+
return error;
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
return false;
|
|
241
|
+
};
|
|
242
|
+
const findNotError = (array, map)=>{
|
|
243
|
+
const errors = [];
|
|
244
|
+
for(let i = 0; i < array.length; i++){
|
|
245
|
+
const error = map(array[i], i);
|
|
246
|
+
if (!error) {
|
|
247
|
+
return false;
|
|
248
|
+
} else {
|
|
249
|
+
errors.push(error);
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
return errors.reduce((result, error)=>{
|
|
253
|
+
return new AssertError(result.value, [
|
|
254
|
+
result.expected,
|
|
255
|
+
error.expected
|
|
256
|
+
].join(' or '), result.path, result.subject);
|
|
257
|
+
});
|
|
258
|
+
};
|
|
259
|
+
const assert = (target, schema, path, optional = false)=>{
|
|
105
260
|
if (schema === null || typeof schema === 'undefined') {
|
|
106
261
|
return new AssertError(schema, 'any value', path, 'schema value');
|
|
107
262
|
}
|
|
108
263
|
if (schema instanceof Optional) {
|
|
109
|
-
return
|
|
264
|
+
return assert(target, schema.schemas[0], path, true);
|
|
110
265
|
}
|
|
111
266
|
const isValue = target !== null && typeof target !== 'undefined';
|
|
112
267
|
if (!isValue && optional) {
|
|
113
268
|
return;
|
|
114
269
|
}
|
|
115
270
|
if (schema instanceof Or) {
|
|
116
|
-
if (!schema.
|
|
271
|
+
if (!schema.schemas.length) {
|
|
117
272
|
return new AssertError(target, 'values', path, 'OR schema');
|
|
118
273
|
}
|
|
119
|
-
return findNotError(schema.
|
|
274
|
+
return findNotError(schema.schemas, (schema)=>assert(target, schema, path));
|
|
120
275
|
}
|
|
121
276
|
if (schema instanceof And) {
|
|
122
|
-
if (!schema.
|
|
277
|
+
if (!schema.schemas.length) {
|
|
123
278
|
return new AssertError(target, 'values', path, 'AND schema');
|
|
124
279
|
}
|
|
125
|
-
return findFirstError(schema.
|
|
280
|
+
return findFirstError(schema.schemas, (schema)=>assert(target, schema, path));
|
|
126
281
|
}
|
|
127
282
|
if (typeof schema === 'function') {
|
|
128
283
|
if (!isValue) {
|
|
@@ -139,7 +294,7 @@ function certain(target, schema, path, optional) {
|
|
|
139
294
|
return new AssertError(target, schema.constructor.name, path);
|
|
140
295
|
}
|
|
141
296
|
return findFirstError(target, (value, idx)=>{
|
|
142
|
-
return findNotError(schema, (itemSchemaType)=>
|
|
297
|
+
return findNotError(schema, (itemSchemaType)=>assert(value, itemSchemaType, `${path}.${idx}`));
|
|
143
298
|
});
|
|
144
299
|
} else if (typeof schema === 'object') {
|
|
145
300
|
if (schema instanceof RegExp) {
|
|
@@ -155,30 +310,29 @@ function certain(target, schema, path, optional) {
|
|
|
155
310
|
}
|
|
156
311
|
if ($keys in schema) {
|
|
157
312
|
const targetKeys = Object.keys(target);
|
|
158
|
-
const assertError = findFirstError(targetKeys, (targetKey)=>
|
|
313
|
+
const assertError = findFirstError(targetKeys, (targetKey)=>assert(targetKey, schema[$keys], `${path}.${targetKey}`));
|
|
159
314
|
if (assertError) {
|
|
160
315
|
return assertError;
|
|
161
316
|
}
|
|
162
317
|
}
|
|
163
318
|
if ($values in schema) {
|
|
164
319
|
const targetKeys = Object.keys(target);
|
|
165
|
-
const assertError = findFirstError(targetKeys, (targetKey)=>
|
|
320
|
+
const assertError = findFirstError(targetKeys, (targetKey)=>assert(target[targetKey], schema[$values], `${path}.${targetKey}`));
|
|
166
321
|
if (assertError) {
|
|
167
322
|
return assertError;
|
|
168
323
|
}
|
|
169
324
|
}
|
|
170
|
-
return findFirstError(Object.keys(schema), (key)=>
|
|
325
|
+
return findFirstError(Object.keys(schema), (key)=>assert(target[key], schema[key], `${path}.${key}`));
|
|
171
326
|
}
|
|
172
327
|
} else if (target !== schema) {
|
|
173
328
|
return new AssertError(target, schema, path);
|
|
174
329
|
}
|
|
175
|
-
}
|
|
330
|
+
};
|
|
176
331
|
export const ascertain = (schema, data, rootName = '[root]')=>{
|
|
177
|
-
const result =
|
|
332
|
+
const result = assert(data, schema, rootName);
|
|
178
333
|
if (result instanceof AssertError) {
|
|
179
334
|
throw new TypeError(result.toString());
|
|
180
335
|
}
|
|
181
336
|
};
|
|
182
|
-
export default ascertain;
|
|
183
337
|
|
|
184
338
|
//# sourceMappingURL=index.js.map
|
package/build/index.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"sources":["../src/index.js"],"sourcesContent":["class AssertError {\n constructor(value, expected, path, subject = 'value') {\n this.value = value;\n this.expected = expected;\n this.path = path;\n this.subject = subject;\n }\n\n toString() {\n return `Invalid ${this.subject} ${JSON.stringify(this.value)} specified by path ${this.path} expected ${this.expected}`;\n }\n}\n\nfunction findFirstError(array, map) {\n for (let i = 0; i < array.length; i++) {\n const error = map(array[i], i);\n if (error) {\n return error;\n }\n }\n return false;\n}\n\nfunction findNotError(array, map) {\n const errors = [];\n for (let i = 0; i < array.length; i++) {\n const error = map(array[i], i);\n if (!error) {\n return false;\n } else {\n errors.push(error);\n }\n }\n return errors.reduce((result, error) => {\n return new AssertError(result.value, [result.expected, error.expected].join(' or '), result.path, result.string);\n });\n}\n\nfunction Optional(schema) {\n this.schema = schema;\n}\n\nfunction And(schema) {\n this.schema = schema;\n}\n\nfunction Or(schema) {\n this.schema = schema;\n}\n\nexport const optional = (schema) => {\n return new Optional(schema);\n};\n\nexport const and = (...schema) => {\n return new And(schema);\n};\n\nexport const or = (...schema) => {\n return new Or(schema);\n};\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\n\nexport const fromBase64 =\n typeof Buffer === 'undefined' ? (value) => atob(value) : (value) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n ms: 1,\n s: 1000,\n m: 60000,\n h: 3600000,\n d: 86400000,\n w: 604800000,\n};\n\nexport const as = {\n string: (value) => {\n return typeof value === 'string' ? value : undefined;\n },\n number: (value) => {\n const result = parseFloat(value);\n return Number.isFinite(result) ? result : undefined;\n },\n date: (value) => {\n const result = Date.parse(value);\n return Number.isFinite(result) ? new Date(result) : undefined;\n },\n time: (value) => {\n const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n if (matches) {\n const [_, amount, unit = 'ms'] = matches;\n return parseInt(amount, 10) * MULTIPLIERS[unit];\n }\n return undefined;\n },\n boolean: (value) => (/^(0|1|true|false|enabled|disabled)$/i.test(value) ? /^(1|true|enabled)$/i.test(value) : undefined),\n array: (value, delimiter) => value?.split(delimiter) ?? undefined,\n json: (value) => {\n try {\n return JSON.parse(value);\n } catch (e) {\n return undefined;\n }\n },\n base64: (value) => {\n try {\n return fromBase64(value);\n } catch (e) {\n return undefined;\n }\n },\n};\n\nfunction certain(target, schema, path, optional) {\n if (schema === null || typeof schema === 'undefined') {\n return new AssertError(schema, 'any value', path, 'schema value');\n }\n if (schema instanceof Optional) {\n return certain(target, schema.schema, path, true);\n }\n const isValue = target !== null && typeof target !== 'undefined';\n if (!isValue && optional) {\n return;\n }\n if (schema instanceof Or) {\n if (!schema.schema.length) {\n return new AssertError(target, 'values', path, 'OR schema');\n }\n return findNotError(schema.schema, (schema) => certain(target, schema, path));\n }\n if (schema instanceof And) {\n if (!schema.schema.length) {\n return new AssertError(target, 'values', path, 'AND schema');\n }\n return findFirstError(schema.schema, (schema) => certain(target, schema, path));\n }\n\n if (typeof schema === 'function') {\n if (!isValue) {\n return new AssertError(target, schema.name, path);\n }\n if (typeof target === 'object' && !(target instanceof schema)) {\n return new AssertError(target, schema.name, path);\n }\n if (typeof target !== 'object' && target.constructor !== schema) {\n return new AssertError(target, schema.name, path);\n }\n } else if (Array.isArray(schema)) {\n if (!Array.isArray(target)) {\n return new AssertError(target, schema.constructor.name, path);\n }\n return findFirstError(target, (value, idx) => {\n return findNotError(schema, (itemSchemaType) => certain(value, itemSchemaType, `${path}.${idx}`));\n });\n } else if (typeof schema === 'object') {\n if (schema instanceof RegExp) {\n if (!schema.test('' + target)) {\n return new AssertError(target, `matching /${schema.source}/`, path);\n }\n } else {\n if (typeof target !== 'object') {\n return new AssertError(target, schema.constructor.name, path);\n }\n if (target === null) {\n return new AssertError(target, 'an object', path);\n }\n if ($keys in schema) {\n const targetKeys = Object.keys(target);\n const assertError = findFirstError(targetKeys, (targetKey) =>\n certain(targetKey, schema[$keys], `${path}.${targetKey}`)\n );\n if (assertError) {\n return assertError;\n }\n }\n if ($values in schema) {\n const targetKeys = Object.keys(target);\n const assertError = findFirstError(targetKeys, (targetKey) =>\n certain(target[targetKey], schema[$values], `${path}.${targetKey}`)\n );\n if (assertError) {\n return assertError;\n }\n }\n return findFirstError(Object.keys(schema), (key) => certain(target[key], schema[key], `${path}.${key}`));\n }\n } else if (target !== schema) {\n return new AssertError(target, schema, path);\n }\n}\n\nexport const ascertain = (schema, data, rootName = '[root]') => {\n const result = certain(data, schema, rootName);\n if (result instanceof AssertError) {\n throw new TypeError(result.toString());\n }\n};\n\nexport default ascertain;\n"],"names":["AssertError","constructor","value","expected","path","subject","toString","JSON","stringify","findFirstError","array","map","i","length","error","findNotError","errors","push","reduce","result","join","string","Optional","schema","And","Or","optional","and","or","$keys","Symbol","for","$values","fromBase64","Buffer","atob","from","MULTIPLIERS","ms","s","m","h","d","w","as","undefined","number","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","_","amount","unit","parseInt","boolean","test","delimiter","split","json","e","base64","certain","target","isValue","name","Array","isArray","idx","itemSchemaType","RegExp","source","targetKeys","Object","keys","assertError","targetKey","key","ascertain","data","rootName","TypeError"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
|
|
1
|
+
{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export class AssertError extends TypeError {\n static join(errors: AssertError[], separator = ' or ') {\n return new AssertError(errors[0].value, errors.map((e) => `${e.expected}`).join(separator), errors[0].path, errors[0].subject);\n }\n constructor(\n public readonly value: unknown,\n public readonly expected: unknown,\n public readonly path: string,\n public readonly subject = 'value',\n ) {\n super(`Invalid ${subject} ${JSON.stringify(value)} for path ${path}, expected ${expected}.`);\n }\n}\n\ntype AssertErrorConstructor = new (value: unknown, expected: unknown, path: string, subject?: string) => Error;\n\ntype Keys = string | number | symbol;\ntype DataValue = any;\ntype Data = Record<Keys, unknown>;\ntype DataArray = DataValue[];\n\nexport type Schema<T> = T extends Data ? { [S in keyof T]?: Schema<T[S]> } : T extends DataArray ? [Schema<T[number]>] : DataValue;\n\nexport type SchemaData<S> =\n S extends Record<Keys, unknown>\n ? { [K in keyof S as Exclude<K, typeof $keys | typeof $values>]?: SchemaData<S[K]> } & Record<string, unknown>\n : S extends unknown[]\n ? unknown[]\n : unknown;\n\nabstract class Operation<T extends Data = DataValue> {\n constructor(public readonly schemas: Schema<T>[]) {\n if (schemas.length === 0) {\n throw new TypeError(`Operation schema ${this.constructor.name} must have at least one element`);\n }\n }\n}\n\nclass Or<T extends Data = DataValue> extends Operation<T> {}\nexport const or = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Or(schemas);\n\nclass And<T extends Data = DataValue> extends Operation<T> {}\nexport const and = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new And(schemas);\n\nclass Optional<T extends Data = DataValue> extends Operation<T> {\n constructor(schema: Schema<T>) {\n super([schema]);\n }\n}\nexport const optional = <T extends Data = DataValue>(schema: Schema<T>) => new Optional(schema);\n\nclass Tuple<T extends Data = DataValue> extends Operation<T> {}\nexport const tuple = <T extends Data = DataValue>(...schemas: Schema<T>[]) => new Tuple(schemas);\n\nexport const $keys = Symbol.for('@@keys');\nexport const $values = Symbol.for('@@values');\nexport const fromBase64 = typeof Buffer === 'undefined' ? (value: string) => atob(value) : (value: string) => Buffer.from(value, 'base64').toString('utf-8');\n\nconst MULTIPLIERS = {\n ms: 1,\n s: 1000,\n m: 60000,\n h: 3600000,\n d: 86400000,\n w: 604800000,\n};\n\nexport const as = {\n string: (value: string | undefined) => {\n return typeof value === 'string' ? value : undefined;\n },\n number: (value: string | undefined) => {\n const result = parseFloat(value as string);\n return Number.isFinite(result) ? result : undefined;\n },\n date: (value: string | undefined) => {\n const result = Date.parse(value as string);\n return Number.isFinite(result) ? new Date(result) : undefined;\n },\n time: (value: string | undefined) => {\n const matches = value?.match(/^(\\d+)(ms|s|m|h|d|w)?$/);\n if (matches) {\n const [, amount, unit = 'ms'] = matches;\n return parseInt(amount, 10) * MULTIPLIERS[unit as keyof typeof MULTIPLIERS];\n }\n return undefined;\n },\n boolean: (value: string | undefined) =>\n /^(0|1|true|false|enabled|disabled)$/i.test(value as string) ? /^(1|true|enabled)$/i.test(value as string) : undefined,\n array: (value: string | undefined, delimiter: string) => value?.split(delimiter) ?? undefined,\n json: (value: string | undefined) => {\n try {\n return JSON.parse(value as string);\n } catch (e) {\n return undefined;\n }\n },\n base64: (value: string | undefined) => {\n try {\n return fromBase64(value as string);\n } catch (e) {\n return undefined;\n }\n },\n};\n\nexport class Context {\n public readonly Error: AssertErrorConstructor;\n public readonly errors: AssertError[] = [];\n public readonly registry: unknown[] = [];\n private varIndex = 0;\n constructor(public readonly options: CompilerOptions = {}) {\n this.Error = options.error ?? AssertError;\n }\n\n error(errors: AssertError[]) {\n this.errors.push(...errors);\n return true;\n }\n\n register(value: unknown): number {\n if (!this.registry.includes(value)) {\n this.registry.push(value);\n }\n return this.registry.indexOf(value);\n }\n\n unique(prefix: string) {\n return `${prefix}$$${this.varIndex++}`;\n }\n}\n\nexport interface CompilerOptions {\n error?: AssertErrorConstructor;\n}\n\nconst codeGen = <T extends Data = DataValue>(schema: Schema<T>, context: Context, valuePath: string, path: string): string => {\n if (schema instanceof And) {\n const valueAlias = context.unique('v');\n const errorsAlias = context.unique('err');\n const code = schema.schemas.map((s) => `try { ${codeGen(s, context, valueAlias, path)} } catch (e) { ${errorsAlias}.push(e); }`).join('\\n');\n return `// And\n const ${errorsAlias} = [];\n const ${valueAlias} = ${valuePath};\n ${code}\n if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ' and '); }\n`;\n } else if (schema instanceof Or) {\n const valueAlias = context.unique('v');\n const errorsAlias = context.unique('err');\n const code = schema.schemas\n .map((s) => codeGen(s, context, valueAlias, path))\n .reduceRight((result, code) => `try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw ctx.Error.join(${errorsAlias}, ' or ')`);\n return `// Or\nconst ${errorsAlias} = [];\nconst ${valueAlias} = ${valuePath};\n${code}\n `;\n } else if (schema instanceof Optional) {\n const valueAlias = context.unique('v');\n return `// Optional\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== undefined && ${valueAlias} !== null) { ${codeGen(schema.schemas[0], context, valueAlias, path)} }\n`;\n } else if (schema instanceof Tuple) {\n const valueAlias = context.unique('v');\n const errorsAlias = context.unique('err');\n const code = schema.schemas\n .map((s, idx) => `try { ${codeGen(s, context, `${valueAlias}[${idx}]`, `${path}[${idx}]`)} } catch (e) { ${errorsAlias}.push(e); }`)\n .join('\\n');\n return `// Tuple\n const ${valueAlias} = ${valuePath};\n const ${errorsAlias} = [];\n if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, 'Array', \\`${path}\\`); }\n ${code}\n if (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }\n`;\n }\n if (typeof schema === 'function') {\n const index = context.register(schema);\n const valueAlias = context.unique('v');\n const registryAlias = context.unique('r');\n return `\nconst ${valueAlias} = ${valuePath};\nconst ${registryAlias} = ctx.registry[${index}];\nif (${valueAlias} === null || ${valueAlias} === undefined) { throw new ctx.Error(${valueAlias}, 'a non-nullable', \\`${path}\\`); }\nif (typeof ${valueAlias} === 'object' && !(${valueAlias} instanceof ${registryAlias})) { throw new ctx.Error(${valueAlias}?.constructor?.name, \\`instance of \\${${registryAlias}.name}\\`, \\`${path}\\`, 'instance of'); }\nelse if (typeof ${valueAlias} !== 'object' && ${valueAlias}?.constructor !== ${registryAlias}) { throw new ctx.Error(${valueAlias}?.constructor?.name, ${registryAlias}.name, \\`${path}\\`, 'type'); }\n`;\n } else if (Array.isArray(schema)) {\n const valueAlias = context.unique('v');\n const code: string[] = [\n `const ${valueAlias} = ${valuePath};`,\n `if (!Array.isArray(${valueAlias})) { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \\`${path}\\`); }`,\n ];\n if (schema.length > 0) {\n const value = context.unique('val');\n const key = context.unique('key');\n const errorsAlias = context.unique('err');\n\n const orCode = schema\n .map((s) => codeGen(s, context, value, `${path}[\\${${key}}]`))\n .reduceRight((result, code) => `try {${code}} catch (e) {${errorsAlias}.push(e);${result}}`, `throw ctx.Error.join(${errorsAlias}, ' or ')`);\n code.push(`for(const ${key} in ${valueAlias}) {`, `const ${errorsAlias} = [];`, `const ${value} = ${valueAlias}[${key}];`, orCode, `}`);\n }\n return code.join('\\n');\n } else if (typeof schema === 'object' && schema !== null) {\n if (schema instanceof RegExp) {\n const valueAlias = context.unique('v');\n return `\nconst ${valueAlias} = ${valuePath};\nif (!${schema.toString()}.test('' + ${valueAlias})) { throw new ctx.Error(${valueAlias}, 'matching ${schema.toString()}', \\`${path}\\`); }\n`;\n } else {\n const valueAlias = context.unique('v');\n const code: string[] = [\n `const ${valueAlias} = ${valuePath};`,\n `if (typeof ${valueAlias} !== 'object') { throw new ctx.Error(${valueAlias}, '${schema.constructor.name}', \\`${path}\\`); }`,\n `if (${valueAlias} === null) { throw new ctx.Error(${valueAlias}, 'object', \\`${path}\\`); }`,\n ];\n if ($keys in schema) {\n const keysAlias = context.unique('key');\n const errorsAlias = context.unique('err');\n const value = context.unique('v');\n code.push(`\nconst ${keysAlias} = Object.keys(${valueAlias});\nconst ${errorsAlias} = ${keysAlias}.map((${value}) => { ${codeGen(schema[$keys], context, value, path)} }).flat().filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }\n`);\n }\n if ($values in schema) {\n const vAlias = context.unique('val');\n const valuesAlias = context.unique('vals');\n const errorsAlias = context.unique('err');\n code.push(`{\nconst ${valuesAlias} = Object.values(${valuePath});\nconst ${errorsAlias} = ${valuesAlias}.map((${vAlias}) => { ${codeGen(schema[$values], context, vAlias, path)} }).flat().filter(Boolean);\nif (${errorsAlias}.length !== 0) { throw ctx.Error.join(${errorsAlias}, ', '); }\n}`);\n }\n const keys = Object.keys(schema);\n code.push(...keys.map((key) => codeGen(schema[key], context, `${valueAlias}['${key}']`, `${path}.${key}`)));\n return `{${code.join('\\n')}}`;\n }\n } else {\n const valueAlias = context.unique('v');\n return `\nconst ${valueAlias} = ${valuePath};\nif (${valueAlias} !== ${schema}) { throw new ctx.Error(${valueAlias}, ${schema}, \\`${path}\\`); }\n`;\n }\n};\n\nexport const compile = <S>(schema: S, rootName: string, options: CompilerOptions = {}) => {\n const context = new Context(options);\n const code = codeGen(schema, context, 'data', rootName);\n const validator = new Function('ctx', 'data', code);\n return (data: SchemaData<S>) => validator(context, data);\n};\n\nconst findFirstError = <T>(array: T[], map: (value: T, index: number) => AssertError | false | null | void | undefined): false | AssertError => {\n for (let i = 0; i < array.length; i++) {\n const error = map(array[i], i);\n if (error) {\n return error;\n }\n }\n return false;\n};\n\nconst findNotError = <T>(array: T[], map: (value: T, index: number) => AssertError | false | null | void | undefined): false | AssertError => {\n const errors: AssertError[] = [];\n for (let i = 0; i < array.length; i++) {\n const error = map(array[i], i);\n if (!error) {\n return false;\n } else {\n errors.push(error);\n }\n }\n return errors.reduce((result, error) => {\n return new AssertError(result.value, [result.expected, error.expected].join(' or '), result.path, result.subject);\n });\n};\n\nconst assert = (target: unknown, schema: unknown, path: string, optional = false): AssertError | false | void => {\n if (schema === null || typeof schema === 'undefined') {\n return new AssertError(schema, 'any value', path, 'schema value');\n }\n if (schema instanceof Optional) {\n return assert(target, schema.schemas[0], path, true);\n }\n const isValue = target !== null && typeof target !== 'undefined';\n if (!isValue && optional) {\n return;\n }\n if (schema instanceof Or) {\n if (!schema.schemas.length) {\n return new AssertError(target, 'values', path, 'OR schema');\n }\n return findNotError(schema.schemas, (schema) => assert(target, schema, path));\n }\n if (schema instanceof And) {\n if (!schema.schemas.length) {\n return new AssertError(target, 'values', path, 'AND schema');\n }\n return findFirstError(schema.schemas, (schema) => assert(target, schema, path));\n }\n\n if (typeof schema === 'function') {\n if (!isValue) {\n return new AssertError(target, schema.name, path);\n }\n if (typeof target === 'object' && !(target instanceof schema)) {\n return new AssertError(target, schema.name, path);\n }\n if (typeof target !== 'object' && target.constructor !== schema) {\n return new AssertError(target, schema.name, path);\n }\n } else if (Array.isArray(schema)) {\n if (!Array.isArray(target)) {\n return new AssertError(target, schema.constructor.name, path);\n }\n return findFirstError(target, (value, idx) => {\n return findNotError(schema, (itemSchemaType) => assert(value, itemSchemaType, `${path}.${idx}`));\n });\n } else if (typeof schema === 'object') {\n if (schema instanceof RegExp) {\n if (!schema.test('' + target)) {\n return new AssertError(target, `matching /${schema.source}/`, path);\n }\n } else {\n if (typeof target !== 'object') {\n return new AssertError(target, schema.constructor.name, path);\n }\n if (target === null) {\n return new AssertError(target, 'an object', path);\n }\n if ($keys in schema) {\n const targetKeys = Object.keys(target);\n const assertError = findFirstError(targetKeys, (targetKey) => assert(targetKey, schema[$keys], `${path}.${targetKey}`));\n if (assertError) {\n return assertError;\n }\n }\n if ($values in schema) {\n const targetKeys = Object.keys(target);\n const assertError = findFirstError(targetKeys, (targetKey) =>\n assert(target[targetKey as keyof typeof target], schema[$values], `${path}.${targetKey}`),\n );\n if (assertError) {\n return assertError;\n }\n }\n return findFirstError(Object.keys(schema), (key) => assert(target[key as keyof typeof target], schema[key as keyof typeof target], `${path}.${key}`));\n }\n } else if (target !== schema) {\n return new AssertError(target, schema, path);\n }\n};\n\nexport const ascertain = <T extends Data = DataValue>(schema: Schema<T>, data: T, rootName = '[root]') => {\n const result = assert(data, schema, rootName);\n if (result instanceof AssertError) {\n throw new TypeError(result.toString());\n }\n};\n"],"names":["AssertError","TypeError","join","errors","separator","value","map","e","expected","path","subject","constructor","JSON","stringify","Operation","schemas","length","name","Or","or","And","and","Optional","schema","optional","Tuple","tuple","$keys","Symbol","for","$values","fromBase64","Buffer","atob","from","toString","MULTIPLIERS","ms","s","m","h","d","w","as","string","undefined","number","result","parseFloat","Number","isFinite","date","Date","parse","time","matches","match","amount","unit","parseInt","boolean","test","array","delimiter","split","json","base64","Context","Error","registry","varIndex","options","error","push","register","includes","indexOf","unique","prefix","codeGen","context","valuePath","valueAlias","errorsAlias","code","reduceRight","idx","index","registryAlias","Array","isArray","key","orCode","RegExp","keysAlias","vAlias","valuesAlias","keys","Object","compile","rootName","validator","Function","data","findFirstError","i","findNotError","reduce","assert","target","isValue","itemSchemaType","source","targetKeys","assertError","targetKey","ascertain"],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "ascertain",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.15.0-0",
|
|
4
4
|
"description": "0-Deps, simple, fast, for browser and node js object schema validator",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"types": "build/index.d.ts",
|
|
@@ -14,12 +14,6 @@
|
|
|
14
14
|
"build",
|
|
15
15
|
"src/index.js"
|
|
16
16
|
],
|
|
17
|
-
"scripts": {
|
|
18
|
-
"build": "rm -rf build && NODE_ENV=production inop src/ build -t js -i __tests__ && cp src/index.d.ts build",
|
|
19
|
-
"build:2": "NODE_ENV=production swc src/index.js -d build --ignore **/__tests__,**/__fixtures__ --strip-leading-paths && cp src/index.d.ts build",
|
|
20
|
-
"test": "NODE_ENV=test jest",
|
|
21
|
-
"test:cov": "COVERAGE=1 NODE_ENV=test jest"
|
|
22
|
-
},
|
|
23
17
|
"repository": {
|
|
24
18
|
"type": "git",
|
|
25
19
|
"url": "git+https://github.com/3axap4eHko/ascertain.git"
|
|
@@ -44,10 +38,26 @@
|
|
|
44
38
|
},
|
|
45
39
|
"homepage": "https://github.com/3axap4eHko/ascertain#readme",
|
|
46
40
|
"devDependencies": {
|
|
47
|
-
"@swc/cli": "^0.3.12",
|
|
48
|
-
"@swc/core": "^1.6.3",
|
|
49
41
|
"@swc/jest": "^0.2.36",
|
|
50
|
-
"
|
|
51
|
-
"
|
|
42
|
+
"@types/jest": "^29.5.12",
|
|
43
|
+
"@typescript-eslint/eslint-plugin": "^7.13.1",
|
|
44
|
+
"@typescript-eslint/parser": "^7.13.1",
|
|
45
|
+
"eslint": "^8.56.0",
|
|
46
|
+
"eslint-config-airbnb-base": "^15.0.0",
|
|
47
|
+
"eslint-config-prettier": "^9.1.0",
|
|
48
|
+
"eslint-plugin-import": "^2.29.1",
|
|
49
|
+
"eslint-plugin-prettier": "^5.1.3",
|
|
50
|
+
"husky": "^9.0.11",
|
|
51
|
+
"inop": "^0.7.0",
|
|
52
|
+
"jest": "^29.7.0",
|
|
53
|
+
"overtake": "^0.1.1",
|
|
54
|
+
"prettier": "^3.3.2",
|
|
55
|
+
"ts-node": "^10.9.2",
|
|
56
|
+
"typescript": "^5.5.2"
|
|
57
|
+
},
|
|
58
|
+
"scripts": {
|
|
59
|
+
"build": "rm -rf build && NODE_ENV=production inop src/ build -i __tests__ && tsc --declaration --emitDeclarationOnly",
|
|
60
|
+
"test": "NODE_ENV=test jest",
|
|
61
|
+
"test:cov": "CI=1 NODE_ENV=test jest"
|
|
52
62
|
}
|
|
53
|
-
}
|
|
63
|
+
}
|