better handling of types

Author: pimpale

types/index.d.ts

@@ -119,6 +119,7 @@ declare module 'wink-nlp' {
     freqTable<T>(tokens: T[]): Array<[token: T, freq: number]>;
     bigrams<T>(tokens: T[]): Array<[T, T]>;
     unique<T>(tokens: T[]): T[];
+    text(tokens: any[]): string;
     markedUpText(tokens: any[]): string;
   }
 
@@ -134,7 +135,8 @@ declare module 'wink-nlp' {
     parentEntity(): ItemEntity | undefined;
     parentCustomEntity(): ItemCustomEntity | undefined;
     markup(beginMarker: string, endMarker: string): void;
-    out<T>(itsf: ItsFunction<T>): T;
+    out(): string;
+    out<T>(itsf: ItsFunction<T>): T | string;
     parentSentence(): ItemSentence;
     index(): number;
   }
@@ -144,21 +146,26 @@ declare module 'wink-nlp' {
     filter(f: (token: ItemToken) => boolean): SelectedTokens;
     itemAt(k: number): ItemToken | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface Tokens {
     each(f: (token: ItemToken) => void): void;
     filter(f: (token: ItemToken) => boolean): SelectedTokens;
     itemAt(k: number): ItemToken | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface ItemEntity {
     parentDocument(): Document;
     markup(beginMarker: string, endMarker: string): void;
-    out<T>(itsf: ItsFunction<T>): T;
+    out(): string;
+    out<T>(itsf: ItsFunction<T>): T | string;
     parentSentence(): ItemSentence;
     tokens(): Tokens;
     index(): number;
@@ -169,21 +176,26 @@ declare module 'wink-nlp' {
     filter(f: (entity: ItemEntity) => boolean): SelectedEntities;
     itemAt(k: number): ItemEntity | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface Entities {
     each(f: (entity: ItemEntity) => void): void;
     filter(f: (entity: ItemEntity) => boolean): SelectedEntities;
     itemAt(k: number): ItemEntity | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface ItemCustomEntity {
     parentDocument(): Document;
     markup(beginMarker: string, endMarker: string): void;
-    out<T>(itsf: ItsFunction<T>): T;
+    out(): string;
+    out<T>(itsf: ItsFunction<T>): T | string;
     parentSentence(): ItemSentence;
     tokens(): Tokens;
     index(): number;
@@ -194,21 +206,26 @@ declare module 'wink-nlp' {
     filter(f: (entity: ItemCustomEntity) => boolean): SelectedCustomEntities;
     itemAt(k: number): ItemCustomEntity | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface CustomEntities {
     each(f: (entity: ItemCustomEntity) => void): void;
     filter(f: (entity: ItemCustomEntity) => boolean): SelectedCustomEntities;
     itemAt(k: number): ItemCustomEntity | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface ItemSentence {
     parentDocument(): Document;
     markup(beginMarker: string, endMarker: string): void;
-    out<T>(itsf: ItsFunction<T>): T;
+    out(): string;
+    out<T>(itsf: ItsFunction<T>): T[] | string;
     entities(): Entities;
     customEntities(): CustomEntities;
     tokens(): Tokens;
@@ -219,15 +236,18 @@ declare module 'wink-nlp' {
     each(f: (entity: ItemSentence) => void): void;
     itemAt(k: number): ItemSentence | undefined;
     length(): number;
-    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U;
+    out(): string[];
+    out<T>(itsf: ItsFunction<T>): T[] | string[];
+    out<T, U>(itsf: ItsFunction<T>, asf: AsFunction<T, U>): U | T[] | string[];
   }
 
   export interface Document {
     entities(): Entities;
     customEntities(): CustomEntities;
     isLexeme(text: string): boolean;
     isOOV(text: string): boolean;
-    out<T>(itsf: ItsFunction<T>): T;
+    out(): string;
+    out<T>(itsf: ItsFunction<T>): T[] | string;
     sentences(): Sentences;
     tokens(): Tokens;
     printTokens(): void;

types/test.ts

@@ -1,14 +1,43 @@
-import winkNlp from 'wink-nlp';
+import winkNlp, {
+    Sentences,
+    CustomEntities,
+    SelectedCustomEntities,
+    Entities,
+    SelectedEntities,
+    Tokens,
+    SelectedTokens,
+    ItsFunction,
+    AsFunction,
+} from 'wink-nlp';
 import model from 'wink-eng-lite-web-model';
 
 // $ExpectType WinkMethods
 winkNlp(model);
 
 // $ExpectType WinkMethods
-winkNlp(model, ["foo"]);
+const nlp = winkNlp(model, ["foo"]);
 
 // $ExpectType ItsHelpers
-winkNlp(model).its;
+const its = nlp.its;
 
 // $ExpectType AsHelpers
-winkNlp(model).as;
+const as = winkNlp(model).as;
+
+// $ExpectType Document
+const doc = nlp.readDoc('test');
+
+// $ExpectType CustomEntities
+const customEntities = doc.customEntities();
+
+// $ExpectType string[]
+customEntities.out(its.value, as.array);
+
+// $ExpectType string[]
+customEntities.out(its.value, as.array);
+
+type OutApplicable = Sentences | CustomEntities | SelectedCustomEntities | Entities | SelectedEntities | Tokens | SelectedTokens;
+
+// $ExpectType <T, U>(toOut: OutApplicable, itsf: ItsFunction<T>, asf: AsFunction<T, U>) => U
+function myOut<T, U>(toOut: OutApplicable, itsf: ItsFunction<T>, asf: AsFunction<T, U>): U {
+  return (toOut.out(itsf, asf) as any) as U;
+}