@pancakeswap/token-lists 0.0.2

package/dist/react.mjs

@@ -0,0 +1,249 @@
+import {
+  getVersionUpgrade
+} from "./chunk-YBVZDUCZ.mjs";
+
+// react/reducer.ts
+import { createReducer } from "@reduxjs/toolkit";
+
+// react/actions.ts
+import { createAction } from "@reduxjs/toolkit";
+var fetchTokenList = {
+  pending: createAction("lists/fetchTokenList/pending"),
+  fulfilled: createAction("lists/fetchTokenList/fulfilled"),
+  rejected: createAction("lists/fetchTokenList/rejected")
+};
+var addList = createAction("lists/addList");
+var removeList = createAction("lists/removeList");
+var enableList = createAction("lists/enableList");
+var disableList = createAction("lists/disableList");
+var acceptListUpdate = createAction("lists/acceptListUpdate");
+var rejectVersionUpdate = createAction("lists/rejectVersionUpdate");
+var updateListVersion = createAction("lists/updateListVersion");
+
+// react/reducer.ts
+var NEW_LIST_STATE = {
+  error: null,
+  current: null,
+  loadingRequestId: null,
+  pendingUpdate: null
+};
+var createTokenListReducer = (initialState, DEFAULT_LIST_OF_LISTS, DEFAULT_ACTIVE_LIST_URLS) => createReducer(
+  initialState,
+  (builder) => builder.addCase(fetchTokenList.pending, (state, { payload: { requestId, url } }) => {
+    var _a, _b;
+    const current = ((_a = state.byUrl[url]) == null ? void 0 : _a.current) ?? null;
+    const pendingUpdate = ((_b = state.byUrl[url]) == null ? void 0 : _b.pendingUpdate) ?? null;
+    state.byUrl[url] = {
+      current,
+      pendingUpdate,
+      loadingRequestId: requestId,
+      error: null
+    };
+  }).addCase(fetchTokenList.fulfilled, (state, { payload: { requestId, tokenList, url } }) => {
+    var _a, _b, _c;
+    const current = (_a = state.byUrl[url]) == null ? void 0 : _a.current;
+    const loadingRequestId = (_b = state.byUrl[url]) == null ? void 0 : _b.loadingRequestId;
+    if (current) {
+      const upgradeType = getVersionUpgrade(current.version, tokenList.version);
+      if (upgradeType === 0 /* NONE */)
+        return;
+      if (loadingRequestId === null || loadingRequestId === requestId) {
+        state.byUrl[url] = {
+          ...state.byUrl[url],
+          loadingRequestId: null,
+          error: null,
+          current,
+          pendingUpdate: tokenList
+        };
+      }
+    } else {
+      if (DEFAULT_ACTIVE_LIST_URLS.includes(url)) {
+        (_c = state.activeListUrls) == null ? void 0 : _c.push(url);
+      }
+      state.byUrl[url] = {
+        ...state.byUrl[url],
+        loadingRequestId: null,
+        error: null,
+        current: tokenList,
+        pendingUpdate: null
+      };
+    }
+  }).addCase(fetchTokenList.rejected, (state, { payload: { url, requestId, errorMessage } }) => {
+    var _a;
+    if (((_a = state.byUrl[url]) == null ? void 0 : _a.loadingRequestId) !== requestId) {
+      return;
+    }
+    state.byUrl[url] = {
+      ...state.byUrl[url],
+      loadingRequestId: null,
+      error: errorMessage,
+      current: null,
+      pendingUpdate: null
+    };
+  }).addCase(addList, (state, { payload: url }) => {
+    if (!state.byUrl[url]) {
+      state.byUrl[url] = NEW_LIST_STATE;
+    }
+  }).addCase(removeList, (state, { payload: url }) => {
+    if (state.byUrl[url]) {
+      delete state.byUrl[url];
+    }
+    if (state.activeListUrls && state.activeListUrls.includes(url)) {
+      state.activeListUrls = state.activeListUrls.filter((u) => u !== url);
+    }
+  }).addCase(enableList, (state, { payload: url }) => {
+    if (!state.byUrl[url]) {
+      state.byUrl[url] = NEW_LIST_STATE;
+    }
+    if (state.activeListUrls && !state.activeListUrls.includes(url)) {
+      state.activeListUrls.push(url);
+    }
+    if (!state.activeListUrls) {
+      state.activeListUrls = [url];
+    }
+  }).addCase(disableList, (state, { payload: url }) => {
+    if (state.activeListUrls && state.activeListUrls.includes(url)) {
+      state.activeListUrls = state.activeListUrls.filter((u) => u !== url);
+    }
+  }).addCase(acceptListUpdate, (state, { payload: url }) => {
+    var _a;
+    if (!((_a = state.byUrl[url]) == null ? void 0 : _a.pendingUpdate)) {
+      throw new Error("accept list update called without pending update");
+    }
+    state.byUrl[url] = {
+      ...state.byUrl[url],
+      pendingUpdate: null,
+      current: state.byUrl[url].pendingUpdate
+    };
+  }).addCase(updateListVersion, (state) => {
+    if (!state.lastInitializedDefaultListOfLists) {
+      state.byUrl = initialState.byUrl;
+      state.activeListUrls = initialState.activeListUrls;
+    } else if (state.lastInitializedDefaultListOfLists) {
+      const lastInitializedSet = state.lastInitializedDefaultListOfLists.reduce(
+        (s, l) => s.add(l),
+        /* @__PURE__ */ new Set()
+      );
+      const newListOfListsSet = DEFAULT_LIST_OF_LISTS.reduce((s, l) => s.add(l), /* @__PURE__ */ new Set());
+      DEFAULT_LIST_OF_LISTS.forEach((listUrl) => {
+        if (!lastInitializedSet.has(listUrl)) {
+          state.byUrl[listUrl] = NEW_LIST_STATE;
+        }
+      });
+      state.lastInitializedDefaultListOfLists.forEach((listUrl) => {
+        if (!newListOfListsSet.has(listUrl)) {
+          delete state.byUrl[listUrl];
+        }
+      });
+    }
+    state.lastInitializedDefaultListOfLists = DEFAULT_LIST_OF_LISTS;
+    if (!state.activeListUrls) {
+      state.activeListUrls = DEFAULT_ACTIVE_LIST_URLS;
+      DEFAULT_ACTIVE_LIST_URLS.forEach((listUrl) => {
+        if (!state.byUrl[listUrl]) {
+          state.byUrl[listUrl] = NEW_LIST_STATE;
+        }
+        return true;
+      });
+    }
+  })
+);
+
+// react/lists.ts
+import { atomWithStorage, useReducerAtom } from "jotai/utils";
+import localForage from "localforage";
+function noop() {
+}
+var noopStorage = {
+  getItem: noop,
+  setItem: noop,
+  removeItem: noop,
+  keys: [],
+  getAllKeys: noop
+};
+var createListsAtom = (storeName, reducer, initialState) => {
+  let gotOnce = false;
+  function IndexedDBStorage(dbName) {
+    if (typeof window !== "undefined") {
+      const db = localForage.createInstance({
+        name: dbName,
+        storeName
+      });
+      return {
+        db,
+        getItem: async (key) => {
+          const value = await db.getItem(key);
+          gotOnce = true;
+          if (value) {
+            return value;
+          }
+          return initialState;
+        },
+        setItem: (k, v) => {
+          if (gotOnce) {
+            return db.setItem(k, v);
+          }
+          return void 0;
+        },
+        removeItem: db.removeItem,
+        delayInit: true
+      };
+    }
+    return noopStorage;
+  }
+  const listsAtom = atomWithStorage(
+    "lists",
+    initialState,
+    IndexedDBStorage("lists")
+  );
+  function useListState() {
+    return useReducerAtom(listsAtom, reducer);
+  }
+  return {
+    listsAtom,
+    useListState
+  };
+};
+
+// react/useFetchListCallback.ts
+import { nanoid } from "@reduxjs/toolkit";
+import { useCallback } from "react";
+function useFetchListCallback(dispatch) {
+  return useCallback(
+    async (listUrl, sendDispatch = true) => {
+      const requestId = nanoid();
+      if (sendDispatch) {
+        dispatch(fetchTokenList.pending({ requestId, url: listUrl }));
+      }
+      const getTokenList = (await import("./getTokenList-T45DK2AY.mjs")).default;
+      return getTokenList(listUrl).then((tokenList) => {
+        if (sendDispatch) {
+          dispatch(fetchTokenList.fulfilled({ url: listUrl, tokenList, requestId }));
+        }
+        return tokenList;
+      }).catch((error) => {
+        console.error(`Failed to get list at url ${listUrl}`, error);
+        if (sendDispatch) {
+          dispatch(fetchTokenList.rejected({ url: listUrl, requestId, errorMessage: error.message }));
+        }
+        throw error;
+      });
+    },
+    [dispatch]
+  );
+}
+var useFetchListCallback_default = useFetchListCallback;
+export {
+  NEW_LIST_STATE,
+  acceptListUpdate,
+  addList,
+  createListsAtom,
+  createTokenListReducer,
+  disableList,
+  enableList,
+  fetchTokenList,
+  rejectVersionUpdate,
+  removeList,
+  updateListVersion,
+  useFetchListCallback_default as useFetchListCallback
+};

