🤖 Merge PR DefinitelyTyped#70460 [levn] [type-check] create levn, fix up type-check by @JoshuaKGoldberg

Author: JoshuaKGoldberg

types/levn/.npmignore

@@ -0,0 +1,5 @@
+*
+!**/*.d.ts
+!**/*.d.cts
+!**/*.d.mts
+!**/*.d.*.ts

types/levn/index.d.ts

@@ -0,0 +1,24 @@
+import { CustomType, ParsedType, ParsedTypeData } from "type-check";
+
+export interface CastableCustomType extends CustomType {
+    cast: (input: unknown) => ParsedTypeData;
+}
+
+export interface ParseOptions {
+    customTypes?: Record<string, CastableCustomType> | undefined;
+    explicit?: boolean | undefined;
+}
+
+export function parse(
+    type: string,
+    string: string,
+    options?: ParseOptions,
+): unknown;
+
+export function parsedTypeParse(
+    parsedType: ParsedType,
+    input: string,
+    options?: ParseOptions,
+): unknown;
+
+export const VERSION: string;

types/levn/levn-tests.ts

@@ -0,0 +1,42 @@
+import * as levn from "levn";
+import { parseType } from "type-check";
+
+levn.VERSION;
+
+levn.parse("Number", "2");
+
+levn.parse("RegExp", "re");
+
+levn.parse("RegExp", "re", {});
+levn.parse("RegExp", "re", { customTypes: {} });
+levn.parse("RegExp", "re", {
+    customTypes: {
+        Even: {
+            cast: input => ({
+                type: "Just",
+                value: input,
+            }),
+            typeOf: "Boolean",
+            validate: input => !!input,
+        },
+    },
+});
+levn.parse("RegExp", "re", { explicit: true });
+levn.parse("RegExp", "re", {
+    customTypes: {
+        Even: {
+            cast: input => ({
+                type: "Just",
+                value: input,
+            }),
+            typeOf: "Boolean",
+            validate: input => !!input,
+        },
+    },
+    explicit: true,
+});
+levn.parse("RegExp", "re", { explicit: true });
+
+const parsedType = parseType("[Number]");
+
+levn.parsedTypeParse(parsedType, "1,2,3");

types/levn/package.json

@@ -0,0 +1,20 @@
+{
+    "private": true,
+    "name": "@types/levn",
+    "version": "0.4.9999",
+    "projects": [
+        "https://github.com/gkz/levn"
+    ],
+    "dependencies": {
+        "@types/type-check": "*"
+    },
+    "devDependencies": {
+        "@types/levn": "workspace:."
+    },
+    "owners": [
+        {
+            "name": "Josh Goldberg",
+            "githubUsername": "JoshuaKGoldberg"
+        }
+    ]
+}

types/levn/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "node16",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "levn-tests.ts"
+    ]
+}

types/type-check/.eslintrc.json

@@ -1,25 +1,28 @@
-declare namespace TypeCheck {
-    export interface CustomType {
-        [typeName: string]: {
-            typeOf: string;
-            validate: (x: any) => any;
-        };
-    }
-
-    export interface Options {
-        customTypes: CustomType;
-    }
-
-    export interface TC {
-        VERSION: string;
-        typeCheck: (typeDescription: string, inst: any, options?: Options) => boolean;
-        parseType: (typeDescription: string) => Object;
-        parsedTypeCheck: (parsedType: any, obj: any) => boolean;
-    }
+export const VERSION: string;
+
+export interface CustomType {
+    typeOf: string;
+    validate: (input: unknown) => boolean;
+}
+
+export interface CustomTypes {
+    [typeName: string]: CustomType;
+}
+
+export interface Options {
+    customTypes?: CustomTypes;
 }
 
-declare var typecheck: TypeCheck.TC;
+export function typeCheck(type: string, input: unknown, options?: Options): boolean;
+
+// This is, in fact, a single element tuple.
+// eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
+export type ParsedType = [ParsedTypeData];
 
-declare module "type-check" {
-    export = typecheck;
+export interface ParsedTypeData {
+    type: string;
 }
+
+export function parseType(type: string): ParsedType;
+
+export function parsedTypeCheck(parsedType: ParsedType, input: string, options?: Options): boolean;

types/type-check/index.d.ts

@@ -2,7 +2,7 @@
 
 import tchecker = require("type-check");
 
-var typeCheck = (i1: string, i2: any, i3?: TypeCheck.Options) => {
+var typeCheck = (i1: string, i2: any, i3?: tchecker.Options) => {
     console.log(tchecker.typeCheck(i1, i2, i3));
 };
 var parseType = (i1: string) => {
@@ -62,7 +62,7 @@ typeCheck("RegExp{source: String, ...}", { source: "re" }); // false
 
 console.log("===>testing custom types");
 // Custom types:
-var opt = <TypeCheck.Options> {
+var opt = <tchecker.Options> {
     customTypes: {
         Even: {
             typeOf: "Number",
@@ -75,7 +75,7 @@ var opt = <TypeCheck.Options> {
 };
 typeCheck("Even", 2, opt); // true
 
-opt = <TypeCheck.Options> {
+opt = <tchecker.Options> {
     customTypes: {
         Odd: {
             typeOf: "Number",