working on it ...

Filters

snippets
119k
followers
251
Published by snip2code

Javascript

This channel collects useful snippets for Javascript language
Sort by

Found 119k snippets

    public by szmerek modified Sep 6, 2017  263  4  5  0

    OnClick without setting an attribute of the link

    //<div id="dog" >Woow woow</div>
    
    
        (function() {
            document.getElementById("dog").onclick = function() { 
                alert('fuf fuf'); 
            };
        })();																								

    public by szmerek modified Aug 20, 2017  162  0  3  0

    Remove part of a string before specified character

    //remove string before '&' if want to include character '&' then 'indexOf("&") + 0'
    var str = "black&white";
    str = str.substring(str.indexOf("&") + 1);
    
    //or use regex
    var str = "black&white";
    str = /&(.+)/.exec(str)[1];
    
    // or use .split() and .pop() 
    var str = "black&white";
    str = str.split("&").pop();						

    public by szmerek modified Aug 20, 2017  143  1  3  0

    Check whether a string matches a regex

    //RegExp allows to inject variable values into the regex string
    var str = "sample1";
    var re = new RegExp("^([a-z0-9]{5,})$");
    if (re.test(str)) {
        console.log("valid");
    } else {
        console.log("invalid");
    }					

    public by szmerek modified Aug 20, 2017  141  0  4  0

    Hide element(s) by class

    Some examples for hiding the class.
    //Ex 
    //<div class="appBanner">appbanner</div> 
    
    document.getElementsByClassName('appBanner')[0].style.visibility = 'hidden';
    
    //change the style rules of all elements matching the class
    
    [].forEach.call(document.querySelectorAll('.appBanner'), function (el) {
      el.style.visibility = 'hidden';
    });
    
    //If for...of is available then use
    
    for (let el of document.querySelectorAll('.appBanner')) el.style.visibility = 'hidden';
    
    //And the other one
    
    Array.filter( document.getElementsByClassName('appBanner'), function(elem){ elem.style.visibility = 'hidden'; });
    
    //and the last one
    
    var appBanners = document.getElementsByClassName('appBanner'), i;
    
    for (i = 0; i < appBanners.length; i += 1) {
        appBanners[i].style.display = 'none';
    }																								

    public by snip2code modified Aug 13, 2017  117  0  3  1

    First Snippet: How to play with Snip2Code

    This is the first example of a snippet: - the title represents in few words which is the exact issue the snippet resolves; it can be something like the name of a method; - the description (this field) is an optional field where you can add interesting information regarding the snippet; something like the comment on the head of a method; - the c
    /* place here the actual content of your snippet. 
       It should be code or pseudo-code. 
       The less dependencies from external stuff, the better! */

    public by AbhishekGhosh modified Jul 26, 2017  20  0  1  0

    Adense-in-post

    Adense-in-post: Adense-in-post.js
    <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
    <!-- responsive_300x250 -->
    <ins class="adsbygoogle"
         style="display:block; text-align:center; width:100%;"
         data-ad-client="ca-pub-xxxxxxxxxxx"
         data-ad-slot="yyyyyyyyy"
         data-ad-format="rectangle"></ins>
    <script>
    (adsbygoogle = window.adsbygoogle || []).push({});
    </script>
    
    

    public by ElectroSoft modified Jul 15, 2017  158  0  4  0

    Prueba de Ajax

    Prueba de Axaj en javascript nativo.
    function ajax()
    {
        var elements = document.getElementsByClassName("formVal");
        var formData = new FormData(); 
        for(var i=0; i<elements.length; i++)
        {
            formData.append(elements[i].name, elements[i].value);
        }
        var xmlHttp = new XMLHttpRequest();
            xmlHttp.onreadystatechange = function()
            {
                if(xmlHttp.readyState == 4 && xmlHttp.status == 200)
                {
                    alert(xmlHttp.responseText);
                }
            }
            xmlHttp.open("post", "prueba.php"); 
            xmlHttp.send(formData); 
    }

    public by rosskevin modified Jul 1, 2017  22  0  1  0

    material-ui NotificationCenter

    material-ui NotificationCenter: NotificationCenter.js
    // @flow
    
    import Queue from 'es-collections/Queue'
    import Snackbar from '@alienfast/material-ui/Snackbar'
    import PropTypes from 'prop-types'
    import React, {Component} from 'react'
    import Logger from './util/Logger'
    import Performance from './util/Performance'
    import Button from './Button'
    
    // if test, shorten duration for multiple messages - saves ~9 seconds on reset_password.feature
    const DefaultDuration = __TEST__ ? 750 : 3000
    
    type Props = {}
    
    type State = {
      queueSize: number,
      status: 'queueSizeChanged' | 'exited'
    }
    
    type Notification = {
      message: string,
      duration?: number,
      delay?: number,
      action?: string,
      onAction?: Function
    }
    
    const EmptyNotification = {
      message: ''
    }
    
    class NotificationCenter extends Component<void, Props, State> {
      static contextTypes = {
        eventBus: PropTypes.object.isRequired
      }
      props: Props
      state: State = {
        queueSize: 0,
        status: 'exited'
      }
      subscriptions: Array<EmitterSubscription>
      queue: Queue
      notification: ?Notification = EmptyNotification
    
      componentWillMount () {
        log.debug('componentWillMount')
        this.queue = new Queue()
        const { eventBus } = this.context
        // eventBus.registerEvent('NotificationCenter', 'notification')
        this.subscriptions = eventBus.subscribe('notification', this.handleNotification)
      }
    
      componentWillUnmount () {
        log.debug('componentWillUnmount')
        const { eventBus } = this.context
        eventBus.unsubscribe(this.subscriptions)
      }
    
      shouldComponentUpdate (nextProps: Props, nextState: State, nextContext: any) {
        //log.debug('shouldComponentUpdate', this.queue.size)
    
        // check to see if we are still showing the current notification
        const peek = this.queue.peek()
        //log.debug('compare notifications', this.notification === peek, this.notification, peek)
        if (this.notification === peek) {
          return false
        }
    
        return Performance.shouldComponentUpdate(this, nextProps, nextState, nextContext, true)
      }
    
      updateQueueSize () {
        this.setState({
          queueSize: this.queue.size,
          status: 'queueSizeChanged'
        })
      }
    
      handleNotification = (notification: Notification) => {
        const { delay } = notification
        const enqueue = () => {
          this.queue.enqueue(notification)
          log.debug('handleNotification', this.queue.size, notification)
          this.updateQueueSize()
        }
    
        if (delay) {
          setTimeout(enqueue, delay)
        } else {
          enqueue()
        }
      }
    
      handleRequestClose = (event: ?SyntheticUIEvent, reason: string, onAction?: Function) => {
        log.debug('handleRequestClose', reason, onAction, this.notification)
        const { duration } = (this.notification ? this.notification : {}) // wacky flow maybe type
        if (reason === 'clickaway' && !duration === 0) {  // allow clickaway on duration 0
          log.debug(reason)
        } else {
          if (onAction) {
            onAction()
          }
          this.queue.dequeue()
          this.updateQueueSize()
        }
      }
    
      handleExited = () => {
        log.debug('handleExited', this.notification)
        this.setState({ status: 'exited' })
      }
    
      render () {
        const { status } = this.state
        const size = this.queue.size
        let open
        let shownNotification: ?Notification
    
        if (size === 0) {
          // We must render the snackbar with an empty notification and close it so
          //  that we still achieve the ease out effect.
          shownNotification = this.notification
          this.notification = EmptyNotification
          open = false
        } else if (status === 'queueSizeChanged' && this.notification !== EmptyNotification) {
          // allow this message to exit
          shownNotification = this.notification
          open = false
        } else {
          // ready to display a new message from the queue
          shownNotification = this.notification = this.queue.peek()
          open = true
        }
    
        const { message, action: actionString, duration, onAction } = (shownNotification || {})
    
        // from the action string, create a button to trigger the action and dismiss the snackbar
        let action
        if (actionString) {
          action = [
            <Button
              key={actionString}
              color='accent'
              dense
              onClick={() => onAction ? onAction() : null}
            >
              {actionString}
            </Button>
          ]
        }
    
        const snackbarProps = {
          open,
          autoHideDuration: (duration === undefined ? DefaultDuration : duration)
        }
        log.debug('render Queue size:', size, ' status: ', status, message, snackbarProps)
    
        return (
          <Snackbar
            key={message}
            {...snackbarProps}
            action={action}
            onRequestClose={this.handleRequestClose}
            onExited={this.handleExited}
            SnackbarContentProps={{
              'aria-describedby': 'message-id'
            }}
            message={<span id='message-id'>{message}</span>}
          />
        )
      }
    }
    
    const log = Logger.get('NotificationCenter')
    
    log.debug('DefaultDuration', DefaultDuration, __TEST__)
    export default NotificationCenter
    
    
    

    public by rosskevin modified Jun 3, 2017  18  0  1  0

    flow libdef for relay modern 1.2. This is in a _works for me_ state. Someone please export these properly from relay or create a proper flow-typed libdef.

    flow libdef for relay modern 1.2. This is in a _works for me_ state. Someone please export these properly from relay or create a proper flow-typed libdef.: relay.js
    // @flow
    
    declare module 'react-relay' {
      declare export type RecordState = 'EXISTENT' | 'NONEXISTENT' | 'UNKNOWN';
    
      declare export type onCompleted = (response: ?Object, errors: ?Array<PayloadError>) => void
      declare export type onError = (error: Error) => void
    
      declare export type CommitOptions = {
        onCompleted: onCompleted,
        onError: onError
      }
    
      /**
       * Ideally this would be a union of Field/Fragment/Mutation/Query/Subscription,
       * but that causes lots of Flow errors.
       */
      declare export type ConcreteBatchCallVariable = {
        jsonPath: string,
        kind: 'BatchCallVariable',
        sourceQueryID: string,
      }
      declare export type ConcreteCall = {
        kind: 'Call',
        metadata: {
          type?: ?string,
        },
        name: string,
        value: ?ConcreteValue,
      }
      declare export type ConcreteCallValue = {
        callValue: mixed,
        kind: 'CallValue',
      }
      declare export type ConcreteCallVariable = {
        callVariableName: string,
        kind: 'CallVariable',
      }
      declare export type ConcreteDirective = {
        args: Array<ConcreteDirectiveArgument>,
        kind: 'Directive',
        name: string,
      }
      declare export type ConcreteDirectiveArgument = {
        name: string,
        value: ?ConcreteDirectiveValue,
      }
      declare export type ConcreteDirectiveValue =
        | ConcreteCallValue
        | ConcreteCallVariable
        | Array<ConcreteCallValue | ConcreteCallVariable>
      declare export type ConcreteFieldMetadata = {
        canHaveSubselections?: ?boolean,
        inferredPrimaryKey?: ?string,
        inferredRootCallName?: ?string,
        isAbstract?: boolean,
        isConnection?: boolean,
        isConnectionWithoutNodeID?: boolean,
        isFindable?: boolean,
        isGenerated?: boolean,
        isPlural?: boolean,
        isRequisite?: boolean,
      }
      declare export type ConcreteFragmentMetadata = {
        isAbstract?: boolean,
        pattern?: boolean,
        plural?: boolean,
      }
      declare export type ConcreteMutation = {
        calls: Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        kind: 'Mutation',
        metadata: {
          inputType?: ?string,
        },
        name: string,
        responseType: string,
      };
      declare export type ConcreteOperationMetadata = {
        inputType?: ?string,
      }
      declare export type ConcreteQuery = {
        calls?: ?Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        fieldName: string,
        isDeferred?: boolean,
        kind: 'Query',
        metadata: {
          identifyingArgName?: ?string,
          identifyingArgType?: ?string,
          isAbstract?: ?boolean,
          isPlural?: ?boolean,
        },
        name: string,
        type: string,
      }
      declare export type ConcreteQueryMetadata = {
        identifyingArgName: ?string,
        identifyingArgType: ?string,
        isAbstract: ?boolean,
        isDeferred: ?boolean,
        isPlural: ?boolean,
      }
      declare export type ConcreteSubscription = {
        calls: Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        kind: 'Subscription',
        name: string,
        responseType: string,
        metadata: {
          inputType?: ?string,
        },
      }
      declare export type ConcreteValue =
        | ConcreteBatchCallVariable
        | ConcreteCallValue
        | ConcreteCallVariable
        | Array<ConcreteCallValue | ConcreteCallVariable>
    
      /**
       * The output of a graphql-tagged fragment definition.
       */
      declare export type ConcreteFragmentDefinition = {
        kind: 'FragmentDefinition',
        argumentDefinitions: Array<ConcreteArgumentDefinition>,
        node: ConcreteFragment,
      }
    
      declare export type ConcreteLocalArgumentDefinition = {
        kind: 'LocalArgument',
        name: string,
        defaultValue: mixed,
      }
    
      declare export type ConcreteRootArgumentDefinition = {
        kind: 'RootArgument',
        name: string,
      }
    
      /**
       * The output of a graphql-tagged operation definition.
       */
      declare export type ConcreteOperationDefinition = {
        kind: 'OperationDefinition',
        argumentDefinitions: Array<ConcreteLocalArgumentDefinition>,
        name: string,
        operation: 'mutation' | 'query' | 'subscription',
        node: ConcreteFragment | ConcreteMutation | ConcreteSubscription,
      }
    
      declare export type ConcreteArgument = ConcreteLiteral | ConcreteVariable
      declare export type ConcreteArgumentDefinition =
        | ConcreteLocalArgument
        | ConcreteRootArgument
      /**
       * Represents a single ConcreteRoot along with metadata for processing it at
       * runtime. The persisted `id` (or `text`) can be used to fetch the query,
       * the `fragment` can be used to read the root data (masking data from child
       * fragments), and the `query` can be used to normalize server responses.
       *
       * NOTE: The use of "batch" in the name is intentional, as this wrapper around
       * the ConcreteRoot will provide a place to store multiple concrete nodes that
       * are part of the same batch, e.g. in the case of deferred nodes or
       * for streaming connections that are represented as distinct concrete roots but
       * are still conceptually tied to one source query.
       */
      declare export type ConcreteBatch = {
        kind: 'Batch',
        fragment: ConcreteFragment,
        id: ?string,
        metadata: { [key: string]: mixed },
        name: string,
        query: ConcreteRoot,
        text: ?string,
      }
      declare export type ConcreteCondition = {
        kind: 'Condition',
        passingValue: boolean,
        condition: string,
        selections: Array<ConcreteSelection>,
      }
      declare export type ConcreteField = ConcreteScalarField | ConcreteLinkedField
      declare export type ConcreteFragment = {
        argumentDefinitions: Array<ConcreteArgumentDefinition>,
        kind: 'Fragment',
        metadata: ?{ [key: string]: mixed },
        name: string,
        selections: Array<ConcreteSelection>,
        type: string,
      }
      declare export type ConcreteFragmentSpread = {
        args: ?Array<ConcreteArgument>,
        kind: 'FragmentSpread',
        name: string,
      }
      declare export type ConcreteHandle = ConcreteScalarHandle | ConcreteLinkedHandle
      declare export type ConcreteRootArgument = {
        kind: 'RootArgument',
        name: string,
        type: ?string,
      }
      declare export type ConcreteInlineFragment = {
        kind: 'InlineFragment',
        selections: Array<ConcreteSelection>,
        type: string,
      }
      declare export type ConcreteLinkedField = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        concreteType: ?string,
        kind: 'LinkedField',
        name: string,
        plural: boolean,
        selections: Array<ConcreteSelection>,
        storageKey: ?string,
      }
      declare export type ConcreteLinkedHandle = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'LinkedHandle',
        name: string,
        handle: string,
        key: string,
        filters: ?Array<string>,
      }
      declare export type ConcreteLiteral = {
        kind: 'Literal',
        name: string,
        type: ?string,
        value: mixed,
      }
      declare export type ConcreteLocalArgument = {
        defaultValue: mixed,
        kind: 'LocalArgument',
        name: string,
        type: string,
      }
      declare export type ConcreteNode =
        | ConcreteCondition
        | ConcreteLinkedField
        | ConcreteFragment
        | ConcreteInlineFragment
        | ConcreteRoot
      declare export type ConcreteRoot = {
        argumentDefinitions: Array<ConcreteLocalArgument>,
        kind: 'Root',
        name: string,
        operation: 'mutation' | 'query' | 'subscription',
        selections: Array<ConcreteSelection>,
      }
      declare export type ConcreteScalarField = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'ScalarField',
        name: string,
        storageKey: ?string,
      }
      declare export type ConcreteScalarHandle = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'ScalarHandle',
        name: string,
        handle: string,
        key: string,
        filters: ?Array<string>,
      }
      declare export type ConcreteSelection =
        | ConcreteCondition
        | ConcreteField
        | ConcreteFragmentSpread
        | ConcreteHandle
        | ConcreteInlineFragment
      declare export type ConcreteVariable = {
        kind: 'Variable',
        name: string,
        type: ?string,
        variableName: string,
      }
      declare export type ConcreteSelectableNode = ConcreteFragment | ConcreteRoot
      declare export type GeneratedNode = ConcreteBatch | ConcreteFragment
    
      // The type of a graphql`...` tagged template expression.
      declare export type GraphQLTaggedNode =
        | (() => ConcreteFragment | ConcreteBatch)
        | {
        modern: () => ConcreteFragment | ConcreteBatch,
        classic: () => ConcreteFragmentDefinition | ConcreteOperationDefinition,
      }
    
      declare export function graphql (strings: Array<string>): GraphQLTaggedNode
    
      declare export type GeneratedNodeMap = { [key: string]: GraphQLTaggedNode }
    
      declare export function createFragmentContainer<TBase: React$ComponentType<*>> (
        Component: TBase,
        fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap
      ): TBase
    
      declare export function createRefetchContainer<TBase: React$ComponentType<*>>(
        Component: TBase,
        fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap,
        taggedNode: GraphQLTaggedNode,
      ): TBase
    
      declare export type Variables = { [name: string]: $FlowFixMe };
      declare export type DataID = string;
    
      declare type TEnvironment = Environment;
      declare type TFragment = ConcreteFragment;
      declare type TGraphQLTaggedNode = GraphQLTaggedNode;
      declare type TNode = ConcreteSelectableNode;
      declare type TOperation = ConcreteBatch;
      declare type TPayload = RelayResponsePayload;
    
      declare export type FragmentMap = CFragmentMap<TFragment>;
      declare export type OperationSelector = COperationSelector<TNode, TOperation>;
      declare export type RelayContext = CRelayContext<TEnvironment>;
      declare export type Selector = CSelector<TNode>;
      declare export type TSnapshot<TRecord> = CSnapshot<TNode, TRecord>;
      declare export type Snapshot = TSnapshot<Record>;
      declare export type ProxySnapshot = TSnapshot<RecordProxy>;
      declare export type UnstableEnvironmentCore = CUnstableEnvironmentCore<TEnvironment,
        TFragment,
        TGraphQLTaggedNode,
        TNode,
        TOperation,
        >;
    
      declare export interface IRecordSource<TRecord> {
        get(dataID: DataID): ?TRecord,
      }
    
      /**
       * A read-only interface for accessing cached graph data.
       */
      declare export interface RecordSource extends IRecordSource<Record> {
        get(dataID: DataID): ?Record,
    
        getRecordIDs(): Array<DataID>,
    
        getStatus(dataID: DataID): RecordState,
    
        has(dataID: DataID): boolean,
    
        load(dataID: DataID,
             callback: (error: ?Error, record: ?Record) => void,): void,
    
        size(): number,
      }
    
      /**
       * A read/write interface for accessing and updating graph data.
       */
      declare export interface MutableRecordSource extends RecordSource {
        clear(): void,
    
        delete(dataID: DataID): void,
    
        remove(dataID: DataID): void,
    
        set(dataID: DataID, record: Record): void,
      }
    
      /**
       * An interface for keeping multiple views of data consistent across an
       * application.
       */
      declare export interface Store {
        /**
         * Get a read-only view of the store's internal RecordSource.
         */
        getSource(): RecordSource,
    
        /**
         * Determine if the selector can be resolved with data in the store (i.e. no
         * fields are missing).
         */
        check(selector: Selector): boolean,
    
        /**
         * Read the results of a selector from in-memory records in the store.
         */
        lookup(selector: Selector): Snapshot,
    
        /**
         * Notify subscribers (see `subscribe`) of any data that was published
         * (`publish()`) since the last time `notify` was called.
         */
        notify(): void,
    
        /**
         * Publish new information (e.g. from the network) to the store, updating its
         * internal record source. Subscribers are not immediately notified - this
         * occurs when `notify()` is called.
         */
        publish(source: RecordSource): void,
    
        /**
         * Attempts to load all the records necessary to fulfill the selector into the
         * target record source.
         */
        resolve(target: MutableRecordSource,
                selector: Selector,
                callback: AsyncLoadCallback,): void,
    
        /**
         * Ensure that all the records necessary to fulfill the given selector are
         * retained in-memory. The records will not be eligible for garbage collection
         * until the returned reference is disposed.
         */
        retain(selector: Selector): Disposable,
    
        /**
         * Subscribe to changes to the results of a selector. The callback is called
         * when `notify()` is called *and* records have been published that affect the
         * selector results relative to the last `notify()`.
         */
        subscribe(snapshot: Snapshot,
                  callback: (snapshot: Snapshot) => void,): Disposable,
      }
    
      /**
       * An interface for imperatively getting/setting properties of a `Record`. This interface
       * is designed to allow the appearance of direct Record manipulation while
       * allowing different implementations that may e.g. create a changeset of
       * the modifications.
       */
      declare export interface RecordProxy {
        copyFieldsFrom(source: RecordProxy): void,
    
        getDataID(): DataID,
    
        getLinkedRecord(name: string, args?: ?Variables): ?RecordProxy,
    
        getLinkedRecords(name: string, args?: ?Variables): ?Array<?RecordProxy>,
    
        getOrCreateLinkedRecord(name: string,
                                typeName: string,
                                args?: ?Variables,): RecordProxy,
    
        getType(): string,
    
        getValue(name: string, args?: ?Variables): mixed,
    
        setLinkedRecord(record: RecordProxy,
                        name: string,
                        args?: ?Variables,): RecordProxy,
    
        setLinkedRecords(records: Array<?RecordProxy>,
                         name: string,
                         args?: ?Variables,): RecordProxy,
    
        setValue(value: mixed, name: string, args?: ?Variables): RecordProxy,
      }
    
      /**
       * An interface for imperatively getting/setting properties of a `RecordSource`. This interface
       * is designed to allow the appearance of direct RecordSource manipulation while
       * allowing different implementations that may e.g. create a changeset of
       * the modifications.
       */
      declare export interface RecordSourceProxy extends IRecordSource<RecordProxy> {
        create(dataID: DataID, typeName: string): RecordProxy,
    
        delete(dataID: DataID): void,
    
        get(dataID: DataID): ?RecordProxy,
    
        getRoot(): RecordProxy,
      }
    
      /**
       * Extends the RecordSourceProxy interface with methods for accessing the root
       * fields of a Selector.
       */
      declare export interface RecordSourceSelectorProxy extends IRecordSource<RecordProxy> {
        create(dataID: DataID, typeName: string): RecordProxy,
    
        delete(dataID: DataID): void,
    
        get(dataID: DataID): ?RecordProxy,
    
        getRoot(): RecordProxy,
    
        getRootField(fieldName: string): ?RecordProxy,
    
        getPluralRootField(fieldName: string): ?Array<?RecordProxy>,
    
        getResponse(): ?Object,
      }
    
      declare export interface IRecordReader<TRecord> {
        getDataID(record: TRecord): DataID,
    
        getType(record: TRecord): string,
    
        getValue(record: TRecord, name: string, args
    
        ?: ?
        Variables
        ):
        mixed,
    
        getLinkedRecordID(record: TRecord, name: string, args
    
        ?: ?
        Variables
        ): ?
        DataID,
    
        getLinkedRecordIDs(record: TRecord,
                           name: string,
                           args
    
        ?: ?
        Variables,
        ): ?
    
        Array<?
    
        DataID
        >,
      }
    
      /**
       * Settings for how a query response may be cached.
       *
       * - `force`: causes a query to be issued unconditionally, irrespective of the
       *   state of any configured response cache.
       * - `poll`: causes a query to live update by polling at the specified interval
       in milliseconds. (This value will be passed to setTimeout.)
       */
      declare export type CacheConfig = {
        force?: ?boolean,
        poll?: ?number,
      };
    
      /**
       * Represents any resource that must be explicitly disposed of. The most common
       * use-case is as a return value for subscriptions, where calling `dispose()`
       * would cancel the subscription.
       */
      declare export type Disposable = {
        dispose(): void,
      };
    
      /**
       * Arbitrary data e.g. received by a container as props.
       */
      declare export type Props = { [key: string]: mixed };
    
      /*
       * An individual cached graph object.
       */
      declare export type Record = { [key: string]: mixed };
    
      /**
       * A collection of records keyed by id.
       */
      declare export type RecordMap<T> = { [dataID: DataID]: ?T };
    
      /**
       * A selector defines the starting point for a traversal into the graph for the
       * purposes of targeting a subgraph.
       */
      declare export type CSelector<TNode> = {
        dataID: DataID,
        node: TNode,
        variables: Variables,
      };
    
      /**
       * A representation of a selector and its results at a particular point in time.
       */
      declare export type CSnapshot<TNode, TRecord> = CSelector<TNode> & {
        data: ?SelectorData,
        seenRecords: RecordMap<TRecord>,
      };
    
      /**
       * The results of a selector given a store/RecordSource.
       */
      declare export type SelectorData = { [key: string]: mixed };
    
      /**
       * The results of reading the results of a FragmentMap given some input
       * `Props`.
       */
      declare export type FragmentSpecResults = { [key: string]: mixed };
    
      /**
       * A utility for resolving and subscribing to the results of a fragment spec
       * (key -> fragment mapping) given some "props" that determine the root ID
       * and variables to use when reading each fragment. When props are changed via
       * `setProps()`, the resolver will update its results and subscriptions
       * accordingly. Internally, the resolver:
       * - Converts the fragment map & props map into a map of `Selector`s.
       * - Removes any resolvers for any props that became null.
       * - Creates resolvers for any props that became non-null.
       * - Updates resolvers with the latest props.
       */
      declare export interface FragmentSpecResolver {
        /**
         * Stop watching for changes to the results of the fragments.
         */
        dispose(): void,
    
        /**
         * Get the current results.
         */
        resolve(): FragmentSpecResults,
    
        /**
         * Update the resolver with new inputs. Call `resolve()` to get the updated
         * results.
         */
        setProps(props: Props): void,
    
        /**
         * Override the variables used to read the results of the fragments. Call
         * `resolve()` to get the updated results.
         */
        setVariables(variables: Variables): void,
      }
    
      declare export type CFragmentMap<TFragment> = { [key: string]: TFragment };
    
      /**
       * An operation selector describes a specific instance of a GraphQL operation
       * with variables applied.
       *
       * - `root`: a selector intended for processing server results or retaining
       *   response data in the store.
       * - `fragment`: a selector intended for use in reading or subscribing to
       *   the results of the the operation.
       */
      declare export type COperationSelector<TNode, TOperation> = {
        fragment: CSelector<TNode>,
        node: TOperation,
        root: CSelector<TNode>,
        variables: Variables,
      };
    
      /**
       * The public API of Relay core. Represents an encapsulated environment with its
       * own in-memory cache.
       */
      declare export interface CEnvironment<
      TEnvironment,
      TFragment,
      TGraphQLTaggedNode,
      TNode,
      TOperation,
      TPayload,
      > {
        /**
         * Read the results of a selector from in-memory records in the store.
         */
        lookup(selector: CSelector<TNode>): CSnapshot<TNode>,
    
        /**
         * Subscribe to changes to the results of a selector. The callback is called
         * when data has been committed to the store that would cause the results of
         * the snapshot's selector to change.
         */
        subscribe(
          snapshot: CSnapshot<TNode>,
          callback: (snapshot: CSnapshot<TNode>) => void,
        ): Disposable,
    
        /**
         * Ensure that all the records necessary to fulfill the given selector are
         * retained in-memory. The records will not be eligible for garbage collection
         * until the returned reference is disposed.
         *
         * Note: This is a no-op in the classic core.
         */
        retain(selector: CSelector<TNode>): Disposable,
    
        /**
         * Send a query to the server with request/response semantics: the query will
         * either complete successfully (calling `onNext` and `onCompleted`) or fail
         * (calling `onError`).
         *
         * Note: Most applications should use `streamQuery` in order to
         * optionally receive updated information over time, should that feature be
         * supported by the network/server. A good rule of thumb is to use this method
         * if you would otherwise immediately dispose the `streamQuery()`
         * after receving the first `onNext` result.
         */
        sendQuery(config: {|
          cacheConfig?: ?CacheConfig,
          onCompleted?: ?() => void,
          onError?: ?(error: Error) => void,
          onNext?: ?(payload: TPayload) => void,
          operation: COperationSelector<TNode, TOperation>,
        |}): Disposable,
    
        /**
         * Send a query to the server with request/subscription semantics: one or more
         * responses may be returned (via `onNext`) over time followed by either
         * the request completing (`onCompleted`) or an error (`onError`).
         *
         * Networks/servers that support subscriptions may choose to hold the
         * subscription open indefinitely such that `onCompleted` is not called.
         */
        streamQuery(config: {|
          cacheConfig?: ?CacheConfig,
          onCompleted?: ?() => void,
          onError?: ?(error: Error) => void,
          onNext?: ?(payload: TPayload) => void,
          operation: COperationSelector<TNode, TOperation>,
        |}): Disposable,
    
        unstable_internal: CUnstableEnvironmentCore<
          TEnvironment,
          TFragment,
          TGraphQLTaggedNode,
          TNode,
          TOperation,
          >,
      }
    
      declare export interface CUnstableEnvironmentCore<
      TEnvironment,
      TFragment,
      TGraphQLTaggedNode,
      TNode,
      TOperation,
      > {
        /**
         * Create an instance of a FragmentSpecResolver.
         *
         * TODO: The FragmentSpecResolver *can* be implemented via the other methods
         * defined here, so this could be moved out of core. It's convenient to have
         * separate implementations until the experimental core is in OSS.
         */
        createFragmentSpecResolver: (
          context: CRelayContext<TEnvironment>,
          containerName: string,
          fragments: CFragmentMap<TFragment>,
          props: Props,
          callback: () => void,
        ) => FragmentSpecResolver,
    
        /**
         * Creates an instance of an OperationSelector given an operation definition
         * (see `getOperation`) and the variables to apply. The input variables are
         * filtered to exclude variables that do not matche defined arguments on the
         * operation, and default values are populated for null values.
         */
        createOperationSelector: (
          operation: TOperation,
          variables: Variables,
        ) => COperationSelector<TNode, TOperation>,
    
        /**
         * Given a graphql`...` tagged template, extract a fragment definition usable
         * by this version of Relay core. Throws if the value is not a fragment.
         */
        getFragment: (node: TGraphQLTaggedNode) => TFragment,
    
        /**
         * Given a graphql`...` tagged template, extract an operation definition
         * usable by this version of Relay core. Throws if the value is not an
         * operation.
         */
        getOperation: (node: TGraphQLTaggedNode) => TOperation,
    
        /**
         * Determine if two selectors are equal (represent the same selection). Note
         * that this function returns `false` when the two queries/fragments are
         * different objects, even if they select the same fields.
         */
        areEqualSelectors: (a: CSelector<TNode>, b: CSelector<TNode>) => boolean,
    
        /**
         * Given the result `item` from a parent that fetched `fragment`, creates a
         * selector that can be used to read the results of that fragment for that item.
         *
         * Example:
         *
         * Given two fragments as follows:
         *
         * ```
         * fragment Parent on User {
       *   id
       *   ...Child
       * }
         * fragment Child on User {
       *   name
       * }
         * ```
         *
         * And given some object `parent` that is the results of `Parent` for id "4",
         * the results of `Child` can be accessed by first getting a selector and then
         * using that selector to `lookup()` the results against the environment:
         *
         * ```
         * const childSelector = getSelector(queryVariables, Child, parent);
         * const childData = environment.lookup(childSelector).data;
         * ```
         */
        getSelector: (
          operationVariables: Variables,
          fragment: TFragment,
          prop: mixed,
        ) => ?CSelector<TNode>,
    
        /**
         * Given the result `items` from a parent that fetched `fragment`, creates a
         * selector that can be used to read the results of that fragment on those
         * items. This is similar to `getSelector` but for "plural" fragments that
         * expect an array of results and therefore return an array of selectors.
         */
        getSelectorList: (
          operationVariables: Variables,
          fragment: TFragment,
          props: Array<mixed>,
        ) => ?Array<CSelector<TNode>>,
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts the selectors for those fragments from the results.
         *
         * The canonical use-case for this function are Relay Containers, which
         * use this function to convert (props, fragments) into selectors so that they
         * can read the results to pass to the inner component.
         */
        getSelectorsFromObject: (
          operationVariables: Variables,
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => {[key: string]: ?(CSelector<TNode> | Array<CSelector<TNode>>)},
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts a mapping of keys -> id(s) of the results.
         *
         * Similar to `getSelectorsFromObject()`, this function can be useful in
         * determining the "identity" of the props passed to a component.
         */
        getDataIDsFromObject: (
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => {[key: string]: ?(DataID | Array<DataID>)},
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts the merged variables that would be in scope for those
         * fragments/results.
         *
         * This can be useful in determing what varaibles were used to fetch the data
         * for a Relay container, for example.
         */
        getVariablesFromObject: (
          operationVariables: Variables,
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => Variables,
      }
    
      /**
       * The type of the `relay` property set on React context by the React/Relay
       * integration layer (e.g. QueryRenderer, FragmentContainer, etc).
       */
      declare export type CRelayContext<TEnvironment> = {
        environment: TEnvironment,
        variables: Variables,
      };
    
      /**
       * The public API of Relay core. Represents an encapsulated environment with its
       * own in-memory cache.
       */
      declare export interface Environment
        extends CEnvironment<
          TEnvironment,
          TFragment,
          TGraphQLTaggedNode,
          TNode,
          TOperation,
          TPayload,
          > {
        /**
         * Applies an optimistic mutation to the store without committing it to the
         * server. The returned Disposable can be used to revert this change at a
         * later time.
         */
        applyMutation(config: {|
          configs: Array<RelayMutationConfig>,
          operation: ConcreteOperationDefinition,
          optimisticResponse: Object,
          variables: Variables,
        |}): Disposable,
    
        /**
         * Applies an optimistic mutation if provided and commits the mutation to the
         * server. The returned Disposable can be used to bypass the `onCompleted`
         * and `onError` callbacks when the server response is returned.
         */
        sendMutation<ResponseType>(config: {|
          configs: Array<RelayMutationConfig>,
          onCompleted?: ?(response: ResponseType) => void,
          onError?: ?(error: Error) => void,
          operation: ConcreteOperationDefinition,
          optimisticOperation?: ?ConcreteOperationDefinition,
          optimisticResponse?: ?Object,
          variables: Variables,
          uploadables?: UploadableMap,
        |}): Disposable,
      }
    
      declare export type Observer<T> = {
        onCompleted?: ?() => void,
        onError?: ?(error: Error) => void,
        onNext?: ?(data: T) => void,
      };
    
      /**
       * The results of reading data for a fragment. This is similar to a `Selector`,
       * but references the (fragment) node by name rather than by value.
       */
      declare export type FragmentPointer = {
        __id: DataID,
        __fragments: { [fragmentName: string]: Variables },
      };
    
      /**
       * A callback for resolving a Selector from a source.
       */
      declare export type AsyncLoadCallback = (loadingState: LoadingState) => void;
      declare export type LoadingState = $Exact<{
        status: 'aborted' | 'complete' | 'error' | 'missing',
        error?: Error,
      }>;
    
      /**
       * A map of records affected by an update operation.
       */
      declare export type UpdatedRecords = { [dataID: DataID]: boolean };
    
      /**
       * A function that updates a store (via a proxy) given the results of a "handle"
       * field payload.
       */
      declare export type Handler = {
        update: (store: RecordSourceProxy, fieldPayload: HandleFieldPayload) => void,
      };
    
      /**
       * A payload that is used to initialize or update a "handle" field with
       * information from the server.
       */
      declare export type HandleFieldPayload = $Exact<{
        // The arguments that were fetched.
        args: Variables,
        // The __id of the record containing the source/handle field.
        dataID: DataID,
        // The (storage) key at which the original server data was written.
        fieldKey: string,
        // The name of the handle.
        handle: string,
        // The (storage) key at which the handle's data should be written by the
        // handler.
        handleKey: string,
      }>;
    
      /**
       * A function that receives a proxy over the store and may trigger side-effects
       * (indirectly) by calling `set*` methods on the store or its record proxies.
       */
      declare export type StoreUpdater = (store: RecordSourceProxy) => void;
    
      /**
       * Similar to StoreUpdater, but accepts a proxy tied to a specific selector in
       * order to easily access the root fields of a query/mutation.
       */
      declare export type SelectorStoreUpdater = (store: RecordSourceSelectorProxy) => void;
    
      declare export type CallValue = ?(
        | boolean
        | number
        | string
        | {[key: string]: CallValue}
        | Array<CallValue>);
    
      declare export type RangeBehaviorsFunction = (connectionArgs: {
        [argName: string]: CallValue,
      }) => ('APPEND' |
        'IGNORE' |
        'PREPEND' |
        'REFETCH' |
        'REMOVE' |
        'NODE_DELETE_HANDLER' |
        'RANGE_ADD_HANDLER' |
        'RANGE_DELETE_HANDLER' |
        'HANDLER_TYPES' |
        'OPTIMISTIC_UPDATE' |
        'SERVER_UPDATE' |
        'POLLER_UPDATE' |
        'UPDATE_TYPES' |
        'RANGE_OPERATIONS');
    
      declare export type RangeBehaviorsObject = {
        [key: string]: 'APPEND' | 'IGNORE' | 'PREPEND' | 'REFETCH' | 'REMOVE',
      };
    
      declare export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
    
      declare export type RelayConcreteNode = mixed;
    
      declare export type RelayMutationConfig =
        | {
        type: 'FIELDS_CHANGE',
        fieldIDs: {[fieldName: string]: DataID | Array<DataID>},
      }
        | {
        type: 'RANGE_ADD',
        parentName?: string,
        parentID?: string,
        connectionInfo?: Array<{
          key: string,
          filters?: Variables,
          rangeBehavior: string,
        }>,
        connectionName?: string,
        edgeName: string,
        rangeBehaviors?: RangeBehaviors,
      }
        | {
        type: 'NODE_DELETE',
        parentName?: string,
        parentID?: string,
        connectionName?: string,
        deletedIDFieldName: string,
      }
        | {
        type: 'RANGE_DELETE',
        parentName?: string,
        parentID?: string,
        connectionKeys?: Array<{
          key: string,
          filters?: Variables,
        }>,
        connectionName?: string,
        deletedIDFieldName: string | Array<string>,
        pathToConnection: Array<string>,
      }
        | {
        type: 'REQUIRED_CHILDREN',
        children: Array<RelayConcreteNode>,
      };
    
      declare export type MutationConfig<T> = {|
        configs?: Array<RelayMutationConfig>,
        mutation: GraphQLTaggedNode,
        variables: Variables,
        uploadables?: UploadableMap,
        onCompleted?: ?(response: T, errors: ?Array<PayloadError>) => void,
        onError?: ?(error: Error) => void,
        optimisticUpdater?: ?SelectorStoreUpdater,
        optimisticResponse?: Object,
        updater?: ?SelectorStoreUpdater,
      |};
    
      // a.k.a commitRelayModernMutation
      declare export function commitMutation<T>(
        environment: Environment,
        config: MutationConfig<T>,
      ): Disposable
    
      declare export type ReadyState = {
        error: ?Error,
        props: ?Object,
        retry: ?() => void,
      };
    
      /**
       * Classic environment below here
       */
      declare export class RelayQueryFragment {
        // stub
      }
    
      declare export class RelayQueryNode {
        // stub
      }
    
      declare export class RelayQueryRoot {
        // stub
      }
    
      declare export class RelayStoreData {
        // stub
      }
    
      declare export type RelayQuerySet = {[queryName: string]: ?RelayQueryRoot};
      declare export type ReadyStateChangeCallback = (readyState: ReadyState) => void;
      declare export type Abortable = {
        abort(): void,
      };
      declare export type StoreReaderData = Object;
      declare export type StoreReaderOptions = {
        traverseFragmentReferences?: boolean,
        traverseGeneratedFields?: boolean,
      };
      declare export type FragmentResolver = {
        dispose(): void,
        resolve(
          fragment: RelayQueryFragment,
          dataIDs: DataID | Array<DataID>,
        ): ?(StoreReaderData | Array<?StoreReaderData>),
      };
    
      declare export interface RelayEnvironmentInterface {
        forceFetch(
          querySet: RelayQuerySet,
          onReadyStateChange: ReadyStateChangeCallback,
        ): Abortable,
        getFragmentResolver(
          fragment: RelayQueryFragment,
          onNext: () => void,
        ): FragmentResolver,
        getStoreData(): RelayStoreData,
        primeCache(
          querySet: RelayQuerySet,
          onReadyStateChange: ReadyStateChangeCallback,
        ): Abortable,
        read(
          node: RelayQueryNode,
          dataID: DataID,
          options?: StoreReaderOptions,
        ): ?StoreReaderData,
        readQuery(
          root: RelayQueryRoot,
          options?: StoreReaderOptions,
        ): Array<?StoreReaderData>,
      }
    
      declare export type ClassicEnvironment = RelayEnvironmentInterface;
    
      declare export class QueryRenderer extends React$Component<{
        cacheConfig?: ?CacheConfig,
        environment: Environment | ClassicEnvironment,
        query: ?GraphQLTaggedNode,
        render: (readyState: ReadyState) => ?React$Element<*>,
        variables: Variables,
      }> {}
    
      // https://github.com/facebook/relay/blob/master/packages/relay-runtime/network/RelayNetworkTypes.js
      /**
       * A cache for saving respones to queries (by id) and variables.
       */
      declare export interface ResponseCache {
        get(id: string, variables: Variables): ?QueryPayload,
        set(id: string, variables: Variables, payload: QueryPayload): void,
      }
    
      /**
       * An interface for fetching the data for one or more (possibly interdependent)
       * queries.
       */
      declare export interface Network {
        fetch: FetchFunction,
        request: RequestResponseFunction,
        requestStream: RequestStreamFunction,
      }
    
      declare export type PayloadData = {[key: string]: mixed};
    
      declare export type PayloadError = {
        message: string,
        locations?: Array<{
          line: number,
          column: number,
        }>,
      };
    
      /**
       * The shape of a GraphQL response as dictated by the
       * [spec](http://facebook.github.io/graphql/#sec-Response)
       */
      declare export type QueryPayload = {|
        data?: ?PayloadData,
        errors?: Array<PayloadError>,
        rerunVariables?: Variables,
      |};
    
      /**
       * The shape of data that is returned by the Relay network layer for a given
       * query.
       */
      declare export type RelayResponsePayload = {|
        fieldPayloads?: ?Array<HandleFieldPayload>,
        source: MutableRecordSource,
        errors: ?Array<PayloadError>,
      |};
    
      declare export type PromiseOrValue<T> = Promise<T> | T | Error;
    
      /**
       * A function that executes a GraphQL operation with request/response semantics,
       * with exactly one raw server response returned
       */
      declare export type FetchFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        uploadables?: UploadableMap,
      ) => PromiseOrValue<QueryPayload>;
    
      /**
       * A function that executes a GraphQL operation with request/subscription
       * semantics, returning one or more raw server responses over time.
       */
      declare export type SubscribeFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        observer: Observer<QueryPayload>,
      ) => Disposable;
    
      /**
       * A function that executes a GraphQL operation with request/subscription
       * semantics, returning one or more responses over time that include the
       * initial result and optional updates e.g. as the results of the operation
       * change.
       */
      declare export type RequestStreamFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        observer: Observer<RelayResponsePayload>,
      ) => Disposable;
    
      /**
       * A function that executes a GraphQL operation with request/response semantics,
       * with exactly one response returned.
       */
      declare export type RequestResponseFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig?: ?CacheConfig,
        uploadables?: UploadableMap,
      ) => PromiseOrValue<RelayResponsePayload>;
    
      declare export type Uploadable = File | Blob;
      declare export type UploadableMap = {[key: string]: Uploadable};
    }
    
    
    

    public by Kevin Ross modified May 31, 2017  20  0  1  0

    flow libdef for found

    flow libdef for found: found.js
    // @flow
    
    // WARNING: this is early and mostly unused.  As I'm refactoring code I'll try to update this.  ping me with questions.
    
    declare module 'found' {
      declare type Map = { [key: string]: any }
      /**
       * The shape might be different with a custom matcher or history enhancer, but the default matcher
       * assumes and provides this shape. As such, this validator is purely for user convenience and
       * should not be used internally.
       */
      declare export type Match = {
        location: {
          pathname: string,
          query: Map,
        },
        params: Map,
      }
    
      /**
       * An object implementing the matching algorithm.
       *
       * User code generally shouldn't need this, but it doesn't hurt to export here, since we use it
       * for routerShape below.
       */
      declare export type Matcher = {
        match: Function,
        getRoutes: Function,
        isActive: Function,
        /**
         * Returns the path string for a pattern of the same format as a route path and a object of the
         * corresponding path parameters
         */
        format: (pattern: any, params: Map) => any,
      }
    
      /**
       * Location descriptor string:
       *  store.dispatch(FarceActions.push('/foo?bar=baz#qux'));
       *
       * Equivalent location descriptor object:
       *    store.dispatch(FarceActions.push({
       *     pathname: '/foo',
       *     search: '?bar=baz',
       *     hash: '#qux',
       *   }));
       *
       * https://github.com/4Catalyzer/farce#locations-and-location-descriptors
       */
      declare export type Location = {
        /**
         * 'PUSH' or 'REPLACE' if the location was reached via FarceActions.push or FarceActions.replace respectively;
         * 'POP' on the initial location, or if the location was reached via the browser back or forward buttons or
         * via FarceActions.go
         */
        action: 'PUSH' | 'REPLACE' | 'POP',
        /**
         * the path name; as on window.location e.g. '/foo'
         */
        pathname: string,
        /**
         * the search string; as on window.location e.g. '?bar=baz'
         */
        search: string,
        /**
         * the location hash; as on window.location e.g. '#qux'
         */
        hash: string,
        /**
         * if present, a unique key identifying the current history entry
         */
        key?: string,
        /**
         * the current index of the history entry, starting at 0 for the initial entry; this increments
         * on FarceActions.push but not on FarceActions.replace
         */
        index: number,
        /**
         * the difference between the current index and the index of the previous location
         */
        delta: number,
        /**
         * additional location state that is not part of the URL
         */
        state: any,
        /**
         * map version of search string
         */
        query: Map
      }
    
      /**
       * Lenient arg version of location using in #push and #replace.
       */
      declare export type LocationArg = string | {
          pathname: string,
          search?: string,
          hash?: string,
          state?: any,
          query?: Map
      }
    
      /**
       * The transition hook function receives the location to which the user is attempting to navigate.
       *
       * This function may return:
       *  - true to allow the transition
       *  - false to block the transition
       *  - A string to prompt the user with that string as the message
       *  - A nully value to call the next transition hook and use its return value, if present, or
       *    else to allow the transition
       *  - A promise that resolves to any of the above values, to allow or block the transition
       *    once the promise resolves
       *
       * @see https://github.com/4Catalyzer/farce#transition-hooks
       */
      declare export type TransitionHook = (location: Location) =>
        ?(boolean | string | Promise<?(boolean | string)>)
    
      declare export class Router {
        /**
         * Navigates to a new location
         * @see farce
         */
        push: (location: LocationArg) => void,
        /**
         * Replace the current history entry
         * @see farce
         */
        replace: (location: LocationArg) => void,
        /**
         * Moves delta steps in the history stack
         * @see farce
         */
          go: (delta: number) => void,
    
        createHref: Function,
        createLocation: Function,
        /**
         * for match as above, returns whether match corresponds to location or a subpath of location;
         * if exact is set, returns whether match corresponds exactly to location
         */
        isActive: (match: Match, location: Location, options: {exact?: boolean}) => boolean,
        matcher: Matcher,
        /**
         * Adds a transition hook that can block navigation.
         *
         * This method takes a transition hook function and returns a function to remove the transition hook.
         */
        addTransitionHook: (hook: TransitionHook) => (() => void),
      }
    
      declare export class Route {
        Component: Function
        children?: Array<Route>
        getComponent?: (props: RoutingState) => Promise<Function>
        path?: string
        render?: (args: RenderArgs) => Function
        prepareParams?: (params: Map, match: Match) => Map
        queries?: {
          [key: string]: Function
        }
      }
    
      declare export type RoutingState = {
        /**
         * The current location
         */
        location: Location,
        /**
         * The union of path parameters for all matched routes
         */
        params: Map,
        /**
         * An array of all matched route objects
         */
        routes: Array<Route>,
        /**
         * The route object corresponding to this component
         */
        route: Route,
        /**
         * the path parameters for route
         */
        routeParams: Map,
        router: Router,
        /**
         * an object with location and params as properties
         */
        match: Match,
        /**
         * an object with static router properties
         */
        router: Router
      }
    
      /**
       * @see https://github.com/4Catalyzer/found/blob/master/README.md#route-configuration
       * A bit lower for the list, no anchor there
       */
      declare export type RenderArgs = {
        match: Match,
        /**
         * the component for the route, if any; null if the component has not yet been loaded
         */
        Component?: Function,
        /**
         * the default props for the route component, specifically match with data as an additional property;
         * null if data have not yet been loaded
         */
        props?: RoutingState,
        /**
         * the data for the route, as above; null if the data have not yet been loaded
         */
        data?: any
      }
    }
    
    
    
    • Public Snippets
    • Channels Snippets