package/dist/types-b620c9be.d.ts

@@ -0,0 +1,39 @@
+declare type ExtensionValue = string | number | boolean | null | undefined;
+interface TokenInfo {
+    readonly chainId: number;
+    readonly address: string;
+    readonly name: string;
+    readonly decimals: number;
+    readonly symbol: string;
+    readonly logoURI?: string;
+    readonly tags?: string[];
+    readonly extensions?: {
+        readonly [key: string]: {
+            [key: string]: {
+                [key: string]: ExtensionValue;
+            } | ExtensionValue;
+        } | ExtensionValue;
+    };
+}
+interface Version {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+}
+interface Tags {
+    readonly [tagId: string]: {
+        readonly name: string;
+        readonly description: string;
+    };
+}
+interface TokenList {
+    readonly name: string;
+    readonly timestamp: string;
+    readonly version: Version;
+    readonly tokens: TokenInfo[];
+    readonly keywords?: string[];
+    readonly tags?: Tags;
+    readonly logoURI?: string;
+}
+
+export { TokenInfo as T, Version as V, TokenList as a, Tags as b };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@pancakeswap/token-lists",
+  "version": "0.0.2",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest --run",
+    "prepublishOnly": "yarn run build",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "ajv": "^6.12.3",
+    "@pancakeswap/swap-sdk-core": "*"
+  },
+  "peerDependencies": {
+    "@reduxjs/toolkit": "^1.8.6",
+    "localforage": "^1.10.0",
+    "jotai": "^1.8.6",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@reduxjs/toolkit": "^1.8.6",
+    "react": "^18.2.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.js"
+    }
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "@reduxjs/toolkit": {
+      "optional": true
+    },
+    "localforage": {
+      "optional": true
+    },
+    "jotai": {
+      "optional": true
+    }
+  }
+}

