Next Phenomenal Microbrewery

    mem-fn
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.1 • Public • Published

    Memoize functions. Similar to mem, but with the ability to set and clear individual keys, all arguments accounted for in the default cache key function, cache key function arguments are passed normally rather than as an array.

    Installation

    yarn add mem-fn
    npm install mem-fn

    Usage

    mem

    import mem from "mem-fn";
    
    let i = 0;
    
    function fn() {
      i += 1;
      return i;
    }
    
    const memFn = mem(fn);
    
    memFn(); // 1
    
    memFn(); // 1

    maxAge

    import mem from "mem-fn";
    
    let i = 0;
    
    function fn() {
      i += 1;
      return i;
    }
    
    const memFn = mem(fn, { maxAge: 100 }); // 100ms
    
    memFn(); // 1
    setTimeout(() => {
      memFn(); // 2
    }, 200);

    cacheKeyFn

    By default, alpha-stringify is used when more than one argument is present. All arguments are included, and object property order does not matter:

    import mem from "mem-fn";
    
    function add({ a, b }: { a: number, b: number }) {
      return a + b;
    }
    
    const memAdd = mem(add);
    
    memAdd({ a: 1, b: 2 }); // 3
    memAdd({ a: 1, b: 2 }); // cache hit - 3
    memAdd({ b: 2, a: 1 }); // cache hit - 3

    When creating a custom cacheKeyFn, arguments are passed normally rather than as an array:

    import mem from "mem-fn";
    
    function add(a: number, b: number) {
      return a + b;
    }
    
    const memAdd = mem(add, {
      cacheKeyFn: (a: number, b: number) => `${a}+${b}`
    });

    clear and set

    import mem from "mem-fn";
    
    function add(a: number, b: number) {
      return a + b;
    }
    
    const memAdd = mem(add);
    
    memAdd.set(1, 2)(4);  // set cache for arguments (1, 2) to 4
    memAdd(1, 2);         // 4
    memAdd.clear(1, 2);   // clear cache corresponding to these arguments
    memAdd(1, 2);         // 3
    memAdd.clearAll();    // clear entire cache

    onSet

    A hook is also provided for when set is called:

    import mem from "mem-fn";
    
    function add(a: number, b: number) {
      return a + b;
    }
    
    const memAdd = mem(add, {
      onSet: ([a, b]: [number, number], result: number) => console.log(`Set: ${a} + ${b} = ${number}`);
    });
    
    memAdd.set(1, 2)(4);  // Set: 1 + 2 = 4

    Types

    import mem, { Options, Fn, MemFn } from "mem-fn";
    
    function mem<F extends Fn<A, T>, A extends any[], T>(
      fn: Fn<A, T>,
      options?: Options<A, T>
    ): MemFn<A, T>;
    
    type Fn<A extends any[], T> = (...args: A) => T;
    
    type Options<A extends any[], T> = {
      /**
       * Milliseconds until the cache expires. Default: `Infinity`
       */
      maxAge?: number;
      /**
       * Determines cache key to use. Default: `(...args) => stringify(args)`
       */
      cacheKeyFn?: (...args: A) => string;
      /**
       * Hook to run after .set() function is called.
       */
      onSet?: (args: A, data: T) => void;
    };
    
    type MemFn<F extends Fn<A, T>, A extends any[], T> = F & {
      clear(...args: A): void;
      clearAll(): void;
      set(...args: A): (value: T) => T;
    };

    Dependenciesdependencies

    • alpha-stringify: Serialize anything, and sort keys for equality comparison

    Dev DependenciesDavid


    License license

    MIT

    Install

    npm i mem-fn

    DownloadsWeekly Downloads

    3

    Version

    1.0.1

    License

    MIT

    Unpacked Size

    8.57 kB

    Total Files

    7

    Last publish

    Collaborators

    • bconnorwhite