}
139 | : never
140 | : T;
141 |
142 | export function isOptionalProperty(propertyName: string): boolean {
143 | return propertyName.match(/[^?]?(?:\?\?)*(\?)?$/)?.[1] === '?';
144 | }
145 |
146 | export function unescapePropertyName(propertyName: string): string {
147 | const match = propertyName.match(/^(.*?[^?]?)((?:\?\?)*)\??$/);
148 | if (match === null) {
149 | return propertyName;
150 | }
151 | const head = match[1] ?? '';
152 | const questionMarks = match[2].replace(/\?\?/g, '?') ?? '';
153 | return `${head}${questionMarks}`;
154 | }
155 |
156 | // https://github.com/microsoft/TypeScript/issues/21732#issuecomment-663994772
157 | function has(
158 | target: object,
159 | property: P
160 | ): target is {[K in P]: unknown} {
161 | return property in target;
162 | }
163 |
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | export {Checker, JsonTypeOf} from './types';
2 | export * as j from './checker';
3 |
--------------------------------------------------------------------------------
/src/types.ts:
--------------------------------------------------------------------------------
1 | export interface Checker {
2 | check(value: unknown): value is T;
3 | }
4 |
5 | export type JsonTypeOf> = T extends Checker
6 | ? U
7 | : never;
8 |
--------------------------------------------------------------------------------
/test-d/index.test-d.ts:
--------------------------------------------------------------------------------
1 | import {expectNotType, expectType} from 'tsd';
2 | import {Checker, j} from '../lib';
3 |
4 | // string
5 | expectType>(j.string);
6 |
7 | // number
8 | expectType>(j.number);
9 |
10 | // boolean
11 | expectType>(j.boolean);
12 |
13 | // null
14 | expectType>(j.nil);
15 |
16 | // unknown
17 | expectType>(j.unknown);
18 |
19 | // literal
20 | expectType>(j.literal('literal'));
21 |
22 | // any
23 | expectType<
24 | Checker<
25 | | string
26 | | number
27 | | boolean
28 | | null
29 | | 'literal'
30 | | (number | boolean)
31 | | string[]
32 | | {foo: string}
33 | >
34 | >(
35 | j.any([
36 | j.string,
37 | j.number,
38 | j.boolean,
39 | j.nil,
40 | j.literal('literal'),
41 | j.any([j.number, j.boolean]),
42 | j.array(j.string),
43 | j.object({foo: j.string}),
44 | ])
45 | );
46 | expectType>(j.any([j.string, j.unknown, j.number]));
47 |
48 | // nullable
49 | expectType>(j.nullable(j.string));
50 | expectType>(j.nullable(j.array(j.string)));
51 | expectType>(
52 | j.nullable(j.object({foo: j.string}))
53 | );
54 | expectType>(j.nullable(j.unknown));
55 |
56 | // array
57 | expectType>(j.array(j.string));
58 | expectType>(j.array(j.number));
59 | expectType>(j.array(j.boolean));
60 | expectType>(j.array(j.nil));
61 | expectType>(j.array(j.unknown));
62 | expectType>(j.array(j.literal('literal')));
63 | expectType>(j.array(j.any([j.string, j.number])));
64 | expectType>(j.array(j.array(j.string)));
65 | expectType>(j.array(j.object({foo: j.string})));
66 |
67 | // object
68 | expectType>(j.object({}));
69 | expectType>(j.object({foo: () => j.string}));
70 | expectType>(j.object({foo: () => 'foo'}));
71 | expectType>(j.object({'optional?': j.string}));
72 | expectNotType>(
73 | j.object({'optional?': j.string})
74 | );
75 | expectType>(j.object({'escaped??': j.string}));
76 | expectType>(
77 | j.object({'escaped_optional???': j.string})
78 | );
79 | expectNotType>(
80 | j.object({'escaped_optional???': j.string})
81 | );
82 | expectType<
83 | Checker<{
84 | string: string;
85 | number: number;
86 | boolean: boolean;
87 | nil: null;
88 | unknown: unknown;
89 | literal: 'literal';
90 | union: string | number;
91 | nullable: string | null;
92 | array: string[];
93 | nested: {
94 | string: string;
95 | };
96 | optional?: string;
97 | 'escaped?': string;
98 | 'escaped_optional?'?: string;
99 | lazy: number | string;
100 | }>
101 | >(
102 | j.object({
103 | string: j.string,
104 | number: j.number,
105 | boolean: j.boolean,
106 | nil: j.nil,
107 | unknown: j.unknown,
108 | literal: j.literal('literal'),
109 | union: j.any([j.string, j.number]),
110 | nullable: j.nullable(j.string),
111 | array: j.array(j.string),
112 | nested: j.object({
113 | string: j.string,
114 | }),
115 | 'optional?': j.string,
116 | 'escaped??': j.string,
117 | 'escaped_optional???': j.string,
118 | lazy: () => j.any([j.number, j.string]),
119 | })
120 | );
121 |
--------------------------------------------------------------------------------
/test/checker.test.ts:
--------------------------------------------------------------------------------
1 | import {
2 | any,
3 | array,
4 | boolean,
5 | isOptionalProperty,
6 | literal,
7 | nil,
8 | nullable,
9 | number,
10 | object,
11 | string,
12 | unescapePropertyName,
13 | unknown,
14 | } from '../src/checker';
15 | import {Checker} from '../src';
16 |
17 | export class TestChecker implements Checker {
18 | isCalled = false;
19 | private readonly result: boolean;
20 |
21 | constructor(result: boolean) {
22 | this.result = result;
23 | }
24 |
25 | check(value: unknown): value is unknown {
26 | this.isCalled = true;
27 | return this.result;
28 | }
29 | }
30 |
31 | export class TestSequenceChecker implements Checker {
32 | private callCount = 0;
33 | private readonly results: boolean[];
34 |
35 | constructor(results: boolean[]) {
36 | this.results = results;
37 | }
38 |
39 | check(value: unknown): value is unknown {
40 | return this.results[this.callCount++];
41 | }
42 | }
43 |
44 | describe('checker', () => {
45 | test('string', () => {
46 | expect(string.check('foo')).toBe(true);
47 | expect(string.check(123)).toBe(false);
48 | expect(string.check({})).toBe(false);
49 | expect(string.check(null)).toBe(false);
50 | });
51 |
52 | test('number', () => {
53 | expect(number.check(123)).toBe(true);
54 | expect(number.check(Number.POSITIVE_INFINITY)).toBe(true);
55 | expect(number.check(Number.NEGATIVE_INFINITY)).toBe(true);
56 | expect(number.check(Number.NaN)).toBe(true);
57 | expect(number.check('123')).toBe(false);
58 | expect(number.check({})).toBe(false);
59 | expect(number.check(null)).toBe(false);
60 | });
61 |
62 | test('boolean', () => {
63 | expect(boolean.check(true)).toBe(true);
64 | expect(boolean.check(false)).toBe(true);
65 | expect(boolean.check('true')).toBe(false);
66 | expect(boolean.check(1)).toBe(false);
67 | expect(boolean.check({})).toBe(false);
68 | expect(boolean.check([])).toBe(false);
69 | expect(boolean.check(null)).toBe(false);
70 | });
71 |
72 | test('nil', () => {
73 | expect(nil.check(null)).toBe(true);
74 | expect(nil.check('null')).toBe(false);
75 | expect(nil.check(Number.NaN)).toBe(false);
76 | expect(nil.check({})).toBe(false);
77 | expect(nil.check([])).toBe(false);
78 | expect(nil.check(undefined)).toBe(false);
79 | });
80 |
81 | test('unknown', () => {
82 | expect(unknown.check('foo')).toBe(true);
83 | expect(unknown.check(123)).toBe(true);
84 | expect(unknown.check({})).toBe(true);
85 | expect(unknown.check([])).toBe(true);
86 | expect(unknown.check(true)).toBe(true);
87 | expect(unknown.check(false)).toBe(true);
88 | expect(unknown.check(null)).toBe(true);
89 | });
90 |
91 | test('literal', () => {
92 | expect(literal('foo').check('foo')).toBe(true);
93 | expect(literal('foo').check('fooo')).toBe(false);
94 | });
95 |
96 | describe('any', () => {
97 | it('should return true if any of given checkers return true', () => {
98 | const checker1 = new TestChecker(true);
99 | const checker2 = new TestChecker(false);
100 | const checker3 = new TestChecker(false);
101 | expect(any([checker1, checker2]).check(null)).toBe(true);
102 | expect(any([checker1, checker3]).check(null)).toBe(true);
103 | expect(any([checker2, checker3]).check(null)).toBe(false);
104 | });
105 | });
106 |
107 | describe('nullable', () => {
108 | it('should return true if the value to be checked is null', () => {
109 | const checker = new TestChecker(false);
110 | expect(nullable(checker).check(null)).toBe(true);
111 | });
112 |
113 | it('should return true if the given checker returns true', () => {
114 | const checker = new TestChecker(true);
115 | expect(nullable(checker).check('any values')).toBe(true);
116 | expect(checker.isCalled).toBe(true);
117 | });
118 | });
119 |
120 | describe('array', () => {
121 | it('should return true if all elements are valid type', () => {
122 | const checker = new TestSequenceChecker([true, true, true, true, true]);
123 | expect(array(checker).check(Array(5).fill(null))).toBe(true);
124 | });
125 |
126 | it('should return false if even one element is wrong type', () => {
127 | const checker = new TestSequenceChecker([true, false, true]);
128 | expect(array(checker).check(Array(3).fill(null))).toBe(false);
129 | });
130 | });
131 |
132 | describe('object', () => {
133 | it('should return true if all properties are valid type', () => {
134 | expect(
135 | object({
136 | foo: new TestChecker(true),
137 | bar: new TestChecker(true),
138 | }).check({foo: null, bar: null})
139 | ).toBe(true);
140 | });
141 |
142 | it('should return false if even one property is wrong type', () => {
143 | expect(
144 | object({
145 | foo: new TestChecker(true),
146 | bar: new TestChecker(false),
147 | }).check({
148 | foo: null,
149 | bar: null,
150 | })
151 | ).toBe(false);
152 | });
153 |
154 | it('should return true if lazy checker returns true', () => {
155 | expect(
156 | object({
157 | foo: () => new TestChecker(true),
158 | }).check({foo: null})
159 | ).toBe(true);
160 | });
161 |
162 | it('should return false if lazy checker returns false', () => {
163 | expect(
164 | object({
165 | foo: () => new TestChecker(false),
166 | }).check({foo: null})
167 | ).toBe(false);
168 | });
169 |
170 | it('should return false if function does not return checker', () => {
171 | expect(
172 | object({
173 | foo: () => 'foo',
174 | }).check({foo: 'foo'})
175 | ).toBe(false);
176 | expect(
177 | object({
178 | foo: () => null,
179 | }).check({foo: null})
180 | ).toBe(false);
181 | });
182 |
183 | it('should return false if required property is missing', () => {
184 | expect(object({foo: new TestChecker(true)}).check({})).toBe(false);
185 | expect(object({'bar??': new TestChecker(true)}).check({})).toBe(false);
186 | expect(object({'foobar????????': new TestChecker(true)}).check({})).toBe(
187 | false
188 | );
189 | });
190 |
191 | it('should return true if optional property is missing', () => {
192 | expect(
193 | object({
194 | 'foo?': new TestChecker(false),
195 | 'bar???': new TestChecker(false),
196 | 'foobar???????': new TestChecker(false),
197 | }).check({})
198 | ).toBe(true);
199 | });
200 | });
201 | });
202 |
203 | describe('isOptionalProperty', () => {
204 | test('empty', () => {
205 | expect(isOptionalProperty('')).toBe(false);
206 | expect(isOptionalProperty('?')).toBe(true);
207 | expect(isOptionalProperty('??')).toBe(false);
208 | expect(isOptionalProperty('???')).toBe(true);
209 | expect(isOptionalProperty('????')).toBe(false);
210 | expect(isOptionalProperty('?????')).toBe(true);
211 | });
212 |
213 | test('name', () => {
214 | expect(isOptionalProperty('foo')).toBe(false);
215 | expect(isOptionalProperty('foo?')).toBe(true);
216 | expect(isOptionalProperty('foo??')).toBe(false);
217 | expect(isOptionalProperty('foo???')).toBe(true);
218 | expect(isOptionalProperty('foo????')).toBe(false);
219 | expect(isOptionalProperty('foo?????')).toBe(true);
220 | });
221 |
222 | test('name with question mark', () => {
223 | expect(isOptionalProperty('foo?bar')).toBe(false);
224 | expect(isOptionalProperty('foo?bar?')).toBe(true);
225 | expect(isOptionalProperty('foo?bar??')).toBe(false);
226 | expect(isOptionalProperty('foo?bar???')).toBe(true);
227 | expect(isOptionalProperty('foo?bar????')).toBe(false);
228 | expect(isOptionalProperty('foo?bar?????')).toBe(true);
229 | });
230 | });
231 |
232 | describe('unescapePropertyName', () => {
233 | test('empty', () => {
234 | expect(unescapePropertyName('')).toBe('');
235 | expect(unescapePropertyName('?')).toBe('');
236 | expect(unescapePropertyName('??')).toBe('?');
237 | expect(unescapePropertyName('???')).toBe('?');
238 | expect(unescapePropertyName('????')).toBe('??');
239 | expect(unescapePropertyName('?????')).toBe('??');
240 | });
241 |
242 | test('name', () => {
243 | expect(unescapePropertyName('foo')).toBe('foo');
244 | expect(unescapePropertyName('foo?')).toBe('foo');
245 | expect(unescapePropertyName('foo??')).toBe('foo?');
246 | expect(unescapePropertyName('foo???')).toBe('foo?');
247 | expect(unescapePropertyName('foo????')).toBe('foo??');
248 | expect(unescapePropertyName('foo?????')).toBe('foo??');
249 | });
250 |
251 | test('name with question mark', () => {
252 | expect(unescapePropertyName('foo?bar')).toBe('foo?bar');
253 | expect(unescapePropertyName('foo?bar?')).toBe('foo?bar');
254 | expect(unescapePropertyName('foo?bar??')).toBe('foo?bar?');
255 | expect(unescapePropertyName('foo?bar???')).toBe('foo?bar?');
256 | expect(unescapePropertyName('foo?bar????')).toBe('foo?bar??');
257 | expect(unescapePropertyName('foo?bar?????')).toBe('foo?bar??');
258 | });
259 | });
260 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "rootDir": "src",
4 | "strict": true,
5 | "target": "ES5",
6 | "lib": ["es2015"],
7 | "module": "esnext",
8 | "moduleResolution": "Node",
9 | "declaration": true,
10 | "declarationDir": "lib",
11 | },
12 | "include": [
13 | "./src/**/*"
14 | ]
15 | }
16 |
--------------------------------------------------------------------------------
3 | 
17 |
18 |