package/react/actions.ts

@@ -0,0 +1,25 @@
+import { ActionCreatorWithPayload, createAction } from '@reduxjs/toolkit'
+import { TokenList, Version } from '../src/types'
+
+export const fetchTokenList: Readonly<{
+  pending: ActionCreatorWithPayload<{ url: string; requestId: string }>
+  fulfilled: ActionCreatorWithPayload<{ url: string; tokenList: TokenList; requestId: string }>
+  rejected: ActionCreatorWithPayload<{ url: string; errorMessage: string; requestId: string }>
+}> = {
+  pending: createAction('lists/fetchTokenList/pending'),
+  fulfilled: createAction('lists/fetchTokenList/fulfilled'),
+  rejected: createAction('lists/fetchTokenList/rejected'),
+}
+// add and remove from list options
+export const addList = createAction<string>('lists/addList')
+export const removeList = createAction<string>('lists/removeList')
+
+// select which lists to search across from loaded lists
+export const enableList = createAction<string>('lists/enableList')
+export const disableList = createAction<string>('lists/disableList')
+
+// versioning
+export const acceptListUpdate = createAction<string>('lists/acceptListUpdate')
+export const rejectVersionUpdate = createAction<Version>('lists/rejectVersionUpdate')
+
+export const updateListVersion = createAction('lists/updateListVersion')

