Top 10 Examples of "stable in functional component" in JavaScript

if (selectorText.indexOf(',') > -1) {
        selectorText.split(/\s*,\s*/).forEach(st => {
          buildSelectorTextToCSSText(selectorTextToCSSTexts, st, cssText);
        });
      } else {
        buildSelectorTextToCSSText(
          selectorTextToCSSTexts,
          selectorText,
          cssText
        );
      }
    });
  });

  // Sort selector by
  stable(selectorTextToCSSTexts, sortBySpecificity)
    .reduce(buildElementToCSSTexts.bind(null, doc), new Map())
    .forEach(applyInlineStyleSheetCSSTexts);
}

//
    // Create the CRD with the Kubernetes API
    //
    const create = await client.apis['apiextensions.k8s.io'].v1beta1.customresourcedefinitions.post({ body: crd })
    console.log('Create: ', create)

    //
    // Add endpoints to our client
    //
    client.addCustomResourceDefinition(crd)

    //
    // List all the resources of the new type
    //
    const all = await client.apis['stable.example.com'].v1.namespaces('default').crontabs.get()
    console.log('All: ', all)

    //
    // Get a specific resources.
    //
    const one = await client.apis['stable.example.com'].v1.namespaces('default').crontabs('foo').get()
    console.log('One: ', one)
  } catch (err) {
    console.error('Error: ', err)
  }
}

// Find regular middleware entries
    const middleware = instances.filter(function(m) {
      return !m.isPhasePlaceHolder;
    });

    // Sort the entries to keep the order
    stableSortInPlace(phases, compareByOrder);

    // Build a map for phase orders (phaseName --> phaseOrder)
    const phaseOrders = {};
    phases.forEach(function(p) {
      phaseOrders[p.phase] = p.order;
    });

    stableSortInPlace(middleware, function(m1, m2) {
      // First by phase
      let delta = phaseOrders[m1.phase] - phaseOrders[m2.phase];
      if (delta !== 0) return (delta > 0 ? 1 : -1);
      // by subPhase
      delta = compareBySubPhase(m1, m2);
      if (delta !== 0) return (delta > 0 ? 1 : -1);
      // By order
      return compareByOrder(m1, m2);
    });
    return {
      phases: phases,
      middleware: middleware,
    };
  }

const playerIds = [
			this.parser.player.guid,
			...this.parser.player.pets.map(pet => pet.guid),
		].join(',')
		filter =  `(${filter}) and source.id not in (${playerIds})`

		// Request the new events
		const newEvents = await getFflogsEvents(
			this.parser.report.code,
			this.parser.fight,
			{filter},
		)

		// Add them onto the end, then sort. Using stable to ensure order is kept, as it can be sensitive sometimes.
		events.push(...newEvents)
		stable.inplace(events, (a, b) => {
			if (a.timestamp === b.timestamp) {
				const aTypeOrder = EVENT_TYPE_ORDER[a.type] || EVENT_TYPE_ORDER.default
				const bTypeOrder = EVENT_TYPE_ORDER[b.type] || EVENT_TYPE_ORDER.default
				return aTypeOrder - bTypeOrder
			}
			return a.timestamp - b.timestamp
		})

		return events
	}
}

