three-base 1.0.80 → 1.0.82

package/lib/Text3D/fontController.js

@@ -4,197 +4,332 @@
  * @Last Modified by: xiaosihan
  * @Last Modified time: 2022-06-08 14:33:45
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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() { 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 Dexie from "dexie";
 import { filter, first, isEmpty } from "lodash";
 import { Font } from "three/examples/jsm/loaders/FontLoader.js";
 import threeUtils from "../threeUtils";
 import gentilisJSON from "./gentilis.json";
-class indexBD extends Dexie {
-    constructor(dbName) {
-        super(dbName);
+var indexBD = /** @class */ (function (_super) {
+    __extends(indexBD, _super);
+    function indexBD(dbName) {
+        return _super.call(this, dbName) || this;
     }
-    threeFont;
-}
+    return indexBD;
+}(Dexie));
 // 字体加载器
-class fontContorl {
-    constructor() { }
-    THREEFontMap = new Map();
-    // 专门存储字体的数据库
-    fontBD = (() => {
-        let fontDB = new indexBD("three-base-font");
-        fontDB.version(1).stores({ threeFont: "++KeyPath,fontType,fontName,fontJson" });
-        return fontDB;
-    })();
+var fontContorl = /** @class */ (function () {
+    function fontContorl() {
+        this.THREEFontMap = new Map();
+        // 专门存储字体的数据库
+        this.fontBD = (function () {
+            var fontDB = new indexBD("three-base-font");
+            fontDB.version(1).stores({ threeFont: "++KeyPath,fontType,fontName,fontJson" });
+            return fontDB;
+        })();
+        // 加载字体的回调函数们
+        this._loadTextCall = new Map();
+    }
     /**
      * 保存 字体json到本地数据库中
      * @param {saveFontParam} { fontType = "simhei", fontName, fontJson }
      * @memberof fontContorl
      */
-    async saveFont({ fontType = "simhei", fontName, fontJson = "" }) {
-        let findResult = await this.getFont({ fontType, fontName });
-        if (isEmpty(findResult)) {
-            await this.fontBD.threeFont.add({ fontType, fontName, fontJson });
-        }
-    }
+    fontContorl.prototype.saveFont = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontName = _a.fontName, _c = _a.fontJson, fontJson = _c === void 0 ? "" : _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var findResult;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.getFont({ fontType: fontType, fontName: fontName })];
+                    case 1:
+                        findResult = _d.sent();
+                        if (!isEmpty(findResult)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.fontBD.threeFont.add({ fontType: fontType, fontName: fontName, fontJson: fontJson })];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * 通过 fontType 和 fontName 查询 fontJson
      * @param {getFontParam} { fontType = "simhei", fontName }
      * @returns
      * @memberof fontContorl
      */
-    async getFont({ fontType = "simhei", fontName }) {
-        let fondResult = await this.fontBD.threeFont
-            .filter(d => (d.fontType === fontType && d.fontName === fontName))
-            .toArray();
-        if (isEmpty(fondResult)) {
-            return undefined;
-        }
-        else {
-            return first(fondResult).fontJson;
-        }
-    }
-    // 加载字体的回调函数们
-    _loadTextCall = new Map();
+    fontContorl.prototype.getFont = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontName = _a.fontName;
+        return __awaiter(this, void 0, void 0, function () {
+            var fondResult;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.fontBD.threeFont
+                            .filter(function (d) { return (d.fontType === fontType && d.fontName === fontName); })
+                            .toArray()];
+                    case 1:
+                        fondResult = _c.sent();
+                        if (isEmpty(fondResult)) {
+                            return [2 /*return*/, undefined];
+                        }
+                        else {
+                            return [2 /*return*/, first(fondResult).fontJson];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     // 加载文字 提供给需要创建字体模型的方法使用 以节流的形式调用 回调函数
-    async loadText({ fontType = "simhei", text = "", fontBasePath, callback }) {
-        // 加载字体容器
-        await this._loadFontIndexJson({ fontType, fontBasePath });
-        let newCallback = () => {
-            let fontFamily = this.THREEFontMap.get(fontType);
-            if (callback && fontFamily) {
-                callback(fontFamily);
-            }
-        };
-        // 遍历文本
-        filter(text).map(fontName => {
-            // 没有的就去加载
-            if (!this.hasFont({ fontType, fontName })) {
-                // 添加文字的默认模型 避免报错
-                let fontFamily = this.THREEFontMap.get(fontType);
-                // 创建 three 字体对象
-                if (fontFamily) {
-                    //@ts-ignore
-                    fontFamily.data.glyphs[fontName] = { "ha": 1389, "x_min": 477, "x_max": 949, "o": "m 700 901 q 906 770 830 906 q 770 477 949 618 q 711 288 711 412 l 613 288 q 781 608 613 494 q 819 722 825 651 q 700 808 808 803 l 684 808 q 581 673 575 803 l 477 673 q 613 884 477 836 q 700 901 629 901 m 732 184 l 732 71 l 591 71 l 591 184 l 732 184 z " };
+    fontContorl.prototype.loadText = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, _c = _a.text, text = _c === void 0 ? "" : _c, fontBasePath = _a.fontBasePath, callback = _a.callback;
+        return __awaiter(this, void 0, void 0, function () {
+            var newCallback;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: 
+                    // 加载字体容器
+                    return [4 /*yield*/, this._loadFontIndexJson({ fontType: fontType, fontBasePath: fontBasePath })];
+                    case 1:
+                        // 加载字体容器
+                        _d.sent();
+                        newCallback = function () {
+                            var fontFamily = _this.THREEFontMap.get(fontType);
+                            if (callback && fontFamily) {
+                                callback(fontFamily);
+                            }
+                        };
+                        // 遍历文本
+                        filter(text).map(function (fontName) {
+                            // 没有的就去加载
+                            if (!_this.hasFont({ fontType: fontType, fontName: fontName })) {
+                                // 添加文字的默认模型 避免报错
+                                var fontFamily = _this.THREEFontMap.get(fontType);
+                                // 创建 three 字体对象
+                                if (fontFamily) {
+                                    //@ts-ignore
+                                    fontFamily.data.glyphs[fontName] = { "ha": 1389, "x_min": 477, "x_max": 949, "o": "m 700 901 q 906 770 830 906 q 770 477 949 618 q 711 288 711 412 l 613 288 q 781 608 613 494 q 819 722 825 651 q 700 808 808 803 l 684 808 q 581 673 575 803 l 477 673 q 613 884 477 836 q 700 901 629 901 m 732 184 l 732 71 l 591 71 l 591 184 l 732 184 z " };
+                                }
+                                _this._loadFontJson({ fontType: fontType, fontName: fontName, fontBasePath: fontBasePath });
+                            }
+                            // 加入待执行的回调
+                            var origin_callbacks = _this._loadTextCall.get("".concat(fontType, "_").concat(fontName)) || [];
+                            if (newCallback) {
+                                _this._loadTextCall.set("".concat(fontType, "_").concat(fontName), __spreadArray(__spreadArray([], origin_callbacks, true), [newCallback], false));
+                            }
+                        });
+                        // 执行任务队列
+                        threeUtils.addWork(newCallback);
+                        return [2 /*return*/];
                 }
-                this._loadFontJson({ fontType, fontName, fontBasePath });
-            }
-            // 加入待执行的回调
-            let origin_callbacks = this._loadTextCall.get(`${fontType}_${fontName}`) || [];
-            if (newCallback) {
-                this._loadTextCall.set(`${fontType}_${fontName}`, [...origin_callbacks, newCallback]);
-            }
+            });
         });
-        // 执行任务队列
-        threeUtils.addWork(newCallback);
-    }
+    };
     // 加载字体
-    async _loadFontIndexJson({ fontType = "simhei", fontBasePath }) {
-        let fontFamily = this.THREEFontMap.get(fontType);
-        // 创建 three 字体对象
-        if (!fontFamily) {
-            // 初始字体结构
-            fontFamily = new Font({
-                "underlineThickness": 69,
-                "underlinePosition": -174,
-                "resolution": 1000,
-                "original_font_information": {},
-                "familyName": "Source Han Sans CN Normal",
-                "descender": -167,
-                "cssFontWeight": "normal",
-                "cssFontStyle": "normal",
-                "boundingBox": {
-                    "yMin": -700,
-                    "xMin": -1389,
-                    "yMax": 700,
-                    "xMax": 4067
-                },
-                "glyphs": {}
+    fontContorl.prototype._loadFontIndexJson = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontBasePath = _a.fontBasePath;
+        return __awaiter(this, void 0, void 0, function () {
+            var fontFamily, fontFamilyIndexJson;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        fontFamily = this.THREEFontMap.get(fontType);
+                        if (!!fontFamily) return [3 /*break*/, 2];
+                        // 初始字体结构
+                        fontFamily = new Font({
+                            "underlineThickness": 69,
+                            "underlinePosition": -174,
+                            "resolution": 1000,
+                            "original_font_information": {},
+                            "familyName": "Source Han Sans CN Normal",
+                            "descender": -167,
+                            "cssFontWeight": "normal",
+                            "cssFontStyle": "normal",
+                            "boundingBox": {
+                                "yMin": -700,
+                                "xMin": -1389,
+                                "yMax": 700,
+                                "xMax": 4067
+                            },
+                            "glyphs": {}
+                        });
+                        this.THREEFontMap.set(fontType, fontFamily);
+                        return [4 /*yield*/, this.getFont({ fontType: fontType, fontName: "index" })];
+                    case 1:
+                        fontFamilyIndexJson = _c.sent();
+                        // 加载外部字体初始结构文件
+                        if (!fontFamilyIndexJson) {
+                            this._loadFontJson({ fontType: fontType, fontName: "index", fontBasePath: fontBasePath });
+                        }
+                        _c.label = 2;
+                    case 2: return [2 /*return*/];
+                }
             });
-            this.THREEFontMap.set(fontType, fontFamily);
-            // 读取本地数据库中的字体初始结构文件
-            let fontFamilyIndexJson = await this.getFont({ fontType, fontName: "index" });
-            // 加载外部字体初始结构文件
-            if (!fontFamilyIndexJson) {
-                this._loadFontJson({ fontType, fontName: "index", fontBasePath });
-            }
-        }
-    }
+        });
+    };
     // 加载外部字体.js
-    async _loadFontJson({ fontType = "simhei", fontName, fontBasePath }) {
-        let fontJson = await this.getFont({ fontType, fontName });
-        if (!fontJson) {
-            fontJson = gentilisJSON.glyphs[fontName];
-        }
-        // 数据库中没有 就去加载字体js
-        if (!fontJson) {
-            // 加载字体js 
-            await new Promise(resolve => {
-                let script = document.createElement("script");
-                Object.assign(script, {
-                    type: "text/javascript",
-                    src: `${fontBasePath}${fontType}/${fontName}.js`,
-                    async: true,
-                    onload: () => {
-                        script.remove();
-                        resolve();
-                    },
-                    onerror: () => {
-                    }
-                });
-                document.head.appendChild(script);
+    fontContorl.prototype._loadFontJson = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontName = _a.fontName, fontBasePath = _a.fontBasePath;
+        return __awaiter(this, void 0, void 0, function () {
+            var fontJson, fontFamily, origin_callbacks;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.getFont({ fontType: fontType, fontName: fontName })];
+                    case 1:
+                        fontJson = _c.sent();
+                        if (!fontJson) {
+                            fontJson = gentilisJSON.glyphs[fontName];
+                        }
+                        if (!!fontJson) return [3 /*break*/, 3];
+                        // 加载字体js 
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                var script = document.createElement("script");
+                                Object.assign(script, {
+                                    type: "text/javascript",
+                                    src: "".concat(fontBasePath).concat(fontType, "/").concat(fontName, ".js"),
+                                    async: true,
+                                    onload: function () {
+                                        script.remove();
+                                        resolve();
+                                    },
+                                    onerror: function () {
+                                    }
+                                });
+                                document.head.appendChild(script);
+                            })];
+                    case 2:
+                        // 加载字体js 
+                        _c.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        fontFamily = this.THREEFontMap.get(fontType);
+                        // 创建 three 字体对象
+                        if (fontFamily) {
+                            //@ts-ignore
+                            fontFamily.data.glyphs[fontName] = fontJson;
+                        }
+                        _c.label = 4;
+                    case 4:
+                        origin_callbacks = this._loadTextCall.get("".concat(fontType, "_").concat(fontName)) || [];
+                        // // 删除待执行的回调
+                        this._loadTextCall.delete("".concat(fontType, "_").concat(fontName));
+                        origin_callbacks.map(function (callback) {
+                            // 执行任务队列
+                            threeUtils.addWork(callback);
+                        });
+                        return [2 /*return*/];
+                }
             });
-        }
-        else {
-            // 数据库或者默认字体中 有就加入字体文件中
-            let fontFamily = this.THREEFontMap.get(fontType);
-            // 创建 three 字体对象
-            if (fontFamily) {
-                //@ts-ignore
-                fontFamily.data.glyphs[fontName] = fontJson;
-            }
-        }
-        // 执行相应的回调函数
-        let origin_callbacks = this._loadTextCall.get(`${fontType}_${fontName}`) || [];
-        // // 删除待执行的回调
-        this._loadTextCall.delete(`${fontType}_${fontName}`);
-        origin_callbacks.map(callback => {
-            // 执行任务队列
-            threeUtils.addWork(callback);
         });
-    }
+    };
     // 判断是否有这个文字
