Accumulating type in TypeScript like powerful instrument for organizing code

Main Idea

Accumulating type is a type that combines the types of declarations that occur in different parts of the code with the same name. Type merging is done according to the OR principle.
Principles and dogmas:

• related code in one place
• organizing separate and independent modules
• write once use everywhere
• intermodular interaction through types

Search Terms

accumulate type, type system

Suggestion

Add the ability to declare accumulative types

Examples

// file: moduleAFolder/moduleA.ts
    accumulate type ModuleNames = "ModuleA"; // type to be "ModuleA" | "ModuleB"
    
// file: moduleAFolder/moduleAHelper.ts
    import {ModuleNames} from "moduleAFolder/moduleA";
    //      ^ powerful part of example: importing type ONLY from moduleA, NOT from ModuleB
    //      ^ accessible value for ModuleNames here are "ModuleA" and "ModuleB"

    const a: ModuleNames = "ModuleA"; // it's ok
    const b: ModuleNames = "ModuleB"; // it's ok.
    const c: ModuleNames = "Unknown"; // it's error
    
// file: moduleBFolder/moduleB.ts
    accumulate type ModuleNames = "ModuleB"; // type to be "ModuleA" | "ModuleB";                   

Example above is very simple but illustrates all principles good code. In more difficalt cases we have 100 modules and 1000 types. Some of them has types that need in another modules.

Yes, we can create folder with name 'shared' and move common types to this folder:

• but then we destroy the integrity of the code inside the separate module. Everything that looked whole before that became fragmented;
• but then we make the “shared” folder a trash or garbage;

Yes, we can copy common types from one module to another:

• but then we make smelling bad code;
• but then we make bug prone code;

More difficult example

 // file: moduleAFolder/moduleA.ts
     accumulate type CrossModuleTypes = {
         "ModuleA": {
             id: string;
             data: {
                 value: string;
             }
         }
     }
     
     
 // file: moduleBFolder/moduleB.ts
     accumulate type CrossModuleTypes = {
         "ModuleB": {
             id: string;
             segment: {
                 part: string;
             }
         }
     }
     
 // file: moduleCFolder/moduleC.ts
     // no imports here!
     accumulate type CrossModuleTypes; // nothing merge, only usaging;
     type UnionToIntersection<U> =  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never
     type ModuleBType = UnionToIntersection<CrossModuleTypes>["ModuleB"];
     const cachingData: ModuleBType = this.loadFromCache("ModuleB");
     console.log("Caching segment from ModuleB is ", cachingData.segment.part); // no errors here.

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Inizia esaminando la sintassi proposta e i TypeScript Design Goals collegati nell’issue. Non sono indicati file di implementazione, test o punti di ingresso del compilatore, quindi il primo compito è individuare le aree del type-checker e della risoluzione dei moduli che regolano le dichiarazioni tra moduli. Il lavoro è completato quando la semantica dei tipi cumulativa è stata definita e validata, preservando l’output JavaScript esistente.