package/react/getTokenList.ts

@@ -0,0 +1,46 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+import { TokenList } from '@pancakeswap/token-lists'
+import uriToHttp from '@pancakeswap/utils/uriToHttp'
+import Ajv from 'ajv'
+import schema from '../schema/pancakeswap.json'
+
+export const tokenListValidator = new Ajv({ allErrors: true }).compile(schema)
+
+/**
+ * Contains the logic for resolving a list URL to a validated token list
+ * @param listUrl list url
+ */
+export default async function getTokenList(listUrl: string): Promise<TokenList> {
+  const urls: string[] = uriToHttp(listUrl)
+
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i]
+    const isLast = i === urls.length - 1
+    let response
+    try {
+      response = await fetch(url)
+    } catch (error) {
+      console.error('Failed to fetch list', listUrl, error)
+      if (isLast) throw new Error(`Failed to download list ${listUrl}`)
+      continue
+    }
+
+    if (!response.ok) {
+      if (isLast) throw new Error(`Failed to download list ${listUrl}`)
+      continue
+    }
+
+    const json = await response.json()
+    if (!tokenListValidator(json)) {
+      const validationErrors: string =
+        tokenListValidator.errors?.reduce<string>((memo, error) => {
+          const add = `${(error as any).dataPath} ${error.message ?? ''}`
+          return memo.length > 0 ? `${memo}; ${add}` : `${add}`
+        }, '') ?? 'unknown error'
+      throw new Error(`Token list failed validation: ${validationErrors}`)
+    }
+    return json as TokenList
+  }
+  throw new Error('Unrecognized list URL protocol.')
+}

package/react/index.ts

@@ -0,0 +1,4 @@
+export * from './reducer'
+export * from './actions'
+export * from './lists'
+export { default as useFetchListCallback } from './useFetchListCallback'

package/react/lists.ts

@@ -0,0 +1,65 @@
+import { atomWithStorage, useReducerAtom } from 'jotai/utils'
+import localForage from 'localforage'
+import { ListsState } from './reducer'
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() {}
+const noopStorage = {
+  getItem: noop,
+  setItem: noop,
+  removeItem: noop,
+  keys: [],
+  getAllKeys: noop,
+}
+
+export const createListsAtom = (storeName: string, reducer: any, initialState: any) => {
+  let gotOnce = false
+  /**
+   * Persist you redux state using IndexedDB
+   * @param {string} dbName - IndexedDB database name
+   */
+  function IndexedDBStorage(dbName: string) {
+    if (typeof window !== 'undefined') {
+      const db = localForage.createInstance({
+        name: dbName,
+        storeName,
+      })
+      return {
+        db,
+        getItem: async (key: string) => {
+          const value = await db.getItem(key)
+          gotOnce = true
+          if (value) {
+            return value
+          }
+          return initialState
+        },
+        setItem: (k: string, v: any) => {
+          if (gotOnce) {
+            return db.setItem(k, v)
+          }
+          return undefined
+        },
+        removeItem: db.removeItem,
+        delayInit: true,
+      }
+    }
+    return noopStorage
+  }
+
+  const listsAtom = atomWithStorage<ListsState>(
+    'lists',
+    initialState,
+    // @ts-ignore
+    IndexedDBStorage('lists'),
+  )
+
+  function useListState() {
+    return useReducerAtom(listsAtom, reducer)
+  }
+
+  return {
+    listsAtom,
+    useListState,
+  }
+}

package/react/package.json

@@ -0,0 +1,5 @@
+{
+  "main": "../dist/react.js",
+  "module": "../dist/react.mjs",
+  "types": "../dist/react.d.ts"
+}