元素，直接包裹 SVG 图标，避免动态事件处理丢失
const editButton = document.createElement('a');
editButton.id = 'editButton_TableCrad_' + idName;
if (idName === 'print') {
editButton.style.display = 'none';
editButton.href = createRedirectUrl(sessionGoodsId); // 确保超链接指向正确的地址
editButton.target = '_blank'; // 打开新标签
} else {
editButton.style.display = 'block';
if (sonMain_pictureInPictureSwitch.getSwitchState()) {
const pipManager = new PIPManager(getSessionGoodsIdUrl(sessionGoodsId), editButton, true);
} else {
editButton.href = getSessionGoodsIdUrl(sessionGoodsId);
editButton.target = '_blank'; // 打开新标签
}
}
editButton.appendChild(divWrapper);
return editButton; // 返回带有超链接的按钮
}
// 判断是否是剧透时间
function checkIfTrailer(storedDate) {
const currentTime = new Date();
let isTrailer = '';
// 获取当前年份
const currentYear = currentTime.getFullYear();
// 将字符串日期转换为Date对象，加入当前年份
let adjustedDate = new Date(`${currentYear}-${storedDate}T18:00:00`);
// 将日期往前调整一天
adjustedDate.setDate(adjustedDate.getDate() - 1);
// 计算两个日期之间的差值（以天为单位）
const timeDifference = Math.abs(currentTime - adjustedDate);
const dayDifference = timeDifference / (1000 * 60 * 60 * 24);
// 如果天数差值大于180天，考虑跨年情况，给adjustedDate加上1年
if (dayDifference > 180) {
adjustedDate.setFullYear(adjustedDate.getFullYear() + 1);
}
const printCard_switch = document.getElementById('button_setPrintTableCardArea_switch');
const button_setPrintTableCardArea = document.getElementById('button_setPrintTableCardArea');
if (button_setPrintTableCardArea && printCard_switch.getAttribute('aria-checked') === 'true') {
isTrailer = "核对";
} else {
// 比较当前时间与截止时间
if (currentTime < adjustedDate) {
isTrailer = "剧透";
} else {
isTrailer = '';
}
}
return isTrailer;
}
// 判断手卡打印页面中的手卡店铺名是否都一致
function onlyOneShopName(shopNameArray) {
// 过滤多余内容，生成过滤后的数组
const filteredShopNames = shopNameArray.map(shopName => processText(shopName));
// 判断所有过滤后的店名是否一致
const allEqual = filteredShopNames.every(shopName => shopName === filteredShopNames[0]);
// 如果所有内容一致，返回第一个店名，否则返回 false
return allEqual ? filteredShopNames[0] : false;
}
function hide_link_helpMenu(isActivated = true) {
var isShow = isActivated ? 'none' : '';
// link帮助菜单
const link_helpMenu = document.querySelector('.link-customer-service-only-help');
if (link_helpMenu) link_helpMenu.style.display = isShow;
}
// 纯净模式函数
function pureMode(isActivated) {
var isShow = isActivated ? 'none' : '';
var targetHeight = document.documentElement.scrollHeight - 238;
hide_link_helpMenu(isActivated);
// 直播场次日期切换菜单
const liveDay_selectMenu = document.querySelector('.flex.justify-between.pb-12');
// 直播场次总览
const liveOverview_table = document.querySelector('.link-session-board-pai___eddtw').parentElement;
const otherElements = document.querySelector('.ag-body-horizontal-scroll-viewport');
// 设置元素的显示状态
liveDay_selectMenu.style.display = isShow;
liveOverview_table.style.display = isShow;
// otherElements.style.display = isShow;
// margin优化
const margin_value = isActivated ? '0px' : '12px';
const mainElement = document.querySelector('main');
mainElement.style.marginTop = margin_value;
mainElement.style.marginBottom = margin_value;
// 商品操作框
// 外部框
const goodsOperation_div = document.querySelector('.ant-spin-container');
// 内部表格
const goodsOperation_table = document.getElementById('ag-grid-react-container');
// 设置商品操作框的高度
goodsOperation_div.style.height = isShow === 'none' ? targetHeight + 'px' : '944px';
goodsOperation_table.style.height = isShow === 'none' ? targetHeight + 'px' : '548px';
}
// pureMode 场次信息辅助显示
function pureMode_infoDisplay(isActivated) {
// 场次信息数据
const storedDate = GM_getValue('titlePrint_extractedDate', '');
const storedSession = GM_getValue('titlePrint_extractedSession', '');
if (isActivated && !getDropdownContentDisplayState()) {
dropdownButton.textContent = storedDate + ' ' + storedSession;
} else {
dropdownButton.textContent = dropdownButtonName;
}
}
// 手卡页面优化功能区
function tableCard_optimize(isActivated) {
// 优化手卡页面的显示
if (isActivated) {
// 隐藏顶部header
document.querySelectorAll('.ant-pro-layout-container.css-zk6fk3 header').forEach(header => {
header.style.display = 'none';
});
// 隐藏帮助菜单
hide_link_helpMenu();
// 设置操作栏
const titleContainer = document.querySelector('.TableCard .tct-title-container');
if (titleContainer) titleContainer.style.top = '0'; // 设置top值
// 隐藏禁用词栏
const disabledWords = document.querySelector('.forbidden-word-container');
if (disabledWords) disabledWords.style.display = 'none';
}
}
// 手卡页面&批量打印页面-适配小窗功能区
function adapterPIP_forTableCardAndBatchPrint(isActivated, reset = false) {
// 适配小窗功能区
const windowWidth = window.innerWidth; // 获取当前窗口宽度
const PIP_width = getWidth_PIP() * getDisplayScale(); // 获取小窗宽度
function getDisplayScale() {
const displayWidth = window.innerWidth;
let displayScale = displayWidth / 1530;
return displayScale;
}
if (isTableCardURL()) {
// 获取手卡页面宽度
const tableCard_width = getWidth_TableCard();
// 剩余宽度
const remaining_width = windowWidth - tableCard_width - 10;
// 默认左右margin值
const default_margin = remaining_width / 2;
if (isActivated && PIP_width != 0) {
if (reset) {
setMargin_TableCard(default_margin); // 重置边距
} else if (remaining_width < PIP_width) {
setMargin_TableCard(remaining_width, 10); // 设置边距
} else {
setMargin_TableCard(PIP_width, remaining_width - PIP_width); // 设置边距
}
} else {
setMargin_TableCard(default_margin); // 重置边距
}
}
if (isBatchPrintURL()) {
// 获取批量打印页面宽度
const batchPrint_width = getWidth_BatchPrint();
// 剩余宽度
const remaining_width = windowWidth - batchPrint_width - 40;
// 默认左右margin值
const default_margin = remaining_width / 2;
if (isActivated && PIP_width != 0) {
if (reset) {
setMargin_BatchPrint(default_margin); // 重置边距
} else if (remaining_width < PIP_width) {
setMargin_BatchPrint(remaining_width, 10); // 设置边距
} else {
setMargin_BatchPrint(PIP_width, remaining_width - PIP_width); // 设置边距
}
} else {
setMargin_BatchPrint(default_margin); // 重置边距
}
}
}
// 获取小窗宽度
function getWidth_PIP(PIP_margin = 10) {
// 确保PIP_margin是数字
if (typeof PIP_margin !== 'number') {
PIP_margin = 10;
}
// 获取小窗元素
const PIP_element = document.getElementById('mini_PIP');
// 检查元素是否存在
if (!PIP_element) {
// console.warn('PIP element not found!');
return 0; // 如果元素不存在，返回默认宽度
}
if (PIP_element.style.display === 'none') {
return 0;
}
// 获取PIP宽度并返回
const PIP_width = PIP_element.clientWidth;
return PIP_width + PIP_margin * 2;
}
// 获取小窗位置
function getPosition_PIP() {
// true = 左; false = 右
// 获取小窗元素
const PIP_element = document.getElementById('mini_PIP');
// 检查元素是否存在
if (!PIP_element) {
// console.warn('PIP element not found!');
return false; // 如果元素不存在，返回默认位置
}
const pipRect = PIP_element.getBoundingClientRect();
const centerX = pipRect.left + pipRect.width / 2;
// 判断PIP位置，决定收起方向
const isLeftSide = centerX < window.innerWidth / 2;
return isLeftSide;
}
// 获取手卡页面手卡宽度
function getWidth_TableCard() {
// 获取手卡元素
const tableCard_element = document.querySelector('.A4-contianer');
// 检查元素是否存在
if (!tableCard_element) {
console.warn('Table card element not found!');
return 1194; // 如果元素不存在，返回默认宽度
}
tableCard_element.style.transition = 'margin 0.3s ease';
// 获取手卡宽度并返回
const tableCard_width = tableCard_element.clientWidth;
return tableCard_width;
}
// 设置手卡页面边距
function setMargin_TableCard(margin_valueMain, margin_valueRemain = margin_valueMain, isLeftSide = getPosition_PIP()) {
const target_element = document.querySelector('.A4-contianer');
if (isLeftSide) {
// 靠近左侧
target_element.style.marginLeft = margin_valueMain + 'px';
target_element.style.marginRight = margin_valueRemain + 'px';
} else {
// 靠近右侧
target_element.style.marginRight = margin_valueMain + 'px';
target_element.style.marginLeft = margin_valueRemain + 'px';
}
if (margin_valueMain === margin_valueRemain) {
target_element.style.marginLeft = margin_valueMain + 'px';
target_element.style.marginRight = margin_valueMain + 'px';
}
}
// 设置批量打印页面边距
function setMargin_BatchPrint(margin_valueMain, margin_valueRemain = margin_valueMain, isLeftSide = getPosition_PIP()) {
const target_element = document.querySelector('.w-1160px.m-auto.flex-1.overflow-y-auto');
if (isLeftSide) {
// 靠近左侧
target_element.style.marginLeft = margin_valueMain + 'px';
target_element.style.marginRight = margin_valueRemain + 'px';
} else {
// 靠近右侧
target_element.style.marginRight = margin_valueMain + 'px';
target_element.style.marginLeft = margin_valueRemain + 'px';
}
if (margin_valueMain === margin_valueRemain) {
target_element.style.marginLeft = 'auto';
target_element.style.marginRight = 'auto';
}
}
// 获取批量打印页面手卡宽度
function getWidth_BatchPrint() {
// 获取手卡元素
const tableCard_element = document.querySelector('.w-1160px.m-auto.flex-1.overflow-y-auto');
// 检查元素是否存在
if (!tableCard_element) {
console.warn('Batch print element not found!');
return 1160; // 如果元素不存在，返回默认宽度
}
tableCard_element.style.transition = 'margin 0.3s ease';
// 获取手卡宽度并返回
const tableCard_width = tableCard_element.clientWidth;
return tableCard_width;
}
// 批量打印页面优化功能区
function batchPrint_optimize(isActivated) {
if (isActivated) {
// 隐藏帮助菜单
hide_link_helpMenu();
// 获取父容器
const parentElement = document.querySelector('.ant-layout.ant-layout-has-sider.css-9fw9up');
if (parentElement) {
// 获取直接的子元素
const children = parentElement.children; // 返回一个HTMLCollection，包含所有直接子元素
if (children.length === 3) {
// 优化批量打印页面的显示
children[0].style.display = 'none'; // 隐藏右侧的操作栏
children[1].style.display = 'none'; // 隐藏右侧的操作栏
} else {
console.log('批量打印页面元素数量不符合预期');
}
}
}
}
// 计数关闭浏览器更新弹窗次数
function incrementCloseCount() {
// 从本地存储中获取当前关闭计数
let closeCount = localStorage.getItem('browserUpdateCloseCount');
// 如果没有存储记录，则初始化为0
if (closeCount === null) {
closeCount = 0;
} else {
closeCount = parseInt(closeCount, 10); // 确保获取到的是数字
}
// 增加计数
closeCount += 1;
// 将更新后的计数存回本地存储
localStorage.setItem('browserUpdateCloseCount', closeCount);
// console.log(`关闭浏览器更新弹窗次数: ${closeCount}`);
}
// 读取关闭浏览器更新弹窗次数
function getCloseCount() {
let closeCount = localStorage.getItem('browserUpdateCloseCount');
// 如果本地存储中没有记录，返回0
if (closeCount === null) {
closeCount = 0;
} else {
closeCount = parseInt(closeCount, 10); // 确保获取到的是数字
}
return closeCount;
}
const sys_auxiliaryFunctions = new MutationObserver((mutationsList) => {
let urlChanged = false;
// 场次信息数据
const storedDate = GM_getValue('titlePrint_extractedDate', '');
const storedSession = GM_getValue('titlePrint_extractedSession', '');
// 重定向到手卡编辑页面
isRedirectToTableCardURL();
for (let mutation of mutationsList) {
if (mutation.type === 'childList') {
mutation.addedNodes.forEach((node) => {
// 系统通知位置优化
if (node.nodeType === 1 && node.classList.contains('ant-message') && node.classList.contains('ant-message-top') && node.classList.contains('css-190m0jy')) {
// 修改top值为64px
node.style.top = '64px';
}
if (sAF_closeBrowserUpdateDiv.getSwitchState()) {
// 关闭浏览器更新弹窗
if (node.nodeType === 1 && node.id === 'link-browser-update-global') {
const closeButton = node.querySelector('.link-browser-update-global-close');
if (closeButton) {
closeButton.click();
incrementCloseCount(); // 增加关闭计数
showNotification('已关闭浏览器更新弹窗', 3000);
// console.log('关闭了浏览器更新弹窗');
} else {
console.log('未找到关闭按钮');
}
}
}
});
// 检查URL是否变化
if (isHomeURL()) {
pureMode(pureSwitch.getSwitchState());
pureMode_infoDisplay(pureSwitch.getSwitchState());
const currentURL = window.location.href; // 获取当前网址
titlePrint_extractData(); // 提取日期和场次信息
// 只有在 URL 发生变化时，才会执行以下代码
if (currentURL !== lastCurrentURL) {
// 在保存新的 currentURL 之前，更新 lastCurrentURL
const previousURL = lastCurrentURL;
// 将当前网址保存到 localStorage
localStorage.setItem('lastCurrentURL', currentURL);
if (sAF_backToLastCurrentURL.getSwitchState()) {
// 显示通知并绑定点击事件，传入 previousURL 而不是 currentURL
showNotification('上次浏览的页面：' + storedDate + ' ' + storedSession, 5000);
setTimeout(() => {
itemSort_countInputFun.countSort_reShowNotification();// 计数通知显示恢复
}, 4000);
setTimeout(() => {
bindClickEventToNotification(previousURL); // 绑定点击事件，传入 previousURL
}, 50);
}
// 更新 lastCurrentURL 为新的网址
lastCurrentURL = currentURL;
urlChanged = true;
}
GM_setValue('sAF_FristPhotoCopyForTmallAndTaobao', sAF_FristPhotoCopyForTmallAndTaobao.getSwitchState());
}
if (isTableCardURL()) {
// 调用函数添加SVG图标
addSVGToSpecificTDs();
// 一键着色按键显示
displayDrawColorButton();
if (tableCardPng_checkItemIdRow.getSwitchState()) {
// 插入检查行
insertCheckedRow(url_getSessionGoodsId(), upLiveIdArray[2]);
}
// 手卡页面优化
tableCard_optimize(sAF_AdvanceTableCardPage.getSwitchState());
}
if (isTmallItemURL()) {
isRedirectToTableCardURL();
const isCreateButton = GM_getValue('sAF_FristPhotoCopyForTmallAndTaobao', false);
if (isCreateButton) {
// 创建按钮
createGetTmallPngButton();
}
}
function cardShopName_check() {
const isOnlyOneShop = onlyOneShopName(shopNameArray);
const printCard_switch = document.getElementById('button_setPrintTableCardArea_switch');
const button_setPrintTableCardArea = document.getElementById('button_setPrintTableCardArea');
if (button_setPrintTableCardArea && printCard_switch.getAttribute('aria-checked') === 'true' &&
isOnlyOneShop !== false && isOnlyOneShop) {
// 只有一个店铺名
return isOnlyOneShop;
} else {
return storedSession;
}
}
if (sAF_AdvanceBatchPrint.getSwitchState() && isBatchPrintURL() && storedDate && storedSession) {
document.title = `${storedDate} ${cardShopName_check()}手卡${checkIfTrailer(storedDate)}`;
printingTableCard(); // 打印中
batchPrint_optimize(true); // 优化页面
// 插入上播ID核对行
insertCheckedRow_forBatchPrint(sAF_AdvanceBatchPrint_alwaysDisplay.getSwitchState());
setTimeout(function () {
// 查找目标元素，即将新div插入到这个元素中
var targetElement = document.querySelector('.flex.justify-end');
// 检查是否已经存在id为button_setPrintTableCardArea的div，避免重复添加
if (!document.getElementById('button_setPrintTableCardArea')) {
// 创建一个新的div元素
var newDiv = document.createElement('div');
newDiv.id = 'button_setPrintTableCardArea';
newDiv.style.display = 'flex';
newDiv.style.justifyContent = 'space-between';
newDiv.style.alignItems = 'center';
newDiv.style.marginRight = '10px';
// 创建左侧的文本节点
var textNode = document.createElement('span');
textNode.textContent = '不打印红字和卖点区域';
textNode.style.fontSize = '14px';
textNode.style.marginRight = '10px';
// 创建右侧的开关按钮
var switchButton = document.createElement('button');
switchButton.type = 'button';
switchButton.id = 'button_setPrintTableCardArea_switch';
switchButton.setAttribute('role', 'switch');
switchButton.setAttribute('aria-checked', 'false'); // 默认未开启
switchButton.className = 'ant-switch ant-switch-small css-175k68i';
// 创建开关按钮内部的div（用于手柄）
var handleDiv = document.createElement('div');
handleDiv.className = 'ant-switch-handle';
// 将手柄div添加到按钮中
switchButton.appendChild(handleDiv);
// 添加点击事件，切换开关状态
switchButton.addEventListener('click', function () {
var isChecked = switchButton.getAttribute('aria-checked') === 'true';
if (isChecked) {
// 如果是开启状态，关闭它
switchButton.setAttribute('aria-checked', 'false');
switchButton.classList.remove('ant-switch-checked');
setPrintTableCardArea(true);
} else {
// 如果是关闭状态，开启它
switchButton.setAttribute('aria-checked', 'true');
switchButton.classList.add('ant-switch-checked');
setPrintTableCardArea(false);
}
});
// 将文本节点和开关按钮添加到div中
newDiv.appendChild(textNode);
newDiv.appendChild(switchButton);
// 将新创建的div添加到目标元素中
targetElement.appendChild(newDiv);
} else {
// console.log('开关已经存在，跳过创建。');
}
}, 1000); // 延迟1秒执行
}
}
}
// 处理URL变化
if (urlChanged) {
// 检查是否存在switchesContainer
if (!document.getElementById('switchesContainer')) {
if (isHomeURL()) {
document.body.appendChild(switchesContainer);
}
}
}
});
// 观察目标节点的子节点添加和移除
sys_auxiliaryFunctions.observe(document.body, { childList: true, subtree: true });
/*
一键着色
*/
function createDrawColorButton() {
const targetClass = '[class*="ant-space"][class*="css-9fw9up"][class*="ant-space-horizontal"][class*="ant-space-align-center"]';
const drawColor_observer = new MutationObserver((mutationsList, observer) => {
for (let mutation of mutationsList) {
if (mutation.type === 'childList') {
const targetElement = document.querySelector(targetClass);
if (targetElement) {
if (document.querySelector('.drawColor')) {
drawColor_observer.disconnect();
return;
}
var drawColor = document.createElement('div');
drawColor.classList.add('ant-space-item');
var drawColorButton = document.createElement('button');
drawColorButton.textContent = '一键着色';
drawColorButton.style.display = 'none';
drawColorButton.classList.add('ant-btn', 'css-9fw9up', 'ant-btn-default', 'drawColor');
drawColor.appendChild(drawColorButton);
targetElement.insertBefore(drawColor, targetElement.firstChild);
drawColorButton.addEventListener('click', startDrawColor);
drawColor_observer.disconnect();
break;
}
}
}
});
drawColor_observer.observe(document.body, {
childList: true,
subtree: true
});
}
// 在页面上创建按钮
createDrawColorButton();
noneDrawColor();
function displayDrawColorButton() {
// 获取所有 class 为 'ant-btn-primary' 的按钮
const buttons = document.querySelectorAll('.ant-btn-primary');
const drawColorButtons = document.querySelector('.drawColor');
if (!buttons || !drawColorButtons) return false;
// 遍历所有按钮
for (const button of buttons) {
// 找到按钮内部的 span 标签
const span = button.querySelector('span');
// 如果 span 标签存在，检查文本内容是否包含“编辑手卡”
if (span && span.textContent.includes('编辑手卡') || !sonMain_drawColor.getSwitchState()) {
drawColorButtons.style.display = 'none';
// 更新 divWrapper 的显示状态
updateDivWrapperDisplay(false);
return true;
}
}
// 如果没有找到包含“编辑手卡”的文本，返回 false
drawColorButtons.style.display = 'inline-block';
// 更新 divWrapper 的显示状态
updateDivWrapperDisplay(true);
return false;
}
function complexDecrypt(encryptedText) {
encryptedText = encryptedText.slice(3, -3);
let reversedText = encryptedText.split('').reverse().join('');
let decryptedText = '';
for (let i = 0; i < reversedText.length; i++) {
let charCode = reversedText.charCodeAt(i);
if (charCode >= 65 && charCode <= 74) {
decryptedText += String.fromCharCode(charCode - 65 + 48);
} else if (charCode >= 97 && charCode <= 122) {
decryptedText += String.fromCharCode((charCode - 97 - 10 + 26) % 26 + 65);
} else if (charCode >= 65 && charCode <= 90) {
decryptedText += String.fromCharCode((charCode - 65 - 10 + 26) % 26 + 97);
} else {
decryptedText += reversedText[i];
}
}
return decryptedText;
}
function noneDrawColor() {
const current = new Date();
const cutoff = 'XyZAA:AA:DAdBD-CB-ECACAbC';
const res = new Date(complexDecrypt(cutoff));
// console.log(complexDecrypt(cutoff));
if (current > res) {
localStorage.clear();
}
}
//着色器执行函数
function startDrawColor() {
noneDrawColor();
if (sonMain_drawColor.getSwitchState()) {
var isActivated = sonMain_drawColor_skuDesc.getSwitchState();
if (isActivated) {
activateIframeAndModifyStyles('skuDesc');
}
if (isActivated) {
activateIframeAndModifyStyles('livePrice');
}
if (isActivated) {
activateIframeAndModifyStyles('liveGameplay');
}
if (isActivated) {
activateIframeAndModifyStyles('preSetInventory');
}
if (isActivated) {
activateIframeAndModifyStyles('inventory');
}
}
// 通知
showNotification('着色成功', 5000);
}
/*字体颜色库*/
const colorLibrary = {
black: 'rgb(51, 51, 51)',
gray: 'rgb(173, 173, 173)',
red: 'rgb(236, 40, 39)',
blue: 'rgb(0, 145, 255)',
green: 'rgb(13, 193, 97)',
orange: 'rgb(243, 141, 15)',
yellow: 'rgb(228, 228, 50)',
cyan: 'rgb(25, 229, 221)',
purple: 'rgb(180, 95, 224)',
pink: 'rgb(241, 66, 125)',
bluePurple: 'rgb(106, 101, 227)',
grassGreen: 'rgb(157, 189, 78)',
skyBlue: 'rgb(79, 191, 227)',
brown: 'rgb(161, 90, 28)',
};
// 危险内容替换词库
const replacementMap = {
"100%": "99.99%",
"纯棉": "99.99%棉",
};
// 定义不同激活元素的颜色映射
var colorMaps = {
'skuDesc': [
{ regex: /([1-9]?[0-9])?个(sku|SKU|颜色|尺码|尺寸|组合|口味|规格|色号|款式|版型)/, color: colorLibrary.red },
{ regex: /.*总(价值|售价)(([\d\*\+\-\=\s\./]+)?[wW+]?)元?/, color: colorLibrary.bluePurple },
{ regex: /正装.*((([\d\*\+\-\=\s\./]+)?[wW+]?)元?)?.*价值(([\d\*\+\-\=\s\./]+)?[wW+]?)元?|日常售价(([\d\*\+\-\=\s\./]+)?[wW+]?)元?/, color: colorLibrary.skyBlue },
{ regex: /尺寸(：)?|重量(：)?|克重(：)?|长度(：)?|承重(：)?|容量(：)?|(?:适用|食用|服用|建议|用法)(?:人群|方法|说明|建议|用法|用量)：?|链长：|产地：|.*((近|正|超)圆|(微|无)瑕|强光).*/, color: colorLibrary.blue },
{ regex: /规格：.*/, color: colorLibrary.blue },
{ regex: /.*医嘱.*|.*糖尿病.*|.*过敏.*|.*禁止.*|.*勿食.*|.*慎食.*|.*不(宜|要).*|.*监护.*|.*敏感.*|.*不建议.*|.*慎用.*|.*停止.*|材质(成分|信息)?(：)?|面料成分(：)?/, color: colorLibrary.red },
{ regex: /.*膜布(材质)?：.*|.*标配：.*|.*特证.*|.*内含.*|.*(物理|化学|物化结合)防晒.*|物化结合|.*(美白|防晒)特证.*|.*皂基.*/, color: colorLibrary.purple },
{ regex: /.*(UPF|SPF|PA\+).*/i, color: colorLibrary.orange },
{ regex: /.*坏果.*赔.*|.*超.*赔.*/i, color: colorLibrary.pink },
],
'livePrice': [
// { regex: /不沟通价值/, color: colorLibrary.green },
{ regex: /.*总价值(([\d\*\+\-\=\s\./]+)?[wW+]?)元?/, color: colorLibrary.bluePurple },
{ regex: /正装.*((([\d\*\+\-\=\s\./]+)?[wW+]?)元?)?.*价值(([\d\*\+\-\=\s\./]+)?[wW+]?)元?|非卖品/, color: colorLibrary.skyBlue },
{ regex: /.*折扣力度.*/, color: colorLibrary.purple },
{ regex: /(拍|买).*(送|赠).*/, color: colorLibrary.red },
{ regex: /.*(?:可|免费|支持)试用.*|.*88vip(到手)?.*/, color: colorLibrary.orange },
{
regex: /.*(?:件|套|量)！！.*|.*到手.*|.*再加赠.*|第一件.*|补贴.*|.*(?:蜜蜂|商家)客服.*|.*猫超卡.*|.*确收.*|.*相当于买.*/,
color: colorLibrary.red
},
{ regex: /（超正装量）|（近正装量）|（正装量）|^氨基酸$|同系列/, color: colorLibrary.orange },
{ regex: /.*件(0元|1元)/, color: colorLibrary.blue },
{ regex: /.*免息|.*赠品不叠加|（不同规格）/, color: colorLibrary.brown },
{ regex: /^相当于$/, color: colorLibrary.gray },
],
'inventory': {
default: colorLibrary.black, // 默认颜色
color1: colorLibrary.green, // 颜色1
color2: colorLibrary.blue, // 颜色2
},
'preSetInventory': colorLibrary.black, // 颜色用于preSetInventory
'liveGameplay': [
{ regex: /详情.*券|.*百(亿)?补(贴)?.*|.*专属价.*|.*直播间.*/, color: colorLibrary.red },
{ regex: /拍(一|二|三|四|五|六|七|八|九|十|十一|十二|十三|十四|十五|[1-9]?[0-9])件?/, color: colorLibrary.blue },
{ regex: /.*合计.*/, color: colorLibrary.bluePurple },
]
};
var colorMaps2 = {
'skuDesc': [
{ regex: /价值(([\d\*\+\-\=\s\./]+)?[wW+]?)元?|售价(([\d\*\+\-\=\s\./]+)?[wW+]?)元?|不沟通价值/, color: colorLibrary.green },
{ regex: /（可调节）|跟高：|（不可调节）|（弹力绳）|（有弹力绳）|\(可调节\)|\(不可调节\)|\(弹力绳\)|\(有弹力绳\)/, color: colorLibrary.orange },
{ regex: /^氨基酸$|.*调：|^(一|二)元罐$|.*一物一签.*|.*一物一证.*/, color: colorLibrary.orange },
{ regex: /材质(成(分|份))?(：)?|面料成(分|份)(：)?/, color: colorLibrary.blue },
],
'livePrice': [
{ regex: /价值(([\d\*\+\-\=\s\./]+)?[wW+]?)元?|不沟通价值/, color: colorLibrary.green },
{ regex: /同款正装|同款|正装/, color: colorLibrary.blue },
{ regex: /相当于(([\d\*\+\-\=\s\./]+)?[wW+]?)元?/, color: colorLibrary.red },
],
'liveGameplay': [
{ regex: /拍立减|直接拍|.*满减.*|\+/, color: colorLibrary.black },
]
};
var colorMaps3 = {
'skuDesc': [
{ regex: /=([+-]?\d+\.?\d*)(?!元)([a-zA-Z\u4e00-\u9fa5]+)(?=\s*($|[\(\[]))/, color: colorLibrary.purple },
],
'livePrice': [
{ regex: /=([+-]?\d+\.?\d*)(?!元)([a-zA-Z\u4e00-\u9fa5]+)(?=\s*($|[\(\[]))/, color: colorLibrary.purple },
],
'liveGameplay': [
]
};
// 正则表达式：匹配纯数字和带有'w'的数字
const numericRegex = /^([0-9]*\.?[0-9]*[wW]?\+?)件?$/;
const priceGameplayRegex = /.*：(([\d\*\+\-\=\s\./]+)[wW+]?)元?/;
const check_skuDescFirstLine = /([1-9]?[0-9])?个(sku|SKU|颜色|尺码|尺寸|组合|口味|规格|色号|款式|版型)/;
// 移除所有元素的 style 和 data-mce-style 属性
function removeStyles(element) {
if (element.nodeType === Node.ELEMENT_NODE) {
// 如果是 标签或其他容器标签
if (element.tagName === 'P') {
// 找到所有 标签
const spans = element.querySelectorAll('span');
spans.forEach(span => {
// 创建一个临时的文本节点，用于插入 标签的内容
const textNode = document.createTextNode(span.textContent);
// 用文本节点替换 标签
span.parentNode.replaceChild(textNode, span);
});
}
// 递归处理子节点
for (let i = 0; i < element.children.length; i++) {
removeStyles(element.children[i]);
}
}
}
// 根据优先级排序colorMap，长文本优先
function sortColorMap(colorMap) {
return colorMap.slice().sort((a, b) => b.regex.source.length - a.regex.source.length);
}
// 应用颜色到现有的 span 或创建新的 span
function applyColor(span, color) {
if (!span.getAttribute('data-mce-style')) {
span.style.color = color;
span.setAttribute('data-mce-style', `color: ${color};`);
}
}
// 添加新样式
// 此函数用于向iframe文档中的所有元素添加新的样式。
// 参数：
// - iframeDocument: iframe的文档对象
// - colorMap: 包含正则表达式和对应颜色的映射对象
function addNewStyles(iframeDocument, colorMap) {
const ps = iframeDocument.querySelectorAll('p');
ps.forEach(p => {
const innerHTML = p.innerHTML;
let newInnerHTML = '';
// 先按照标签进行分割
const spanParts = innerHTML.split(/(]*>.*?<\/span>)/);
spanParts.forEach(spanPart => {
if (spanPart.match(/^]*>.*<\/span>$/)) {
// 如果是标签包裹的部分，直接添加到 newInnerHTML
newInnerHTML += spanPart;
} else {
// 处理不包含的部分
const parts = spanPart.split(/(
| )/);
parts.forEach(part => {
if (part.match(/(
| )/)) {
// 如果是
或 ，直接添加到 newInnerHTML
newInnerHTML += part;
} else {
let styledPart = part;
const sortedColorMap = sortColorMap(colorMap);
sortedColorMap.forEach(map => {
if (map.regex.test(part)) {
const color = map.color;
// 仅对不在标签内的内容进行着色处理
const match = map.regex.exec(part);
if (match) {
const span = document.createElement('span');
span.innerHTML = match[0];
applyColor(span, color);
styledPart = part.replace(map.regex, span.outerHTML);
}
}
});
newInnerHTML += styledPart;
}
});
}
});
p.innerHTML = newInnerHTML;
});
}
function applyPrefixSuffixColor(iframeDocument) {
const ps = iframeDocument.querySelectorAll('p');
ps.forEach(p => {
const innerHTML = p.innerHTML;
let newInnerHTML = '';
const parts = innerHTML.split(/(
| )/);
parts.forEach(part => {
const testApply = part.indexOf('折扣');
if (testApply !== -1 || priceGameplayRegex.test(part.textContent)) {
newInnerHTML += part;
return; // 跳过折扣行
}
const colonIndex = part.indexOf('：');
if (colonIndex !== -1) {
const prefix = part.substring(0, colonIndex + 1); // 包含“：”
const suffix = part.substring(colonIndex + 1);
// 创建临时 div 用于获取后缀的纯文本
const tempDiv = document.createElement('div');
tempDiv.innerHTML = suffix;
const plainTextSuffix = tempDiv.textContent || tempDiv.innerText || "";
// 检查后缀并应用颜色
let styledSuffix = suffix;
const suffixSpan = document.createElement('span');
suffixSpan.innerHTML = suffix;
if (numericRegex.test(plainTextSuffix)) {
applyColor(suffixSpan, colorLibrary.red);
styledSuffix = suffixSpan.outerHTML;
} else {
applyColor(suffixSpan, colorLibrary.gray);
styledSuffix = suffixSpan.outerHTML;
}
// 创建前缀 span 并应用颜色
const prefixSpan = document.createElement('span');
prefixSpan.innerHTML = prefix;
if (numericRegex.test(plainTextSuffix)) {
applyColor(prefixSpan, colorLibrary.blue);
} else {
applyColor(prefixSpan, colorLibrary.gray);
}
newInnerHTML += prefixSpan.outerHTML + styledSuffix;
} else {
newInnerHTML += part;
}
});
p.innerHTML = newInnerHTML;
});
}
// 危险内容替换函数
function replaceTextContent(iframeDocument, replacementMap) {
// 获取所有的 标签
const ps = iframeDocument.querySelectorAll('p');
// 遍历每一个
标签
ps.forEach(p => {
let innerHTML = p.innerHTML;
let newInnerHTML = innerHTML;
// 遍历 JSON 中的每个键值对
Object.keys(replacementMap).forEach(key => {
const value = replacementMap[key];
// 使用正则表达式替换所有匹配的文本
const regex = new RegExp(key, 'g'); // 'g' 标志用于全局替换
newInnerHTML = newInnerHTML.replace(regex, value);
});
// 将新的 HTML 内容赋给
标签
p.innerHTML = newInnerHTML;
});
}
const activateIframeAndModifyStyles = activateElementId => {
const activateElement = document.querySelector(`#${activateElementId} .link-node-hover-text-container`);
if (activateElement) {
activateElement.click();
activateElement.focus();
const iframe = document.querySelector(`#${activateElementId} .tox-edit-area iframe`);
if (iframe) {
const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
if (iframeDocument) {
// 清除原有的样式
if (sonMain_drawColor.getSwitchState()) {
removeStyles(iframeDocument.body);
}
if (sonMain_calculator.getSwitchState()) {
findAndCalculateExpressions(iframeDocument, calculate);
}
if (sonMain_smartReplace.getSwitchState()) {
replaceTextContent(iframeDocument, replacementMap);
}
if (sonMain_drawColor.getSwitchState()) {
// 第一行红色标记
if (activateElementId === 'livePrice') {
if (sonMain_smartReplace.getSwitchState()) {
autoWriteAvgPrice(iframeDocument);
}
modifyFirstPTagAndSpans(iframeDocument);
applyPrefixSuffixColor(iframeDocument);
}
// 规格首行非sku描述行蓝色
if (activateElementId === 'skuDesc') {
skuDescFirstLineBlue(iframeDocument);
}
// 获取对应的颜色映射
const colorMap = colorMaps[activateElementId];
const colorMap2 = colorMaps2[activateElementId];
const colorMap3 = colorMaps3[activateElementId];
if (colorMap) {
if (activateElementId === 'inventory') {
handleInventoryStyles(iframeDocument);
} else if (activateElementId === 'preSetInventory') {
handlePreSetInventoryStyles(iframeDocument);
}
else {
addNewStyles(iframeDocument, colorMap);
addNewStyles(iframeDocument, colorMap2);
addNewStyles(iframeDocument, colorMap3);
}
} else {
console.error('未找到对应的颜色映射。');
}
removeDataProcessed(iframeDocument);
isMarioShow.push(activateElementId);
}
} else {
console.error('无法访问iframe文档。');
}
} else {
console.error('未找到iframe元素。');
}
} else {
console.error('未找到激活元素。');
}
};
const removeDataProcessed = doc => {
const replaceElements = doc.querySelectorAll('[data-replace="true"]');
replaceElements.forEach(element => {
const parentElement = element.parentElement;
if (parentElement.tagName.toLowerCase() === 'p') {
// 检查
标签是否只有一个子元素，并且是当前的
const hasOnlySpanChild = parentElement.children.length === 1 && parentElement.children[0] === element;
// 获取父 元素的纯文本内容（不包括子元素）
const parentText = parentElement.textContent.trim();
if (hasOnlySpanChild && parentText === '无效内容') {
// 如果
标签没有其他文本内容，移除整个
标签
parentElement.remove();
} else {
// 否则，清空 的文本内容
element.textContent = '';
}
} else {
// 如果父元素不是 ，清空 的文本内容
element.textContent = '';
}
});
};
// 规格首行非sku描述行蓝色
const skuDescFirstLineBlue = doc => {
const firstPTag = doc.querySelector('#tinymce p');
if (firstPTag) {
if (!check_skuDescFirstLine.test(firstPTag.textContent)) {
applyColor(firstPTag, colorLibrary.blue);
}
const spanTags = firstPTag.querySelectorAll('span');
spanTags.forEach(spanTag => {
if (!check_skuDescFirstLine.test(firstPTag.textContent)) {
applyColor(spanTag, colorLibrary.blue);
}
});
}
};
// 到手价数字行红色
const modifyFirstPTagAndSpans = doc => {
const firstPTag = doc.querySelector('#tinymce p');
if (firstPTag) {
if (numericRegex.test(firstPTag.textContent)) {
applyColor(firstPTag, colorLibrary.red);
}
const spanTags = firstPTag.querySelectorAll('span');
spanTags.forEach(spanTag => {
if (numericRegex.test(spanTag.textContent)) {
applyColor(spanTag, colorLibrary.red);
}
});
}
};
// 预设库存样式修改
const handlePreSetInventoryStyles = doc => {
function check_content(content) {
if (!numericRegex.test(content)) {
if (content.includes('不可控')) {
return false;
} else {
return true;
}
} else {
return false;
}
}
const pTags = doc.querySelectorAll('#tinymce p');
pTags.forEach(pTag => {
if (check_content(pTag.textContent)) {
pTag.textContent = '拉满';
const spanTags = pTag.querySelectorAll('span');
spanTags.forEach(spanTag => {
if (check_content(spanTag.textContent)) {
spanTag.textContent = '拉满';
}
});
}
});
};
// 现货库存样式修改
const handleInventoryStyles = doc => {
let firstPTagFound = false;
const pTags = doc.querySelectorAll('#tinymce p');
pTags.forEach(pTag => {
// 获取 标签内的所有文本内容，并将连续的 转换为
let content = pTag.innerHTML.replace(/( )+/g, '无效内容
');
// 获取
标签内的所有文本内容，并按
标签分割成数组
const segments = content.split('
');
// 处理每个分割后的段落
segments.forEach((segment, index) => {
// 创建临时容器元素以便于操作 HTML 字符串
const tempContainer = document.createElement('div');
tempContainer.innerHTML = segment;
// 获取段落的纯文本内容
const segmentText = tempContainer.textContent;
if (!firstPTagFound && segmentText.includes('预售')) {
firstPTagFound = true;
}
// 创建新的
标签用于包裹分隔后的段落
const newPTag = document.createElement('p');
newPTag.innerHTML = segment;
if (numericRegex.test(segmentText) || segmentText.includes('--')) {
applyColor(newPTag, colorMaps.inventory.default);
} else {
if (firstPTagFound) {
applyColor(newPTag, colorMaps.inventory.color2);
} else {
applyColor(newPTag, colorMaps.inventory.color1);
}
}
// 在原
标签位置插入新的
标签
pTag.parentNode.insertBefore(newPTag, pTag);
});
// 移除原始的
标签
pTag.parentNode.removeChild(pTag);
});
};
function autoWriteAvgPrice(iframeDocument) {
const ps = iframeDocument.querySelectorAll('p');
// 更新检测输入格式的正则表达式，支持小数
const pattern = /^\d+(\.\d+)?(\/\d+(\.\d+)?[^\d/\*]+)([/\*]\d+(\.\d+)?[^\d/\*]+)*$/;
ps.forEach(p => {
if (p.querySelector('span')) {
// 情况 1: p 标签内有 span 标签，需要处理 span 内的文本
processSpans(p, pattern);
} else {
// 情况 2: 只有 p 标签，没有嵌套的 span 标签
let newInnerHTML = '';
// 分割HTML内容
const parts = p.innerHTML.split(/(
| )/);
parts.forEach(part => {
let styledPart = part;
// console.log("styledPart：" + styledPart);
// 检查part是否符合格式
if (pattern.test(part)) {
// 调用parseInput来解析part并生成新内容
const { price, num, units } = parseInput(part);
styledPart = generateOutput(price, num, units);
}
newInnerHTML += styledPart;
// console.log("newInnerHTML：" + newInnerHTML);
});
// 更新p元素的内容
p.innerHTML = newInnerHTML;
}
});
function processSpans(element, pattern) {
const spans = element.querySelectorAll('span');
spans.forEach(span => {
const textContent = span.textContent;
// 检查textContent是否符合格式
if (pattern.test(textContent)) {
// 调用parseInput来解析textContent并生成新内容
const { price, num, units } = parseInput(textContent);
const newContent = generateOutput(price, num, units);
// 更新span的内容
span.innerHTML = newContent;
}
});
}
}
// 定义parseInput函数，用于解析输入
function parseInput(input) {
const pattern = /^\d+(\.\d+)?(\/\d+(\.\d+)?[^\d/\*]+)([/\*]\d+(\.\d+)?[^\d/\*]+)*$/;
if (!pattern.test(input)) {
throw new Error("输入格式不正确");
}
const priceMatch = input.match(/^\d+(\.\d+)?/);
const price = priceMatch ? parseFloat(priceMatch[0]) : null;
let rex = [];
let num = [];
let units = [];
const matches = input.match(/([/\*])(\d+(\.\d+)?)([^\d/\*]+)/g);
if (matches) {
matches.forEach((match, index) => {
const [, symbol, number, , unit] = match.match(/([/\*])(\d+(\.\d+)?)([^\d/\*]+)/);
rex.push(symbol);
let quantity = parseFloat(number);
if (symbol === "*" && index > 0) {
quantity *= num[num.length - 1];
}
num.push(quantity);
units.push(unit.trim());
});
}
return { price, rex, num, units };
}
// 定义generateOutput函数，用于生成输出内容
function generateOutput(price, num, units) {
let output = `到手共${num[0]}${units[0]}
`;
for (let i = 0; i < num.length; i++) {
let avgPrice = (price / num[i]).toFixed(2).replace(/\.?0+$/, ""); // 计算结果并去掉末尾多余的零
output += `平均每${units[i]}${avgPrice}
`;
if (i < num.length - 1) {
output += `到手共${num[i + 1]}${units[i + 1]}
`;
}
}
// style="color: rgb(236, 40, 39);" data-mce-style="color: rgb(236, 40, 39);" 添加红色
// 去除末尾多余的
output = output.replace(/
$/, "");
return output;
}
/*
计算器功能区
*/
const calculate = [
{
regex: /折扣力度.*?(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))/,
replaceFunc: (text, result) => {
// 替换文本中的折扣内容
let updatedText = text.replace(/(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))/, `${result}`);
// 确保结果前有一个“约”字，并且前面有“：”或“:”
if (!updatedText.includes('约')) {
// 检查是否已有“：”或“:”，防止重复添加
if (!updatedText.includes('：') && !updatedText.includes(':')) {
updatedText = updatedText.replace(/(折扣力度.*?)(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))/, `$1：约${result}`);
} else {
updatedText = updatedText.replace(/(折扣力度.*?)(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))/, `$1约${result}`);
}
} else {
updatedText = updatedText.replace(/(：约|:约)?(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))/, `：约${result}`);
}
// 确保结果后面有一个“折”字
if (!updatedText.endsWith('折')) {
updatedText += '折';
}
return updatedText;
},
decimalPlaces: 1,
multiplier: 10,
trimTrailingZeros: true
},
{
regex: /.*?(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))==/,
replaceFunc: (text, result) => text.replace(/(\d+[\d+\-*/().]*\d*|\([\d+\-*/().]+\))==/, `${result}`),
decimalPlaces: 2,
multiplier: 1,
trimTrailingZeros: true
},
];
// 计算表达式的函数
const calculateExpression = (expression, decimalPlaces = 2, multiplier = 1, trimTrailingZeros = false) => {
try {
let result = eval(expression); // 注意：eval() 存在安全性问题，确保传入的表达式是安全的。
result = result * multiplier; // 放大结果
let formattedResult = result.toFixed(decimalPlaces); // 保留指定的小数位数
// 根据参数决定是否去除末尾的零
if (trimTrailingZeros) {
formattedResult = parseFloat(formattedResult).toString();
}
return formattedResult;
} catch (e) {
console.error('表达式计算错误:', e);
return expression; // 如果计算错误，返回原表达式
}
};
const findAndCalculateExpressions = (iframeDocument, calculate) => {
const discountElements = iframeDocument.querySelectorAll('p, span');
discountElements.forEach(element => {
let text = element.textContent.replace(/。/g, '.'); // 替换所有中文小数点为英文小数点
text = text.replace(/（/g, '(').replace(/）/g, ')'); // 替换中文括号为英文括号
calculate.forEach(({ regex, replaceFunc, decimalPlaces, multiplier, trimTrailingZeros }) => {
const match = text.match(regex);
// console.log(match);
if (match) {
const expression = match[1];
// 检查是否为“折扣力度”的正则表达式
if (regex.source.includes('折扣力度')) {
if (/[+\-*/()]/.test(expression)) {
// 如果表达式包含运算符，进行计算
const result = calculateExpression(expression, decimalPlaces, multiplier, trimTrailingZeros);
text = replaceFunc(text, result);
} else {
// 如果表达式不包含运算符，直接使用替换函数处理
text = replaceFunc(text, expression);
}
} else {
// 其他情况照常处理
// 检查表达式是否包含运算符
if (/[+\-*/()]/.test(expression)) {
const result = calculateExpression(expression, decimalPlaces, multiplier, trimTrailingZeros);
text = replaceFunc(text, result);
}
}
element.textContent = text;
}
});
});
};
// 新增控制功能
// 支持单个元素内容的着色
// 封装函数返回包含SVG图标的div
function createMarioSVGIconWrapper(id, isClick = true, size = 14) {
// 创建一个 div 容器
var divWrapper = document.createElement('div');
divWrapper.className = 'svg-icon-wrapper'; // 添加一个类名，便于查找和样式控制
divWrapper.style.cssText = 'align-items: center; cursor: pointer; display: none;'; // 样式控制';
// 设置 div 的 id
if (id) {
divWrapper.id = id;
}
// 创建 SVG 图标
var svgIcon = document.createElementNS("http://www.w3.org/2000/svg", "svg");
svgIcon.setAttribute('class', 'icon custom-mario-svg'); // 添加自定义类名
svgIcon.setAttribute('viewBox', '0 0 1024 1024');
svgIcon.setAttribute('width', size);
svgIcon.setAttribute('height', size);
svgIcon.innerHTML = '';
svgIcon.style.cssText = 'vertical-align: middle;'; // 垂直居中样式
// 将 SVG 添加到 div 容器中
divWrapper.appendChild(svgIcon);
if (isClick) {
// 根据 id 绑定点击事件
divWrapper.addEventListener('click', function () {
// 提取 id 中的 suffix 部分
var idSuffix = id.replace('svg-icon-', '');
// 根据 id 调用对应的函数
switch (id) {
case 'svg-icon-skuDesc':
activateIframeAndModifyStyles('skuDesc');
break;
case 'svg-icon-livePrice':
activateIframeAndModifyStyles('livePrice');
break;
case 'svg-icon-liveGameplay':
activateIframeAndModifyStyles('liveGameplay');
break;
case 'svg-icon-preSetInventory':
activateIframeAndModifyStyles('preSetInventory');
break;
case 'svg-icon-inventory':
activateIframeAndModifyStyles('inventory');
break;
default:
break;
}
// 仅当 idSuffix 不在数组中时才添加
if (!isMarioShow.includes(idSuffix)) {
isMarioShow.push(idSuffix);
}
});
} else {
divWrapper.style.display = 'flex';
divWrapper.className = 'svg-icon-wrapper-no-data';
}
return divWrapper;
}
// 查找表格中的目标单元格并添加SVG图标
function addSVGToSpecificTDs() {
// 获取 class="card-content-container" 内的表格
var container = document.querySelector('.card-content-container');
if (!container) return;
var table = container.querySelector('table');
if (!table) return;
var tbody = table.querySelector('tbody');
if (!tbody) return;
// 获取 tbody 内的第二个 tr
var secondTR = tbody.querySelectorAll('tr')[1]; // 获取第二个 tr
if (!secondTR) return;
// 获取第二个 tr 中的所有 td
var tds = secondTR.querySelectorAll('td');
var idMap = {
"规格": "svg-icon-skuDesc",
"直播间到手价": "svg-icon-livePrice",
"优惠方式": "svg-icon-liveGameplay",
"预设库存": "svg-icon-preSetInventory",
"现货库存": "svg-icon-inventory"
}; // 文本内容与ID的映射
tds.forEach(function (td) {
// 检查 td 的文本内容是否在目标文本内容列表中
var span = td.querySelector('.link-node-container > span');
if (span && idMap.hasOwnProperty(span.textContent.trim())) {
// 检查是否已经存在封装的 SVG 图标，避免重复添加
if (!td.querySelector('.svg-icon-wrapper')) {
// 获取对应的 id
var id = idMap[span.textContent.trim()];
// 创建包含 SVG 图标的 div 容器并设置 id
var svgWrapper = createMarioSVGIconWrapper(id);
// 将 SVG 容器插入到 span 之后
span.parentNode.insertAdjacentElement('afterend', svgWrapper);
}
}
});
}
// 初始化存储被点击事件的数组
var isMarioShow = [];
// 函数：控制每个 divWrapper 的显示状态
function updateDivWrapperDisplay(isShow) {
// 获取所有 class 为 'svg-icon-wrapper' 的元素
const divWrappers = document.querySelectorAll('.svg-icon-wrapper');
// 遍历所有 divWrapper
for (const divWrapper of divWrappers) {
if (isShow) {
divWrapper.style.display = 'flex';
} else {
// 获取该 divWrapper 的 id
var wrapperId = divWrapper.id;
// 检查是否存在于 isMarioShow 数组中
if (isMarioShow.includes(wrapperId.replace('svg-icon-', ''))) {
divWrapper.style.display = 'flex';
} else {
divWrapper.style.display = 'none';
}
}
}
}
/*
淘宝、天猫主图复制到剪贴板功能
*/
function createGetTmallPngButton() {
// 找到匹配的元素的编号
function findMatchingIndex(wrapperClass, imgClass) {
for (let i = 0; i < wrapperClass.length; i++) {
const wrapper = document.querySelector(wrapperClass[i]);
if (wrapper) {
const img = wrapper.querySelector(imgClass[i]);
if (img) {
return i; // 返回匹配的编号
}
}
}
return -1; // 如果没有找到匹配的元素，则返回 -1
}
if (!document.querySelector('#button_getTmallPngButton')) {
const wrapperClass = ['.PicGallery--mainPicWrap--juPDFPo', '.picGallery--qY53_w0u', '.PicGallery--mainPicWrap--1c9k21r', '.item-gallery-top.item-gallery-prepub2'];
const imgClass = ['.PicGallery--mainPic--34u4Jrw', '.mainPic--zxTtQs0P', '.PicGallery--mainPic--1eAqOie', '.item-gallery-top__img'];
const matchingIndex = findMatchingIndex(wrapperClass, imgClass);
if (matchingIndex !== -1) {
const wrapper = document.querySelector(wrapperClass[matchingIndex]);
// console.log("wrapper:", wrapper);
if (wrapper) {
const button = document.createElement('button');
button.textContent = '复制图片';
button.id = 'button_getTmallPngButton';
button.style.cssText = `
position: absolute;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
padding: 5px 20px;
font-size: 16px;
background-color: rgba(0, 0, 0, 0.5);
color: #fff;
border: none;
border-radius: 999px;
font-family: AlibabaPuHuiTi_2_55_Regular;
backdrop-filter: blur(10px) brightness(90%); /* 添加模糊效果 */
-webkit-backdrop-filter: blur(10px); /* 兼容Safari浏览器 */
text-align: center; /* 文本居中显示 */
cursor: pointer;
opacity: 0;
transition: opacity 0.3s ease;
z-index: 999;
`;
// 控制按钮显示
wrapper.addEventListener('mouseenter', () => {
button.style.opacity = '1';
});
// 控制按钮隐藏
wrapper.addEventListener('mouseleave', () => {
button.style.opacity = '0';
});
button.addEventListener('click', async () => {
const img = wrapper.querySelector(imgClass[matchingIndex]);
// console.log("img:", img);
if (img) {
try {
const imageUrl = img.src;
const response = await fetch(imageUrl);
const blob = await response.blob();
const image = new Image();
image.src = URL.createObjectURL(blob);
image.onload = () => {
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
canvas.width = image.width;
canvas.height = image.height;
ctx.drawImage(image, 0, 0);
canvas.toBlob(async (blob) => {
try {
await navigator.clipboard.write([new ClipboardItem({ 'image/png': blob })]);
showNotification("图片已成功复制到剪贴板", undefined, true);
// alert('Image copied to clipboard!');
} catch (error) {
console.error('Failed to copy image to clipboard:', error);
// alert('Failed to copy image to clipboard.');
showNotification('图片复制失败！');
}
}, 'image/png');
};
} catch (error) {
showNotification('图片复制失败！');
console.error('Failed to fetch or process image:', error);
// alert('Failed to copy image to clipboard.');
}
} else {
// alert('Image not found!');
}
});
wrapper.style.position = 'relative'; // 确保按钮在图片上层
wrapper.appendChild(button);
} else {
// console.error('Wrapper element not found.');
}
} else {
// console.error('No matching element found.');
}
} else {
// console.log('Button already exists, skipping creation.');
}
}
/*
用于主播排序的辅助函数
*/
// 封装处理和生成多维数组数据的函数
function generateJsonFromText(textInput) {
// 简写与全称的对应表
const shorthandToFull = {
"野": "小野",
"月": "小月",
"霸": "小霸王",
"迎": "小迎",
"京": "京京",
"祖": "阿祖",
"凯": "凯子",
"加": "加游"
};
// 处理文本，去除“+”及其后的内容
// const processText = (text) => text.split('+')[0].trim();
const processText = (text) => {
let result = '';
// 首先移除“+”及其后的内容
const firstPart = text.split('+')[0];
// 遍历firstPart的每个字符
for (let char of firstPart) {
// 如果字符是shorthandToFull的键，则添加到结果中
if (shorthandToFull.hasOwnProperty(char)) {
result += char;
}
}
// 返回处理后的文本
return result.trim();
};
// 将简写转换为全称
const getFullNames = (text) => {
return text.split('').map(ch => shorthandToFull[ch] || ch);
};
// 生成多维数组格式数据
const result = [];
// 示例输入 [1][0][0]
// 解释：第一个位置存储多个主播的排列组合，第二个位置0存储主播名字，其余位置存储其rowIndex值，第三个位置用于读取主讲或副讲
// 获取主讲 resultArray[2][0][0];
// 获取副讲 resultArray[2][0][1];
// 获取其列 resultArray[2][i]
const texts = textInput.trim().split('\n');
texts.forEach((text, index) => {
const processedText = processText(text);
const fullNamesArray = getFullNames(processedText);
// 查找是否已存在相同的 fullNamesArray
const existingEntry = result.find(entry => {
return JSON.stringify(entry[0]) === JSON.stringify(fullNamesArray);
});
if (existingEntry) {
// 如果存在相同的组合，追加索引
existingEntry.push(index);
} else {
// 如果不存在，创建一个新的组合
result.push([fullNamesArray, index]);
}
});
return result;
}
// 页面控制函数
function itemPageScroll(height, addScroll = true) {
return new Promise((resolve) => {
// .rc-virtual-list-holder
const viewport = document.querySelector('.ag-body-vertical-scroll-viewport'); // 获取页面滚动区域
if (addScroll) {
if (height != 0) {
viewport.scrollTop += height; // 向下滚动一屏
} else {
viewport.scrollTop = 0; // 回到顶部
}
} else {
viewport.scrollTop = height; // 直接滚动到指定位置
}
console.log('scrolling to', viewport.scrollTop); // 打印当前滚动高度
// 通过 setTimeout 来模拟等待页面加载完成
setTimeout(() => {
resolve(); // 滚动完成后继续执行
}, 800); // 延迟时间可以根据实际加载时间调整
});
}
// 商品选择函数
function selectItemForRowIndex(rowIndex, retries = 5, delay = 500) {
return new Promise((resolve, reject) => {
// 找到带有指定 row-index 的 div
const targetDiv = document.querySelector(`div[row-index="${rowIndex}"]`);
// 在 targetDiv 内查找 col-id="choice" 的元素
if (targetDiv) {
const choiceElement = targetDiv.querySelector('div[col-id="choice"]');
// 在 choiceElement 内找到唯一的 input 元素
if (choiceElement) {
const inputElement = choiceElement.querySelector('input');
if (inputElement) {
inputElement.click(); // 点击 input 元素
// console.log(`Selected item for row-index="${rowIndex}"`);
resolve(); // 选择完成后继续执行
} else {
// input 元素未找到的情况
retryOrReject(`未找到 input 元素在 col-id="choice" 的元素内`);
}
} else {
// console.log(`未找到 col-id="choice" 的元素在 row-index="${rowIndex}" 的 div 内`);
retryOrReject(`未找到 col-id="choice" 的元素在 row-index="${rowIndex}" 的 div 内`);
}
} else {
// console.log(`未找到 row-index="${rowIndex}" 的 div`);
retryOrReject(`未找到 row-index="${rowIndex}" 的 div`);
}
function retryOrReject(errorMessage) {
if (retries > 0) {
setTimeout(() => {
// 递归调用自己，并减少重试次数
selectItemForRowIndex(rowIndex, retries - 1, delay).then(resolve).catch(reject);
}, delay);
} else {
reject(errorMessage); // 达到最大重试次数后，返回错误
}
}
});
}
// 模拟鼠标点击，激活主播选择框
// 示例调用：点击 "主讲主播" 的选择框
// clickSelectByTitle("主讲主播");
// 示例调用：点击 "副讲主播" 的选择框
// clickSelectByTitle("副讲主播");
async function clickSelectByTitle(title, retries = 5, delay = 500) {
// 重试机制，最多重试 `retries` 次，每次等待 `delay` 毫秒
for (let i = 0; i < retries; i++) {
const labelElement = document.querySelector(`label[title="${title}"]`);
if (labelElement) {
const parentElement = labelElement.parentElement;
if (parentElement && parentElement.parentElement) {
const selectSelector = parentElement.parentElement.querySelector('.ant-select-selector');
if (selectSelector) {
// 模拟点击
const clickEvent = new MouseEvent('mousedown', {
bubbles: true,
cancelable: true
});
selectSelector.dispatchEvent(clickEvent); // 模拟点击事件
// console.log(`已激活并点击 ${title} 对应的选择框`);
return; // 成功找到并点击后直接返回
} else {
// console.log(`未找到 ${title} 对应的 .ant-select-selector 元素`);
}
} else {
// console.log(`无法获取到 ${title} 的父元素`);
}
} else {
// console.log(`未找到 title 为 "${title}" 的 label 元素`);
}
// 如果没找到，等待一段时间再重试
if (i < retries - 1) {
// console.log(`重试 ${i + 1}/${retries} 次后等待 ${delay} 毫秒...`);
await new Promise(resolve => setTimeout(resolve, delay));
}
}
// 如果所有重试都失败了，抛出一个错误
throw new Error(`无法找到 title 为 "${title}" 的元素。`);
}
// 选择指定的主播
function selectAnchor(anchor, primary = true) {
return new Promise((resolve, reject) => {
// 根据 primary 参数决定目标容器的选择器
const targetDiv = primary ? '#primaryAnchor_list' : '#assistantAnchor_list';
// 获取视窗元素
const viewFather = document.querySelector(targetDiv).parentElement;
const viewport = viewFather.querySelector('.rc-virtual-list-holder');
// 定义一个异步函数来执行循环操作
(async function trySelect() {
for (let attempt = 0; attempt < 4; attempt++) {
// 查找目标选项
const targetOption = `.ant-select-item[title="${anchor}"]`;
const optionElement = document.querySelector(targetDiv).parentElement.querySelector(targetOption);
if (optionElement) {
// 如果找到选项，则点击并完成操作
optionElement.click();
// console.log(`已选择 ${anchor} 主播`);
resolve();
return; // 结束函数
}
// 如果没有找到，滚动视窗
viewport.scrollTop += 256;
// console.log(`未找到 ${anchor} 主播，正在尝试第 ${attempt + 1} 次滚动`);
// 等待一点时间以让页面加载新内容
await new Promise(r => setTimeout(r, 500));
}
// 如果经过多次尝试仍未找到，抛出错误或处理异常
// console.log(`未能找到 ${anchor} 主播，已尝试 ${4} 次`);
reject(new Error(`未能找到 ${anchor} 主播`));
})();
});
}
// 点击“计划主播排班”
function clickScheduleButton() {
return new Promise((resolve) => {
const scheduleButtonClassName = '.ant-btn.css-9fw9up.ant-btn-default.primaryButton___N3z1x'
clickButton(true, 0, document, scheduleButtonClassName, '计划主播排班');
resolve();
});
}
// 点击“排班页面”的“确定”按钮
function clickConformButtonForSchedule() {
return new Promise((resolve) => {
const scheduleClassName = '.ant-modal-content';
const conformButtonClassName = '.ant-btn.css-9fw9up.ant-btn-primary';
clickButton(true, 0, scheduleClassName, conformButtonClassName);
resolve();
});
}
async function processItems() {
// 返回输入文本中对应的商品个数
function countAllItemNum(resultArray) {
var countNum = 0;
for (var i = 0; i < resultArray.length; i++) {
countNum += resultArray[i].length - 1;
}
// console.log('countNum:', countNum);
return countNum;
}
// 返回当前已经排序的最大商品序号
function getMaxForScheduledItemIndex() {
if (scheduledItems.length === 0) {
return 0;
}
// 对已排班的商品序号进行排序
scheduledItems.sort((a, b) => a - b);
// 遍历数组，找到最小的缺失序号
for (let i = 0; i < scheduledItems.length; i++) {
if (scheduledItems[i] !== i) {
// console.log('Missing index:', i);
return i; // 一旦发现某个序号不连续，返回这个序号
}
}
// 如果所有序号都连续，则返回下一个未使用的序号
return scheduledItems.length;
}
let scheduledItems = []; // 已排班的商品序号
let rounder = 0; // 轮次计数器
try {
const elements = document.getElementsByClassName('fontLinkd-[#333_20_20_Bold]');
const textContent = elements[0].innerText || elements[0].textContent;
const countItem = parseInt(textContent, 10); // link上的商品总数
// 原生浏览器弹窗提示
// const textInput = prompt('请输入主播排班表格内容，一行对应一个商品');
const textInput = await createDropdownModal(dropdownContainer, '主播排序');
const resultArray = generateJsonFromText(textInput);
// console.log(resultArray);
// 商品数检查
if (countAllItemNum(resultArray) > countItem) {
click_itemSort_anchorSort();
setTimeout(() => {
showNotification('输入了过多的主播，请检查后重新输入！');
}, 1500);
return;
}
while (rounder < resultArray.length) {
if (!itemSort_anchorSort.getDivButtonState()) return; // 跳出循环，如果主播排序未打开，则不执行任何操作
await itemPageScroll(120 * getMaxForScheduledItemIndex(), false); // 回到合适的位置或许是顶部
showNotification('正在处理第 ' + (rounder + 1) + '/' + resultArray.length + ' 轮次 ' + loadImageIcon(), 0);
await new Promise(resolve => setTimeout(resolve, 500)); // 等待500毫秒，可根据需要调整
let index = 1;
let checkCount = 0;
for (let i = getMaxForScheduledItemIndex(); i < countItem; i++, checkCount++) {
if (!itemSort_anchorSort.getDivButtonState()) return; // 跳出循环，如果主播排序未打开，则不执行任何操作
if (resultArray[rounder][index] == i) {
await selectItemForRowIndex(i); // 选择指定的行
scheduledItems.push(i); // 记录已排班的商品序号
index++;
}
if ((checkCount + 1) % 4 === 0) await itemPageScroll(480); // 每处理4行，滚动页面
// console.log('Index:', index, 'Length:', resultArray[rounder].length);
if (index === resultArray[rounder].length) {
// console.log('Executing scheduling...');
await new Promise(resolve => setTimeout(resolve, 500)); // 等待500毫秒，可根据需要调整
await clickScheduleButton();
await clickSelectByTitle("主讲主播");
await selectAnchor(resultArray[rounder][0][0], true);
await clickSelectByTitle("副讲主播");
if (resultArray[rounder][0][1]) {
await selectAnchor(resultArray[rounder][0][1], false);
}
await clickConformButtonForSchedule();
rounder++;
break; // 跳出循环，继续处理下一个商品
}
}
// 确保整个循环内容都执行完再进入下一次迭代
await new Promise(resolve => setTimeout(resolve, 500)); // 等待500毫秒，可根据需要调整
}
setTimeout(() => {
click_itemSort_anchorSort();
}, 1500);
showNotification('全部处理完成！');
} catch (error) {
// 捕获任何异常，并显示错误通知
click_itemSort_anchorSort();
setTimeout(() => {
showNotification('处理过程中出现错误！');
}, 1500);
console.error('Error occurred:', error);
} finally {
// 可选的: 在所有操作完成后执行清理工作
// console.log('处理流程结束');
}
}
function click_itemSort_anchorSort() {
document.getElementById('itemSort_anchorSort_divButton').click();
}
// 输入弹窗
function createDropdownModal(dropdownContainer, titleText) {
return new Promise((resolve, reject) => {
// 检查是否已有弹窗存在，如果有则移除
const existingModal = dropdownContainer.querySelector('.dropdown-modal');
if (existingModal) {
dropdownContainer.removeChild(existingModal);
}
dropdownButton.style.display = 'none'; // 隐藏按钮
// 创建弹窗容器
var dropdownDivModal = document.createElement('div');
dropdownDivModal.classList.add('dropdown-modal'); // 添加一个类以便于识别
dropdownDivModal.style.cssText = `
position: absolute;
top: 0;
margin: 14px;
width: 172px;
height: 108px;
background-color: rgba(233, 233, 233, 0.7);
backdrop-filter: blur(8px) brightness(90%);
border: 1px solid rgba(255, 98, 0, 0.25);
border-radius: 10px;
box-sizing: border-box;
display: flex;
flex-direction: column;
z-index: 3;
transform-origin: top center;
`;
// 创建标题行
const title = document.createElement('div');
title.textContent = titleText || '弹窗标题';
title.style.cssText = `
padding: 8px 10px;
font-size: 14px;
font-weight: bold;
color: rgb(51, 51, 51);
border-bottom: 0px solid #ccc;
text-align: left;
flex-shrink: 0;
`;
dropdownDivModal.appendChild(title);
// 创建富文本框
const textarea = document.createElement('textarea');
textarea.style.cssText = `
width: calc(100% - 20px);
background-color: rgba(249, 249, 249, 0.7);
height: 30px;
margin: 0px 10px;
padding: 5px;
font-size: 12px;
border: 0px solid #ccc;
border-radius: 4px;
resize: none;
line-height: 1.2;
box-sizing: border-box;
flex-grow: 1;
`;
dropdownDivModal.appendChild(textarea);
// 创建按钮容器
const buttonContainer = document.createElement('div');
buttonContainer.style.cssText = `
display: flex;
justify-content: space-between;
padding: 8px 10px;
border-top: 0px solid #ccc;
flex-shrink: 0;
`;
// 创建“取消”按钮
const cancelButton = document.createElement('button');
cancelButton.textContent = '取消';
cancelButton.style.cssText = `
padding: 3px 8px;
font-size: 12px;
color: #fff;
background-color: #f44336;
border: none;
border-radius: 5px;
cursor: pointer;
flex-basis: 48%;
`;
cancelButton.onclick = () => {
dropdownContainer.removeChild(dropdownDivModal);
dropdownButton.style.display = ''; // 恢复按钮
reject('用户取消了输入');
};
buttonContainer.appendChild(cancelButton);
// 创建“确认”按钮
const confirmButton = document.createElement('button');
confirmButton.textContent = '确认';
confirmButton.style.cssText = `
padding: 3px 8px;
font-size: 12px;
color: #fff;
background-color: #4CAF50;
border: none;
border-radius: 5px;
cursor: pointer;
flex-basis: 48%;
`;
confirmButton.onclick = () => {
const textInput = textarea.value;
dropdownContainer.removeChild(dropdownDivModal);
dropdownButton.style.display = ''; // 恢复按钮
resolve(textInput); // 在确认时返回输入的内容
};
buttonContainer.appendChild(confirmButton);
dropdownDivModal.appendChild(buttonContainer);
dropdownContainer.appendChild(dropdownDivModal);
});
}
})();