ztxkutils 2.10.51 → 2.10.52

package/dist/hooks/index.d.ts

@@ -4,4 +4,5 @@ import useTableValidate from './useTableValidate';
 import useScreenFull from './useScreenFull';
 import useMutationObserver from './useMutationObserver';
 import useFileIdToBase64 from './useFileIdToBase64';
-export { useTableLinkage, useFetchState, useTableValidate, useScreenFull, useMutationObserver, useFileIdToBase64, };
+import useAsr from './useAsr';
+export { useTableLinkage, useFetchState, useTableValidate, useScreenFull, useMutationObserver, useFileIdToBase64, useAsr, };

package/dist/hooks/useAsr.d.ts

@@ -0,0 +1,87 @@
+/// <reference types="react" />
+/**
+ * 连接讯飞的方法
+ * 内部管理状态
+ * UNDEFINED 初始化状态
+ * CONNECTING 开始准备连接时的状态，会获取ws地址，然后建立ws连接
+ * OPEN 表示录音已经开始了，可以发送数据了
+ * CLOSED ws连接因为一些异常 发生关闭，需要终止录音
+ * CLOSING 表示最后一段录音信息已经接收完毕，可以关闭连接了
+ */
+declare type IStatus = 'UNDEFINED' | 'CONNECTING' | 'OPEN' | 'CLOSED' | 'CLOSING';
+interface IRecord {
+    /** 开始录音方法 */
+    start: () => void;
+    /** 关闭录音方法 */
+    stop: () => void;
+    /** 当前语言 */
+    language?: string;
+    /** 目标语言 */
+    transLanguage?: string;
+}
+export declare function useWs(info?: {
+    textResultCallback?: (t: any) => void;
+    isDebugger?: boolean;
+    getWsUrlRequest?: any;
+}): {
+    status: IStatus;
+    changeStatus: (s: IStatus) => void;
+    connectWebSocket: (recorder: IRecord) => Promise<void>;
+    webscoketObjRef: import("react").MutableRefObject<any>;
+    resultTextRef: import("react").MutableRefObject<string>;
+};
+/**
+ * 录音管理器的相关方法
+ */
+export declare function useRecorderManager(options: {
+    url?: string;
+    startCallback?: () => void;
+    frameRecordCallback?: (info?: any) => void;
+    stopCallback?: (buffer?: any) => void;
+}): {
+    recordRef: import("react").MutableRefObject<any>;
+    start: () => Promise<void>;
+    stop: () => void;
+};
+/**
+ * 定义一个计时器类似的东西
+ * 可以开始计时 结束计时
+ */
+export declare function useCount(callback: any): {
+    start: () => void;
+    stop: () => void;
+};
+/**
+ * 数据转换
+ * 将收到的讯飞语音识别的数据 转换成 标准数据
+ */
+export declare function parseWsData(data: any, msgCallback: any, callback: any, isDebugger: any): void;
+/**
+ * 返回最新的值 但是是一个ref对象
+ */
+export declare function useLastest(value: any): import("react").MutableRefObject<any>;
+/**
+ * 返回一个按钮的方法
+ * getCmdCallback 将语音识别结果 发送给 后台 获取识别结果
+ * recordTextCallback 语音识别结果实时触发
+ * isNeedCmd 是否需要后台识别
+ * getWsUrlRequest ws url 地址
+ * getWsCmdRequest 识别指令接口
+ * recordUrl 录音sdk路径
+ */
+export default function useStartWs(info: {
+    getCmdCallback?: (cmdInfo: any) => void;
+    recordTextCallback?: (text: any) => void;
+    isNeedCmd?: boolean;
+    isDebugger?: boolean;
+    getWsUrlRequest: any;
+    getWsCmdRequest?: any;
+    recordUrl?: any;
+}): {
+    onClickHandle: () => Promise<void>;
+    status: IStatus;
+    loading: boolean;
+    isInit: boolean;
+    isStarting: boolean;
+};
+export {};

package/dist/hooks.js

@@ -1,6 +1,8 @@
 import { _ as __assign, b as __awaiter, c as __generator } from './tslib.es6-35653116.js';
 import { useState, useEffect, useRef, useCallback } from 'react';
 export { default as useFileIdToBase64 } from './useFileIdToBase64.js';
