Delete redundant helper

Author: Andrii Kirmas

src/defs.spec.ts

@@ -1,15 +1,10 @@
-import { Component } from "react";
+import { Component, PureComponent } from "react";
 import type { ClassNames } from "./defs";
 
-type ClassNamesSingleton<C extends string> = {classNames: Record<C, string|undefined>}
-
-class ClassComponent extends Component<ClassNamesSingleton<"component">> {}
-class ClassPureComponent extends Component<ClassNamesSingleton<"pureComponent">> {}
-function Functional(_: ClassNamesSingleton<"functional">) {
-  return null
-}
-type ComponentProps= ClassNamesSingleton<"props">
-
+type Props = ClassNames<true, "props">
+function Functional(_: ClassNames<"functional">) { return null }
+class ClassComponent extends Component<ClassNames<"component"|"comp0">> {}
+class ClassPureComponent extends PureComponent<ClassNames<"pureComponent">> {}
 
 describe("ClassNames", () => {
   it("<true>", () => {
@@ -76,7 +71,7 @@ describe("ClassNames", () => {
     expect(suites).toBeInstanceOf(Object)
   })
 })
-describe("", () => {
+describe("Miss-use", () => {
   it("<'class1', true>", () => {
     const suite1
     //@ts-expect-error Type 'boolean' does not satisfy the constraint 'never'
@@ -114,17 +109,18 @@ describe("ClassNamesFrom", () => {
 
   it("manually merge", () => {
     type AppClassNames = (
-      ClassNamesSingleton<"App">
+      ClassNames<"App">
       & ClassNames<typeof ClassComponent>
       & ClassNames<typeof ClassPureComponent>
       & ClassNames<typeof Functional>
-      & ClassNames<ComponentProps>
+      & ClassNames<Props>
     )["classNames"];
 
     const suites: Record<string, AppClassNames> = {
       "exact": {
         App: undefined,
         component: undefined,
+        comp0: undefined,
         functional: undefined,
         props: undefined,
         pureComponent: undefined
@@ -179,18 +175,20 @@ describe("ClassNamesFrom", () => {
   })
 
   it("multiple apply", () => {
-    type AppClassnames = ClassNames<
+    type AppClassNames = ClassNames<
+        true,
         "App",
         typeof ClassComponent,
         typeof ClassPureComponent,
         typeof Functional,
-        ComponentProps
+        Props
     >["classNames"];
 
-    const suites: Record<string, AppClassnames> = {
+    const suites: Record<string, AppClassNames> = {
       "exact": {
         App: undefined,
         component: undefined,
+        comp0: undefined,
         functional: undefined,
         props: undefined,
         pureComponent: undefined

src/defs.test.ts

@@ -1,43 +1,7 @@
-import type { JSXElementConstructor } from "react";
 import { Component } from "react";
-import type { ClassNamesProp, ClassNamesStrict, GetClassKeys } from "./defs";
+import type { ClassNamesProp, GetClassKeys } from "./defs";
 
-class ClassComponent0 extends Component<ClassNamesStrict<never, "comp1"|"comp2">> {}
-class ClassComponent1 extends Component<ClassNamesStrict<true, never>> {}
-class ClassComponent2 extends Component<ClassNamesStrict<true, "comp1"|"comp2">> {}
-
-describe("ClassNamesStrict", () => {
-  it("<never, 'class1'|'class2'>", () => {
-    const suites: Record<string, ClassNamesStrict<never, 'class1'|'class2'>> = {
-      "good": {
-        classNames: {
-          class1: undefined,
-          class2: undefined
-        }
-      }
-    }
-    expect(suites).toBeInstanceOf(Object)
-  })
-  it("ClassComponent0", () => {
-    const suites: Record<string, ClassNamesStrict<never, never, typeof ClassComponent0>> = {
-      "good": {
-        classNames: {
-          comp1: undefined,
-          comp2: undefined,
-          //@ts-expect-error Object literal may only specify known properties, and 'redundant' does not exist
-          redundant: undefined
-        }
-      },
-      "omitted": {
-        //@ts-expect-error Property 'comp2' is missing in type
-        classNames: {
-          comp1: undefined,
-        }
-      }
-    }
-    expect(suites).toBeInstanceOf(Object)
-  })
-})
+class ClassComponent0 extends Component<ClassNamesProp<"comp1"|"comp2">> {}
 
 describe("GetClassKeys", () => {
   it("ClassComponent", () => {
@@ -50,20 +14,3 @@ describe("GetClassKeys", () => {
     expect(suites).toBeInstanceOf(Object)
   })
 })
-
-it("WithClassNames", () => {
-  type WithClassNames = ClassNamesProp | JSXElementConstructor<ClassNamesProp>
-  // | Component<ClassNamesProp> | (props: ClassNamesProp) => any
-
-  const suites: Record<string, WithClassNames> = {
-    ClassComponent0,
-    //TODO
-    //@ts-expect-error Property 'className' is missing
-    ClassComponent1,
-    //TODO
-    //@ts-expect-error Property 'className' is missing
-    ClassComponent2,
-  }
-
-  expect(suites).toBeInstanceOf(Object)
-})

src/defs.ts

@@ -34,35 +34,6 @@ export type ClassNames<
   | GetClassKeys<C10>  
 >
 
-
-export type ClassNamesStrict<
-  C0 extends true | never,
-  C1 extends string | never = never,
-  C2 extends ReactRelated = never,
-  C3 extends ReactRelated = never,
-  C4 extends ReactRelated = never,
-  C5 extends ReactRelated = never,
-  C6 extends ReactRelated = never,
-  C7 extends ReactRelated = never,
-  C8 extends ReactRelated = never,
-  C9 extends ReactRelated = never,
-  C10 extends ReactRelated = never,
-  C11 extends ReactRelated = never
->
-= Ever<C0, {className: string}> & ClassNamesProp<C1
-> & ClassNamesProp<C1
-| GetClassKeys<C2>
-| GetClassKeys<C3>
-| GetClassKeys<C4>
-| GetClassKeys<C5>
-| GetClassKeys<C6>
-| GetClassKeys<C7>
-| GetClassKeys<C8>
-| GetClassKeys<C9>
-| GetClassKeys<C10>  
-| GetClassKeys<C11>  
->
-
 export type ReactRelated = Record<string, any> | JSXElementConstructor<any>
 
 export type ClassNamesProp<C extends string = string> = Ever<C, {classNames: ClassNamesMap<C>}>