diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml index c8b22fd7..70941b49 100644 --- a/.github/workflows/deploy.yml +++ b/.github/workflows/deploy.yml @@ -20,7 +20,7 @@ concurrency: jobs: # 构建工作 - build: + build-and-deploy: runs-on: ubuntu-latest steps: - name: Checkout @@ -49,14 +49,13 @@ jobs: with: path: docs/.vitepress/dist - # 部署工作 - deploy: - environment: - name: github-pages - url: ${{ steps.deployment.outputs.page_url }} - needs: build - runs-on: ubuntu-latest - steps: - name: Deploy to GitHub Pages id: deployment - uses: actions/deploy-pages@v4 \ No newline at end of file + uses: actions/deploy-pages@v4 + + - name: Refresh CDN Cache + env: + TENCENT_CLOUD_SECRET_ID: ${{ secrets.TENCENT_CLOUD_SECRET_ID }} + TENCENT_CLOUD_SECRET_KEY: ${{ secrets.TENCENT_CLOUD_SECRET_KEY }} + TENCENT_CLOUD_ZONE_ID: ${{ secrets.TENCENT_CLOUD_ZONE_ID }} + run: node scripts/cdn-fresh.mjs \ No newline at end of file diff --git a/docs/.vitepress/config.mts.timestamp-1742482973657-8bee96eedb873.mjs b/docs/.vitepress/config.mts.timestamp-1742482973657-8bee96eedb873.mjs new file mode 100644 index 00000000..14d6e0ea --- /dev/null +++ b/docs/.vitepress/config.mts.timestamp-1742482973657-8bee96eedb873.mjs @@ -0,0 +1,476 @@ +// docs/.vitepress/config.mts +import { fileURLToPath, URL } from "node:url"; + +// scripts/sidebar.ts +import fs2 from "fs/promises"; +import path2 from "path"; +import fg from "file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/node_modules/fast-glob/out/index.js"; +import matter2 from "file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/node_modules/gray-matter/index.js"; + +// scripts/sidebar-wiki.ts +import fs from "fs"; +import path from "path"; +import matter from "file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/node_modules/gray-matter/index.js"; +var excludeFiles = [ + "entities/vanilla-usage-components.md", + "entities/vanilla-usage-spawn-rules.md", + "entities/vuc-full.md", + "entities/vusr-full.md" +]; +var fastBuild = process.env.fastBuild === "true "; +if (fastBuild && process.env.NODE_ENV == "production") { + console.log( + ` +INFO: fastBuild selected. the files: +${JSON.stringify( + excludeFiles, + null, + 4 + )} +will not be compiled! +` + ); +} +function formatLink(path3) { + return path3.split(/\\|\//g).join("/").replace(".md", ""); +} +function getCategoryOrder(frontMatter) { + const data = {}; + if (!frontMatter.data.categories) { + return data; + } + frontMatter.data.categories.forEach(function(category, index) { + data[category.title] = index + 1; + }); + return data; +} +function getCategories(frontMatter) { + const data = []; + if (!frontMatter.data.categories) { + return data; + } + frontMatter.data.categories.forEach(function(category, index) { + category.nav_order = -1; + category.category = category.title; + data.push({ + text: category.title, + data: category, + tags: category.tags, + prefix: category.prefix, + section: true, + color: category.color, + link: "", + activeMatch: " " + }); + }); + return data; +} +var order; +function generateWikiSidebar(base, dir) { + const data = []; + const files = fs.readdirSync(dir); + files.forEach(function(file) { + let joinedPath = path.join(dir, file); + const stats = fs.statSync(joinedPath); + if (stats.isDirectory() && fs.existsSync(path.join(joinedPath, "index.md"))) { + const str = fs.readFileSync( + path.join(joinedPath, "index.md"), + "utf8" + ); + let frontMatter; + try { + frontMatter = matter(str); + } catch (e) { + joinedPath = path.relative( + process.cwd(), + path.join(joinedPath, "index.md") + ); + console.log( + // @ts-ignore + `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter! ${e.message}` + ); + throw new Error( + // @ts-ignore + `File ${joinedPath} has invalid frontmatter! ${e.message}` + ); + } + order = getCategoryOrder(frontMatter); + const children = generateWikiSidebar(base, joinedPath).concat( + getCategories(frontMatter) + ); + children.sort( + ({ data: dataA, text: textA }, { data: dataB, text: textB }) => { + const navA = (dataA.nav_order || 50) + (order[dataA.category] || 0) * 100 || Number.MAX_SAFE_INTEGER; + const navB = (dataB.nav_order || 50) + (order[dataB.category] || 0) * 100 || Number.MAX_SAFE_INTEGER; + if (navA == navB) { + return textA.localeCompare(textB); + } + return navA - navB; + } + ); + data.push({ + text: frontMatter.data.title, + data: frontMatter.data, + children + }); + if (frontMatter.data.title === void 0) { + throw new Error( + "File " + path.join(joinedPath, "index.md") + " has invalid frontmatter!" + ); + } + } else if (stats.isFile()) { + if (!file.endsWith(".md") || file.endsWith("index.md")) return; + const str = fs.readFileSync(joinedPath, "utf8"); + let frontMatter; + try { + frontMatter = matter(str); + } catch (e) { + joinedPath = path.relative(process.cwd(), joinedPath); + console.log( + // @ts-ignore + `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter! ${e.message}` + ); + throw new Error( + // @ts-ignore + `File ${joinedPath} has invalid frontmatter! ${e.message}` + ); + } + const link = formatLink(joinedPath.toString().replace(base, "")); + if (frontMatter.data.hidden === true) return; + let prefix = null; + if (frontMatter.data.prefix != null) { + prefix = frontMatter.data.prefix; + } + let tags = null; + if (frontMatter.data.tags != null) { + tags = frontMatter.data.tags; + } + data.push({ + text: frontMatter.data.title, + data: frontMatter.data, + tags, + prefix, + section: frontMatter.data.section || false, + color: frontMatter.data.color || "none", + link, + activeMatch: `^${link}` + }); + if (frontMatter.data.title === void 0) { + joinedPath = path.relative(process.cwd(), joinedPath); + console.log( + `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter!` + ); + throw new Error(`File ${joinedPath} has invalid frontmatter!`); + } + } + }); + return data.sort( + ({ data: dataA, text: textA }, { data: dataB, text: textB }) => { + const navA = (dataA.nav_order || 50) + (order[dataA.category] || 0) * 100 || Number.MAX_SAFE_INTEGER; + const navB = (dataB.nav_order || 50) + (order[dataB.category] || 0) * 100 || Number.MAX_SAFE_INTEGER; + if (navA == navB) { + return textA.localeCompare(textB); + } + return navA - navB; + } + ); +} + +// scripts/sidebar.ts +var DOCS_DIR = "docs"; +var IGNORE_PATHS = ["README.md", "readme.md", "index.md"]; +var DEFAULT_COLLAPSED_INDEX_MAP = { + "wiki": 1, + "mcdocs": 1, + "mcguide": 0, + "mconline": 0 +}; +var CATEGORY_MAP = { + "wiki": "Wiki", + "mcdocs": "API\u6587\u6863", + "mcguide": "\u5F00\u53D1\u6307\u5357", + "mconline": "\u6559\u5B66\u8BFE\u7A0B" +}; +function extractOrderNumber(name, matterData) { + const match = name.match(/^(\d+)-/); + if (match) { + return parseInt(match[1], 10); + } else if (matterData.order) { + return parseInt(matterData.order); + } else if (matterData.nav_order) { + return parseInt(matterData.nav_order); + } + return Number.MAX_SAFE_INTEGER; +} +async function generateSidebar() { + const sidebar = {}; + const files = await fg([`${DOCS_DIR}/**/*.md`]); + for (const filePath of files) { + if (filePath.includes("wiki")) continue; + const relativePath = path2.relative(DOCS_DIR, filePath); + if (IGNORE_PATHS.some((ignore) => relativePath.toLowerCase().includes(ignore.toLowerCase()))) continue; + const segments = relativePath.split(path2.sep); + const categoryKey = segments[0]; + const fileContent = await fs2.readFile(filePath, "utf-8"); + const { data: matterData } = matter2(fileContent); + if (matterData.hidden) { + continue; + } + const categoryName = CATEGORY_MAP[categoryKey] || categoryKey; + let currentLevel = sidebar[categoryKey] || []; + if (!sidebar[categoryKey]) { + sidebar[categoryKey] = currentLevel; + } + for (let i = 0; i < segments.length; i++) { + const segment = segments[i].replace(".md", ""); + const isLast = i === segments.length - 1; + let link; + if (isLast) { + link = `/${segments.slice(0, i + 1).join("/")}`.replace(/\.md$/, ""); + } else if (i === 0) { + link = `/${segment}`; + } + const order2 = extractOrderNumber(segment, matterData); + if (isLast) { + const title = await getTitleFromFile(filePath, matterData); + const activeMatch = `^${link}(?:/|$)`; + currentLevel.push({ text: title, link, order: order2, activeMatch }); + } else { + let displayText = i === 0 ? categoryName : segment; + displayText = displayText.replace(/^\d+-\s*/, ""); + let group = currentLevel.find( + (item) => i === 0 && item.text === categoryName || i !== 0 && item.text === displayText + ); + if (!group) { + const groupLink = i === 0 ? `/${segment}` : void 0; + group = { + text: displayText, + items: [], + order: order2, + collapsed: i > DEFAULT_COLLAPSED_INDEX_MAP[segments[0]], + // 为目录添加活动匹配模式 + activeMatch: `^/${segment}(?:/|$)`, + link: groupLink + }; + currentLevel.push(group); + } + currentLevel = group.items || []; + } + } + } + for (const key in sidebar) { + sortSidebarItems(sidebar[key]); + } + const sidebarFlat = {}; + for (const key in sidebar) { + sidebarFlat[key] = []; + sidebar[key].forEach((item) => { + if (item.items) { + sidebarFlat[key].push(...item.items); + } else { + sidebarFlat[key].push(item); + } + }); + } + const wiki = generateWikiSidebar(path2.join(process.cwd(), "docs"), path2.join(process.cwd(), "docs/wiki")); + const wikiSidebar = []; + wiki.forEach((item) => { + if (item.data.categories) { + const secondUrls = []; + const second = item.data.categories.map((category) => { + ; + return { + text: category.title, + collapsed: false, + items: item.children.filter((child) => child.data.category === category.title).filter((child) => child.link).map((child) => { + secondUrls.push(child.link); + return { + text: child.text, + link: child.link, + activeMatch: child.activeMatch + }; + }) + }; + }); + const notMatched = item.children.filter((child) => !secondUrls.includes(child.link)).filter((child) => child.link).map((child) => { + return { + text: child.text, + link: child.link, + activeMatch: child.activeMatch + }; + }); + wikiSidebar.push({ + text: item.data.title, + collapsed: true, + items: [...second, ...notMatched] + }); + } else { + wikiSidebar.push({ + text: item.text, + collapsed: true, + items: item.children.filter((child) => child.link).map((child) => { + return { + text: child.text, + link: child.link, + activeMatch: child.activeMatch + }; + }) + }); + } + }); + sidebarFlat["wiki"] = wikiSidebar; + return sidebarFlat; +} +function sortSidebarItems(items) { + items.sort((a, b) => { + const orderA = a.order ?? Number.MAX_SAFE_INTEGER; + const orderB = b.order ?? Number.MAX_SAFE_INTEGER; + return orderA - orderB; + }); + items.forEach((item) => { + if (item.items && item.items.length > 0) { + sortSidebarItems(item.items); + } + }); +} +async function getTitleFromFile(filePath, matterData) { + if (matterData.title) { + return matterData.title.trim().replace(/['"]/g, ""); + } + const basename = path2.basename(filePath, ".md"); + return basename.replace(/^\d+-\s*/, "").replace(/-/g, " "); +} +var sidebar_default = generateSidebar; + +// docs/.vitepress/config.mts +import { withMermaid } from "file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/node_modules/vitepress-plugin-mermaid/dist/vitepress-plugin-mermaid.es.mjs"; +var __vite_injected_original_import_meta_url = "file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/docs/.vitepress/config.mts"; +var config_default = withMermaid({ + lang: "zh-CN", + title: "\u6211\u7684\u4E16\u754C\u4E2D\u56FD\u7248 Wiki", + description: "ModSDK \u5F00\u53D1\u8005\u6587\u6863 \u955C\u50CF\uFF0C\u4F46\u63D0\u4F9B\u66F4\u4F18\u8D28\u7684\u641C\u7D22", + ignoreDeadLinks: true, + // 替换原生搜索组件，自定义展示的搜索结果内容 + vite: { + resolve: { + alias: [ + { + find: /^.*\/VPAlgoliaSearchBox\.vue$/, + replacement: fileURLToPath( + new URL("./theme/components/AlgoliaSearch.vue", __vite_injected_original_import_meta_url) + ) + } + ] + } + }, + locales: { + root: { + label: "\u7B80\u4F53\u4E2D\u6587", + lang: "zh-CN", + themeConfig: { + // 右侧导航栏的本地化文本 + outlineTitle: "\u672C\u9875\u76EE\u5F55", + // 文档底部的本地化文本 + docFooter: { + prev: "\u4E0A\u4E00\u9875", + next: "\u4E0B\u4E00\u9875" + }, + // 最后更新时间的本地化文本 + lastUpdatedText: "\u6700\u540E\u66F4\u65B0\u4E8E", + // 返回顶部按钮的本地化文本 + returnToTopLabel: "\u8FD4\u56DE\u9876\u90E8", + // 移动端菜单的本地化文本 + sidebarMenuLabel: "\u83DC\u5355", + darkModeSwitchLabel: "\u4E3B\u9898", + lightModeSwitchTitle: "\u5207\u6362\u5230\u6D45\u8272\u6A21\u5F0F", + darkModeSwitchTitle: "\u5207\u6362\u5230\u6DF1\u8272\u6A21\u5F0F" + } + } + }, + head: [ + ["script", { async: "", src: "https://www.googletagmanager.com/gtag/js?id=G-HPBDPVLP03" }], + ["script", {}, ` + window.dataLayer = window.dataLayer || []; + function gtag(){dataLayer.push(arguments);} + gtag('js', new Date()); + gtag('config', 'G-HPBDPVLP03'); + `] + ], + themeConfig: { + // https://vitepress.dev/reference/default-theme-config + nav: [ + { text: "\u9996\u9875", link: "/" }, + { text: "Wiki", link: "/wiki" }, + { text: "API\u6587\u6863", link: "/mcdocs/0-\u6B22\u8FCE" }, + { text: "\u5F00\u53D1\u6307\u5357", link: "/mcguide/0-\u6B22\u8FCE" }, + { text: "\u6559\u5B66\u8BFE\u7A0B", link: "/mconline/0-\u6B22\u8FCE" } + ], + sidebar: await sidebar_default(), + socialLinks: [ + { icon: "github", link: "https://github.com/EaseCation/netease-modsdk-wiki" } + ], + editLink: { + pattern: "https://github.com/EaseCation/netease-modsdk-wiki/edit/main/docs/:path", + text: "\u5728 GitHub \u4E0A\u7F16\u8F91\u6B64\u9875" + }, + search: { + provider: "algolia", + options: { + appId: "F8HD84CUON", + apiKey: "ccaf9255472c593d8a8b0724a940bb29", + indexName: "netease-modsdk", + searchParameters: { + // 筛选掉 rootType 为 mconline 的项目 + facetFilters: ["rootType:-mconline"] + }, + locales: { + root: { + placeholder: "\u641C\u7D22\u6587\u6863", + translations: { + button: { + buttonText: "\u641C\u7D22\u6587\u6863", + buttonAriaLabel: "\u641C\u7D22\u6587\u6863" + }, + modal: { + searchBox: { + resetButtonTitle: "\u6E05\u9664\u67E5\u8BE2\u6761\u4EF6", + resetButtonAriaLabel: "\u6E05\u9664\u67E5\u8BE2\u6761\u4EF6", + cancelButtonText: "\u53D6\u6D88", + cancelButtonAriaLabel: "\u53D6\u6D88" + }, + startScreen: { + recentSearchesTitle: "\u641C\u7D22\u5386\u53F2", + noRecentSearchesText: "\u6CA1\u6709\u641C\u7D22\u5386\u53F2", + saveRecentSearchButtonTitle: "\u4FDD\u5B58\u81F3\u641C\u7D22\u5386\u53F2", + removeRecentSearchButtonTitle: "\u4ECE\u641C\u7D22\u5386\u53F2\u4E2D\u79FB\u9664", + favoriteSearchesTitle: "\u6536\u85CF", + removeFavoriteSearchButtonTitle: "\u4ECE\u6536\u85CF\u4E2D\u79FB\u9664" + }, + errorScreen: { + titleText: "\u65E0\u6CD5\u83B7\u53D6\u7ED3\u679C", + helpText: "\u4F60\u53EF\u80FD\u9700\u8981\u68C0\u67E5\u4F60\u7684\u7F51\u7EDC\u8FDE\u63A5" + }, + footer: { + selectText: "\u9009\u62E9", + navigateText: "\u5207\u6362", + closeText: "\u5173\u95ED", + searchByText: "\u641C\u7D22\u63D0\u4F9B\u5546" + }, + noResultsScreen: { + noResultsText: "\u65E0\u6CD5\u627E\u5230\u76F8\u5173\u7ED3\u679C", + suggestedQueryText: "\u4F60\u53EF\u4EE5\u5C1D\u8BD5\u67E5\u8BE2", + reportMissingResultsText: "\u4F60\u8BA4\u4E3A\u8BE5\u67E5\u8BE2\u5E94\u8BE5\u6709\u7ED3\u679C\uFF1F", + reportMissingResultsLinkText: "\u70B9\u51FB\u53CD\u9988" + } + } + } + } + } + } + } + } +}); +export { + config_default as default +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["docs/.vitepress/config.mts", "scripts/sidebar.ts", "scripts/sidebar-wiki.ts"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/docs/.vitepress\";const __vite_injected_original_filename = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/docs/.vitepress/config.mts\";const __vite_injected_original_import_meta_url = \"file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/docs/.vitepress/config.mts\";import { defineConfig } from 'vitepress';\nimport { fileURLToPath, URL } from 'node:url'\nimport generateSidebar from '../../scripts/sidebar.js';\nimport { withMermaid } from \"vitepress-plugin-mermaid\";\n\n// https://vitepress.dev/reference/site-config\nexport default withMermaid({\n  lang: 'zh-CN',\n  title: \"\u6211\u7684\u4E16\u754C\u4E2D\u56FD\u7248 Wiki\",\n  description: \"ModSDK \u5F00\u53D1\u8005\u6587\u6863 \u955C\u50CF\uFF0C\u4F46\u63D0\u4F9B\u66F4\u4F18\u8D28\u7684\u641C\u7D22\",\n  ignoreDeadLinks: true,\n  // \u66FF\u6362\u539F\u751F\u641C\u7D22\u7EC4\u4EF6\uFF0C\u81EA\u5B9A\u4E49\u5C55\u793A\u7684\u641C\u7D22\u7ED3\u679C\u5185\u5BB9\n  vite: {\n    resolve: {\n      alias: [\n        {\n          find: /^.*\\/VPAlgoliaSearchBox\\.vue$/,\n          replacement: fileURLToPath(\n            new URL('./theme/components/AlgoliaSearch.vue', import.meta.url)\n          )\n        }\n      ]\n    }\n  },\n  locales: {\n    root: {\n      label: '\u7B80\u4F53\u4E2D\u6587',\n      lang: 'zh-CN',\n      themeConfig: {\n        // \u53F3\u4FA7\u5BFC\u822A\u680F\u7684\u672C\u5730\u5316\u6587\u672C\n        outlineTitle: '\u672C\u9875\u76EE\u5F55',\n        // \u6587\u6863\u5E95\u90E8\u7684\u672C\u5730\u5316\u6587\u672C\n        docFooter: {\n          prev: '\u4E0A\u4E00\u9875',\n          next: '\u4E0B\u4E00\u9875'\n        },\n        // \u6700\u540E\u66F4\u65B0\u65F6\u95F4\u7684\u672C\u5730\u5316\u6587\u672C\n        lastUpdatedText: '\u6700\u540E\u66F4\u65B0\u4E8E',\n        // \u8FD4\u56DE\u9876\u90E8\u6309\u94AE\u7684\u672C\u5730\u5316\u6587\u672C\n        returnToTopLabel: '\u8FD4\u56DE\u9876\u90E8',\n        // \u79FB\u52A8\u7AEF\u83DC\u5355\u7684\u672C\u5730\u5316\u6587\u672C\n        sidebarMenuLabel: '\u83DC\u5355',\n        darkModeSwitchLabel: '\u4E3B\u9898',\n        lightModeSwitchTitle: '\u5207\u6362\u5230\u6D45\u8272\u6A21\u5F0F',\n        darkModeSwitchTitle: '\u5207\u6362\u5230\u6DF1\u8272\u6A21\u5F0F'\n      }\n    }\n  },\n  head: [\n    ['script', { async: '', src: 'https://www.googletagmanager.com/gtag/js?id=G-HPBDPVLP03' }],\n    ['script', {}, `\n      window.dataLayer = window.dataLayer || [];\n      function gtag(){dataLayer.push(arguments);}\n      gtag('js', new Date());\n      gtag('config', 'G-HPBDPVLP03');\n    `]\n  ],\n  themeConfig: {\n    // https://vitepress.dev/reference/default-theme-config\n    nav: [\n      { text: '\u9996\u9875', link: '/' },\n      { text: 'Wiki', link: '/wiki' },\n      { text: 'API\u6587\u6863', link: '/mcdocs/0-\u6B22\u8FCE' },\n      { text: '\u5F00\u53D1\u6307\u5357', link: '/mcguide/0-\u6B22\u8FCE' },\n      { text: '\u6559\u5B66\u8BFE\u7A0B', link: '/mconline/0-\u6B22\u8FCE' },\n    ],\n\n    sidebar: await generateSidebar(),\n\n    socialLinks: [\n      { icon: 'github', link: 'https://github.com/EaseCation/netease-modsdk-wiki' }\n    ],\n\n    editLink: {\n      pattern: 'https://github.com/EaseCation/netease-modsdk-wiki/edit/main/docs/:path',\n      text: '\u5728 GitHub \u4E0A\u7F16\u8F91\u6B64\u9875'\n    },\n\n    search: {\n      provider: 'algolia',\n      options: {\n        appId: 'F8HD84CUON',\n        apiKey: 'ccaf9255472c593d8a8b0724a940bb29',\n        indexName: 'netease-modsdk',\n        searchParameters: {\n          // \u7B5B\u9009\u6389 rootType \u4E3A mconline \u7684\u9879\u76EE\n          facetFilters: ['rootType:-mconline']\n        },\n        locales: {\n          root: {\n            placeholder: '\u641C\u7D22\u6587\u6863',\n            translations: {\n              button: {\n                buttonText: '\u641C\u7D22\u6587\u6863',\n                buttonAriaLabel: '\u641C\u7D22\u6587\u6863'\n              },\n              modal: {\n                searchBox: {\n                  resetButtonTitle: '\u6E05\u9664\u67E5\u8BE2\u6761\u4EF6',\n                  resetButtonAriaLabel: '\u6E05\u9664\u67E5\u8BE2\u6761\u4EF6',\n                  cancelButtonText: '\u53D6\u6D88',\n                  cancelButtonAriaLabel: '\u53D6\u6D88'\n                },\n                startScreen: {\n                  recentSearchesTitle: '\u641C\u7D22\u5386\u53F2',\n                  noRecentSearchesText: '\u6CA1\u6709\u641C\u7D22\u5386\u53F2',\n                  saveRecentSearchButtonTitle: '\u4FDD\u5B58\u81F3\u641C\u7D22\u5386\u53F2',\n                  removeRecentSearchButtonTitle: '\u4ECE\u641C\u7D22\u5386\u53F2\u4E2D\u79FB\u9664',\n                  favoriteSearchesTitle: '\u6536\u85CF',\n                  removeFavoriteSearchButtonTitle: '\u4ECE\u6536\u85CF\u4E2D\u79FB\u9664'\n                },\n                errorScreen: {\n                  titleText: '\u65E0\u6CD5\u83B7\u53D6\u7ED3\u679C',\n                  helpText: '\u4F60\u53EF\u80FD\u9700\u8981\u68C0\u67E5\u4F60\u7684\u7F51\u7EDC\u8FDE\u63A5'\n                },\n                footer: {\n                  selectText: '\u9009\u62E9',\n                  navigateText: '\u5207\u6362',\n                  closeText: '\u5173\u95ED',\n                  searchByText: '\u641C\u7D22\u63D0\u4F9B\u5546'\n                },\n                noResultsScreen: {\n                  noResultsText: '\u65E0\u6CD5\u627E\u5230\u76F8\u5173\u7ED3\u679C',\n                  suggestedQueryText: '\u4F60\u53EF\u4EE5\u5C1D\u8BD5\u67E5\u8BE2',\n                  reportMissingResultsText: '\u4F60\u8BA4\u4E3A\u8BE5\u67E5\u8BE2\u5E94\u8BE5\u6709\u7ED3\u679C\uFF1F',\n                  reportMissingResultsLinkText: '\u70B9\u51FB\u53CD\u9988'\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n})\n", "const __vite_injected_original_dirname = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts\";const __vite_injected_original_filename = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts/sidebar.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts/sidebar.ts\";import fs from 'fs/promises';\nimport path from 'path';\nimport fg from 'fast-glob';\nimport matter from 'gray-matter';\nimport { generateWikiSidebar } from './sidebar-wiki';\n\n// \u5B9A\u4E49\u4FA7\u8FB9\u680F\u9879\u76EE\u63A5\u53E3\ninterface SidebarItem {\n    text: string;\n    link?: string;\n    items?: SidebarItem[];\n    order?: number; // \u6DFB\u52A0\u6392\u5E8F\u5B57\u6BB5\n    collapsed?: boolean; // \u6DFB\u52A0\u6298\u53E0\u72B6\u6001\u63A7\u5236\n    activeMatch?: string; // \u6DFB\u52A0\u6D3B\u52A8\u5339\u914D\u6A21\u5F0F\n}\n\n// \u914D\u7F6E\u53C2\u6570\nconst DOCS_DIR = 'docs';          // \u6587\u6863\u6839\u76EE\u5F55\nconst IGNORE_PATHS = ['README.md', 'readme.md', 'index.md']; // \u5FFD\u7565\u7684\u6587\u4EF6\u540D\nconst DEFAULT_COLLAPSED_INDEX_MAP = {\n    'wiki': 1,\n    'mcdocs': 1,\n    'mcguide': 0,\n    'mconline': 0\n};\n\n// \u4E00\u7EA7\u76EE\u5F55\u540D\u79F0\u6620\u5C04\u8868\nconst CATEGORY_MAP: Record<string, string> = {\n    \"wiki\": \"Wiki\",\n    'mcdocs': 'API\u6587\u6863',\n    'mcguide': '\u5F00\u53D1\u6307\u5357',\n    'mconline': '\u6559\u5B66\u8BFE\u7A0B'\n};\n\n/**\n * \u4ECE\u540D\u79F0\u4E2D\u63D0\u53D6\u6392\u5E8F\u6570\u5B57\n * \u4F8B\u5982\uFF1A'0-\u6982\u8FF0' \u8FD4\u56DE 0\uFF0C'1-\u57FA\u7840' \u8FD4\u56DE 1\n */\nfunction extractOrderNumber(name: string, matterData: any): number {\n    const match = name.match(/^(\\d+)-/);\n    if (match) {\n        return parseInt(match[1], 10);\n    } else if (matterData.order) {\n        return parseInt(matterData.order);\n    } else if (matterData.nav_order) {\n        return parseInt(matterData.nav_order);\n    }\n    return Number.MAX_SAFE_INTEGER;\n}\n\n/**\n * \u751F\u6210\u4FA7\u8FB9\u680F\u914D\u7F6E\u9879\n */\nasync function generateSidebar(): Promise<Record<string, SidebarItem[]>> {\n    const sidebar: Record<string, SidebarItem[]> = {};\n    const files = await fg([`${DOCS_DIR}/**/*.md`]);\n\n    // \u5904\u7406\u6240\u6709\u975E wiki \u6587\u4EF6\n    for (const filePath of files) {\n        // \u8DF3\u8FC7wiki\n        if (filePath.includes('wiki')) continue;\n        const relativePath = path.relative(DOCS_DIR, filePath);\n        if (IGNORE_PATHS.some(ignore => relativePath.toLowerCase().includes(ignore.toLowerCase()))) continue;\n\n        const segments = relativePath.split(path.sep);\n        const categoryKey = segments[0];\n\n        // \u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\uFF0C\u7136\u540E\u901A\u8FC7matter\u8BFB\u53D6\u5934\u90E8\u4FE1\u606F\n        const fileContent = await fs.readFile(filePath, 'utf-8');\n        const { data: matterData } = matter(fileContent);\n\n        if (matterData.hidden) {\n            continue;\n        }\n\n        // \u4F7F\u7528\u6620\u5C04\u8868\u83B7\u53D6\u663E\u793A\u540D\u79F0\n        const categoryName = CATEGORY_MAP[categoryKey] || categoryKey;\n\n        let currentLevel: SidebarItem[] = sidebar[categoryKey] || [];\n\n        if (!sidebar[categoryKey]) {\n            sidebar[categoryKey] = currentLevel;\n        }\n\n        // \u9012\u5F52\u6784\u5EFA\u5C42\u7EA7\u7ED3\u6784\n        for (let i = 0; i < segments.length; i++) {\n            const segment = segments[i].replace('.md', '');\n            const isLast = i === segments.length - 1;\n\n            // \u4FEE\u6539\u94FE\u63A5\u751F\u6210\u903B\u8F91\n            let link;\n            if (isLast) {\n                // \u4E3A\u6587\u4EF6\u751F\u6210\u94FE\u63A5\n                link = `/${segments.slice(0, i + 1).join('/')}`.replace(/\\.md$/, '');\n            } else if (i === 0) {\n                link = `/${segment}`;\n            }\n\n            const order = extractOrderNumber(segment, matterData); // \u63D0\u53D6\u6392\u5E8F\u53F7\n\n            if (isLast) {\n                // \u6DFB\u52A0\u6700\u7EC8\u6587\u4EF6\u9879\n                const title = await getTitleFromFile(filePath, matterData);\n                // \u6DFB\u52A0 activeMatch \u4EE5\u652F\u6301\u66F4\u7CBE\u786E\u7684\u9AD8\u4EAE\u5339\u914D\n                const activeMatch = `^${link}(?:/|$)`;\n                currentLevel.push({ text: title, link, order, activeMatch });\n            } else {\n                // \u67E5\u627E\u6216\u521B\u5EFA\u76EE\u5F55\u5206\u7EC4\n                let displayText = i === 0 ? categoryName : segment;\n\n                // \u79FB\u9664\u6570\u5B57\u524D\u7F00\n                displayText = displayText.replace(/^\\d+-\\s*/, '');\n\n                let group = currentLevel.find(item =>\n                    (i === 0 && item.text === categoryName) ||\n                    (i !== 0 && item.text === displayText)\n                );\n\n                if (!group) {\n                    const groupLink = i === 0 ? `/${segment}` : undefined;\n                    group = {\n                        text: displayText,\n                        items: [],\n                        order,\n                        collapsed: i > DEFAULT_COLLAPSED_INDEX_MAP[segments[0]],\n                        // \u4E3A\u76EE\u5F55\u6DFB\u52A0\u6D3B\u52A8\u5339\u914D\u6A21\u5F0F\n                        activeMatch: `^/${segment}(?:/|$)`,\n                        link: groupLink\n                    };\n                    currentLevel.push(group);\n                }\n                currentLevel = group.items || [];\n            }\n        }\n    }\n\n    // \u5BF9\u6BCF\u4E2A\u5C42\u7EA7\u8FDB\u884C\u6392\u5E8F\n    for (const key in sidebar) {\n        sortSidebarItems(sidebar[key]);\n    }\n\n    // \u79FB\u9664\u7B2C\u4E00\u7EA7\uFF0C\u5C06\u6BCF\u4E00\u4E2A\u7B2C\u4E00\u7EA7\u4E2D\u7684items\u5E73\u94FA\u5230\u4E00\u7EA7\n    const sidebarFlat: Record<string, SidebarItem[]> = {};\n    for (const key in sidebar) {\n        sidebarFlat[key] = [];\n        sidebar[key].forEach(item => {\n            if (item.items) {\n                sidebarFlat[key].push(...item.items);\n            } else {\n                sidebarFlat[key].push(item);\n            }\n        });\n    }\n\n    // \u5904\u7406wiki\n    const wiki = generateWikiSidebar(path.join(process.cwd(), 'docs'), path.join(process.cwd(), 'docs/wiki'));\n    const wikiSidebar: SidebarItem[] = [];\n    wiki.forEach(item => {\n        if (item.data.categories) {\n            // \u4E00\u7EA7\u5927\u5206\u7C7B\n\n            // \u4E8C\u7EA7\u5206\u7C7B\n            const secondUrls: string[] = [];\n            const second = item.data.categories.map((category: any) => {;\n                return {\n                    text: category.title,\n                    collapsed: false,\n                    items: item.children\n                        .filter(child => child.data.category === category.title)\n                        .filter(child => child.link)\n                        .map(child => {\n                            secondUrls.push(child.link);\n                            return {\n                                text: child.text,\n                                link: child.link,\n                                activeMatch: child.activeMatch\n                            }\n                        })\n                }\n            });\n            // \u5339\u914D\u5230\u4E00\u7EA7\u4F46\u662F\u672A\u5339\u914D\u5230\u4E8C\u7EA7\n            const notMatched = item.children\n                .filter(child => !secondUrls.includes(child.link))\n                .filter(child => child.link)\n                .map(child => {\n                    return {\n                        text: child.text,\n                        link: child.link,\n                        activeMatch: child.activeMatch\n                    }\n                });\n\n            wikiSidebar.push({\n                text: item.data.title,\n                collapsed: true,\n                items: [...second, ...notMatched]\n            });\n        } else {\n            // \u4E00\u7EA7\u5927\u5206\u7C7B\n            wikiSidebar.push({\n                text: item.text,\n                collapsed: true,\n                items: item.children\n                    .filter(child => child.link)\n                    .map(child => {\n                        return {\n                            text: child.text,\n                            link: child.link,\n                            activeMatch: child.activeMatch\n                        }\n                    })\n            });\n        }\n    });\n    // \u6DFB\u52A0 wiki\n    sidebarFlat['wiki'] = wikiSidebar;\n\n    return sidebarFlat;\n}\n\n/**\n * \u9012\u5F52\u6392\u5E8F\u4FA7\u8FB9\u680F\u9879\u76EE\n */\nfunction sortSidebarItems(items: SidebarItem[]): void {\n    // \u6839\u636E order \u5B57\u6BB5\u6392\u5E8F\n    items.sort((a, b) => {\n        const orderA = a.order ?? Number.MAX_SAFE_INTEGER;\n        const orderB = b.order ?? Number.MAX_SAFE_INTEGER;\n        return orderA - orderB;\n    });\n\n    // \u9012\u5F52\u6392\u5E8F\u5B50\u9879\n    items.forEach(item => {\n        if (item.items && item.items.length > 0) {\n            sortSidebarItems(item.items);\n        }\n    });\n}\n\n/**\n * \u4ECE\u6587\u4EF6 Frontmatter \u6216\u6587\u4EF6\u540D\u63D0\u53D6\u6807\u9898\n */\nasync function getTitleFromFile(filePath: string, matterData: any): Promise<string> {\n    if (matterData.title) {\n        return matterData.title.trim().replace(/['\"]/g, '');\n    }\n    // \u5982\u679C\u6CA1\u6709 frontmatter title\uFF0C\u4ECE\u6587\u4EF6\u540D\u83B7\u53D6\n    const basename = path.basename(filePath, '.md');\n    // \u666E\u901A\u6587\u4EF6\uFF0C\u79FB\u9664\u6570\u5B57\u524D\u7F00\u548C\u8FDE\u5B57\u7B26\n    return basename.replace(/^\\d+-\\s*/, '').replace(/-/g, ' ');\n}\n\nexport default generateSidebar;\n", "const __vite_injected_original_dirname = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts\";const __vite_injected_original_filename = \"/Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts/sidebar-wiki.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/fangyizhou/Documents/coding/netease-modsdk-wiki/scripts/sidebar-wiki.ts\";import fs from 'fs'\nimport path from 'path'\nimport matter from 'gray-matter'\nimport fetch from 'node-fetch'\n\nconst baseUrl = '/'\n\n// define whether big pages should be built.\n// fastBuild should only be used when testing, since it will not compile some of the wikis content.\nconst excludeFiles = [\n    'entities/vanilla-usage-components.md',\n    'entities/vanilla-usage-spawn-rules.md',\n    'entities/vuc-full.md',\n    'entities/vusr-full.md',\n]\n\nconst fastBuild = process.env.fastBuild === 'true ' // SPACE has to be there, since the SET var=val command adds a space at the end!\n\nif (fastBuild && process.env.NODE_ENV == 'production') {\n    console.log(\n        `\\nINFO: fastBuild selected. the files:\\n${JSON.stringify(\n            excludeFiles,\n            null,\n            4\n        )}\\nwill not be compiled!\\n`\n    )\n}\n\nfunction formatLink(path: string) {\n    return path.split(/\\\\|\\//g).join('/').replace('.md', '')\n}\n\n/*\nGets the categories from within the frontmatter of an index.md file, and returns them as list.\n */\nfunction getCategoryOrder(frontMatter: matter.GrayMatterFile<string>) {\n    const data: { [Key: string]: number } = {}\n    if (!frontMatter.data.categories) {\n        return data\n    }\n\n    frontMatter.data.categories.forEach(function (\n        category: { title: string | number },\n        index: number\n    ) {\n        data[category.title] = index + 1\n    })\n\n    return data\n}\n\nfunction getCategories(frontMatter: matter.GrayMatterFile<string>) {\n    const data: {\n        text: any\n        data: any\n        tags: any\n        prefix: any\n        section: boolean\n        color: any\n        link: string\n        activeMatch: string\n    }[] = []\n    if (!frontMatter.data.categories) {\n        return data\n    }\n\n    frontMatter.data.categories.forEach(function (\n        category: {\n            nav_order: number\n            category: any\n            title: any\n            tags: any\n            prefix: any\n            color: any\n        },\n        index: any\n    ) {\n        category.nav_order = -1\n        category.category = category.title\n        data.push({\n            text: category.title,\n            data: category,\n            tags: category.tags,\n            prefix: category.prefix,\n            section: true,\n            color: category.color,\n            link: '',\n            activeMatch: ' ',\n        })\n    })\n\n    return data\n}\n\nlet order: { [Key: string]: number }\n\n/*\nRecursively generate the navigation links for the sidebar.\n*/\nexport function generateWikiSidebar(base: string, dir: string) {\n    const data: {\n        text: any\n        data: { [key: string]: any }\n        children?: any\n        tags?: any\n        prefix?: any\n        section?: any\n        color?: any\n        link?: string\n        activeMatch?: string\n    }[] = []\n    const files = fs.readdirSync(dir)\n\n    files.forEach(function (file) {\n        let joinedPath = path.join(dir, file)\n        const stats = fs.statSync(joinedPath)\n        // Handle top level directories\n        if (\n            stats.isDirectory() &&\n            fs.existsSync(path.join(joinedPath, 'index.md'))\n        ) {\n            const str = fs.readFileSync(\n                path.join(joinedPath, 'index.md'),\n                'utf8'\n            )\n            let frontMatter\n            try {\n                frontMatter = matter(str)\n            } catch (e) {\n                joinedPath = path.relative(\n                    process.cwd(),\n                    path.join(joinedPath, 'index.md')\n                )\n                console.log(\n                    // @ts-ignore\n                    `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter! ${e.message}`\n                )\n                throw new Error(\n                    // @ts-ignore\n                    `File ${joinedPath} has invalid frontmatter! ${e.message}`\n                )\n            }\n\n            order = getCategoryOrder(frontMatter)\n\n            const children = generateWikiSidebar(base, joinedPath).concat(\n                getCategories(frontMatter)\n            )\n\n            children.sort(\n                (\n                    { data: dataA, text: textA },\n                    { data: dataB, text: textB }\n                ) => {\n                    // Default to max int, so without nav order you will show second\n                    // Multiply by category value if it exists\n                    const navA =\n                        (dataA.nav_order || 50) +\n                        (order[dataA.category] || 0) * 100 ||\n                        Number.MAX_SAFE_INTEGER\n                    const navB =\n                        (dataB.nav_order || 50) +\n                        (order[dataB.category] || 0) * 100 ||\n                        Number.MAX_SAFE_INTEGER\n\n                    // Tie goes to the text compare! (Will also apply for elements without nav order)\n                    if (navA == navB) {\n                        return textA.localeCompare(textB)\n                    }\n\n                    // Return nav order\n                    return navA - navB\n                }\n            )\n            data.push({\n                text: frontMatter.data.title,\n                data: frontMatter.data,\n                children: children,\n            })\n\n            if (frontMatter.data.title === void 0) {\n                throw new Error(\n                    'File ' +\n                    path.join(joinedPath, 'index.md') +\n                    ' has invalid frontmatter!'\n                )\n            }\n        }\n\n        // Handle the normal files\n        else if (stats.isFile()) {\n            // Don't include non-markdown files, or the index page itself\n            if (!file.endsWith('.md') || file.endsWith('index.md')) return\n\n            const str = fs.readFileSync(joinedPath, 'utf8')\n            let frontMatter\n            try {\n                frontMatter = matter(str)\n            } catch (e) {\n                joinedPath = path.relative(process.cwd(), joinedPath)\n                console.log(\n                    // @ts-ignore\n                    `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter! ${e.message}`\n                )\n                throw new Error(\n                    // @ts-ignore\n                    `File ${joinedPath} has invalid frontmatter! ${e.message}`\n                )\n            }\n            const link = formatLink(joinedPath.toString().replace(base, ''))\n\n            // Don't include hidden pages (ignores children)\n            if (frontMatter.data.hidden === true) return\n\n            let prefix = null\n\n            if (frontMatter.data.prefix != null) {\n                prefix = frontMatter.data.prefix\n            }\n\n            let tags = null\n\n            if (frontMatter.data.tags != null) {\n                tags = frontMatter.data.tags\n            }\n            data.push({\n                text: frontMatter.data.title,\n                data: frontMatter.data,\n                tags: tags,\n                prefix: prefix,\n                section: frontMatter.data.section || false,\n                color: frontMatter.data.color || 'none',\n                link,\n                activeMatch: `^${link}`,\n            })\n            if (frontMatter.data.title === void 0) {\n                joinedPath = path.relative(process.cwd(), joinedPath)\n                console.log(\n                    `::error file=${joinedPath},line=1,col=1::File ${joinedPath} has invalid frontmatter!`\n                )\n                throw new Error(`File ${joinedPath} has invalid frontmatter!`)\n            }\n        }\n    })\n\n    return data.sort(\n        ({ data: dataA, text: textA }, { data: dataB, text: textB }) => {\n            // Default to max int, so without nav order you will show second\n            // Multiply by category value if it exists\n            const navA =\n                (dataA.nav_order || 50) + (order[dataA.category] || 0) * 100 ||\n                Number.MAX_SAFE_INTEGER\n            const navB =\n                (dataB.nav_order || 50) + (order[dataB.category] || 0) * 100 ||\n                Number.MAX_SAFE_INTEGER\n\n            // Tie goes to the text compare! (Will also apply for elements without nav order)\n            if (navA == navB) {\n                return textA.localeCompare(textB)\n            }\n\n            // Return nav order\n            return navA - navB\n        }\n    )\n}"],
  "mappings": "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",
  "names": ["fs", "path", "matter", "path", "path", "fs", "matter", "order"]
}
 diff --git a/package-lock.json b/package-lock.json index a92fb0c3..330922d1 100644 --- a/package-lock.json +++ b/package-lock.json @@ -17,6 +17,7 @@ "marked": "^15.0.7", "mermaid": "^11.5.0", "openai": "^4.87.4", + "tencentcloud-sdk-nodejs": "^4.1.0", "vitepress": "^1.6.3", "vitepress-plugin-mermaid": "^2.0.17", "vue": "^3.5.13" @@ -2041,6 +2042,19 @@ "node": ">=0.4.0" } }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, "node_modules/agentkeepalive": { "version": "4.6.0", "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz", @@ -2096,6 +2110,16 @@ "dev": true, "license": "MIT" }, + "node_modules/bignumber.js": { + "version": "9.1.2", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz", + "integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + } + }, "node_modules/birpc": { "version": "0.2.19", "resolved": "https://registry.npmjs.org/birpc/-/birpc-0.2.19.tgz", @@ -3229,6 +3253,19 @@ "node": ">= 0.4" } }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", @@ -3389,6 +3426,20 @@ "url": "https://github.com/sponsors/wooorm" } }, + "node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, "node_modules/humanize-ms": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", @@ -3465,6 +3516,19 @@ "node": ">=0.12.0" } }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/is-what": { "version": "4.1.16", "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.16.tgz", @@ -3492,6 +3556,16 @@ "js-yaml": "bin/js-yaml.js" } }, + "node_modules/json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.0.0" + } + }, "node_modules/katex": { "version": "0.16.21", "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.21.tgz", @@ -4445,6 +4519,56 @@ "dev": true, "license": "MIT" }, + "node_modules/tencentcloud-sdk-nodejs": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/tencentcloud-sdk-nodejs/-/tencentcloud-sdk-nodejs-4.1.0.tgz", + "integrity": "sha512-WifbzmRola9FVl1YIZJuZP7NjpAVToAfPv4IiQYOWj2tlHYwNBO8BfKOcn0WJh+Csn7Be8YehyZl4L5EoEgnkg==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "form-data": "^3.0.0", + "get-stream": "^6.0.0", + "https-proxy-agent": "^5.0.0", + "is-stream": "^2.0.0", + "json-bigint": "^1.0.0", + "node-fetch": "^2.2.0", + "tslib": "1.13.0", + "uuid": "^9.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tencentcloud-sdk-nodejs/node_modules/form-data": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.3.tgz", + "integrity": "sha512-q5YBMeWy6E2Un0nMGWMgI65MAKtaylxfNJGJxpGh45YDciZB4epbWpaAfImil6CPAPTYB4sh0URQNDRIZG5F2w==", + "dev": true, + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "mime-types": "^2.1.35" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/tencentcloud-sdk-nodejs/node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "dev": true, + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, "node_modules/tinyexec": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", @@ -4493,6 +4617,13 @@ "node": ">=6.10" } }, + "node_modules/tslib": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.13.0.tgz", + "integrity": "sha512-i/6DQjL8Xf3be4K/E6Wgpekn5Qasl1usyw++dAA35Ue5orEn65VIxOA+YvNNl9HV3qv70T7CNwjODHZrLwvd1Q==", + "dev": true, + "license": "0BSD" + }, "node_modules/ufo": { "version": "1.5.4", "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.5.4.tgz", diff --git a/package.json b/package.json index 3ac7f9c7..6223fa68 100644 --- a/package.json +++ b/package.json @@ -20,6 +20,7 @@ "marked": "^15.0.7", "mermaid": "^11.5.0", "openai": "^4.87.4", + "tencentcloud-sdk-nodejs": "^4.1.0", "vitepress": "^1.6.3", "vitepress-plugin-mermaid": "^2.0.17", "vue": "^3.5.13" diff --git a/scripts/cdn-fresh.mjs b/scripts/cdn-fresh.mjs new file mode 100644 index 00000000..e2596900 --- /dev/null +++ b/scripts/cdn-fresh.mjs @@ -0,0 +1,123 @@ +import dotenv from 'dotenv'; +import tencentcloud from 'tencentcloud-sdk-nodejs'; +import path from 'path'; +import { fileURLToPath } from 'url'; +import fs from 'fs'; + +// 加载环境变量 +dotenv.config(); + +// 获取当前文件的目录 +const __filename = fileURLToPath(import.meta.url); +const __dirname = path.dirname(__filename); + +// 从环境变量中获取腾讯云 API 密钥 +const SECRET_ID = process.env.TENCENT_CLOUD_SECRET_ID; +const SECRET_KEY = process.env.TENCENT_CLOUD_SECRET_KEY; +const ZONE_ID = process.env.TENCENT_CLOUD_ZONE_ID; + +const ONLINE_WIKI_URL = "https://mcwiki.easecation.net"; // 最后不能带/ + +// 检查密钥是否存在 +if (!SECRET_ID || !SECRET_KEY || !ZONE_ID) { + console.error('错误: 请确保环境变量中设置了 TENCENT_CLOUD_SECRET_ID, TENCENT_CLOUD_SECRET_KEY 和 TENCENT_CLOUD_ZONE_ID'); + process.exit(1); +} + +// 获取腾讯云 API 客户端 +const TeoClient = tencentcloud.teo.v20220901.Client; + +// 实例化客户端 +const clientConfig = { + credential: { + secretId: SECRET_ID, + secretKey: SECRET_KEY, + }, + region: "", // EdgeOne 服务不需要指定地域 + profile: { + httpProfile: { + endpoint: "teo.tencentcloudapi.com", + }, + }, +}; + +const client = new TeoClient(clientConfig); + +console.log('开始刷新 CDN 缓存...'); + +try { + const response = await client.CreatePurgeTask({ + ZoneId: ZONE_ID, + Type: "purge_prefix", + Method: "invalidate", + Targets: [ + ONLINE_WIKI_URL + ] + }); + console.log('刷新 CDN 缓存完成:', response); +} catch (error) { + console.error('刷新目录缓存失败:', error); + throw error; +} + +console.log('开始预热部分页面...'); + +// 提取docs/.vitepress/dist/assets中匹配xxx.md.xxx.js形式的文件 +const assetsDir = path.resolve(__dirname, '../docs/.vitepress/dist/assets'); +const files = fs.readdirSync(assetsDir).filter(file => file.match(/\.md\.[a-zA-Z0-9]+\.js$/)); + +const prefetchPages = [ + "mcdocs/0-欢迎", + "mcdocs/1-ModAPI/事件/事件索引表", + "mcdocs/1-ModAPI/事件/UI", + "mcdocs/1-ModAPI/事件/世界", + "mcdocs/1-ModAPI/事件/实体", + "mcdocs/1-ModAPI/事件/控制", + "mcdocs/1-ModAPI/事件/方块", + "mcdocs/1-ModAPI/事件/模型", + "mcdocs/1-ModAPI/事件/物品", + "mcdocs/1-ModAPI/事件/玩家", + "mcdocs/1-ModAPI/事件/联机大厅", + "mcdocs/1-ModAPI/事件/音效", + "mcdocs/1-ModAPI/接口/Api索引表", + "mcdocs/1-ModAPI/枚举值/索引", + "mcguide/0-欢迎", + "mcguide/20-玩法开发/13-模组SDK编程/2-Python脚本开发/0-脚本开发入门", + "mcguide/18-界面与交互/2-从零开始创建UI", + "mcguide/16-美术/6-模型和动作/00-模型制作方案", + "mcguide/20-玩法开发/15-自定义游戏内容/1-自定义物品/1-自定义基础物品", + "mcguide/20-玩法开发/15-自定义游戏内容/2-自定义方块/0-自定义方块概述", + "mcguide/20-玩法开发/15-自定义游戏内容/3-自定义生物/01-自定义基础生物", + "mcguide/20-玩法开发/15-自定义游戏内容/4-自定义维度/1-自定义维度", + "mconline/0-欢迎", + "wiki/guide/introduction", + "wiki/modsdk/modsdk-intro", + "wiki/blocks/blocks-intro", + "wiki/items/items-intro", + "wiki/entities/entity-intro-bp", + "wiki/json-ui/json-ui-intro" +]; + +const prefetchPagesTag = prefetchPages.map(page => page.replaceAll("/", "_") + ".md"); + +const targetsJs = files + .filter(file => prefetchPagesTag.filter(tag => file.indexOf(tag) >= 0).length > 0) + .map(file => `${ONLINE_WIKI_URL}/assets/${file}`); + +const targetsHtml = prefetchPages.map(file => `${ONLINE_WIKI_URL}/${file}.html`); + +try { + const response = await client.CreatePrefetchTask({ + ZoneId: ZONE_ID, + Targets: [ + ONLINE_WIKI_URL, + ONLINE_WIKI_URL + "/wiki", + ...targetsHtml, + ...targetsJs + ] + }); + console.log('预热 CDN 完成:', response); +} catch (error) { + console.error('CDN 预热失败:', error); + throw error; +} \ No newline at end of file