@ledgerhq/live-common 25.0.0-next.0 → 25.0.0-next.3

package/src/platform/filters.ts

@@ -0,0 +1,102 @@
+import { makeRe } from "minimatch";
+import { PlatformAccount, PlatformCurrency, AppManifest } from "./types";
+import { isPlatformTokenCurrency } from "./helpers";
+import semver from "semver";
+
+export type FilterParams = {
+  branches?: string[];
+  platform?: string;
+  private?: boolean;
+  version?: string;
+};
+
+export type AccountFilters = {
+  currencies?: string[];
+};
+
+export function filterPlatformAccounts(
+  accounts: PlatformAccount[],
+  filters: AccountFilters
+): PlatformAccount[] {
+  const filterCurrencyRegexes = filters.currencies
+    ? filters.currencies.map((filter) => makeRe(filter))
+    : null;
+
+  return accounts.filter((account) => {
+    if (
+      filterCurrencyRegexes &&
+      !filterCurrencyRegexes.some((regex) => account.currency.match(regex))
+    ) {
+      return false;
+    }
+    return true;
+  });
+}
+
+export type CurrencyFilters = {
+  includeTokens?: boolean;
+  currencies?: string[];
+};
+
+export function filterPlatformCurrencies(
+  currencies: PlatformCurrency[],
+  filters: CurrencyFilters
+): PlatformCurrency[] {
+  const filterCurrencyRegexes = filters.currencies
+    ? filters.currencies.map((filter) => makeRe(filter))
+    : null;
+
+  return currencies.filter((currency) => {
+    if (!filters.includeTokens && isPlatformTokenCurrency(currency)) {
+      return false;
+    }
+
+    if (
+      filterCurrencyRegexes &&
+      !filterCurrencyRegexes.some((regex) => currency.id.match(regex))
+    ) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+function matchVersion(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.version ||
+    semver.satisfies(filterParams.version, manifest.apiVersion)
+  );
+}
+
+function matchBranches(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.branches || filterParams.branches.includes(manifest.branch)
+  );
+}
+
+function matchPlatform(filterParams: FilterParams, manifest: AppManifest) {
+  return (
+    !filterParams.platform ||
+    manifest.platform === "all" ||
+    filterParams.platform === manifest.platform
+  );
+}
+
+function matchPrivate(filterParams: FilterParams, manifest: AppManifest) {
+  return filterParams.private === true || !(manifest.private === true);
+}
+
+export function filterPlatformApps(
+  appManifests: AppManifest[],
+  filterParams: FilterParams
+): AppManifest[] {
+  return appManifests.filter((appManifest: AppManifest) => {
+    return (
+      matchBranches(filterParams, appManifest) &&
+      matchPlatform(filterParams, appManifest) &&
+      matchPrivate(filterParams, appManifest) &&
+      matchVersion(filterParams, appManifest)
+    );
+  });
+}

package/src/platform/helpers.ts

@@ -0,0 +1,33 @@
+import { isCryptoCurrency, isTokenCurrency } from "../currencies";
+import { Currency } from "../types";
+import {
+  PlatformCurrency,
+  PlatformSupportedCurrency,
+  PlatformERC20TokenCurrency,
+  PlatformCryptoCurrency,
+  PlatformCurrencyType,
+} from "./types";
+
+export function isPlatformSupportedCurrency(
+  currency: Currency
+): currency is PlatformSupportedCurrency {
+  return isCryptoCurrency(currency) || isTokenCurrency(currency);
+}
+
+export function isPlatformCryptoCurrency(
+  currency: PlatformCurrency
+): currency is PlatformCryptoCurrency {
+  return currency.type === PlatformCurrencyType.CryptoCurrency;
+}
+
+export function isPlatformTokenCurrency(
+  currency: PlatformCurrency
+): currency is PlatformERC20TokenCurrency {
+  return currency.type === PlatformCurrencyType.TokenCurrency;
+}
+
+export function isPlatformERC20TokenCurrency(
+  currency: PlatformCurrency
+): currency is PlatformERC20TokenCurrency {
+  return (currency as PlatformERC20TokenCurrency).standard === "ERC20";
+}

package/src/platform/logic.ts

@@ -1,23 +1,4 @@
-import semver from "semver";
-import type { AppManifest, AppPlatform, AppBranch } from "./types";
-import { getPlatformVersion } from "./version";
-
-export function translateContent(content: any, locale = "en") {
+export function translateContent(content: any, locale = "en"): string {
   if (!content || typeof content !== "object") return content;
   return content[locale] || content.en;
 }
-
-export function isSupported(manifest: AppManifest) {
-  return semver.satisfies(
-    semver.coerce(getPlatformVersion()) || "",
-    manifest.apiVersion
-  );
-}
-
-export function matchBranches(manifest: AppManifest, branches: AppBranch[]) {
-  return branches.indexOf(manifest.branch) > -1;
-}
-
-export function matchPlatform(manifest: AppManifest, platform: AppPlatform) {
-  return manifest.platform === "all" || manifest.platform === platform;
-}