Merge pull request #61 from t-winter/master

added support for Date

Author: woutervh-

.gitignore

@@ -1,3 +1,4 @@
 node_modules/
 lib/
 test/*.js
+.idea

README.md

@@ -130,7 +130,7 @@ There are some options to configure the transformer.
 | Property | Description |
 |--|--|
 | `shortCircuit` | Boolean (default `false`). If `true`, all type guards will return `true`, i.e. no validation takes place. Can be used for example in production deployments where doing a lot of validation can cost too much CPU. |
-| `ignoreClasses` | Boolean (default: `false`). If `true`, when the transformer encounters a class, it will ignore it and simply return `true`. If `false`, an error is generated at compile time. |
+| `ignoreClasses` | Boolean (default: `false`). If `true`, when the transformer encounters a class (except for `Date`), it will ignore it and simply return `true`. If `false`, an error is generated at compile time. |
 | `ignoreMethods` | Boolean (default: `false`). If `true`, when the transformer encounters a method, it will ignore it and simply return `true`. If `false`, an error is generated at compile time. |
 | `ignoreFunctions` | Boolean (default: `false`). If `true`, when the transformer encounters a function, it will ignore it and simply return `true`. If `false`, an error is generated at compile time. |
 | `disallowSuperfluousObjectProperties` | Boolean (default: `false`). If `true`, objects are checked for having superfluous properties and will cause the validation to fail if they do. If `false`, no check for superfluous properties is made. |
@@ -279,7 +279,7 @@ There you can find all the different types that are tested for.
 
 * This library aims to be able to check any serializable data.
 * This library will not check functions. Function signatures are impossible to check at run-time.
-* This library will not check classes. Instead, you are encouraged to use the native `instanceof` operator. For example:
+* This library will not check classes (except the global `Date`). Instead, you are encouraged to use the native `instanceof` operator. For example:
 
 ```typescript
 import { is } from 'typescript-is';

index.d.ts

@@ -204,6 +204,10 @@ interface ExpectedObject {
     type: 'object';
 }
 
+interface ExpectedDate {
+    type: 'date';
+}
+
 interface ExpectedNonPrimitive {
     type: 'non-primitive';
 }
@@ -253,6 +257,7 @@ type Reason = ExpectedString
     | ExpectedBigInt
     | ExpectedBoolean
     | ExpectedObject
+    | ExpectedDate
     | ExpectedNonPrimitive
     | MissingObjectProperty
     | SuperfluousObjectProperty

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-is",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "engines": {
     "node": ">=6.14.4"
   },

package.json

@@ -8,6 +8,70 @@ import * as VisitorIsStringKeyof from './visitor-is-string-keyof';
 import * as VisitorTypeName from './visitor-type-name';
 import { sliceSet } from './utils';
 
+function visitDateType(type: ts.ObjectType, visitorContext: VisitorContext) {
+    const name = VisitorTypeName.visitType(type, visitorContext, { type: 'type-check' });
+    return VisitorUtils.setFunctionIfNotExists(name, visitorContext, () => {
+        return ts.createFunctionDeclaration(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            undefined,
+            [ts.createParameter(undefined, undefined, undefined, VisitorUtils.objectIdentifier, undefined, undefined, undefined)],
+            undefined,
+            ts.createBlock(
+                [
+                    ts.createVariableStatement(
+                        undefined,
+                        ts.createVariableDeclarationList(
+                            [ts.createVariableDeclaration(
+                                ts.createIdentifier('nativeDateObject'),
+                                undefined,
+                                undefined
+                            )],
+                            ts.NodeFlags.Let
+                        )
+                    ),
+                    ts.createIf(
+                        ts.createBinary(
+                            ts.createTypeOf(ts.createIdentifier('global')),
+                            ts.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
+                            ts.createStringLiteral('undefined')
+                        ),
+                        ts.createExpressionStatement(ts.createBinary(
+                            ts.createIdentifier('nativeDateObject'),
+                            ts.createToken(ts.SyntaxKind.EqualsToken),
+                            ts.createPropertyAccess(
+                                ts.createIdentifier('window'),
+                                ts.createIdentifier('Date')
+                            )
+                        )),
+                        ts.createExpressionStatement(ts.createBinary(
+                            ts.createIdentifier('nativeDateObject'),
+                            ts.createToken(ts.SyntaxKind.EqualsToken),
+                            ts.createPropertyAccess(
+                                ts.createIdentifier('global'),
+                                ts.createIdentifier('Date')
+                            )
+                        ))
+                    ),
+                    ts.createIf(
+                        ts.createLogicalNot(
+                            ts.createBinary(
+                                ts.createIdentifier('object'),
+                                ts.createToken(ts.SyntaxKind.InstanceOfKeyword),
+                                ts.createIdentifier('nativeDateObject')
+                            )
+                        ),
+                        ts.createReturn(VisitorUtils.createErrorObject({ type: 'date' })),
+                        ts.createReturn(ts.createNull())
+                    )],
+                true
+            )
+        )
+    });
+}
+
 function visitTupleObjectType(type: ts.TupleType, visitorContext: VisitorContext) {
     const name = VisitorTypeName.visitType(type, visitorContext, { type: 'type-check' });
     return VisitorUtils.setFunctionIfNotExists(name, visitorContext, () => {
@@ -379,7 +443,17 @@ function visitTypeParameter(type: ts.Type, visitorContext: VisitorContext) {
 
 function visitObjectType(type: ts.ObjectType, visitorContext: VisitorContext) {
     if (VisitorUtils.checkIsClass(type, visitorContext)) {
-        return VisitorUtils.getIgnoredTypeFunction(visitorContext);
+        // Dates
+        if (VisitorUtils.checkIsDateClass(type)) {
+            return visitDateType(type, visitorContext);
+        }
+
+        // all other classes
+        if (visitorContext.options.ignoreClasses) {
+            return VisitorUtils.getIgnoredTypeFunction(visitorContext);
+        } else {
+            throw new Error('Classes cannot be validated. https://github.com/woutervh-/typescript-is/issues/3');
+        }
     }
     if (tsutils.isTupleType(type)) {
         // Tuple with finite length.

src/transform-inline/visitor-type-check.ts

@@ -4,6 +4,7 @@ import { VisitorContext } from './visitor-context';
 import * as VisitorUtils from './visitor-utils';
 import * as VisitorKeyof from './visitor-keyof';
 import * as VisitorIndexedAccess from './visitor-indexed-access';
+import { checkIsDateClass } from './visitor-utils';
 
 interface TypeCheckNameMode {
     type: 'type-check';
@@ -67,6 +68,8 @@ function visitObjectType(type: ts.ObjectType, visitorContext: VisitorContext, mo
         return visitTupleObjectType(type, visitorContext, mode);
     } else if (visitorContext.checker.getIndexTypeOfType(type, ts.IndexKind.Number)) {
         return visitArrayObjectType(type, visitorContext, mode);
+    } else if (checkIsDateClass(type)) {
+        return '_date';
     } else {
         return visitRegularObjectType(type);
     }

src/transform-inline/visitor-type-name.ts

@@ -1,4 +1,5 @@
 import * as ts from 'typescript';
+import { ModifierFlags } from 'typescript';
 import * as tsutils from 'tsutils/typeguard/3.0';
 import { VisitorContext } from './visitor-context';
 import { Reason } from '../../index';
@@ -23,14 +24,16 @@ export function checkIsClass(type: ts.ObjectType, visitorContext: VisitorContext
         hasConstructSignatures = constructSignatures.length >= 1;
     }
 
-    if (type.isClass() || hasConstructSignatures) {
-        if (visitorContext.options.ignoreClasses) {
-            return true;
-        } else {
-            throw new Error('Classes cannot be validated. https://github.com/woutervh-/typescript-is/issues/3');
-        }
-    } else {
-        return false;
+    return type.isClass() || hasConstructSignatures;
+}
+
+export function checkIsDateClass(type: ts.ObjectType) {
+    if (
+        type.symbol !== undefined
+        && type.symbol.escapedName === 'Date'
+        && (ts.getCombinedModifierFlags(type.symbol.valueDeclaration) & ModifierFlags.Ambient) !== 0
+    ) {
+        return true;
     }
 }
 
@@ -589,5 +592,7 @@ function createErrorMessage(reason: Reason): ts.Expression {
             return createAssertionString(`expected ${reason.value ? 'true' : 'false'}`);
         case 'non-primitive':
             return createAssertionString('expected a non-primitive');
+        case 'date':
+            return createAssertionString('expected a Date');
     }
 }

src/transform-inline/visitor-utils.ts

@@ -1,9 +1,6 @@
 import { is } from '../index';
 
-class ClassX {
-    method() {
-        //
-    }
-}
+// overwriting the global Date with a custom class, this isn't supported and should raise an error if ignoreClasses is false
+class Date {}
 
-is<ClassX>(new ClassX()); // ignore when ignoreClasses is true
+is<Date>(new Date()); // ignore when ignoreClasses is true

test-fixtures/issue-16-a.ts

@@ -1,3 +1,3 @@
 import { is } from '../index';
 
-is<Date>({}); // Ignore when ignoreClasses and ignoreMethods are true.
+is<Date>({}); // Do NOT ignore when ignoreClasses and ignoreMethods are false.