@beppla/tapas-ui 1.0.70 → 1.0.72

package/module/Icons/fontLoader.js

@@ -1,204 +1,234 @@
-"use strict";
+import React from 'react';
+import { Platform } from 'react-native';
 
-var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function (resolve) {
-      resolve(value);
-    });
+/**
+ * 简化的字体加载器
+ * 负责在Web环境中加载字体文件
+ */
+class FontLoader {
+  fontsLoaded = false;
+  loading = false;
+  listeners = [];
+  constructor() {
+    this.init();
   }
-  return new (P || (P = Promise))(function (resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
+  static getInstance() {
+    if (!FontLoader.instance) {
+      FontLoader.instance = new FontLoader();
     }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
+    return FontLoader.instance;
+  }
+
+  /**
+   * 初始化字体加载器
+   */
+  async init() {
+    if (Platform.OS !== 'web') {
+      this.fontsLoaded = true;
+      this.notifyListeners();
+      return;
     }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    try {
+      await this.loadWebFont();
+    } catch (error) {
+      console.warn('字体加载失败，将使用备用图标:', error);
     }
-    step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-};
-var __generator = this && this.__generator || function (thisArg, body) {
-  var _ = {
-      label: 0,
-      sent: function () {
-        if (t[0] & 1) throw t[1];
-        return t[1];
-      },
-      trys: [],
-      ops: []
-    },
-    f,
-    y,
-    t,
-    g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-  return g.next = verb(0), g["throw"] = verb(1), g["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);
+
+  /**
+   * 在Web环境中加载字体
+   */
+  async loadWebFont() {
+    // 检查 Web 环境是否可用
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+      console.warn('Web环境不可用，跳过字体加载');
+      this.fontsLoaded = true;
+      this.notifyListeners();
+      return;
+    }
+    const doc = document;
+
+    // 检查字体是否已经加载
+    if (doc.fonts && doc.fonts.check('1em icomoon')) {
+      this.fontsLoaded = true;
+      this.notifyListeners();
+      return;
+    }
+    this.loading = true;
+    try {
+      // 检查FontFace API是否可用
+      if (typeof FontFace !== 'undefined') {
+        // 尝试多个字体路径
+        const fontPaths = ['/assets/fonts/customfont.ttf', './assets/fonts/customfont.ttf', '../assets/fonts/customfont.ttf', '/customfont.ttf'];
+        let fontLoaded = false;
+        for (const path of fontPaths) {
+          try {
+            const font = new FontFace('icomoon', `url(${path})`);
+            await font.load();
+            doc.fonts.add(font);
+            fontLoaded = true;
+            console.log(`字体加载成功: ${path}`);
             break;
+          } catch (error) {
+            console.warn(`字体路径加载失败: ${path}`, error);
+            continue;
           }
-          if (t[2]) _.ops.pop();
-          _.trys.pop();
-          continue;
+        }
+        if (fontLoaded) {
+          // 等待字体完全加载
+          await this.waitForFontLoad(doc);
+          this.fontsLoaded = true;
+          this.notifyListeners();
+        } else {
+          throw new Error('所有字体路径都加载失败');
+        }
+      } else {
+        // FontFace API 不可用，使用 CSS @font-face 方式
+        console.warn('FontFace API不可用，使用CSS方式加载字体');
+        this.loadFontWithCSS(doc);
       }
-      op = body.call(thisArg, _);
-    } catch (e) {
-      op = [6, e];
-      y = 0;
+    } catch (error) {
+      console.warn('字体加载失败，将使用备用图标:', error);
+      this.fontsLoaded = true;
+      this.notifyListeners();
     } finally {
-      f = t = 0;
+      this.loading = false;
     }
-    if (op[0] & 5) throw op[1];
-    return {
-      value: op[0] ? op[1] : void 0,
-      done: true
-    };
   }
-};
-var __importDefault = this && this.__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : {
-    "default": mod
-  };
-};
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.fontLoader = void 0;
-exports.useFontLoader = useFontLoader;
-var react_1 = __importDefault(require("react"));
-var react_native_1 = require("react-native");
-/**
- * 简化的字体加载器
- * 负责在Web环境中加载字体文件
- */
-var FontLoader = /** @class */function () {
-  function FontLoader() {
-    this.fontsLoaded = false;
-    this.loading = false;
-    this.listeners = [];
-    this.init();
+
+  /**
+   * 使用 CSS @font-face 加载字体
+   */
+  loadFontWithCSS(doc) {
+    try {
+      const style = doc.createElement('style');
+      style.textContent = `
+        @font-face {
+          font-family: 'icomoon';
+          src: url('/assets/fonts/customfont.ttf') format('truetype');
+          font-weight: normal;
+          font-style: normal;
+          font-display: swap;
+        }
+      `;
+      doc.head.appendChild(style);
+
+      // 监听字体加载完成
+      if (doc.fonts && doc.fonts.ready) {
+        doc.fonts.ready.then(() => {
+          this.fontsLoaded = true;
+          this.notifyListeners();
+          console.log('字体加载成功 (CSS方式)');
+        }).catch(error => {
+          console.warn('CSS字体加载失败，将使用备用图标:', error);
+          this.fontsLoaded = true;
+          this.notifyListeners();
+        });
+      } else {
+        // 降级处理
+        setTimeout(() => {
+          this.fontsLoaded = true;
+          this.notifyListeners();
+        }, 1000);
+      }
+    } catch (error) {
+      console.warn('CSS字体加载过程中出错，将使用备用图标:', error);
+      this.fontsLoaded = true;
+      this.notifyListeners();
+    }
   }
-  FontLoader.getInstance = function () {
-    if (!FontLoader.instance) {
-      FontLoader.instance = new FontLoader();
+
+  /**
+   * 等待字体完全加载
+   */
+  async waitForFontLoad(doc) {
+    if (!doc.fonts || !doc.fonts.ready) {
+      return;
     }
-    return FontLoader.instance;
-  };
+    try {
+      await doc.fonts.ready;
+    } catch (error) {
+      console.warn('等待字体加载时出错:', error);
+    }
+  }
+
   /**
-   * 初始化字体加载器
+   * 添加字体加载状态监听器
    */
-  FontLoader.prototype.init = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var error_1;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            if (react_native_1.Platform.OS !== 'web') {
-              this.fontsLoaded = true;
-              this.notifyListeners();
-              return [2 /*return*/];
-            }
-            _a.label = 1;
-          case 1:
-            _a.trys.push([1, 3,, 4]);
-            return [4 /*yield*/, this.loadWebFont()];
-          case 2:
-            _a.sent();
-            return [3 /*break*/, 4];
-          case 3:
-            error_1 = _a.sent();
-            console.warn('字体加载失败，将使用备用图标:', error_1);
-            return [3 /*break*/, 4];
-          case 4:
-            return [2 /*return*/];
-        }
-      });
+  addListener(listener) {
+    this.listeners.push(listener);
+
+    // 如果字体已经加载，立即通知
+    if (this.fontsLoaded) {
+      listener();
+    }
+
+    // 返回取消监听的函数
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * 通知所有监听器
+   */
+  notifyListeners() {
+    this.listeners.forEach(listener => {
+      try {
+        listener();
+      } catch (error) {
+        console.warn('字体加载监听器执行失败:', error);
+      }
     });
-  };
+  }
+
   /**
-   * 在Web环境中加载字体
+   * 检查字体是否已加载
    */
-  FontLoader.prototype.loadWebFont = function () {
-    return __awaiter(this, void 0, void 0, function () {
-      var doc, fontPaths, fontLoaded, _i, fontPaths_1, path, font, error_2, error_3;
-      return __generator(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            // 检查 Web 环境是否可用
-            if (typeof window === 'undefined' || typeof document === 'undefined') {
-              console.warn('Web环境不可用，跳过字体加载');
-              this.fontsLoaded = true;
-              this.notifyListeners();
-              return [2 /*return*/];
-            }
-            doc = document;
-            // 检查字体是否已经加载
-            if (doc.fonts && doc.fonts.check('1em icomoon')) {
-              this.fontsLoaded = true;
-              this.notifyListeners();
-              return [2 /*return*/];
-            }
-            this.loading = true;
-            _a.label = 1;
-          case 1:
-            _a.trys.push([1, 13, 14, 15]);
-            if (!(typeof FontFace !== 'undefined')) return [3 /*break*/, 11];
+  isFontLoaded() {
+    return this.fontsLoaded;
+  }
+
+  /**
+   * 检查是否正在加载
+   */
+  isLoading() {
+    return this.loading;
+  }
+
+  /**
+   * 强制重新加载字体
+   */
+  async reload() {
+    this.fontsLoaded = false;
+    this.loading = false;
+    this.listeners = [];
+    await this.init();
+  }
+}
+
+// 导出单例实例
+export const fontLoader = FontLoader.getInstance();
+
+// 导出Hook
+export function useFontLoader() {
+  const [fontsLoaded, setFontsLoaded] = React.useState(fontLoader.isFontLoaded());
+  const [loading, setLoading] = React.useState(fontLoader.isLoading());
+  React.useEffect(() => {
+    const unsubscribe = fontLoader.addListener(() => {
+      setFontsLoaded(true);
+      setLoading(false);
+    });
+    return unsubscribe;
+  }, []);
+  return {
+    fontsLoaded,
+    loading
+  };
+}
             fontPaths = ['/assets/fonts/customfont.ttf', './assets/fonts/customfont.ttf', '../assets/fonts/customfont.ttf', '/customfont.ttf'];
             fontLoaded = false;
             _i = 0, fontPaths_1 = fontPaths;
@@ -407,4 +437,3 @@ function useFontLoader() {
     loading: loading
   };
 }
-//# sourceMappingURL=fontLoader.js.map

package/module/Icons/index.js

@@ -1,14 +1,12 @@
-"use strict";
+// 导出图标组件
+export { default as TapasIcon } from './TapasIcon';
+export { default as TapasIconExpo } from './TapasIconExpo';
+// 导出字体加载器
+export { fontLoader, useFontLoader } from './fontLoader';
+export { expoFontLoader, useExpoFontLoader } from './expoFontLoader';
+export { smartFontLoader, useSmartFontLoader } from './smartFontLoader';
 
-var __importDefault = this && this.__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : {
-    "default": mod
-  };
-};
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useSmartFontLoader = exports.smartFontLoader = exports.useExpoFontLoader = exports.expoFontLoader = exports.useFontLoader = exports.fontLoader = exports.TapasIconExpo = exports.TapasIcon = void 0;
+// 重新导出类型
 // 导出图标组件
 var TapasIcon_1 = require("./TapasIcon");
 Object.defineProperty(exports, "TapasIcon", {
@@ -64,4 +62,3 @@ Object.defineProperty(exports, "useSmartFontLoader", {
     return smartFontLoader_1.useSmartFontLoader;
   }
 });
-//# sourceMappingURL=index.js.map

package/module/Icons/smartFontLoader.js

@@ -498,4 +498,3 @@ function useSmartFontLoader() {
     loading: loading
   };
 }
-//# sourceMappingURL=smartFontLoader.js.map

package/module/Image/Image.js

@@ -121,7 +121,6 @@ const useStyles = makeStyles(theme => ({
   }
 }));
 export default withTheme(TapasImage);
-//# sourceMappingURL=Image.js.mapdingVal, opacity]);
   var handleLoad = (0, react_1.useCallback)(function () {
     if (uri) {
       setLoadingVal(true);
@@ -214,4 +213,3 @@ var useStyles = (0, themed_1.makeStyles)(function (theme) {
   };
 });
 exports.default = (0, themed_1.withTheme)(TapasImage);
-//# sourceMappingURL=Image.js.map

package/module/Image/PreviewImg.js

@@ -170,4 +170,3 @@ var PreviewImg = function (_a) {
   }), data.length > 1 ? getIcon('chevron_right', currentIndex === data.length - 1) : null));
 };
 exports.default = (0, themed_1.withTheme)(PreviewImg);
-//# sourceMappingURL=PreviewImg.js.map

package/module/Input/Input.js

@@ -95,7 +95,6 @@ export const TapasInput = ({
   })));
 };
 export default withTheme(TapasInput);
-//# sourceMappingURL=Input.js.mapolorTextPrimary,
       overflow: "hidden",
       position: "absolute",
       display: "flex",
@@ -169,4 +168,3 @@ var TapasInput = function (_a) {
 };
 exports.TapasInput = TapasInput;
 exports.default = (0, themed_1.withTheme)(exports.TapasInput);
-//# sourceMappingURL=Input.js.map

package/module/Layout/DrawerContext.js

@@ -28,7 +28,6 @@ export const DrawerProvider = ({
     }
   }, children);
 };
-//# sourceMappingURL=DrawerContext.js.mapturn m[k];
       }
     };
   }
@@ -97,4 +96,3 @@ var DrawerProvider = function (_a) {
   }, children);
 };
 exports.DrawerProvider = DrawerProvider;
-//# sourceMappingURL=DrawerContext.js.map