diff --git a/.gitignore b/.gitignore index 394522f..8c8220a 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,4 @@ -node_modules/** \ No newline at end of file +out +node_modules +.vscode-test/ +.vsix diff --git a/.vscode/launch.json b/.vscode/launch.json index 2131f2c..3333439 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -1,4 +1,4 @@ -// A launch configuration that launches the extension inside a new window +// A launch configuration that compiles the extension and then opens it inside a new window { "version": "0.1.0", "configurations": [ @@ -8,15 +8,21 @@ "request": "launch", "runtimeExecutable": "${execPath}", "args": ["--extensionDevelopmentPath=${workspaceRoot}" ], - "stopOnEntry": false + "stopOnEntry": false, + "sourceMaps": true, + "outFiles": [ "${workspaceRoot}/out/**/*.js" ], + "preLaunchTask": "npm: watch" }, { "name": "Launch Tests", "type": "extensionHost", "request": "launch", "runtimeExecutable": "${execPath}", - "args": ["--extensionDevelopmentPath=${workspaceRoot}", "--extensionTestsPath=${workspaceRoot}/test" ], - "stopOnEntry": false + "args": ["--extensionDevelopmentPath=${workspaceRoot}", "--extensionTestsPath=${workspaceRoot}/out/test" ], + "stopOnEntry": false, + "sourceMaps": true, + "outFiles": [ "${workspaceRoot}/out/test/**/*.js" ], + "preLaunchTask": "npm: watch" } ] -} \ No newline at end of file +} diff --git a/.vscode/settings.json b/.vscode/settings.json index 0c4a669..d137133 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,3 +1,9 @@ +// Place your settings in this file to overwrite default and user settings. { - "vsicons.presets.angular": false + "files.exclude": { + "out": false // set this to true to hide the "out" folder with the compiled JS files + }, + "search.exclude": { + "out": true // set this to false to include "out" folder in search results + } } \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..604e38f --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,20 @@ +// See https://go.microsoft.com/fwlink/?LinkId=733558 +// for the documentation about the tasks.json format +{ + "version": "2.0.0", + "tasks": [ + { + "type": "npm", + "script": "watch", + "problemMatcher": "$tsc-watch", + "isBackground": true, + "presentation": { + "reveal": "never" + }, + "group": { + "kind": "build", + "isDefault": true + } + } + ] +} \ No newline at end of file diff --git a/.vscodeignore b/.vscodeignore index 4f99bc6..ea75c67 100644 --- a/.vscodeignore +++ b/.vscodeignore @@ -1,6 +1,8 @@ .vscode/** -typings/** -test/** +.vscode-test/** +out/test/** +out/**/*.map +src/** .gitignore -jsconfig.json -node_modules/** \ No newline at end of file +tsconfig.json +vsc-extension-quickstart.md diff --git a/src/config/config.json b/assets/config.json similarity index 100% rename from src/config/config.json rename to assets/config.json diff --git a/jsconfig.json b/jsconfig.json deleted file mode 100644 index 32ac1e0..0000000 --- a/jsconfig.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "compilerOptions": { - "module": "commonjs", - "target": "ES6", - "noLib": true - }, - "exclude": [ - "node_modules" - ] -} \ No newline at end of file diff --git a/package.json b/package.json index 8cca537..03cb463 100644 --- a/package.json +++ b/package.json @@ -5,7 +5,7 @@ "version": "1.1.15", "publisher": "shalldie", "engines": { - "vscode": "^1.0.0" + "vscode": "^1.17.0" }, "icon": "gif/logo.png", "categories": [ @@ -14,7 +14,7 @@ "activationEvents": [ "*" ], - "main": "./extension", + "main": "./out/extension", "contributes": { "commands": [ { @@ -65,9 +65,16 @@ } }, "scripts": { - "postinstall": "node ./node_modules/vscode/bin/install" + "vscode:prepublish": "npm run compile", + "compile": "tsc -p ./", + "watch": "tsc -watch -p ./", + "postinstall": "node ./node_modules/vscode/bin/install", + "test": "npm run compile && node ./node_modules/vscode/bin/test" }, "devDependencies": { - "vscode": "^0.11.0" + "typescript": "^2.5.3", + "vscode": "^1.1.5", + "@types/node": "^7.0.43", + "@types/mocha": "^2.2.42" } } \ No newline at end of file diff --git a/src/background.js b/src/background.js deleted file mode 100644 index 35e5b1e..0000000 --- a/src/background.js +++ /dev/null @@ -1,170 +0,0 @@ -var fs = require('fs'); -var path = require('path'); - -var vscode = require('vscode'); - -var getCss = require('./getCss'); // css template -var vscodePath = require('./vscodePath'); // 路径文件 -var version = require('./version'); // 版本 -var vsHelp = require('./vsHelp'); // vsHelp 辅助类 - -/** - * 主流程控制类 - * - * @class Background - */ -class Background { - - /** - * Creates an instance of Background. - * - * - * @memberOf Background - */ - constructor() { - this.init(); - } - - - /** - * 初始化 - * - * - * @memberOf Background - */ - init() { - var firstLoad = this.firstLoad(); // 检查是否刚刚安装 - - var ifOld = this.removeOld(); // 是否存在过时文件,或者样式表中无数据 - - var config = vscode.workspace.getConfiguration('background'); // 用户配置 - - this.lastConfig = config; // 当前的配置 - - if (firstLoad || ifOld) { // 第一次默认安装,如果样式表无数据也进行安装检测 - this.install(true); - } - - - // 监测配置文件 - var subscriptions = []; - - vscode.workspace.onDidChangeConfiguration(this.install, this, subscriptions); - - this.disposable = vscode.Disposable.from(subscriptions); - - - } - - /** - * 是否刚刚安装background插件 - * - * @returns boolean - * - * @memberOf Background - */ - firstLoad() { - var configPath = path.join(__dirname, 'config', 'config.json'); - var info = JSON.parse(fs.readFileSync(configPath, 'utf-8')); - if (info.firstload) { - // var hasOld = this.removeOld(); - // var content = hasOld ? 'Ver. old uninstalled. ' : ''; - - vsHelp.showInfo('Welcome to use background! U can config it in settings.json.'); - info.firstload = false; - fs.writeFileSync(configPath, JSON.stringify(info, null, ' '), 'utf-8'); - - return true; - } - - return false; - } - - /** - * 移除旧版本 - * - * @returns 是否存在旧版本,或者未安装 - * - * @memberOf Background - */ - removeOld() { - var cssContent = fs.readFileSync(vscodePath.cssPath, 'utf-8'); // css 文件内容 - - var ifVerOld = !~cssContent.indexOf(`background.ver.${version}`); // 版本是否过时 - - if (ifVerOld) { // 如果版本过时,则卸载 - this.uninstall(); - console.log('删除旧版本'); - return true; - } - return false; - } - - - /** - * 安装背景图 - * - * - * @memberOf Background - */ - install(firstload) { - var lastConfig = this.lastConfig; // 之前的配置 - var config = vscode.workspace.getConfiguration('background'); // 用户配置 - - // 如果配置文件改变到时候,当前插件配置没有改变,则返回 - if (!firstload && JSON.stringify(lastConfig) == JSON.stringify(config)) { - // console.log('配置文件未改变.') - return; - } - - // 之后到操作有两种:1.初次加载 2.配置文件改变 - - if (!lastConfig.enabled && !config.enabled) { // 如果此时仍然为未启用状态,只是修改图片路径 - return; - } - - this.lastConfig = config; // 更新最新配置 - - if (!config.enabled) { // 关闭插件 - this.uninstall(); - vsHelp.showInfoRestart('Background has been uninstalled! Please restart.'); - return; - } - - var arr = []; // 默认图片 - - if (!config.useDefault) { // 自定义图片 - arr = config.customImages; - } - - var content = getCss(arr, config.style, config.useFront).replace(/\s*$/, ''); // 去除末尾空白 - - var cssContent = fs.readFileSync(vscodePath.cssPath, 'utf-8'); - - - cssContent = cssContent.replace(/\/\*css-background-start\*\/[\s\S]*?\/\*css-background-end\*\//g, ''); - cssContent = cssContent.replace(/\s*$/, ''); - - cssContent += content; - - fs.writeFileSync(vscodePath.cssPath, cssContent, 'utf-8'); - vsHelp.showInfoRestart('Background has been changed! Please restart.'); - } - - /** - * 卸载背景图 - * - * - * @memberOf Background - */ - uninstall() { - var content = fs.readFileSync(vscodePath.cssPath, 'utf-8'); - content = content.replace(/\/\*css-background-start\*\/[\s\S]*?\/\*css-background-end\*\//g, ''); - content = content.replace(/\s*$/, ''); - fs.writeFileSync(vscodePath.cssPath, content, 'utf-8'); - } - - -} - -module.exports = Background; \ No newline at end of file diff --git a/src/background.ts b/src/background.ts new file mode 100644 index 0000000..f35aaba --- /dev/null +++ b/src/background.ts @@ -0,0 +1,257 @@ +import * as path from 'path'; +import * as fs from 'fs'; + +import * as vscode from 'vscode'; + +import vsHelp from './vsHelp'; +import vscodePath from './vscodePath'; +import version from './version'; +import getCss from './getCss'; + +/** + * 文件类型 + * + * @enum {number} + */ +enum FileType { + /** + * 未修改的css文件 + */ + empty, + /** + * hack 过的旧版本css文件 + */ + isOld, + /** + * hack 过的新版本的css文件 + */ + isNew +} + +/** + * 插件逻辑类 + * + * @export + * @class Background + */ +class Background { + + //#region private fields 私有字段 + + /** + * 当前用户配置 + * + * @private + * @type {*} + * @memberof Background + */ + private config: any = vscode.workspace.getConfiguration('background'); + + //#endregion + + //#region private methods 私有方法 + + /** + * 获取 css 文件内容 + * + * @private + * @returns {string} + * @memberof Background + */ + private getCssContent(): string { + return fs.readFileSync(vscodePath.cssPath, 'utf-8'); + } + + /** + * 设置 css 文件内容 + * + * @private + * @param {string} content + * @memberof Background + */ + private saveCssContent(content: string): void { + fs.writeFileSync(vscodePath.cssPath, content, 'utf-8'); + } + + + /** + * 初始化 + * + * @private + * @memberof Background + */ + private initialize(): void { + + let firstload = this.checkFirstload(); // 是否初次加载插件 + + let fileType = this.getFileType(); // css 文件目前状态 + + // 如果是第一次加载插件,或者旧版本 + if (firstload || fileType == FileType.isOld) { + this.install(true); + } + + } + + /** + * 检测是否初次加载,并在初次加载的时候提示用户 + * + * @private + * @returns {boolean} 是否初次加载 + * @memberof Background + */ + private checkFirstload(): boolean { + const configPath = path.join(__dirname, '../assets/config.json'); + let info: { firstload: boolean } = JSON.parse(fs.readFileSync(configPath, 'utf-8')); + + if (info.firstload) { + // 提示 + vsHelp.showInfo('Welcome to use background! U can config it in settings.json.') + // 标识插件已启动过 + info.firstload = false; + fs.writeFileSync(configPath, JSON.stringify(info, null, ' '), 'utf-8'); + + return true; + } + + return false; + } + + /** + * 获取css文件状态 + * + * @private + * @returns {FileType} + * @memberof Background + */ + private getFileType(): FileType { + let cssContent = this.getCssContent(); + + // 未 hack 过 + let ifUnInstall: boolean = !~cssContent.indexOf(`background.ver`); + + if (ifUnInstall) { + return FileType.empty; + } + + // hack 过的旧版本 + let ifVerOld: boolean = !~cssContent.indexOf(`/*background.ver.${version}*/`); + + if (ifVerOld) { + fs.writeFileSync(path.join(__dirname, '../xxx.css'), cssContent, 'utf-8'); + return FileType.isOld; + } + + // hack 过的新版本 + return FileType.isNew; + } + + /** + * 安装插件,hack css + * + * @private + * @param {boolean} [refresh] 需要更新 + * @returns {void} + * @memberof Background + */ + private install(refresh?: boolean): void { + + let lastConfig = this.config; // 之前的配置 + let config = vscode.workspace.getConfiguration('background'); // 当前用户配置 + + // 1.如果配置文件改变到时候,当前插件配置没有改变,则返回 + if (!refresh && JSON.stringify(lastConfig) == JSON.stringify(config)) { + // console.log('配置文件未改变.') + return; + } + + // 之后操作有两种:1.初次加载 2.配置文件改变 + + // 2.两次配置均为,未启动插件 + if (!lastConfig.enabled && !config.enabled) { + // console.log('两次配置均为,未启动插件'); + return; + } + + // 3.保存当前配置 + this.config = config; // 更新配置 + + // 4.如果关闭插件 + if (!config.enabled) { + this.uninstall(); + vsHelp.showInfoRestart('Background has been uninstalled! Please restart.'); + return; + } + + // 5.hack 样式 + let arr = []; // 默认图片 + + if (!config.useDefault) { // 自定义图片 + arr = config.customImages; + } + + // 自定义的样式内容 + let content = getCss(arr, config.style, config.useFront).replace(/\s*$/, ''); // 去除末尾空白 + + // 添加到原有样式(尝试删除旧样式)中 + let cssContent = this.getCssContent(); + cssContent = this.clearCssContent(cssContent); + cssContent += content; + + this.saveCssContent(cssContent); + vsHelp.showInfoRestart('Background has been changed! Please restart.'); + + } + + /** + * 卸载 + * + * @private + * @memberof Background + */ + private uninstall(): boolean { + try { + let content = this.getCssContent(); + content = this.clearCssContent(content); + this.saveCssContent(content); + return true; + } + catch (ex) { + console.log(ex); + return false; + } + } + + /** + * 清理css中的添加项 + * + * @private + * @param {string} content + * @returns {string} + * @memberof Background + */ + private clearCssContent(content: string): string { + content = content.replace(/\/\*css-background-start\*\/[\s\S]*?\/\*css-background-end\*\//g, ''); + content = content.replace(/\s*$/, ''); + return content; + } + + //#endregion + + //#region public methods + + /** + * 初始化,并开始监听配置文件改变 + * + * @returns {vscode.Disposable} + * @memberof Background + */ + public watch(): vscode.Disposable { + this.initialize(); + return vscode.workspace.onDidChangeConfiguration(() => this.install()); + } + + //#endregion +} + +export default new Background(); \ No newline at end of file diff --git a/src/defBase64.js b/src/defBase64.ts similarity index 99% rename from src/defBase64.js rename to src/defBase64.ts index c0048bb..24f3e9e 100644 --- a/src/defBase64.js +++ b/src/defBase64.ts @@ -1,7 +1,7 @@ /** * 默认图片 */ -module.exports = [ +export default [ 'data:image/png;base64,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', 'data:image/png;base64,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', 'data:image/png;base64,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' diff --git a/extension.js b/src/extension.ts similarity index 51% rename from extension.js rename to src/extension.ts index ccffc56..5499fc5 100644 --- a/extension.js +++ b/src/extension.ts @@ -1,33 +1,34 @@ -// The module 'vscode' contains the VS Code extensibility API -// Import the module and reference it with the alias vscode in your code below -var vscode = require('vscode'); -var vsHelp = require('./src/vsHelp'); -var Background = require('./src/background'); - -// this method is called when your extension is activated -// your extension is activated the very first time the command is executed -function activate(context) { - - // Use the console to output diagnostic information (console.log) and errors (console.error) - // This line of code will only be executed once when your extension is activated - // console.log('Congratulations, your extension "background" is now active!'); - - // The command has been defined in the package.json file - // Now provide the implementation of the command with registerCommand - // The commandId parameter must match the command field in package.json - - - - var disposableInfo = vscode.commands.registerCommand('extension.background.info', function () { - vsHelp.showInfo('You can config your background in settings.json. Enjoy it!'); - }); - - context.subscriptions.push(new Background()); - - context.subscriptions.push(disposableInfo); -} -exports.activate = activate; - -// this method is called when your extension is deactivated -function deactivate() { } -exports.deactivate = deactivate; \ No newline at end of file +'use strict'; +// The module 'vscode' contains the VS Code extensibility API +// Import the module and reference it with the alias vscode in your code below +import * as vscode from 'vscode'; +import background from './background'; + +// this method is called when your extension is activated +// your extension is activated the very first time the command is executed +export function activate(context: vscode.ExtensionContext) { + + // Use the console to output diagnostic information (console.log) and errors (console.error) + // This line of code will only be executed once when your extension is activated + // console.log('Congratulations, your extension "background-feature" is now active!'); + + // The command has been defined in the package.json file + // Now provide the implementation of the command with registerCommand + // The commandId parameter must match the command field in package.json + let disposable = vscode.commands.registerCommand('extension.sayHello', () => { + // The code you place here will be executed every time your command is executed + + // Display a message box to the user + vscode.window.showInformationMessage('Hello Worldaaaaaa!'); + }); + + context.subscriptions.push(disposable); + + context.subscriptions.push(background.watch()); + +} + +// this method is called when your extension is deactivated +export function deactivate() { + vscode.window.showInformationMessage('deactivated!'); +} \ No newline at end of file diff --git a/src/getCss.js b/src/getCss.ts similarity index 66% rename from src/getCss.js rename to src/getCss.ts index 2109c2d..bde147d 100644 --- a/src/getCss.js +++ b/src/getCss.ts @@ -1,31 +1,23 @@ -var defBase64 = require('./defBase64'); -var version = require('./version'); +import defBase64 from './defBase64'; +import version from './version'; /** * 生成css样式 * - * @param {Array} arr - * @param {Object} style - * @param {boolean} useFront - * @returns {string} + * @export + * @param {Array} arr 图片数组 + * @param {any} [style={}] 自定义样式 + * @param {boolean} [useFront=true] 是否用前景图 + * @returns */ -module.exports = function (arr, style, useFront) { - style = style || {}; - let img0, img1, img2; +export default function (arr: Array, style = {}, useFront = true) { + let [img0, img1, img2] = (arr && arr.length) ? + [encodeURI(arr[0] || 'none'), + encodeURI(arr[1] || 'none'), + encodeURI(arr[2] || 'none')] : defBase64; - if (arr && arr.length) { // 如果传入的有参数 + let styleArr: string[] = []; - img0 = encodeURI(arr[0] || "none"); - img1 = encodeURI(arr[1] || "none"); - img2 = encodeURI(arr[2] || "none"); - - } else { // 如果没有参数,则使用默认值 - img0 = defBase64[0]; - img1 = defBase64[1]; - img2 = defBase64[2]; - } - - let styleArr = []; for (let k in style) { // 在使用背景图时,排除掉 pointer-events if (!useFront && ~['pointer-events', 'z-index'].indexOf(k)) { @@ -36,6 +28,7 @@ module.exports = function (arr, style, useFront) { styleArr.push(`${k}:${style[k]}`); } } + // 在前景图时使用 ::after let frontContent = useFront ? '::after' : ''; diff --git a/src/version.js b/src/version.js deleted file mode 100644 index 3188977..0000000 --- a/src/version.js +++ /dev/null @@ -1 +0,0 @@ -module.exports = '1.1.15'; \ No newline at end of file diff --git a/src/version.ts b/src/version.ts new file mode 100644 index 0000000..b6bb3d8 --- /dev/null +++ b/src/version.ts @@ -0,0 +1 @@ +export default '1.1.16'; \ No newline at end of file diff --git a/src/vsHelp.js b/src/vsHelp.js deleted file mode 100644 index 709a220..0000000 --- a/src/vsHelp.js +++ /dev/null @@ -1,75 +0,0 @@ -var vscode = require('vscode'); - -/** - * 提示辅助工具类 - * - * @class VsHelp - */ -class VsHelp { - - /** - * 输入框 - * - * @static - * @param {any} options - * @returns promise - */ - static prompt(options) { - // options: - // { - // password?: boolean 是否密文 - // placeHolder?: string 水印 - // prompt?: string title文字 - // validateInput?: (value: string) => string ??? - // value?: string 默认值 - // } - - var dict = { - "string": { prompt: options }, - "object": options - }; - - var type = typeof options; - options = dict[type] || {}; - - return vscode.window.showInputBox(options); - } - - /** - * 信息提示框 - * - * @static - * @param {any} content - * @returns - */ - static showInfo(content) { - return vscode.window.showInformationMessage(content); - } - - /** - * 提示完信息就重启 - * - * @static - * @param {any} content - */ - static showInfoRestart(content) { - vscode.window.showInformationMessage(content, { title: "Restart vscode" }) - .then(function (item) { - if (!item) return; - vscode.commands.executeCommand('workbench.action.reloadWindow'); - }); - } - - /** - * 错误提示框 - * - * @static - * @param {any} error - * @returns promise - */ - static showError(error) { - return vscode.window.showErrorMessage(error); - } -} - -module.exports = VsHelp; \ No newline at end of file diff --git a/src/vsHelp.ts b/src/vsHelp.ts new file mode 100644 index 0000000..6a35a94 --- /dev/null +++ b/src/vsHelp.ts @@ -0,0 +1,29 @@ +import * as vscode from 'vscode'; + +const vsHelp = { + /** + * 展示信息提示框 + * + * @param {string} content 提示内容 + * @returns {Thenable} + */ + showInfo(content: string): Thenable { + return vscode.window.showInformationMessage(content); + }, + + /** + * 提示信息并重启 + * + * @param {any} content 提示内容 + * @returns {Thenable} + */ + showInfoRestart(content): Thenable { + return vscode.window.showInformationMessage(content, { title: "Restart vscode" }) + .then(function (item) { + if (!item) return; + vscode.commands.executeCommand('workbench.action.reloadWindow'); + }); + } +} + +export default vsHelp; \ No newline at end of file diff --git a/src/vscodePath.js b/src/vscodePath.js deleted file mode 100644 index ce9427c..0000000 --- a/src/vscodePath.js +++ /dev/null @@ -1,14 +0,0 @@ -var path = require('path'); - -var base = path.dirname(require.main.filename); // 基础目录 - -var cssPath = path.join(base, 'vs', 'workbench', 'workbench.main.css'); // css文件路径 - -var indexDir = path.join(base, 'vs', 'workbench', 'electron-browser', 'bootstrap'); // electron 入口文件所在文件夹 - - -module.exports = { - base: base, - cssPath: cssPath, - indexDir: indexDir -}; diff --git a/src/vscodePath.ts b/src/vscodePath.ts new file mode 100644 index 0000000..262626b --- /dev/null +++ b/src/vscodePath.ts @@ -0,0 +1,25 @@ +import * as path from 'path'; + +// 基础目录 +const base = path.dirname(require.main.filename); + +// css文件路径 +const cssPath = path.join(base, 'vs', 'workbench', 'workbench.main.css'); + +// electron 入口文件所在文件夹 +const indexDir = path.join(base, 'vs', 'workbench', 'electron-browser', 'bootstrap'); + +export default { + /** + * 基础目录 + */ + base, + /** + * css文件路径 + */ + cssPath, + /** + * electron 入口文件所在文件夹 + */ + indexDir +}; \ No newline at end of file diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..8a1d847 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,16 @@ +{ + "compilerOptions": { + "module": "commonjs", + "target": "es6", + "outDir": "out", + "lib": [ + "es6" + ], + "sourceMap": true, + "rootDir": "src" + }, + "exclude": [ + "node_modules", + ".vscode-test" + ] +} \ No newline at end of file diff --git a/typings/node.d.ts b/typings/node.d.ts deleted file mode 100644 index 5ed7730..0000000 --- a/typings/node.d.ts +++ /dev/null @@ -1 +0,0 @@ -/// \ No newline at end of file diff --git a/typings/vscode-typings.d.ts b/typings/vscode-typings.d.ts deleted file mode 100644 index 5590dc8..0000000 --- a/typings/vscode-typings.d.ts +++ /dev/null @@ -1 +0,0 @@ -///