Seamless-Immutable & Flow

Anybody an idea how to write a module declaration for this or how to use seamless with flow type? Any recommendations? Where to start, here we tried and failed badly a couple of times …

declare module 'seamless-immutable' {
  declare class SeamlessImmutableCollection {
    (collection: any, prototype?: Object, depth?: number): SeamlessImmutableCollection,

    /* array functions */
    flatMap(fn: Function): Array<any>,
    asObject(fn: Function): Object,
    asMutable(): Array<any>,

    /* object functions */
    merge(collection: Array<any> | Object, deep?: Object): Object,
    set(key: string, value: any): Object,
    setIn(keyPath: Array<string>, value: any): Object,
    update(key: string, fn: Function): Object,
    updateIn(keyPath: Array<string>, fn: Function): Object,
    without(fn: Function): Object,
    without(keys: Array<string>): Object,
    without(...keys: Array<string>): Object,
    asMutable(): Array<any> | Object
  }

  declare var exports: SeamlessImmutableCollection;
}

[chrisbull]

@azundo Found this…

https://gist.github.com/mizchi/3054bca701dff4b5e28efd9133c66818

seems to be working great for me thus far.

import Immutable, { type Immutable as ImmutableType } from 'seamless-immutable'

type LoginState = {
  authToken: string,
  error: any,
  fetching: boolean,
  loading: boolean,
}

type _LoginState = ImmutableType<LoginState>

const INITIAL_STATE: _LoginState = Immutable({
  authToken: '',
  error: null,
  fetching: false,
  loading: false,
})

export const request = (state: _LoginState): _LoginState =>
  state.merge({ fetching: true })

[KROT47]

With ES modules support:

/* @flow */

declare module 'seamless-immutable' {
  declare type fromType = Object | Array<*>;

  declare export type Immutable<T: fromType> = T & {
    // Array methods
    flatMap(fn: Function): Array<any>;
    asObject(fn: Function): Object;
    asMutable(): Array<any>;
    // Object methods
    merge(collection: Array<any> | Object, deep?: Object): Object;
    set(key: string, value: any): Object;
    setIn(keyPath: Array<string>, value: any): Object;
    update(key: string, fn: Function): Object;
    updateIn(keyPath: Array<string>, fn: Function): Object;
    without(fn: Function): Object;
    without(keys: Array<string>): Object;
    without(...keys: Array<string>): Object;
    asMutable(): Array<any> | Object;
  };

  declare export function from<T: fromType> (spec: T): Immutable<T>;

  declare export function isImmutable(x: *): boolean;

  declare export default typeof from;
}