-    hasFont({ fontType, fontName }) {
+    fontContorl.prototype.hasFont = function (_a) {
+        var fontType = _a.fontType, fontName = _a.fontName;
         return !isEmpty(this.THREEFontMap.get(fontType) &&
             //@ts-ignore
             this.THREEFontMap.get(fontType).data.glyphs[fontName]);
-    }
+    };
     // 这个方法是提供给外部字体文件调用的
-    addFont({ fontType = "simhei", fontName, fontJson }) {
+    fontContorl.prototype.addFont = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontName = _a.fontName, fontJson = _a.fontJson;
         // 保存字体json到本地数据中
-        this.saveFont({ fontType, fontName, fontJson });
-        let fontFamily = this.THREEFontMap.get(fontType);
+        this.saveFont({ fontType: fontType, fontName: fontName, fontJson: fontJson });
+        var fontFamily = this.THREEFontMap.get(fontType);
         // 创建 three 字体对象
         if (fontFamily) {
             //@ts-ignore
             fontFamily.data.glyphs[fontName] = fontJson;
         }
-    }
+    };
     // 这个方法是提供给外部字体文件调用的
-    addFontFamily({ fontType = "simhei", fontFamilyJson }) {
+    fontContorl.prototype.addFontFamily = function (_a) {
+        var _b = _a.fontType, fontType = _b === void 0 ? "simhei" : _b, fontFamilyJson = _a.fontFamilyJson;
         // 保存字体初始结构到数据库中
-        this.saveFont({ fontType, fontName: "index", fontJson: fontFamilyJson });
-        let fontFamily = this.THREEFontMap.get(fontType);
+        this.saveFont({ fontType: fontType, fontName: "index", fontJson: fontFamilyJson });
+        var fontFamily = this.THREEFontMap.get(fontType);
         // 创建 three 字体对象
         if (fontFamily) {
             //@ts-ignore
-            fontFamily.data = {
-                ...fontFamilyJson,
+            fontFamily.data = __assign(__assign({}, fontFamilyJson), { 
                 //@ts-ignore
-                glyphs: fontFamily.data.glyphs
-            };
+                glyphs: fontFamily.data.glyphs });
         }
-    }
-}
-const fontContorller = new fontContorl();
-Object.assign(window, { fontContorller });
+    };
+    return fontContorl;
+}());
+var fontContorller = new fontContorl();
+Object.assign(window, { fontContorller: fontContorller });
 export default fontContorller;