FuseJS Typescript Definition

fusejs.d.ts

/**
 * FuseJS module definitions for Typescript
 *
 * @version 0.1.0
 */

declare type ArrayLike<T> = Array<T> | { length: number;[index: number]: T };

declare type ArrayOrIterable<T> = ArrayLike<T>;

declare type Optional<T> = T | null;

// Just to satisfy the compiler in this context
declare interface Promise<T> {}

declare namespace FuseJS {
  export type FileContent = string | ArrayBuffer;

  export interface StorageResult {}

  export interface Storage {
    deleteSync(filename: string): void;
    delete(filename: string): Promise<StorageResult>;
    readSync(filename: string): void;
    read(filename: string): Promise<StorageResult>;
    writeSync(filename: string, contents: FileContent): void;
    write(filename: string, contents: FileContent): Promise<StorageResult>;
  }

  export interface Observable<T> {
    CompareFn: (oldValue: T, newValue: T) => boolean;
    UpdateFn: (oldValue: T, newValue: T) => void;
    MapFn: (newValue: T) => T;

    length: number;
    toArray(): Array<T>;

    add(value: T): void;
    addAll(values: ArrayOrIterable<T>): void;

    // List operators
    clear(): void;
    contains(value: T): boolean;
    forEach(item: T, index?: number): void;
    getAt(index: number): Optional<T>;
    identity(): T;
    indexOf(value: T): number;
    insertAll(index: number, array: ArrayOrIterable<T>): void;
    insertAt(index: number, value: T): void;
    refreshAll(
      newValues: ArrayOrIterable<T>,
      compareFunc: (oldValue: T, newValue: T) => boolean,
      updateFunc: (oldValue: T, newValue: T) => void,
      mapFunc: (newValue: T) => T): void

    removeValue(value: T): void;
    removeAt(index: number): void;
    removeRange(start: number, count: number): void;
    removeWhere(func: (value: T) => boolean);
    replaceAll(array: ArrayOrIterable<T>): void;
    replaceAt(index: number, value: T): void;
    tryRemove(value: T): boolean;

    // Reactive operators
    any(value: T): Observable<boolean>;
    combine(obs: ArrayOrIterable<Observable<T>>, func: (...values: T[]) => T): Observable<T>;
    combineLatest(obs: ArrayOrIterable<Observable<T>>, func: (...values: T[]) => T): Observable<T>;
    combineArrays(obs: ArrayOrIterable<Observable<T>>, func: (...values: T[]) => T): Observable<T>;
    count(): number;
    count(condition: (value: T) => boolean): Observable<T>;
    expand(func: (value: ArrayOrIterable<T>) => T[]): Observable<T>;
    filter(condition: (value: T) => boolean): Observable<T>;
    first(): Observable<T>;
    flatMap(func: (item: T) => T): Observable<T>;
    inner(): Observable<T>;
    last(): Observable<T>;
    map(func: (value: T, index?: number) => T): Observable<T>;
    not(): Observable<T>;
    pick(index: number): Observable<T>;
    setInnerValue(value: T): Observable<T>;
    slice(begin?: number, end?: number);
    twoWayMap(getter: (value: T) => T, setter: (value: T) => T): Observable<T>;
    where(condition: (value: T) => T): Observable<T>;
    where(condition: { [key: string]: any }): Observable<T>;

    // Subscribers
    addSubscriber(func: (value: T) => void): void;
    removeSubscriber(func: (value: T) => void): void;

    // Other
    setValueWithOrigin(value: T, origin: T): void;
    toString(): string;
  }
}

declare module 'FuseJS/Storage' {
  import Storage = FuseJS.Storage;
  export = Storage;
}

declare module 'FuseJS/Observable' {
  import Observable = FuseJS.Observable;
  export = Observable;
}