TypeScript mantra-core.composeAll函數代碼示例

import {useDeps, composeWithTracker, composeAll, IKomposer, IKomposerData} from 'mantra-core';

export const composer: IKomposer = ({context, postId}, onData: IKomposerData) => {
  const {Meteor, Collections, Tracker} = context();

  Meteor.subscribe('posts.single', postId, () => {
    const post = Collections.Posts.findOne(postId);
    onData(null, {post});
  });

  // support latency compensation
  //  we don't need to invalidate tracker because of the
  //  data fetching from the cache.
  const postFromCache = Tracker.nonreactive(() => {
    return Collections.Posts.findOne(postId);
  });

  if (postFromCache) {
    onData(null, {post: postFromCache});
  } else {
    onData();
  }

  return null;
};

export default composeAll(
  composeWithTracker(composer),
  useDeps()
)(Post);

import NewPost from '../components/newpost';
import {useDeps, composeWithTracker, composeAll, IKomposer, IKomposerData, IDepsMapper} from 'mantra-core';



export const composer: IKomposer = ({context, clearErrors}, onData: IKomposerData) => {
  const {LocalState} = context();
  const error = LocalState.get('SAVING_ERROR');
  onData(null, {error});

  // clearErrors when unmounting the component
  return clearErrors;
};

export const depsMapper: IDepsMapper = (context, actions) => ({
  create: actions.posts.create,
  clearErrors: actions.posts.clearErrors,
  context: () => context
});

export default composeAll(
  composeWithTracker(composer),
  useDeps(depsMapper)
)(NewPost);

import { IContext } from "../configs/context";
import { useDeps, composeWithTracker, composeAll, IKomposer, IKomposerData } from "mantra-core";
import Component, { IComponentProps, IComponentActions } from "../components/logged_user_view";
import { VIEWKEY, ERRORKEY, MESSAGEKEY } from "../actions/accounts";

interface IProps {
  context?: IContext;
  showUserName?: boolean;
}

export const composer: IKomposer = ({context, showUserName}: IProps, onData: IKomposerData<IComponentProps>) => {
  const { Meteor, i18n }: IContext = context;

  onData(null, {
    userName: showUserName ? Meteor.user().profile.name : "",
    context: context
  });

  return null;
};

export const depsMapper = (context: IContext, actions: any): IComponentActions => ({
  signOut: actions.accounts.signOut
});

export default composeAll<IProps>(
  composeWithTracker(composer),
  useDeps(depsMapper)
)(Component);

      },
      forceFetch: true
    }
  };
};

const mapMutationsToProps = (p: any) => ({
  removePostMutation: (id: string) => {
    return createMutation(`
      mutation removePost($id: String) {
         removePost(id: $id)
      }`, { id });
  }
});

const mapDispatchToProps = (dispatch: IDispatch, ownProps: IProps) => ({
  removePost: (mutation: any) => {
    dispatch(ownProps.removePost(ownProps.postId, mutation));
  },
});

const depsToPropsMapper = (context: IContext, actions: IActions) => ({
  removePost: actions.posts.remove
});

export default composeAll<IProps>(
  compose(apolloContainer()),
  connect({ mapQueriesToProps, mapMutationsToProps, mapDispatchToProps }),
  useDeps(depsToPropsMapper) // -> not needed here
)(Post);

      return {
        mutation: gql`
        mutation addComment($postId: String, $comment: String) {
           addComment(postId: $postId, comment: $comment)
        }`,
        variables: {
          postId: postId,
          comment
        }
      };
    }
  };
};

const mapStateToProps = (state: IState) => {
  return {
    error: state.post.error
  };
};

export const mapDepsToProps = (context: IContext, actions: IActions ) => ({
  create: actions.comments.create,
  clearErrors: actions.general.clearErrors,
  context: () => context
});

export default composeAll<IProps>(
  connect({mapMutationsToProps, mapStateToProps}),
  useDeps(mapDepsToProps)
)(Component);

  context?: () => IContext;
}

const composer: IKomposer = ({ mark }: IComponentProps, onData: IKomposerData<IComponentProps>) => {
  if (mark) {
    onData(null, { mark });
  } else {
    onData();
  }
  return null;
};

const mapDispatchToProps = (dispatch: any, ownProps: any): IComponentActions => ({
  assignResult: (index: number, mark: any) =>
    dispatch({ type: 'CHANGE_MARK', index, mark }),
  changeStudent: (student: string) =>
    dispatch({ type: 'STUDENT', student }),
  save: () => {
    dispatch({ type: 'SAVE' });
  }
});

const mapStateToProps = (state: IState) => ({
  mark: state.mark
});

export default composeAll<IProps>(
  compose(composer),
  connect(mapStateToProps, mapDispatchToProps)
)(Component);

import { compose, composeAll } from 'mantra-core';
import apolloContainer from './apollo';
import { connect } from 'react-apollo';

interface IProps {
  context: IContainerContext;
}

function mapQueriesToProps() {
  return {
    data: {
      query: gql`
          {
            posts {
             _id,
             title,
             content
           }
          }
        `,
      forceFetch: true
    }
  };
};

export default composeAll<{}>(
  compose(apolloContainer()),
  connect({ mapQueriesToProps })
  // useDeps() // -> not needed here
)(PostList);

      sort: { student: 1 }
    };
    const marks = Collections.Results.find({}, options).fetch();

    // store data in the store
    Store.dispatch({ type: 'RESULTS', marks });

    if (id) {
      Store.dispatch({ type: 'RESULT', mark: Collections.Results.findOne(id) });
    } else {
      Store.dispatch({ type: 'CREATE_RESULT'});
    }

    onData(null, {});
  } else {
    onData();
  }

  return null;
};

const mapStateToProps = (state: IState) => ({
  marks: state.marks
});

export default composeAll<IProps>(
  connect(mapStateToProps),
  composeWithTracker(composer),
  useDeps()
)(Component);

    addPost: generateMutationObject
  };
};

// const mapDispatchToProps = (dispatch: any, ownProps: any) => {
//   return {
//     create: (title: string, content: string, mutation: any) => {
//         dispatch(ownProps.createAction(title, content, mutation));
//     }
//   };
// };

const mapStateToProps = (state: IState) => {
  return {
    error: state.post.error
  };
};

const mapDepsToProps = (context: IContext, actions: IActions) => {
  return {
     create: actions.posts.create
  };
};

export default composeAll<{}>(
  connect({mapMutationsToProps, mapStateToProps}),
  useDeps(mapDepsToProps)
)(NewPost);

// export default (NewPost);

  ownProps: IProps;
  state: IState;
}

const mapQueriesToProps = ({ ownProps }: IReduxProps): IGraphqlQuery  => {
  return {
    data: {
      query: gql`
          query comments($postId: String) {
            comments(postId: $postId) {
             _id,
             createdAt,
             text,
             author
           }
          }
        `,
      forceFetch: true,
      variables: {
        postId: ownProps.postId
      }
    }
  };
};


export default composeAll<IProps>(
  compose(apolloContainer()),
  connect({ mapQueriesToProps })
)(Component);