How to use fast-memoize - 10 common examples

const [tableAdjective, referencedTableAdjective] = getAdjectives(fk.name, fk.table.name, fk.referencedTable.name);

    return [
      tableAdjective ? `${tableAdjective}${fk.separator}${fk.table.name}` : fk.table.name,
      referencedTableAdjective ? `${referencedTableAdjective}${fk.separator}${fk.referencedTable.name}` : fk.referencedTable.name,
    ];
  },
  { serializer: memoizeSerializer }
);

// Memoize uses JSON.stringify to cache arguments. DB objects has circular data structures which cannot be serialized. Below are manually memoized functions:
/**
 * Memoized function to get foreign keys from source table to target table.
 * @hidden
 */
export const getForeignKeysTo = memoize((source: Table, target?: Table) => source.foreignKeys.filter(fk => fk.referencedTable === target), {
  serializer: memoizeSerializer,
});

/**
 * Creates a summary table in markdown format for all relations in database.
 *
 * @ignore
 * @param relationNameFunction is function to name relations.
 * @returns markdown table.
 *
 * @example
 * pgStructure({ database: "db", user: "user", password: "password" }).then(db => {
 *  console.log(getRelationsMarkdown(db));
 *  console.log(db.relationNameCollisions);
 * });
 */

!Array.isArray(landbaseEquipsId)
          ? undefined
          : effectiveEquips(
              zip(landbaseEquipsId, onslots).map(([equipId, onslot]) =>
                equipId <= 0
                  ? undefined
                  : modifiedEquipDataSelectorFactory(equipId)({ state, onslot }),
              ),
              slotnum,
            ),
    ),
  ),
)

// Return [map, $map] or undefined
export const mapDataSelectorFactory = memoize(mapId =>
  arrayResultWrapper(
    createSelector([mapsSelector, constSelector], (maps, { $maps }) => {
      if (!maps[mapId] || !$maps[mapId]) return
      return [maps[mapId], $maps[mapId]]
    }),
  ),
)

export const sortieMapIdSelector = createSelector(sortieSelector, sortie => sortie.sortieMapId)
export const sortieMapDataSelector = createSelector(
  [sortieMapIdSelector, mapsSelector, constSelector],
  (mapId, maps, { $maps }) => getMapData(mapId, maps, $maps),
)
export const sortieMapHpSelector = createSelector(sortieMapDataSelector, mapData =>
  mapData ? getMapHp(mapData[0], mapData[1]) : undefined,
)

],
    (fleet, { sortieStatus }) =>
      flatMap(sortieStatus, (sortie, index) => (sortie ? get(fleet, [index, 'api_ship'], []) : [])),
  ),
)

export const escapeStatusSelectorFactory = memoize(shipId =>
  createSelector(
    [sortieShipIdSelector, sortieSelector],
    (sortieShipIds, { escapedPos }) =>
      shipId > 0 && escapedPos.some(pos => sortieShipIds[pos] === shipId),
  ),
)

// There's a Number type check
const shipBaseDataSelectorFactory = memoize(shipId =>
  createSelector([shipsSelector], ships =>
    ships && typeof shipId === 'number' && shipId ? ships[shipId] : undefined,
  ),
)

// Reads props.shipId
// Returns [_ship, $ship]
// Returns undefined if uninitialized, or if ship not found in _ship
// Attention: shipId here only accepts Number type,
//   otherwise will always return undefined
export const shipDataSelectorFactory = memoize(shipId =>
  arrayResultWrapper(
    createSelector([shipBaseDataSelectorFactory(shipId), constSelector], (ship, { $ships }) =>
      $ships && typeof ship === 'object' && ship ? [ship, $ships[ship.api_ship_id]] : undefined,
    ),
  ),

),
)