+import { message } from 'ztxkui';
+import axios from 'axios';
 import './fileOperation.js';
 import './authority-e6bde99f.js';
 import './tools-09a4d620.js';
@@ -412,4 +414,373 @@ function useMutationObserver(dom, callback) {
     }, [dom, callback]);
 }
 
-export { useFetchState, useMutationObserver, useScreenFull, useTableLinkage, useTableValidate };
+function useWs(info) {
+    var _this = this;
+    var _a = info || {}, textResultCallback = _a.textResultCallback, isDebugger = _a.isDebugger, getWsUrlRequest = _a.getWsUrlRequest;
+    var websocketUrlRef = useRef(''); // 长连接地址
+    var _b = useState('UNDEFINED'), status = _b[0], setStatus = _b[1]; // 内部状态
+    var webscoketObjRef = useRef(null); // ws连接对象
+    var resultTextRef = useRef(''); // 识别结果
+    var webscoketUrlRef = useRef(); // ws长连接地址
+    var textResultCbLastest = useLastest(textResultCallback);
+    // 修改状态
+    var changeStatus = useCallback(function (s) {
+        setStatus(s);
+    }, []);
+    // 获取讯飞WS长连接地址
+    var getWebSocketUrlHandle = useCallback(function () {
+        if (!getWsUrlRequest) {
+            throw new Error('必须传入获取Ws长连接的方法');
+        }
+        return new Promise(function (resolve, reject) {
+            getWsUrlRequest()
+                .then(function (res) {
+                var _a, _b;
+                if (res.status === 200 && res.data.code === 200) {
+                    websocketUrlRef.current = "" + ((_b = (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.connectUrl);
+                    resolve(websocketUrlRef.current);
+                }
+                else {
+                    reject({ msg: '获取ws链接地址失败!' });
+                }
+            })
+                .catch(function (err) {
+                var _a;
+                reject({ msg: ((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.msg) || '获取ws地址失败!' });
+            });
+        });
+    }, []);
+    // 开始连接方法
+    var connectWebSocket = useCallback(function (recorder) { return __awaiter(_this, void 0, void 0, function () {
+        var websocketUrl, res, err_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    // SETP 1 将状态设置为 开始连接状态
+                    // 获取讯飞ws长连接地址
+                    changeStatus('CONNECTING');
+                    websocketUrl = webscoketUrlRef.current;
+                    if (!!websocketUrl) return [3 /*break*/, 4];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, getWebSocketUrlHandle()];
+                case 2:
+                    res = _b.sent();
+                    if (typeof res === 'string') {
+                        // &lang=${recorder?.language}&transType=normal&transStrategy=2&targetLang=${recorder?.transLanguage}
+                        websocketUrl = webscoketUrlRef.current = "" + res;
+                    }
+                    else {
+                        changeStatus('CLOSED');
+                        message.info(((_a = res) === null || _a === void 0 ? void 0 : _a.msg) || '获取ws地址失败!');
+                        return [2 /*return*/];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _b.sent();
+                    changeStatus('CLOSED');
+                    message.info((err_1 === null || err_1 === void 0 ? void 0 : err_1.msg) || '获取ws地址失败!');
+                    return [2 /*return*/];
+                case 4:
+                    // 长连接不能复用？  发送完 end: true后 长连接就关闭了
+                    // SETP 2 建立WS长连接
+                    // 赋值ws对象给Ref
+                    if ('WebSocket' in window) {
+                        webscoketObjRef.current = new WebSocket(websocketUrl);
+                    }
+                    else if ('MozWebSocket' in window) {
+                        webscoketObjRef.current = new window.MozWebSocket(websocketUrl);
+                    }
+                    else {
+                        message.info('浏览器不支持WebSocket');
+                        return [2 /*return*/];
+                    }
+                    // SETP 3 监听WS长连接的各种状态
+                    // 连接建立开始后。开始录音
+                    webscoketObjRef.current.onopen = function (e) {
+                        if (isDebugger) {
+                            console.log('连接建立', e);
+                        }
+                        resultTextRef.current = '';
+                        textResultCbLastest.current &&
+                            textResultCbLastest.current(resultTextRef.current);
+                        recorder.start();
+                    };
+                    // 处理回调消息
+                    webscoketObjRef.current.onmessage = function (e) {
+                        parseWsData(e.data, function (msg) {
+                            if (msg.code === '0') {
+                                if (isDebugger) {
+                                    console.log('识别结果：', msg.resultText);
+                                }
+                                resultTextRef.current += msg.resultText;
+                                textResultCbLastest.current &&
+                                    textResultCbLastest.current(resultTextRef.current);
+                            }
+                        }, function (err) {
+                            var _a, _b;
+                            if (err) {
+                                if (isDebugger) {
+                                    console.log('ws连接出错了!');
+                                }
+                                recorder.stop();
+                                webscoketObjRef.current.send('{"end": true}');
+                                changeStatus('CLOSED');
+                                (_b = (_a = webscoketObjRef.current) === null || _a === void 0 ? void 0 : _a.close) === null || _b === void 0 ? void 0 : _b.call(_a);
+                            }
+                        }, isDebugger);
+                    };
+                    // 连接异常 处理异常
+                    // 关闭录音
+                    // 修改状态为 CLOSED
+                    webscoketObjRef.current.onerror = function (e) {
+                        if (isDebugger) {
+                            console.log('连接异常', e);
+                        }
+                        recorder.stop();
+                        changeStatus('CLOSED');
+                    };
+                    // 主动关闭
+                    // 关闭录音
+                    // 修改状态为 CLOSED
+                    webscoketObjRef.current.onclose = function (e) {
+                        if (isDebugger) {
+                            console.log('连接关闭', e);
+                        }
+                        recorder.stop();
+                        changeStatus('CLOSED');
+                    };
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [changeStatus, getWebSocketUrlHandle, textResultCbLastest, isDebugger]);
+    return {
+        status: status,
+        changeStatus: changeStatus,
+        connectWebSocket: connectWebSocket,
+        webscoketObjRef: webscoketObjRef,
+        resultTextRef: resultTextRef,
+    };
+}
+/**
+ * 录音管理器的相关方法
+ */
+function useRecorderManager(options) {
+    var _this = this;
+    var _a = options.url, url = _a === void 0 ? '/asrsdk' : _a, startCallback = options.startCallback, frameRecordCallback = options.frameRecordCallback, stopCallback = options.stopCallback;
+    // 录音对象
+    var recordRef = useRef();
+    // 初始化录音对象
+    var RecorderManager = window.RecorderManager;
+    if (!recordRef.current && RecorderManager) {
+        recordRef.current = new RecorderManager(url);
+        // 监听录音是否开启
+        recordRef.current.onStart = function () {
+            startCallback && startCallback();
+        };
+        // 监听已录制完指定帧大小的文件事件。如果设置了 frameSize，则会回调此事件
+        recordRef.current.onFrameRecorded = function (_a) {
+            var isLastFrame = _a.isLastFrame, frameBuffer = _a.frameBuffer;
+            frameRecordCallback && frameRecordCallback({ isLastFrame: isLastFrame, frameBuffer: frameBuffer });
+        };
+        // 录音停止触发事件
+        recordRef.current.onStop = function (audioBuffers) {
+            stopCallback && stopCallback(audioBuffers);
+        };
+    }
+    if (!RecorderManager) {
+        console.error('你没有引入路由相关API，请引入!');
+    }
+    var start = function () { return __awaiter(_this, void 0, void 0, function () {
+        var _a, _b;
+        return __generator(this, function (_c) {
+            (_b = (_a = recordRef.current) === null || _a === void 0 ? void 0 : _a.start) === null || _b === void 0 ? void 0 : _b.call(_a, {
+                sampleRate: 16000,
+                frameSize: 1280, // 指定帧大小，传入 frameSize 后，每录制指定帧大小的内容后，会回调录制的文件内容，不指定则不会回调
+            });
+            return [2 /*return*/];
+        });
+    }); };
+    var stop = function () {
+        var _a, _b;
+        (_b = (_a = recordRef.current) === null || _a === void 0 ? void 0 : _a.stop) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    return {
+        recordRef: recordRef,
+        start: start,
+        stop: stop,
+    };
+}
+/**
+ * 数据转换
+ * 将收到的讯飞语音识别的数据 转换成 标准数据
+ */
+function parseWsData(data, msgCallback, callback, isDebugger) {
+    var _a, _b, _c, _d;
+    try {
+        var jsonData = JSON.parse(data);
+        if (jsonData.action === 'started') {
+            // 握手成功
+            if (isDebugger) {
+                console.log('握手成功');
+            }
+        }
+        else if (jsonData.action === 'result') {
+            var data_1 = JSON.parse(jsonData.data);
+            if (isDebugger) {
+                console.log('收到讯飞的语音提示', data_1);
+            }
+            // 类型是 '0' 的话 表示是完整的音频
+            // 类型是 '1' 的话 表示是中间的音频
+            var type = (_b = (_a = data_1 === null || data_1 === void 0 ? void 0 : data_1.cn) === null || _a === void 0 ? void 0 : _a.st) === null || _b === void 0 ? void 0 : _b.type;
+            var resultText_1 = '';
+            if ((_d = (_c = data_1 === null || data_1 === void 0 ? void 0 : data_1.cn) === null || _c === void 0 ? void 0 : _c.st) === null || _d === void 0 ? void 0 : _d.rt) {
+                data_1.cn.st.rt.forEach(function (j) {
+                    j.ws.forEach(function (k) {
+                        k.cw.forEach(function (l) {
+                            resultText_1 += l.w;
+                        });
+                    });
+                });
+            }
+            if (type + '' === '0') {
+                // 【最终】识别结果：
+                msgCallback({ resultText: resultText_1, code: '0' });
+                resultText_1 = '';
+            }
+        }
+        else if (jsonData.action === 'error') {
+            // 连接发生错误
+            if (isDebugger) {
+                console.log('出错了:', jsonData);
+            }
+            callback({ code: '1', msg: '连接出错了' });
+        }
+    }
+    catch (err) {
+        console.log(err);
+    }
+}
+/**
+ * 返回最新的值 但是是一个ref对象
+ */
+function useLastest(value) {
+    var ref = useRef(value);
+    ref.current = value;
+    return ref;
+}
+/**
+ * 返回一个按钮的方法
+ * getCmdCallback 将语音识别结果 发送给 后台 获取识别结果
+ * recordTextCallback 语音识别结果实时触发
+ * isNeedCmd 是否需要后台识别
+ * getWsUrlRequest ws url 地址
+ * getWsCmdRequest 识别指令接口
+ * recordUrl 录音sdk路径
+ */
+function useStartWs(info) {
+    var _this = this;
+    var getCmdCallback = info.getCmdCallback, recordTextCallback = info.recordTextCallback, isNeedCmd = info.isNeedCmd, isDebugger = info.isDebugger, getWsUrlRequest = info.getWsUrlRequest, getWsCmdRequest = info.getWsCmdRequest, recordUrl = info.recordUrl;
+    // ws连接
+    var _a = useWs({
+        textResultCallback: recordTextCallback,
+        isDebugger: isDebugger,
+        getWsUrlRequest: getWsUrlRequest,
+    }), status = _a.status, changeStatus = _a.changeStatus, connectWebSocket = _a.connectWebSocket, webscoketObjRef = _a.webscoketObjRef, resultTextRef = _a.resultTextRef;
+    var cancelRef = useRef();
+    var cbLastest = useLastest(getCmdCallback);
+    var statusLastest = useLastest(status);
+    // 录音器方法
+    var _b = useRecorderManager({
+        url: recordUrl,
+        startCallback: function () {
+            // 录音开始时，表示可以开始发送数据了
+            changeStatus('OPEN');
+        },
+        frameRecordCallback: function (_a) {
+            var isLastFrame = _a.isLastFrame, frameBuffer = _a.frameBuffer;
+            var webscoketObj = webscoketObjRef.current;
+            if (webscoketObj && (webscoketObj === null || webscoketObj === void 0 ? void 0 : webscoketObj.readyState) === (webscoketObj === null || webscoketObj === void 0 ? void 0 : webscoketObj.OPEN)) {
+                webscoketObj.send(new Int8Array(frameBuffer));
+                if (isLastFrame) {
+                    if (isDebugger) {
+                        console.log('收到录音的最后帧!');
+                    }
+                    webscoketObj.send('{"end": true}');
+                    // 最后一段录音结束才可以结束翻译
+                    changeStatus('CLOSING');
+                }
+            }
+        },
+        stopCallback: function () {
+            if (isDebugger) {
+                console.log(resultTextRef.current.replace(/，|。/g, ''), statusLastest.current);
+            }
+            // 根据识别结果 获取后台的指令命令
+            if (resultTextRef.current &&
+                statusLastest.current === 'CLOSED' &&
+                isNeedCmd) {
+                if (!getWsCmdRequest) {
+                    throw new Error('你没有传入 获取指令的接口，这将导致错误!');
+                }
+                if (cancelRef.current) {
+                    cancelRef.current();
+                }
+                getWsCmdRequest({ voiceContent: resultTextRef.current.replace(/，|。/g, '') }, {
+                    cancelToken: new axios.CancelToken(function (c) {
+                        cancelRef.current = c;
+                    }),
+                })
+                    .then(function (res) {
+                    var _a, _b;
+                    if (res.status === 200 && res.data.code === 200) {
+                        cbLastest.current && cbLastest.current(res.data.data);
+                    }
+                    else {
+                        message.error(((_b = (_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.msg) || '不支持处理该指令，请重说!');
+                    }
+                })
+                    .catch(function (err) {
+                    var _a, _b;
+                    message.error(((_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.msg) || '不支持处理该指令，请重说!');
+                });
+            }
+        },
+    }), start = _b.start, stop = _b.stop;
+    var onClick = useCallback(function () { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!(status === 'UNDEFINED' || status === 'CLOSED')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, connectWebSocket({
+                            start: start,
+                            stop: stop,
+                        })];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    if (status === 'OPEN' || status === 'CONNECTING') {
+                        // 停止录音
+                        stop();
+                    }
+                    _a.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [connectWebSocket, start, status, stop]);
+    return {
+        onClickHandle: onClick,
+        status: status,
+        // 识别中
+        loading: status === 'CLOSING' || status === 'CONNECTING',
+        // 初始状态
+        isInit: status === 'UNDEFINED' || status === 'CLOSED',
+        // 开启中
+        isStarting: status === 'CONNECTING',
+    };
+}
+
+export { useStartWs as useAsr, useFetchState, useMutationObserver, useScreenFull, useTableLinkage, useTableValidate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztxkutils",
-  "version": "2.10.51",
+  "version": "2.10.52",
   "description": "",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/dist/reqUrl-787dd9e5.js

@@ -1,82 +0,0 @@
-/**
- * @file 项目基本配置，包括各个环境的请求地址
- */
-// 环境变量
-function getReqUrl(processObj) {
-    var ENV = processObj.REACT_APP_ENV;
-    // api服务器各个环境地址
-    var ZT_API_DEV = processObj.REACT_APP_ZT_API_DEV || 'http://192.168.0.83:8000'; // 开发环境
-    var ZT_API_TEST = processObj.REACT_APP_ZT_API_TEST || window.location.origin; // 测试环境 https://192.168.0.135:8000
-    var ZT_API_STAGE = processObj.REACT_APP_ZT_API_STAGE || window.location.origin; // 阶段性环境 http://192.168.0.134:8000
-    var ZT_API_SIM = processObj.REACT_APP_ZT_API_SIM || window.location.origin; // 阶段性环境 http://192.168.0.134:8000
-    var ZT_API_PRODUCT = processObj.REACT_APP_ZT_API_PRODUCT || window.location.origin; // 生产环境 http://dz.zmd.com.cn
-    var ZT_API_PUBLIC_PRODUCT = processObj.REACT_APP_ZT_API_PUBLIC_PRODUCT ||
-        'https://m-portal.zmd.com.cn:18998'; // 生产环境外网api地址 http://dz.zmd.com.cn:48000
-    // 文件服务器
-    var ZT_FILE_PREVIEW_DEV = processObj.REACT_APP_ZT_FILE_PREVIEW_DEV || 'http://192.168.0.83:88'; // 开发环境
-    var ZT_FILE_PREVIEW_TEST = processObj.REACT_APP_ZT_FILE_PREVIEW_TEST || 'http://172.55.5.101:33013'; // 测试环境 https://192.168.0.135:18012
-    var ZT_FILE_PREVIEW_STAGE = processObj.REACT_APP_ZT_FILE_PREVIEW_STAGE ||
-        'https://dzfile-prod.zmd.com.cn/'; // 阶段性环境 http://192.168.0.134:8012
-    var ZT_FILE_PREVIEW_SIM = processObj.REACT_APP_ZT_FILE_PREVIEW_SIM ||
-        'https://dzfile-data.zmd.com.cn/'; // 阶段性环境 http://192.168.0.134:8012
-    var ZT_FILE_PREVIEW_PRODUCT = processObj.REACT_APP_ZT_FILE_PREVIEW_PRODUCT ||
-        'https://dzfile.zmd.com.cn:8012'; // 生产环境
-    // 字体文件附件id
-    var ZT_FONTFAMILY_DEV = '1551733945007517697';
-    var ZT_FONTFAMILY_TEST = '1551836774183047169';
-    var ZT_FONTFAMILY_STAGE = '1551837561144905730';
-    var ZT_FONTFAMILY_SIM = '1562010976138207234';
-    var ZT_FONTFAMILY_PRODUCT = '1552851055372992513';
-    // 实际api请求地址
-    var ZT_API_BASEURL = ZT_API_DEV;
-    var ZT_API_PUBLICURL = ZT_API_PUBLIC_PRODUCT;
-    var ZT_FILE_BASEURL = ZT_FILE_PREVIEW_DEV;
-    var ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_DEV;
-    if (ENV) {
-        switch (ENV.toLowerCase()) {
-            case 'zt-dev':
-                ZT_API_BASEURL = ZT_API_DEV;
-                ZT_API_PUBLICURL = ZT_API_DEV;
-                ZT_FILE_BASEURL = ZT_FILE_PREVIEW_DEV;
-                ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_DEV;
-                break;
-            case 'zt-test':
-                ZT_API_BASEURL = ZT_API_TEST;
-                ZT_API_PUBLICURL = ZT_API_TEST;
-                ZT_FILE_BASEURL = ZT_FILE_PREVIEW_TEST;
-                ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_TEST;
-                break;
-            case 'zt-stage':
-                ZT_API_BASEURL = ZT_API_STAGE;
-                ZT_API_PUBLICURL = ZT_API_STAGE;
-                ZT_FILE_BASEURL = ZT_FILE_PREVIEW_STAGE;
-                ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_STAGE;
-                break;
-            case 'zt-sim':
-                ZT_API_BASEURL = ZT_API_SIM;
-                ZT_API_PUBLICURL = ZT_API_SIM;
-                ZT_FILE_BASEURL = ZT_FILE_PREVIEW_SIM;
-                ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_SIM;
-                break;
-            case 'zt-product':
-                ZT_API_BASEURL = ZT_API_PRODUCT;
-                ZT_API_PUBLICURL = ZT_API_PUBLIC_PRODUCT;
-                ZT_FILE_BASEURL = ZT_FILE_PREVIEW_PRODUCT;
-                ZT_FONTFAMILY_BASEURL = ZT_FONTFAMILY_PRODUCT;
-                break;
-        }
-    }
-    return {
-        ZT_API_BASEURL: ZT_API_BASEURL,
-        ZT_FILE_BASEURL: ZT_FILE_BASEURL,
-        ZT_API_PUBLICURL: ZT_API_PUBLICURL,
-        ZT_FONTFAMILY_BASEURL: ZT_FONTFAMILY_BASEURL,
-    };
-}
-
-var reqUrl = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  getReqUrl: getReqUrl
-});
-
-export { getReqUrl as g, reqUrl as r };