From 92208693519655fa5436b87e9c76b3266dc36f83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Fri, 16 Jun 2017 23:00:01 +0200 Subject: [PATCH 1/8] paths is not a valid option to pass to says.js --- src/css/sass.js | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/css/sass.js b/src/css/sass.js index c31e7b1..bf3e3d0 100644 --- a/src/css/sass.js +++ b/src/css/sass.js @@ -58,6 +58,9 @@ export default class SassCompiler extends CompilerBase { sourceMapRoot: filePath, }); + // not a valid option + delete opts.paths; + let result = await new Promise((res,rej) => { sass.compile(sourceCode, opts, (r) => { if (r.status !== 0) { From 46a1625e0d9e259bd0df8b4a23b4dad6c6e5a367 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Fri, 16 Jun 2017 23:02:42 +0200 Subject: [PATCH 2/8] Remove leading "/" when we are importing from entry file --- src/css/sass.js | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/css/sass.js b/src/css/sass.js index bf3e3d0..77e12f1 100644 --- a/src/css/sass.js +++ b/src/css/sass.js @@ -165,7 +165,14 @@ export default class SassCompiler extends CompilerBase { return; } else { // sass.js works in the '/sass/' directory - const cleanedRequestPath = request.resolved.replace(/^\/sass\//, ''); + let cleanedRequestPath = request.resolved.replace(/^\/sass\//, ''); + + // if we are importing from the entry file (stdin) the path is + // resolved with a leading '/'' -> remove it + if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') { + cleanedRequestPath = cleanedRequestPath.substring(1); + } + for (let includePath of includePaths) { const filePath = path.resolve(includePath, cleanedRequestPath); let variations = sass.getPathVariations(filePath); From 0b40872c8a6d7148ff3c13ad0cbaaee0bfc72dac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Fri, 16 Jun 2017 23:28:28 +0200 Subject: [PATCH 3/8] Publish to npm as @getstation/electron-compilers and version 5.10.0 --- package.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 4483a1f..27789f5 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { - "name": "electron-compilers", - "version": "5.9.0", + "name": "@getstation/electron-compilers", + "version": "5.10.0", "description": "Compiler implementations for electron-compile", "main": "lib/main.js", "scripts": { From d7c48cdf17786d27ad185ef9ed0f51022d710ad0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Sat, 17 Jun 2017 00:08:04 +0200 Subject: [PATCH 4/8] tired of this BS --- lib/compiler-base.js | 168 ++++++++++++++++++++ lib/css/less.js | 174 ++++++++++++++++++++ lib/css/sass.js | 277 ++++++++++++++++++++++++++++++++ lib/css/stylus.js | 175 ++++++++++++++++++++ lib/html/inline-html.js | 344 ++++++++++++++++++++++++++++++++++++++++ lib/html/jade.js | 38 +++++ lib/html/vue.js | 206 ++++++++++++++++++++++++ lib/js/babel.js | 127 +++++++++++++++ lib/js/coffeescript.js | 65 ++++++++ lib/js/graphql.js | 42 +++++ lib/js/typescript.js | 186 ++++++++++++++++++++++ lib/json/cson.js | 40 +++++ lib/main.js | 6 + lib/passthrough.js | 48 ++++++ 14 files changed, 1896 insertions(+) create mode 100644 lib/compiler-base.js create mode 100644 lib/css/less.js create mode 100644 lib/css/sass.js create mode 100644 lib/css/stylus.js create mode 100644 lib/html/inline-html.js create mode 100644 lib/html/jade.js create mode 100644 lib/html/vue.js create mode 100644 lib/js/babel.js create mode 100644 lib/js/coffeescript.js create mode 100644 lib/js/graphql.js create mode 100644 lib/js/typescript.js create mode 100644 lib/json/cson.js create mode 100644 lib/main.js create mode 100644 lib/passthrough.js diff --git a/lib/compiler-base.js b/lib/compiler-base.js new file mode 100644 index 0000000..ac80b88 --- /dev/null +++ b/lib/compiler-base.js @@ -0,0 +1,168 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +/** + * This class is the base interface for compilers that are used by + * electron-compile. If your compiler library only supports a + * synchronous API, use SimpleCompilerBase instead. + * + * @interface + */ +class CompilerBase { + constructor() { + this.compilerOptions = {}; + } + + /** + * This method describes the MIME types that your compiler supports as input. + * Many precompiled file types don't have a specific MIME type, so if it's not + * recognized by the mime-types package, you need to patch rig-mime-types in + * electron-compile. + * + * @return {string[]} An array of MIME types that this compiler can compile. + * + * @abstract + */ + static getInputMimeTypes() { + throw new Error("Implement me!"); + } + + /** + * Determines whether a file should be compiled + * + * @param {string} fileName The full path of a file to compile. + * @param {object} compilerContext An object that compilers can add extra + information to as part of a job - the caller + won't do anything with this. + * @return {Promise} True if you are able to compile this file. + * + * @abstract + */ + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + throw new Error("Implement me!"); + })(); + } + + /** + * Returns the dependent files of this file. This is used for languages such + * as LESS which allow you to import / reference other related files. In future + * versions of electron-compile, we will use this information to invalidate + * all of the parent files if a child file changes. + * + * @param {string} sourceCode The contents of filePath + * @param {string} fileName The full path of a file to compile. + * @param {object} compilerContext An object that compilers can add extra + information to as part of a job - the caller + won't do anything with this. + * @return {Promise} An array of dependent file paths, or an empty + * array if there are no dependent files. + * + * @abstract + */ + determineDependentFiles(sourceCode, fileName, compilerContext) { + return _asyncToGenerator(function* () { + throw new Error("Implement me!"); + })(); + } + + /** + * Compiles the file + * + * @param {string} sourceCode The contents of filePath + * @param {string} fileName The full path of a file to compile. + * @param {object} compilerContext An object that compilers can add extra + information to as part of a job - the caller + won't do anything with this. + * @return {Promise} An object representing the compiled result + * @property {string} code The compiled code + * @property {string} mimeType The MIME type of the compiled result, which + * should exist in the mime-types database. + * + * @abstract + */ + compile(sourceCode, fileName, compilerContext) { + return _asyncToGenerator(function* () { + throw new Error("Implement me!"); + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + throw new Error("Implement me!"); + } + + determineDependentFilesSync(sourceCode, fileName, compilerContext) { + throw new Error("Implement me!"); + } + + compileSync(sourceCode, fileName, compilerContext) { + throw new Error("Implement me!"); + } + + /** + * Returns a version number representing the version of the underlying + * compiler library. When this number changes, electron-compile knows + * to throw all away its generated code. + * + * @return {string} A version number. Note that this string isn't + * parsed in any way, just compared to the previous + * one for equality. + * + * @abstract + */ + getCompilerVersion() { + throw new Error("Implement me!"); + } +} + +exports.CompilerBase = CompilerBase; /** + * This class implements all of the async methods of CompilerBase by just + * calling the sync version. Use it to save some time when implementing + * simple compilers. + * + * To use it, implement the compile method, the getCompilerVersion method, + * and the getInputMimeTypes static method. + * + * @abstract + */ + +class SimpleCompilerBase extends CompilerBase { + constructor() { + super(); + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + return _asyncToGenerator(function* () { + return []; + })(); + } + + compile(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + return _this.compileSync(sourceCode, filePath, compilerContext); + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + return []; + } +} +exports.SimpleCompilerBase = SimpleCompilerBase; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/compiler-base.js"],"names":["CompilerBase","constructor","compilerOptions","getInputMimeTypes","Error","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","compile","shouldCompileFileSync","determineDependentFilesSync","compileSync","getCompilerVersion","SimpleCompilerBase","filePath"],"mappings":";;;;;;;;AAAA;;;;;;;AAOO,MAAMA,YAAN,CAAmB;AACxBC,gBAAc;AACZ,SAAKC,eAAL,GAAuB,EAAvB;AACD;;AAED;;;;;;;;;;AAUA,SAAOC,iBAAP,GAA2B;AACzB,UAAM,IAAIC,KAAJ,CAAU,eAAV,CAAN;AACD;;AAGD;;;;;;;;;;;AAWMC,mBAAN,CAAwBC,QAAxB,EAAkCC,eAAlC,EAAmD;AAAA;AACjD,YAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AADiD;AAElD;;AAGD;;;;;;;;;;;;;;;;AAgBMI,yBAAN,CAA8BC,UAA9B,EAA0CH,QAA1C,EAAoDC,eAApD,EAAqE;AAAA;AACnE,YAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AADmE;AAEpE;;AAGD;;;;;;;;;;;;;;;AAeMM,SAAN,CAAcD,UAAd,EAA0BH,QAA1B,EAAoCC,eAApC,EAAqD;AAAA;AACnD,YAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AADmD;AAEpD;;AAEDO,wBAAsBL,QAAtB,EAAgCC,eAAhC,EAAiD;AAC/C,UAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AACD;;AAEDQ,8BAA4BH,UAA5B,EAAwCH,QAAxC,EAAkDC,eAAlD,EAAmE;AACjE,UAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AACD;;AAEDS,cAAYJ,UAAZ,EAAwBH,QAAxB,EAAkCC,eAAlC,EAAmD;AACjD,UAAM,IAAIH,KAAJ,CAAU,eAAV,CAAN;AACD;;AAED;;;;;;;;;;;AAWAU,uBAAqB;AACnB,UAAM,IAAIV,KAAJ,CAAU,eAAV,CAAN;AACD;AArGuB;;QAAbJ,Y,GAAAA,Y,EAyGb;;;;;;;;;;;AAUO,MAAMe,kBAAN,SAAiCf,YAAjC,CAA8C;AACnDC,gBAAc;AACZ;AACD;;AAEKI,mBAAN,CAAwBC,QAAxB,EAAkCC,eAAlC,EAAmD;AAAA;AACjD,aAAO,IAAP;AADiD;AAElD;;AAEKC,yBAAN,CAA8BC,UAA9B,EAA0CO,QAA1C,EAAoDT,eAApD,EAAqE;AAAA;AACnE,aAAO,EAAP;AADmE;AAEpE;;AAEKG,SAAN,CAAcD,UAAd,EAA0BO,QAA1B,EAAoCT,eAApC,EAAqD;AAAA;;AAAA;AACnD,aAAO,MAAKM,WAAL,CAAiBJ,UAAjB,EAA6BO,QAA7B,EAAuCT,eAAvC,CAAP;AADmD;AAEpD;;AAEDI,wBAAsBL,QAAtB,EAAgCC,eAAhC,EAAiD;AAC/C,WAAO,IAAP;AACD;;AAEDK,8BAA4BH,UAA5B,EAAwCO,QAAxC,EAAkDT,eAAlD,EAAmE;AACjE,WAAO,EAAP;AACD;AAvBkD;QAAxCQ,kB,GAAAA,kB","file":"compiler-base.js","sourcesContent":["/**\n * This class is the base interface for compilers that are used by \n * electron-compile. If your compiler library only supports a \n * synchronous API, use SimpleCompilerBase instead.\n *\n * @interface\n */ \nexport class CompilerBase {\n  constructor() {\n    this.compilerOptions = {};\n  }\n  \n  /**  \n   * This method describes the MIME types that your compiler supports as input. \n   * Many precompiled file types don't have a specific MIME type, so if it's not\n   * recognized by the mime-types package, you need to patch rig-mime-types in\n   * electron-compile.\n   *\n   * @return {string[]}  An array of MIME types that this compiler can compile.\n   *\n   * @abstract\n   */   \n  static getInputMimeTypes() {\n    throw new Error(\"Implement me!\");\n  }\n\n\n  /**\n   * Determines whether a file should be compiled\n   *    \n   * @param  {string} fileName        The full path of a file to compile.\n   * @param  {object} compilerContext An object that compilers can add extra\n                                    information to as part of a job - the caller\n                                    won't do anything with this.\n   * @return {Promise<bool>}        True if you are able to compile this file.\n   *\n   * @abstract\n   */   \n  async shouldCompileFile(fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  \n  /**  \n   * Returns the dependent files of this file. This is used for languages such\n   * as LESS which allow you to import / reference other related files. In future\n   * versions of electron-compile, we will use this information to invalidate\n   * all of the parent files if a child file changes.\n   *    \n   * @param  {string} sourceCode    The contents of filePath\n   * @param  {string} fileName        The full path of a file to compile.\n   * @param  {object} compilerContext An object that compilers can add extra\n                                    information to as part of a job - the caller\n                                    won't do anything with this.\n   * @return {Promise<string[]>}    An array of dependent file paths, or an empty\n   *                                array if there are no dependent files. \n   *\n   * @abstract\n   */   \n  async determineDependentFiles(sourceCode, fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  \n  /**  \n   * Compiles the file\n   *    \n   * @param  {string} sourceCode    The contents of filePath\n   * @param  {string} fileName      The full path of a file to compile.\n   * @param  {object} compilerContext An object that compilers can add extra\n                                    information to as part of a job - the caller\n                                    won't do anything with this.\n   * @return {Promise<object>}      An object representing the compiled result\n   * @property {string} code        The compiled code\n   * @property {string} mimeType    The MIME type of the compiled result, which \n   *                                should exist in the mime-types database.\n   *\n   * @abstract\n   */   \n  async compile(sourceCode, fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  determineDependentFilesSync(sourceCode, fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  compileSync(sourceCode, fileName, compilerContext) {\n    throw new Error(\"Implement me!\");\n  }\n\n  /**\n   * Returns a version number representing the version of the underlying \n   * compiler library. When this number changes, electron-compile knows\n   * to throw all away its generated code.\n   *    \n   * @return {string}  A version number. Note that this string isn't \n   *                   parsed in any way, just compared to the previous\n   *                   one for equality.\n   *\n   * @abstract\n   */   \n  getCompilerVersion() {\n    throw new Error(\"Implement me!\");\n  }\n}\n\n\n/**\n * This class implements all of the async methods of CompilerBase by just \n * calling the sync version. Use it to save some time when implementing \n * simple compilers.\n *\n * To use it, implement the compile method, the getCompilerVersion method, \n * and the getInputMimeTypes static method. \n * \n * @abstract\n */ \nexport class SimpleCompilerBase extends CompilerBase {\n  constructor() {\n    super();\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    return this.compileSync(sourceCode, filePath, compilerContext);\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/css/less.js b/lib/css/less.js new file mode 100644 index 0000000..cf1cf67 --- /dev/null +++ b/lib/css/less.js @@ -0,0 +1,174 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _detectiveLess = require('detective-less'); + +var _detectiveLess2 = _interopRequireDefault(_detectiveLess); + +var _compilerBase = require('../compiler-base'); + +var _toutsuite = require('toutsuite'); + +var _toutsuite2 = _interopRequireDefault(_toutsuite); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +const mimeTypes = ['text/less']; +let lessjs = null; + +/** + * @access private + */ +class LessCompiler extends _compilerBase.CompilerBase { + constructor() { + super(); + + this.compilerOptions = { + sourceMap: { sourceMapFileInline: true } + }; + + this.seenFilePaths = {}; + } + + static getInputMimeTypes() { + return mimeTypes; + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + return _this.determineDependentFilesSync(sourceCode, filePath, compilerContext); + })(); + } + + compile(sourceCode, filePath, compilerContext) { + var _this2 = this; + + return _asyncToGenerator(function* () { + lessjs = lessjs || _this2.getLess(); + + let thisPath = _path2.default.dirname(filePath); + _this2.seenFilePaths[thisPath] = true; + + let paths = Object.keys(_this2.seenFilePaths); + + if (_this2.compilerOptions.paths) { + paths.push(..._this2.compilerOptions.paths); + } + + let opts = Object.assign({}, _this2.compilerOptions, { + paths: paths, + filename: _path2.default.basename(filePath) + }); + + let result = yield lessjs.render(sourceCode, opts); + let source = result.css; + + // NB: If you compile a file that is solely imports, its + // actual content is '' yet it is a valid file. '' is not + // truthy, so we're going to replace it with a string that + // is truthy. + if (!source && typeof source === 'string') { + source = ' '; + } + + return { + code: source, + mimeType: 'text/css' + }; + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + let dependencyFilenames = (0, _detectiveLess2.default)(sourceCode); + let dependencies = []; + + for (let dependencyName of dependencyFilenames) { + dependencies.push(_path2.default.join(_path2.default.dirname(filePath), dependencyName)); + } + + return dependencies; + } + + compileSync(sourceCode, filePath, compilerContext) { + lessjs = lessjs || this.getLess(); + + let source; + let error = null; + + let thisPath = _path2.default.dirname(filePath); + this.seenFilePaths[thisPath] = true; + + let paths = Object.keys(this.seenFilePaths); + + if (this.compilerOptions.paths) { + paths.push(...this.compilerOptions.paths); + } + + let opts = Object.assign({}, this.compilerOptions, { + paths: paths, + filename: _path2.default.basename(filePath), + fileAsync: false, async: false, syncImport: true + }); + + (0, _toutsuite2.default)(() => { + lessjs.render(sourceCode, opts, (err, out) => { + if (err) { + error = err; + } else { + // NB: Because we've forced less to work in sync mode, we can do this + source = out.css; + } + }); + }); + + if (error) { + throw error; + } + + // NB: If you compile a file that is solely imports, its + // actual content is '' yet it is a valid file. '' is not + // truthy, so we're going to replace it with a string that + // is truthy. + if (!source && typeof source === 'string') { + source = ' '; + } + + return { + code: source, + mimeType: 'text/css' + }; + } + + getLess() { + let ret; + (0, _toutsuite2.default)(() => ret = require('less')); + return ret; + } + + getCompilerVersion() { + return require('less/package.json').version; + } +} +exports.default = LessCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/less.js"],"names":["mimeTypes","lessjs","LessCompiler","constructor","compilerOptions","sourceMap","sourceMapFileInline","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getLess","thisPath","dirname","paths","Object","keys","push","opts","assign","filename","basename","result","render","source","css","code","mimeType","shouldCompileFileSync","dependencyFilenames","dependencies","dependencyName","join","compileSync","error","fileAsync","async","syncImport","err","out","ret","require","getCompilerVersion","version"],"mappings":"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","file":"less.js","sourcesContent":["import path from 'path';\nimport detective from 'detective-less';\nimport {CompilerBase} from '../compiler-base';\nimport toutSuite from 'toutsuite';\n\nconst mimeTypes = ['text/less'];\nlet lessjs = null;\n\n/**\n * @access private\n */\nexport default class LessCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      sourceMap: { sourceMapFileInline: true }\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    lessjs = lessjs || this.getLess();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      paths: paths,\n      filename: path.basename(filePath)\n    });\n\n    let result = await lessjs.render(sourceCode, opts);\n    let source = result.css;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source && typeof source === 'string') {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = detective(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(path.join(path.dirname(filePath), dependencyName));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    lessjs = lessjs || this.getLess();\n\n    let source;\n    let error = null;\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      paths: paths,\n      filename: path.basename(filePath),\n      fileAsync: false, async: false, syncImport: true\n    });\n\n    toutSuite(() => {\n      lessjs.render(sourceCode, opts, (err, out) => {\n        if (err) {\n          error = err;\n        } else {\n          // NB: Because we've forced less to work in sync mode, we can do this\n          source = out.css;\n        }\n      });\n    });\n\n    if (error) {\n      throw error;\n    }\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source && typeof source === 'string') {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getLess() {\n    let ret;\n    toutSuite(() => ret = require('less'));\n    return ret;\n  }\n\n  getCompilerVersion() {\n    return require('less/package.json').version;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/css/sass.js b/lib/css/sass.js new file mode 100644 index 0000000..2b4316a --- /dev/null +++ b/lib/css/sass.js @@ -0,0 +1,277 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _fs = require('fs'); + +var _fs2 = _interopRequireDefault(_fs); + +var _toutsuite = require('toutsuite'); + +var _toutsuite2 = _interopRequireDefault(_toutsuite); + +var _detectiveSass = require('detective-sass'); + +var _detectiveSass2 = _interopRequireDefault(_detectiveSass); + +var _detectiveScss = require('detective-scss'); + +var _detectiveScss2 = _interopRequireDefault(_detectiveScss); + +var _sassLookup = require('sass-lookup'); + +var _sassLookup2 = _interopRequireDefault(_sassLookup); + +var _compilerBase = require('../compiler-base'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +const mimeTypes = ['text/sass', 'text/scss']; +let sass = null; + +/** + * @access private + */ +class SassCompiler extends _compilerBase.CompilerBase { + constructor() { + super(); + + this.compilerOptions = { + comments: true, + sourceMapEmbed: true, + sourceMapContents: true + }; + + this.seenFilePaths = {}; + } + + static getInputMimeTypes() { + return mimeTypes; + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + return _this.determineDependentFilesSync(sourceCode, filePath, compilerContext); + })(); + } + + compile(sourceCode, filePath, compilerContext) { + var _this2 = this; + + return _asyncToGenerator(function* () { + sass = sass || _this2.getSass(); + + let thisPath = _path2.default.dirname(filePath); + _this2.seenFilePaths[thisPath] = true; + + let paths = Object.keys(_this2.seenFilePaths); + + if (_this2.compilerOptions.paths) { + paths.push(..._this2.compilerOptions.paths); + } + + paths.unshift('.'); + + sass.importer(_this2.buildImporterCallback(paths)); + + let opts = Object.assign({}, _this2.compilerOptions, { + indentedSyntax: filePath.match(/\.sass$/i), + sourceMapRoot: filePath + }); + + // not a valid option + delete opts.paths; + + let result = yield new Promise(function (res, rej) { + sass.compile(sourceCode, opts, function (r) { + if (r.status !== 0) { + rej(new Error(r.formatted || r.message)); + return; + } + + res(r); + return; + }); + }); + + let source = result.text; + + // NB: If you compile a file that is solely imports, its + // actual content is '' yet it is a valid file. '' is not + // truthy, so we're going to replace it with a string that + // is truthy. + if (!source) { + source = ' '; + } + + return { + code: source, + mimeType: 'text/css' + }; + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + let dependencyFilenames = _path2.default.extname(filePath) === '.sass' ? (0, _detectiveSass2.default)(sourceCode) : (0, _detectiveScss2.default)(sourceCode); + let dependencies = []; + + for (let dependencyName of dependencyFilenames) { + dependencies.push((0, _sassLookup2.default)(dependencyName, _path2.default.basename(filePath), _path2.default.dirname(filePath))); + } + + return dependencies; + } + + compileSync(sourceCode, filePath, compilerContext) { + sass = sass || this.getSass(); + + let thisPath = _path2.default.dirname(filePath); + this.seenFilePaths[thisPath] = true; + + let paths = Object.keys(this.seenFilePaths); + + if (this.compilerOptions.paths) { + paths.push(...this.compilerOptions.paths); + } + + paths.unshift('.'); + sass.importer(this.buildImporterCallback(paths)); + + let opts = Object.assign({}, this.compilerOptions, { + indentedSyntax: filePath.match(/\.sass$/i), + sourceMapRoot: filePath + }); + + let result; + (0, _toutsuite2.default)(() => { + sass.compile(sourceCode, opts, r => { + if (r.status !== 0) { + throw new Error(r.formatted); + } + result = r; + }); + }); + + let source = result.text; + + // NB: If you compile a file that is solely imports, its + // actual content is '' yet it is a valid file. '' is not + // truthy, so we're going to replace it with a string that + // is truthy. + if (!source) { + source = ' '; + } + + return { + code: source, + mimeType: 'text/css' + }; + } + + getSass() { + let ret; + (0, _toutsuite2.default)(() => ret = require('sass.js/dist/sass.node').Sass); + return ret; + } + + buildImporterCallback(includePaths) { + const self = this; + return function (request, done) { + let file; + if (request.file) { + done(); + return; + } else { + // sass.js works in the '/sass/' directory + let cleanedRequestPath = request.resolved.replace(/^\/sass\//, ''); + + // if we are importing from the entry file (stdin) the path is + // resolved with a leading '/'' -> remove it + if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') { + cleanedRequestPath = cleanedRequestPath.substring(1); + } + + for (let includePath of includePaths) { + const filePath = _path2.default.resolve(includePath, cleanedRequestPath); + let variations = sass.getPathVariations(filePath); + + file = variations.map(self.fixWindowsPath.bind(self)).reduce(self.importedFileReducer.bind(self), null); + + if (file) { + const content = _fs2.default.readFileSync(file, { encoding: 'utf8' }); + return sass.writeFile(file, content, () => { + done({ path: file }); + return; + }); + } + } + + if (!file) { + done(); + return; + } + } + }; + } + + importedFileReducer(found, path) { + // Find the first variation that actually exists + if (found) return found; + + try { + const stat = _fs2.default.statSync(path); + if (!stat.isFile()) return null; + return path; + } catch (e) { + return null; + } + } + + fixWindowsPath(file) { + // Unfortunately, there's a bug in sass.js that seems to ignore the different + // path separators across platforms + + // For some reason, some files have a leading slash that we need to get rid of + if (process.platform === 'win32' && file[0] === '/') { + file = file.slice(1); + } + + // Sass.js generates paths such as `_C:\myPath\file.sass` instead of `C:\myPath\_file.sass` + if (file[0] === '_') { + const parts = file.slice(1).split(_path2.default.sep); + const dir = parts.slice(0, -1).join(_path2.default.sep); + const fileName = parts.reverse()[0]; + file = _path2.default.resolve(dir, '_' + fileName); + } + return file; + } + + getCompilerVersion() { + // NB: There is a bizarre bug in the node module system where this doesn't + // work but only in saveConfiguration tests + //return require('@paulcbetts/node-sass/package.json').version; + return "4.1.1"; + } +} +exports.default = SassCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/sass.js"],"names":["mimeTypes","sass","SassCompiler","constructor","compilerOptions","comments","sourceMapEmbed","sourceMapContents","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getSass","thisPath","dirname","paths","Object","keys","push","unshift","importer","buildImporterCallback","opts","assign","indentedSyntax","match","sourceMapRoot","result","Promise","res","rej","r","status","Error","formatted","message","source","text","code","mimeType","shouldCompileFileSync","dependencyFilenames","extname","dependencies","dependencyName","basename","compileSync","ret","require","Sass","includePaths","self","request","done","file","cleanedRequestPath","resolved","replace","previous","charAt","substring","includePath","resolve","variations","getPathVariations","map","fixWindowsPath","bind","reduce","importedFileReducer","content","readFileSync","encoding","writeFile","path","found","stat","statSync","isFile","e","process","platform","slice","parts","split","sep","dir","join","reverse","getCompilerVersion"],"mappings":";;;;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA,MAAMA,YAAY,CAAC,WAAD,EAAc,WAAd,CAAlB;AACA,IAAIC,OAAO,IAAX;;AAEA;;;AAGe,MAAMC,YAAN,oCAAwC;AACrDC,gBAAc;AACZ;;AAEA,SAAKC,eAAL,GAAuB;AACrBC,gBAAU,IADW;AAErBC,sBAAgB,IAFK;AAGrBC,yBAAmB;AAHE,KAAvB;;AAMA,SAAKC,aAAL,GAAqB,EAArB;AACD;;AAED,SAAOC,iBAAP,GAA2B;AACzB,WAAOT,SAAP;AACD;;AAEKU,mBAAN,CAAwBC,QAAxB,EAAkCC,eAAlC,EAAmD;AAAA;AACjD,aAAO,IAAP;AADiD;AAElD;;AAEKC,yBAAN,CAA8BC,UAA9B,EAA0CC,QAA1C,EAAoDH,eAApD,EAAqE;AAAA;;AAAA;AACnE,aAAO,MAAKI,2BAAL,CAAiCF,UAAjC,EAA6CC,QAA7C,EAAuDH,eAAvD,CAAP;AADmE;AAEpE;;AAEKK,SAAN,CAAcH,UAAd,EAA0BC,QAA1B,EAAoCH,eAApC,EAAqD;AAAA;;AAAA;AACnDX,aAAOA,QAAQ,OAAKiB,OAAL,EAAf;;AAEA,UAAIC,WAAW,eAAKC,OAAL,CAAaL,QAAb,CAAf;AACA,aAAKP,aAAL,CAAmBW,QAAnB,IAA+B,IAA/B;;AAEA,UAAIE,QAAQC,OAAOC,IAAP,CAAY,OAAKf,aAAjB,CAAZ;;AAEA,UAAI,OAAKJ,eAAL,CAAqBiB,KAAzB,EAAgC;AAC9BA,cAAMG,IAAN,CAAW,GAAG,OAAKpB,eAAL,CAAqBiB,KAAnC;AACD;;AAEDA,YAAMI,OAAN,CAAc,GAAd;;AAEAxB,WAAKyB,QAAL,CAAc,OAAKC,qBAAL,CAA2BN,KAA3B,CAAd;;AAEA,UAAIO,OAAON,OAAOO,MAAP,CAAc,EAAd,EAAkB,OAAKzB,eAAvB,EAAwC;AACjD0B,wBAAgBf,SAASgB,KAAT,CAAe,UAAf,CADiC;AAEjDC,uBAAejB;AAFkC,OAAxC,CAAX;;AAKA;AACA,aAAOa,KAAKP,KAAZ;;AAEA,UAAIY,SAAS,MAAM,IAAIC,OAAJ,CAAY,UAACC,GAAD,EAAKC,GAAL,EAAa;AAC1CnC,aAAKgB,OAAL,CAAaH,UAAb,EAAyBc,IAAzB,EAA+B,UAACS,CAAD,EAAO;AACpC,cAAIA,EAAEC,MAAF,KAAa,CAAjB,EAAoB;AAClBF,gBAAI,IAAIG,KAAJ,CAAUF,EAAEG,SAAF,IAAeH,EAAEI,OAA3B,CAAJ;AACA;AACD;;AAEDN,cAAIE,CAAJ;AACA;AACD,SARD;AASD,OAVkB,CAAnB;;AAYA,UAAIK,SAAST,OAAOU,IAApB;;AAEA;AACA;AACA;AACA;AACA,UAAI,CAACD,MAAL,EAAa;AACXA,iBAAS,GAAT;AACD;;AAED,aAAO;AACLE,cAAMF,MADD;AAELG,kBAAU;AAFL,OAAP;AA9CmD;AAkDpD;;AAEDC,wBAAsBnC,QAAtB,EAAgCC,eAAhC,EAAiD;AAC/C,WAAO,IAAP;AACD;;AAEDI,8BAA4BF,UAA5B,EAAwCC,QAAxC,EAAkDH,eAAlD,EAAmE;AACjE,QAAImC,sBAAsB,eAAKC,OAAL,CAAajC,QAAb,MAA2B,OAA3B,GAAqC,6BAAcD,UAAd,CAArC,GAAiE,6BAAcA,UAAd,CAA3F;AACA,QAAImC,eAAe,EAAnB;;AAEA,SAAK,IAAIC,cAAT,IAA2BH,mBAA3B,EAAgD;AAC9CE,mBAAazB,IAAb,CAAkB,0BAAW0B,cAAX,EAA2B,eAAKC,QAAL,CAAcpC,QAAd,CAA3B,EAAoD,eAAKK,OAAL,CAAaL,QAAb,CAApD,CAAlB;AACD;;AAED,WAAOkC,YAAP;AACD;;AAEDG,cAAYtC,UAAZ,EAAwBC,QAAxB,EAAkCH,eAAlC,EAAmD;AACjDX,WAAOA,QAAQ,KAAKiB,OAAL,EAAf;;AAEA,QAAIC,WAAW,eAAKC,OAAL,CAAaL,QAAb,CAAf;AACA,SAAKP,aAAL,CAAmBW,QAAnB,IAA+B,IAA/B;;AAEA,QAAIE,QAAQC,OAAOC,IAAP,CAAY,KAAKf,aAAjB,CAAZ;;AAEA,QAAI,KAAKJ,eAAL,CAAqBiB,KAAzB,EAAgC;AAC9BA,YAAMG,IAAN,CAAW,GAAG,KAAKpB,eAAL,CAAqBiB,KAAnC;AACD;;AAEDA,UAAMI,OAAN,CAAc,GAAd;AACAxB,SAAKyB,QAAL,CAAc,KAAKC,qBAAL,CAA2BN,KAA3B,CAAd;;AAEA,QAAIO,OAAON,OAAOO,MAAP,CAAc,EAAd,EAAkB,KAAKzB,eAAvB,EAAwC;AACjD0B,sBAAgBf,SAASgB,KAAT,CAAe,UAAf,CADiC;AAEjDC,qBAAejB;AAFkC,KAAxC,CAAX;;AAKA,QAAIkB,MAAJ;AACA,6BAAU,MAAM;AACdhC,WAAKgB,OAAL,CAAaH,UAAb,EAAyBc,IAAzB,EAAgCS,CAAD,IAAO;AACpC,YAAIA,EAAEC,MAAF,KAAa,CAAjB,EAAoB;AAClB,gBAAM,IAAIC,KAAJ,CAAUF,EAAEG,SAAZ,CAAN;AACD;AACDP,iBAASI,CAAT;AACD,OALD;AAMD,KAPD;;AASA,QAAIK,SAAST,OAAOU,IAApB;;AAEA;AACA;AACA;AACA;AACA,QAAI,CAACD,MAAL,EAAa;AACXA,eAAS,GAAT;AACD;;AAED,WAAO;AACLE,YAAMF,MADD;AAELG,gBAAU;AAFL,KAAP;AAID;;AAED3B,YAAU;AACR,QAAImC,GAAJ;AACA,6BAAU,MAAMA,MAAMC,QAAQ,wBAAR,EAAkCC,IAAxD;AACA,WAAOF,GAAP;AACD;;AAED1B,wBAAuB6B,YAAvB,EAAqC;AACnC,UAAMC,OAAO,IAAb;AACA,WAAQ,UAAUC,OAAV,EAAmBC,IAAnB,EAAyB;AAC/B,UAAIC,IAAJ;AACA,UAAIF,QAAQE,IAAZ,EAAkB;AAChBD;AACA;AACD,OAHD,MAGO;AACL;AACA,YAAIE,qBAAqBH,QAAQI,QAAR,CAAiBC,OAAjB,CAAyB,WAAzB,EAAsC,EAAtC,CAAzB;;AAEA;AACA;AACA,YAAIL,QAAQM,QAAR,KAAqB,OAArB,IAAgCH,mBAAmBI,MAAnB,CAA0B,CAA1B,MAAiC,GAArE,EAA0E;AACxEJ,+BAAqBA,mBAAmBK,SAAnB,CAA6B,CAA7B,CAArB;AACD;;AAED,aAAK,IAAIC,WAAT,IAAwBX,YAAxB,EAAsC;AACpC,gBAAMzC,WAAW,eAAKqD,OAAL,CAAaD,WAAb,EAA0BN,kBAA1B,CAAjB;AACA,cAAIQ,aAAapE,KAAKqE,iBAAL,CAAuBvD,QAAvB,CAAjB;;AAEA6C,iBAAOS,WACJE,GADI,CACAd,KAAKe,cAAL,CAAoBC,IAApB,CAAyBhB,IAAzB,CADA,EAEJiB,MAFI,CAEGjB,KAAKkB,mBAAL,CAAyBF,IAAzB,CAA8BhB,IAA9B,CAFH,EAEwC,IAFxC,CAAP;;AAIA,cAAIG,IAAJ,EAAU;AACR,kBAAMgB,UAAU,aAAGC,YAAH,CAAgBjB,IAAhB,EAAsB,EAAEkB,UAAU,MAAZ,EAAtB,CAAhB;AACA,mBAAO7E,KAAK8E,SAAL,CAAenB,IAAf,EAAqBgB,OAArB,EAA8B,MAAM;AACzCjB,mBAAK,EAAEqB,MAAMpB,IAAR,EAAL;AACA;AACD,aAHM,CAAP;AAID;AACF;;AAED,YAAI,CAACA,IAAL,EAAW;AACTD;AACA;AACD;AACF;AACF,KArCD;AAsCD;;AAEDgB,sBAAoBM,KAApB,EAA2BD,IAA3B,EAAiC;AAC/B;AACA,QAAIC,KAAJ,EAAW,OAAOA,KAAP;;AAEX,QAAI;AACF,YAAMC,OAAO,aAAGC,QAAH,CAAYH,IAAZ,CAAb;AACA,UAAI,CAACE,KAAKE,MAAL,EAAL,EAAoB,OAAO,IAAP;AACpB,aAAOJ,IAAP;AACD,KAJD,CAIE,OAAMK,CAAN,EAAS;AACT,aAAO,IAAP;AACD;AACF;;AAEDb,iBAAeZ,IAAf,EAAqB;AACnB;AACA;;AAEA;AACA,QAAI0B,QAAQC,QAAR,KAAqB,OAArB,IAAgC3B,KAAK,CAAL,MAAY,GAAhD,EAAqD;AACnDA,aAAOA,KAAK4B,KAAL,CAAW,CAAX,CAAP;AACD;;AAED;AACA,QAAI5B,KAAK,CAAL,MAAY,GAAhB,EAAqB;AACnB,YAAM6B,QAAQ7B,KAAK4B,KAAL,CAAW,CAAX,EAAcE,KAAd,CAAoB,eAAKC,GAAzB,CAAd;AACA,YAAMC,MAAMH,MAAMD,KAAN,CAAY,CAAZ,EAAe,CAAC,CAAhB,EAAmBK,IAAnB,CAAwB,eAAKF,GAA7B,CAAZ;AACA,YAAMhF,WAAW8E,MAAMK,OAAN,GAAgB,CAAhB,CAAjB;AACAlC,aAAO,eAAKQ,OAAL,CAAawB,GAAb,EAAkB,MAAMjF,QAAxB,CAAP;AACD;AACD,WAAOiD,IAAP;AACD;;AAEDmC,uBAAqB;AACnB;AACA;AACA;AACA,WAAO,OAAP;AACD;AA/NoD;kBAAlC7F,Y","file":"sass.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport toutSuite from 'toutsuite';\nimport detectiveSASS from 'detective-sass';\nimport detectiveSCSS from 'detective-scss';\nimport sassLookup from 'sass-lookup';\nimport {CompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/sass', 'text/scss'];\nlet sass = null;\n\n/**\n * @access private\n */\nexport default class SassCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      comments: true,\n      sourceMapEmbed: true,\n      sourceMapContents: true\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    // not a valid option\n    delete opts.paths;\n\n    let result = await new Promise((res,rej) => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          rej(new Error(r.formatted || r.message));\n          return;\n        }\n\n        res(r);\n        return;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = path.extname(filePath) === '.sass' ? detectiveSASS(sourceCode) : detectiveSCSS(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(sassLookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    let result;\n    toutSuite(() => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          throw new Error(r.formatted);\n        }\n        result = r;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getSass() {\n    let ret;\n    toutSuite(() => ret = require('sass.js/dist/sass.node').Sass);\n    return ret;\n  }\n\n  buildImporterCallback (includePaths) {\n    const self = this;\n    return (function (request, done) {\n      let file;\n      if (request.file) {\n        done();\n        return;\n      } else {\n        // sass.js works in the '/sass/' directory\n        let cleanedRequestPath = request.resolved.replace(/^\\/sass\\//, '');\n\n        // if we are importing from the entry file (stdin) the path is\n        // resolved with a leading '/'' -> remove it\n        if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') {\n          cleanedRequestPath = cleanedRequestPath.substring(1);\n        }\n\n        for (let includePath of includePaths) {\n          const filePath = path.resolve(includePath, cleanedRequestPath);\n          let variations = sass.getPathVariations(filePath);\n\n          file = variations\n            .map(self.fixWindowsPath.bind(self))\n            .reduce(self.importedFileReducer.bind(self), null);\n\n          if (file) {\n            const content = fs.readFileSync(file, { encoding: 'utf8' });\n            return sass.writeFile(file, content, () => {\n              done({ path: file });\n              return;\n            });\n          }\n        }\n\n        if (!file) {\n          done();\n          return;\n        }\n      }\n    });\n  }\n\n  importedFileReducer(found, path) {\n    // Find the first variation that actually exists\n    if (found) return found;\n\n    try {\n      const stat = fs.statSync(path);\n      if (!stat.isFile()) return null;\n      return path;\n    } catch(e) {\n      return null;\n    }\n  }\n\n  fixWindowsPath(file) {\n    // Unfortunately, there's a bug in sass.js that seems to ignore the different\n    // path separators across platforms\n\n    // For some reason, some files have a leading slash that we need to get rid of\n    if (process.platform === 'win32' && file[0] === '/') {\n      file = file.slice(1);\n    }\n\n    // Sass.js generates paths such as `_C:\\myPath\\file.sass` instead of `C:\\myPath\\_file.sass`\n    if (file[0] === '_') {\n      const parts = file.slice(1).split(path.sep);\n      const dir = parts.slice(0, -1).join(path.sep);\n      const fileName = parts.reverse()[0];\n      file = path.resolve(dir, '_' + fileName);\n    }\n    return file;\n  }\n\n  getCompilerVersion() {\n    // NB: There is a bizarre bug in the node module system where this doesn't\n    // work but only in saveConfiguration tests\n    //return require('@paulcbetts/node-sass/package.json').version;\n    return \"4.1.1\";\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/css/stylus.js b/lib/css/stylus.js new file mode 100644 index 0000000..7a7ee96 --- /dev/null +++ b/lib/css/stylus.js @@ -0,0 +1,175 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _detectiveStylus = require('detective-stylus'); + +var _detectiveStylus2 = _interopRequireDefault(_detectiveStylus); + +var _stylusLookup = require('stylus-lookup'); + +var _stylusLookup2 = _interopRequireDefault(_stylusLookup); + +var _compilerBase = require('../compiler-base'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +const mimeTypes = ['text/stylus']; + +let stylusjs = null; +let nib = null; + +function each(obj, sel) { + for (let k in obj) { + sel(obj[k], k); + } +} + +/** + * @access private + */ +class StylusCompiler extends _compilerBase.CompilerBase { + constructor() { + super(); + + this.compilerOptions = { + sourcemap: 'inline', + import: ['nib'] + }; + + this.seenFilePaths = {}; + } + + static getInputMimeTypes() { + return mimeTypes; + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + return _this.determineDependentFilesSync(sourceCode, filePath, compilerContext); + })(); + } + + compile(sourceCode, filePath, compilerContext) { + var _this2 = this; + + return _asyncToGenerator(function* () { + nib = nib || require('nib'); + stylusjs = stylusjs || require('stylus'); + _this2.seenFilePaths[_path2.default.dirname(filePath)] = true; + + let opts = _this2.makeOpts(filePath); + + let code = yield new Promise(function (res, rej) { + let styl = stylusjs(sourceCode, opts); + + _this2.applyOpts(opts, styl); + + styl.render(function (err, css) { + if (err) { + rej(err); + } else { + res(css); + } + }); + }); + + return { + code, mimeType: 'text/css' + }; + })(); + } + + makeOpts(filePath) { + let opts = Object.assign({}, this.compilerOptions, { + filename: (0, _path.basename)(filePath) + }); + + if (opts.import && !Array.isArray(opts.import)) { + opts.import = [opts.import]; + } + + if (opts.import && opts.import.indexOf('nib') >= 0) { + opts.use = opts.use || []; + + if (!Array.isArray(opts.use)) { + opts.use = [opts.use]; + } + + opts.use.push(nib()); + } + + return opts; + } + + applyOpts(opts, stylus) { + each(opts, (val, key) => { + switch (key) { + case 'set': + case 'define': + each(val, (v, k) => stylus[key](k, v)); + break; + case 'include': + case 'import': + case 'use': + each(val, v => stylus[key](v)); + break; + } + }); + + stylus.set('paths', Object.keys(this.seenFilePaths).concat(['.'])); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + let dependencyFilenames = (0, _detectiveStylus2.default)(sourceCode); + let dependencies = []; + + for (let dependencyName of dependencyFilenames) { + dependencies.push((0, _stylusLookup2.default)(dependencyName, _path2.default.basename(filePath), _path2.default.dirname(filePath))); + } + + return dependencies; + } + + compileSync(sourceCode, filePath, compilerContext) { + nib = nib || require('nib'); + stylusjs = stylusjs || require('stylus'); + this.seenFilePaths[_path2.default.dirname(filePath)] = true; + + let opts = this.makeOpts(filePath), + styl = stylusjs(sourceCode, opts); + + this.applyOpts(opts, styl); + + return { + code: styl.render(), + mimeType: 'text/css' + }; + } + + getCompilerVersion() { + return require('stylus/package.json').version; + } +} +exports.default = StylusCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/stylus.js"],"names":["mimeTypes","stylusjs","nib","each","obj","sel","k","StylusCompiler","constructor","compilerOptions","sourcemap","import","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","require","dirname","opts","makeOpts","code","Promise","res","rej","styl","applyOpts","render","err","css","mimeType","Object","assign","filename","Array","isArray","indexOf","use","push","stylus","val","key","v","set","keys","concat","shouldCompileFileSync","dependencyFilenames","dependencies","dependencyName","basename","compileSync","getCompilerVersion","version"],"mappings":"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","file":"stylus.js","sourcesContent":["import path from 'path';\nimport detective from 'detective-stylus';\nimport lookup from 'stylus-lookup';\nimport {CompilerBase} from '../compiler-base';\nimport {basename} from 'path';\n\nconst mimeTypes = ['text/stylus'];\n\nlet stylusjs = null;\nlet nib = null;\n\nfunction each(obj, sel) {\n  for (let k in obj) {\n    sel(obj[k], k);\n  }\n}\n\n/**\n * @access private\n */\nexport default class StylusCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      sourcemap: 'inline',\n      import: ['nib']\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    nib = nib || require('nib');\n    stylusjs = stylusjs || require('stylus');\n    this.seenFilePaths[path.dirname(filePath)] = true;\n\n    let opts = this.makeOpts(filePath);\n\n    let code = await new Promise((res,rej) => {\n      let styl = stylusjs(sourceCode, opts);\n\n      this.applyOpts(opts, styl);\n\n      styl.render((err, css) => {\n        if (err) {\n          rej(err);\n        } else {\n          res(css);\n        }\n      });\n    });\n\n    return {\n      code, mimeType: 'text/css'\n    };\n  }\n\n  makeOpts(filePath) {\n    let opts = Object.assign({}, this.compilerOptions, {\n      filename: basename(filePath)\n    });\n\n    if (opts.import && !Array.isArray(opts.import)) {\n      opts.import = [opts.import];\n    }\n\n    if (opts.import && opts.import.indexOf('nib') >= 0) {\n      opts.use = opts.use || [];\n\n      if (!Array.isArray(opts.use)) {\n        opts.use = [opts.use];\n      }\n\n      opts.use.push(nib());\n    }\n\n    return opts;\n  }\n  \n  \n  applyOpts(opts, stylus) {\n    each(opts, (val, key) => {\n      switch(key) {\n      case 'set':\n      case 'define':\n        each(val, (v, k) => stylus[key](k, v));\n        break;\n      case 'include':\n      case 'import':\n      case 'use':\n        each(val, (v) => stylus[key](v));\n        break;\n      }\n    });\n\n    stylus.set('paths', Object.keys(this.seenFilePaths).concat(['.']));\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = detective(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(lookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    nib = nib || require('nib');\n    stylusjs = stylusjs || require('stylus');\n    this.seenFilePaths[path.dirname(filePath)] = true;\n\n    let opts = this.makeOpts(filePath), styl = stylusjs(sourceCode, opts);\n\n    this.applyOpts(opts, styl);\n\n    return {\n      code: styl.render(),\n      mimeType: 'text/css'\n    };\n  }\n\n  getCompilerVersion() {\n    return require('stylus/package.json').version;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/html/inline-html.js b/lib/html/inline-html.js new file mode 100644 index 0000000..e05d8d7 --- /dev/null +++ b/lib/html/inline-html.js @@ -0,0 +1,344 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _mimeTypes = require('@paulcbetts/mime-types'); + +var _mimeTypes2 = _interopRequireDefault(_mimeTypes); + +var _compilerBase = require('../compiler-base'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +const inputMimeTypes = ['text/html']; +let cheerio = null; + +const d = require('debug')('electron-compile:inline-html'); + +const compiledCSS = { + 'text/less': true, + 'text/scss': true, + 'text/sass': true, + 'text/stylus': true +}; + +/** + * @access private + */ +class InlineHtmlCompiler extends _compilerBase.CompilerBase { + constructor(compileBlock, compileBlockSync) { + super(); + + this.compileBlock = compileBlock; + this.compileBlockSync = compileBlockSync; + } + + static createFromCompilers(compilersByMimeType) { + d(`Setting up inline HTML compilers: ${JSON.stringify(Object.keys(compilersByMimeType))}`); + + let compileBlock = (() => { + var _ref = _asyncToGenerator(function* (sourceCode, filePath, mimeType, ctx) { + let realType = mimeType; + if (!mimeType && ctx.tag === 'script') realType = 'application/javascript'; + + if (!realType) return sourceCode; + + let compiler = compilersByMimeType[realType] || compilersByMimeType['text/plain']; + let ext = _mimeTypes2.default.extension(realType); + let fakeFile = `${filePath}:inline_${ctx.count}.${ext}`; + + d(`Compiling inline block for ${filePath} with mimeType ${mimeType}`); + if (!(yield compiler.shouldCompileFile(fakeFile, ctx))) return sourceCode; + return (yield compiler.compileSync(sourceCode, fakeFile, ctx)).code; + }); + + return function compileBlock(_x, _x2, _x3, _x4) { + return _ref.apply(this, arguments); + }; + })(); + + let compileBlockSync = (sourceCode, filePath, mimeType, ctx) => { + let realType = mimeType; + if (!mimeType && ctx.tag === 'script') realType = 'application/javascript'; + + if (!realType) return sourceCode; + + let compiler = compilersByMimeType[realType] || compilersByMimeType['text/plain']; + let ext = _mimeTypes2.default.extension(realType); + let fakeFile = `${filePath}:inline_${ctx.count}.${ext}`; + + d(`Compiling inline block for ${filePath} with mimeType ${mimeType}`); + if (!compiler.shouldCompileFileSync(fakeFile, ctx)) return sourceCode; + return compiler.compileSync(sourceCode, fakeFile, ctx).code; + }; + + return new InlineHtmlCompiler(compileBlock, compileBlockSync); + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + return _asyncToGenerator(function* () { + return []; + })(); + } + + each(nodes, selector) { + return _asyncToGenerator(function* () { + let acc = []; + nodes.each(function (i, el) { + let promise = selector(i, el); + if (!promise) return false; + + acc.push(promise); + return true; + }); + + yield Promise.all(acc); + })(); + } + + eachSync(nodes, selector) { + // NB: This method is here just so it's easier to mechanically + // translate the async compile to compileSync + return nodes.each((i, el) => { + selector(i, el); + return true; + }); + } + + compile(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + cheerio = cheerio || require('cheerio'); + + //Leave the attributes casing as it is, because of Angular 2 and maybe other case-sensitive frameworks + let $ = cheerio.load(sourceCode, { lowerCaseAttributeNames: false }); + let toWait = []; + + let that = _this; + let styleCount = 0; + toWait.push(_this.each($('style'), (() => { + var _ref2 = _asyncToGenerator(function* (i, el) { + let mimeType = $(el).attr('type') || 'text/plain'; + + let thisCtx = Object.assign({ + count: styleCount++, + tag: 'style' + }, compilerContext); + + let origText = $(el).text(); + let newText = yield that.compileBlock(origText, filePath, mimeType, thisCtx); + + if (origText !== newText) { + $(el).text(newText); + $(el).attr('type', 'text/css'); + } + }); + + return function (_x5, _x6) { + return _ref2.apply(this, arguments); + }; + })())); + + let scriptCount = 0; + toWait.push(_this.each($('script'), (() => { + var _ref3 = _asyncToGenerator(function* (i, el) { + let src = $(el).attr('src'); + if (src && src.length > 2) { + $(el).attr('src', InlineHtmlCompiler.fixupRelativeUrl(src)); + return; + } + + let thisCtx = Object.assign({ + count: scriptCount++, + tag: 'script' + }, compilerContext); + + let mimeType = $(el).attr('type') || 'application/javascript'; + let origText = $(el).text(); + let newText = yield that.compileBlock(origText, filePath, mimeType, thisCtx); + + if (origText !== newText) { + $(el).text(newText); + $(el).attr('type', 'application/javascript'); + } + }); + + return function (_x7, _x8) { + return _ref3.apply(this, arguments); + }; + })())); + + $('link').map(function (i, el) { + let href = $(el).attr('href'); + if (href && href.length > 2) { + $(el).attr('href', InlineHtmlCompiler.fixupRelativeUrl(href)); + } + + // NB: In recent versions of Chromium, the link type MUST be text/css or + // it will be flat-out ignored. Also I hate myself for hardcoding these. + let type = $(el).attr('type'); + if (compiledCSS[type]) $(el).attr('type', 'text/css'); + }); + + $('x-require').map(function (i, el) { + let src = $(el).attr('src'); + + // File URL? Bail + if (src.match(/^file:/i)) return; + + // Absolute path? Bail. + if (src.match(/^([\/]|[A-Za-z]:)/i)) return; + + try { + $(el).attr('src', _path2.default.resolve(_path2.default.dirname(filePath), src)); + } catch (e) { + $(el).text(`${e.message}\n${e.stack}`); + } + }); + + yield Promise.all(toWait); + + return { + code: $.html(), + mimeType: 'text/html' + }; + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + return []; + } + + compileSync(sourceCode, filePath, compilerContext) { + cheerio = cheerio || require('cheerio'); + + //Leave the attributes casing as it is, because of Angular 2 and maybe other case-sensitive frameworks + let $ = cheerio.load(sourceCode, { lowerCaseAttributeNames: false }); + + let that = this; + let styleCount = 0; + this.eachSync($('style'), (() => { + var _ref4 = _asyncToGenerator(function* (i, el) { + let mimeType = $(el).attr('type'); + + let thisCtx = Object.assign({ + count: styleCount++, + tag: 'style' + }, compilerContext); + + let origText = $(el).text(); + let newText = that.compileBlockSync(origText, filePath, mimeType, thisCtx); + + if (origText !== newText) { + $(el).text(newText); + $(el).attr('type', 'text/css'); + } + }); + + return function (_x9, _x10) { + return _ref4.apply(this, arguments); + }; + })()); + + let scriptCount = 0; + this.eachSync($('script'), (() => { + var _ref5 = _asyncToGenerator(function* (i, el) { + let src = $(el).attr('src'); + if (src && src.length > 2) { + $(el).attr('src', InlineHtmlCompiler.fixupRelativeUrl(src)); + return; + } + + let thisCtx = Object.assign({ + count: scriptCount++, + tag: 'script' + }, compilerContext); + + let mimeType = $(el).attr('type'); + + let oldText = $(el).text(); + let newText = that.compileBlockSync(oldText, filePath, mimeType, thisCtx); + + if (oldText !== newText) { + $(el).text(newText); + $(el).attr('type', 'application/javascript'); + } + }); + + return function (_x11, _x12) { + return _ref5.apply(this, arguments); + }; + })()); + + $('link').map((i, el) => { + let href = $(el).attr('href'); + if (href && href.length > 2) { + $(el).attr('href', InlineHtmlCompiler.fixupRelativeUrl(href)); + } + + // NB: In recent versions of Chromium, the link type MUST be text/css or + // it will be flat-out ignored. Also I hate myself for hardcoding these. + let type = $(el).attr('type'); + if (compiledCSS[type]) $(el).attr('type', 'text/css'); + }); + + $('x-require').map((i, el) => { + let src = $(el).attr('src'); + + // File URL? Bail + if (src.match(/^file:/i)) return; + + // Absolute path? Bail. + if (src.match(/^([\/]|[A-Za-z]:)/i)) return; + + try { + $(el).attr('src', _path2.default.resolve(_path2.default.dirname(filePath), src)); + } catch (e) { + $(el).text(`${e.message}\n${e.stack}`); + } + }); + + return { + code: $.html(), + mimeType: 'text/html' + }; + } + + getCompilerVersion() { + let thisVersion = require('../../package.json').version; + let compilers = this.allCompilers || []; + let otherVersions = compilers.map(x => x.getCompilerVersion).join(); + + return `${thisVersion},${otherVersions}`; + } + + static fixupRelativeUrl(url) { + if (!url.match(/^\/\//)) return url; + return `https:${url}`; + } +} +exports.default = InlineHtmlCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/html/inline-html.js"],"names":["inputMimeTypes","cheerio","d","require","compiledCSS","InlineHtmlCompiler","constructor","compileBlock","compileBlockSync","createFromCompilers","compilersByMimeType","JSON","stringify","Object","keys","sourceCode","filePath","mimeType","ctx","realType","tag","compiler","ext","extension","fakeFile","count","shouldCompileFile","compileSync","code","shouldCompileFileSync","getInputMimeTypes","fileName","compilerContext","determineDependentFiles","each","nodes","selector","acc","i","el","promise","push","Promise","all","eachSync","compile","$","load","lowerCaseAttributeNames","toWait","that","styleCount","attr","thisCtx","assign","origText","text","newText","scriptCount","src","length","fixupRelativeUrl","map","href","type","match","resolve","dirname","e","message","stack","html","determineDependentFilesSync","oldText","getCompilerVersion","thisVersion","version","compilers","allCompilers","otherVersions","x","join","url"],"mappings":"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","file":"inline-html.js","sourcesContent":["import path from 'path';\nimport mimeTypes from '@paulcbetts/mime-types';\nimport {CompilerBase} from '../compiler-base';\n\nconst inputMimeTypes = ['text/html'];\nlet cheerio = null;\n\nconst d = require('debug')('electron-compile:inline-html');\n\nconst compiledCSS = {\n  'text/less': true,\n  'text/scss': true,\n  'text/sass': true,\n  'text/stylus': true,\n};\n\n/**\n * @access private\n */\nexport default class InlineHtmlCompiler extends CompilerBase {\n  constructor(compileBlock, compileBlockSync) {\n    super();\n\n    this.compileBlock = compileBlock;\n    this.compileBlockSync = compileBlockSync;\n  }\n\n  static createFromCompilers(compilersByMimeType) {\n    d(`Setting up inline HTML compilers: ${JSON.stringify(Object.keys(compilersByMimeType))}`);\n\n    let compileBlock = async (sourceCode, filePath, mimeType, ctx) => {\n      let realType = mimeType;\n      if (!mimeType && ctx.tag === 'script') realType = 'application/javascript';\n\n      if (!realType) return sourceCode;\n\n      let compiler = compilersByMimeType[realType] || compilersByMimeType['text/plain'];\n      let ext = mimeTypes.extension(realType);\n      let fakeFile = `${filePath}:inline_${ctx.count}.${ext}`;\n\n      d(`Compiling inline block for ${filePath} with mimeType ${mimeType}`);\n      if (!(await compiler.shouldCompileFile(fakeFile, ctx))) return sourceCode;\n      return (await compiler.compileSync(sourceCode, fakeFile, ctx)).code;\n    };\n\n    let compileBlockSync = (sourceCode, filePath, mimeType, ctx) => {\n      let realType = mimeType;\n      if (!mimeType && ctx.tag === 'script') realType = 'application/javascript';\n\n      if (!realType) return sourceCode;\n\n      let compiler = compilersByMimeType[realType] || compilersByMimeType['text/plain'];\n      let ext = mimeTypes.extension(realType);\n      let fakeFile = `${filePath}:inline_${ctx.count}.${ext}`;\n\n      d(`Compiling inline block for ${filePath} with mimeType ${mimeType}`);\n      if (!compiler.shouldCompileFileSync(fakeFile, ctx)) return sourceCode;\n      return compiler.compileSync(sourceCode, fakeFile, ctx).code;\n    };\n\n    return new InlineHtmlCompiler(compileBlock, compileBlockSync);\n  }\n\n  static getInputMimeTypes() {\n    return inputMimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n\n  async each(nodes, selector) {\n    let acc = [];\n    nodes.each((i, el) => {\n      let promise = selector(i,el);\n      if (!promise) return false;\n\n      acc.push(promise);\n      return true;\n    });\n\n    await Promise.all(acc);\n  }\n\n  eachSync(nodes, selector) {\n    // NB: This method is here just so it's easier to mechanically\n    // translate the async compile to compileSync\n    return nodes.each((i,el) => {\n      selector(i,el);\n      return true;\n    });\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    cheerio = cheerio || require('cheerio');\n    \n    //Leave the attributes casing as it is, because of Angular 2 and maybe other case-sensitive frameworks\n    let $ = cheerio.load(sourceCode, {lowerCaseAttributeNames: false});\n    let toWait = [];\n\n    let that = this;\n    let styleCount = 0;\n    toWait.push(this.each($('style'), async (i, el) => {\n      let mimeType = $(el).attr('type') || 'text/plain';\n\n      let thisCtx = Object.assign({\n        count: styleCount++,\n        tag: 'style'\n      }, compilerContext);\n\n      let origText = $(el).text();\n      let newText = await that.compileBlock(origText, filePath, mimeType, thisCtx);\n\n      if (origText !== newText) {\n        $(el).text(newText);\n        $(el).attr('type', 'text/css');\n      }\n    }));\n\n    let scriptCount = 0;\n    toWait.push(this.each($('script'), async (i, el) => {\n      let src = $(el).attr('src');\n      if (src && src.length > 2) {\n        $(el).attr('src', InlineHtmlCompiler.fixupRelativeUrl(src));\n        return;\n      }\n\n      let thisCtx = Object.assign({\n        count: scriptCount++,\n        tag: 'script'\n      }, compilerContext);\n\n      let mimeType = $(el).attr('type') || 'application/javascript';\n      let origText = $(el).text();\n      let newText = await that.compileBlock(origText, filePath, mimeType, thisCtx);\n\n      if (origText !== newText) {\n        $(el).text(newText);\n        $(el).attr('type', 'application/javascript');\n      }\n    }));\n\n    $('link').map((i, el) => {\n      let href = $(el).attr('href');\n      if (href && href.length > 2) { $(el).attr('href', InlineHtmlCompiler.fixupRelativeUrl(href)); }\n\n      // NB: In recent versions of Chromium, the link type MUST be text/css or\n      // it will be flat-out ignored. Also I hate myself for hardcoding these.\n      let type = $(el).attr('type');\n      if (compiledCSS[type]) $(el).attr('type', 'text/css');\n    });\n\n    $('x-require').map((i, el) => {\n      let src = $(el).attr('src');\n\n      // File URL? Bail\n      if (src.match(/^file:/i)) return;\n\n      // Absolute path? Bail.\n      if (src.match(/^([\\/]|[A-Za-z]:)/i)) return;\n\n      try {\n        $(el).attr('src', path.resolve(path.dirname(filePath), src));\n      } catch (e) {\n        $(el).text(`${e.message}\\n${e.stack}`);\n      }\n    });\n\n    await Promise.all(toWait);\n\n    return {\n      code: $.html(),\n      mimeType: 'text/html'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    cheerio = cheerio || require('cheerio');\n    \n    //Leave the attributes casing as it is, because of Angular 2 and maybe other case-sensitive frameworks\n    let $ = cheerio.load(sourceCode, {lowerCaseAttributeNames: false});\n\n    let that = this;\n    let styleCount = 0;\n    this.eachSync($('style'), async (i, el) => {\n      let mimeType = $(el).attr('type');\n\n      let thisCtx = Object.assign({\n        count: styleCount++,\n        tag: 'style'\n      }, compilerContext);\n\n      let origText = $(el).text();\n      let newText = that.compileBlockSync(origText, filePath, mimeType, thisCtx);\n\n      if (origText !== newText) {\n        $(el).text(newText);\n        $(el).attr('type', 'text/css');\n      }\n    });\n\n    let scriptCount = 0;\n    this.eachSync($('script'), async (i, el) => {\n      let src = $(el).attr('src');\n      if (src && src.length > 2) {\n        $(el).attr('src', InlineHtmlCompiler.fixupRelativeUrl(src));\n        return;\n      }\n\n      let thisCtx = Object.assign({\n        count: scriptCount++,\n        tag: 'script'\n      }, compilerContext);\n\n      let mimeType = $(el).attr('type');\n\n      let oldText = $(el).text();\n      let newText = that.compileBlockSync(oldText, filePath, mimeType, thisCtx);\n\n      if (oldText !== newText) {\n        $(el).text(newText);\n        $(el).attr('type', 'application/javascript');\n      }\n    });\n\n    $('link').map((i, el) => {\n      let href = $(el).attr('href');\n      if (href && href.length > 2) { $(el).attr('href', InlineHtmlCompiler.fixupRelativeUrl(href)); }\n\n      // NB: In recent versions of Chromium, the link type MUST be text/css or\n      // it will be flat-out ignored. Also I hate myself for hardcoding these.\n      let type = $(el).attr('type');\n      if (compiledCSS[type]) $(el).attr('type', 'text/css');\n    });\n\n    $('x-require').map((i, el) => {\n      let src = $(el).attr('src');\n\n      // File URL? Bail\n      if (src.match(/^file:/i)) return;\n\n      // Absolute path? Bail.\n      if (src.match(/^([\\/]|[A-Za-z]:)/i)) return;\n\n      try {\n        $(el).attr('src', path.resolve(path.dirname(filePath), src));\n      } catch (e) {\n        $(el).text(`${e.message}\\n${e.stack}`);\n      }\n    });\n\n    return {\n      code: $.html(),\n      mimeType: 'text/html'\n    };\n  }\n\n  getCompilerVersion() {\n    let thisVersion = require('../../package.json').version;\n    let compilers = this.allCompilers || [];\n    let otherVersions = compilers.map((x) => x.getCompilerVersion).join();\n\n    return `${thisVersion},${otherVersions}`;\n  }\n\n  static fixupRelativeUrl(url) {\n    if (!url.match(/^\\/\\//)) return url;\n    return `https:${url}`;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/html/jade.js b/lib/html/jade.js new file mode 100644 index 0000000..feb9fe5 --- /dev/null +++ b/lib/html/jade.js @@ -0,0 +1,38 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _compilerBase = require('../compiler-base'); + +const inputMimeTypes = ['text/jade']; +let jade = null; + +/** + * @access private + */ +class JadeCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + this.compilerOptions.sourceMap = true; + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + compileSync(sourceCode, filePath) { + jade = jade || require('jade'); + + let code = jade.render(sourceCode, Object.assign({ filename: filePath, cache: false }, this.compilerOptions)); + + return { code, mimeType: 'text/html' }; + } + + getCompilerVersion() { + return require('jade/package.json').version; + } +} +exports.default = JadeCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/html/vue.js b/lib/html/vue.js new file mode 100644 index 0000000..338d11a --- /dev/null +++ b/lib/html/vue.js @@ -0,0 +1,206 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _compilerBase = require('../compiler-base'); + +var _toutsuite = require('toutsuite'); + +var _toutsuite2 = _interopRequireDefault(_toutsuite); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } + +const inputMimeTypes = ['text/vue']; +let vueify = null; + +const d = require('debug')('electron-compile:vue'); + +const mimeTypeToSimpleType = { + 'text/coffeescript': 'coffee', + 'text/typescript': 'ts', + 'application/javascript': 'js', + 'text/jade': 'jade', + 'text/less': 'less', + 'text/sass': 'sass', + 'text/scss': 'scss', + 'text/stylus': 'stylus' +}; + +/** + * @access private + */ +class VueCompiler extends _compilerBase.CompilerBase { + constructor(asyncCompilers, syncCompilers) { + super(); + Object.assign(this, { asyncCompilers, syncCompilers }); + + this.compilerOptions = {}; + } + + static createFromCompilers(compilersByMimeType) { + let makeAsyncCompilers = () => Object.keys(compilersByMimeType).reduce((acc, mimeType) => { + let compiler = compilersByMimeType[mimeType]; + + acc[mimeType] = (() => { + var _ref = _asyncToGenerator(function* (content, cb, vueCompiler, filePath) { + let ctx = {}; + try { + if (!(yield compiler.shouldCompileFile(filePath, ctx))) { + cb(null, content); + return; + } + + let result = yield compiler.compile(content, filePath, ctx); + cb(null, result.code); + return; + } catch (e) { + cb(e); + } + }); + + return function (_x, _x2, _x3, _x4) { + return _ref.apply(this, arguments); + }; + })(); + + let st = mimeTypeToSimpleType[mimeType]; + if (st) acc[st] = acc[mimeType]; + + return acc; + }, {}); + + let makeSyncCompilers = () => Object.keys(compilersByMimeType).reduce((acc, mimeType) => { + let compiler = compilersByMimeType[mimeType]; + + acc[mimeType] = (content, cb, vueCompiler, filePath) => { + let ctx = {}; + try { + if (!compiler.shouldCompileFileSync(filePath, ctx)) { + cb(null, content); + return; + } + + let result = compiler.compileSync(content, filePath, ctx); + cb(null, result.code); + return; + } catch (e) { + cb(e); + } + }; + + let st = mimeTypeToSimpleType[mimeType]; + if (st) acc[st] = acc[mimeType]; + + return acc; + }, {}); + + // NB: This is super hacky but we have to defer building asyncCompilers + // and syncCompilers until compilersByMimeType is filled out + let ret = new VueCompiler(null, null); + + let asyncCompilers, syncCompilers; + Object.defineProperty(ret, 'asyncCompilers', { + get: () => { + asyncCompilers = asyncCompilers || makeAsyncCompilers(); + return asyncCompilers; + } + }); + + Object.defineProperty(ret, 'syncCompilers', { + get: () => { + syncCompilers = syncCompilers || makeSyncCompilers(); + return syncCompilers; + } + }); + + return ret; + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + shouldCompileFile(fileName, compilerContext) { + return _asyncToGenerator(function* () { + return true; + })(); + } + + determineDependentFiles(sourceCode, filePath, compilerContext) { + return _asyncToGenerator(function* () { + return []; + })(); + } + + compile(sourceCode, filePath, compilerContext) { + var _this = this; + + return _asyncToGenerator(function* () { + vueify = vueify || require('@paulcbetts/vueify'); + + let opts = Object.assign({}, _this.compilerOptions); + + let code = yield new Promise(function (res, rej) { + vueify.compiler.compileNoGlobals(sourceCode, filePath, _this.asyncCompilers, opts, function (e, r) { + if (e) { + rej(e); + } else { + res(r); + } + }); + }); + + return { + code, + mimeType: 'application/javascript' + }; + })(); + } + + shouldCompileFileSync(fileName, compilerContext) { + return true; + } + + determineDependentFilesSync(sourceCode, filePath, compilerContext) { + return []; + } + + compileSync(sourceCode, filePath, compilerContext) { + vueify = vueify || require('@paulcbetts/vueify'); + + let opts = Object.assign({}, this.compilerOptions); + + let err, code; + (0, _toutsuite2.default)(() => { + vueify.compiler.compileNoGlobals(sourceCode, filePath, this.syncCompilers, opts, (e, r) => { + if (e) { + err = e; + } else { + code = r; + } + }); + }); + + if (err) throw err; + + return { + code, + mimeType: 'application/javascript' + }; + } + + getCompilerVersion() { + // NB: See same issue with SASS and user-scoped modules as to why we hard-code this + let thisVersion = '9.4.0'; + let compilers = this.allCompilers || []; + let otherVersions = compilers.map(x => x.getCompilerVersion).join(); + + return `${thisVersion},${otherVersions}`; + } +} +exports.default = VueCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/html/vue.js"],"names":["inputMimeTypes","vueify","d","require","mimeTypeToSimpleType","VueCompiler","constructor","asyncCompilers","syncCompilers","Object","assign","compilerOptions","createFromCompilers","compilersByMimeType","makeAsyncCompilers","keys","reduce","acc","mimeType","compiler","content","cb","vueCompiler","filePath","ctx","shouldCompileFile","result","compile","code","e","st","makeSyncCompilers","shouldCompileFileSync","compileSync","ret","defineProperty","get","getInputMimeTypes","fileName","compilerContext","determineDependentFiles","sourceCode","opts","Promise","res","rej","compileNoGlobals","r","determineDependentFilesSync","err","getCompilerVersion","thisVersion","compilers","allCompilers","otherVersions","map","x","join"],"mappings":"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","file":"vue.js","sourcesContent":["import {CompilerBase} from '../compiler-base';\nimport toutSuite from 'toutsuite';\n\nconst inputMimeTypes = ['text/vue'];\nlet vueify = null;\n\nconst d = require('debug')('electron-compile:vue');\n\nconst mimeTypeToSimpleType = {\n  'text/coffeescript': 'coffee',\n  'text/typescript': 'ts',\n  'application/javascript': 'js',\n  'text/jade': 'jade',\n  'text/less': 'less',\n  'text/sass': 'sass',\n  'text/scss': 'scss',\n  'text/stylus': 'stylus',\n};\n\n/**\n * @access private\n */\nexport default class VueCompiler extends CompilerBase {\n  constructor(asyncCompilers, syncCompilers) {\n    super();\n    Object.assign(this, { asyncCompilers, syncCompilers });\n\n    this.compilerOptions = {};\n  }\n\n  static createFromCompilers(compilersByMimeType) {\n    let makeAsyncCompilers = () => Object.keys(compilersByMimeType).reduce((acc, mimeType) => {\n      let compiler = compilersByMimeType[mimeType];\n\n      acc[mimeType] = async (content, cb, vueCompiler, filePath) => {\n        let ctx = {};\n        try {\n          if (!await compiler.shouldCompileFile(filePath, ctx)) {\n            cb(null, content);\n            return;\n          }\n\n          let result = await compiler.compile(content, filePath, ctx);\n          cb(null, result.code);\n          return;\n        } catch (e) {\n          cb(e);\n        }\n      };\n\n      let st = mimeTypeToSimpleType[mimeType];\n      if (st) acc[st] = acc[mimeType];\n\n      return acc;\n    }, {});\n\n    let makeSyncCompilers = () => Object.keys(compilersByMimeType).reduce((acc, mimeType) => {\n      let compiler = compilersByMimeType[mimeType];\n\n      acc[mimeType] = (content, cb, vueCompiler, filePath) => {\n        let ctx = {};\n        try {\n          if (!compiler.shouldCompileFileSync(filePath, ctx)) {\n            cb(null, content);\n            return;\n          }\n\n          let result = compiler.compileSync(content, filePath, ctx);\n          cb(null, result.code);\n          return;\n        } catch (e) {\n          cb(e);\n        }\n      };\n\n      let st = mimeTypeToSimpleType[mimeType];\n      if (st) acc[st] = acc[mimeType];\n\n      return acc;\n    }, {});\n\n    // NB: This is super hacky but we have to defer building asyncCompilers\n    // and syncCompilers until compilersByMimeType is filled out\n    let ret = new VueCompiler(null, null);\n\n    let asyncCompilers, syncCompilers;\n    Object.defineProperty(ret, 'asyncCompilers', {\n      get: () => {\n        asyncCompilers = asyncCompilers || makeAsyncCompilers();\n        return asyncCompilers;\n      }\n    });\n\n    Object.defineProperty(ret, 'syncCompilers', {\n      get: () => {\n        syncCompilers = syncCompilers || makeSyncCompilers();\n        return syncCompilers;\n      }\n    });\n\n    return ret;\n  }\n\n  static getInputMimeTypes() {\n    return inputMimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    vueify = vueify || require('@paulcbetts/vueify');\n\n    let opts = Object.assign({}, this.compilerOptions);\n\n    let code = await new Promise((res, rej) => {\n      vueify.compiler.compileNoGlobals(sourceCode, filePath, this.asyncCompilers, opts, (e,r) => {\n        if (e) { rej(e); } else { res(r); }\n      });\n    });\n\n    return {\n      code,\n      mimeType: 'application/javascript'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    return [];\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    vueify = vueify || require('@paulcbetts/vueify');\n\n    let opts = Object.assign({}, this.compilerOptions);\n\n    let err,code;\n    toutSuite(() => {\n      vueify.compiler.compileNoGlobals(sourceCode, filePath, this.syncCompilers, opts, (e,r) => {\n        if (e) { err = e; } else { code = r; }\n      });\n    });\n\n    if (err) throw err;\n\n    return {\n      code,\n      mimeType: 'application/javascript'\n    };\n  }\n\n  getCompilerVersion() {\n    // NB: See same issue with SASS and user-scoped modules as to why we hard-code this\n    let thisVersion = '9.4.0';\n    let compilers = this.allCompilers || [];\n    let otherVersions = compilers.map((x) => x.getCompilerVersion).join();\n\n    return `${thisVersion},${otherVersions}`;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/js/babel.js b/lib/js/babel.js new file mode 100644 index 0000000..da17d95 --- /dev/null +++ b/lib/js/babel.js @@ -0,0 +1,127 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _compilerBase = require('../compiler-base'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const mimeTypes = ['text/jsx', 'application/javascript']; +let babel = null; +let istanbul = null; + +class BabelCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + } + + static getInputMimeTypes() { + return mimeTypes; + } + + // NB: This method exists to stop Babel from trying to load plugins from the + // app's node_modules directory, which in a production app doesn't have Babel + // installed in it. Instead, we try to load from our entry point's node_modules + // directory (i.e. Grunt perhaps), and if it doesn't work, just keep going. + attemptToPreload(names, prefix) { + if (!names.length) return null; + + const fixupModule = exp => { + // NB: Some plugins like transform-decorators-legacy, use import/export + // semantics, and others don't + if ('default' in exp) return exp['default']; + return exp; + }; + + const nodeModulesAboveUs = _path2.default.resolve(__dirname, '..', '..', '..'); + + const preloadStrategies = [x => fixupModule(require.main.require(x)), x => fixupModule(require(_path2.default.join(nodeModulesAboveUs, x))), x => fixupModule(require(x))]; + + const possibleNames = name => { + let names = [`babel-${prefix}-${name}`]; + + if (prefix === 'plugin') { + // Look for module names that do not start with "babel-plugin-" + names.push(name); + } + + return names; + }; + + // Apply one preloading strategy to the possible names of a module, and return the preloaded + // module if found, null otherwise + const preloadPossibleNames = (name, strategy) => { + if (typeof strategy !== 'function') return null; + + return possibleNames(name).reduce((mod, possibleName) => { + if (mod !== null) return mod; + + try { + return strategy(possibleName); + } catch (e) {} + + return null; + }, null); + }; + + // Pick a loading strategy that finds the first plugin, the same strategy will be + // used to preload all plugins + const selectedStrategy = preloadStrategies.reduce((winner, strategy) => { + if (winner !== null) return winner; + return preloadPossibleNames(names[0], strategy) === null ? null : strategy; + }, null); + + return names.map(name => preloadPossibleNames(name, selectedStrategy)).filter(mod => mod !== null); + } + + compileSync(sourceCode, filePath, compilerContext) { + babel = babel || require('babel-core'); + + let opts = Object.assign({}, this.compilerOptions, { + filename: filePath, + ast: false, + babelrc: false + }); + + let useCoverage = false; + if ('coverage' in opts) { + useCoverage = !!opts.coverage; + delete opts.coverage; + } + + if ('plugins' in opts) { + let plugins = this.attemptToPreload(opts.plugins, 'plugin'); + if (plugins && plugins.length === opts.plugins.length) opts.plugins = plugins; + } + + if ('presets' in opts) { + let presets = this.attemptToPreload(opts.presets, 'preset'); + if (presets && presets.length === opts.presets.length) opts.presets = presets; + } + + const output = babel.transform(sourceCode, opts); + let sourceMaps = output.map ? JSON.stringify(output.map) : null; + + let code = output.code; + if (useCoverage) { + istanbul = istanbul || require('istanbul'); + + sourceMaps = null; + code = new istanbul.Instrumenter().instrumentSync(output.code, filePath); + } + + return { code, sourceMaps, mimeType: 'application/javascript' }; + } + + getCompilerVersion() { + return require('babel-core/package.json').version; + } +} +exports.default = BabelCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/js/babel.js"],"names":["mimeTypes","babel","istanbul","BabelCompiler","constructor","getInputMimeTypes","attemptToPreload","names","prefix","length","fixupModule","exp","nodeModulesAboveUs","resolve","__dirname","preloadStrategies","x","require","main","join","possibleNames","name","push","preloadPossibleNames","strategy","reduce","mod","possibleName","e","selectedStrategy","winner","map","filter","compileSync","sourceCode","filePath","compilerContext","opts","Object","assign","compilerOptions","filename","ast","babelrc","useCoverage","coverage","plugins","presets","output","transform","sourceMaps","JSON","stringify","code","Instrumenter","instrumentSync","mimeType","getCompilerVersion","version"],"mappings":"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","file":"babel.js","sourcesContent":["import path from 'path';\nimport {SimpleCompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/jsx', 'application/javascript'];\nlet babel = null;\nlet istanbul = null;\n\nexport default class BabelCompiler extends SimpleCompilerBase {\n  constructor() {\n    super();\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  // NB: This method exists to stop Babel from trying to load plugins from the\n  // app's node_modules directory, which in a production app doesn't have Babel\n  // installed in it. Instead, we try to load from our entry point's node_modules\n  // directory (i.e. Grunt perhaps), and if it doesn't work, just keep going.\n  attemptToPreload(names, prefix) {\n    if (!names.length) return null\n\n    const fixupModule = (exp) => {\n      // NB: Some plugins like transform-decorators-legacy, use import/export\n      // semantics, and others don't\n      if ('default' in exp) return exp['default'];\n      return exp;\n    };\n\n    const nodeModulesAboveUs = path.resolve(__dirname, '..', '..', '..');\n\n    const preloadStrategies = [\n      x => fixupModule(require.main.require(x)),\n      x => fixupModule(require(path.join(nodeModulesAboveUs, x))),\n      x => fixupModule(require(x))\n    ]\n\n    const possibleNames = (name) => {\n      let names = [`babel-${prefix}-${name}`];\n\n      if (prefix === 'plugin') {\n        // Look for module names that do not start with \"babel-plugin-\"\n        names.push(name);\n      }\n\n      return names;\n    };\n\n    // Apply one preloading strategy to the possible names of a module, and return the preloaded\n    // module if found, null otherwise\n    const preloadPossibleNames = (name, strategy) => {\n      if (typeof strategy !== 'function') return null;\n\n      return possibleNames(name).reduce((mod, possibleName)=>{\n        if (mod !== null) return mod;\n\n        try {\n          return strategy(possibleName);\n        } catch(e) {}\n\n        return null;\n      }, null)\n    }\n\n    // Pick a loading strategy that finds the first plugin, the same strategy will be\n    // used to preload all plugins\n    const selectedStrategy = preloadStrategies.reduce((winner, strategy)=>{\n      if (winner !== null) return winner;\n      return preloadPossibleNames(names[0], strategy) === null ? null : strategy;\n    }, null)\n\n    return names.map(name => preloadPossibleNames(name, selectedStrategy)).filter((mod) => mod !== null)\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    babel = babel || require('babel-core');\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      filename: filePath,\n      ast: false,\n      babelrc: false\n    });\n\n    let useCoverage = false;\n    if ('coverage' in opts) {\n      useCoverage = !!opts.coverage;\n      delete opts.coverage;\n    }\n\n    if ('plugins' in opts) {\n      let plugins = this.attemptToPreload(opts.plugins, 'plugin');\n      if (plugins && plugins.length === opts.plugins.length) opts.plugins = plugins;\n    }\n\n    if ('presets' in opts) {\n      let presets = this.attemptToPreload(opts.presets, 'preset');\n      if (presets && presets.length === opts.presets.length) opts.presets = presets;\n    }\n\n    const output = babel.transform(sourceCode, opts);\n    let sourceMaps = output.map ? JSON.stringify(output.map) : null;\n\n    let code = output.code;\n    if (useCoverage) {\n      istanbul = istanbul || require('istanbul');\n\n      sourceMaps = null;\n      code = (new istanbul.Instrumenter()).instrumentSync(output.code, filePath);\n    }\n\n    return { code, sourceMaps, mimeType: 'application/javascript', };\n  }\n\n  getCompilerVersion() {\n    return require('babel-core/package.json').version;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/js/coffeescript.js b/lib/js/coffeescript.js new file mode 100644 index 0000000..12983ec --- /dev/null +++ b/lib/js/coffeescript.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _btoa = require('btoa'); + +var _btoa2 = _interopRequireDefault(_btoa); + +var _compilerBase = require('../compiler-base'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const inputMimeTypes = ['text/coffeescript']; +let coffee = null; + +/** + * @access private + */ +class CoffeeScriptCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + this.compilerOptions.sourceMap = true; + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + compileSync(sourceCode, filePath) { + coffee = coffee || require('coffee-script'); + + var _coffee$compile = coffee.compile(sourceCode, Object.assign({ filename: filePath }, this.compilerOptions)); + + let js = _coffee$compile.js, + v3SourceMap = _coffee$compile.v3SourceMap; + + + js = `${js}\n` + `//# sourceMappingURL=data:application/json;base64,${(0, _btoa2.default)(unescape(encodeURIComponent(v3SourceMap)))}\n` + `//# sourceURL=${this.convertFilePath(filePath)}`; + + return { + code: js, + mimeType: 'application/javascript' + }; + } + + convertFilePath(filePath) { + if (process.platform === 'win32') { + filePath = `/${_path2.default.resolve(filePath).replace(/\\/g, '/')}`; + } + + return encodeURI(filePath); + } + + getCompilerVersion() { + return require('coffee-script/package.json').version; + } +} +exports.default = CoffeeScriptCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/js/graphql.js b/lib/js/graphql.js new file mode 100644 index 0000000..a8975a1 --- /dev/null +++ b/lib/js/graphql.js @@ -0,0 +1,42 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _compilerBase = require('../compiler-base'); + +const inputMimeTypes = ['text/graphql']; +let gql = null; + +class GraphQLCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + compileSync(sourceCode) { + gql = gql || require('graphql-tag/loader'); + // This is a stub, original loader calls webpack-specific this.cacheable() + const webpackLoaderStub = { + cacheable: () => {} + }; + const loader = gql.bind(webpackLoaderStub); + + const js = loader(sourceCode); + + return { + code: js, + mimeType: 'application/javascript' + }; + } + + getCompilerVersion() { + return require('graphql-tag/package.json').version; + } +} +exports.default = GraphQLCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/js/typescript.js b/lib/js/typescript.js new file mode 100644 index 0000000..afc47cf --- /dev/null +++ b/lib/js/typescript.js @@ -0,0 +1,186 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _compilerBase = require('../compiler-base'); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _jsStringEscape = require('js-string-escape'); + +var _jsStringEscape2 = _interopRequireDefault(_jsStringEscape); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const inputMimeTypes = ['text/typescript', 'text/tsx']; +const d = require('debug')('electron-compile:typescript-compiler'); + +let ts = null; +let istanbul = null; +let sorcery = null; + +const builtinKeys = ['hotModuleReload', 'coverage', 'babel']; + +class TypeScriptCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + + this.outMimeType = 'application/javascript'; + this.compilerOptions = { + inlineSourceMap: true, + inlineSources: true + }; + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + _getParsedConfigOptions(tsCompiler) { + let parsedConfig = this.parsedConfig; + + if (!parsedConfig) { + let opts = Object.assign({}, this.compilerOptions); + let builtinOpts = {}; + builtinKeys.forEach(k => { + if (k in this.compilerOptions) { + delete opts[k]; + builtinOpts[k] = this.compilerOptions[k]; + } + }); + + const results = tsCompiler.convertCompilerOptionsFromJson(opts); + + if (results.errors && results.errors.length) { + throw new Error(JSON.stringify(results.errors)); + } + + parsedConfig = this.parsedConfig = { typescriptOpts: results.options, builtinOpts }; + } + + return parsedConfig; + } + + compileSync(sourceCode, filePath) { + ts = ts || require('typescript'); + const options = this._getParsedConfigOptions(ts); + + const isTsx = filePath.match(/\.tsx$/i); + const transpileOptions = { + compilerOptions: options.typescriptOpts, + fileName: filePath.match(/\.(ts|tsx)$/i) ? _path2.default.basename(filePath) : null + }; + + if (isTsx && options.builtinOpts.hotModuleReload !== false) { + sourceCode = this.addHotModuleLoadingRegistration(sourceCode, filePath, this.getExportsForFile(sourceCode, filePath, options.typescriptOpts)); + } + + let output = ts.transpileModule(sourceCode, transpileOptions); + let sourceMaps = output.sourceMapText ? output.sourceMapText : null; + if (options.builtinOpts.coverage) { + sourceMaps = null; + istanbul = istanbul || require('istanbul'); + + sourceMaps = null; + output.outputText = new istanbul.Instrumenter().instrumentSync(output.outputText, filePath); + } + + d(JSON.stringify(output.diagnostics)); + + const babelOpts = this.parsedConfig.builtinOpts.babel; + if (babelOpts) { + if (!this.babel) { + const BabelCompiler = require("./babel").default; + this.babel = new BabelCompiler(); + this.babel.compilerOptions = babelOpts; + } + + sorcery = sorcery || require('sorcery'); + + let tsOutputPath = filePath.replace(/.tsx?$/i, ".js"); + let babelOutputPath = filePath.replace(/.tsx?$/i, ".babel.js"); + + output.outputText = output.outputText.replace(/\/\/# sourceMap.*/g, ""); + + let babelOutput = this.babel.compileSync(output.outputText, tsOutputPath); + let chain = sorcery.loadSync(babelOutputPath, { + content: { + [filePath]: sourceCode, + [tsOutputPath]: output.outputText, + [babelOutputPath]: babelOutput.code + }, + sourcemaps: { + [tsOutputPath]: JSON.parse(sourceMaps), + [babelOutputPath]: JSON.parse(babelOutput.sourceMaps) + } + }); + let finalSourceMaps = chain.apply(); + let outputCode = babelOutput.code + "\n//# sourceMappingURL=" + finalSourceMaps.toUrl(); + + // the only way to make sourceMaps usable seems to be to have + // them inlined right now, see https://github.com/electron/electron-compile/issues/172#issuecomment-277146112 + return { + code: outputCode, + mimeType: babelOutput.mimeType + }; + } + + return { + code: output.outputText, + mimeType: this.outMimeType, + sourceMaps + }; + } + + addHotModuleLoadingRegistration(sourceCode, fileName, exports) { + if (exports.length < 1) return sourceCode; + + let registrations = exports.map(x => { + let id = `${x}` == 'default' ? '(typeof _default !== \'undefined\' ? _default : exports.default)' : `${x}`; + let name = `"${x}"`; + return `__REACT_HOT_LOADER__.register(${id}, ${name}, __FILENAME__);\n`; + }); + + let tmpl = ` +${sourceCode} + +if (typeof __REACT_HOT_LOADER__ !== 'undefined') { + const __FILENAME__ = "${(0, _jsStringEscape2.default)(fileName)}"; + ${registrations} +}`; + + return tmpl; + } + + getExportsForFile(sourceCode, fileName, tsOptions) { + let sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.ES6); + let ret = []; + + // Walk the tree to search for classes + let visit = node => { + if (!this.isNodeExported(node)) return; + + if (node.kind === ts.SyntaxKind.ClassDeclaration || node.kind === ts.SyntaxKind.FunctionDeclaration) { + ret.push(node.name.text); + } + }; + + ts.forEachChild(sourceFile, visit); + + return ret; + } + + isNodeExported(node) { + return (node.flags & ts.NodeFlags.Export) !== 0 || node.parent && node.parent.kind === ts.SyntaxKind.SourceFile; + } + + getCompilerVersion() { + return require('typescript/package.json').version; + } +} +exports.default = TypeScriptCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/js/typescript.js"],"names":["inputMimeTypes","d","require","ts","istanbul","sorcery","builtinKeys","TypeScriptCompiler","constructor","outMimeType","compilerOptions","inlineSourceMap","inlineSources","getInputMimeTypes","_getParsedConfigOptions","tsCompiler","parsedConfig","opts","Object","assign","builtinOpts","forEach","k","results","convertCompilerOptionsFromJson","errors","length","Error","JSON","stringify","typescriptOpts","options","compileSync","sourceCode","filePath","isTsx","match","transpileOptions","fileName","basename","hotModuleReload","addHotModuleLoadingRegistration","getExportsForFile","output","transpileModule","sourceMaps","sourceMapText","coverage","outputText","Instrumenter","instrumentSync","diagnostics","babelOpts","babel","BabelCompiler","default","tsOutputPath","replace","babelOutputPath","babelOutput","chain","loadSync","content","code","sourcemaps","parse","finalSourceMaps","apply","outputCode","toUrl","mimeType","exports","registrations","map","x","id","name","tmpl","tsOptions","sourceFile","createSourceFile","ScriptTarget","ES6","ret","visit","node","isNodeExported","kind","SyntaxKind","ClassDeclaration","FunctionDeclaration","push","text","forEachChild","flags","NodeFlags","Export","parent","SourceFile","getCompilerVersion","version"],"mappings":"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","file":"typescript.js","sourcesContent":["import {SimpleCompilerBase} from '../compiler-base';\nimport path from 'path';\nimport jsEscape from 'js-string-escape';\n\nconst inputMimeTypes = ['text/typescript', 'text/tsx'];\nconst d = require('debug')('electron-compile:typescript-compiler');\n\nlet ts = null;\nlet istanbul = null;\nlet sorcery = null;\n\nconst builtinKeys = ['hotModuleReload', 'coverage', 'babel'];\n\nexport default class TypeScriptCompiler extends SimpleCompilerBase {\n  constructor() {\n    super();\n\n    this.outMimeType = 'application/javascript';\n    this.compilerOptions = {\n      inlineSourceMap: true,\n      inlineSources: true\n    };\n  }\n\n  static getInputMimeTypes() {\n    return inputMimeTypes;\n  }\n\n  _getParsedConfigOptions(tsCompiler) {\n    let parsedConfig = this.parsedConfig;\n\n    if (!parsedConfig) {\n      let opts = Object.assign({}, this.compilerOptions);\n      let builtinOpts = {};\n      builtinKeys.forEach((k) => {\n        if (k in this.compilerOptions) {\n          delete opts[k];\n          builtinOpts[k] = this.compilerOptions[k];\n        }\n      });\n\n      const results = tsCompiler.convertCompilerOptionsFromJson(opts);\n\n      if (results.errors && results.errors.length) {\n        throw new Error(JSON.stringify(results.errors));\n      }\n\n      parsedConfig = this.parsedConfig = { typescriptOpts: results.options, builtinOpts };\n    }\n\n    return parsedConfig;\n  }\n\n  compileSync(sourceCode, filePath) {\n    ts = ts || require('typescript');\n    const options = this._getParsedConfigOptions(ts);\n\n    const isTsx = filePath.match(/\\.tsx$/i);\n    const transpileOptions = {\n      compilerOptions: options.typescriptOpts,\n      fileName: filePath.match(/\\.(ts|tsx)$/i) ? path.basename(filePath) : null\n    };\n\n    if (isTsx && options.builtinOpts.hotModuleReload !== false) {\n      sourceCode = this.addHotModuleLoadingRegistration(sourceCode, filePath, this.getExportsForFile(sourceCode, filePath, options.typescriptOpts));\n    }\n\n    let output = ts.transpileModule(sourceCode, transpileOptions);\n    let sourceMaps = output.sourceMapText ? output.sourceMapText : null;\n    if (options.builtinOpts.coverage) {\n      sourceMaps = null;\n      istanbul = istanbul || require('istanbul');\n\n      sourceMaps = null;\n      output.outputText = (new istanbul.Instrumenter()).instrumentSync(output.outputText, filePath);\n    }\n\n    d(JSON.stringify(output.diagnostics));\n\n    const babelOpts = this.parsedConfig.builtinOpts.babel;\n    if (babelOpts) {\n      if (!this.babel) {\n        const BabelCompiler = require(\"./babel\").default;\n        this.babel = new BabelCompiler();\n        this.babel.compilerOptions = babelOpts;\n      }\n\n      sorcery = sorcery || require('sorcery');\n\n      let tsOutputPath = filePath.replace(/.tsx?$/i, \".js\");\n      let babelOutputPath = filePath.replace(/.tsx?$/i, \".babel.js\");\n\n      output.outputText = output.outputText.replace(/\\/\\/# sourceMap.*/g, \"\");\n\n      let babelOutput = this.babel.compileSync(output.outputText, tsOutputPath);\n      let chain = sorcery.loadSync(babelOutputPath, {\n        content: {\n          [filePath]: sourceCode,\n          [tsOutputPath]: output.outputText,\n          [babelOutputPath]: babelOutput.code,\n        },\n        sourcemaps: {\n          [tsOutputPath]: JSON.parse(sourceMaps),\n          [babelOutputPath]: JSON.parse(babelOutput.sourceMaps),\n        }\n      });\n      let finalSourceMaps = chain.apply();\n      let outputCode = babelOutput.code + \"\\n//# sourceMappingURL=\" + finalSourceMaps.toUrl();\n\n      // the only way to make sourceMaps usable seems to be to have\n      // them inlined right now, see https://github.com/electron/electron-compile/issues/172#issuecomment-277146112\n      return {\n        code: outputCode,\n        mimeType: babelOutput.mimeType,\n      };\n    }\n\n    return {\n      code: output.outputText,\n      mimeType: this.outMimeType,\n      sourceMaps\n    };\n  }\n\n  addHotModuleLoadingRegistration(sourceCode, fileName, exports) {\n    if (exports.length < 1) return sourceCode;\n\n    let registrations = exports.map(x => {\n      let id = `${x}` == 'default' ? '(typeof _default !== \\'undefined\\' ? _default : exports.default)' : `${x}`;\n      let name = `\"${x}\"`;\n      return `__REACT_HOT_LOADER__.register(${id}, ${name}, __FILENAME__);\\n`;\n    });\n\n    let tmpl = `\n${sourceCode}\n\nif (typeof __REACT_HOT_LOADER__ !== 'undefined') {\n  const __FILENAME__ = \"${jsEscape(fileName)}\";\n  ${registrations}\n}`;\n\n    return tmpl;\n  }\n\n  getExportsForFile(sourceCode, fileName, tsOptions) {\n    let sourceFile = ts.createSourceFile(fileName, sourceCode, ts.ScriptTarget.ES6);\n    let ret = [];\n\n    // Walk the tree to search for classes\n    let visit = (node) => {\n      if (!this.isNodeExported(node)) return;\n      \n      if (node.kind === ts.SyntaxKind.ClassDeclaration || node.kind === ts.SyntaxKind.FunctionDeclaration) {\n        ret.push(node.name.text);\n      }\n    };\n\n    ts.forEachChild(sourceFile, visit);\n\n    return ret;\n  }\n\n  isNodeExported(node) {\n    return (node.flags & ts.NodeFlags.Export) !== 0 || (node.parent && node.parent.kind === ts.SyntaxKind.SourceFile);\n  }\n\n  getCompilerVersion() {\n    return require('typescript/package.json').version;\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/json/cson.js b/lib/json/cson.js new file mode 100644 index 0000000..721a7ac --- /dev/null +++ b/lib/json/cson.js @@ -0,0 +1,40 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _compilerBase = require('../compiler-base'); + +const inputMimeTypes = ['text/cson']; +let CSON = null; + +/** + * @access private + */ +class CSONCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + compileSync(sourceCode, filePath) { + CSON = CSON || require('cson'); + + let result = CSON.parse(sourceCode); + + return { + code: JSON.stringify(result), + mimeType: 'application/json' + }; + } + + getCompilerVersion() { + return require('cson/package.json').version; + } +} +exports.default = CSONCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9qc29uL2Nzb24uanMiXSwibmFtZXMiOlsiaW5wdXRNaW1lVHlwZXMiLCJDU09OIiwiQ1NPTkNvbXBpbGVyIiwiY29uc3RydWN0b3IiLCJnZXRJbnB1dE1pbWVUeXBlcyIsImNvbXBpbGVTeW5jIiwic291cmNlQ29kZSIsImZpbGVQYXRoIiwicmVxdWlyZSIsInJlc3VsdCIsInBhcnNlIiwiY29kZSIsIkpTT04iLCJzdHJpbmdpZnkiLCJtaW1lVHlwZSIsImdldENvbXBpbGVyVmVyc2lvbiIsInZlcnNpb24iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBOztBQUVBLE1BQU1BLGlCQUFpQixDQUFDLFdBQUQsQ0FBdkI7QUFDQSxJQUFJQyxPQUFPLElBQVg7O0FBRUE7OztBQUdlLE1BQU1DLFlBQU4sMENBQThDO0FBQzNEQyxnQkFBYztBQUNaO0FBQ0Q7O0FBRUQsU0FBT0MsaUJBQVAsR0FBMkI7QUFDekIsV0FBT0osY0FBUDtBQUNEOztBQUVESyxjQUFZQyxVQUFaLEVBQXdCQyxRQUF4QixFQUFrQztBQUNoQ04sV0FBT0EsUUFBUU8sUUFBUSxNQUFSLENBQWY7O0FBRUEsUUFBSUMsU0FBU1IsS0FBS1MsS0FBTCxDQUFXSixVQUFYLENBQWI7O0FBRUEsV0FBTztBQUNMSyxZQUFNQyxLQUFLQyxTQUFMLENBQWVKLE1BQWYsQ0FERDtBQUVMSyxnQkFBVTtBQUZMLEtBQVA7QUFJRDs7QUFFREMsdUJBQXFCO0FBQ25CLFdBQU9QLFFBQVEsbUJBQVIsRUFBNkJRLE9BQXBDO0FBQ0Q7QUF0QjBEO2tCQUF4Q2QsWSIsImZpbGUiOiJjc29uLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtTaW1wbGVDb21waWxlckJhc2V9IGZyb20gJy4uL2NvbXBpbGVyLWJhc2UnO1xuXG5jb25zdCBpbnB1dE1pbWVUeXBlcyA9IFsndGV4dC9jc29uJ107XG5sZXQgQ1NPTiA9IG51bGw7XG5cbi8qKlxuICogQGFjY2VzcyBwcml2YXRlXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIENTT05Db21waWxlciBleHRlbmRzIFNpbXBsZUNvbXBpbGVyQmFzZSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKCk7XG4gIH1cblxuICBzdGF0aWMgZ2V0SW5wdXRNaW1lVHlwZXMoKSB7XG4gICAgcmV0dXJuIGlucHV0TWltZVR5cGVzO1xuICB9XG5cbiAgY29tcGlsZVN5bmMoc291cmNlQ29kZSwgZmlsZVBhdGgpIHtcbiAgICBDU09OID0gQ1NPTiB8fCByZXF1aXJlKCdjc29uJyk7XG5cbiAgICBsZXQgcmVzdWx0ID0gQ1NPTi5wYXJzZShzb3VyY2VDb2RlKTtcblxuICAgIHJldHVybiB7XG4gICAgICBjb2RlOiBKU09OLnN0cmluZ2lmeShyZXN1bHQpLFxuICAgICAgbWltZVR5cGU6ICdhcHBsaWNhdGlvbi9qc29uJ1xuICAgIH07XG4gIH1cblxuICBnZXRDb21waWxlclZlcnNpb24oKSB7XG4gICAgcmV0dXJuIHJlcXVpcmUoJ2Nzb24vcGFja2FnZS5qc29uJykudmVyc2lvbjtcbiAgfVxufVxuIl19 \ No newline at end of file diff --git a/lib/main.js b/lib/main.js new file mode 100644 index 0000000..3560fd1 --- /dev/null +++ b/lib/main.js @@ -0,0 +1,6 @@ +'use strict'; + +const filenames = ['css/less', 'css/sass', 'css/stylus', 'js/babel', 'js/graphql', 'js/coffeescript', 'js/typescript', 'json/cson', 'html/inline-html', 'html/jade', 'html/vue', 'passthrough']; + +module.exports = filenames.map(x => require('./' + x).default); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9tYWluLmpzIl0sIm5hbWVzIjpbImZpbGVuYW1lcyIsIm1vZHVsZSIsImV4cG9ydHMiLCJtYXAiLCJ4IiwicmVxdWlyZSIsImRlZmF1bHQiXSwibWFwcGluZ3MiOiI7O0FBQUEsTUFBTUEsWUFBWSxDQUNoQixVQURnQixFQUVoQixVQUZnQixFQUdoQixZQUhnQixFQUloQixVQUpnQixFQUtoQixZQUxnQixFQU1oQixpQkFOZ0IsRUFPaEIsZUFQZ0IsRUFRaEIsV0FSZ0IsRUFTaEIsa0JBVGdCLEVBVWhCLFdBVmdCLEVBV2hCLFVBWGdCLEVBWWhCLGFBWmdCLENBQWxCOztBQWVBQyxPQUFPQyxPQUFQLEdBQWlCRixVQUFVRyxHQUFWLENBQWVDLENBQUQsSUFBT0MsUUFBUSxPQUFPRCxDQUFmLEVBQWtCRSxPQUF2QyxDQUFqQiIsImZpbGUiOiJtYWluLmpzIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgZmlsZW5hbWVzID0gW1xuICAnY3NzL2xlc3MnLFxuICAnY3NzL3Nhc3MnLFxuICAnY3NzL3N0eWx1cycsXG4gICdqcy9iYWJlbCcsXG4gICdqcy9ncmFwaHFsJyxcbiAgJ2pzL2NvZmZlZXNjcmlwdCcsXG4gICdqcy90eXBlc2NyaXB0JyxcbiAgJ2pzb24vY3NvbicsXG4gICdodG1sL2lubGluZS1odG1sJyxcbiAgJ2h0bWwvamFkZScsXG4gICdodG1sL3Z1ZScsXG4gICdwYXNzdGhyb3VnaCdcbl07XG5cbm1vZHVsZS5leHBvcnRzID0gZmlsZW5hbWVzLm1hcCgoeCkgPT4gcmVxdWlyZSgnLi8nICsgeCkuZGVmYXVsdCk7XG4iXX0= \ No newline at end of file diff --git a/lib/passthrough.js b/lib/passthrough.js new file mode 100644 index 0000000..256f557 --- /dev/null +++ b/lib/passthrough.js @@ -0,0 +1,48 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _path = require('path'); + +var _path2 = _interopRequireDefault(_path); + +var _compilerBase = require('./compiler-base'); + +var _mimeTypes = require('@paulcbetts/mime-types'); + +var _mimeTypes2 = _interopRequireDefault(_mimeTypes); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const inputMimeTypes = ['text/plain', 'image/svg+xml']; + +/** + * @access private + * + * This class is used for binary files and other files that should end up in + * your cache directory, but aren't actually compiled + */ +class PassthroughCompiler extends _compilerBase.SimpleCompilerBase { + constructor() { + super(); + } + + static getInputMimeTypes() { + return inputMimeTypes; + } + + compileSync(sourceCode, filePath) { + return { + code: sourceCode, + mimeType: _mimeTypes2.default.lookup(filePath) + }; + } + + getCompilerVersion() { + return require(_path2.default.join(__dirname, '..', 'package.json')).version; + } +} +exports.default = PassthroughCompiler; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9wYXNzdGhyb3VnaC5qcyJdLCJuYW1lcyI6WyJpbnB1dE1pbWVUeXBlcyIsIlBhc3N0aHJvdWdoQ29tcGlsZXIiLCJjb25zdHJ1Y3RvciIsImdldElucHV0TWltZVR5cGVzIiwiY29tcGlsZVN5bmMiLCJzb3VyY2VDb2RlIiwiZmlsZVBhdGgiLCJjb2RlIiwibWltZVR5cGUiLCJsb29rdXAiLCJnZXRDb21waWxlclZlcnNpb24iLCJyZXF1aXJlIiwiam9pbiIsIl9fZGlybmFtZSIsInZlcnNpb24iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBOzs7O0FBQ0E7O0FBQ0E7Ozs7OztBQUVBLE1BQU1BLGlCQUFpQixDQUFDLFlBQUQsRUFBZSxlQUFmLENBQXZCOztBQUdBOzs7Ozs7QUFNZSxNQUFNQyxtQkFBTiwwQ0FBcUQ7QUFDbEVDLGdCQUFjO0FBQ1o7QUFDRDs7QUFFRCxTQUFPQyxpQkFBUCxHQUEyQjtBQUN6QixXQUFPSCxjQUFQO0FBQ0Q7O0FBRURJLGNBQVlDLFVBQVosRUFBd0JDLFFBQXhCLEVBQWtDO0FBQ2hDLFdBQU87QUFDTEMsWUFBTUYsVUFERDtBQUVMRyxnQkFBVSxvQkFBVUMsTUFBVixDQUFpQkgsUUFBakI7QUFGTCxLQUFQO0FBSUQ7O0FBRURJLHVCQUFxQjtBQUNuQixXQUFPQyxRQUFRLGVBQUtDLElBQUwsQ0FBVUMsU0FBVixFQUFxQixJQUFyQixFQUEyQixjQUEzQixDQUFSLEVBQW9EQyxPQUEzRDtBQUNEO0FBbEJpRTtrQkFBL0NiLG1CIiwiZmlsZSI6InBhc3N0aHJvdWdoLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQge1NpbXBsZUNvbXBpbGVyQmFzZX0gZnJvbSAnLi9jb21waWxlci1iYXNlJztcbmltcG9ydCBtaW1lVHlwZXMgZnJvbSAnQHBhdWxjYmV0dHMvbWltZS10eXBlcyc7XG5cbmNvbnN0IGlucHV0TWltZVR5cGVzID0gWyd0ZXh0L3BsYWluJywgJ2ltYWdlL3N2Zyt4bWwnXTtcblxuXG4vKipcbiAqIEBhY2Nlc3MgcHJpdmF0ZVxuICogXG4gKiBUaGlzIGNsYXNzIGlzIHVzZWQgZm9yIGJpbmFyeSBmaWxlcyBhbmQgb3RoZXIgZmlsZXMgdGhhdCBzaG91bGQgZW5kIHVwIGluIFxuICogeW91ciBjYWNoZSBkaXJlY3RvcnksIGJ1dCBhcmVuJ3QgYWN0dWFsbHkgY29tcGlsZWRcbiAqLyBcbmV4cG9ydCBkZWZhdWx0IGNsYXNzIFBhc3N0aHJvdWdoQ29tcGlsZXIgZXh0ZW5kcyBTaW1wbGVDb21waWxlckJhc2Uge1xuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcigpO1xuICB9XG5cbiAgc3RhdGljIGdldElucHV0TWltZVR5cGVzKCkge1xuICAgIHJldHVybiBpbnB1dE1pbWVUeXBlcztcbiAgfVxuXG4gIGNvbXBpbGVTeW5jKHNvdXJjZUNvZGUsIGZpbGVQYXRoKSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGNvZGU6IHNvdXJjZUNvZGUsXG4gICAgICBtaW1lVHlwZTogbWltZVR5cGVzLmxvb2t1cChmaWxlUGF0aClcbiAgICB9O1xuICB9XG4gIFxuICBnZXRDb21waWxlclZlcnNpb24oKSB7XG4gICAgcmV0dXJuIHJlcXVpcmUocGF0aC5qb2luKF9fZGlybmFtZSwgJy4uJywgJ3BhY2thZ2UuanNvbicpKS52ZXJzaW9uO1xuICB9XG59XG4iXX0= \ No newline at end of file From 23406608160cd5f6967ddbe4069a5236c58b5ffd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Sat, 17 Jun 2017 00:16:51 +0200 Subject: [PATCH 5/8] Fuclll --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 27789f5..b1db09e 100644 --- a/package.json +++ b/package.json @@ -1,5 +1,5 @@ { - "name": "@getstation/electron-compilers", + "name": "electron-compilers", "version": "5.10.0", "description": "Compiler implementations for electron-compile", "main": "lib/main.js", From 16c7b5f41d269783aa8bdf4a3460f68b8dc702d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Sat, 17 Jun 2017 00:25:13 +0200 Subject: [PATCH 6/8] Screw --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 179f575..3dc61be 100644 --- a/.gitignore +++ b/.gitignore @@ -26,6 +26,5 @@ build/Release # https://docs.npmjs.com/misc/faq#should-i-check-my-node-modules-folder-into-git node_modules -lib test-dist docs From 22b092e65daa5547a2c0b7b2bdbec3e60396ef26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandre=20Lach=C3=A8ze?= Date: Thu, 22 Jun 2017 13:21:02 +0200 Subject: [PATCH 7/8] Very basic import --- lib/css/sass.js | 14 ++++---------- src/css/sass.js | 12 +++--------- 2 files changed, 7 insertions(+), 19 deletions(-) diff --git a/lib/css/sass.js b/lib/css/sass.js index 2b4316a..a3ab9d2 100644 --- a/lib/css/sass.js +++ b/lib/css/sass.js @@ -202,17 +202,11 @@ class SassCompiler extends _compilerBase.CompilerBase { done(); return; } else { - // sass.js works in the '/sass/' directory - let cleanedRequestPath = request.resolved.replace(/^\/sass\//, ''); - - // if we are importing from the entry file (stdin) the path is - // resolved with a leading '/'' -> remove it - if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') { - cleanedRequestPath = cleanedRequestPath.substring(1); - } + // treat as it + const importRequest = request.current; for (let includePath of includePaths) { - const filePath = _path2.default.resolve(includePath, cleanedRequestPath); + const filePath = _path2.default.resolve(includePath, importRequest); let variations = sass.getPathVariations(filePath); file = variations.map(self.fixWindowsPath.bind(self)).reduce(self.importedFileReducer.bind(self), null); @@ -274,4 +268,4 @@ class SassCompiler extends _compilerBase.CompilerBase { } } exports.default = SassCompiler; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/sass.js"],"names":["mimeTypes","sass","SassCompiler","constructor","compilerOptions","comments","sourceMapEmbed","sourceMapContents","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getSass","thisPath","dirname","paths","Object","keys","push","unshift","importer","buildImporterCallback","opts","assign","indentedSyntax","match","sourceMapRoot","result","Promise","res","rej","r","status","Error","formatted","message","source","text","code","mimeType","shouldCompileFileSync","dependencyFilenames","extname","dependencies","dependencyName","basename","compileSync","ret","require","Sass","includePaths","self","request","done","file","cleanedRequestPath","resolved","replace","previous","charAt","substring","includePath","resolve","variations","getPathVariations","map","fixWindowsPath","bind","reduce","importedFileReducer","content","readFileSync","encoding","writeFile","path","found","stat","statSync","isFile","e","process","platform","slice","parts","split","sep","dir","join","reverse","getCompilerVersion"],"mappings":";;;;;;AAAA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;AAEA,MAAMA,YAAY,CAAC,WAAD,EAAc,WAAd,CAAlB;AACA,IAAIC,OAAO,IAAX;;AAEA;;;AAGe,MAAMC,YAAN,oCAAwC;AACrDC,gBAAc;AACZ;;AAEA,SAAKC,eAAL,GAAuB;AACrBC,gBAAU,IADW;AAErBC,sBAAgB,IAFK;AAGrBC,yBAAmB;AAHE,KAAvB;;AAMA,SAAKC,aAAL,GAAqB,EAArB;AACD;;AAED,SAAOC,iBAAP,GAA2B;AACzB,WAAOT,SAAP;AACD;;AAEKU,mBAAN,CAAwBC,QAAxB,EAAkCC,eAAlC,EAAmD;AAAA;AACjD,aAAO,IAAP;AADiD;AAElD;;AAEKC,yBAAN,CAA8BC,UAA9B,EAA0CC,QAA1C,EAAoDH,eAApD,EAAqE;AAAA;;AAAA;AACnE,aAAO,MAAKI,2BAAL,CAAiCF,UAAjC,EAA6CC,QAA7C,EAAuDH,eAAvD,CAAP;AADmE;AAEpE;;AAEKK,SAAN,CAAcH,UAAd,EAA0BC,QAA1B,EAAoCH,eAApC,EAAqD;AAAA;;AAAA;AACnDX,aAAOA,QAAQ,OAAKiB,OAAL,EAAf;;AAEA,UAAIC,WAAW,eAAKC,OAAL,CAAaL,QAAb,CAAf;AACA,aAAKP,aAAL,CAAmBW,QAAnB,IAA+B,IAA/B;;AAEA,UAAIE,QAAQC,OAAOC,IAAP,CAAY,OAAKf,aAAjB,CAAZ;;AAEA,UAAI,OAAKJ,eAAL,CAAqBiB,KAAzB,EAAgC;AAC9BA,cAAMG,IAAN,CAAW,GAAG,OAAKpB,eAAL,CAAqBiB,KAAnC;AACD;;AAEDA,YAAMI,OAAN,CAAc,GAAd;;AAEAxB,WAAKyB,QAAL,CAAc,OAAKC,qBAAL,CAA2BN,KAA3B,CAAd;;AAEA,UAAIO,OAAON,OAAOO,MAAP,CAAc,EAAd,EAAkB,OAAKzB,eAAvB,EAAwC;AACjD0B,wBAAgBf,SAASgB,KAAT,CAAe,UAAf,CADiC;AAEjDC,uBAAejB;AAFkC,OAAxC,CAAX;;AAKA;AACA,aAAOa,KAAKP,KAAZ;;AAEA,UAAIY,SAAS,MAAM,IAAIC,OAAJ,CAAY,UAACC,GAAD,EAAKC,GAAL,EAAa;AAC1CnC,aAAKgB,OAAL,CAAaH,UAAb,EAAyBc,IAAzB,EAA+B,UAACS,CAAD,EAAO;AACpC,cAAIA,EAAEC,MAAF,KAAa,CAAjB,EAAoB;AAClBF,gBAAI,IAAIG,KAAJ,CAAUF,EAAEG,SAAF,IAAeH,EAAEI,OAA3B,CAAJ;AACA;AACD;;AAEDN,cAAIE,CAAJ;AACA;AACD,SARD;AASD,OAVkB,CAAnB;;AAYA,UAAIK,SAAST,OAAOU,IAApB;;AAEA;AACA;AACA;AACA;AACA,UAAI,CAACD,MAAL,EAAa;AACXA,iBAAS,GAAT;AACD;;AAED,aAAO;AACLE,cAAMF,MADD;AAELG,kBAAU;AAFL,OAAP;AA9CmD;AAkDpD;;AAEDC,wBAAsBnC,QAAtB,EAAgCC,eAAhC,EAAiD;AAC/C,WAAO,IAAP;AACD;;AAEDI,8BAA4BF,UAA5B,EAAwCC,QAAxC,EAAkDH,eAAlD,EAAmE;AACjE,QAAImC,sBAAsB,eAAKC,OAAL,CAAajC,QAAb,MAA2B,OAA3B,GAAqC,6BAAcD,UAAd,CAArC,GAAiE,6BAAcA,UAAd,CAA3F;AACA,QAAImC,eAAe,EAAnB;;AAEA,SAAK,IAAIC,cAAT,IAA2BH,mBAA3B,EAAgD;AAC9CE,mBAAazB,IAAb,CAAkB,0BAAW0B,cAAX,EAA2B,eAAKC,QAAL,CAAcpC,QAAd,CAA3B,EAAoD,eAAKK,OAAL,CAAaL,QAAb,CAApD,CAAlB;AACD;;AAED,WAAOkC,YAAP;AACD;;AAEDG,cAAYtC,UAAZ,EAAwBC,QAAxB,EAAkCH,eAAlC,EAAmD;AACjDX,WAAOA,QAAQ,KAAKiB,OAAL,EAAf;;AAEA,QAAIC,WAAW,eAAKC,OAAL,CAAaL,QAAb,CAAf;AACA,SAAKP,aAAL,CAAmBW,QAAnB,IAA+B,IAA/B;;AAEA,QAAIE,QAAQC,OAAOC,IAAP,CAAY,KAAKf,aAAjB,CAAZ;;AAEA,QAAI,KAAKJ,eAAL,CAAqBiB,KAAzB,EAAgC;AAC9BA,YAAMG,IAAN,CAAW,GAAG,KAAKpB,eAAL,CAAqBiB,KAAnC;AACD;;AAEDA,UAAMI,OAAN,CAAc,GAAd;AACAxB,SAAKyB,QAAL,CAAc,KAAKC,qBAAL,CAA2BN,KAA3B,CAAd;;AAEA,QAAIO,OAAON,OAAOO,MAAP,CAAc,EAAd,EAAkB,KAAKzB,eAAvB,EAAwC;AACjD0B,sBAAgBf,SAASgB,KAAT,CAAe,UAAf,CADiC;AAEjDC,qBAAejB;AAFkC,KAAxC,CAAX;;AAKA,QAAIkB,MAAJ;AACA,6BAAU,MAAM;AACdhC,WAAKgB,OAAL,CAAaH,UAAb,EAAyBc,IAAzB,EAAgCS,CAAD,IAAO;AACpC,YAAIA,EAAEC,MAAF,KAAa,CAAjB,EAAoB;AAClB,gBAAM,IAAIC,KAAJ,CAAUF,EAAEG,SAAZ,CAAN;AACD;AACDP,iBAASI,CAAT;AACD,OALD;AAMD,KAPD;;AASA,QAAIK,SAAST,OAAOU,IAApB;;AAEA;AACA;AACA;AACA;AACA,QAAI,CAACD,MAAL,EAAa;AACXA,eAAS,GAAT;AACD;;AAED,WAAO;AACLE,YAAMF,MADD;AAELG,gBAAU;AAFL,KAAP;AAID;;AAED3B,YAAU;AACR,QAAImC,GAAJ;AACA,6BAAU,MAAMA,MAAMC,QAAQ,wBAAR,EAAkCC,IAAxD;AACA,WAAOF,GAAP;AACD;;AAED1B,wBAAuB6B,YAAvB,EAAqC;AACnC,UAAMC,OAAO,IAAb;AACA,WAAQ,UAAUC,OAAV,EAAmBC,IAAnB,EAAyB;AAC/B,UAAIC,IAAJ;AACA,UAAIF,QAAQE,IAAZ,EAAkB;AAChBD;AACA;AACD,OAHD,MAGO;AACL;AACA,YAAIE,qBAAqBH,QAAQI,QAAR,CAAiBC,OAAjB,CAAyB,WAAzB,EAAsC,EAAtC,CAAzB;;AAEA;AACA;AACA,YAAIL,QAAQM,QAAR,KAAqB,OAArB,IAAgCH,mBAAmBI,MAAnB,CAA0B,CAA1B,MAAiC,GAArE,EAA0E;AACxEJ,+BAAqBA,mBAAmBK,SAAnB,CAA6B,CAA7B,CAArB;AACD;;AAED,aAAK,IAAIC,WAAT,IAAwBX,YAAxB,EAAsC;AACpC,gBAAMzC,WAAW,eAAKqD,OAAL,CAAaD,WAAb,EAA0BN,kBAA1B,CAAjB;AACA,cAAIQ,aAAapE,KAAKqE,iBAAL,CAAuBvD,QAAvB,CAAjB;;AAEA6C,iBAAOS,WACJE,GADI,CACAd,KAAKe,cAAL,CAAoBC,IAApB,CAAyBhB,IAAzB,CADA,EAEJiB,MAFI,CAEGjB,KAAKkB,mBAAL,CAAyBF,IAAzB,CAA8BhB,IAA9B,CAFH,EAEwC,IAFxC,CAAP;;AAIA,cAAIG,IAAJ,EAAU;AACR,kBAAMgB,UAAU,aAAGC,YAAH,CAAgBjB,IAAhB,EAAsB,EAAEkB,UAAU,MAAZ,EAAtB,CAAhB;AACA,mBAAO7E,KAAK8E,SAAL,CAAenB,IAAf,EAAqBgB,OAArB,EAA8B,MAAM;AACzCjB,mBAAK,EAAEqB,MAAMpB,IAAR,EAAL;AACA;AACD,aAHM,CAAP;AAID;AACF;;AAED,YAAI,CAACA,IAAL,EAAW;AACTD;AACA;AACD;AACF;AACF,KArCD;AAsCD;;AAEDgB,sBAAoBM,KAApB,EAA2BD,IAA3B,EAAiC;AAC/B;AACA,QAAIC,KAAJ,EAAW,OAAOA,KAAP;;AAEX,QAAI;AACF,YAAMC,OAAO,aAAGC,QAAH,CAAYH,IAAZ,CAAb;AACA,UAAI,CAACE,KAAKE,MAAL,EAAL,EAAoB,OAAO,IAAP;AACpB,aAAOJ,IAAP;AACD,KAJD,CAIE,OAAMK,CAAN,EAAS;AACT,aAAO,IAAP;AACD;AACF;;AAEDb,iBAAeZ,IAAf,EAAqB;AACnB;AACA;;AAEA;AACA,QAAI0B,QAAQC,QAAR,KAAqB,OAArB,IAAgC3B,KAAK,CAAL,MAAY,GAAhD,EAAqD;AACnDA,aAAOA,KAAK4B,KAAL,CAAW,CAAX,CAAP;AACD;;AAED;AACA,QAAI5B,KAAK,CAAL,MAAY,GAAhB,EAAqB;AACnB,YAAM6B,QAAQ7B,KAAK4B,KAAL,CAAW,CAAX,EAAcE,KAAd,CAAoB,eAAKC,GAAzB,CAAd;AACA,YAAMC,MAAMH,MAAMD,KAAN,CAAY,CAAZ,EAAe,CAAC,CAAhB,EAAmBK,IAAnB,CAAwB,eAAKF,GAA7B,CAAZ;AACA,YAAMhF,WAAW8E,MAAMK,OAAN,GAAgB,CAAhB,CAAjB;AACAlC,aAAO,eAAKQ,OAAL,CAAawB,GAAb,EAAkB,MAAMjF,QAAxB,CAAP;AACD;AACD,WAAOiD,IAAP;AACD;;AAEDmC,uBAAqB;AACnB;AACA;AACA;AACA,WAAO,OAAP;AACD;AA/NoD;kBAAlC7F,Y","file":"sass.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport toutSuite from 'toutsuite';\nimport detectiveSASS from 'detective-sass';\nimport detectiveSCSS from 'detective-scss';\nimport sassLookup from 'sass-lookup';\nimport {CompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/sass', 'text/scss'];\nlet sass = null;\n\n/**\n * @access private\n */\nexport default class SassCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      comments: true,\n      sourceMapEmbed: true,\n      sourceMapContents: true\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    // not a valid option\n    delete opts.paths;\n\n    let result = await new Promise((res,rej) => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          rej(new Error(r.formatted || r.message));\n          return;\n        }\n\n        res(r);\n        return;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = path.extname(filePath) === '.sass' ? detectiveSASS(sourceCode) : detectiveSCSS(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(sassLookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    let result;\n    toutSuite(() => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          throw new Error(r.formatted);\n        }\n        result = r;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getSass() {\n    let ret;\n    toutSuite(() => ret = require('sass.js/dist/sass.node').Sass);\n    return ret;\n  }\n\n  buildImporterCallback (includePaths) {\n    const self = this;\n    return (function (request, done) {\n      let file;\n      if (request.file) {\n        done();\n        return;\n      } else {\n        // sass.js works in the '/sass/' directory\n        let cleanedRequestPath = request.resolved.replace(/^\\/sass\\//, '');\n\n        // if we are importing from the entry file (stdin) the path is\n        // resolved with a leading '/'' -> remove it\n        if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') {\n          cleanedRequestPath = cleanedRequestPath.substring(1);\n        }\n\n        for (let includePath of includePaths) {\n          const filePath = path.resolve(includePath, cleanedRequestPath);\n          let variations = sass.getPathVariations(filePath);\n\n          file = variations\n            .map(self.fixWindowsPath.bind(self))\n            .reduce(self.importedFileReducer.bind(self), null);\n\n          if (file) {\n            const content = fs.readFileSync(file, { encoding: 'utf8' });\n            return sass.writeFile(file, content, () => {\n              done({ path: file });\n              return;\n            });\n          }\n        }\n\n        if (!file) {\n          done();\n          return;\n        }\n      }\n    });\n  }\n\n  importedFileReducer(found, path) {\n    // Find the first variation that actually exists\n    if (found) return found;\n\n    try {\n      const stat = fs.statSync(path);\n      if (!stat.isFile()) return null;\n      return path;\n    } catch(e) {\n      return null;\n    }\n  }\n\n  fixWindowsPath(file) {\n    // Unfortunately, there's a bug in sass.js that seems to ignore the different\n    // path separators across platforms\n\n    // For some reason, some files have a leading slash that we need to get rid of\n    if (process.platform === 'win32' && file[0] === '/') {\n      file = file.slice(1);\n    }\n\n    // Sass.js generates paths such as `_C:\\myPath\\file.sass` instead of `C:\\myPath\\_file.sass`\n    if (file[0] === '_') {\n      const parts = file.slice(1).split(path.sep);\n      const dir = parts.slice(0, -1).join(path.sep);\n      const fileName = parts.reverse()[0];\n      file = path.resolve(dir, '_' + fileName);\n    }\n    return file;\n  }\n\n  getCompilerVersion() {\n    // NB: There is a bizarre bug in the node module system where this doesn't\n    // work but only in saveConfiguration tests\n    //return require('@paulcbetts/node-sass/package.json').version;\n    return \"4.1.1\";\n  }\n}\n"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/sass.js"],"names":["mimeTypes","sass","SassCompiler","constructor","compilerOptions","comments","sourceMapEmbed","sourceMapContents","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getSass","thisPath","dirname","paths","Object","keys","push","unshift","importer","buildImporterCallback","opts","assign","indentedSyntax","match","sourceMapRoot","result","Promise","res","rej","r","status","Error","formatted","message","source","text","code","mimeType","shouldCompileFileSync","dependencyFilenames","extname","dependencies","dependencyName","basename","compileSync","ret","require","Sass","includePaths","self","request","done","file","importRequest","current","includePath","resolve","variations","getPathVariations","map","fixWindowsPath","bind","reduce","importedFileReducer","content","readFileSync","encoding","writeFile","path","found","stat","statSync","isFile","e","process","platform","slice","parts","split","sep","dir","join","reverse","getCompilerVersion"],"mappings":"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","file":"sass.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport toutSuite from 'toutsuite';\nimport detectiveSASS from 'detective-sass';\nimport detectiveSCSS from 'detective-scss';\nimport sassLookup from 'sass-lookup';\nimport {CompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/sass', 'text/scss'];\nlet sass = null;\n\n/**\n * @access private\n */\nexport default class SassCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      comments: true,\n      sourceMapEmbed: true,\n      sourceMapContents: true\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    // not a valid option\n    delete opts.paths;\n\n    let result = await new Promise((res,rej) => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          rej(new Error(r.formatted || r.message));\n          return;\n        }\n\n        res(r);\n        return;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = path.extname(filePath) === '.sass' ? detectiveSASS(sourceCode) : detectiveSCSS(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(sassLookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    let result;\n    toutSuite(() => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          throw new Error(r.formatted);\n        }\n        result = r;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getSass() {\n    let ret;\n    toutSuite(() => ret = require('sass.js/dist/sass.node').Sass);\n    return ret;\n  }\n\n  buildImporterCallback (includePaths) {\n    const self = this;\n    return (function (request, done) {\n      let file;\n      if (request.file) {\n        done();\n        return;\n      } else {\n        // treat as it\n        const importRequest = request.current;\n\n        for (let includePath of includePaths) {\n          const filePath = path.resolve(includePath, importRequest);\n          let variations = sass.getPathVariations(filePath);\n\n          file = variations\n            .map(self.fixWindowsPath.bind(self))\n            .reduce(self.importedFileReducer.bind(self), null);\n\n          if (file) {\n            const content = fs.readFileSync(file, { encoding: 'utf8' });\n            return sass.writeFile(file, content, () => {\n              done({ path: file });\n              return;\n            });\n          }\n        }\n\n        if (!file) {\n          done();\n          return;\n        }\n      }\n    });\n  }\n\n  importedFileReducer(found, path) {\n    // Find the first variation that actually exists\n    if (found) return found;\n\n    try {\n      const stat = fs.statSync(path);\n      if (!stat.isFile()) return null;\n      return path;\n    } catch(e) {\n      return null;\n    }\n  }\n\n  fixWindowsPath(file) {\n    // Unfortunately, there's a bug in sass.js that seems to ignore the different\n    // path separators across platforms\n\n    // For some reason, some files have a leading slash that we need to get rid of\n    if (process.platform === 'win32' && file[0] === '/') {\n      file = file.slice(1);\n    }\n\n    // Sass.js generates paths such as `_C:\\myPath\\file.sass` instead of `C:\\myPath\\_file.sass`\n    if (file[0] === '_') {\n      const parts = file.slice(1).split(path.sep);\n      const dir = parts.slice(0, -1).join(path.sep);\n      const fileName = parts.reverse()[0];\n      file = path.resolve(dir, '_' + fileName);\n    }\n    return file;\n  }\n\n  getCompilerVersion() {\n    // NB: There is a bizarre bug in the node module system where this doesn't\n    // work but only in saveConfiguration tests\n    //return require('@paulcbetts/node-sass/package.json').version;\n    return \"4.1.1\";\n  }\n}\n"]} \ No newline at end of file diff --git a/src/css/sass.js b/src/css/sass.js index 77e12f1..e565884 100644 --- a/src/css/sass.js +++ b/src/css/sass.js @@ -164,17 +164,11 @@ export default class SassCompiler extends CompilerBase { done(); return; } else { - // sass.js works in the '/sass/' directory - let cleanedRequestPath = request.resolved.replace(/^\/sass\//, ''); - - // if we are importing from the entry file (stdin) the path is - // resolved with a leading '/'' -> remove it - if (request.previous === 'stdin' && cleanedRequestPath.charAt(0) === '/') { - cleanedRequestPath = cleanedRequestPath.substring(1); - } + // treat as it + const importRequest = request.current; for (let includePath of includePaths) { - const filePath = path.resolve(includePath, cleanedRequestPath); + const filePath = path.resolve(includePath, importRequest); let variations = sass.getPathVariations(filePath); file = variations From dc0022cfb989bc057d6bdb26beb307033ef7c44a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=ABl=20Charles?= Date: Fri, 30 Jun 2017 16:08:28 +0200 Subject: [PATCH 8/8] Fix electron-compilers sass for both electron runtime and compile --- lib/css/sass.js | 18 ++++++++++++------ package.json | 2 +- src/css/sass.js | 16 +++++++++++----- 3 files changed, 24 insertions(+), 12 deletions(-) diff --git a/lib/css/sass.js b/lib/css/sass.js index a3ab9d2..7f20bc5 100644 --- a/lib/css/sass.js +++ b/lib/css/sass.js @@ -202,11 +202,8 @@ class SassCompiler extends _compilerBase.CompilerBase { done(); return; } else { - // treat as it - const importRequest = request.current; - - for (let includePath of includePaths) { - const filePath = _path2.default.resolve(includePath, importRequest); + const filePathGenerator = getFilepathsForVariation(includePaths, request); + for (let filePath of filePathGenerator) { let variations = sass.getPathVariations(filePath); file = variations.map(self.fixWindowsPath.bind(self)).reduce(self.importedFileReducer.bind(self), null); @@ -267,5 +264,14 @@ class SassCompiler extends _compilerBase.CompilerBase { return "4.1.1"; } } + exports.default = SassCompiler; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/sass.js"],"names":["mimeTypes","sass","SassCompiler","constructor","compilerOptions","comments","sourceMapEmbed","sourceMapContents","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getSass","thisPath","dirname","paths","Object","keys","push","unshift","importer","buildImporterCallback","opts","assign","indentedSyntax","match","sourceMapRoot","result","Promise","res","rej","r","status","Error","formatted","message","source","text","code","mimeType","shouldCompileFileSync","dependencyFilenames","extname","dependencies","dependencyName","basename","compileSync","ret","require","Sass","includePaths","self","request","done","file","importRequest","current","includePath","resolve","variations","getPathVariations","map","fixWindowsPath","bind","reduce","importedFileReducer","content","readFileSync","encoding","writeFile","path","found","stat","statSync","isFile","e","process","platform","slice","parts","split","sep","dir","join","reverse","getCompilerVersion"],"mappings":"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","file":"sass.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport toutSuite from 'toutsuite';\nimport detectiveSASS from 'detective-sass';\nimport detectiveSCSS from 'detective-scss';\nimport sassLookup from 'sass-lookup';\nimport {CompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/sass', 'text/scss'];\nlet sass = null;\n\n/**\n * @access private\n */\nexport default class SassCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      comments: true,\n      sourceMapEmbed: true,\n      sourceMapContents: true\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    // not a valid option\n    delete opts.paths;\n\n    let result = await new Promise((res,rej) => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          rej(new Error(r.formatted || r.message));\n          return;\n        }\n\n        res(r);\n        return;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = path.extname(filePath) === '.sass' ? detectiveSASS(sourceCode) : detectiveSCSS(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(sassLookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    let result;\n    toutSuite(() => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          throw new Error(r.formatted);\n        }\n        result = r;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getSass() {\n    let ret;\n    toutSuite(() => ret = require('sass.js/dist/sass.node').Sass);\n    return ret;\n  }\n\n  buildImporterCallback (includePaths) {\n    const self = this;\n    return (function (request, done) {\n      let file;\n      if (request.file) {\n        done();\n        return;\n      } else {\n        // treat as it\n        const importRequest = request.current;\n\n        for (let includePath of includePaths) {\n          const filePath = path.resolve(includePath, importRequest);\n          let variations = sass.getPathVariations(filePath);\n\n          file = variations\n            .map(self.fixWindowsPath.bind(self))\n            .reduce(self.importedFileReducer.bind(self), null);\n\n          if (file) {\n            const content = fs.readFileSync(file, { encoding: 'utf8' });\n            return sass.writeFile(file, content, () => {\n              done({ path: file });\n              return;\n            });\n          }\n        }\n\n        if (!file) {\n          done();\n          return;\n        }\n      }\n    });\n  }\n\n  importedFileReducer(found, path) {\n    // Find the first variation that actually exists\n    if (found) return found;\n\n    try {\n      const stat = fs.statSync(path);\n      if (!stat.isFile()) return null;\n      return path;\n    } catch(e) {\n      return null;\n    }\n  }\n\n  fixWindowsPath(file) {\n    // Unfortunately, there's a bug in sass.js that seems to ignore the different\n    // path separators across platforms\n\n    // For some reason, some files have a leading slash that we need to get rid of\n    if (process.platform === 'win32' && file[0] === '/') {\n      file = file.slice(1);\n    }\n\n    // Sass.js generates paths such as `_C:\\myPath\\file.sass` instead of `C:\\myPath\\_file.sass`\n    if (file[0] === '_') {\n      const parts = file.slice(1).split(path.sep);\n      const dir = parts.slice(0, -1).join(path.sep);\n      const fileName = parts.reverse()[0];\n      file = path.resolve(dir, '_' + fileName);\n    }\n    return file;\n  }\n\n  getCompilerVersion() {\n    // NB: There is a bizarre bug in the node module system where this doesn't\n    // work but only in saveConfiguration tests\n    //return require('@paulcbetts/node-sass/package.json').version;\n    return \"4.1.1\";\n  }\n}\n"]} \ No newline at end of file +function* getFilepathsForVariation(includePaths, request) { + const resolved = request.resolved.replace(/^\/sass\//, ''); + yield resolved; + const current = request.current; + for (let includePath of includePaths) { + yield _path2.default.resolve(includePath, current); + } +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/css/sass.js"],"names":["mimeTypes","sass","SassCompiler","constructor","compilerOptions","comments","sourceMapEmbed","sourceMapContents","seenFilePaths","getInputMimeTypes","shouldCompileFile","fileName","compilerContext","determineDependentFiles","sourceCode","filePath","determineDependentFilesSync","compile","getSass","thisPath","dirname","paths","Object","keys","push","unshift","importer","buildImporterCallback","opts","assign","indentedSyntax","match","sourceMapRoot","result","Promise","res","rej","r","status","Error","formatted","message","source","text","code","mimeType","shouldCompileFileSync","dependencyFilenames","extname","dependencies","dependencyName","basename","compileSync","ret","require","Sass","includePaths","self","request","done","file","filePathGenerator","getFilepathsForVariation","variations","getPathVariations","map","fixWindowsPath","bind","reduce","importedFileReducer","content","readFileSync","encoding","writeFile","path","found","stat","statSync","isFile","e","process","platform","slice","parts","split","sep","dir","join","reverse","resolve","getCompilerVersion","resolved","replace","current","includePath"],"mappings":"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","file":"sass.js","sourcesContent":["import path from 'path';\nimport fs from 'fs';\nimport toutSuite from 'toutsuite';\nimport detectiveSASS from 'detective-sass';\nimport detectiveSCSS from 'detective-scss';\nimport sassLookup from 'sass-lookup';\nimport {CompilerBase} from '../compiler-base';\n\nconst mimeTypes = ['text/sass', 'text/scss'];\nlet sass = null;\n\n/**\n * @access private\n */\nexport default class SassCompiler extends CompilerBase {\n  constructor() {\n    super();\n\n    this.compilerOptions = {\n      comments: true,\n      sourceMapEmbed: true,\n      sourceMapContents: true\n    };\n\n    this.seenFilePaths = {};\n  }\n\n  static getInputMimeTypes() {\n    return mimeTypes;\n  }\n\n  async shouldCompileFile(fileName, compilerContext) {\n    return true;\n  }\n\n  async determineDependentFiles(sourceCode, filePath, compilerContext) {\n    return this.determineDependentFilesSync(sourceCode, filePath, compilerContext);\n  }\n\n  async compile(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    // not a valid option\n    delete opts.paths;\n\n    let result = await new Promise((res,rej) => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          rej(new Error(r.formatted || r.message));\n          return;\n        }\n\n        res(r);\n        return;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  shouldCompileFileSync(fileName, compilerContext) {\n    return true;\n  }\n\n  determineDependentFilesSync(sourceCode, filePath, compilerContext) {\n    let dependencyFilenames = path.extname(filePath) === '.sass' ? detectiveSASS(sourceCode) : detectiveSCSS(sourceCode);\n    let dependencies = [];\n\n    for (let dependencyName of dependencyFilenames) {\n      dependencies.push(sassLookup(dependencyName, path.basename(filePath), path.dirname(filePath)));\n    }\n\n    return dependencies;\n  }\n\n  compileSync(sourceCode, filePath, compilerContext) {\n    sass = sass || this.getSass();\n\n    let thisPath = path.dirname(filePath);\n    this.seenFilePaths[thisPath] = true;\n\n    let paths = Object.keys(this.seenFilePaths);\n\n    if (this.compilerOptions.paths) {\n      paths.push(...this.compilerOptions.paths);\n    }\n\n    paths.unshift('.');\n    sass.importer(this.buildImporterCallback(paths));\n\n    let opts = Object.assign({}, this.compilerOptions, {\n      indentedSyntax: filePath.match(/\\.sass$/i),\n      sourceMapRoot: filePath,\n    });\n\n    let result;\n    toutSuite(() => {\n      sass.compile(sourceCode, opts, (r) => {\n        if (r.status !== 0) {\n          throw new Error(r.formatted);\n        }\n        result = r;\n      });\n    });\n\n    let source = result.text;\n\n    // NB: If you compile a file that is solely imports, its\n    // actual content is '' yet it is a valid file. '' is not\n    // truthy, so we're going to replace it with a string that\n    // is truthy.\n    if (!source) {\n      source = ' ';\n    }\n\n    return {\n      code: source,\n      mimeType: 'text/css'\n    };\n  }\n\n  getSass() {\n    let ret;\n    toutSuite(() => ret = require('sass.js/dist/sass.node').Sass);\n    return ret;\n  }\n\n  buildImporterCallback (includePaths) {\n    const self = this;\n    return (function (request, done) {\n      let file;\n      if (request.file) {\n        done();\n        return;\n      } else {\n        const filePathGenerator = getFilepathsForVariation(includePaths, request);\n        for (let filePath of filePathGenerator) {\n          let variations = sass.getPathVariations(filePath);\n\n          file = variations\n            .map(self.fixWindowsPath.bind(self))\n            .reduce(self.importedFileReducer.bind(self), null);\n\n          if (file) {\n            const content = fs.readFileSync(file, { encoding: 'utf8' });\n            return sass.writeFile(file, content, () => {\n              done({ path: file });\n              return;\n            });\n          }\n        }\n\n        if (!file) {\n          done();\n          return;\n        }\n      }\n    });\n  }\n\n  importedFileReducer(found, path) {\n    // Find the first variation that actually exists\n    if (found) return found;\n\n    try {\n      const stat = fs.statSync(path);\n      if (!stat.isFile()) return null;\n      return path;\n    } catch(e) {\n      return null;\n    }\n  }\n\n  fixWindowsPath(file) {\n    // Unfortunately, there's a bug in sass.js that seems to ignore the different\n    // path separators across platforms\n\n    // For some reason, some files have a leading slash that we need to get rid of\n    if (process.platform === 'win32' && file[0] === '/') {\n      file = file.slice(1);\n    }\n\n    // Sass.js generates paths such as `_C:\\myPath\\file.sass` instead of `C:\\myPath\\_file.sass`\n    if (file[0] === '_') {\n      const parts = file.slice(1).split(path.sep);\n      const dir = parts.slice(0, -1).join(path.sep);\n      const fileName = parts.reverse()[0];\n      file = path.resolve(dir, '_' + fileName);\n    }\n    return file;\n  }\n\n  getCompilerVersion() {\n    // NB: There is a bizarre bug in the node module system where this doesn't\n    // work but only in saveConfiguration tests\n    //return require('@paulcbetts/node-sass/package.json').version;\n    return \"4.1.1\";\n  }\n}\n\nfunction *getFilepathsForVariation(includePaths, request) {\n  const resolved = request.resolved.replace(/^\\/sass\\//, '');\n  yield resolved;\n  const current = request.current;\n  for (let includePath of includePaths) {\n    yield path.resolve(includePath, current);\n  }\n}\n"]} \ No newline at end of file diff --git a/package.json b/package.json index b1db09e..82b3b20 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "electron-compilers", - "version": "5.10.0", + "version": "5.10.1", "description": "Compiler implementations for electron-compile", "main": "lib/main.js", "scripts": { diff --git a/src/css/sass.js b/src/css/sass.js index e565884..31fc2ce 100644 --- a/src/css/sass.js +++ b/src/css/sass.js @@ -164,11 +164,8 @@ export default class SassCompiler extends CompilerBase { done(); return; } else { - // treat as it - const importRequest = request.current; - - for (let includePath of includePaths) { - const filePath = path.resolve(includePath, importRequest); + const filePathGenerator = getFilepathsForVariation(includePaths, request); + for (let filePath of filePathGenerator) { let variations = sass.getPathVariations(filePath); file = variations @@ -231,3 +228,12 @@ export default class SassCompiler extends CompilerBase { return "4.1.1"; } } + +function *getFilepathsForVariation(includePaths, request) { + const resolved = request.resolved.replace(/^\/sass\//, ''); + yield resolved; + const current = request.current; + for (let includePath of includePaths) { + yield path.resolve(includePath, current); + } +}