@fileverse-dev/fortune-react 1.0.35 → 1.0.37

package/es/hooks/useCryptoCells.js

@@ -0,0 +1,210 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { useEffect, useRef, useState } from "react";
+import { getCryptoPrice } from "../utils/cryptoApi";
+export function useCryptoCells() {
+  var _this = this;
+  var _a = useState([]),
+    cryptoCells = _a[0],
+    setCryptoCells = _a[1];
+  var timerRef = useRef(null);
+  var upsertCryptoCell = function upsertCryptoCell(cellId, baseValue, cryptoType, fiat) {
+    return __awaiter(_this, void 0, void 0, function () {
+      var price;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4, getCryptoPrice(cryptoType, fiat)];
+          case 1:
+            price = _a.sent();
+            setCryptoCells(function (prev) {
+              var idx = prev.findIndex(function (c) {
+                return c.cellId === cellId;
+              });
+              var newCell = {
+                cellId: cellId,
+                baseValue: baseValue,
+                cryptoType: cryptoType,
+                fiat: fiat,
+                value: baseValue / price
+              };
+              if (idx === -1) return __spreadArray(__spreadArray([], prev, true), [newCell], false);
+              var updated = __spreadArray([], prev, true);
+              updated[idx] = newCell;
+              return updated;
+            });
+            return [2];
+        }
+      });
+    });
+  };
+  useEffect(function () {
+    function refreshAll() {
+      return __awaiter(this, void 0, void 0, function () {
+        var _this = this;
+        return __generator(this, function (_a) {
+          setCryptoCells(function (prev) {
+            var updatePromises = prev.map(function (cell) {
+              return __awaiter(_this, void 0, void 0, function () {
+                var price;
+                return __generator(this, function (_a) {
+                  switch (_a.label) {
+                    case 0:
+                      return [4, getCryptoPrice(cell.cryptoType, cell.fiat)];
+                    case 1:
+                      price = _a.sent();
+                      return [2, __assign(__assign({}, cell), {
+                        value: cell.baseValue / price
+                      })];
+                  }
+                });
+              });
+            });
+            return Promise.all(updatePromises);
+          });
+          return [2];
+        });
+      });
+    }
+    timerRef.current = setInterval(refreshAll, 20 * 60 * 1000);
+    return function () {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+  }, []);
+  return {
+    cryptoCells: cryptoCells,
+    upsertCryptoCell: upsertCryptoCell
+  };
+}

package/es/utils/convertCellsToCrypto.d.ts

@@ -0,0 +1,8 @@
+export declare const getFiatSymbol: (code: string) => string;
+export declare function convertCellsToCrypto({ context, setContext, denomination, decimals, baseCurrency, }: {
+    context: any;
+    setContext: (fn: (ctx: any) => void) => void;
+    denomination: string;
+    decimals: number;
+    baseCurrency: string;
+}): Promise<void>;

package/es/utils/convertCellsToCrypto.js