proto._sortLayersByPhase = function() {
  if (this._skipLayerSorting) return;

  const phaseOrder = {};
  this._requestHandlingPhases.forEach(function(name, ix) {
    phaseOrder[name + ':before'] = ix * 3;
    phaseOrder[name] = ix * 3 + 1;
    phaseOrder[name + ':after'] = ix * 3 + 2;
  });

  const router = this._router;
  stableSortInPlace(router.stack, compareLayers);

  function compareLayers(left, right) {
    const leftPhase = left.phase;
    const rightPhase = right.phase;

    if (leftPhase === rightPhase) return 0;

    // Builtin middleware is always first
    if (leftPhase === BUILTIN_MIDDLEWARE) return -1;
    if (rightPhase === BUILTIN_MIDDLEWARE) return 1;

    // Layers registered via app.use and app.route
    // are executed as the first items in `routes` phase
    if (leftPhase === undefined) {
      if (rightPhase === 'routes')
        return -1;

function middleware(req, res, next) {
    // bail early if req/res don't pass conditions for execution or there's no data to sort
    if (!should_execute(req, res) || _.isEmpty(res.data)) {
      return next();
    }

    // capture the pre-sort order
    const presort_order = res.data.map(_.property('_id'));

    // stable operates on array in place
    stable.inplace(res.data, comparator(req.clean));

    // capture the post-sort order
    const postsort_order = res.data.map(_.property('_id'));

    // log it for debugging purposes
    logger.debug([
      `req.clean: ${JSON.stringify(req.clean)}`,
      `pre-sort: [${presort_order}]`,
      `post-sort: [${postsort_order}]`
    ].join(', '));

    next();
  }

// eslint-disable-next-line no-param-reassign
                  currentPost.categoryInCommon =
                    currentPost.category_id === post.category_id;
                });

                const ranking = Object.keys(articles).filter(
                  currentSlug =>
                    articles[currentSlug].issue_id === latestIssueId &&
                    currentSlug !== post.slug,
                );
                if (ranking.length < 3) {
                  throw new Error(
                    'Less than three articles to qualify as related articles',
                  );
                }
                stable.inplace(ranking, (slugA, slugB) => {
                  const a = articles[slugA];
                  const b = articles[slugB];
                  if (a.tagsInCommon !== b.tagsInCommon) {
                    // This puts a before b if a has more tags in common
                    return b.tagsInCommon - a.tagsInCommon;
                  }
                  if (a.categoryInCommon !== b.categoryInCommon) {
                    if (a.categoryInCommon) {
                      return -1;
                    }
                    return 1;
                  }
                  return 0;
                });
                // since the sort is stable we know we should always get the
                // same values, also if there are no articles with related tags

export function mergeEvents(existing: Fflogs.Event[], incoming: Fflogs.Event[]) {
	// Create a new array with the incoming events at the end
	const events = existing.concat(incoming)

	// Sort them in place
	stable.inplace(events, (a, b) => {
		if (a.timestamp === b.timestamp) {
			const aTypeOrder = EVENT_TYPE_ORDER[a.type as string] || EVENT_TYPE_ORDER.default
			const bTypeOrder = EVENT_TYPE_ORDER[b.type as string] || EVENT_TYPE_ORDER.default
			return aTypeOrder - bTypeOrder
		}
		return a.timestamp - b.timestamp
	})

	return events
}

function sortMiddleware(instances) {
    // Find all phases
    const phases = instances.filter(function(m) {
      return m.isPhasePlaceHolder;
    });

    // Find regular middleware entries
    const middleware = instances.filter(function(m) {
      return !m.isPhasePlaceHolder;
    });

    // Sort the entries to keep the order
    stableSortInPlace(phases, compareByOrder);

    // Build a map for phase orders (phaseName --> phaseOrder)
    const phaseOrders = {};
    phases.forEach(function(p) {
      phaseOrders[p.phase] = p.order;
    });

    stableSortInPlace(middleware, function(m1, m2) {
      // First by phase
      let delta = phaseOrders[m1.phase] - phaseOrders[m2.phase];
      if (delta !== 0) return (delta > 0 ? 1 : -1);
      // by subPhase
      delta = compareBySubPhase(m1, m2);
      if (delta !== 0) return (delta > 0 ? 1 : -1);
      // By order
      return compareByOrder(m1, m2);

result.seenIps[ip] = true
      result.unique.push(cleanedService)

      return result
    },
    { unique: [], seenIps: {} }
  ).unique

  const dedupedWithoutIp = differenceBy(
    uniqBy(listWithoutIp, 'name'),
    sanitizedWithIp,
    'name'
  )

  // use a stable sort because core-js polyfills can mess with Array.sort order
  return stableSort(sanitizedWithIp.concat(dedupedWithoutIp), compareServices)
}