const shipSlotnumSelectorFactory = memoize(shipId =>
  createSelector(shipBaseDataSelectorFactory(shipId), ship => (ship ? ship.api_slotnum : 0)),
)
const shipSlotSelectorFactory = memoize(shipId =>
  createSelector(shipBaseDataSelectorFactory(shipId), ship => (ship ? ship.api_slot : undefined)),
)
const shipExslotSelectorFactory = memoize(shipId =>
  createSelector(shipBaseDataSelectorFactory(shipId), ship => (ship ? ship.api_slot_ex : -1)),
)
const shipOnSlotSelectorFactory = memoize(shipId =>
  createSelector(shipBaseDataSelectorFactory(shipId), ship => (ship ? ship.api_onslot : undefined)),
)
const landbaseSlotnumSelectorFactory = memoize(landbaseId =>
  createSelector(landbaseSelectorFactory(landbaseId), landbase =>
    landbase ? landbase.api_plane_info.length : 0,
  ),
)
const landbaseOnSlotSelectorFactory = memoize(landbaseId =>
  createSelector(landbaseSelectorFactory(landbaseId), landbase =>
    landbase ? landbase.api_plane_info.map(l => l.api_count) : undefined,
  ),
)
// Returns [equipId for each slot on the ship]
// length is always 5 + 1(ex slot)
// Slot is padded with -1 for each empty slot
// Returns undefined if ship is undefined
const shipEquipsIdSelectorFactory = memoize(shipId =>
  arrayResultWrapper(
    createSelector(

return obj
}

/**
 * Given a sequence of index1, elements1, ..., indexN elementN this function returns
 * the corresponding MerkleTree of height 7.
 */
const _generateMerkleTree = function(...args) {
  const txs = Array(2 ** 7).fill(sha256(0x0))
  for (let i = 0; i < args.length; i += 2) {
    txs[args[i]] = args[i + 1]
  }
  return new MerkleTree(txs, sha256)
}
const generateMerkleTree = memoize(_generateMerkleTree, {
  strategy: memoize.strategies.variadic,
})

const sendTxAndGetReturnValue = async function(method, ...args) {
  const result = await method.call(...args)
  await method(...args)
  return result
}

/**
 * Partitions array into chunks of size spacing
 * @param input: Array
 * @param spacing: int
 * @returns {Array}
 */
function partitionArray(input, spacing) {
  const output = []

if (searchRegExp.test(value)) {
        return true;
      }

      if (isLeaf) {
        return false;
      }

      const subtree = filter(node.nodes);

      return Boolean(subtree.length);
    });
  };

  const createFilteredTree = memoize(
    (tree, searchTerm) => (searchTerm ? filter(tree) : tree),
    {
      serializer: ([tree, searchTerm, softSearch]) =>
        `${JSON.stringify(tree)}-${searchTerm}-${softSearch}`,
    }
  );
  const renderNode = ({ node, parent, depth = 0, haltSearch }) => {
    const {
      searchTerm,
      softSearch,
      onLeafClick: _,
      onParentClick: __,
      expansionPanelSummaryProps,
      expansionPanelDetailsProps,
      listItemProps,
      caseSensitiveSearch,

if (size && typeof size === 'string') {
    if (endsWith(size, '%')) {
      const ratio = Number(size.replace('%', '')) / 100;
      return parentSize * ratio;
    } else if (endsWith(size, 'vw')) {
      const ratio = Number(size.replace('vw', '')) / 100;
      return window.innerWidth * ratio;
    } else if (endsWith(size, 'vh')) {
      const ratio = Number(size.replace('vh', '')) / 100;
      return window.innerHeight * ratio;
    }
  }
  return size;
};

const calculateNewMax = memoize(
  (
    parentSize: { width: number; height: number },
    maxWidth?: string | number,
    maxHeight?: string | number,
    minWidth?: string | number,
    minHeight?: string | number,
  ) => {
    maxWidth = getPixelSize(maxWidth, parentSize.width);
    maxHeight = getPixelSize(maxHeight, parentSize.height);
    minWidth = getPixelSize(minWidth, parentSize.width);
    minHeight = getPixelSize(minHeight, parentSize.height);
    return {
      maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth),
      maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight),
      minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth),
      minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight),

return mapping[sortBy];
};

const filterTasksByState = curry((filter, tasks) =>
  filter
    ? tasks.filter(({ node: { status: { state } } }) => filter.includes(state))
    : tasks
);
const filterTasksByName = curry((searchTerm, tasks) =>
  searchTerm
    ? tasks.filter(({ node: { metadata: { name } } }) =>
        lowerCase(name).includes(searchTerm)
      )
    : tasks
);
const createSortedTasks = memoize(
  (tasks, sortBy, sortDirection, filter, searchTerm) => {
    const filteredTasks = pipe(
      filterTasksByState(filter),
      filterTasksByName(searchTerm)
    )(tasks);

    if (!sortBy) {
      return filteredTasks;
    }

    return filteredTasks.sort((a, b) => {
      const firstElement =
        sortDirection === 'desc'
          ? valueFromNode(b.node, sortBy)
          : valueFromNode(a.node, sortBy);
      const secondElement =

constructor() {
    super();

    this.createNativeFormatter = memoize((locales, options) => {
      return new Intl.DateTimeFormat(locales, options);
    });
  }

locale = locale || getCurrentLocale()
  if (locale == null) {
    throw new Error('[svelte-i18n] A "locale" must be set to format numbers')
  }

  if (format) {
    options = getIntlFormatterOptions('number', format)
  }

  return new Intl.NumberFormat(locale, options)
})

export const getDateFormatter: MemoizedIntlFormatter<
  Intl.DateTimeFormat,
  Intl.DateTimeFormatOptions
> = memoize(({ locale, format, ...options } = {}) => {
  locale = locale || getCurrentLocale()
  if (locale == null) {
    throw new Error('[svelte-i18n] A "locale" must be set to format dates')
  }

  if (format) options = getIntlFormatterOptions('date', format)
  else if (Object.keys(options).length === 0) {
    options = getIntlFormatterOptions('date', 'short')
  }

  return new Intl.DateTimeFormat(locale, options)
})

export const getTimeFormatter: MemoizedIntlFormatter<
  Intl.DateTimeFormat,
  Intl.DateTimeFormatOptions