diff --git a/README.md b/README.md index 9d47d77..b054fb9 100644 --- a/README.md +++ b/README.md @@ -1,58 +1,13 @@ ---- -title: obsidian-vaultexporter-plugin -ctime: 2024-04-22 20:10 -aliases: - - -tags: - - -NID: -NIW: -drafts: true -publish: false -PrevNote: "[[obsidian-sample-plugin]]" -NextNote: "[[vexporter readMe]]" -LocalGitProject: D:\iLanix\isync\Obsidian\.obsidian\plugins\obsidian-vaultexporter-plugin ---- - -下载 [obsidian-sample-plugin](https://github.com/obsidianmd/obsidian-sample-plugin)， - -```bash -cd Your_Vault_DIR/.obsidian/plugins -git clone https://github.com/obsidianmd/obsidian-sample-plugin.git -``` - -修改 `manifest.json`： - -```jsn -{ - "id": "vault-exporter", - "name": "Vault Exporter", - "version": "1.0.0", - "minAppVersion": "0.15.0", - "description": "Export current note to another Vault.", - "author": "ZigHolding", - "isDesktopOnly": true -} -``` - -```bash -cd obsidian-sample-plugin -npm i # 下载依赖包 -npm run dev # 将 main.ts 编译为 main.js -``` - -开发完成后：将`main.js`、`styles.css`、`mainfest.json` 复制到 ：`VaultFolder/.obsidian/plugins/your-plugin-id/`。 - 需要先安装 [[obsidian-notechain-plugin]] 和 [[Templater]] 插件。 `Vault Exporter: Set Git Project`：将当前笔记绑定项目笔记。输入目录，生成 `LocalGitProject` 的元数据。 -![](./assets/Pasted image 20240422220412.png) +![Pasted image 20240422220412.png](./assets/Pasted image 20240422220412.png) `Vault Exporter: Export readMe`：将当前笔记输出到 readme，笔记引用的图和文件复制到 `LocalGitProject/assets` 下。复制 readme 时，会更换链接。 元数据和附录可以在设置页面更改。 -![](./assets/Pasted image 20240422213449.png) +![Pasted image 20240422213449.png](./assets/Pasted image 20240422213449.png) diff --git a/data.json b/data.json index 2a576c4..97f6ae5 100644 --- a/data.json +++ b/data.json @@ -1,5 +1,7 @@ { "nameLocalGitProject": "LocalGitProject", + "readmeRemoveFrontmatter": true, "assetsLocalGitProject": "assets", + "pluginDirExporter": "D:\\iLanix\\isync\\Obsidian\\.obsidian\\plugins", "mySetting": "D:/iLanix/isync/test" } \ No newline at end of file diff --git a/main.js b/main.js index c0d0ccc..0f4f85d 100644 --- a/main.js +++ b/main.js @@ -28,72 +28,47 @@ __export(main_exports, { }); module.exports = __toCommonJS(main_exports); var import_obsidian = require("obsidian"); -var fs = require("fs"); -var DEFAULT_SETTINGS = { - nameLocalGitProject: "LocalGitProject", - assetsLocalGitProject: "assets" -}; -var cmd_export_readme = (plugin) => ({ - id: "export_readme", - name: "Export readMe", - callback: async () => { - let nc = await plugin.app.plugins.getPlugin("note-chain"); - let tfile = nc.chain.current_note; - await plugin.export_readme( - tfile, - null, - true, - plugin.settings.assetsLocalGitProject - ); + +// src/fseditor.ts +var FsEditor = class { + constructor(plugin) { + this.plugin = plugin; + this.fs = require("fs"); + this.path = require("path"); } -}); -var cmd_set_git_project = (plugin) => ({ - id: "set_git_project", - name: "Set Git Project", - callback: async () => { - let nc = await plugin.app.plugins.getPlugin("note-chain"); - let dir = await nc.chain.tp_prompt("\u8F93\u5165\u6587\u4EF6\u5939"); - if (!dir || !fs.existsSync(dir)) { - return; + get root() { + let a = this.plugin.app.vault.adapter; + return a.basePath.replace(/\\/g, "/"); + } + abspath(tfile) { + if (tfile) { + return this.root + "/" + tfile.path; + } else { + return null; } - await nc.editor.set_frontmatter( - nc.chain.current_note, - plugin.settings.nameLocalGitProject, - dir - ); } -}); -var commandBuilders = [ - cmd_export_readme, - cmd_set_git_project -]; -function addCommands(plugin) { - commandBuilders.forEach((c) => { - plugin.addCommand(c(plugin)); - }); -} -var VaultExpoterPlugin = class extends import_obsidian.Plugin { - async onload() { - await this.loadSettings(); - this.app.vt = this; - this.fs = fs; - this.root = this.app.vault.adapter.basePath; - this.addSettingTab(new VExporterSettingTab(this.app, this)); - addCommands(this); + isfile(path) { + return this.fs.existsSync(path) && this.fs.statSync(path).isFile(); } - onunload() { + isdir(path) { + return this.fs.existsSync(path) && this.fs.statSync(path).isDirectory(); } - async loadSettings() { - this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); - } - async saveSettings() { - await this.saveData(this.settings); + mkdirRecursiveSync(path) { + if (this.isdir(path)) { + return true; + } + const parent = this.path.dirname(path); + if (!this.isdir(parent)) { + this.mkdirRecursiveSync(parent); + } + this.fs.mkdirSync(path); } /** * 附件 src 到 dst，不在 vault 中，需要绝对路径 * overwrite，复盖；mtime，新文件； */ - copy_file_by_path(src, dst, mode = "overwrite>mtime>pass") { + copy_file_by_path(src, dst, mode = "pass>overwrite>mtime") { + const fs = this.fs; mode = mode.split(">")[0]; if (!fs.existsSync(src)) { return; @@ -112,19 +87,155 @@ var VaultExpoterPlugin = class extends import_obsidian.Plugin { fs.copyFileSync(src, dst); } } - abspath(tfile) { - if (tfile) { - return this.root + "/" + tfile.path; - } else { - return null; - } - } - copy_tfile(tfile, dst) { + copy_tfile(tfile, dst, mode = "mtime") { if (tfile) { let src = this.abspath(tfile); - src && this.copy_file_by_path(src, dst); + src && this.copy_file_by_path(src, dst, mode); } } + mirror_tfile(tfile, vault_root, mode = "mtime", attachment = true, outlink = false) { + if (tfile) { + vault_root = vault_root.replace(/\\g/, "/"); + let src = this.root + "/" + tfile.path; + let dst = vault_root + "/" + tfile.path; + this.mkdirRecursiveSync(this.path.dirname); + this.copy_file_by_path(src, dst, mode); + if (attachment) { + let nc = this.plugin.app.plugins.getPlugin("note-chain"); + let tfiles = nc.chain.get_outlinks(tfile); + for (let t of tfiles) { + if (!(t.extension === "md")) { + this.mirror_tfile(t, vault_root, mode, false); + } else if (outlink) { + this.mirror_tfile(t, vault_root, mode, false); + } + } + } + } + } + modify(path, callback, encoding = "utf8") { + const fs = this.fs; + if (!fs.existsSync(path)) { + return; + } + ; + fs.readFile( + path, + encoding, + (err, data) => { + if (err) { + console.error("Error reading file:", err); + ; + } + let rs = callback(path, data); + fs.writeFile(path, rs, encoding, (err2) => { + if (err2) { + console.error("Error writing file:", err2); + } else { + console.log("File content updated successfully."); + } + }); + } + ); + } +}; + +// main.ts +var DEFAULT_SETTINGS = { + nameLocalGitProject: "LocalGitProject", + readmeRemoveFrontmatter: true, + assetsLocalGitProject: "assets", + pluginDirExporter: "" +}; +var cmd_export_readme = (plugin) => ({ + id: "export_readme", + name: "Export readMe", + callback: async () => { + const nc = plugin.notechain; + let tfile = nc.chain.current_note; + await plugin.export_readme( + tfile, + null, + true, + plugin.settings.assetsLocalGitProject + ); + } +}); +var cmd_set_git_project = (plugin) => ({ + id: "set_git_project", + name: "Set Git Project", + callback: async () => { + const nc = plugin.notechain; + let dir = await nc.chain.tp_prompt("\u8F93\u5165\u6587\u4EF6\u5939"); + if (!dir || !plugin.fsEditor.fs.existsSync(dir)) { + return; + } + await nc.editor.set_frontmatter( + nc.chain.current_note, + plugin.settings.nameLocalGitProject, + dir + ); + } +}); +var cmd_export_plugin = (plugin) => ({ + id: "cmd_export_plugin", + name: "Export Plugin", + callback: async () => { + const nc = plugin.notechain; + let plugins = Object.keys(plugin.app.plugins.plugins); + let p = await nc.chain.tp_suggester(plugins, plugins); + let eplugin = plugin.app.plugins.getPlugin(p); + if (eplugin) { + let target = plugin.settings.pluginDirExporter; + if (!plugin.fsEditor.fs.existsSync(target)) { + target = await nc.chain.tp_prompt("\u8F93\u51FA\u76EE\u5F55"); + } + target = target.replace(/\\/g, "/"); + if (!target.endsWith("/" + p)) { + target = target + "/" + p; + } + if (!plugin.fsEditor.fs.existsSync(target)) { + plugin.fsEditor.fs.mkdirSync(target); + } + let items = ["main.js", "manifest.json", "styles.css", "data.json"]; + for (let item of items) { + let src = `${plugin.fsEditor.root}/${plugin.manifest.dir}/${item}`; + let dst = `${target}/${item}`; + plugin.fsEditor.copy_file_by_path(src, dst, "overwrite"); + new import_obsidian.Notice(`\u5BFC\u51FA\uFF1A${p}/${item}`, 3e3); + } + } + } +}); +var commandBuilders = [ + cmd_export_readme, + cmd_set_git_project, + cmd_export_plugin +]; +function addCommands(plugin) { + commandBuilders.forEach((c) => { + plugin.addCommand(c(plugin)); + }); +} +var VaultExpoterPlugin = class extends import_obsidian.Plugin { + async onload() { + await this.loadSettings(); + this.app.vt = this; + this.fsEditor = new FsEditor(this); + this.addSettingTab(new VExporterSettingTab(this.app, this)); + addCommands(this); + } + onunload() { + } + get notechain() { + return this.app.plugins.getPlugin("note-chain"); + } + async loadSettings() { + this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); + } + async saveSettings() { + await this.saveData(this.settings); + } async export_readme(tfile, dst, as_readme = true, assets = "assets") { let nc = this.app.plugins.getPlugin("note-chain"); if (!tfile) { @@ -143,7 +254,7 @@ var VaultExpoterPlugin = class extends import_obsidian.Plugin { } } dst = dst.replace(/\\/g, "/"); - if (!fs.existsSync(dst)) { + if (!this.fsEditor.fs.existsSync(dst)) { console.log("No Dir:", dst); } console.log(dst); @@ -154,37 +265,35 @@ var VaultExpoterPlugin = class extends import_obsidian.Plugin { } else { tmp = dst + "/" + tfile.basename + ".md"; } - this.copy_tfile(tfile, tmp); + this.fsEditor.copy_tfile(tfile, tmp); await this.replace_readme(tmp); let adir = dst + "/" + assets; - if (!fs.existsSync(adir)) { - fs.mkdirSync(adir); + if (!this.fsEditor.fs.existsSync(adir)) { + this.fsEditor.fs.mkdirSync(adir); } for (let f of olinks) { if (!(f.extension === "md")) { - this.copy_tfile(f, adir + "/" + f.basename + "." + f.extension); + this.fsEditor.copy_tfile(f, adir + "/" + f.basename + "." + f.extension); } } } replace_readme(path) { - fs.readFile(path, "utf8", (err, data) => { - if (err) { - return; - } - const replacedContent = data.replace( + const ufunc = (path2, data) => { + let replacedContent = data.replace( /\!\[\[(.*?)\]\]/g, (match, filename) => { - return `![](./assets/${filename})`; + return `![${filename}](./assets/${filename})`; } ); - fs.writeFile(path, replacedContent, "utf8", (err2) => { - if (err2) { - console.error("Error writing file:", err2); - } else { - console.log("File content updated successfully."); - } - }); - }); + if (this.settings.readmeRemoveFrontmatter) { + replacedContent = replacedContent.replace( + /---[\n(\r\n)][\s\S]*?---[\n(\r\n)]/, + "" + ); + } + return replacedContent; + }; + this.fsEditor.modify(path, ufunc, "utf8"); } }; var VExporterSettingTab = class extends import_obsidian.PluginSettingTab { @@ -192,6 +301,20 @@ var VExporterSettingTab = class extends import_obsidian.PluginSettingTab { super(app, plugin); this.plugin = plugin; } + getSettingValue(field) { + return this.plugin.settings[field]; + } + add_toggle(name, desc, field) { + const { containerEl } = this; + let value = this.plugin.settings[field]; + let item = new import_obsidian.Setting(containerEl).setName(name).setDesc(desc).addToggle( + (text) => text.setValue(value).onChange(async (value2) => { + this.plugin.settings[field] = value2; + await this.plugin.saveSettings(); + }) + ); + return item; + } display() { const { containerEl } = this; containerEl.empty(); @@ -203,6 +326,15 @@ var VExporterSettingTab = class extends import_obsidian.PluginSettingTab { this.plugin.settings.assetsLocalGitProject = value; await this.plugin.saveSettings(); })); + this.add_toggle( + "Remove Frontmatter?", + "", + "readmeRemoveFrontmatter" + ); + new import_obsidian.Setting(containerEl).setName("Plugin Dir To Export").addText((text) => text.setValue(this.plugin.settings.pluginDirExporter).onChange(async (value) => { + this.plugin.settings.pluginDirExporter = value; + await this.plugin.saveSettings(); + })); } }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import * as Module from 'module';\r\nimport { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, TFile } from 'obsidian';\r\n\r\n// Remember to rename these classes and interfaces!\r\n\r\nconst fs = require('fs');\r\n\r\ninterface VExporterSettings {\r\n\tnameLocalGitProject: string;\r\n\tassetsLocalGitProject:string;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: VExporterSettings = {\r\n\tnameLocalGitProject: 'LocalGitProject',\r\n\tassetsLocalGitProject: 'assets'\r\n}\r\n\r\nconst cmd_export_readme = (plugin:VaultExpoterPlugin) => ({\r\n\tid: 'export_readme',\r\n\tname: 'Export readMe',\r\n\tcallback: async () => {\r\n\t\tlet nc = await plugin.app.plugins.getPlugin('note-chain');\r\n\t\tlet tfile = nc.chain.current_note;\r\n\t\tawait plugin.export_readme(\r\n\t\t\ttfile,null,true,plugin.settings.assetsLocalGitProject\r\n\t\t);\r\n\t}\r\n});\r\n\r\nconst cmd_set_git_project = (plugin:VaultExpoterPlugin) => ({\r\n\tid: 'set_git_project',\r\n\tname: 'Set Git Project',\r\n\tcallback: async () => {\r\n\t\tlet nc = await plugin.app.plugins.getPlugin('note-chain');\r\n\t\tlet dir = await nc.chain.tp_prompt('\u8F93\u5165\u6587\u4EF6\u5939');\r\n\t\tif(!dir || !fs.existsSync(dir)){\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tawait nc.editor.set_frontmatter(\r\n\t\t\tnc.chain.current_note,\r\n\t\t\tplugin.settings.nameLocalGitProject,\r\n\t\t\tdir\r\n\t\t)\r\n\t}\r\n});\r\n\r\nconst commandBuilders = [\r\n\tcmd_export_readme,\r\n\tcmd_set_git_project\r\n];\r\n\r\nfunction addCommands(plugin:VaultExpoterPlugin) {\r\n    commandBuilders.forEach((c) => {\r\n        plugin.addCommand(c(plugin));\r\n    });\r\n}\r\n\r\nexport default class VaultExpoterPlugin extends Plugin {\r\n\tsettings: VExporterSettings;\r\n\troot : string;\r\n\t\r\n\tasync onload() {\r\n\t\tawait this.loadSettings();\r\n\t\tthis.app.vt = this;\r\n\t\tthis.fs = fs;\r\n\t\tthis.root = this.app.vault.adapter.basePath;\r\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\r\n\t\tthis.addSettingTab(new VExporterSettingTab(this.app, this));\r\n\r\n\t\taddCommands(this);\r\n\t}\r\n\r\n\tonunload() {\r\n\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n\r\n\t/**\r\n\t* \u9644\u4EF6 src \u5230 dst\uFF0C\u4E0D\u5728 vault \u4E2D\uFF0C\u9700\u8981\u7EDD\u5BF9\u8DEF\u5F84\r\n\t* overwrite\uFF0C\u590D\u76D6\uFF1Bmtime\uFF0C\u65B0\u6587\u4EF6\uFF1B\r\n\t*/\r\n\tcopy_file_by_path(src:string, dst:string,mode='overwrite>mtime>pass') {\r\n\t\tmode = mode.split('>')[0]\r\n\t\tif(!fs.existsSync(src)){\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tif(fs.existsSync(dst)){\r\n\t\t\tif(mode==='overwrite'){\r\n\t\t\t\tfs.unlinkSync(dst);\r\n\t\t\t\tfs.copyFileSync(src,dst);\r\n\t\t\t}else if(mode==='mtime'){\r\n\t\t\t\t// dst \u66F4\u65B0\u65F6\u95F4\u5C0F\u4E8E src\r\n\t\t\t\tif(fs.statSync(dst).mtimeMs<fs.statSync(src).mtimeMs){\r\n\t\t\t\t\tfs.unlinkSync(dst);\r\n\t\t\t\t\tfs.copyFileSync(src,dst);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}else{\r\n\t\t\tfs.copyFileSync(src,dst);\r\n\t\t}\r\n\t}\r\n\r\n\tabspath(tfile:TFile){\r\n\t\tif(tfile){\r\n\t\t\treturn this.root+'/'+tfile.path;\r\n\t\t}else{\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n\tcopy_tfile(tfile:TFile, dst:string) {\r\n\t\tif(tfile){\r\n\t\t\tlet src = this.abspath(tfile);\r\n\t\t\tsrc && this.copy_file_by_path(src,dst);\r\n\t\t}\r\n\t}\r\n\t\r\n\tasync export_readme(tfile:TFile,dst:string|null,as_readme=true,assets='assets'){\r\n\t\t\r\n\t\tlet nc = this.app.plugins.getPlugin('note-chain');\r\n\t\tif(!tfile){tfile = nc.chain.current_note;}\r\n\t\t\r\n\t\tif(!dst){\r\n\t\t\tdst = this.settings.nameLocalGitProject;\r\n\t\t}\r\n\t\tif(!dst.contains('/')){\r\n\t\t\tdst = nc.editor.get_frontmatter(tfile,dst);\r\n\t\t}\r\n\r\n\t\tif(!dst){\r\n\t\t\tdst = await nc.chain.tp_prompt('Path of LocalGitProject');\r\n\t\t\tif(!dst){return;}\r\n\t\t}\r\n\t\tdst = dst.replace(/\\\\/g,'/');\r\n\t\tif(!fs.existsSync(dst)){\r\n\t\t\tconsole.log('No Dir:',dst);\r\n\t\t}\r\n\t\tconsole.log(dst);\r\n\t\tlet olinks = nc.chain.get_outlinks(tfile);\r\n\t\t\r\n\t\tlet tmp;\r\n\t\tif(as_readme){\r\n\t\t\ttmp = dst+'/'+'readMe.md';\r\n\t\t}else{\r\n\t\t\ttmp = dst+'/'+tfile.basename+'.md';\r\n\t\t}\r\n\r\n\t\tthis.copy_tfile(tfile,tmp);\r\n\t\tawait this.replace_readme(tmp);\r\n\r\n\t\tlet adir = dst+'/'+assets;\r\n\t\tif(!fs.existsSync(adir)){\r\n\t\t\tfs.mkdirSync(adir);\r\n\t\t}\r\n\t\tfor(let f of olinks){\r\n\t\t\tif(!(f.extension==='md')){\r\n\t\t\t\tthis.copy_tfile(f,adir+'/'+f.basename+'.'+f.extension);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t\r\n\treplace_readme(path:string){\r\n\t\tfs.readFile(path, 'utf8', (err, data) => {\r\n\t\t\tif (err) {\r\n\t\t\t  return;\r\n\t\t\t}\r\n\t\t\t\r\n\t\t\tconst replacedContent = data.replace(\r\n\t\t\t\t/\\!\\[\\[(.*?)\\]\\]/g, \r\n\t\t\t\t(match, filename) => {\r\n\t\t\t  \treturn `![](./assets/${filename})`;\r\n\t\t\t});\r\n\t\t\t\r\n\t\t\t// \u5F02\u6B65\u5199\u5165\u65B0\u5185\u5BB9\u5230\u6587\u4EF6\r\n\t\t\tfs.writeFile(path, replacedContent, 'utf8', (err) => {\r\n\t\t\t  if (err) {\r\n\t\t\t\tconsole.error('Error writing file:', err);\r\n\t\t\t  } else {\r\n\t\t\t\tconsole.log('File content updated successfully.');\r\n\t\t\t  }\r\n\t\t\t});\r\n\t\t  });\r\n\t}\r\n}\r\n\r\nclass VExporterSettingTab extends PluginSettingTab {\r\n\tplugin: VaultExpoterPlugin;\r\n\r\n\tconstructor(app: App, plugin: VaultExpoterPlugin) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tconst {containerEl} = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('LocalGitProject')\r\n\t\t\t.setDesc('Metadata Name for Dir of Git Porject')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setPlaceholder('Enter your field')\r\n\t\t\t\t.setValue(this.plugin.settings.nameLocalGitProject)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.nameLocalGitProject = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t\t\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Folder For Assets')\r\n\t\t\t.setDesc('Dir Name for Assets')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.assetsLocalGitProject)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.assetsLocalGitProject = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t}\r\n}\r\n"],
  "mappings": "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",
  "names": ["err"]
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts", "src/fseditor.ts"],
  "sourcesContent": ["import * as Module from 'module';\r\nimport { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, TFile } from 'obsidian';\r\n\r\nimport { FsEditor } from 'src/fseditor';\r\n\r\ninterface VExporterSettings {\r\n\tnameLocalGitProject: string;\r\n\tassetsLocalGitProject:string;\r\n\treadmeRemoveFrontmatter:boolean;\r\n\tpluginDirExporter:string;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: VExporterSettings = {\r\n\tnameLocalGitProject: 'LocalGitProject',\r\n\treadmeRemoveFrontmatter:true,\r\n\tassetsLocalGitProject: 'assets',\r\n\tpluginDirExporter:''\r\n}\r\n\r\n\r\nconst cmd_export_readme = (plugin:VaultExpoterPlugin) => ({\r\n\tid: 'export_readme',\r\n\tname: 'Export readMe',\r\n\tcallback: async () => {\r\n\t\tconst nc = plugin.notechain;\r\n\t\tlet tfile = nc.chain.current_note;\r\n\t\tawait plugin.export_readme(\r\n\t\t\ttfile,null,true,plugin.settings.assetsLocalGitProject\r\n\t\t);\r\n\t}\r\n});\r\n\r\nconst cmd_set_git_project = (plugin:VaultExpoterPlugin) => ({\r\n\tid: 'set_git_project',\r\n\tname: 'Set Git Project',\r\n\tcallback: async () => {\r\n\t\tconst nc = plugin.notechain;\r\n\t\tlet dir = await nc.chain.tp_prompt('\u8F93\u5165\u6587\u4EF6\u5939');\r\n\t\tif(!dir || !plugin.fsEditor.fs.existsSync(dir)){\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tawait nc.editor.set_frontmatter(\r\n\t\t\tnc.chain.current_note,\r\n\t\t\tplugin.settings.nameLocalGitProject,\r\n\t\t\tdir\r\n\t\t)\r\n\t}\r\n});\r\n\r\nconst cmd_export_plugin = (plugin:VaultExpoterPlugin) => ({\r\n\tid: 'cmd_export_plugin',\r\n\tname: 'Export Plugin',\r\n\tcallback: async () => {\r\n\t\tconst nc = plugin.notechain;\r\n\t\t\r\n\t\tlet plugins = Object.keys((plugin.app as any).plugins.plugins);\r\n\t\tlet p = await nc.chain.tp_suggester(plugins,plugins);\r\n\t\tlet eplugin = (plugin.app as any).plugins.getPlugin(p);\r\n\t\tif(eplugin){\r\n\t\t\tlet target = plugin.settings.pluginDirExporter;\r\n\t\t\tif(!plugin.fsEditor.fs.existsSync(target)){\r\n\t\t\t\ttarget = await nc.chain.tp_prompt('\u8F93\u51FA\u76EE\u5F55');\r\n\t\t\t}\r\n\t\t\ttarget = target.replace(/\\\\/g,'/');\r\n\t\t\tif(!target.endsWith('/' + p)){\r\n\t\t\t\ttarget = target + '/' + p;\r\n\t\t\t}\r\n\t\t\tif(!plugin.fsEditor.fs.existsSync(target)){\r\n\t\t\t\tplugin.fsEditor.fs.mkdirSync(target);\r\n\t\t\t}\r\n\t\t\tlet items = ['main.js','manifest.json','styles.css','data.json'];\r\n\t\t\tfor(let item of items){\r\n\t\t\t\tlet src = `${plugin.fsEditor.root}/${plugin.manifest.dir}/${item}`;\r\n\t\t\t\tlet dst = `${target}/${item}`;\r\n\t\t\t\tplugin.fsEditor.copy_file_by_path(src,dst,'overwrite');\r\n\t\t\t\tnew Notice(`\u5BFC\u51FA\uFF1A${p}/${item}`,3000);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n});\r\n\r\nconst commandBuilders = [\r\n\tcmd_export_readme,\r\n\tcmd_set_git_project,\r\n\tcmd_export_plugin\r\n];\r\n\r\nfunction addCommands(plugin:VaultExpoterPlugin) {\r\n    commandBuilders.forEach((c) => {\r\n        plugin.addCommand(c(plugin));\r\n    });\r\n}\r\n\r\nexport default class VaultExpoterPlugin extends Plugin {\r\n\tsettings: VExporterSettings;\r\n\tfsEditor : FsEditor;\r\n\tasync onload() {\r\n\t\tawait this.loadSettings();\r\n\t\tthis.app.vt = this;\r\n\t\tthis.fsEditor = new FsEditor(this);\r\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\r\n\t\tthis.addSettingTab(new VExporterSettingTab(this.app, this));\r\n\r\n\t\taddCommands(this);\r\n\t}\r\n\r\n\tonunload() {\r\n\r\n\t}\r\n\r\n\tget notechain(){\r\n\t\treturn (this.app as any).plugins.getPlugin('note-chain');\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n\t\r\n\tasync export_readme(tfile:TFile,dst:string|null,as_readme=true,assets='assets'){\r\n\t\tlet nc = (this.app as any).plugins.getPlugin('note-chain');\r\n\t\tif(!tfile){tfile = nc.chain.current_note;}\r\n\t\t\r\n\t\tif(!dst){\r\n\t\t\tdst = this.settings.nameLocalGitProject;\r\n\t\t}\r\n\t\tif(!dst.contains('/')){\r\n\t\t\tdst = nc.editor.get_frontmatter(tfile,dst);\r\n\t\t}\r\n\r\n\t\tif(!dst){\r\n\t\t\tdst = await nc.chain.tp_prompt('Path of LocalGitProject');\r\n\t\t\tif(!dst){return;}\r\n\t\t}\r\n\t\tdst = dst.replace(/\\\\/g,'/');\r\n\t\tif(!this.fsEditor.fs.existsSync(dst)){\r\n\t\t\tconsole.log('No Dir:',dst);\r\n\t\t}\r\n\t\tconsole.log(dst);\r\n\t\tlet olinks = nc.chain.get_outlinks(tfile);\r\n\t\t\r\n\t\tlet tmp;\r\n\t\tif(as_readme){\r\n\t\t\ttmp = dst+'/'+'readMe.md';\r\n\t\t}else{\r\n\t\t\ttmp = dst+'/'+tfile.basename+'.md';\r\n\t\t}\r\n\r\n\t\tthis.fsEditor.copy_tfile(tfile,tmp);\r\n\t\tawait this.replace_readme(tmp);\r\n\r\n\t\tlet adir = dst+'/'+assets;\r\n\t\tif(!this.fsEditor.fs.existsSync(adir)){\r\n\t\t\tthis.fsEditor.fs.mkdirSync(adir);\r\n\t\t}\r\n\t\tfor(let f of olinks){\r\n\t\t\tif(!(f.extension==='md')){\r\n\t\t\t\tthis.fsEditor.copy_tfile(f,adir+'/'+f.basename+'.'+f.extension);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t\r\n\treplace_readme(path:string){\r\n\t\tconst ufunc = (path:string,data:string)=>{\r\n\t\t\tlet replacedContent = data.replace(\r\n\t\t\t\t/\\!\\[\\[(.*?)\\]\\]/g, \r\n\t\t\t\t(match:any, filename:string) => {\r\n\t\t\t\treturn `![${filename}](./assets/${filename})`;\r\n\t\t\t});\r\n\t\t\tif(this.settings.readmeRemoveFrontmatter){\r\n\t\t\t\treplacedContent = replacedContent.replace(\r\n\t\t\t\t\t/---[\\n(\\r\\n)][\\s\\S]*?---[\\n(\\r\\n)]/,''\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t\treturn replacedContent;\r\n\t\t}\r\n\t\tthis.fsEditor.modify(path,ufunc,'utf8');\r\n\t}\r\n}\r\n\r\nclass VExporterSettingTab extends PluginSettingTab {\r\n\tplugin: VaultExpoterPlugin;\r\n\t\r\n\r\n\tconstructor(app: App, plugin: VaultExpoterPlugin) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tgetSettingValue(field: keyof VExporterSettings) {\r\n\t\treturn this.plugin.settings[field];\r\n\t}\r\n\r\n\tadd_toggle(name:string,desc:string,field:keyof VExporterSettings){\r\n\t\tconst {containerEl} = this;\r\n\t\tlet value = this.plugin.settings[field] as boolean;\r\n\t\tlet item = new Setting(containerEl)  \r\n\t\t\t.setName(name)\r\n\t\t\t.setDesc(desc)\r\n\t\t\t.addToggle(text => text\r\n\t\t\t\t.setValue(value)\r\n\t\t\t\t.onChange(async (value:never) => {\r\n\t\t\t\t\tthis.plugin.settings[field] = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t})\r\n\t\t\t);\r\n\t\treturn item;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tconst {containerEl} = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('LocalGitProject')\r\n\t\t\t.setDesc('Metadata Name for Dir of Git Porject')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setPlaceholder('Enter your field')\r\n\t\t\t\t.setValue(this.plugin.settings.nameLocalGitProject)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.nameLocalGitProject = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t\t\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Folder For Assets')\r\n\t\t\t.setDesc('Dir Name for Assets')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.assetsLocalGitProject)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.assetsLocalGitProject = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t\t\r\n\t\tthis.add_toggle(\r\n\t\t\t'Remove Frontmatter?','','readmeRemoveFrontmatter'\r\n\t\t);\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Plugin Dir To Export')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.pluginDirExporter)\r\n\t\t\t\t.onChange(async (value) => {\r\n\t\t\t\t\tthis.plugin.settings.pluginDirExporter = value;\r\n\t\t\t\t\tawait this.plugin.saveSettings();\r\n\t\t\t\t}));\r\n\t\t\r\n\t}\r\n}\r\n", "\r\nimport { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, TFile } from 'obsidian';\r\n\r\nexport class FsEditor{\r\n    fs;\r\n    path;\r\n    plugin :Plugin;\r\n\r\n    constructor(plugin:Plugin){\r\n        this.plugin = plugin;\r\n        this.fs = require('fs');\r\n        this.path = require('path');\r\n    }\r\n\r\n    get root(){\r\n        let a = this.plugin.app.vault.adapter as any;\r\n        return a.basePath.replace(/\\\\/g,'/');\r\n    }\r\n\r\n    abspath(tfile:TFile){\r\n\t\tif(tfile){\r\n\t\t\treturn this.root+'/'+tfile.path;\r\n\t\t}else{\r\n\t\t\treturn null;\r\n\t\t}\r\n\t}\r\n\r\n    isfile(path:string){\r\n        return this.fs.existsSync(path) && this.fs.statSync(path).isFile();\r\n    }\r\n\r\n    isdir(path:string){\r\n        return this.fs.existsSync(path) && this.fs.statSync(path).isDirectory();\r\n    }\r\n\r\n    mkdirRecursiveSync(path:string){\r\n        if(this.isdir(path)){return true;}\r\n        const parent = this.path.dirname(path);\r\n        if(!this.isdir(parent)){\r\n            this.mkdirRecursiveSync(parent);\r\n        }\r\n        this.fs.mkdirSync(path);\r\n    }\r\n\r\n    /**\r\n\t* \u9644\u4EF6 src \u5230 dst\uFF0C\u4E0D\u5728 vault \u4E2D\uFF0C\u9700\u8981\u7EDD\u5BF9\u8DEF\u5F84\r\n\t* overwrite\uFF0C\u590D\u76D6\uFF1Bmtime\uFF0C\u65B0\u6587\u4EF6\uFF1B\r\n\t*/\r\n    copy_file_by_path(src:string,dst:string,mode='pass>overwrite>mtime') {\r\n        const fs = this.fs;\r\n\r\n        mode = mode.split('>')[0]\r\n        if(!fs.existsSync(src)){\r\n            return;\r\n        }\r\n        if(fs.existsSync(dst)){\r\n            if(mode==='overwrite'){\r\n                fs.unlinkSync(dst);\r\n                fs.copyFileSync(src,dst);\r\n            }else if(mode==='mtime'){\r\n                // dst \u66F4\u65B0\u65F6\u95F4\u5C0F\u4E8E src\r\n                if(fs.statSync(dst).mtimeMs<fs.statSync(src).mtimeMs){\r\n                    fs.unlinkSync(dst);\r\n                    fs.copyFileSync(src,dst);\r\n                }\r\n            }\r\n        }else{\r\n            fs.copyFileSync(src,dst);\r\n        }\r\n    }\r\n\r\n    copy_tfile(tfile:TFile, dst:string,mode='mtime') {\r\n\t\tif(tfile){\r\n\t\t\tlet src = this.abspath(tfile);\r\n\t\t\tsrc && this.copy_file_by_path(src,dst,mode);\r\n\t\t}\r\n\t}\r\n\r\n    mirror_tfile(tfile:TFile,vault_root:string,mode='mtime',attachment=true,outlink=false){\r\n        // \u5C06\u7B14\u8BB0\u955C\u50CF\u79FB\u52A8\u5230\u522B\u7684\u5E93\u4E2D\uFF0C\u6587\u4EF6\u7ED3\u6784\u4E0E\u5F53\u524D\u5E93\u76F8\u540C\r\n        if(tfile){\r\n            vault_root = vault_root.replace(/\\\\g/,'/');\r\n\t\t\tlet src = this.root + '/' + tfile.path;\r\n            let dst = vault_root+'/'+tfile.path;\r\n            this.mkdirRecursiveSync(this.path.dirname);\r\n\t\t\tthis.copy_file_by_path(src,dst,mode);\r\n            if(attachment){\r\n                let nc = (this.plugin.app as any).plugins.getPlugin('note-chain');\r\n                let tfiles = nc.chain.get_outlinks(tfile);\r\n                for(let t of tfiles){\r\n                    if(!(t.extension==='md')){\r\n                        this.mirror_tfile(t,vault_root,mode,false);\r\n                    }else if(outlink){\r\n                        this.mirror_tfile(t,vault_root,mode,false);\r\n                    }\r\n                }\r\n            }\r\n\t\t}\r\n    }\r\n\r\n    modify(path:string,callback:Function,encoding='utf8'){\r\n        const fs = this.fs;\r\n        if(!fs.existsSync(path)){return};\r\n\r\n        fs.readFile(path, encoding, (err:Error, data:string) => {\r\n\t\t\tif(err){\r\n                console.error('Error reading file:', err);;\r\n            }\r\n            let rs = callback(path,data);\r\n\t\t\tfs.writeFile(path, rs, encoding, (err:Error) => {\r\n\t\t\t  if (err) {\r\n\t\t\t\tconsole.error('Error writing file:', err);\r\n\t\t\t  } else {\r\n\t\t\t\tconsole.log('File content updated successfully.');\r\n\t\t\t  }\r\n\t\t\t});\r\n\t\t  }\r\n        );\r\n    }\r\n}\r\n"],
  "mappings": "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",
  "names": ["err", "path", "value"]
}
 diff --git a/main.ts b/main.ts index 754348e..80281f9 100644 --- a/main.ts +++ b/main.ts @@ -1,25 +1,28 @@ import * as Module from 'module'; import { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, TFile } from 'obsidian'; -// Remember to rename these classes and interfaces! - -const fs = require('fs'); +import { FsEditor } from 'src/fseditor'; interface VExporterSettings { nameLocalGitProject: string; assetsLocalGitProject:string; + readmeRemoveFrontmatter:boolean; + pluginDirExporter:string; } const DEFAULT_SETTINGS: VExporterSettings = { nameLocalGitProject: 'LocalGitProject', - assetsLocalGitProject: 'assets' + readmeRemoveFrontmatter:true, + assetsLocalGitProject: 'assets', + pluginDirExporter:'' } + const cmd_export_readme = (plugin:VaultExpoterPlugin) => ({ id: 'export_readme', name: 'Export readMe', callback: async () => { - let nc = await plugin.app.plugins.getPlugin('note-chain'); + const nc = plugin.notechain; let tfile = nc.chain.current_note; await plugin.export_readme( tfile,null,true,plugin.settings.assetsLocalGitProject @@ -31,9 +34,9 @@ const cmd_set_git_project = (plugin:VaultExpoterPlugin) => ({ id: 'set_git_project', name: 'Set Git Project', callback: async () => { - let nc = await plugin.app.plugins.getPlugin('note-chain'); + const nc = plugin.notechain; let dir = await nc.chain.tp_prompt('输入文件夹'); - if(!dir || !fs.existsSync(dir)){ + if(!dir || !plugin.fsEditor.fs.existsSync(dir)){ return; } await nc.editor.set_frontmatter( @@ -44,9 +47,42 @@ const cmd_set_git_project = (plugin:VaultExpoterPlugin) => ({ } }); +const cmd_export_plugin = (plugin:VaultExpoterPlugin) => ({ + id: 'cmd_export_plugin', + name: 'Export Plugin', + callback: async () => { + const nc = plugin.notechain; + + let plugins = Object.keys((plugin.app as any).plugins.plugins); + let p = await nc.chain.tp_suggester(plugins,plugins); + let eplugin = (plugin.app as any).plugins.getPlugin(p); + if(eplugin){ + let target = plugin.settings.pluginDirExporter; + if(!plugin.fsEditor.fs.existsSync(target)){ + target = await nc.chain.tp_prompt('输出目录'); + } + target = target.replace(/\\/g,'/'); + if(!target.endsWith('/' + p)){ + target = target + '/' + p; + } + if(!plugin.fsEditor.fs.existsSync(target)){ + plugin.fsEditor.fs.mkdirSync(target); + } + let items = ['main.js','manifest.json','styles.css','data.json']; + for(let item of items){ + let src = `${plugin.fsEditor.root}/${plugin.manifest.dir}/${item}`; + let dst = `${target}/${item}`; + plugin.fsEditor.copy_file_by_path(src,dst,'overwrite'); + new Notice(`导出：${p}/${item}`,3000); + } + } + } +}); + const commandBuilders = [ cmd_export_readme, - cmd_set_git_project + cmd_set_git_project, + cmd_export_plugin ]; function addCommands(plugin:VaultExpoterPlugin) { @@ -57,13 +93,11 @@ function addCommands(plugin:VaultExpoterPlugin) { export default class VaultExpoterPlugin extends Plugin { settings: VExporterSettings; - root : string; - + fsEditor : FsEditor; async onload() { await this.loadSettings(); this.app.vt = this; - this.fs = fs; - this.root = this.app.vault.adapter.basePath; + this.fsEditor = new FsEditor(this); // This adds a settings tab so the user can configure various aspects of the plugin this.addSettingTab(new VExporterSettingTab(this.app, this)); @@ -74,6 +108,10 @@ export default class VaultExpoterPlugin extends Plugin { } + get notechain(){ + return (this.app as any).plugins.getPlugin('note-chain'); + } + async loadSettings() { this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData()); } @@ -81,50 +119,9 @@ export default class VaultExpoterPlugin extends Plugin { async saveSettings() { await this.saveData(this.settings); } - - /** - * 附件 src 到 dst，不在 vault 中，需要绝对路径 - * overwrite，复盖；mtime，新文件； - */ - copy_file_by_path(src:string, dst:string,mode='overwrite>mtime>pass') { - mode = mode.split('>')[0] - if(!fs.existsSync(src)){ - return; - } - if(fs.existsSync(dst)){ - if(mode==='overwrite'){ - fs.unlinkSync(dst); - fs.copyFileSync(src,dst); - }else if(mode==='mtime'){ - // dst 更新时间小于 src - if(fs.statSync(dst).mtimeMs { - if (err) { - return; - } - - const replacedContent = data.replace( + const ufunc = (path:string,data:string)=>{ + let replacedContent = data.replace( /\!\[\[(.*?)\]\]/g, - (match, filename) => { - return `![](./assets/${filename})`; + (match:any, filename:string) => { + return `![${filename}](./assets/${filename})`; }); - - // 异步写入新内容到文件 - fs.writeFile(path, replacedContent, 'utf8', (err) => { - if (err) { - console.error('Error writing file:', err); - } else { - console.log('File content updated successfully.'); - } - }); - }); + if(this.settings.readmeRemoveFrontmatter){ + replacedContent = replacedContent.replace( + /---[\n(\r\n)][\s\S]*?---[\n(\r\n)]/,'' + ) + } + return replacedContent; + } + this.fsEditor.modify(path,ufunc,'utf8'); } } class VExporterSettingTab extends PluginSettingTab { plugin: VaultExpoterPlugin; + constructor(app: App, plugin: VaultExpoterPlugin) { super(app, plugin); this.plugin = plugin; } + getSettingValue(field: keyof VExporterSettings) { + return this.plugin.settings[field]; + } + + add_toggle(name:string,desc:string,field:keyof VExporterSettings){ + const {containerEl} = this; + let value = this.plugin.settings[field] as boolean; + let item = new Setting(containerEl) + .setName(name) + .setDesc(desc) + .addToggle(text => text + .setValue(value) + .onChange(async (value:never) => { + this.plugin.settings[field] = value; + await this.plugin.saveSettings(); + }) + ); + return item; + } + display(): void { const {containerEl} = this; @@ -223,5 +235,19 @@ class VExporterSettingTab extends PluginSettingTab { this.plugin.settings.assetsLocalGitProject = value; await this.plugin.saveSettings(); })); + + this.add_toggle( + 'Remove Frontmatter?','','readmeRemoveFrontmatter' + ); + + new Setting(containerEl) + .setName('Plugin Dir To Export') + .addText(text => text + .setValue(this.plugin.settings.pluginDirExporter) + .onChange(async (value) => { + this.plugin.settings.pluginDirExporter = value; + await this.plugin.saveSettings(); + })); + } } diff --git a/src/fseditor.ts b/src/fseditor.ts new file mode 100644 index 0000000..b2e49a5 --- /dev/null +++ b/src/fseditor.ts @@ -0,0 +1,120 @@ + +import { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, TFile } from 'obsidian'; + +export class FsEditor{ + fs; + path; + plugin :Plugin; + + constructor(plugin:Plugin){ + this.plugin = plugin; + this.fs = require('fs'); + this.path = require('path'); + } + + get root(){ + let a = this.plugin.app.vault.adapter as any; + return a.basePath.replace(/\\/g,'/'); + } + + abspath(tfile:TFile){ + if(tfile){ + return this.root+'/'+tfile.path; + }else{ + return null; + } + } + + isfile(path:string){ + return this.fs.existsSync(path) && this.fs.statSync(path).isFile(); + } + + isdir(path:string){ + return this.fs.existsSync(path) && this.fs.statSync(path).isDirectory(); + } + + mkdirRecursiveSync(path:string){ + if(this.isdir(path)){return true;} + const parent = this.path.dirname(path); + if(!this.isdir(parent)){ + this.mkdirRecursiveSync(parent); + } + this.fs.mkdirSync(path); + } + + /** + * 附件 src 到 dst，不在 vault 中，需要绝对路径 + * overwrite，复盖；mtime，新文件； + */ + copy_file_by_path(src:string,dst:string,mode='pass>overwrite>mtime') { + const fs = this.fs; + + mode = mode.split('>')[0] + if(!fs.existsSync(src)){ + return; + } + if(fs.existsSync(dst)){ + if(mode==='overwrite'){ + fs.unlinkSync(dst); + fs.copyFileSync(src,dst); + }else if(mode==='mtime'){ + // dst 更新时间小于 src + if(fs.statSync(dst).mtimeMs { + if(err){ + console.error('Error reading file:', err);; + } + let rs = callback(path,data); + fs.writeFile(path, rs, encoding, (err:Error) => { + if (err) { + console.error('Error writing file:', err); + } else { + console.log('File content updated successfully.'); + } + }); + } + ); + } +}