@@ -0,0 +1,215 @@
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+import { getFlowdata } from "@fileverse-dev/fortune-core";
+import { getCryptoPrice } from "./cryptoApi";
+export var getFiatSymbol = function getFiatSymbol(code) {
+  switch (code) {
+    case "USD":
+      return "$";
+    case "EUR":
+      return "€";
+    case "GBP":
+      return "£";
+    case "JPY":
+      return "¥";
+    case "CNY":
+      return "¥";
+    case "INR":
+      return "₹";
+    default:
+      return code;
+  }
+};
+var COINGECKO_IDS = {
+  BTC: "bitcoin",
+  ETH: "ethereum",
+  SOL: "solana"
+};
+export function convertCellsToCrypto(_a) {
+  var context = _a.context,
+    setContext = _a.setContext,
+    denomination = _a.denomination,
+    decimals = _a.decimals,
+    baseCurrency = _a.baseCurrency;
+  return __awaiter(this, void 0, void 0, function () {
+    var selections, flowdata, selectedCells, denomStr, coingeckoId, price;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          selections = context.luckysheet_select_save;
+          flowdata = getFlowdata(context);
+          if (!selections || !flowdata) return [2];
+          selectedCells = [];
+          selections.forEach(function (selection) {
+            for (var row = selection.row[0]; row <= selection.row[1]; row += 1) {
+              for (var col = selection.column[0]; col <= selection.column[1]; col += 1) {
+                selectedCells.push({
+                  row: row,
+                  col: col
+                });
+              }
+            }
+          });
+          denomStr = typeof denomination === "string" && denomination.trim() !== "" ? denomination : "ETH";
+          denomStr = denomStr.toUpperCase();
+          coingeckoId = typeof COINGECKO_IDS[denomStr] === "string" ? COINGECKO_IDS[denomStr] : "ethereum";
+          return [4, getCryptoPrice(String(coingeckoId), baseCurrency.toLowerCase())];
+        case 1:
+          price = _b.sent();
+          selectedCells.forEach(function (_a) {
+            var _b, _c, _d;
+            var row = _a.row,
+              col = _a.col;
+            var cell = (_b = flowdata[row]) === null || _b === void 0 ? void 0 : _b[col];
+            var baseValue = 0;
+            if ((cell === null || cell === void 0 ? void 0 : cell.baseValue) !== undefined) {
+              baseValue = cell.baseValue;
+            } else {
+              if (typeof (cell === null || cell === void 0 ? void 0 : cell.v) === "number") {
+                baseValue = cell.v;
+              } else if (typeof (cell === null || cell === void 0 ? void 0 : cell.v) === "string") {
+                baseValue = parseFloat(cell.v);
+              }
+              if (((_c = cell === null || cell === void 0 ? void 0 : cell.ct) === null || _c === void 0 ? void 0 : _c.fa) && cell.ct.fa.includes('"')) {
+                var numericValue = parseFloat(((_d = cell.v) === null || _d === void 0 ? void 0 : _d.toString()) || "0");
+                if (!Number.isNaN(numericValue)) {
+                  baseValue = numericValue;
+                }
+              }
+            }
+            if (!baseValue || Number.isNaN(baseValue)) return;
+            var cryptoValue = baseValue / price;
+            setContext(function (ctx) {
+              var d = getFlowdata(ctx);
+              if (!d || !Array.isArray(d) || !d[row] || !d[row][col] || cryptoValue === null) return;
+              if (!d[row]) d[row] = [];
+              if (!d[row][col]) d[row][col] = {};
+              var cellCp = d[row][col];
+              cellCp.v = baseValue.toString();
+              cellCp.m = "".concat(cryptoValue.toFixed(decimals), " ").concat(denomStr);
+              cellCp.ct = {
+                fa: "0.".concat("0".repeat(decimals), " \"").concat(denomStr, "\""),
+                t: "n"
+              };
+              cellCp.baseValue = baseValue;
+              d[row][col] = cellCp;
+            });
+          });
+          return [2];
+      }
+    });
+  });
+}

package/es/utils/cryptoApi.d.ts

@@ -0,0 +1,2 @@
+export declare function getCryptoPrice(crypto: string, fiat: string): Promise<number>;
+export declare function clearCryptoPriceCache(): void;

package/es/utils/cryptoApi.js

