feat: initial commit

Author: jedwards1211

.eslintrc

@@ -2,5 +2,8 @@
   "extends": [
     "@jedwards1211/eslint-config-typescript",
     "eslint-config-prettier"
-  ]
+  ],
+  "rules": {
+    "@typescript-eslint/no-explicit-any": 0
+  }
 }

README.md

@@ -1,17 +1,17 @@
-# typescript-library-skeleton
+# @jcoreio/typescript-validators
 
-[![CircleCI](https://circleci.com/gh/jedwards1211/typescript-library-skeleton.svg?style=svg)](https://circleci.com/gh/jedwards1211/typescript-library-skeleton)
-[![Coverage Status](https://codecov.io/gh/jedwards1211/typescript-library-skeleton/branch/master/graph/badge.svg)](https://codecov.io/gh/jedwards1211/typescript-library-skeleton)
+[![CircleCI](https://circleci.com/gh/jcoreio/typescript-validators.svg?style=svg)](https://circleci.com/gh/jcoreio/typescript-validators)
+[![Coverage Status](https://codecov.io/gh/jcoreio/typescript-validators/branch/master/graph/badge.svg)](https://codecov.io/gh/jcoreio/typescript-validators)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
-[![npm version](https://badge.fury.io/js/typescript-library-skeleton.svg)](https://badge.fury.io/js/typescript-library-skeleton)
+[![npm version](https://badge.fury.io/js/%40jcoreio%2Ftypescript-validators.svg)](https://badge.fury.io/js/%40jcoreio%2Ftypescript-validators)
 
 This is my personal skeleton for creating an typescript library npm package. You are welcome to use it.
 
 ## Quick start
 
 ```sh
-npx 0-60 clone https://github.com/jedwards1211/typescript-library-skeleton.git
+npx 0-60 clone https://github.com/jcoreio/typescript-validators.git
 ```
 
 ## Tools used

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "typescript-library-skeleton",
+  "name": "@jcoreio/typescript-validators",
   "version": "0.0.0-development",
-  "description": "my personal ES2015 library project skeleton",
+  "description": "API input validators with user-friendly error output and TypeScript to ensure you don't miss any properties",
   "main": "index.js",
   "sideEffects": false,
   "scripts": {
@@ -69,17 +69,23 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jedwards1211/typescript-library-skeleton.git"
+    "url": "https://github.com/jcoreio/typescript-validators.git"
   },
   "keywords": [
-    "typescript"
+    "typescript",
+    "validation",
+    "validator",
+    "api",
+    "assertion",
+    "assert",
+    "validate"
   ],
   "author": "Andy Edwards",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/jedwards1211/typescript-library-skeleton/issues"
+    "url": "https://github.com/jcoreio/typescript-validators/issues"
   },
-  "homepage": "https://github.com/jedwards1211/typescript-library-skeleton#readme",
+  "homepage": "https://github.com/jcoreio/typescript-validators#readme",
   "devDependencies": {
     "@babel/cli": "^7.1.5",
     "@babel/core": "^7.1.6",
@@ -122,7 +128,8 @@
     "typescript": "^3.7.2"
   },
   "dependencies": {
-    "@babel/runtime": "^7.1.5"
+    "@babel/runtime": "^7.1.5",
+    "typelevel-ts": "^0.4.0"
   },
   "renovate": {
     "extends": [

src/Validation.ts

@@ -0,0 +1,159 @@
+import Type from './types/Type'
+import makeJSONError from './errorReporting/makeJSONError'
+import { weakSetAdd, weakSetDelete, weakSetHas } from './cyclic'
+
+export type IdentifierPath = Array<string | number | symbol>
+
+export type ErrorTuple = [IdentifierPath, string, Type<any>]
+
+export default class Validation<T> {
+  input: T
+
+  path: string[] = []
+
+  prefix: string = ''
+
+  errors: ErrorTuple[] = []
+
+  // Tracks whether we're in validation of cyclic objects.
+  cyclic: WeakMap<Type<any>, WeakSet<any>> = new WeakMap()
+
+  constructor(input: T) {
+    this.input = input
+  }
+
+  inCycle(type: Type<any>, input: any): boolean {
+    const tracked = this.cyclic.get(type)
+    if (!tracked) {
+      return false
+    } else {
+      return weakSetHas(tracked, input)
+    }
+  }
+
+  startCycle(type: Type<any>, input: any) {
+    let tracked = this.cyclic.get(type)
+    if (!tracked) {
+      tracked = new WeakSet()
+      this.cyclic.set(type, tracked)
+    }
+    weakSetAdd(tracked, input)
+  }
+
+  endCycle(type: Type<any>, input: any) {
+    const tracked = this.cyclic.get(type)
+    if (tracked) {
+      weakSetDelete(tracked, input)
+    }
+  }
+
+  hasErrors(path?: IdentifierPath): boolean {
+    if (path) {
+      for (const [candidate] of this.errors) {
+        if (matchPath(path, candidate)) {
+          return true
+        }
+      }
+      return false
+    } else {
+      return this.errors.length > 0
+    }
+  }
+
+  addError(
+    path: IdentifierPath,
+    expectedType: Type<any>,
+    message: string
+  ): this {
+    this.errors.push([path, message, expectedType])
+    return this
+  }
+
+  clearError(path: IdentifierPath | null | undefined): boolean {
+    let didClear = false
+    if (path) {
+      const errors = []
+      for (const error of this.errors) {
+        if (matchPath(path, error[0])) {
+          didClear = true
+        } else {
+          errors.push(error)
+        }
+      }
+      this.errors = errors
+    } else {
+      didClear = this.errors.length > 0
+      this.errors = []
+    }
+    return didClear
+  }
+
+  resolvePath(path: IdentifierPath): any {
+    return resolvePath(this.input, path)
+  }
+  toJSON(): any {
+    return makeJSONError(this)
+  }
+}
+
+const validIdentifierOrAccessor = /^[$A-Z_][0-9A-Z_$[\].]*$/i
+
+export function stringifyPath(path: IdentifierPath): string {
+  if (!path.length) {
+    return 'Value'
+  }
+  const { length } = path
+  const parts = new Array(length)
+  for (let i = 0; i < length; i++) {
+    const part = path[i]
+    if (part === '[[Return Type]]') {
+      parts[i] = 'Return Type'
+    } else if (
+      typeof part !== 'string' ||
+      !validIdentifierOrAccessor.test(part)
+    ) {
+      parts[i] = `[${String(part)}]`
+    } else if (i > 0) {
+      parts[i] = `.${String(part)}`
+    } else {
+      parts[i] = String(part)
+    }
+  }
+  return parts.join('')
+}
+
+export function resolvePath(input: any, path: IdentifierPath): any {
+  let subject = input
+  const { length } = path
+  for (let i = 0; i < length; i++) {
+    if (subject == null) {
+      return undefined
+    }
+    const part = path[i]
+    if (part === '[[Return Type]]') {
+      continue
+    }
+    if (subject instanceof Map) {
+      subject = subject.get(part)
+    } else {
+      subject = subject[part]
+    }
+  }
+  return subject
+}
+
+export function matchPath(
+  path: IdentifierPath,
+  candidate: IdentifierPath
+): boolean {
+  const { length } = path
+  if (length > candidate.length) {
+    return false
+  }
+  for (let i = 0; i < length; i++) {
+    if (candidate[i] !== path[i]) {
+      return false
+    }
+  }
+  return true
+}

src/__tests__/__fixtures__/$PropertyType/simplest$PropertyType.js

@@ -0,0 +1,26 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+export function pass (t: TypeContext) {
+  const ThingType = t.object({
+    id: t.number(),
+    name: t.string(),
+  });
+
+  const ThingNameType = t.$propertyType(ThingType, 'name');
+
+  return ThingNameType.assert('this is fine');
+}
+
+
+export function fail (t: TypeContext) {
+ const ThingType = t.object({
+    id: t.number(),
+    name: t.string(),
+  });
+
+  const ThingNameType = t.$propertyType(ThingType, 'name');
+
+  return ThingNameType.assert(false);
+}

src/__tests__/__fixtures__/$PropertyType/typeAlias$PropertyType.js

@@ -0,0 +1,26 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+export function pass (t: TypeContext) {
+  const ThingType = t.type('Thing', t.object({
+    id: t.number(),
+    name: t.string(),
+  }));
+
+  const ThingIdType = t.$propertyType(ThingType, 'id');
+
+  return ThingIdType.assert(123);
+}
+
+
+export function fail (t: TypeContext) {
+ const ThingType = t.object({
+    id: t.number(),
+    name: t.string(),
+  });
+
+  const ThingIdType = t.$propertyType(ThingType, 'id');
+
+  return ThingIdType.assert('this is bad');
+}

src/__tests__/__fixtures__/$TupleMapType/simplest$TupleMapType.js

@@ -0,0 +1,37 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+function makeType (t: TypeContext) {
+   const NumberStringType = t.tuple(
+    t.number(),
+    t.string()
+  );
+
+  const Pairer = t.function((fn) => {
+    const V = fn.typeParameter('V');
+    return [
+      t.param('v', t.flowInto(V)),
+      t.return(t.tuple(V, V))
+    ];
+  });
+
+  return t.$tupleMap(NumberStringType, Pairer);
+}
+
+export function pass (t: TypeContext) {
+  const PairedType = makeType(t);
+  return PairedType.assert([
+    [1, 1],
+    ['foo', 'bar']
+  ]);
+}
+
+
+export function fail (t: TypeContext) {
+ const PairedType = makeType(t);
+  return PairedType.assert([
+    ['nope', 'bar'],
+    [false]
+  ]);
+}

src/__tests__/__fixtures__/$TupleMapType/unwrap$TupleMapType.js

@@ -0,0 +1,38 @@
+/* @flow */
+
+import type TypeContext from '../../../TypeContext';
+
+function makeType (t: TypeContext) {
+   const NumberStringType = t.tuple(
+    t.number(),
+    t.string()
+  );
+
+  const Pairer = t.function((fn) => {
+    const V = fn.typeParameter('V');
+    return [
+      t.param('v', t.flowInto(V)),
+      t.return(t.tuple(V, V))
+    ];
+  });
+
+  return t.$tupleMap(NumberStringType, Pairer).unwrap();
+}
+
+export function pass (t: TypeContext) {
+  const PairedType = makeType(t);
+  PairedType.assert([
+    [1, 1],
+    ['foo', 'bar']
+  ]);
+  return PairedType.typeName === 'TupleType';
+}
+
+
+export function fail (t: TypeContext) {
+ const PairedType = makeType(t);
+  return PairedType.assert([
+    ['nope', 'bar'],
+    [false]
+  ]);
+}