@@ -0,0 +1,154 @@
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function sent() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var COINGECKO_API = "https://api.coingecko.com/api/v3/simple/price";
+var CACHE_DURATION = 60 * 1000;
+var priceCache = {};
+export function getCryptoPrice(crypto, fiat) {
+  var _a;
+  return __awaiter(this, void 0, void 0, function () {
+    var key, now, url, resp, data, price;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          key = "".concat(crypto, "-").concat(fiat).toLowerCase();
+          now = Date.now();
+          if (priceCache[key] && now - priceCache[key].timestamp < CACHE_DURATION) {
+            return [2, priceCache[key].price];
+          }
+          url = "".concat(COINGECKO_API, "?ids=").concat(crypto, "&vs_currencies=").concat(fiat);
+          return [4, fetch(url)];
+        case 1:
+          resp = _b.sent();
+          if (!resp.ok) throw new Error("Failed to fetch crypto price");
+          return [4, resp.json()];
+        case 2:
+          data = _b.sent();
+          price = (_a = data[crypto]) === null || _a === void 0 ? void 0 : _a[fiat];
+          if (typeof price !== "number") throw new Error("Invalid price data");
+          priceCache[key] = {
+            price: price,
+            timestamp: now
+          };
+          return [2, price];
+      }
+    });
+  });
+}
+export function clearCryptoPriceCache() {
+  Object.keys(priceCache).forEach(function (key) {
+    return delete priceCache[key];
+  });
+}

package/es/utils/updateCellsDecimalFormat.d.ts

@@ -0,0 +1,6 @@
+export declare function updateCellsDecimalFormat({ context, setContext, decimals, denomination, }: {
+    context: any;
+    setContext: (fn: (ctx: any) => void) => void;
+    decimals: number;
+    denomination?: string;
+}): void;

package/es/utils/updateCellsDecimalFormat.js

@@ -0,0 +1,80 @@
+import { getFlowdata } from "@fileverse-dev/fortune-core";
+import { FIAT_ICON_MAP } from "../constants";
+function getFiatSymbol(code) {
+  switch (code) {
+    case "USD":
+      return "$";
+    case "EUR":
+      return "€";
+    case "GBP":
+      return "£";
+    case "JPY":
+      return "¥";
+    case "CNY":
+      return "¥";
+    case "INR":
+      return "₹";
+    default:
+      return code;
+  }
+}
+export function updateCellsDecimalFormat(_a) {
+  var context = _a.context,
+    setContext = _a.setContext,
+    decimals = _a.decimals,
+    denomination = _a.denomination;
+  var selections = context.luckysheet_select_save;
+  var flowdata = getFlowdata(context);
+  if (!selections || !flowdata) return;
+  var selectedCells = [];
+  selections.forEach(function (selection) {
+    for (var row = selection.row[0]; row <= selection.row[1]; row += 1) {
+      for (var col = selection.column[0]; col <= selection.column[1]; col += 1) {
+        selectedCells.push({
+          row: row,
+          col: col
+        });
+      }
+    }
+  });
+  setContext(function (ctx) {
+    var d = getFlowdata(ctx);
+    if (!d) return;
+    selectedCells.forEach(function (_a) {
+      var _b;
+      var row = _a.row,
+        col = _a.col;
+      var cell = (_b = d[row]) === null || _b === void 0 ? void 0 : _b[col];
+      if (!cell) return;
+      var denomStr = "ETH";
+      var isCrypto = false;
+      if (cell.ct && typeof cell.ct.fa === "string") {
+        var _c = cell.ct.fa.match(/"([A-Z]+)"/) || [],
+          matchedDenom = _c[1];
+        if (matchedDenom) {
+          denomStr = matchedDenom;
+          isCrypto = true;
+        }
+      }
+      if (isCrypto) {
+        cell.ct = {
+          fa: "0.".concat("0".repeat(decimals), " \"").concat(denomStr, "\""),
+          t: "n"
+        };
+        if (typeof cell.v === "number") {
+          cell.m = "".concat(cell.v.toFixed(decimals), " ").concat(denomStr);
+        }
+      } else {
+        var fiat = denomination || "USD";
+        var symbol = fiat in FIAT_ICON_MAP ? getFiatSymbol(fiat) : fiat;
+        cell.ct = {
+          fa: "".concat(symbol, " #,##0.").concat("0".repeat(decimals)),
+          t: "n"
+        };
+        if (typeof cell.v === "number") {
+          cell.m = "".concat(symbol, " ").concat(cell.v.toFixed(decimals));
+        }
+      }
+    });
+  });
+}